Context Navigation

Back to Ticket #4747

Ticket #4747: mdb.patch

File mdb.patch, 203.1 KB (added by ben <ben.fordnz@…>, 17 years ago)
Full Patch -r4189:5589

django/test/utils.py

=== django/test/utils.py
==================================================================

 import sys, time
 from django.conf import settings
+from django.db import connection, backend, get_creation_module
+from django.db import connection, transaction, backend, \
+                connection_info, connections, get_creation_module
 from django.core import management, mail
 from django.core import management, mail
 from django.dispatch import dispatcher
 …
 TEST_DATABASE_PREFIX = 'test_'
 def instrumented_test_render(self, context):
-    """An instrumented Template render method, providing a signal
-    that can be intercepted by the test system Client
     """
+    An instrumented Template render method, providing a signal that can be
+    intercepted by the test system Client.
+    """
     dispatcher.send(signal=signals.template_rendered, sender=self, template=self, context=context)
     return self.nodelist.render(context)
+def instrumented_test_iter_render(self, context):
+    """
+    An instrumented Template iter_render method, providing a signal that can be
+    intercepted by the test system Client.
+    """
+    for chunk in self.nodelist.iter_render(context):
+        yield chunk
+    dispatcher.send(signal=signals.template_rendered, sender=self, template=self, context=context)
 class TestSMTPConnection(object):
     """A substitute SMTP connection for use during test sessions.
 …
     """
     Template.original_render = Template.render
+    Template.original_iter_render = Template.iter_render
     Template.render = instrumented_test_render
+    Template.iter_render = instrumented_test_render
     mail.original_SMTPConnection = mail.SMTPConnection
     mail.SMTPConnection = TestSMTPConnection
 …
     """
     Template.render = Template.original_render
+    del Template.original_render
+    Template.iter_render = Template.original_iter_render
+    del Template.original_render, Template.original_iter_render
     mail.SMTPConnection = mail.original_SMTPConnection
     del mail.original_SMTPConnection
 …
         connection.connection.autocommit(True)
     elif hasattr(connection.connection, "set_isolation_level"):
         connection.connection.set_isolation_level(0)
 def get_mysql_create_suffix():
     suffix = []
     if settings.TEST_DATABASE_CHARSET:
 …
     if verbosity >= 1:
         print "Creating test database..."
     # If we're using SQLite, it's more convenient to test against an
     # in-memory database.
     if settings.DATABASE_ENGINE == "sqlite3":
+        TEST_DATABASE_NAME = ":memory:"
+        TEST_DATABASE_NAME = "/home/ben/test.db" #":memory:"
+        if verbosity >= 2:
+            print "Using in-memory sqlite database for testing"
     else:
         suffix = {
             'postgresql': get_postgresql_create_suffix,
 …
             TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME
         else:
             TEST_DATABASE_NAME = TEST_DATABASE_PREFIX + settings.DATABASE_NAME
+        qn = backend.quote_name
         # Create the test database and connect to it. We need to autocommit
         # if the database supports it because PostgreSQL doesn't allow
         # CREATE/DROP DATABASE statements within transactions.
         cursor = connection.cursor()
         _set_autocommit(connection)
         try:
             cursor.execute("CREATE DATABASE %s %s" % (backend.quote_name(TEST_DATABASE_NAME), suffix))
+            cursor.execute("CREATE DATABASE %s %s" % (qn(TEST_DATABASE_NAME), suffix))
         except Exception, e:
             sys.stderr.write("Got an error creating the test database: %s\n" % e)
             if not autoclobber:
 …
                 try:
                     if verbosity >= 1:
                         print "Destroying old test database..."
                     cursor.execute("DROP DATABASE %s" % backend.quote_name(TEST_DATABASE_NAME))
+                    cursor.execute("DROP DATABASE %s" % qn(TEST_DATABASE_NAME))
                     if verbosity >= 1:
                         print "Creating test database..."
                     cursor.execute("CREATE DATABASE %s %s" % (backend.quote_name(TEST_DATABASE_NAME), suffix))
+                    cursor.execute("CREATE DATABASE %s %s" % (qn(TEST_DATABASE_NAME), suffix))
                 except Exception, e:
                     sys.stderr.write("Got an error recreating the test database: %s\n" % e)
                     sys.exit(2)
 …
     # the side effect of initializing the test database.
     cursor = connection.cursor()
+def destroy_test_db(old_database_name, verbosity=1):
+    # Fill OTHER_DATABASES with the TEST_DATABASES settings,
+    # and connect each named connection to the test database.
+    test_databases = {}
+    for db_name in settings.TEST_DATABASES:
+        db_st = {'DATABASE_NAME': TEST_DATABASE_NAME}
+        if db_name in settings.TEST_DATABASE_MODELS:
+            db_st['MODELS'] = settings.TEST_DATABASE_MODELS.get(db_name, [])
+        test_databases[db_name] = db_st
+    settings.OTHER_DATABASES = test_databases
+def destroy_test_db(old_database_name, old_databases, verbosity=1):
     # If the database wants to drop the test DB itself, let it
     creation_module = get_creation_module()
     if hasattr(creation_module, "destroy_test_db"):
         creation_module.destroy_test_db(settings, connection, backend, old_database_name, verbosity)
         return
     # Unless we're using SQLite, remove the test database to clean up after
     # ourselves. Connect to the previous database (not the test database)
     # to do so, because it's not allowed to delete a database while being
     # connected to it.
     if verbosity >= 1:
         print "Destroying test database..."
     connection.close()
+    for cnx in connections.keys():
+        connections[cnx].close()
+    connections.reset()
     TEST_DATABASE_NAME = settings.DATABASE_NAME
+    if verbosity >= 2:
+        print "Closed connections to %s" % TEST_DATABASE_NAME
     settings.DATABASE_NAME = old_database_name
     if settings.DATABASE_ENGINE != "sqlite3":
+        settings.OTHER_DATABASES = old_databases
+        for cnx in connections.keys():
+            try:
+                connections[cnx].connection.cursor()
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except:
+                pass
         cursor = connection.cursor()
         _set_autocommit(connection)
         time.sleep(1) # To avoid "database is being accessed by other users" errors.

django/http/init.py

=== django/http/__init__.py
==================================================================

         content = ''.join(self._container)
         if isinstance(content, unicode):
             content = content.encode(self._charset)
+        # If self._container was an iterator, we have just exhausted it, so we
+        # need to save the results for anything else that needs access
+        if not self._is_string:
+            self._container = [content]
+            self._is_string = True
         return content
     def _set_content(self, value):
 …
     content = property(_get_content, _set_content)
     def __iter__(self):
+        self._iterator = self._container.__iter__()
+        return self
+        for chunk in self._container:
+            if isinstance(chunk, unicode):
+                chunk = chunk.encode(self._charset)
+            yield chunk
-    def next(self):
-        chunk = self._iterator.next()
-        if isinstance(chunk, unicode):
-            chunk = chunk.encode(self._charset)
-        return chunk
     def close(self):
         if hasattr(self._container, 'close'):
             self._container.close()

django/oldforms/init.py

=== django/oldforms/__init__.py
==================================================================

         return data
     html2python = staticmethod(html2python)
+    def iter_render(self, data):
+        # this even needed?
+        return (self.render(data),)
     def render(self, data):
         raise NotImplementedError

django/db/models/base.py

=== django/db/models/base.py
==================================================================

 from django.db.models.fields.related import OneToOneRel, ManyToOneRel
 from django.db.models.query import delete_objects
 from django.db.models.options import Options, AdminOptions
 from django.db import connection, backend, transaction
+from django.db import transaction
 from django.db.models import signals
 from django.db.models.loading import register_models, get_model
 from django.dispatch import dispatcher
 …
     "Metaclass for all models"
     def __new__(cls, name, bases, attrs):
         # If this isn't a subclass of Model, don't do anything special.
+        print "\n\n" + "*"*40
+        print "ModelBase Called with name: %s and attrs:" % name
+        print "\n".join(["%s => %s" % (k,v) for k, v in attrs.items()])
         try:
             if not filter(lambda b: issubclass(b, Model), bases):
                 return super(ModelBase, cls).__new__(cls, name, bases, attrs)
 …
     def save(self):
         dispatcher.send(signal=signals.pre_save, sender=self.__class__, instance=self)
+        db = self.__class__._default_manager.db
+        connection = db.connection
+        backend = db.backend
+        qn = backend.quote_name
         non_pks = [f for f in self._meta.fields if not f.primary_key]
         cursor = connection.cursor()
 …
         if pk_set:
             # Determine whether a record with the primary key already exists.
             cursor.execute("SELECT COUNT(*) FROM %s WHERE %s=%%s" % \
                 (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)),
+                (qn(self._meta.db_table), qn(self._meta.pk.column)),
                 self._meta.pk.get_db_prep_lookup('exact', pk_val))
             # If it does already exist, do an UPDATE.
             if cursor.fetchone()[0] > 0:
                 db_values = [f.get_db_prep_save(f.pre_save(self, False)) for f in non_pks]
                 if db_values:
                     cursor.execute("UPDATE %s SET %s WHERE %s=%%s" % \
                         (backend.quote_name(self._meta.db_table),
                         ','.join(['%s=%%s' % backend.quote_name(f.column) for f in non_pks]),
                         backend.quote_name(self._meta.pk.column)),
+                        (qn(self._meta.db_table),
+                        ','.join(['%s=%%s' % qn(f.column) for f in non_pks]),
+                        qn(self._meta.pk.column)),
                         db_values + self._meta.pk.get_db_prep_lookup('exact', pk_val))
             else:
                 record_exists = False
         if not pk_set or not record_exists:
             field_names = [backend.quote_name(f.column) for f in self._meta.fields if not isinstance(f, AutoField)]
+            field_names = [qn(f.column) for f in self._meta.fields if not isinstance(f, AutoField)]
             db_values = [f.get_db_prep_save(f.pre_save(self, True)) for f in self._meta.fields if not isinstance(f, AutoField)]
             # If the PK has been manually set, respect that.
             if pk_set:
 …
                 db_values += [f.get_db_prep_save(f.pre_save(self, True)) for f in self._meta.fields if isinstance(f, AutoField)]
             placeholders = ['%s'] * len(field_names)
             if self._meta.order_with_respect_to:
                 field_names.append(backend.quote_name('_order'))
+                field_names.append(qn('_order'))
                 # TODO: This assumes the database supports subqueries.
                 placeholders.append('(SELECT COUNT(*) FROM %s WHERE %s = %%s)' % \
                     (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.order_with_respect_to.column)))
+                    (qn(self._meta.db_table), qn(self._meta.order_with_respect_to.column)))
                 db_values.append(getattr(self, self._meta.order_with_respect_to.attname))
             if db_values:
                 cursor.execute("INSERT INTO %s (%s) VALUES (%s)" % \
                     (backend.quote_name(self._meta.db_table), ','.join(field_names),
+                    (qn(self._meta.db_table), ','.join(field_names),
                     ','.join(placeholders)), db_values)
             else:
                 # Create a new record with defaults for everything.
                 cursor.execute("INSERT INTO %s (%s) VALUES (%s)" %
                     (backend.quote_name(self._meta.db_table),
                      backend.quote_name(self._meta.pk.column),
+                    (qn(self._meta.db_table),
+                     qn(self._meta.pk.column),
                      backend.get_pk_default_value()))
             if self._meta.has_auto_field and not pk_set:
                 setattr(self, self._meta.pk.attname, backend.get_last_insert_id(cursor, self._meta.db_table, self._meta.pk.column))
         transaction.commit_unless_managed()
+        transaction.commit_unless_managed([connection])
         # Run any post-save hooks.
         dispatcher.send(signal=signals.post_save, sender=self.__class__, instance=self)
 …
         return dict(field.choices).get(value, value)
     def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
+        qn = self._default_manager.db.backend.quote_name
         op = is_next and '>' or '<'
         where = '(%s %s %%s OR (%s = %%s AND %s.%s %s %%s))' % \
             (backend.quote_name(field.column), op, backend.quote_name(field.column),
             backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column), op)
+            (qn(field.column), op, qn(field.column),
+            qn(self._meta.db_table), qn(self._meta.pk.column), op)
         param = str(getattr(self, field.attname))
         q = self.__class__._default_manager.filter(**kwargs).order_by((not is_next and '-' or '') + field.name, (not is_next and '-' or '') + self._meta.pk.name)
         q._where.append(where)
 …
             raise self.DoesNotExist, "%s matching query does not exist." % self.__class__._meta.object_name
     def _get_next_or_previous_in_order(self, is_next):
+        qn = self._default_manager.db.backend.quote_name
         cachename = "__%s_order_cache" % is_next
         if not hasattr(self, cachename):
             op = is_next and '>' or '<'
             order_field = self._meta.order_with_respect_to
             where = ['%s %s (SELECT %s FROM %s WHERE %s=%%s)' % \
                 (backend.quote_name('_order'), op, backend.quote_name('_order'),
                 backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)),
                 '%s=%%s' % backend.quote_name(order_field.column)]
+                (qn('_order'), op, qn('_order'),
+                qn(self._meta.db_table), qn(self._meta.pk.column)),
+                '%s=%%s' % qn(order_field.column)]
             params = [self._get_pk_val(), getattr(self, order_field.attname)]
             obj = self._default_manager.order_by('_order').extra(where=where, params=params)[:1].get()
             setattr(self, cachename, obj)
 …
 # ORDERING METHODS #########################
 def method_set_order(ordered_obj, self, id_list):
+    db = ordered_obj._default_manager.db
+    connection = db.connection
+    qn = db.backend.quote_name
     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" % \
         (backend.quote_name(ordered_obj._meta.db_table), backend.quote_name('_order'),
         backend.quote_name(ordered_obj._meta.order_with_respect_to.column),
         backend.quote_name(ordered_obj._meta.pk.column))
+        (qn(ordered_obj._meta.db_table), qn('_order'),
+        qn(ordered_obj._meta.order_with_respect_to.column),
+        qn(ordered_obj._meta.pk.column))
     rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name)
     cursor.executemany(sql, [(i, rel_val, j) for i, j in enumerate(id_list)])
     transaction.commit_unless_managed()
+    transaction.commit_unless_managed([connection])
 def method_get_order(ordered_obj, self):
+    db = ordered_obj._default_manager.db
+    connection = db.connection
+    qn = db.backend.quote_name
     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" % \
         (backend.quote_name(ordered_obj._meta.pk.column),
         backend.quote_name(ordered_obj._meta.db_table),
         backend.quote_name(ordered_obj._meta.order_with_respect_to.column),
         backend.quote_name('_order'))
+        (qn(ordered_obj._meta.pk.column),
+        qn(ordered_obj._meta.db_table),
+        qn(ordered_obj._meta.order_with_respect_to.column),
+        qn('_order'))
     rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name)
     cursor.execute(sql, [rel_val])
     return [r[0] for r in cursor.fetchall()]

django/db/models/manager.py

=== django/db/models/manager.py
==================================================================

+from django.db import ConnectionInfoDescriptor
 from django.db.models.query import QuerySet, EmptyQuerySet
 from django.dispatch import dispatcher
 from django.db.models import signals
+from django.db.models import signals, get_apps, get_models
 from django.db.models.fields import FieldDoesNotExist
+try:
+    # Only exists in Python 2.4+
+    from threading import local
+except ImportError:
+    # Import copy of _thread_local.py from Python 2.4
+    from django.utils._threading_local import local
 # Size of each "chunk" for get_iterator calls.
 # Larger values are slightly faster at the expense of more storage space.
 GET_ITERATOR_CHUNK_SIZE = 100
 …
         except FieldDoesNotExist:
             pass
         cls.add_to_class('objects', Manager())
+    elif cls._default_manager.model != cls:
+        # cls is an inherited model; don't want the parent manager
+        cls.add_to_class('objects', Manager())
 dispatcher.connect(ensure_default_manager, signal=signals.class_prepared)
 class Manager(object):
     # Tracks each time a Manager instance is created. Used to retain order.
     creation_counter = 0
+    db = ConnectionInfoDescriptor()
     def __init__(self):
         super(Manager, self).__init__()
         # Increase the creation counter, and save our local copy.
 …
         # TODO: Use weakref because of possible memory leak / circular reference.
         self.model = model
         setattr(model, name, ManagerDescriptor(self))
+        if not hasattr(model, '_default_manager') or self.creation_counter < model._default_manager.creation_counter:
+        if not hasattr(model, '_default_manager') \
+            or self.creation_counter < model._default_manager.creation_counter \
+            or model._default_manager.model != model:
             model._default_manager = self
     #######################
     # PROXIES TO QUERYSET #
     #######################
 …
     def values(self, *args, **kwargs):
         return self.get_query_set().values(*args, **kwargs)
+    #######################
+    # SCHEMA MANIPULATION #
+    #######################
+    def install(self, initial_data=False, pending=None):
+        """Install my model's table, indexes and (if requested) initial data.
+        Returns a dict of pending statements, keyed by the model that
+        needs to be created before the statements can be executed.
+        (Pending statements are those that could not yet be executed,
+        such as foreign key constraints for tables that don't exist at
+        install time.)
+        """
+        if pending is None:
+            pending = {}
+        builder = self.db.get_creation_module().builder
+        run, pending = builder.get_create_table(self.model, pending=pending)
+        run += builder.get_create_indexes(self.model)
+        many_many = builder.get_create_many_to_many(self.model)
+        for statement in run:
+            statement.execute()
+        for klass, statements in many_many.items():
+            if klass in builder.models_already_seen:
+                for statement in statements:
+                    statement.execute()
+            else:
+                pending.setdefault(klass, []).extend(statements)
+        if initial_data:
+            self.load_initial_data()
+        return pending
+    def get_pending(self, rel_class, f):
+        """Get list pending statement relating my model to rel_class via
+        field f
+        """
+        builder = self.db.get_creation_module().builder
+        return builder.get_ref_sql(self.model, rel_class, f)
+    def load_initial_data(self):
+        """Install initial data for model in db, Returns statements executed.
+        """
+        builder = self.db.get_creation_module().builder
+        statements = builder.get_initialdata(self.model)
+        for statement in statements:
+            statement.execute()
+        return statements
+    def get_installed_models(self, table_list):
+        """Get list of models installed, given a list of tables.
+        """
+        all_models = []
+        for app in get_apps():
+            for model in get_models(app):
+                all_models.append(model)
+        return set([m for m in all_models
+                    if m._meta.db_table in table_list])
+    def get_table_list(self):
+        """Get list of tables accessible via my model's connection.
+        """
+        builder = self.db.get_creation_module().builder
+        return builder.get_table_list(self.db)
 class ManagerDescriptor(object):
     # This class ensures managers aren't accessible via model instances.
     # For example, Poll.objects works, but poll_obj.objects raises AttributeError.
 …
         if instance != None:
             raise AttributeError, "Manager isn't accessible via %s instances" % type.__name__
         return self.manager

django/db/models/options.py

=== django/db/models/options.py
==================================================================

 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
 …
 from django.db.models import Manager
 from bisect import bisect
 import re
+import weakref
 # 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()
 …
             self.db_table = truncate_name(self.db_table,
                                           backend.get_max_name_length())
+        # Keep a weakref to my model, for access to managers and such
+        self._model = weakref.ref(model)
     def add_field(self, field):
         # Insert the given field in the order in which it was created, using
         # the "creation_counter" attribute of the field.
 …
                 return f
         raise FieldDoesNotExist, '%s has no field named %r' % (self.object_name, name)
+    def get_default_manager(self):
+        model = self._model()
+        if model is None:
+            raise ReferenceError("Model no longer available in %s" % self)
+        return model._default_manager
     def get_order_sql(self, table_prefix=''):
         "Returns the full 'ORDER BY' clause for this object, according to self.ordering."
         if not self.ordering: return ''

django/db/models/loading.py

=== django/db/models/loading.py
==================================================================

 _app_models = {} # Dictionary of models against app label
                  # Each value is a dictionary of model name: model class
                  # Applabel and Model entry exists in cache when individual model is loaded.
+_app_model_order = {} # Dictionary of models against app label
+                      # Each value is a list of model names, in the order in
+                      # which the models were created
 _app_errors = {} # Dictionary of errors that were experienced when loading the INSTALLED_APPS
                  # Key is the app_name of the model, value is the exception that was raised
                  # during model loading.
 …
     get_apps() # Run get_apps() to populate the _app_list cache. Slightly hackish.
     return _app_errors
 def get_models(app_mod=None):
+def get_models(app_mod=None, creation_order=False):
     """
     Given a module containing models, returns a list of the models. Otherwise
     returns a list of all installed models.
     """
     app_list = get_apps() # Run get_apps() to populate the _app_list cache. Slightly hackish.
     if app_mod:
+        return _app_models.get(app_mod.__name__.split('.')[-2], {}).values()
+        app_label = app_mod.__name__.split('.')[-2]
+        app_models = _app_models.get(app_label, {})
+        if creation_order:
+            return [ app_models[name]
+                     for name in _app_model_order.get(app_label, []) ]
+        return app_models.values()
     else:
         model_list = []
         for app_mod in app_list:

django/db/models/fields/init.py

=== django/db/models/fields/__init__.py
==================================================================

                 except ValueError:
                     raise validators.ValidationError, gettext('Enter a valid date/time in YYYY-MM-DD HH:MM format.')
     def get_db_prep_save(self, value):
         # Casts dates into string format for entry into database.
+    def pre_save(self, model_instance, add):
+        value = super(DateField, self).pre_save(model_instance, add)
         if value is not None:
             # MySQL will throw a warning if microseconds are given, because it
             # doesn't support microseconds.
+            settings = model_instance._default_manager.db.connection.settings
             if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'):
                 value = value.replace(microsecond=0)
+        return value
+    def get_db_prep_save(self, value):
+        # Casts dates into string format for entry into database.
+        if value is not None:
             value = str(value)
         return Field.get_db_prep_save(self, value)
 …
         if value is not None:
             # MySQL will throw a warning if microseconds are given, because it
             # doesn't support microseconds.
+            settings = model_instance._default_manager.db.connection.settings
             if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'):
                 value = value.replace(microsecond=0)
             if settings.DATABASE_ENGINE == 'oracle':

django/db/models/fields/related.py

=== django/db/models/fields/related.py
==================================================================

 from django.db import backend, transaction
+from django.db import transaction
 from django.db.models import signals, get_model
 from django.db.models.fields import AutoField, Field, IntegerField, get_ul_class
 from django.db.models.related import RelatedObject
 …
             # source_col_name: the PK colname in join_table for the source object
             # target_col_name: the PK colname in join_table for the target object
             # *objs - objects to add. Either object instances, or primary keys of object instances.
             from django.db import connection
+            connection = self.model._default_manager.db.connection
             # If there aren't any objects, there is nothing to do.
             if objs:
 …
                     cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
                         (self.join_table, source_col_name, target_col_name),
                         [self._pk_val, obj_id])
                 transaction.commit_unless_managed()
+            transaction.commit_unless_managed(connection)
         def _remove_items(self, source_col_name, target_col_name, *objs):
             # source_col_name: the PK colname in join_table for the source object
             # target_col_name: the PK colname in join_table for the target object
             # *objs - objects to remove
             from django.db import connection
+            connection = self.model._default_manager.db.connection
             # If there aren't any objects, there is nothing to do.
             if objs:
 …
                     (self.join_table, source_col_name,
                     target_col_name, ",".join(['%s'] * len(old_ids))),
                     [self._pk_val] + list(old_ids))
                 transaction.commit_unless_managed()
+            transaction.commit_unless_managed(connection)
         def _clear_items(self, source_col_name):
             # source_col_name: the PK colname in join_table for the source object
             from django.db import connection
+            connection = self.model._default_manager.db.connection
             cursor = connection.cursor()
             cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
                 (self.join_table, source_col_name),
                 [self._pk_val])
             transaction.commit_unless_managed()
+            transaction.commit_unless_managed(connection)
     return ManyRelatedManager
 …
         superclass = rel_model._default_manager.__class__
         RelatedManager = create_many_related_manager(superclass)
         qn = backend.quote_name
+        qn = rel_model._default_manager.db.backend.quote_name
         manager = RelatedManager(
             model=rel_model,
             core_filters={'%s__pk' % self.related.field.name: instance._get_pk_val()},
 …
         superclass = rel_model._default_manager.__class__
         RelatedManager = create_many_related_manager(superclass)
         qn = backend.quote_name
+        qn = rel_model._default_manager.db.backend.quote_name
         manager = RelatedManager(
             model=rel_model,
             core_filters={'%s__pk' % self.field.related_query_name(): instance._get_pk_val()},

django/db/models/query.py

=== django/db/models/query.py
==================================================================

         # self._select is a dictionary, and dictionaries' key order is
         # undefined, so we convert it to a list of tuples.
         extra_select = self._select.items()
+        cursor = connection.cursor()
+        cursor = self.model._default_manager.db.connection.cursor()
         cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params)
         fill_cache = self._select_related
 …
         """
         if self._result_cache is not None:
             return len(self._result_cache)
+        #from multi-db
+        db = self.model._default_manager.db
+        backend = db.backend
+        connection = db.connection
         counter = self._clone()
         counter._order_by = ()
         counter._select_related = False
 …
         Returns a dictionary mapping each of the given IDs to the object with
         that ID.
         """
+        backend = self.model._default_manager.db.backend
         assert self._limit is None and self._offset is None, \
                 "Cannot use 'limit' or 'offset' with in_bulk"
         assert isinstance(id_list, (tuple,  list)), "in_bulk() must be provided with a list of IDs."
 …
     def _get_sql_clause(self):
         opts = self.model._meta
+        backend = self.model._default_manager.db.backend
+        qn = backend.quote_name
         # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z.
+        select = ["%s.%s" % (backend.quote_name(opts.db_table), backend.quote_name(f.column)) for f in opts.fields]
+        select = ["%s.%s" % (qn(opts.db_table), qn(f.column))
+                  for f in opts.fields]
         tables = [quote_only_if_word(t) for t in self._tables]
         joins = SortedDict()
         where = self._where[:]
 …
         # Add any additional SELECTs.
         if self._select:
+            select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), backend.quote_name(s[0])) for s in self._select.items()])
+            select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), qn(s[0]))
+                           for s in self._select.items()])
         # Start composing the body of the SQL statement.
         sql = [" FROM", backend.quote_name(opts.db_table)]
+        sql = [" FROM", qn(opts.db_table)]
         # Compose the join dictionary into SQL describing the joins.
         if joins:
 …
                     order = "ASC"
                 if "." in col_name:
                     table_prefix, col_name = col_name.split('.', 1)
                     table_prefix = backend.quote_name(table_prefix) + '.'
+                    table_prefix = qn(table_prefix) + '.'
                 else:
                     # Use the database table as a column prefix if it wasn't given,
                     # and if the requested column isn't a custom SELECT.
                     if "." not in col_name and col_name not in (self._select or ()):
                         table_prefix = backend.quote_name(opts.db_table) + '.'
+                        table_prefix = qn(opts.db_table) + '.'
                     else:
                         table_prefix = ''
                 order_by.append('%s%s %s' % (table_prefix, backend.quote_name(orderfield2column(col_name, opts)), order))
+                order_by.append('%s%s %s' % (table_prefix, qn(orderfield2column(col_name, opts)), order))
         if order_by:
             sql.append("ORDER BY " + ", ".join(order_by))
 …
         columns = [f.column for f in fields]
         select = ['%s.%s' % (backend.quote_name(self.model._meta.db_table), backend.quote_name(c)) for c in columns]
+        #from multi-db
+        db = self.model._default_manager.db
+        backend = db.backend
+        qn = backend.quote_name
+        connection = db.connection
         # Add any additional SELECTs.
         if self._select:
             select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), backend.quote_name(s[0])) for s in self._select.items()])
         cursor = connection.cursor()
+        select = ['%s.%s' % (qn(self.model._meta.db_table), qn(c))
+                  for c in columns]
         cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params)
         has_resolve_columns = hasattr(self, 'resolve_columns')
 …
     def iterator(self):
         from django.db.backends.util import typecast_timestamp
         from django.db.models.fields import DateTimeField
+        db = self.model._default_manager.db
+        backend = db.backend
+        qn = backend.quote_name
+        connection = db.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' % \
+                (backend.quote_name(self.model._meta.db_table), backend.quote_name(self._field.column)))
+                (qn(self.model._meta.db_table), qn(self._field.column)))
         try:
             select, sql, params = self._get_sql_clause()
         except EmptyResultSet:
             raise StopIteration
         table_name = backend.quote_name(self.model._meta.db_table)
         field_name = backend.quote_name(self._field.column)
+        table_name = qn(self.model._meta.db_table)
+        field_name = qn(self._field.column)
         if backend.allows_group_by_ordinal:
             group_by = '1'
 …
             return SortedDict(), [], []
         return joins, where2, params
+def get_where_clause(lookup_type, table_prefix, field_name, value):
+def get_where_clause(opts, lookup_type, table_prefix, field_name, value):
+    backend = opts.get_default_manager().db.backend
+    qn = backend.quote_name
     if table_prefix.endswith('.'):
         table_prefix = backend.quote_name(table_prefix[:-1])+'.'
     field_name = backend.quote_name(field_name)
+        table_prefix = qn(table_prefix[:-1])+'.'
+    field_name = qn(field_name)
     if type(value) == datetime.datetime and backend.get_datetime_cast_sql():
         cast_sql = backend.get_datetime_cast_sql()
     else:
 …
     Helper function that recursively populates the select, tables and where (in
     place) for select_related queries.
     """
+    qn = opts.get_default_manager().db.backend.quote_name
     # If we've got a max_depth set and we've exceeded that depth, bail now.
     if max_depth and cur_depth > max_depth:
         return None
-    qn = backend.quote_name
     for f in opts.fields:
         if f.rel and not f.null:
             db_table = f.rel.to._meta.db_table
 …
     return choices
 def lookup_inner(path, lookup_type, value, opts, table, column):
-    qn = backend.quote_name
     joins, where, params = SortedDict(), [], []
     current_opts = opts
     current_table = table
     current_column = column
     intermediate_table = None
     join_required = False
+    db = current_opts.get_default_manager().db
+    backend = db.backend
+    connection = db.connection
+    qn = backend.quote_name
     name = path.pop(0)
     # Has the primary key been requested? If so, expand it out
 …
             # Last query term was a normal field.
             column = field.column
         where.append(get_where_clause(lookup_type, current_table + '.', column, value))
+        where.append(get_where_clause(current_opts, lookup_type, current_table + '.', column, value))
         params.extend(field.get_db_prep_lookup(lookup_type, value))
     return joins, where, params
 def delete_objects(seen_objs):
     "Iterate through a list of seen classes, and remove any instances that are referred to"
-    qn = backend.quote_name
     ordered_classes = seen_objs.keys()
     ordered_classes.reverse()
-    cursor = connection.cursor()
     for cls in ordered_classes:
+        db = cls._default_manager.db
+        backend = db.backend
+        connection = db.connection
+        cursor = connection.cursor()
+        qn = backend.quote_name
         seen_objs[cls] = seen_objs[cls].items()
         seen_objs[cls].sort()
 …
                         pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE])
     # Now delete the actual data
+    dirty_conns = []
     for cls in ordered_classes:
+        db = cls._default_manager.db
+        backend = db.backend
+        connection = db.connection
+        qn = backend.quote_name
+        cursor = connection.cursor()
+        if connection not in dirty_conns:
+            dirty_conns.append(connection)
         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):
 …
             setattr(instance, cls._meta.pk.attname, None)
             dispatcher.send(signal=signals.post_delete, sender=cls, instance=instance)
     transaction.commit_unless_managed()
+    transaction.commit_unless_managed(dirty_conns)

django/db/init.py

=== django/db/__init__.py
==================================================================

 from django.conf import settings
+from django.conf import settings, UserSettingsHolder
 from django.core import signals
+from django.core.exceptions import ImproperlyConfigured
 from django.dispatch import dispatcher
+try:
+    # Only exists in Python 2.4+
+    from threading import local
+except ImportError:
+    # Import copy of _thread_local.py from Python 2.4
+    from django.utils._threading_local import local
 __all__ = ('backend', 'connection', 'DatabaseError', 'IntegrityError')
+# singleton to represent the default connection in connections
+class dummy(object):
+    def __repr__(self):
+        return self.__str__()
+    def __str__(self):
+        return '<default>'
+_default = dummy()
+del dummy
+# storage for local default connection
+_local = local()
 if not settings.DATABASE_ENGINE:
     settings.DATABASE_ENGINE = 'dummy'
+try:
+    backend = __import__('django.db.backends.%s.base' % settings.DATABASE_ENGINE, {}, {}, [''])
+except ImportError, e:
+    # The database backend wasn't found. Display a helpful error message
+    # listing all possible database backends.
+    from django.core.exceptions import ImproperlyConfigured
+    import os
+    backend_dir = os.path.join(__path__[0], 'backends')
+    available_backends = [f for f in os.listdir(backend_dir) if not f.startswith('_') and not f.startswith('.') and not f.endswith('.py') and not f.endswith('.pyc')]
+    available_backends.sort()
+    if settings.DATABASE_ENGINE not in available_backends:
+        raise ImproperlyConfigured, "%r isn't an available database backend. Available options are: %s" % \
+            (settings.DATABASE_ENGINE, ", ".join(map(repr, available_backends)))
+    else:
+        raise # If there's some other error, this must be an error in Django itself.
+def connect(settings, **kw):
+    """Connect to the database specified in settings. Returns a
+    ConnectionInfo on success, raises ImproperlyConfigured if the
+    settings don't specify a valid database connection.
+    """
+    return ConnectionInfo(settings, **kw)
+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()
+class ConnectionInfo(object):
+    """Encapsulates all information about a connection and the backend
+    to which it belongs. Provides methods for loading backend
+    creation, introspection, and shell modules, closing the
+    connection, and resetting the connection's query log.
+    """
+    def __init__(self, settings=None, **kw):
+        super(ConnectionInfo, self).__init__(**kw)
+        if settings is None:
+            from django.conf import settings
+        if not settings.DATABASE_OPTIONS:
+            settings.DATABASE_OPTIONS = {}
+        self.settings = settings
+        self.backend = self.load_backend()
+        self.connection = self.backend.DatabaseWrapper(settings)
+        self.DatabaseError = self.backend.DatabaseError
+connection = backend.DatabaseWrapper(**settings.DATABASE_OPTIONS)
+DatabaseError = backend.DatabaseError
+        # Register an event that closes the database connection
+        # when a Django request is finished.
+        dispatcher.connect(self.close, signal=signals.request_finished)
+        # Register an event that resets connection.queries
+        # when a Django request is started.
+        dispatcher.connect(self.reset_queries, signal=signals.request_started)
+    def __repr__(self):
+        return "Connection: %r (ENGINE=%s NAME=%s)" \
+               % (self.connection,
+                  self.settings.DATABASE_ENGINE,
+                  self.settings.DATABASE_NAME)
+    def close(self):
+        """Close connection"""
+        self.connection.close()
+    def get_introspection_module(self):
+        return __import__('django.db.backends.%s.introspection' %
+                          self.settings.DATABASE_ENGINE, {}, {}, [''])
+    def get_creation_module(self):
+        return __import__('django.db.backends.%s.creation' %
+                          self.settings.DATABASE_ENGINE, {}, {}, [''])
+    def load_backend(self):
+        try:
+            backend = __import__('django.db.backends.%s.base' %
+                                 self.settings.DATABASE_ENGINE, {}, {}, [''])
+        except ImportError, e:
+            # The database backend wasn't found. Display a helpful error
+            # message listing all possible database backends.
+            import os
+            backend_dir = os.path.join(__path__[0], 'backends')
+            available_backends = [f for f in os.listdir(backend_dir)
+                                  if not f.startswith('_')  \
+                                  and not f.startswith('.') \
+                                  and not f.endswith('.py') \
+                                  and not f.endswith('.pyc')]
+            available_backends.sort()
+            if self.settings.DATABASE_ENGINE not in available_backends:
+                raise ImproperlyConfigured, \
+                      "%r isn't an available database backend. "\
+                      "Available options are: %s" % \
+                      (self.settings.DATABASE_ENGINE,
+                       ", ".join(map(repr, available_backends)))
+            else:
+                # If there's some other error, this must be an error
+                # in Django itself.
+                raise
+        return backend
+    def runshell(self):
+        __import__('django.db.backends.%s.client' %
+                   self.settings.DATABASE_ENGINE, {}, {}, ['']
+                   ).runshell(self.settings)
+    def reset_queries(self):
+        """Reset log of queries executed by connection"""
+        self.connection.queries = []
+class LazyConnectionManager(object):
+    """Manages named connections lazily, instantiating them as
+    they are requested.
+    """
+    def __init__(self):
+        self.local = local()
+        self.local.connections = {}
+        # Reset connections on request finish, to make sure each request can
+        # load the correct connections for its settings
+        dispatcher.connect(self.reset, signal=signals.request_finished)
+    def __iter__(self):
+        # Iterates only over *active* connections, not all possible
+        # connections
+        return iter(self.local.connections.keys())
+    def __getattr__(self, attr):
+        return getattr(self.local.connections, attr)
+    def __getitem__(self, k):
+        try:
+            return self.local.connections[k]
+        except (AttributeError, KeyError):
+            return self.connect(k)
+    def __setitem__(self, k, v):
+        try:
+            self.local.connections[k] = v
+        except AttributeError:
+            # First access in thread
+            self.local.connections = {k: v}
+    def connect(self, name):
+        """Return the connection with this name in
+        settings.OTHER_DATABASES. Creates the connection if it doesn't yet
+        exist. Reconnects if it does. If the name requested is the default
+        connection (a singleton defined in django.db), then the default
+        connection is returned.
+        """
+        try:
+            cnx = self.local.connections
+        except AttributeError:
+            cnx = self.local.connections = {}
+        if name in cnx:
+            cnx[name].close()
+        if name is _default:
+            cnx[name] = connect(settings)
+            return cnx[name]
+        try:
+            info = settings.OTHER_DATABASES[name]
+        except KeyError:
+            raise ImproperlyConfigured, \
+                  "No database connection '%s' has been configured" % name
+        except AttributeError:
+            raise ImproperlyConfigured, \
+                  "No OTHER_DATABASES in settings."
+        # In settings it's a dict, but connect() needs an object:
+        # pass global settings so that the default connection settings
+        # can be defaults for the named connections.
+        database = UserSettingsHolder(settings)
+        for k, v in info.items():
+            setattr(database, k, v)
+        cnx[name] = connect(database)
+        return cnx[name]
+    def items(self):
+        # Iterates over *all possible* connections
+        items = []
+        for key in self.keys():
+            items.append((key, self[key]))
+        return items
+    def keys(self):
+        # Iterates over *all possible* connections
+        keys = [_default]
+        try:
+            keys.extend(settings.OTHER_DATABASES.keys())
+        except AttributeError:
+            pass
+        return keys
+    def reset(self):
+        if not hasattr(self.local, 'connections'):
+            return
+        self.local.connections = {}
+def model_connection_name(klass):
+    """Get the connection name that a model is configured to use, with the
+    current settings.
+    """
+    app = klass._meta.app_label
+    model = klass.__name__
+    app_model = "%s.%s" % (app, model)
+    # Quick exit if no OTHER_DATABASES defined
+    if (not hasattr(settings, 'OTHER_DATABASES')
+        or not settings.OTHER_DATABASES):
+        return _default
+    # Look in MODELS for the best match: app_label.Model. If that isn't
+    # found, take just app_label. If nothing is found, use the default
+    maybe = None
+    for name, db_def in settings.OTHER_DATABASES.items():
+        if not 'MODELS' in db_def:
+            continue
+        mods = db_def['MODELS']
+        # Can't get a better match than this
+        if app_model in mods:
+            return name
+        elif app in mods:
+            if maybe is not None:
+                raise ImproperlyConfigured, \
+                    "App %s appears in more than one OTHER_DATABASES " \
+                    "setting (%s and %s)" % (maybe, name)
+            maybe = name
+    if maybe:
+        return maybe
+    # No named connection for this model; use the default
+    return _default
+class ConnectionInfoDescriptor(object):
+    """Descriptor used to access database connection information from a
+    manager or other connection holder. Keeps a thread-local cache of
+    connections per instance, and always returns the same connection for an
+    instance in particular thread during a particular request.
+    Any object that includes a ``model`` attribute that holds a model class
+    can use this descriptor to manage connections.
+    """
+    def __init__(self):
+        self.local = local()
+        self.local.cnx = {}
+        dispatcher.connect(self.reset, signal=signals.request_finished)
+    def __get__(self, instance, type=None):
+        if instance is None:
+            raise AttributeError, \
+                "ConnectionInfo is accessible only through an instance"
+        try:
+            instance_connection = self.local.cnx.get(instance, None)
+        except AttributeError:
+            # First access in this thread
+            self.local.cnx = {}
+            instance_connection = None
+        if instance_connection is None:
+            instance_connection = self.get_connection(instance)
+            self.local.cnx[instance] = instance_connection
+        return instance_connection
+    def __set__(self, instance, value):
+        try:
+            self.local.cnx[instance] = value
+        except AttributeError:
+            # First access in thread
+            self.local.cnx = {instance: value}
+    def __delete__(self, instance):
+        try:
+            del self.local.cnx[instance]
+        except (AttributeError, KeyError):
+            # Not stored, no need to reset
+            pass
+    def get_connection(self, instance):
+        return connections[model_connection_name(instance.model)]
+    def reset(self):
+        if not hasattr(self.local, 'cnx'):
+            return
+        self.local.cnx = {}
+class LocalizingProxy:
+    """A lazy-initializing proxy. The proxied object is not
+    initialized until the first attempt to access it. This is used to
+    attach module-level properties to local storage.
+    """
+    def __init__(self, name, storage, func, *arg, **kw):
+        self.__name = name
+        self.__storage = storage
+        self.__func = func
+        self.__arg = arg
+        self.__kw = kw
+        # We need to clear out this thread's storage at the end of each
+        # request, in case new settings are loaded with the next
+        def reset(stor=storage, name=name):
+            if hasattr(stor, name):
+                delattr(stor, name)
+        dispatcher.connect(reset, signal=signals.request_finished)
+    def __getattr__(self, attr):
+        # Private (__*) attributes are munged
+        if attr.startswith('_LocalizingProxy'):
+            return self.__dict__[attr]
+        try:
+            return getattr(getattr(self.__storage, self.__name), attr)
+        except AttributeError:
+            setattr(self.__storage, self.__name, self.__func(*self.__arg,
+                                                             **self.__kw))
+            return getattr(getattr(self.__storage, self.__name), attr)
+    def __setattr__(self, attr, val):
+        # Private (__*) attributes are munged
+        if attr.startswith('_LocalizingProxy'):
+            self.__dict__[attr] = val
+            return
+        try:
+            stor = getattr(self.__storage, self.__name)
+        except AttributeError:
+            stor =  self.__func(*self.__arg)
+            setattr(self.__storage, self.__name, stor)
+        setattr(stor, attr, val)
+# Create a manager for named connections
+connections = LazyConnectionManager()
+# Backwards compatibility: establish the default connection and set the
+# default connection properties at module level, using the lazy proxy so that
+# each thread may have a different default connection, if so configured
+connection_info = LocalizingProxy('connection_info', _local,
+                                  lambda: connections[_default])
+connection = LocalizingProxy('connection', _local,
+                             lambda: connections[_default].connection)
+backend = LocalizingProxy('backend', _local,
+                          lambda: connections[_default].backend)
+DatabaseError = LocalizingProxy('DatabaseError', _local,
+                                lambda: connections[_default].DatabaseError)
+#================================BUG==Might need LocalizingProxy==============
 IntegrityError = backend.IntegrityError
+get_introspection_module = LocalizingProxy(
+    'get_introspection_module', _local,
+    lambda: connections[_default].get_introspection_module)
+get_creation_module = LocalizingProxy(
+    'get_creation_module', _local,
+    lambda: connections[_default].get_creation_module)
+runshell = LocalizingProxy('runshell', _local,
+                           lambda: connections[_default].runshell)
-# Register an event that closes the database connection
-# when a Django request is finished.
-dispatcher.connect(connection.close, signal=signals.request_finished)
+# Register an event that resets connection.queries
+# when a Django request is started.
+def reset_queries():
+    connection.queries = []
+dispatcher.connect(reset_queries, signal=signals.request_started)
+# Register an event that rolls back the connection
+# Register an event that rolls back all connections
 # when a Django request has an exception.
 def _rollback_on_exception():
     from django.db import transaction
     transaction.rollback_unless_managed()
+dispatcher.connect(_rollback_on_exception, signal=signals.got_request_exception)
+dispatcher.connect(_rollback_on_exception,
+                   signal=signals.got_request_exception)

django/db/backends/ado_mssql/base.py

=== django/db/backends/ado_mssql/base.py
==================================================================

     return res
 Database.convertVariantToPython = variantToPython
+try:
+    # Only exists in Python 2.4+
+    from threading import local
+except ImportError:
+    # Import copy of _thread_local.py from Python 2.4
+    from django.utils._threading_local import local
+class DatabaseWrapper(local):
+    def __init__(self, **kwargs):
+class DatabaseWrapper(object):
+    def __init__(self, settings):
+        self.settings = settings
+        self.options = settings.DATABASE_OPTIONS
         self.connection = None
         self.queries = []
     def cursor(self):
         from django.conf import settings
+        settings = self.settings
         if self.connection is None:
             if settings.DATABASE_NAME == '' or settings.DATABASE_USER == '':
                 from django.core.exceptions import ImproperlyConfigured
 …
 needs_datetime_string_cast = True
 needs_upper_for_iops = False
 supports_constraints = True
+supports_compound_statements = True
 supports_tablespaces = True
 uses_case_insensitive_names = False

django/db/backends/ado_mssql/client.py

=== django/db/backends/ado_mssql/client.py
==================================================================


1		def runshell():
	1	def runshell(settings):
2	2	raise NotImplementedError

django/db/backends/ado_mssql/creation.py

=== django/db/backends/ado_mssql/creation.py
==================================================================


	1	from django.db.backends.ansi import sql
	2	builder = sql.SchemaBuilder()
	3
1	4	DATA_TYPES = {
2	5	'AutoField': 'int IDENTITY (1, 1)',
3	6	'BooleanField': 'bit',

django/db/backends/postgresql/base.py

=== django/db/backends/postgresql/base.py
==================================================================

 DatabaseError = Database.DatabaseError
 IntegrityError = Database.IntegrityError
+try:
+    # Only exists in Python 2.4+
+    from threading import local
+except ImportError:
+    # Import copy of _thread_local.py from Python 2.4
+    from django.utils._threading_local import local
+class DatabaseWrapper(object):
+    def __init__(self, settings):
+        self.settings = settings
 def smart_basestring(s, charset):
     if isinstance(s, unicode):
         return s.encode(charset)
 …
 postgres_version = None
-class DatabaseWrapper(local):
-    def __init__(self, **kwargs):
         self.connection = None
         self.queries = []
         self.options = kwargs
+        self.options = settings.DATABASE_OPTIONS
     def cursor(self):
         from django.conf import settings
+        settings = self.settings
         set_tz = False
         if self.connection is None:
             set_tz = True
 …
 needs_datetime_string_cast = True
 needs_upper_for_iops = False
 supports_constraints = True
+supports_compound_statements = True
 supports_tablespaces = False
 uses_case_insensitive_names = False

django/db/backends/postgresql/client.py

=== django/db/backends/postgresql/client.py
==================================================================

-from django.conf import settings
 import os
 def runshell():
+def runshell(settings):
     args = ['psql']
     if settings.DATABASE_USER:
         args += ["-U", settings.DATABASE_USER]

django/db/backends/postgresql/sql.py

=== django/db/backends/postgresql/sql.py
==================================================================

+from django.db import models
+from django.db.backends.ansi.sql import BoundStatement, SchemaBuilder, \
+    default_style
+class PgSchemaBuilder(SchemaBuilder):
+    """SchemaBuilder for postgres. Implements an additional method that
+    outputs SQL statements to reset the sequence(s) for a model.
+    """
+    def get_sequence_reset(self, model, style=None):
+        """Get sequence reset sql for a model.
+        """
+        if style is None:
+            style=default_style
+        for f in model._meta.fields:
+            output = []
+            db = model._default_manager.db
+            connection = db.connection
+            qn = db.backend.quote_name
+            if isinstance(f, models.AutoField):
+                output.append(BoundStatement(
+                        "%s setval('%s', (%s max(%s) %s %s));" % \
+                        (style.SQL_KEYWORD('SELECT'),
+                         style.SQL_FIELD('%s_%s_seq' %
+                                         (model._meta.db_table, f.column)),
+                         style.SQL_KEYWORD('SELECT'),
+                         style.SQL_FIELD(qn(f.column)),
+                         style.SQL_KEYWORD('FROM'),
+                         style.SQL_TABLE(qn(model._meta.db_table))),
+                        connection))
+                break # Only one AutoField is allowed per model, so don't bother continuing.
+        for f in model._meta.many_to_many:
+            output.append(
+                BoundStatement("%s setval('%s', (%s max(%s) %s %s));" % \
+                               (style.SQL_KEYWORD('SELECT'),
+                                style.SQL_FIELD('%s_id_seq' % f.m2m_db_table()),
+                                style.SQL_KEYWORD('SELECT'),
+                                style.SQL_FIELD(qn('id')),
+                                style.SQL_KEYWORD('FROM'),
+                                style.SQL_TABLE(f.m2m_db_table())),
+                               connection))
+        return output

django/db/backends/postgresql/creation.py

=== django/db/backends/postgresql/creation.py
==================================================================


	1	from django.db.backends.postgresql import sql
	2	builder = sql.PgSchemaBuilder()
	3
1	4	# This dictionary maps Field objects to their associated PostgreSQL column
2	5	# types, as strings. Column-type strings can contain format strings; they'll
3	6	# be interpolated against the values of Field.__dict__ before being output.

django/db/backends/sqlite3/base.py

=== django/db/backends/sqlite3/base.py
==================================================================

     from django.utils._threading_local import local
 class DatabaseWrapper(local):
+    def __init__(self, **kwargs):
+    def __init__(self, settings):
+        self.settings = settings
         self.connection = None
         self.queries = []
         self.options = kwargs
+        self.options = settings.DATABASE_OPTIONS
     def cursor(self):
         from django.conf import settings
+        settings = self.settings
         if self.connection is None:
             kwargs = {
                 'database': settings.DATABASE_NAME,
 …
 needs_datetime_string_cast = True
 needs_upper_for_iops = False
 supports_constraints = False
+supports_compound_statements = False
 supports_tablespaces = False
 uses_case_insensitive_names = False

django/db/backends/sqlite3/client.py

=== django/db/backends/sqlite3/client.py
==================================================================

-from django.conf import settings
 import os
 def runshell():
+def runshell(settings):
     args = ['', settings.DATABASE_NAME]
     os.execvp('sqlite3', args)

django/db/backends/sqlite3/creation.py

=== django/db/backends/sqlite3/creation.py
==================================================================


	1	from django.db.backends.ansi import sql
	2	builder = sql.SchemaBuilder()
	3
1	4	# SQLite doesn't actually support most of these types, but it "does the right
2	5	# thing" given more verbose field definitions, so leave them as is so that
3	6	# schema inspection is more useful.

django/db/backends/mysql/base.py

=== django/db/backends/mysql/base.py
==================================================================

 # standard util.CursorDebugWrapper can be used. Also, using sql_mode
 # TRADITIONAL will automatically cause most warnings to be treated as errors.
-try:
-    # Only exists in Python 2.4+
-    from threading import local
-except ImportError:
-    # Import copy of _thread_local.py from Python 2.4
-    from django.utils._threading_local import local
+class DatabaseWrapper(local):
+    def __init__(self, **kwargs):
+class DatabaseWrapper(object):
+    def __init__(self, settings):
+        self.settings = settings
         self.connection = None
         self.queries = []
         self.server_version = None
         self.options = kwargs
+        self.options = settings.DATABASE_OPTIONS
     def _valid_connection(self):
         if self.connection is not None:
 …
         return False
     def cursor(self):
         from django.conf import settings
+        settings = self.settings
         from warnings import filterwarnings
         if not self._valid_connection():
             kwargs = {
 …
 needs_datetime_string_cast = True     # MySQLdb requires a typecast for dates
 needs_upper_for_iops = False
 supports_constraints = True
+supports_compound_statements = True
 supports_tablespaces = False
 uses_case_insensitive_names = False

django/db/backends/mysql/client.py

=== django/db/backends/mysql/client.py
==================================================================

-from django.conf import settings
 import os
 def runshell():
+def runshell(settings):
     args = ['']
     db = settings.DATABASE_OPTIONS.get('db', settings.DATABASE_NAME)
     user = settings.DATABASE_OPTIONS.get('user', settings.DATABASE_USER)

django/db/backends/mysql/creation.py

=== django/db/backends/mysql/creation.py
==================================================================


	1	from django.db.backends.ansi import sql
	2	builder = sql.SchemaBuilder()
	3
1	4	# This dictionary maps Field objects to their associated MySQL column
2	5	# types, as strings. Column-type strings can contain format strings; they'll
3	6	# be interpolated against the values of Field.__dict__ before being output.

django/db/backends/oracle/base.py

=== django/db/backends/oracle/base.py
==================================================================

 DatabaseError = Database.Error
 IntegrityError = Database.IntegrityError
+try:
+    # Only exists in Python 2.4+
+    from threading import local
+except ImportError:
+    # Import copy of _thread_local.py from Python 2.4
+    from django.utils._threading_local import local
+class DatabaseWrapper(local):
+    def __init__(self, **kwargs):
+class DatabaseWrapper(object):
+    def __init__(self, settings):
+        self.settings = settings
         self.connection = None
         self.queries = []
         self.options = kwargs
+        self.options = settings.DATABASE_OPTIONS
     def _valid_connection(self):
         return self.connection is not None
     def cursor(self):
+        settings = self.settings
         if not self._valid_connection():
             if len(settings.DATABASE_HOST.strip()) == 0:
                 settings.DATABASE_HOST = 'localhost'
 …
 needs_datetime_string_cast = False
 needs_upper_for_iops = True
 supports_constraints = True
+supports_compound_statements = True
 supports_tablespaces = True
 uses_case_insensitive_names = True

django/db/backends/oracle/client.py

=== django/db/backends/oracle/client.py
==================================================================

-from django.conf import settings
 import os
 def runshell():
+def runshell(settings):
     dsn = settings.DATABASE_USER
     if settings.DATABASE_PASSWORD:
         dsn += "/%s" % settings.DATABASE_PASSWORD

django/db/backends/postgresql_psycopg2/base.py

=== django/db/backends/postgresql_psycopg2/base.py
==================================================================

 postgres_version = None
 class DatabaseWrapper(local):
+    def __init__(self, **kwargs):
+    def __init__(self, settings):
+        self.settings = settings
         self.connection = None
         self.queries = []
         self.options = kwargs
+        self.options = settings.DATABASE_OPTIONS
     def cursor(self):
         from django.conf import settings
+        settings = self.settings
         set_tz = False
         if self.connection is None:
             set_tz = True
 …
 needs_datetime_string_cast = False
 needs_upper_for_iops = False
 supports_constraints = True
+supports_compound_statements = True
 supports_tablespaces = False
 uses_case_insensitive_names = False

django/db/backends/ansi/init.py

=== django/db/backends/ansi/__init__.py
==================================================================


	1	pass

django/db/backends/ansi/sql.py

=== django/db/backends/ansi/sql.py
==================================================================

+"""ANSISQL schema manipulation functions and classes
+"""
+import os
+import re
+from django.db import models
+from django.contrib.contenttypes import generic
+# For Python 2.3
+if not hasattr(__builtins__, 'set'):
+    from sets import Set as set
+# default dummy style
+class dummy:
+    def __getattr__(self, attr):
+        return lambda x: x
+default_style = dummy()
+del dummy
+class BoundStatement(object):
+    """Represents an SQL statement that is to be executed, at some point in
+    the future, using a specific database connection.
+    """
+    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):
+    """Basic ANSI SQL schema element builder. Instances of this class may be
+    used to construct SQL expressions that create or drop schema elements such
+    as tables, indexes and (for those backends that support them) foreign key
+    or other constraints.
+    """
+    def __init__(self):
+        # models that I have created
+        self.models_already_seen = set()
+        # model references, keyed by the referrent model
+        self.references = {}
+        # table cache; set to short-circuit table lookups
+        self.tables = None
+    def get_create_table(self, model, style=None, pending=None):
+        """Construct and return the SQL expression(s) needed to create the
+        table for the given model, and any constraints on that
+        table. The return value is a 2-tuple. The first element of the tuple
+        is a list of BoundStatements that may be executed immediately. The
+        second is a dict of BoundStatements representing constraints that
+        can't be executed immediately because (for instance) the referent
+        table does not exist, keyed by the model class they reference.
+        """
+        if style is None:
+            style = default_style
+        if pending is None:
+            pending = {}
+        self.models_already_seen.add(model)
+        opts = model._meta
+        db = model._default_manager.db
+        backend = db.backend
+        quote_name = backend.quote_name
+        data_types = db.get_creation_module().DATA_TYPES
+        table_output = []
+        for f in opts.fields:
+            if isinstance(f, (models.ForeignKey, models.OneToOneField)):
+                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.
+                        if backend.supports_constraints:
+                            pending.setdefault(f.rel.to, []).append((model, 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), db.connection)]
+        # Pull out any pending statements for me
+        if pending:
+            if model in pending:
+                for rel_class, f in pending[model]:
+                    create.append(self.get_ref_sql(model, rel_class, f,
+                                                   style=style))
+                # What was pending for me is now no longer pending
+                pending.pop(model)
+        return (create, pending)
+    def get_create_indexes(self, model, style=None):
+        """Construct and return SQL statements needed to create the indexes for
+        a model. Returns a list of BoundStatements.
+        """
+        if style is None:
+            style = default_style
+        db = model._default_manager.db
+        backend = db.backend
+        connection = db.connection
+        output = []
+        for f in model._meta.fields:
+            if f.db_index:
+                unique = f.unique and 'UNIQUE ' or ''
+                output.append(
+                    BoundStatement(
+                        ' '.join(
+                            [style.SQL_KEYWORD('CREATE %sINDEX' % unique),
+                             style.SQL_TABLE('%s_%s' %
+                                             (model._meta.db_table, f.column)),
+                             style.SQL_KEYWORD('ON'),
+                             style.SQL_TABLE(
+                                    backend.quote_name(model._meta.db_table)),
+                             "(%s);" % style.SQL_FIELD(
+                                    backend.quote_name(f.column))]),
+                        connection)
+                    )
+        return output
+    def get_create_many_to_many(self, model, style=None):
+        """Construct and return SQL statements needed to create the
+        tables and relationships for all many-to-many relations
+        defined in the model. Returns a list of bound statments. Note
+        that these statements should only be executed after all models
+        for an app have been created.
+        """
+        if style is None:
+            style = default_style
+        db = model._default_manager.db
+        quote_name = db.backend.quote_name
+        connection = db.connection
+        data_types = db.get_creation_module().DATA_TYPES
+        opts = model._meta
+        # statements to execute, keyed by the other model
+        output = {}
+        for f in opts.many_to_many:
+            if not isinstance(f.rel, generic.GenericRel):
+                table_output = [
+                    style.SQL_KEYWORD('CREATE TABLE') + ' ' + \
+                    style.SQL_TABLE(quote_name(f.m2m_db_table())) + ' (']
+                table_output.append('    %s %s %s,' % \
+                    (style.SQL_FIELD(quote_name('id')),
+                    style.SQL_COLTYPE(data_types['AutoField']),
+                    style.SQL_KEYWORD('NOT NULL PRIMARY KEY')))
+                table_output.append('    %s %s %s %s (%s),' % \
+                    (style.SQL_FIELD(quote_name(f.m2m_column_name())),
+                    style.SQL_COLTYPE(data_types[self.get_rel_data_type(opts.pk)] % opts.pk.__dict__),
+                    style.SQL_KEYWORD('NOT NULL REFERENCES'),
+                    style.SQL_TABLE(quote_name(opts.db_table)),
+                    style.SQL_FIELD(quote_name(opts.pk.column))))
+                table_output.append('    %s %s %s %s (%s),' % \
+                    (style.SQL_FIELD(quote_name(f.m2m_reverse_name())),
+                    style.SQL_COLTYPE(data_types[self.get_rel_data_type(f.rel.to._meta.pk)] % f.rel.to._meta.pk.__dict__),
+                    style.SQL_KEYWORD('NOT NULL REFERENCES'),
+                    style.SQL_TABLE(quote_name(f.rel.to._meta.db_table)),
+                    style.SQL_FIELD(quote_name(f.rel.to._meta.pk.column))))
+                table_output.append('    %s (%s, %s)' % \
+                    (style.SQL_KEYWORD('UNIQUE'),
+                    style.SQL_FIELD(quote_name(f.m2m_column_name())),
+                    style.SQL_FIELD(quote_name(f.m2m_reverse_name()))))
+                table_output.append(');')
+                output.setdefault(f.rel.to, []).append(
+                    BoundStatement('\n'.join(table_output), connection))
+        return output
+    def get_drop_table(self, model, cascade=False, style=None):
+        """Construct and return the SQL statment(s) needed to drop a model's
+        table. If cascade is true, then output additional statments to drop any
+        many-to-many tables that this table created and any foreign keys that
+        reference this table.
+        """
+        if style is None:
+            style = default_style
+        opts = model._meta
+        db = model._default_manager.db
+        db_table = opts.db_table
+        backend = db.backend
+        qn = backend.quote_name
+        output = []
+        output.append(BoundStatement(
+                '%s %s;' % (style.SQL_KEYWORD('DROP TABLE'),
+                            style.SQL_TABLE(qn(db_table))),
+                db.connection))
+        if cascade:
+            # deal with others that might have a foreign key TO me: alter
+            # their tables to drop the constraint
+            if backend.supports_constraints:
+                references_to_delete = self.get_references()
+                if model in references_to_delete:
+                    for rel_class, f in references_to_delete[model]:
+                        table = rel_class._meta.db_table
+                        if not self.table_exists(db, table):
+                            print "NO TABLE %s" % table
+                            continue
+                        col = f.column
+                        r_table = opts.db_table
+                        r_col = opts.get_field(f.rel.field_name).column
+                        output.append(BoundStatement(
+                            '%s %s %s %s;' %
+                            (style.SQL_KEYWORD('ALTER TABLE'),
+                             style.SQL_TABLE(qn(table)),
+                             style.SQL_KEYWORD(
+                                        backend.get_drop_foreignkey_sql()),
+                             style.SQL_FIELD(qn("%s_refs_%s_%x" %
+                                                (col, r_col,
+                                                 abs(hash((table, r_table)))))
+                                             )),
+                            db.connection))
+                    del references_to_delete[model]
+            # many to many: drop any many-many tables that are my
+            # responsiblity
+            for f in opts.many_to_many:
+                if not isinstance(f.rel, generic.GenericRel):
+                    output.append(BoundStatement(
+                            '%s %s;' %
+                            (style.SQL_KEYWORD('DROP TABLE'),
+                             style.SQL_TABLE(qn(f.m2m_db_table()))),
+                            db.connection))
+        return output
+    def get_initialdata(self, model):
+        opts = model._meta
+        db = model._default_manager.db
+        settings = db.connection.settings
+        backend = db.backend
+        app_dir = self.get_initialdata_path(model)
+        output = []
+        # Some backends can't execute more than one SQL statement at a time.
+        # We'll split the initial data into individual statements unless
+        # backend.supports_compound_statements.
+        statements = re.compile(r";[ \t]*$", re.M)
+        # Find custom SQL, if it's available.
+        sql_files = [os.path.join(app_dir, "%s.%s.sql" %
+                                  (opts.object_name.lower(),
+                                   settings.DATABASE_ENGINE)),
+                     os.path.join(app_dir, "%s.sql" %
+                                  opts.object_name.lower())]
+        for sql_file in sql_files:
+            if os.path.exists(sql_file):
+                fp = open(sql_file, 'U')
+                if backend.supports_compound_statements:
+                    output.append(BoundStatement(fp.read(), db.connection))
+                else:
+                    for statement in statements.split(fp.read()):
+                        # Remove any comments from the file
+                        statement = re.sub(r"--.*[\n\Z]", "", statement)
+                        if statement.strip():
+                            output.append(BoundStatement(statement + ";",
+                                                         db.connection))
+                fp.close()
+        return output
+    def get_initialdata_path(self, model):
+        """Get the path from which to load sql initial data files for a model.
+        """
+        return os.path.normpath(os.path.join(os.path.dirname(
+                    models.get_app(model._meta.app_label).__file__), 'sql'))
+    def get_rel_data_type(self, f):
+        return (f.get_internal_type() in ('AutoField', 'PositiveIntegerField',
+                                          'PositiveSmallIntegerField')) \
+                                          and 'IntegerField' \
+                                          or f.get_internal_type()
+    def get_ref_sql(self, model, rel_class, f, style=None):
+        """Get sql statement for a reference between model and rel_class on
+        field f.
+        """
+        if style is None:
+            style = default_style
+        db = model._default_manager.db
+        qn = db.backend.quote_name
+        opts = model._meta
+        rel_opts = rel_class._meta
+        table = rel_opts.db_table
+        r_col = f.column
+        r_table = opts.db_table
+        col = opts.get_field(f.rel.field_name).column
+        # For MySQL, r_name must be unique in the first 64
+        # characters. So we are careful with character usage here.
+        r_name = '%s_refs_%s_%x' % (col, r_col,
+                                    abs(hash((r_table, table))))
+        sql = style.SQL_KEYWORD('ALTER TABLE') + \
+              ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s);' % \
+              (qn(table), qn(r_name),
+               qn(r_col), qn(r_table), qn(col))
+        return BoundStatement(sql, db.connection)
+    def get_references(self):
+        """Fill (if needed) and return the reference cache.
+        """
+        if self.references:
+            return self.references
+        for klass in models.get_models():
+            for f in klass._meta.fields:
+                if f.rel:
+                    self.references.setdefault(f.rel.to,
+                                               []).append((klass, f))
+        return self.references
+    def get_table_list(self, db):
+        """Get list of tables accessible via db.
+        """
+        if self.tables is not None:
+            return self.tables
+        cursor = db.connection.cursor()
+        introspection = db.get_introspection_module()
+        return introspection.get_table_list(cursor)
+    def table_exists(self, db, table):
+        tables = self.get_table_list(db)
+        return table in tables

django/db/backends/dummy/base.py

=== django/db/backends/dummy/base.py
==================================================================

     pass
 class DatabaseWrapper:
     cursor = complain
     _commit = complain
     _rollback = ignore
     def __init__(self, **kwargs):
         pass
+    def __init__(self, settings):
+        self.settings = settings
     def close(self):
         pass # close()

django/db/transaction.py

=== django/db/transaction.py
==================================================================

     import thread
 except ImportError:
     import dummy_thread as thread
 from django.db import connection
+from django import db
 from django.conf import settings
 class TransactionManagementError(Exception):
 …
     Puts the transaction manager into a manual state: managed transactions have
     to be committed explicitly by the user. If you switch off transaction
     management and there is a pending commit/rollback, the data will be
     commited.
+    commited. Note that managed state applies across all connections.
     """
     thread_ident = thread.get_ident()
     top = state.get(thread_ident, None)
     if top:
         top[-1] = flag
         if not flag and is_dirty():
+            connection._commit()
+            for cx in all_connections():
+                cx._commit()
             set_clean()
     else:
         raise TransactionManagementError("This code isn't under transaction management")
 def commit_unless_managed():
+def commit_unless_managed(connections=None):
     """
     Commits changes if the system is not in managed transaction mode.
     """
     if not is_managed():
+        connection._commit()
+        if connections is None:
+            connections = all_connections()
+        else:
+            connections = ensure_connections(connections)
+        for cx in connections:
+            cx._commit()
     else:
         set_dirty()
 def rollback_unless_managed():
+def rollback_unless_managed(connections=None):
     """
     Rolls back changes if the system is not in managed transaction mode.
     """
     if not is_managed():
+        connection._rollback()
+        if connections is None:
+            connections = all_connections()
+        for cx in connections:
+            cx._rollback()
     else:
         set_dirty()
 def commit():
+def commit(connections=None):
     """
     Does the commit itself and resets the dirty flag.
     """
+    connection._commit()
+    if connections is None:
+        connections = all_connections()
+    else:
+        connections = ensure_connections(connections)
+    for cx in connections:
+        cx._commit()
     set_clean()
 def rollback():
+def rollback(connections=None):
     """
     This function does the rollback itself and resets the dirty flag.
     """
+    connection._rollback()
+    if connections is None:
+        connections = all_connections()
+    else:
+        connections = ensure_connections(connections)
+    for cx in connections:
+        cx._rollback()
     set_clean()
 ##############
 …
             leave_transaction_management()
     return _autocommit
 def commit_on_success(func):
+def commit_on_success(func, connections=None):
     """
     This decorator activates commit on response. This way, if the view function
     runs successfully, a commit is made; if the viewfunc produces an exception,
 …
                 raise
             else:
                 if is_dirty():
                     commit()
+                    commit(connections)
             return res
         finally:
             leave_transaction_management()
 …
             leave_transaction_management()
     return _commit_manually
+###########
+# HELPERS #
+###########
+def all_connections():
+    return [db.connection] + [ c.connection
+                               for c in db.connections.values() ]
+def ensure_connections(val):
+    connections = []
+    if isinstance(val, basestring):
+        val = [val]
+    try:
+        iter(val)
+    except:
+        val = [val]
+    for cx in val:
+        if hasattr(cx, 'cursor'):
+            connections.append(cx)
+        elif hasattr(cx, 'connection'):
+            connections.append(cx.connection)
+        elif isinstance(cx, basestring):
+            connections.append(db.connections[cx].connection)
+    return connections

django/conf/global_settings.py

=== django/conf/global_settings.py
==================================================================

 DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.
 DATABASE_OPTIONS = {}          # Set to empty dictionary for default.
+# Optional named database connections in addition to the default.
+OTHER_DATABASES = {}
 # Host for sending e-mail.
 EMAIL_HOST = 'localhost'
 …
 # If None, a name of 'test_' + DATABASE_NAME will be assumed
 TEST_DATABASE_NAME = None
+# Tuple of other test databases to create. Names in this tuple
+# are suffixes that will be appended to TEST_DATABASE_NAME
+TEST_DATABASES = []
+# Models to assign to each test database. This must be a list of
+# dicts, with each dict key being a name from TEST_DATABASES and value
+# a list of models or app_labels that will use that database.
+TEST_DATABASE_MODELS = []
+############### FROM TRUNK #############################
 # Strings used to set the character set and collation order for the test
 # database. These values are passed literally to the server, so they are
 # backend-dependent. If None, no special settings are sent (system defaults are

django/core/servers/basehttp.py

=== django/core/servers/basehttp.py
==================================================================

         """
         if not self.result_is_file() and not self.sendfile():
             for data in self.result:
                 self.write(data)
+                self.write(data, False)
             self.finish_content()
         self.close()
 …
         else:
             self._write('Status: %s\r\n' % self.status)
     def write(self, data):
+    def write(self, data, flush=True):
         """'write()' callable as specified by PEP 333"""
         assert type(data) is StringType,"write() argument must be string"
 …
         # XXX check Content-Length and truncate if too many bytes written?
         self._write(data)
+        self._flush()
+        if flush:
+            self._flush()
     def sendfile(self):
         """Platform-specific file transmission
 …
         if not self.headers_sent:
             self.headers['Content-Length'] = "0"
             self.send_headers()
-        else:
-            pass # XXX check if content-length was too short?
     def close(self):
         try:

django/core/management.py

=== django/core/management.py
==================================================================

 from django.core.exceptions import ImproperlyConfigured
 from optparse import OptionParser
 from django.utils import termcolors
+from django.db import model_connection_name
 import os, re, shutil, sys, textwrap
+try:
+    set
+except NameError:
+    from sets import Set as set   # Python 2.3 fallback
+# For Python 2.3
+if not hasattr(__builtins__, 'set'):
+    from sets import Set as set
 # For backwards compatibility: get_version() used to be in this module.
 get_version = django.get_version
 …
 def get_sql_create(app):
     "Returns a list of the CREATE TABLE SQL statements for the given app."
     from django.db import get_creation_module, models
+    from django.db import get_creation_module, models, model_connection_name
+    data_types = get_creation_module().DATA_TYPES
+    # final output will be divided by comments into sections for each
+    # named connection, if there are any named connections
+    connection_output = {}
+    pending = {}
+    final_output = []
+    app_models = models.get_models(app)#, creation_order=True)
+    for model in app_models:
+        opts = model._meta
+        connection_name = model_connection_name(model)
+        output = connection_output.setdefault(connection_name, [])
+        db = model._default_manager.db
+        creation = db.get_creation_module()
+        data_types = creation.DATA_TYPES
+        if not data_types:
+            # This must be the "dummy" database backend, which means the user
+            # hasn't set DATABASE_ENGINE.
+    if not data_types:
+        # This must be the "dummy" database backend, which means the user
+        # hasn't set DATABASE_ENGINE.
+        sys.stderr.write(style.ERROR("Error: Django doesn't know which syntax to use for your SQL statements,\n" +
+            "because you haven't specified the DATABASE_ENGINE setting.\n" +
+            "Edit your settings file and change DATABASE_ENGINE to something like 'postgresql' or 'mysql'.\n"))
+        sys.exit(1)
+            # FIXME diff error message for bad default v bad named
+            sys.stderr.write(style.ERROR("Error: Django doesn't know which syntax to use for your SQL statements,\n" +
+                                         "because you haven't specified the DATABASE_ENGINE setting.\n" +
+                                         "Edit your settings file and change DATABASE_ENGINE to something like 'postgresql' or 'mysql'.\n"))
+            sys.exit(1)
+    # Get installed models, so we generate REFERENCES right.
+    # We trim models from the current app so that the sqlreset command does not
+    # generate invalid SQL (leaving models out of known_models is harmless, so
+    # we can be conservative).
+    app_models = models.get_models(app)
+    final_output = []
+    known_models = set([model for model in _get_installed_models(_get_table_list()) if model not in app_models])
+    pending_references = {}
+        # Get installed models, so we generate REFERENCES right
+        # We trim models from the current app so that the sqlreset command does
+        # not generate invalid SQL (leaving models out of known_models is
+        # harmless, so we can be conservative).
+        manager = model._default_manager
+        try:
+            tables = manager.get_table_list()
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except:
+            # Something else went wrong -- maybe the database isn't
+            # running. But we can still generate sql, so use an empty
+            # table list.
+            tables = []
     for model in app_models:
         output, references = _get_sql_model_create(model, known_models)
         final_output.extend(output)
         for refto, refs in references.items():
             pending_references.setdefault(refto,[]).extend(refs)
         final_output.extend(_get_sql_for_pending_references(model, pending_references))
         # Keep track of the fact that we've created the table for this model.
         known_models.add(model)
+        installed_models = [ m for m in
+                             manager.get_installed_models(tables)
+                             if m not in app_models ]
+        models_output = set(installed_models)
+        builder = creation.builder
+        builder.models_already_seen.update(models_output)
+        model_output, pending = builder.get_create_table(model, style, pending)
+        output.extend(model_output)
+    # Create the many-to-many join tables.
+    for model in app_models:
+        final_output.extend(_get_many_to_many_sql_for_model(model))
+        # Create the many-to-many join tables.
+        many_many = builder.get_create_many_to_many(model, style)
+        for refmodel, statements in many_many.items():
+            output.extend(statements)
+    final_output = _collate(connection_output)
     # Handle references to tables that are from other apps
     # but don't exist physically
     not_installed_models = set(pending_references.keys())
+    not_installed_models = set(pending.keys())
     if not_installed_models:
         alter_sql = []
         for model in not_installed_models:
+            alter_sql.extend(['-- ' + sql for sql in
+                _get_sql_for_pending_references(model, pending_references)])
+            builder = model._default_manager.db.get_creation_module().builder
+            for rel_class, f in pending[model]:
+                sql = builder.get_ref_sql(model, rel_class, f, style)
+                alter_sql.append('-- '+ str(sql))
         if alter_sql:
+            final_output.append('-- The following references should be added but depend on non-existent tables:')
+            final_output.append('-- The following references should be added '
+                                'but depend on non-existent tables:')
             final_output.extend(alter_sql)
+    # convert BoundStatements into strings
+    final_output = map(str, final_output)
     return final_output
 get_sql_create.help_doc = "Prints the CREATE TABLE SQL statements for the given app name(s)."
 get_sql_create.args = APP_ARGS
 …
 def get_sql_delete(app):
     "Returns a list of the DROP TABLE SQL statements for the given app."
+    from django.db import model_connection_name
     from django.db import backend, connection, models, get_introspection_module
     from django.db.backends.util import truncate_name
     introspection = get_introspection_module()
+    # This should work even if a connection isn't available
+    try:
+        cursor = connection.cursor()
+    except:
+        cursor = None
+    # Figure out which tables already exist
+    if cursor:
+        table_names = introspection.get_table_list(cursor)
+    else:
+        table_names = []
+    if backend.uses_case_insensitive_names:
+        table_name_converter = str.upper
+    else:
+        table_name_converter = lambda x: x
+    output = []
+    # Output DROP TABLE statements for standard application tables.
+    to_delete = set()
+    references_to_delete = {}
+    connection_output = {}
+    final_output = []
     app_models = models.get_models(app)
     for model in app_models:
+        if cursor and table_name_converter(model._meta.db_table) in table_names:
+            # The table exists, so it needs to be dropped
+            opts = model._meta
+            for f in opts.fields:
+                if f.rel and f.rel.to not in to_delete:
+                    references_to_delete.setdefault(f.rel.to, []).append( (model, f) )
+            to_delete.add(model)
+    for model in app_models:
+        if cursor and table_name_converter(model._meta.db_table) in table_names:
+            # Drop the table now
+            output.append('%s %s;' % (style.SQL_KEYWORD('DROP TABLE'),
+                style.SQL_TABLE(backend.quote_name(model._meta.db_table))))
+            if backend.supports_constraints and model in references_to_delete:
+                for rel_class, f in references_to_delete[model]:
+                    table = rel_class._meta.db_table
+                    col = f.column
+                    r_table = model._meta.db_table
+                    r_col = model._meta.get_field(f.rel.field_name).column
+                    r_name = '%s_refs_%s_%x' % (col, r_col, abs(hash((table, r_table))))
+                    output.append('%s %s %s %s;' % \
+                        (style.SQL_KEYWORD('ALTER TABLE'),
+                        style.SQL_TABLE(backend.quote_name(table)),
+                        style.SQL_KEYWORD(backend.get_drop_foreignkey_sql()),
+                        style.SQL_FIELD(truncate_name(r_name, backend.get_max_name_length()))))
+                del references_to_delete[model]
+            if model._meta.has_auto_field and hasattr(backend, 'get_drop_sequence'):
+                output.append(backend.get_drop_sequence(model._meta.db_table))
+    # Output DROP TABLE statements for many-to-many tables.
+    for model in app_models:
+        opts = model._meta
+        for f in opts.many_to_many:
+            if cursor and table_name_converter(f.m2m_db_table()) in table_names:
+                output.append("%s %s;" % (style.SQL_KEYWORD('DROP TABLE'),
+                    style.SQL_TABLE(backend.quote_name(f.m2m_db_table()))))
+                if hasattr(backend, 'get_drop_sequence'):
+                    output.append(backend.get_drop_sequence("%s_%s" % (model._meta.db_table, f.column)))
+    app_label = app_models[0]._meta.app_label
+    # Close database connection explicitly, in case this output is being piped
+    # directly into a database client, to avoid locking issues.
+    if cursor:
+        cursor.close()
+        connection.close()
+    return output[::-1] # Reverse it, to deal with table dependencies.
+        db = model._default_manager.db
+        connection = db.connection
+        try:
+            cursor = connection.cursor()
+        except:
+            cursor = None
+        #******** Start of conflict section ######
+        ###** From multi-db
+        builder = db.get_creation_module().builder
+        connection_name = model_connection_name(model)
+        output = connection_output.setdefault(connection_name, [])
+        output.extend(map(str,
+                          builder.get_drop_table(model,
+                                                 cascade=True, style=style)))
+        if cursor:
+            # Close database connection explicitly, in case this
+            # output is being piped directly into a database client,
+            # to avoid locking issues.
+            cursor.close()
+            connection.close()
+    final_output = _collate(connection_output, reverse=True)
+    return final_output
 get_sql_delete.help_doc = "Prints the DROP TABLE SQL statements for the given app name(s)."
 get_sql_delete.args = APP_ARGS
 …
 def get_custom_sql(app):
     "Returns a list of the custom table modifying SQL statements for the given app."
     from django.db.models import get_models
     output = []
+    connection_output = {}
     app_models = get_models(app)
     app_dir = os.path.normpath(os.path.join(os.path.dirname(app.__file__), 'sql'))
     for model in app_models:
+        output.extend(get_custom_sql_for_model(model))
+        opts = model._meta
+        connection_name = model_connection_name(model)
+        output = connection_output.setdefault(connection_name, [])
+        builder = model._default_manager.db.get_creation_module().builder
+        output.extend(builder.get_initialdata(model))
     return output
+    return _collate(connection_output)
 get_custom_sql.help_doc = "Prints the custom table modifying SQL statements for the given app name(s)."
 get_custom_sql.args = APP_ARGS
 …
 get_sql_initial_data.args = ''
 def get_sql_sequence_reset(app):
+    "Returns a list of the SQL statements to reset sequences for the given app."
+    from django.db import backend, models
+    return backend.get_sql_sequence_reset(style, models.get_models(app))
+get_sql_sequence_reset.help_doc = "Prints the SQL statements for resetting sequences for the given app name(s)."
+    "Returns a list of the SQL statements to reset PostgreSQL sequences for the given app."
+    from django.db import model_connection_name
+    from django.db.models import get_models
+    connection_output = {}
+    for model in get_models(app):
+        connection_name = model_connection_name(model)
+        output = connection_output.setdefault(connection_name, [])
+        builder = model._default_manager.db.get_creation_module().builder
+        try:
+            output.extend(builder.get_sequence_reset(model, style))
+        except AttributeError:
+            sys.stderr.write(
+                "%s is configured to use database engine %s, which does "
+                "not support sequence reset.\n" %
+                (model.__name__,
+                 model._default_manager.db.connection.settings.DATABASE_ENGINE))
+    return _collate(connection_output)
+get_sql_sequence_reset.help_doc = "Prints the SQL statements for resetting PostgreSQL sequences for the given app name(s)."
 get_sql_sequence_reset.args = APP_ARGS
 def get_sql_indexes(app):
     "Returns a list of the CREATE INDEX SQL statements for all models in the given app."
+    from django.db import models
+    output = []
+    for model in models.get_models(app):
+        output.extend(get_sql_indexes_for_model(model))
+    return output
+    from django.db import model_connection_name
+    from django.db.models import get_models
+    connection_output = {}
+    for model in get_models(app):
+        opts = model._meta
+        connection_name = model_connection_name(model)
+        output = connection_output.setdefault(connection_name, [])
+        output.extend(map(str, get_sql_indexes_for_model(model)))
+    return _collate(connection_output)
 get_sql_indexes.help_doc = "Prints the CREATE INDEX SQL statements for the given model module name(s)."
 get_sql_indexes.args = APP_ARGS
 …
 get_sql_all.help_doc = "Prints the CREATE TABLE, initial-data and CREATE INDEX SQL statements for the given model module name(s)."
 get_sql_all.args = APP_ARGS
+def _collate(connection_output, reverse=False):
+    from django.db import _default
+    final_output = []
+    if len(connection_output.keys()) == 1:
+        # all for the default connection
+        for statements in connection_output.values():
+            final_output.extend(statements)
+            if reverse:
+                final_output.reverse()
+    else:
+        for connection_name, statements in connection_output.items():
+            if not statements:
+                continue
+            final_output.append(' -- The following statements are for connection: %s' % connection_name)
+            if reverse:
+                statements.reverse()
+            final_output.extend(statements)
+            final_output.append(' -- END statements for %s\n' %
+                                connection_name)
+    return map(str, final_output)
 def _emit_post_sync_signal(created_models, verbosity, interactive):
     from django.db import models
     from django.dispatch import dispatcher
 …
     print '\n'.join(output)
 diffsettings.args = ""
+def install(app):
+    "Executes the equivalent of 'get_sql_all' in the current database."
+    # Wrap _install to hide the return value so ./manage.py install
+    # doesn't complain about unprintable output.
+    _install(app)
+def _install(app, commit=True, initial_data=True, pending_allowed=False,
+             pending=None, verbosity=1, signal=True, interactive=True):
+    from django.db import connection, models, transaction
+    import sys
+    app_name = app.__name__.split('.')[-2]
+    disable_termcolors()
+    # First, try validating the models.
+    _check_for_validation_errors(app)
+    created_models = []
+    try:
+        if pending is None:
+            pending = {}
+        for model in models.get_models(app, creation_order=True):
+            if verbosity >= 2:
+                print "Processing %s.%s model" % (app_name,
+                                                  model._meta.object_name)
+            manager = model._default_manager
+            tables = manager.get_table_list()
+            models_installed = manager.get_installed_models(tables)
+            # Don't re-install already-installed models
+            if not model in models_installed:
+                pending = manager.install(initial_data=initial_data,
+                                          pending=pending)
+                created_models.append(model)
+        if pending:
+            models_installed = manager.get_installed_models(tables)
+            for model in pending.keys():
+                manager = model._default_manager
+                if model in models_installed:
+                    for rel_class, f in pending[model]:
+                        manager.get_pending(rel_class, f).execute()
+                    pending.pop(model)
+                elif not pending_allowed:
+                    raise Exception("%s is not installed, but it has pending "
+                                    "references" % model)
+    except Exception, e:
+        import traceback
+        print traceback.format_exception(*sys.exc_info())
+        sys.stderr.write(style.ERROR("""Error: %s couldn't be installed. Possible reasons:
+  * The database isn't running or isn't configured correctly.
+  * At least one of the database tables already exists.
+  * The SQL was invalid.
+Hint: Look at the output of 'django-admin.py sqlall %s'. That's the SQL this command wasn't able to run.
+The full error: """ % (app_name, app_name)) + style.ERROR_OUTPUT(str(e)) + '\n')
+        transaction.rollback_unless_managed()
+        sys.exit(1)
+    if commit:
+        transaction.commit_unless_managed()
+    if signal:
+        _post_syncdb(app, created_models=created_models,
+                     verbosity=verbosity, interactive=interactive)
+    return created_models, pending
+install.help_doc = "Executes ``sqlall`` for the given app(s) in the current database."
+install.args = APP_ARGS
+def _post_syncdb(app, created_models, verbosity=1, interactive=True):
+    """Send the post_syncdb signal for an application."""
+    from django.dispatch import dispatcher
+    from django.db.models import signals
+    if verbosity >= 2:
+        print "Sending post-syncdb signal for application", app.__name__.split('.')[-2]
+    dispatcher.send(signal=signals.post_syncdb, sender=app,
+                    app=app, created_models=created_models,
+                    verbosity=verbosity, interactive=interactive)
 def reset(app, interactive=True):
     "Executes the equivalent of 'get_sql_reset' in the current database."
     from django.db import connection, transaction
 …
     Returns number of errors.
     """
     from django.conf import settings
     from django.db import models, connection
+    from django.db import connections, models, connection, model_connection_name
     from django.db.models.loading import get_app_errors
     from django.db.models.fields.related import RelatedObject
 …
     for cls in models.get_models(app):
         opts = cls._meta
+        connection_name = model_connection_name(cls)
+        connection = connections[connection_name]
         # Do field-specific validation.
         for f in opts.fields:
             if f.name == 'id' and not f.primary_key and opts.pk.name == 'id':
 …
             # Check that maxlength <= 255 if using older MySQL versions.
             if settings.DATABASE_ENGINE == 'mysql':
                 db_version = connection.get_server_version()
+                db_version = connection.connection.get_server_version()
                 if db_version < (5, 0, 3) and isinstance(f, (models.CharField, models.CommaSeparatedIntegerField, models.SlugField)) and f.maxlength > 255:
                     e.add(opts, '"%s": %s cannot have a "maxlength" greater than 255 when you are using a version of MySQL prior to 5.0.3 (you are using %s).' % (f.name, f.__class__.__name__, '.'.join([str(n) for n in db_version[:3]])))
 …
                 if f.rel.to not in models.get_models():
                     e.add(opts, "'%s' has relation with model %s, which has not been installed" % (f.name, rel_opts.object_name))
+                #TODO: Fix this to allow relations that span databases by splitting querys up
+                rel_connection = model_connection_name(f.rel.to)
+                if rel_connection != connection_name:
+                    e.add(opts, "'%s' is configured to use connection '%s' but has relation with '%s', which is configured to use connection '%s'" % (cls.__name__, connection_name, f.rel.to.__name__, rel_connection))
                 rel_name = RelatedObject(f.rel.to, cls, f).get_accessor_name()
                 rel_query_name = f.related_query_name()
                 for r in rel_opts.fields:
 …
     'createcachetable',
     'dbshell',
     'diffsettings',
+    'install',
     'reset',
     'sqlindexes',
     'syncdb',

django/views/generic/simple.py

Property changes on: django/core/management.py
___________________________________________________________________
Name: svn:eol-style
 -native

=== django/views/generic/simple.py
==================================================================

             dictionary[key] = value
     c = RequestContext(request, dictionary)
     t = loader.get_template(template)
     return HttpResponse(t.render(c), mimetype=mimetype)
+    return HttpResponse(t.iter_render(c), mimetype=mimetype)
 def redirect_to(request, url, **kwargs):
     """

django/views/generic/date_based.py

=== django/views/generic/date_based.py
==================================================================

             c[key] = value()
         else:
             c[key] = value
     return HttpResponse(t.render(c), mimetype=mimetype)
+    return HttpResponse(t.iter_render(c), mimetype=mimetype)
 def archive_year(request, year, queryset, date_field, template_name=None,
         template_loader=loader, extra_context=None, allow_empty=False,
 …
             c[key] = value()
         else:
             c[key] = value
     return HttpResponse(t.render(c), mimetype=mimetype)
+    return HttpResponse(t.iter_render(c), mimetype=mimetype)
 def archive_month(request, year, month, queryset, date_field,
         month_format='%b', template_name=None, template_loader=loader,
 …
             c[key] = value()
         else:
             c[key] = value
     return HttpResponse(t.render(c), mimetype=mimetype)
+    return HttpResponse(t.iter_render(c), mimetype=mimetype)
 def archive_week(request, year, week, queryset, date_field,
         template_name=None, template_loader=loader,
 …
             c[key] = value()
         else:
             c[key] = value
     return HttpResponse(t.render(c), mimetype=mimetype)
+    return HttpResponse(t.iter_render(c), mimetype=mimetype)
 def archive_day(request, year, month, day, queryset, date_field,
         month_format='%b', day_format='%d', template_name=None,
 …
             c[key] = value()
         else:
             c[key] = value
     return HttpResponse(t.render(c), mimetype=mimetype)
+    return HttpResponse(t.iter_render(c), mimetype=mimetype)
 def archive_today(request, **kwargs):
     """
 …
             c[key] = value()
         else:
             c[key] = value
     response = HttpResponse(t.render(c), mimetype=mimetype)
+    response = HttpResponse(t.iter_render(c), mimetype=mimetype)
     populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.name))
     return response

django/views/generic/list_detail.py

=== django/views/generic/list_detail.py
==================================================================

         model = queryset.model
         template_name = "%s/%s_list.html" % (model._meta.app_label, model._meta.object_name.lower())
     t = template_loader.get_template(template_name)
     return HttpResponse(t.render(c), mimetype=mimetype)
+    return HttpResponse(t.iter_render(c), mimetype=mimetype)
 def object_detail(request, queryset, object_id=None, slug=None,
         slug_field=None, template_name=None, template_name_field=None,
 …
             c[key] = value()
         else:
             c[key] = value
     response = HttpResponse(t.render(c), mimetype=mimetype)
+    response = HttpResponse(t.iter_render(c), mimetype=mimetype)
     populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.name))
     return response

django/views/generic/create_update.py

=== django/views/generic/create_update.py
==================================================================

             c[key] = value()
         else:
             c[key] = value
     return HttpResponse(t.render(c))
+    return HttpResponse(t.iter_render(c))
 def update_object(request, model, object_id=None, slug=None,
         slug_field=None, template_name=None, template_loader=loader,
 …
             c[key] = value()
         else:
             c[key] = value
     response = HttpResponse(t.render(c))
+    response = HttpResponse(t.iter_render(c))
     populate_xheaders(request, response, model, getattr(object, object._meta.pk.attname))
     return response
 …
                 c[key] = value()
             else:
                 c[key] = value
         response = HttpResponse(t.render(c))
+        response = HttpResponse(t.iter_render(c))
         populate_xheaders(request, response, model, getattr(object, object._meta.pk.attname))
         return response

django/views/debug.py

=== django/views/debug.py
==================================================================

         'template_does_not_exist': template_does_not_exist,
         'loader_debug_info': loader_debug_info,
     })
     return HttpResponseServerError(t.render(c), mimetype='text/html')
+    return HttpResponseServerError(t.iter_render(c), mimetype='text/html')
 def technical_404_response(request, exception):
     "Create a technical 404 error response. The exception should be the Http404."
 …
         'request_protocol': request.is_secure() and "https" or "http",
         'settings': get_safe_settings(),
     })
     return HttpResponseNotFound(t.render(c), mimetype='text/html')
+    return HttpResponseNotFound(t.iter_render(c), mimetype='text/html')
 def empty_urlconf(request):
     "Create an empty URLconf 404 error response."
 …
     c = Context({
         'project_name': settings.SETTINGS_MODULE.split('.')[0]
     })
     return HttpResponseNotFound(t.render(c), mimetype='text/html')
+    return HttpResponseNotFound(t.iter_render(c), mimetype='text/html')
 def _get_lines_from_file(filename, lineno, context_lines, loader=None, module_name=None):
     """

django/views/defaults.py

=== django/views/defaults.py
==================================================================

             The path of the requested URL (e.g., '/app/pages/bad_page/')
     """
     t = loader.get_template(template_name) # You need to create a 404.html template.
     return http.HttpResponseNotFound(t.render(RequestContext(request, {'request_path': request.path})))
+    return http.HttpResponseNotFound(t.iter_render(RequestContext(request, {'request_path': request.path})))
 def server_error(request, template_name='500.html'):
     """
 …
     Context: None
     """
     t = loader.get_template(template_name) # You need to create a 500.html template.
     return http.HttpResponseServerError(t.render(Context({})))
+    return http.HttpResponseServerError(t.iter_render(Context({})))

django/views/static.py

=== django/views/static.py
==================================================================

         'directory' : path + '/',
         'file_list' : files,
     })
     return HttpResponse(t.render(c))
+    return HttpResponse(t.iter_render(c))
 def was_modified_since(header=None, mtime=0, size=0):
     """

django/shortcuts/init.py

=== django/shortcuts/__init__.py
==================================================================

 from django.db.models.manager import Manager
 def render_to_response(*args, **kwargs):
     return HttpResponse(loader.render_to_string(*args, **kwargs))
+    return HttpResponse(loader.render_to_iter(*args, **kwargs))
 load_and_render = render_to_response # For backwards compatibility.
 def get_object_or_404(klass, *args, **kwargs):

django/contrib/comments/templatetags/comments.py

=== django/contrib/comments/templatetags/comments.py
==================================================================

         self.photo_options, self.rating_options = photo_options, rating_options
         self.is_public = is_public
     def render(self, context):
+    def iter_render(self, context):
         from django.conf import settings
         from django.utils.text import normalize_newlines
         import base64
 …
             try:
                 self.obj_id = template.resolve_variable(self.obj_id_lookup_var, context)
             except template.VariableDoesNotExist:
                 return ''
+                return
             # Validate that this object ID is valid for this content-type.
             # We only have to do this validation if obj_id_lookup_var is provided,
             # because do_comment_form() validates hard-coded object IDs.
 …
             context['hash'] = Comment.objects.get_security_hash(context['options'], context['photo_options'], context['rating_options'], context['target'])
             context['logout_url'] = settings.LOGOUT_URL
             default_form = loader.get_template(COMMENT_FORM)
+        output = default_form.render(context)
+        for chunk in default_form.iter_render(context):
+            yield chunk
         context.pop()
-        return output
 class CommentCountNode(template.Node):
     def __init__(self, package, module, context_var_name, obj_id, var_name, free):
 …
         self.context_var_name, self.obj_id = context_var_name, obj_id
         self.var_name, self.free = var_name, free
     def render(self, context):
+    def iter_render(self, context):
         from django.conf import settings
         manager = self.free and FreeComment.objects or Comment.objects
         if self.context_var_name is not None:
 …
             content_type__app_label__exact=self.package,
             content_type__model__exact=self.module, site__id__exact=settings.SITE_ID).count()
         context[self.var_name] = comment_count
         return ''
+        return ()
 class CommentListNode(template.Node):
     def __init__(self, package, module, context_var_name, obj_id, var_name, free, ordering, extra_kwargs=None):
 …
         self.ordering = ordering
         self.extra_kwargs = extra_kwargs or {}
     def render(self, context):
+    def iter_render(self, context):
         from django.conf import settings
         get_list_function = self.free and FreeComment.objects.filter or Comment.objects.get_list_with_karma
         if self.context_var_name is not None:
             try:
                 self.obj_id = template.resolve_variable(self.context_var_name, context)
             except template.VariableDoesNotExist:
                 return ''
+                return ()
         kwargs = {
             'object_id__exact': self.obj_id,
             'content_type__app_label__exact': self.package,
 …
                 comment_list = [c for c in comment_list if not c.is_hidden or (user_id == c.user_id)]
         context[self.var_name] = comment_list
         return ''
+        return ()
 class DoCommentForm:
     """

django/contrib/admin/templatetags/admin_modify.py

=== django/contrib/admin/templatetags/admin_modify.py
==================================================================

             return cls.nodelists[klass]
     get_nodelist = classmethod(get_nodelist)
     def render(self, context):
+    def iter_render(self, context):
         bound_field = template.resolve_variable(self.bound_field_var, context)
         context.push()
         context['bound_field'] = bound_field
+        output = self.get_nodelist(bound_field.field.__class__).render(context)
+        for chunk in self.get_nodelist(bound_field.field.__class__).iter_render(context):
+            yield chunk
         context.pop()
-        return output
 class FieldWrapper(object):
     def __init__(self, field ):
 …
     def __init__(self, rel_var):
         self.rel_var = rel_var
     def render(self, context):
+    def iter_render(self, context):
         relation = template.resolve_variable(self.rel_var, context)
         context.push()
         if relation.field.rel.edit_inline == models.TABULAR:
 …
         original = context.get('original', None)
         bound_related_object = relation.bind(context['form'], original, bound_related_object_class)
         context['bound_related_object'] = bound_related_object
         t = loader.get_template(bound_related_object.template_name())
         output = t.render(context)
+        for chunk in loader.get_template(bound_related_object.template_name()).iter_render(context):
+            yield chunk
         context.pop()
-        return output
 def output_all(form_fields):
     return ''.join([str(f) for f in form_fields])

django/contrib/admin/templatetags/log.py

=== django/contrib/admin/templatetags/log.py
==================================================================

     def __repr__(self):
         return "<GetAdminLog Node>"
     def render(self, context):
+    def iter_render(self, context):
         if self.user is None:
             context[self.varname] = LogEntry.objects.all().select_related()[:self.limit]
         else:
             if not self.user.isdigit():
                 self.user = context[self.user].id
             context[self.varname] = LogEntry.objects.filter(user__id__exact=self.user).select_related()[:self.limit]
         return ''
+        return ()
 class DoGetAdminLog:
     """

django/contrib/admin/templatetags/adminapplist.py

=== django/contrib/admin/templatetags/adminapplist.py
==================================================================

     def __init__(self, varname):
         self.varname = varname
     def render(self, context):
+    def iter_render(self, context):
         from django.db import models
         from django.utils.text import capfirst
         app_list = []
 …
                         'models': model_list,
                     })
         context[self.varname] = app_list
         return ''
+        return ()
 def get_admin_app_list(parser, token):
     """

django/template/init.py

=== django/template/__init__.py
==================================================================

 '\n<html>\n\n</html>\n'
 """
 import re
+import types
 from inspect import getargspec
 from django.conf import settings
 from django.template.context import Context, RequestContext, ContextPopException
 …
             for subnode in node:
                 yield subnode
     def render(self, context):
+    def iter_render(self, context):
         "Display stage -- can be called many times"
         return self.nodelist.render(context)
+        return self.nodelist.iter_render(context)
+    def render(self, context):
+        return ''.join(self.iter_render(context))
 def compile_string(template_string, origin):
     "Compiles template_string into NodeList ready for rendering"
     lexer = lexer_factory(template_string, origin)
 …
             del bits[0]
     return current
+class NodeBase(type):
+    def __new__(cls, name, bases, attrs):
+        """
+        Ensures that either a 'render' or 'render_iter' method is defined on
+        any Node sub-class. This avoids potential infinite loops at runtime.
+        """
+        if not (isinstance(attrs.get('render'), types.FunctionType) or
+                isinstance(attrs.get('iter_render'), types.FunctionType)):
+            raise TypeError('Unable to create Node subclass without either "render" or "iter_render" method.')
+        return type.__new__(cls, name, bases, attrs)
 class Node(object):
+    __metaclass__ = NodeBase
+    def iter_render(self, context):
+        return (self.render(context),)
     def render(self, context):
         "Return the node rendered as a string"
         pass
+        return ''.join(self.iter_render(context))
     def __iter__(self):
         yield self
 …
 class NodeList(list):
     def render(self, context):
+        bits = []
+        return ''.join(self.iter_render(context))
+    def iter_render(self, context):
         for node in self:
+            if isinstance(node, Node):
+                bits.append(self.render_node(node, context))
+            else:
+                bits.append(node)
+        return ''.join(bits)
+            for chunk in node.iter_render(context):
+                yield chunk
     def get_nodes_by_type(self, nodetype):
         "Return a list of all nodes of the given type"
 …
             nodes.extend(node.get_nodes_by_type(nodetype))
         return nodes
-    def render_node(self, node, context):
-        return(node.render(context))
 class DebugNodeList(NodeList):
+    def render_node(self, node, context):
+        try:
+            result = node.render(context)
+        except TemplateSyntaxError, e:
+            if not hasattr(e, 'source'):
+                e.source = node.source
+            raise
+        except Exception, e:
+            from sys import exc_info
+            wrapped = TemplateSyntaxError('Caught an exception while rendering: %s' % e)
+            wrapped.source = node.source
+            wrapped.exc_info = exc_info()
+            raise wrapped
+        return result
+    def iter_render(self, context):
+        for node in self:
+            if not isinstance(node, Node):
+                yield node
+                continue
+            try:
+                for chunk in node.iter_render(context):
+                    yield chunk
+            except TemplateSyntaxError, e:
+                if not hasattr(e, 'source'):
+                    e.source = node.source
+                raise
+            except Exception, e:
+                from sys import exc_info
+                wrapped = TemplateSyntaxError('Caught an exception while rendering: %s' % e)
+                wrapped.source = node.source
+                wrapped.exc_info = exc_info()
+                raise wrapped
 class TextNode(Node):
     def __init__(self, s):
 …
     def __repr__(self):
         return "<Text Node: '%s'>" % self.s[:25]
+    def iter_render(self, context):
+        return (self.s,)
     def render(self, context):
         return self.s
 …
         else:
             return output
+    def iter_render(self, context):
+        return (self.render(context),)
     def render(self, context):
         output = self.filter_expression.resolve(context)
         return self.encode_output(output)
 …
             def __init__(self, vars_to_resolve):
                 self.vars_to_resolve = vars_to_resolve
+            #def iter_render(self, context):
+            #    return (self.render(context),)
             def render(self, context):
                 resolved_vars = [resolve_variable(var, context) for var in self.vars_to_resolve]
                 return func(*resolved_vars)
 …
                 def __init__(self, vars_to_resolve):
                     self.vars_to_resolve = vars_to_resolve
                 def render(self, context):
+                def iter_render(self, context):
                     resolved_vars = [resolve_variable(var, context) for var in self.vars_to_resolve]
                     if takes_context:
                         args = [context] + resolved_vars
 …
                         else:
                             t = get_template(file_name)
                         self.nodelist = t.nodelist
                     return self.nodelist.render(context_class(dict))
+                    return self.nodelist.iter_render(context_class(dict))
             compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
             compile_func.__doc__ = func.__doc__

django/template/defaulttags.py

=== django/template/defaulttags.py
==================================================================

 register = Library()
 class CommentNode(Node):
     def render(self, context):
         return ''
+    def iter_render(self, context):
+        return ()
 class CycleNode(Node):
     def __init__(self, cyclevars, variable_name=None):
 …
         self.counter = -1
         self.variable_name = variable_name
+    def iter_render(self, context):
+        return (self.render(context),)
     def render(self, context):
         self.counter += 1
         value = self.cyclevars[self.counter % self.cyclevars_len]
 …
         return value
 class DebugNode(Node):
     def render(self, context):
+    def iter_render(self, context):
         from pprint import pformat
         output = [pformat(val) for val in context]
         output.append('\n\n')
         output.append(pformat(sys.modules))
         return ''.join(output)
+        for val in context:
+            yield pformat(val)
+        yield "\n\n"
+        yield pformat(sys.modules)
 class FilterNode(Node):
     def __init__(self, filter_expr, nodelist):
         self.filter_expr, self.nodelist = filter_expr, nodelist
     def render(self, context):
+    def iter_render(self, context):
         output = self.nodelist.render(context)
         # apply filters
         context.update({'var': output})
         filtered = self.filter_expr.resolve(context)
         context.pop()
         return filtered
+        return (filtered,)
 class FirstOfNode(Node):
     def __init__(self, vars):
         self.vars = vars
+    def iter_render(self, context):
+        return (self.render(context),)
     def render(self, context):
         for var in self.vars:
             try:
 …
         nodes.extend(self.nodelist_loop.get_nodes_by_type(nodetype))
         return nodes
+    def render(self, context):
+        nodelist = NodeList()
+    def iter_render(self, context):
         if 'forloop' in context:
             parentloop = context['forloop']
         else:
 …
         context.push()
         try:
             values = self.sequence.resolve(context, True)
+            if values is None:
+                values = ()
+            elif not hasattr(values, '__len__'):
+                values = list(values)
         except VariableDoesNotExist:
+            values = []
+        if values is None:
+            values = []
+        if not hasattr(values, '__len__'):
+            values = list(values)
+            values = ()
         len_values = len(values)
         if self.reversed:
             values = reversed(values)
 …
                 'parentloop': parentloop,
+            }
             if unpack:
+                # If there are multiple loop variables, unpack the item into them.
+                # If there are multiple loop variables, unpack the item into
+                # them.
                 context.update(dict(zip(self.loopvars, item)))
             else:
                 context[self.loopvars[0]] = item
+            # We inline this to avoid the overhead since ForNode is pretty
+            # common.
             for node in self.nodelist_loop:
+                nodelist.append(node.render(context))
+                for chunk in node.iter_render(context):
+                    yield chunk
             if unpack:
                 # The loop variables were pushed on to the context so pop them
                 # off again. This is necessary because the tag lets the length
 …
                 # context.
                 context.pop()
         context.pop()
-        return nodelist.render(context)
 class IfChangedNode(Node):
     def __init__(self, nodelist, *varlist):
 …
         self._last_seen = None
         self._varlist = varlist
     def render(self, context):
+    def iter_render(self, context):
         if 'forloop' in context and context['forloop']['first']:
             self._last_seen = None
         try:
 …
             self._last_seen = compare_to
             context.push()
             context['ifchanged'] = {'firstloop': firstloop}
+            content = self.nodelist.render(context)
+            for chunk in self.nodelist.iter_render(context):
+                yield chunk
             context.pop()
-            return content
-        else:
-            return ''
 class IfEqualNode(Node):
     def __init__(self, var1, var2, nodelist_true, nodelist_false, negate):
 …
     def __repr__(self):
         return "<IfEqualNode>"
     def render(self, context):
+    def iter_render(self, context):
         try:
             val1 = resolve_variable(self.var1, context)
         except VariableDoesNotExist:
 …
         except VariableDoesNotExist:
             val2 = None
         if (self.negate and val1 != val2) or (not self.negate and val1 == val2):
             return self.nodelist_true.render(context)
         return self.nodelist_false.render(context)
+            return self.nodelist_true.iter_render(context)
+        return self.nodelist_false.iter_render(context)
 class IfNode(Node):
     def __init__(self, bool_exprs, nodelist_true, nodelist_false, link_type):
 …
         nodes.extend(self.nodelist_false.get_nodes_by_type(nodetype))
         return nodes
     def render(self, context):
+    def iter_render(self, context):
         if self.link_type == IfNode.LinkTypes.or_:
             for ifnot, bool_expr in self.bool_exprs:
                 try:
 …
                 except VariableDoesNotExist:
                     value = None
                 if (value and not ifnot) or (ifnot and not value):
                     return self.nodelist_true.render(context)
             return self.nodelist_false.render(context)
+                    return self.nodelist_true.iter_render(context)
+            return self.nodelist_false.iter_render(context)
         else:
             for ifnot, bool_expr in self.bool_exprs:
                 try:
 …
                 except VariableDoesNotExist:
                     value = None
                 if not ((value and not ifnot) or (ifnot and not value)):
                     return self.nodelist_false.render(context)
             return self.nodelist_true.render(context)
+                    return self.nodelist_false.iter_render(context)
+            return self.nodelist_true.iter_render(context)
     class LinkTypes:
         and_ = 0,
 …
         self.target, self.expression = target, expression
         self.var_name = var_name
     def render(self, context):
+    def iter_render(self, context):
         obj_list = self.target.resolve(context, True)
         if obj_list == None: # target_var wasn't found in context; fail silently
             context[self.var_name] = []
             return ''
+            return ()
         # List of dictionaries in the format
         # {'grouper': 'key', 'list': [list of contents]}.
         context[self.var_name] = [{'grouper':key, 'list':list(val)} for key, val in
             groupby(obj_list, lambda v, f=self.expression.resolve: f(v, True))]
         return ''
+        return ()
 def include_is_allowed(filepath):
     for root in settings.ALLOWED_INCLUDE_ROOTS:
 …
     def __init__(self, filepath, parsed):
         self.filepath, self.parsed = filepath, parsed
     def render(self, context):
+    def iter_render(self, context):
         if not include_is_allowed(self.filepath):
             if settings.DEBUG:
                 return "[Didn't have permission to include file]"
+                return ("[Didn't have permission to include file]",)
             else:
                 return '' # Fail silently for invalid includes.
         try:
 …
             output = ''
         if self.parsed:
             try:
+                t = Template(output, name=self.filepath)
+                return t.render(context)
+                return Template(output, name=self.filepath).iter_render(context)
             except TemplateSyntaxError, e:
                 if settings.DEBUG:
                     return "[Included template had syntax error: %s]" % e
                 else:
                     return '' # Fail silently for invalid included templates.
         return output
+        return (output,)
 class LoadNode(Node):
     def render(self, context):
         return ''
+    def iter_render(self, context):
+        return ()
 class NowNode(Node):
     def __init__(self, format_string):
         self.format_string = format_string
+    def iter_render(self, context):
+        return (self.render(context),)
     def render(self, context):
         from datetime import datetime
         from django.utils.dateformat import DateFormat
 …
     def __init__(self, tagtype):
         self.tagtype = tagtype
+    def iter_render(self, context):
+        return (self.render(context),)
     def render(self, context):
         return self.mapping.get(self.tagtype, '')
 …
         self.args = args
         self.kwargs = kwargs
     def render(self, context):
+    def iter_render(self, context):
         from django.core.urlresolvers import reverse, NoReverseMatch
         args = [arg.resolve(context) for arg in self.args]
         kwargs = dict([(k, v.resolve(context)) for k, v in self.kwargs.items()])
         try:
             return reverse(self.view_name, args=args, kwargs=kwargs)
+            return (reverse(self.view_name, args=args, kwargs=kwargs),)
         except NoReverseMatch:
             try:
                 project_name = settings.SETTINGS_MODULE.split('.')[0]
                 return reverse(project_name + '.' + self.view_name, args=args, kwargs=kwargs)
             except NoReverseMatch:
                 return ''
+                return ()
 class WidthRatioNode(Node):
     def __init__(self, val_expr, max_expr, max_width):
 …
         self.max_expr = max_expr
         self.max_width = max_width
+    def iter_render(self, context):
+        return (self.render(context),)
     def render(self, context):
         try:
             value = self.val_expr.resolve(context)
 …
     def __repr__(self):
         return "<WithNode>"
     def render(self, context):
+    def iter_render(self, context):
         val = self.var.resolve(context)
         context.push()
         context[self.name] = val
+        output = self.nodelist.render(context)
+        for chunk in self.nodelist.iter_render(context):
+            yield chunk
         context.pop()
-        return output
 #@register.tag
 def comment(parser, token):

django/template/loader_tags.py

=== django/template/loader_tags.py
==================================================================

     def __repr__(self):
         return "<Block Node: %s. Contents: %r>" % (self.name, self.nodelist)
     def render(self, context):
+    def iter_render(self, context):
         context.push()
         # Save context in case of block.super().
         self.context = context
         context['block'] = self
+        result = self.nodelist.render(context)
+        for chunk in self.nodelist.iter_render(context):
+            yield chunk
         context.pop()
-        return result
     def super(self):
         if self.parent:
 …
         except TemplateDoesNotExist:
             raise TemplateSyntaxError, "Template %r cannot be extended, because it doesn't exist" % parent
         else:
             return get_template_from_string(source, origin, parent)
+            return get_template_from_string(source, origin)
     def render(self, context):
+    def iter_render(self, context):
         compiled_parent = self.get_parent(context)
         parent_is_child = isinstance(compiled_parent.nodelist[0], ExtendsNode)
         parent_blocks = dict([(n.name, n) for n in compiled_parent.nodelist.get_nodes_by_type(BlockNode)])
 …
                 parent_block.parent = block_node.parent
                 parent_block.add_parent(parent_block.nodelist)
                 parent_block.nodelist = block_node.nodelist
         return compiled_parent.render(context)
+        return compiled_parent.iter_render(context)
 class ConstantIncludeNode(Node):
     def __init__(self, template_path):
 …
                 raise
             self.template = None
     def render(self, context):
+    def iter_render(self, context):
         if self.template:
+            return self.template.render(context)
+        else:
+            return ''
+            return self.template.iter_render(context)
+        return ()
 class IncludeNode(Node):
     def __init__(self, template_name):
         self.template_name = template_name
     def render(self, context):
+    def iter_render(self, context):
         try:
             template_name = resolve_variable(self.template_name, context)
             t = get_template(template_name)
             return t.render(context)
+            return t.iter_render(context)
         except TemplateSyntaxError, e:
             if settings.TEMPLATE_DEBUG:
                 raise
             return ''
+            return ()
         except:
             return '' # Fail silently for invalid included templates.
+            return () # Fail silently for invalid included templates.
 def do_block(parser, token):
     """

django/template/loader.py

=== django/template/loader.py
==================================================================

     Returns a compiled Template object for the given template name,
     handling template inheritance recursively.
     """
+    source, origin = find_template_source(template_name)
+    template = get_template_from_string(source, origin, template_name)
+    return template
+    return get_template_from_string(*find_template_source(template_name))
 def get_template_from_string(source, origin=None, name=None):
+def get_template_from_string(source, origin=None):
     """
     Returns a compiled Template object for the given template code,
     handling template inheritance recursively.
     """
     return Template(source, origin, name)
+    return Template(source, origin)
 def render_to_string(template_name, dictionary=None, context_instance=None):
+def _render_setup(template_name, dictionary=None, context_instance=None):
     """
+    Loads the given template_name and renders it with the given dictionary as
+    context. The template_name may be a string to load a single template using
+    get_template, or it may be a tuple to use select_template to find one of
+    the templates in the list. Returns a string.
+    Common setup code for render_to_string and render_to_iter.
     """
+    dictionary = dictionary or {}
+    if dictionary is None:
+        dictionary = {}
     if isinstance(template_name, (list, tuple)):
         t = select_template(template_name)
     else:
 …
         context_instance.update(dictionary)
     else:
         context_instance = Context(dictionary)
     return t.render(context_instance)
+    return t, context_instance
+def render_to_string(template_name, dictionary=None, context_instance=None):
+    """
+    Loads the given template_name and renders it with the given dictionary as
+    context. The template_name may be a string to load a single template using
+    get_template, or it may be a tuple to use select_template to find one of
+    the templates in the list. Returns a string.
+    """
+    t, c = _render_setup(template_name, dictionary=dictionary, context_instance=context_instance)
+    return t.render(c)
+def render_to_iter(template_name, dictionary=None, context_instance=None):
+    """
+    Loads the given template_name and renders it with the given dictionary as
+    context. The template_name may be a string to load a single template using
+    get_template, or it may be a tuple to use select_template to find one of
+    the templates in the list. Returns a string.
+    """
+    t, c = _render_setup(template_name, dictionary=dictionary, context_instance=context_instance)
+    return t.iter_render(c)
 def select_template(template_name_list):
     "Given a list of template names, returns the first that can be loaded."
     for template_name in template_name_list:

tests/modeltests/multiple_databases/init.py

=== tests/modeltests/multiple_databases/__init__.py
==================================================================


	1	pass

tests/modeltests/multiple_databases/models.py

=== tests/modeltests/multiple_databases/models.py
==================================================================

+"""
+XXX. Using multiple database connections
+Django normally uses only a single database connection. However,
+support is available for using any number of different, named
+connections. Multiple database support is entirely optional and has
+no impact on your application if you don't use it.
+Named connections are defined in your settings module. Create a
+`OTHER_DATABASES` variable that is a dict, mapping connection names to their
+particulars. The particulars are defined in a dict with the same keys
+as the variable names as are used to define the default connection, with one
+addition: MODELS.
+The MODELS item in an OTHER_DATABASES entry is a list of the apps and models
+that will use that connection.
+Access to named connections is through `django.db.connections`, which
+behaves like a dict: you access connections by name. Connections are
+established lazily, when accessed.  `django.db.connections[database]`
+holds a `ConnectionInfo` instance, with the attributes:
+`DatabaseError`, `backend`, `get_introspection_module`,
+`get_creation_module`, and `runshell`.
+To access a model's connection, use its manager. The connection is available
+at `model._default_manager.db.connection`. To find the backend or other
+connection metadata, use `model._meta.db` to access the full ConnectionInfo
+with connection metadata.
+"""
+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 Opus(models.Model):
+    artist = models.ForeignKey(Artist)
+    name = models.CharField(maxlength=100)
+    year = models.IntegerField()
+    def __str__(self):
+        return "%s (%s)" % (self.name, self.year)
+class Widget(models.Model):
+    code = models.CharField(maxlength=10, unique=True)
+    weight = models.IntegerField()
+    def __str__(self):
+        return self.code
+class DooHickey(models.Model):
+    name = models.CharField(maxlength=50)
+    widgets = models.ManyToManyField(Widget, related_name='doohickeys')
+    def __str__(self):
+        return self.name
+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)
+__test__ = {'API_TESTS': """
+# See what connections are defined. django.db.connections acts like a dict.
+>>> from django.db import connection, connections, _default, model_connection_name
+>>> from django.conf import settings
+# Connections are referenced by name
+>>> connections['_a']
+Connection: ...
+>>> connections['_b']
+Connection: ...
+# Let's see what connections are available. The default connection is always
+# included in connections as well, and may be accessed as connections[_default].
+>>> connection_names = connections.keys()
+>>> connection_names.sort()
+>>> connection_names
+[<default>, '_a', '_b']
+# Invalid connection names raise ImproperlyConfigured
+>>> connections['bad']
+Traceback (most recent call last):
+ ...
+ImproperlyConfigured: No database connection 'bad' has been configured
+# The model_connection_name() function will tell you the name of the
+# connection that a model is configured to use.
+>>> model_connection_name(Artist)
+'_a'
+>>> model_connection_name(Widget)
+'_b'
+>>> model_connection_name(Vehicle) is _default
+True
+>>> a = Artist(name="Paul Klee", alive=False)
+>>> a.save()
+>>> w = Widget(code='100x2r', weight=1000)
+>>> w.save()
+>>> v = Vehicle(make='Chevy', model='Camaro', year='1966')
+>>> v.save()
+>>> artists = Artist.objects.all()
+>>> list(artists)
+[<Artist: Paul Klee>]
+# Models can access their connections through the db property of their
+# default manager.
+>>> paul = _[0]
+>>> Artist.objects.db
+Connection: ... (ENGINE=... NAME=...)
+>>> paul._default_manager.db
+Connection: ... (ENGINE=... NAME=...)
+# When transactions are not managed, model save will commit only
+# for the model's connection.
+>>> from django.db import transaction
+>>> transaction.enter_transaction_management()
+>>> transaction.managed(False)
+>>> a = Artist(name="Joan Miro", alive=False)
+>>> w = Widget(code="99rbln", weight=1)
+>>> a.save()
+# Only connection '_a' is committed, so if we rollback
+# all connections we'll forget the new Widget.
+>>> transaction.rollback()
+>>> list(Artist.objects.all())
+[<Artist: Paul Klee>, <Artist: Joan Miro>]
+>>> list(Widget.objects.all())
+[<Widget: 100x2r>]
+# Managed transaction state applies across all connections.
+>>> transaction.managed(True)
+# When managed, just as when using a single connection, updates are
+# not committed until a commit is issued.
+>>> a = Artist(name="Pablo Picasso", alive=False)
+>>> a.save()
+>>> w = Widget(code="99rbln", weight=1)
+>>> w.save()
+>>> v = Vehicle(make='Pontiac', model='Fiero', year='1987')
+>>> v.save()
+# The connections argument may be passed to commit, rollback, and the
+# commit_on_success decorator as a keyword argument, as the first (for
+# commit and rollback) or second (for the decorator) positional
+# argument. It may be passed as a ConnectionInfo object, a connection
+# (DatabaseWrapper) object, a connection name, or a list or dict of
+# ConnectionInfo objects, connection objects, or connection names. If a
+# dict is passed, the keys are ignored and the values used as the list
+# of connections to commit, rollback, etc.
+>>> transaction.commit(connections['_b'])
+>>> transaction.commit('_b')
+>>> transaction.commit(connections='_b')
+>>> transaction.commit(connections=['_b'])
+>>> transaction.commit(['_a', '_b'])
+>>> transaction.commit(connections)
+# When the connections argument is omitted entirely, the transaction
+# command applies to all connections. Here we have committed
+# connections 'django_test_db_a' and 'django_test_db_b', but not the
+# default connection, so the new vehicle is lost on rollback.
+>>> transaction.rollback()
+>>> list(Artist.objects.all())
+[<Artist: Paul Klee>, <Artist: Joan Miro>, <Artist: Pablo Picasso>]
+>>> list(Widget.objects.all())
+[<Widget: 100x2r>, <Widget: 99rbln>]
+>>> list(Vehicle.objects.all())
+[<Vehicle: 1966 Chevy Camaro>]
+>>> transaction.rollback()
+>>> transaction.managed(False)
+>>> transaction.leave_transaction_management()
+# Of course, relations and all other normal database operations work
+# with models that use named connections just the same as with models
+# that use the default connection. The only caveat is that you can't
+# use a relation between two models that are stored in different
+# databases. Note that that doesn't mean that two models using
+# different connection *names* can't be related; only that in the the
+# context in which they are used, if you use the relation, the
+# connections named by the two models must resolve to the same
+# database.
+>>> a = Artist.objects.get(name="Paul Klee")
+>>> list(a.opus_set.all())
+[]
+>>> a.opus_set.create(name="Magic Garden", year="1926")
+<Opus: Magic Garden (1926)>
+>>> list(a.opus_set.all())
+[<Opus: Magic Garden (1926)>]
+>>> d = DooHickey(name='Thing')
+>>> d.save()
+>>> d.widgets.create(code='d101', weight=92)
+<Widget: d101>
+>>> list(d.widgets.all())
+[<Widget: d101>]
+>>> w = Widget.objects.get(code='d101')
+>>> list(w.doohickeys.all())
+[<DooHickey: Thing>]
+"""}

tests/regressiontests/manager_db/tests.py

Property changes on: tests/modeltests/multiple_databases
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +

=== tests/regressiontests/manager_db/__init__.py
==================================================================
=== tests/regressiontests/manager_db/tests.py
==================================================================

+import unittest
+from regressiontests.manager_db.models import Insect
+class TestManagerDBAccess(unittest.TestCase):
+    def test_db_property(self):
+        m = Insect.objects
+        db = Insect.objects.db
+        assert db
+        assert db.connection
+        assert db.connection.cursor
+        assert db.backend
+        assert db.backend.quote_name
+        assert db.get_creation_module
+if __name__ == '__main__':
+    unittest.main()

tests/regressiontests/manager_db/models.py

=== tests/regressiontests/manager_db/models.py
==================================================================


	1	from django.db import models
	2
	3	class Insect(models.Model):
	4	common_name = models.CharField(maxlength=64)
	5	latin_name = models.CharField(maxlength=128)

tests/regressiontests/thread_isolation/tests.py

Property changes on: tests/regressiontests/manager_db
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +

=== tests/regressiontests/thread_isolation/__init__.py
==================================================================
=== tests/regressiontests/thread_isolation/tests.py
==================================================================

+# tests that db settings can be different in different threads
+#
+#
+#    What's going on here:
+#
+#    Simulating multiple web requests in a threaded environment, one in
+#    which settings are different for each request. So we replace
+#    django.conf.settings with a thread local, with different
+#    configurations in each thread, and then fire off three
+#    simultaneous requests (using a condition to sync them up), and
+#    test that each thread sees its own settings and the models in each
+#    thread attempt to connect to the correct database as per their
+#    settings.
+#
+import copy
+import os
+import sys
+import threading
+import unittest
+from thread import get_ident
+from django.conf import settings, UserSettingsHolder
+from django.core.handlers.wsgi import WSGIHandler
+from django.db import model_connection_name, _default, connection, connections
+from regressiontests.request_isolation.tests import MockHandler
+from regressiontests.thread_isolation.models import *
+try:
+    # Only exists in Python 2.4+
+    from threading import local
+except ImportError:
+    # Import copy of _thread_local.py from Python 2.4
+    from django.utils._threading_local import local
+# helpers
+EV = threading.Event()
+class LocalSettings:
+    """Settings holder that allows thread-local overrides of defaults.
+    """
+    def __init__(self, defaults):
+        self._defaults = defaults
+        self._local = local()
+    def __getattr__(self, attr):
+        if attr in ('_defaults', '_local'):
+            return self.__dict__[attr]
+        _local = self.__dict__['_local']
+        _defaults = self.__dict__['_defaults']
+        debug("LS get %s (%s)", attr, hasattr(_local, attr))
+        if not hasattr(_local, attr):
+            # Make sure everything we return is the local version; this
+            # avoids sets to deep datastructures overwriting the defaults
+            setattr(_local, attr, copy.deepcopy(getattr(_defaults, attr)))
+        return getattr(_local, attr)
+    def __setattr__(self, attr, val):
+        if attr in ('_defaults', '_local'):
+            self.__dict__[attr] = val
+        else:
+            debug("LS set local %s = %s", attr, val)
+            setattr(self.__dict__['_local'], attr, val)
+def thread_two(func, *arg):
+    def start():
+        # from django.conf import settings
+        settings.OTHER_DATABASES['_b']['MODELS'] = []
+        debug("t2 ODB: %s", settings.OTHER_DATABASES)
+        debug("t2 waiting")
+        EV.wait(2.0)
+        func(*arg)
+        debug("t2 complete")
+    t2 = threading.Thread(target=start)
+    t2.start()
+    return t2
+def thread_three(func, *arg):
+    def start():
+        # from django.conf import settings
+        settings.OTHER_DATABASES['_b']['MODELS'] = ['ti.MY']
+        settings.OTHER_DATABASES['_b'], \
+            settings.OTHER_DATABASES['_a'] = \
+            settings.OTHER_DATABASES['_a'], \
+            settings.OTHER_DATABASES['_b']
+        settings.DATABASE_NAME = \
+            settings.OTHER_DATABASES['_a']['DATABASE_NAME']
+        debug("t3 ODB: %s", settings.OTHER_DATABASES)
+        debug("3 %s: start: default: %s", get_ident(), settings.DATABASE_NAME)
+        debug("3 %s: start: conn: %s", get_ident(),
+              connection.settings.DATABASE_NAME)
+        debug("t3 waiting")
+        EV.wait(2.0)
+        func(*arg)
+        debug("t3 complete")
+    t3 = threading.Thread(target=start)
+    t3.start()
+    return t3
+def debug(*arg):
+    pass
+#    msg, arg = arg[0], arg[1:]
+#    print msg % arg
+def start_response(code, headers):
+    debug("start response: %s %s", code, headers)
+    pass
+class TestThreadIsolation(unittest.TestCase):
+    # event used to synchronize threads so we can be sure they are running
+    # together
+    lock = threading.RLock()
+    errors = []
+    def setUp(self):
+        debug("setup")
+        self.settings = settings._target
+        settings._target = UserSettingsHolder(copy.deepcopy(settings._target))
+        settings.OTHER_DATABASES['_a']['MODELS'] =  ['ti.MX']
+        settings.OTHER_DATABASES['_b']['MODELS'] = ['ti.MY']
+        # normal settings holders aren't thread-safe, so we need to substitute
+        # one that is (and so allows per-thread settings)
+        holder = settings._target
+        settings._target = LocalSettings(holder)
+    def teardown(self):
+        debug("teardown")
+        settings._target = self.settings
+    def add_thread_error(self, err):
+        self.lock.acquire()
+        try:
+            self.errors.append(err)
+        finally:
+            self.lock.release()
+    def thread_errors(self):
+        self.lock.acquire()
+        try:
+            return self.errors[:]
+        finally:
+            self.lock.release()
+    def request_one(self, request):
+        """Start out with settings as originally configured"""
+        from django.conf import settings
+        debug("request_one: %s", settings.OTHER_DATABASES)
+        self.assertEqual(model_connection_name(MQ), _default)
+        self.assertEqual(model_connection_name(MX), '_a')
+        self.assertEqual(
+            MX._default_manager.db.connection.settings.DATABASE_NAME,
+            settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
+        self.assertEqual(model_connection_name(MY), '_b')
+        self.assertEqual(
+            MY._default_manager.db.connection.settings.DATABASE_NAME,
+            settings.OTHER_DATABASES['_b']['DATABASE_NAME'])
+        self.assert_(MQ._default_manager.db.connection is
+                     connections[_default].connection)
+        self.assertEqual(
+            MQ._default_manager.db.connection.settings.DATABASE_NAME,
+            settings.DATABASE_NAME)
+        self.assertEqual(connection.settings.DATABASE_NAME,
+                         settings.DATABASE_NAME)
+    def request_two(self, request):
+        """Between the first and second requests, settings change to assign
+        model MY to a different connection
+        """
+        # from django.conf import settings
+        debug("request_two: %s", settings.OTHER_DATABASES)
+        try:
+            self.assertEqual(model_connection_name(MQ), _default)
+            self.assertEqual(model_connection_name(MX), '_a')
+            self.assertEqual(
+                MX._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
+            self.assertEqual(model_connection_name(MY), _default)
+            self.assertEqual(
+                MY._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.DATABASE_NAME)
+            self.assert_(MQ._default_manager.db.connection is
+                         connections[_default].connection)
+            self.assertEqual(
+                MQ._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.DATABASE_NAME)
+            self.assertEqual(connection.settings.DATABASE_NAME,
+                             settings.DATABASE_NAME)
+        except:
+            self.add_thread_error(sys.exc_info())
+    def request_three(self, request):
+        """Between the 2nd and 3rd requests, the settings at the names in
+        OTHER_DATABASES have changed.
+        """
+        # from django.conf import settings
+        debug("3 %s: %s", get_ident(), settings.OTHER_DATABASES)
+        debug("3 %s: default: %s", get_ident(), settings.DATABASE_NAME)
+        debug("3 %s: conn: %s", get_ident(),
+              connection.settings.DATABASE_NAME)
+        try:
+            self.assertEqual(model_connection_name(MQ), _default)
+            self.assertEqual(model_connection_name(MX), '_b')
+            self.assertEqual(
+                MX._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_b']['DATABASE_NAME'])
+            self.assertEqual(model_connection_name(MY), '_a')
+            self.assertEqual(
+                MY._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
+            self.assert_(MQ._default_manager.db.connection is
+                         connections[_default].connection)
+            self.assertEqual(
+                connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
+        except:
+            self.add_thread_error(sys.exc_info())
+    def test_thread_isolation(self):
+        debug("running tests")
+        env = os.environ.copy()
+        env['PATH_INFO'] = '/'
+        env['REQUEST_METHOD'] = 'GET'
+        t2 = thread_two(MockHandler(self.request_two), env, start_response)
+        t3 = thread_three(MockHandler(self.request_three), env, start_response)
+        try:
+            EV.set()
+            MockHandler(self.request_one)(env, start_response)
+        finally:
+            t2.join()
+            t3.join()
+            err = self.thread_errors()
+            if err:
+                import traceback
+                for e in err:
+                    traceback.print_exception(*e)
+                    raise AssertionError("%s thread%s failed" %
+                                         (len(err), len(err) > 1 and 's' or
+                                          ''))

tests/regressiontests/thread_isolation/models.py

=== tests/regressiontests/thread_isolation/models.py
==================================================================

+from django.db import models
+# models
+class MQ(models.Model):
+    val = models.CharField(maxlength=10)
+    class Meta:
+        app_label = 'ti'
+class MX(models.Model):
+    val = models.CharField(maxlength=10)
+    class Meta:
+        app_label = 'ti'
+class MY(models.Model):
+    val = models.CharField(maxlength=10)
+    class Meta:
+        app_label = 'ti'

tests/regressiontests/ansi_sql/sql/car.sql

Property changes on: tests/regressiontests/thread_isolation
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +


Property changes on: tests/regressiontests/initial_sql_regress/sql
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +

=== tests/regressiontests/ansi_sql/sql/car.sql
==================================================================


	1	insert into ansi_sql_car (make, model, year, condition)
	2	values ('Chevy', 'Impala', 1966, 'mint');

tests/regressiontests/ansi_sql/models.py

Property changes on: tests/regressiontests/ansi_sql/sql
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +

=== tests/regressiontests/ansi_sql/__init__.py
==================================================================
=== tests/regressiontests/ansi_sql/models.py
==================================================================

+"""
+>>> from django.db.backends.ansi import sql
+# so we can test with a predicatable constraint setting
+>>> real_cnst = Mod._default_manager.db.backend.supports_constraints
+>>> Mod._default_manager.db.backend.supports_constraints = True
+# generate create sql
+>>> builder = sql.SchemaBuilder()
+>>> builder.get_create_table(Car)
+([BoundStatement('CREATE TABLE "ansi_sql_car" (...);')], {})
+>>> builder.models_already_seen
+Set([<class 'regressiontests.ansi_sql.models.Car'>])
+>>> builder.models_already_seen = set()
+# test that styles are used
+>>> builder.get_create_table(Car, style=mockstyle())
+([BoundStatement('SQL_KEYWORD(CREATE TABLE) SQL_TABLE("ansi_sql_car") (...SQL_FIELD("id")...);')], {})
+# test pending relationships
+>>> builder.models_already_seen = set()
+>>> builder.get_create_table(Mod)
+([BoundStatement('CREATE TABLE "ansi_sql_mod" (..."car_id" integer NOT NULL,...);')], {<class 'regressiontests.ansi_sql.models.Car'>: [(<class 'regressiontests.ansi_sql.models.Mod'>, <django.db.models.fields.related.ForeignKey...>)]})
+>>> builder.models_already_seen = set()
+>>> builder.get_create_table(Car)
+([BoundStatement('CREATE TABLE "ansi_sql_car" (...);')], {})
+>>> builder.get_create_table(Mod)
+([BoundStatement('CREATE TABLE "ansi_sql_mod" (..."car_id" integer NOT NULL REFERENCES "ansi_sql_car" ("id"),...);')], {})
+# test many-many
+>>> builder.get_create_table(Collector)
+([BoundStatement('CREATE TABLE "ansi_sql_collector" (...);')], {})
+>>> builder.get_create_many_to_many(Collector)
+{<class 'regressiontests.ansi_sql.models.Car'>: [BoundStatement('CREATE TABLE "ansi_sql_collector_cars" (...);')]}
+# test indexes
+>>> builder.get_create_indexes(Car)
+[]
+>>> builder.get_create_indexes(Mod)
+[BoundStatement('CREATE INDEX ... ON "ansi_sql_mod" ("car_id");'), BoundStatement('CREATE INDEX ... ON "ansi_sql_mod" ("part");')]
+>>> builder.get_create_indexes(Collector)
+[]
+# test initial data
+# patch builder so that it looks for initial data where we want it to
+# >>> builder.get_initialdata_path = othertests_sql
+>>> builder.get_initialdata(Car)
+[BoundStatement("insert into ansi_sql_car (...)...values (...);...")]
+# test drop
+>>> builder.get_drop_table(Mod)
+[BoundStatement('DROP TABLE "ansi_sql_mod";')]
+>>> builder.get_drop_table(Mod, cascade=True)
+[BoundStatement('DROP TABLE "ansi_sql_mod";')]
+>>> builder.get_drop_table(Car)
+[BoundStatement('DROP TABLE "ansi_sql_car";')]
+# drop with cascade
+>>> builder.tables = ['ansi_sql_car', 'ansi_sql_mod', 'ansi_sql_collector']
+>>> Mod._default_manager.db.backend.supports_constraints = False
+>>> Mod._default_manager.db.backend.supports_constraints
+False
+>>> Car._default_manager.db.backend.supports_constraints
+False
+>>> builder.get_drop_table(Car, cascade=True)
+[BoundStatement('DROP TABLE "ansi_sql_car";')]
+>>> Mod._default_manager.db.backend.supports_constraints = True
+>>> Mod._default_manager.db.backend.supports_constraints
+True
+>>> Car._default_manager.db.backend.supports_constraints
+True
+>>> builder.get_drop_table(Car, cascade=True)
+[BoundStatement('DROP TABLE "ansi_sql_car";'), BoundStatement('ALTER TABLE "ansi_sql_mod" ...')]
+>>> builder.get_drop_table(Collector)
+[BoundStatement('DROP TABLE "ansi_sql_collector";')]
+>>> builder.get_drop_table(Collector, cascade=True)
+[BoundStatement('DROP TABLE "ansi_sql_collector";'), BoundStatement('DROP TABLE "ansi_sql_collector_cars";')]
+>>> Mod._default_manager.db.backend.supports_constraints = real_cnst
+"""
+#import os
+#import sys
+#from django.conf import settings
+#from django.core.management import install
+from django.db import models
+#from django.db.models import loading
+# For Python 2.3
+if not hasattr(__builtins__, 'set'):
+    from sets import Set as set
+# test models
+class Car(models.Model):
+    make = models.CharField(maxlength=32)
+    model = models.CharField(maxlength=32)
+    year = models.IntegerField()
+    condition = models.CharField(maxlength=32)
+class Collector(models.Model):
+    name = models.CharField(maxlength=32)
+    cars = models.ManyToManyField(Car)
+class Mod(models.Model):
+    car = models.ForeignKey(Car)
+    part = models.CharField(maxlength=32, db_index=True)
+    description = models.TextField()
+class mockstyle:
+    """mock style that wraps text in STYLE(text), for testing"""
+    def __getattr__(self, attr):
+        if attr in ('ERROR', 'ERROR_OUTPUT', 'SQL_FIELD', 'SQL_COLTYPE',
+                    'SQL_KEYWORD', 'SQL_TABLE'):
+            return lambda text: "%s(%s)" % (attr, text)
+# def othertests_sql(mod):
+#     """Look in othertests/sql for sql initialdata"""
+#     return os.path.normpath(os.path.join(os.path.dirname(__file__), 'sql'))
+# # install my models and force myself into the registry of apps and models
+# # (without this, references and such to/from the models installed here
+# # won't be picked up in get_models(), since get_models() looks only at
+# # models from apps in INSTALLED_APPS, and the model and app lookup rules
+# # enforce a module structure that this test file can't follow)
+# Car.objects.install()
+# Collector.objects.install()
+# Mod.objects.install()
+# loading.get_apps()
+# loading._app_list.append(sys.modules[__name__])
+# # model lookup only works for pk.models, so fake up my module name
+# __name__ = 'othertests.ansi_sql.models'

tests/regressiontests/request_isolation/tests.py

Property changes on: tests/regressiontests/ansi_sql
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +

=== tests/regressiontests/request_isolation/__init__.py
==================================================================
=== tests/regressiontests/request_isolation/tests.py
==================================================================

+# tests that db settings can change between requests
+import copy
+import os
+import unittest
+from django.conf import settings, UserSettingsHolder
+from django.core.handlers.wsgi import WSGIHandler
+from django.db import models, model_connection_name, _default, connection
+from django.http import HttpResponse
+from regressiontests.request_isolation.models import *
+# helpers
+class MockHandler(WSGIHandler):
+    def __init__(self, test):
+        self.test = test
+        super(MockHandler, self).__init__()
+    def get_response(self, request):
+        # debug("mock handler answering %s, %s", path, request)
+        return HttpResponse(self.test(request))
+def debug(*arg):
+    pass
+    # msg, arg = arg[0], arg[1:]
+    # print msg % arg
+def start_response(code, headers):
+    debug("start response: %s %s", code, headers)
+    pass
+# tests
+class TestRequestIsolation(unittest.TestCase):
+    def setUp(self):
+        debug("setup")
+        self.settings = settings._target
+        settings._target = UserSettingsHolder(copy.deepcopy(settings._target))
+        settings.OTHER_DATABASES['_a']['MODELS'] = ['ri.MX']
+        settings.OTHER_DATABASES['_b']['MODELS'] = ['ri.MY']
+    def tearDown(self):
+        debug("teardown")
+        settings._target = self.settings
+    def testRequestIsolation(self):
+        env = os.environ.copy()
+        env['PATH_INFO'] = '/'
+        env['REQUEST_METHOD'] = 'GET'
+        def request_one(request):
+            """Start out with settings as originally configured"""
+            self.assertEqual(model_connection_name(MX), '_a')
+            self.assertEqual(
+                MX._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
+            self.assertEqual(model_connection_name(MY), '_b')
+            self.assertEqual(
+                MY._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_b']['DATABASE_NAME'])
+        def request_two(request):
+            """Between the first and second requests, settings change to assign
+            model MY to a different connection
+            """
+            self.assertEqual(model_connection_name(MX), '_a')
+            self.assertEqual(
+                MX._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
+            self.assertEqual(model_connection_name(MY), _default)
+            self.assertEqual(
+                MY._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.DATABASE_NAME)
+        def request_three(request):
+            """Between the 2nd and 3rd requests, the settings at the names in
+            OTHER_DATABASES have changed.
+            """
+            self.assertEqual(model_connection_name(MX), '_b')
+            self.assertEqual(
+                MX._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_b']['DATABASE_NAME'])
+            self.assertEqual(model_connection_name(MY), '_a')
+            self.assertEqual(
+                MY._default_manager.db.connection.settings.DATABASE_NAME,
+                settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
+        MockHandler(request_one)(env, start_response)
+        settings.OTHER_DATABASES['_b']['MODELS'] = []
+        MockHandler(request_two)(env, start_response)
+        settings.OTHER_DATABASES['_b']['MODELS'] = ['ri.MY']
+        settings.OTHER_DATABASES['_b'], \
+            settings.OTHER_DATABASES['_a'] = \
+            settings.OTHER_DATABASES['_a'], \
+            settings.OTHER_DATABASES['_b']
+        MockHandler(request_three)(env, start_response)

tests/regressiontests/request_isolation/models.py

=== tests/regressiontests/request_isolation/models.py
==================================================================

+from django.db import models
+# models
+class MX(models.Model):
+    val = models.CharField(maxlength=10)
+    class Meta:
+        app_label = 'ri'
+class MY(models.Model):
+    val = models.CharField(maxlength=10)
+    class Meta:
+        app_label = 'ri'

tests/regressiontests/manager_schema_manipulation/tests.py

Property changes on: tests/regressiontests/request_isolation
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +

=== tests/regressiontests/manager_schema_manipulation/__init__.py
==================================================================
=== tests/regressiontests/manager_schema_manipulation/tests.py
==================================================================

+"""
+# Django uses a model's default manager to perform schema
+# manipulations such as creating or dropping the model's table.
+>>> from django.db import models
+>>> from django.conf import settings
+>>> import copy
+# save copy of settings so we can restore it later
+>>> odb = copy.deepcopy(settings.OTHER_DATABASES)
+>>> settings.OTHER_DATABASES['django_msm_test_db_a'] = { 'MODELS': ['msm.PA', 'msm.P', 'msm.PC']}
+>>> settings.OTHER_DATABASES['django_msm_test_db_b'] = {'MODELS': ['msm.QA', 'msm.QB', 'msm.QC', 'msm.QD']}
+# default connection
+>>> class DA(models.Model):
+...     name = models.CharField(maxlength=20)
+...
+...     def __str__(self):
+...         return self.name
+# connection a
+>>> class PA(models.Model):
+...     name = models.CharField(maxlength=20)
+...     # This creates a cycle in the dependency graph
+...     c = models.ForeignKey('PC', null=True)
+...
+...     def __str__(self):
+...         return self.name
+...
+...     class Meta:
+...         app_label = 'msm'
+>>> class PB(models.Model):
+...     name = models.CharField(maxlength=20)
+...     a = models.ForeignKey(PA)
+...
+...     def __str__(self):
+...         return self.name
+...
+...     class Meta:
+...         app_label = 'msm'
+>>> class PC(models.Model):
+...     name = models.CharField(maxlength=20)
+...     b = models.ForeignKey(PB)
+...
+...     def __str__(self):
+...         return self.name
+...
+...     class Meta:
+...         app_label = 'msm'
+# connection b
+>>> class QA(models.Model):
+...     name = models.CharField(maxlength=20)
+...
+...     def __str__(self):
+...         return self.name
+...
+...     class Meta:
+...         app_label = 'msm'
+>>> class QB(models.Model):
+...     name = models.CharField(maxlength=20)
+...     a = models.ForeignKey(QA)
+...
+...     def __str__(self):
+...         return self.name
+...
+...     class Meta:
+...         app_label = 'msm'
+# many-many
+>>> class QC(models.Model):
+...     name = models.CharField(maxlength=20)
+...
+...     def __str__(self):
+...         return self.name
+...
+...     class Meta:
+...         app_label = 'msm'
+>>> class QD(models.Model):
+...     name = models.CharField(maxlength=20)
+...     qcs = models.ManyToManyField(QC)
+...
+...     def __str__(self):
+...         return self.name
+...
+...     class Meta:
+...         app_label = 'msm'
+# Using the manager, models can be installed individually, whether they
+# use the default connection or a named connection.
+>>> DA.objects.install()
+{}
+>>> QA.objects.install()
+{}
+>>> QB.objects.install()
+{}
+>>> DA.objects.all()
+[]
+>>> list(QA.objects.all())
+[]
+>>> list(QB.objects.all())
+[]
+>>> QA(name="something").save()
+>>> QA.objects.all()
+[<QA: something>]
+# The `install()` method returns a tuple, the first element of which is a
+# list of statements that were executed, and the second, pending
+# statements that could not be executed because (for instance) they are
+# meant to establish foreign key relationships to tables that don't
+# exist. These are bound to the model's connection and should
+# be executed after all models in the app have been installed. The pending
+# statments are returned as a dict keyed by the model which must be installed
+# before the pending statements can be installed.
+# NOTE: pretend db supports constraints for this test
+>>> real_cnst = PA._default_manager.db.backend.supports_constraints
+>>> PA._default_manager.db.backend.supports_constraints = True
+>>> result = PA.objects.install()
+>>> result
+{<class 'regressiontests.manager_schema_manipulation.tests.PC'>: [(<class 'regressiontests.manager_schema_manipulation.tests.PA'>, <django.db.models.fields.related.ForeignKey ...>)]}
+# NOTE: restore real constraint flag
+>>> PA._default_manager.db.backend.supports_constraints = real_cnst
+# Models with many-many relationships may also have pending statement
+# lists. Like other pending statements, these should be executed after
+# all models in the app have been installed. If the related table's model
+# has already been created, then there will be no pending list.
+>>> QC.objects.install()
+{}
+>>> QD.objects.install()
+{}
+# Finally, restore the original settings
+>>> settings.OTHER_DATABASES = odb
+"""

tests/runtests.py

=== tests/regressiontests/manager_schema_manipulation/models.py
==================================================================

Property changes on: tests/regressiontests/manager_schema_manipulation
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +

=== tests/runtests.py
==================================================================

 TEST_TEMPLATE_DIR = 'templates'
 CONTRIB_DIR = os.path.dirname(contrib.__file__)
+TEST_DATABASES = ('_a', '_b')
+TEST_DATABASE_MODELS = {
+    '_a': [ 'multiple_databases.Artist',
+            'multiple_databases.Opus' ],
+    '_b': [ 'multiple_databases.Widget',
+            'multiple_databases.DooHickey' ]
+}
 MODEL_TEST_DIR = os.path.join(os.path.dirname(__file__), MODEL_TESTS_DIR_NAME)
 REGRESSION_TEST_DIR = os.path.join(os.path.dirname(__file__), REGRESSION_TESTS_DIR_NAME)
 …
     # Redirect some settings for the duration of these tests.
     settings.TEST_DATABASE_NAME = TEST_DATABASE_NAME
     settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
+    settings.TEST_DATABASES = TEST_DATABASES
+    settings.TEST_DATABASE_MODELS = TEST_DATABASE_MODELS
     settings.ROOT_URLCONF = 'urls'
     settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR),)
     settings.USE_I18N = True

docs/settings.txt

Property changes on: tests/templates
___________________________________________________________________
Name: svn:ignore
 +*.pyc
 +

=== docs/settings.txt
==================================================================

 See `allowed date format strings`_. See also DATE_FORMAT, DATETIME_FORMAT,
 TIME_FORMAT and YEAR_MONTH_FORMAT.
+OTHER_DATABASES
+---------------
+Default: ``{}``
+Other database connections to use in addition to the default connection. See the `multiple database support docs`_.
 PREPEND_WWW
 -----------
 …
 .. _cache docs: ../cache/
 .. _middleware docs: ../middleware/
+.. _multiple database support docs: ../multiple_database_support/
 .. _session docs: ../sessions/
 .. _See available choices: http://www.postgresql.org/docs/8.1/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
 .. _template documentation: ../templates_python/

docs/multiple_database_support.txt

=== docs/multiple_database_support.txt
==================================================================

+========================
+Using Multiple Databases
+========================
+Standard Django practice is to use a single database connection for
+all models in all applications. However, Django supports configuring
+and using multiple database connections on a per-application, per-model
+or an ad-hoc basis. Using multiple database connections is optional.
+Configuring other database connections
+======================================
+Django's default database connection is configured via the settings
+DATABASE_ENGINE, DATABASE_NAME, DATABASE_USER, DATABASE_PASSWORD,
+DATABASE_HOST, and DATABASE_PORT. Other connections are configured via
+the OTHER_DATABASES setting. Define OTHER_DATABASES as a dict, with a
+name for each connection as the key and a dict of settings as the
+value. In each OTHER_DATABASES entry (called a "named connection"),
+the keys are the same as the DATABASE_ENGINE, etc, settings used to
+configure the default connection. All keys are optional; any that are
+missing in a named connection's settings will inherit their values
+from the default connection.
+Here's an example::
+    DATABASE_ENGINE = 'postgresql'
+    DATABASE_NAME = 'django_apps'
+    DATABASE_USER = 'default_user'
+    DATABASE_PASSWORD = 'xxx'
+    OTHER_DATABASES = {
+        'local': { 'DATABASE_ENGINE': 'sqlite3',
+                   'DATABASE_NAME': '/tmp/cache.db' },
+        'public': { 'DATABASE_HOST': 'public',
+                    'DATABASE_USER': 'public_user',
+                    'DATABASE_PASSWORD': 'xxx' }
+        'private': { 'DATABASE_HOST': 'private',
+                     'DATABASE_USER': 'private_user',
+                     'DATABASE_PASSWORD': 'xxx' }
+    }
+In addition to the DATABASE_* settings, each named connection in
+OTHER_DATABASES may optionally include a MODELS setting. This should
+be a list of app or app.model names, and is used to configure which
+models should use this connection instead of the default connection.
+Here's the example above, with ``MODELS``::
+    OTHER_DATABASES = {
+        'local': { 'DATABASE_ENGINE': 'sqlite3',
+                   'DATABASE_NAME': '/tmp/cache.db',
+                   # A model name: only the model ContentItem
+                   # with the app_label myapp will use this connection
+                   'MODELS': ['myapp.ContentItem'] },
+        'public': { 'DATABASE_HOST': 'public',
+                    'DATABASE_USER': 'public_user',
+                    'DATABASE_PASSWORD': 'xxx',
+                    # Two models in myapp will use the connection
+                    # named 'public', as will ALL models in
+                    # django.contribe.comments
+                    'MODELS': ['myapp.Blog','myapp.Article',
+                               'django.contrib.comments' ] }
+        # No models or apps are configured to use the private db
+        'private': { 'DATABASE_HOST': 'private',
+                     'DATABASE_USER': 'private_user',
+                     'DATABASE_PASSWORD': 'xxx' }
+    }
+Accessing a model's connection
+==============================
+Each manager has a ``db`` attribute that can be used to access the model's
+connection. Access the ``db`` attribute of a model's manager to obtain the
+model's currently configured connection.
+Example::
+    from django.db import models
+    class Blog(models.Model)
+        name = models.CharField(maxlength=50)
+    class Article(models.Model)
+        blog = models.ForeignKey(Blog)
+        title = models.CharField(maxlength=100)
+        slug = models.SlugField()
+        summary = models.CharField(maxlength=500)
+        body = models.TextField()
+    class ContentItem(models.Model)
+        slug = models.SlugField()
+        mimetype = models.CharField(maxlength=50)
+        file = models.FileField()
+    # Get a ConnectionInfo instance that describes the connection
+    article_db = Article.objects.db
+    # Get a connection and a cursor
+    connection = article_db.connection
+    cursor = connection.cursor()
+    # Get the ``quote_name`` function from the backend
+    qn = article_db.backend.quote_name
+Ordinarily you won't have to access a model's connection directly;
+just use the model and manager normally and they will use the
+connection configured for the model.
+ConnectionInfo objects
+======================
+FIXME Describe the ConnectionInfo object and each of its attributes.
+Accessing connections by name
+=============================
+Access named connections directly through
+``django.db.connections``. Each entry in ``django.db.connections`` is
+a ``ConnectionInfo`` instance bound to the settings configured in the
+OTHER_DATABASES entry under the same key.
+Example::
+    from django.db import connections
+    private_db = connections['private']
+    cursor = private_db.connection.cursor()
+Using transactions with other database connections
+==================================================
+Transaction managed state applies across all connections
+commit/rollback apply to all connections by default
+but you can specify individual connections or lists or dicts of connections
+Changing model connections on the fly
+=====================================
+Here's an example of primitive mirroring::
+    # Read all articles from the private db
+    # Note that we pull the articles into a list; this is necessary
+    # because query sets are lazy. If we were to change the model's
+    # connection without copying the articles into a local list, we'd
+    # wind up reading from public instead of private.
+    Article.objects.db = connections['private']
+    all_articles = list(Article.objects.all())
+    # Save each article in the public db
+    Article.objects.db = connections['public']
+    for article in all_articles:
+        article.save()
+Thread and request isolation
+============================
+connections close after each request
+connection settings are thread-local

docs/templates_python.txt

=== docs/templates_python.txt
==================================================================

     While ``TEMPLATE_STRING_IF_INVALID`` can be a useful debugging tool,
     it is a bad idea to turn it on as a 'development default'.
     Many templates, including those in the Admin site, rely upon the
     silence of the template system when a non-existent variable is
     encountered. If you assign a value other than ``''`` to
     ``TEMPLATE_STRING_IF_INVALID``, you will experience rendering
     problems with these templates and sites.
     Generally, ``TEMPLATE_STRING_IF_INVALID`` should only be enabled
     in order to debug a specific template problem, then cleared
     once debugging is complete.
 …
 When Django compiles a template, it splits the raw template text into
 ''nodes''. Each node is an instance of ``django.template.Node`` and has
+a ``render()`` method. A compiled template is, simply, a list of ``Node``
+objects. When you call ``render()`` on a compiled template object, the template
+calls ``render()`` on each ``Node`` in its node list, with the given context.
+The results are all concatenated together to form the output of the template.
+either a ``render()`` or ``iter_render()`` method. A compiled template is,
+simply, a list of ``Node`` objects. When you call ``render()`` on a compiled
+template object, the template calls ``render()`` on each ``Node`` in its node
+list, with the given context. The results are all concatenated together to
+form the output of the template.
 Thus, to define a custom template tag, you specify how the raw template tag is
 converted into a ``Node`` (the compilation function), and what the node's
 ``render()`` method does.
+``render()`` or ``iter_render()`` method does.
 Writing the compilation function
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
 ~~~~~~~~~~~~~~~~~~~~
 The second step in writing custom tags is to define a ``Node`` subclass that
+has a ``render()`` method.
+has a ``render()`` method (we will discuss the ``iter_render()`` alternative
+in `Improving rendering speed`_, below).
 Continuing the above example, we need to define ``CurrentTimeNode``::
 …
         def __init__(self, date_to_be_formatted, format_string):
             self.date_to_be_formatted = date_to_be_formatted
             self.format_string = format_string
         def render(self, context):
             try:
                 actual_date = resolve_variable(self.date_to_be_formatted, context)
 …
 .. _configuration:
+Improving rendering speed
+~~~~~~~~~~~~~~~~~~~~~~~~~
+For most practical purposes, the ``render()`` method on a ``Node`` will be
+sufficient and the simplest way to implement a new tag. However, if your
+template tag is expected to produce large strings via ``render()``, you can
+speed up the rendering process (and reduce memory usage) using iterative
+rendering via the ``iter_render()`` method.
+The ``iter_render()`` method should either be an iterator that yields string
+chunks, one at a time, or a method that returns a sequence of string chunks.
+The template renderer will join the successive chunks together when creating
+the final output. The improvement over the ``render()`` method here is that
+you do not need to create one large string containing all the output of the
+``Node``, instead you can produce the output in smaller chunks.
+By way of example, here's a trivial ``Node`` subclass that simply returns the
+contents of a file it is given::
+    class FileNode(Node):
+        def __init__(self, filename):
+            self.filename = filename
+        def iter_render(self):
+            for line in file(self.filename):
+                yield line
+For very large files, the full file contents will never be read entirely into
+memory when this tag is used, which is a useful optimisation.
+If you define an ``iter_render()`` method on your ``Node`` subclass, you do
+not need to define a ``render()`` method. The reverse is true as well: the
+default ``Node.iter_render()`` method will call your ``render()`` method if
+necessary. A useful side-effect of this is that you can develop a new tag
+using ``render()`` and producing all the output at once, which is easy to
+debug. Then you can rewrite the method as an iterator, rename it to
+``iter_render()`` and everything will still work.
+It is compulsory, however, to define *either* ``render()`` or ``iter_render()``
+in your subclass. If you omit them both, a ``TypeError`` will be raised when
+the code is imported.
 Configuring the template system in standalone mode
 ==================================================
 …
 .. _settings file: ../settings/#using-settings-without-the-django-settings-module-environment-variable
 .. _settings documentation: ../settings/

Download in other formats:

Original Format

Issues

Context Navigation

Ticket #4747: mdb.patch

Download in other formats: