Ticket #4747: mdb.patch

django/test/utils.py

@@ -1 +1 @@
-import sys, time
-from django.conf import settings
-
+
+
-from django.core import management, mail
-from django.core import management, mail
-from django.dispatch import dispatcher
@@ -12 +13 @@
-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.
@@ -45 +55 @@
-        
-    """
-    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
@@ -60 +72 @@
-        
-    """
-    Template.render = Template.original_render
-
+
+
-    
-    mail.SMTPConnection = mail.original_SMTPConnection
-    del mail.original_SMTPConnection
@@ -73 +86 @@
-        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:
@@ -97 +110 @@
-    
-    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":
-
+
+
+
-    else:
-        suffix = {
-            'postgresql': get_postgresql_create_suffix,
@@ -112 +128 @@
-            TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME
-        else:
-            TEST_DATABASE_NAME = TEST_DATABASE_PREFIX + settings.DATABASE_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:
-backend.quote_name
+qn
-        except Exception, e:            
-            sys.stderr.write("Got an error creating the test database: %s\n" % e)
-            if not autoclobber:
@@ -128 +145 @@
-                try:
-                    if verbosity >= 1:
-                        print "Destroying old test database..."                
-backend.quote_name
+qn
-                    if verbosity >= 1:
-                        print "Creating test database..."
-backend.quote_name
+qn
-                except Exception, e:
-                    sys.stderr.write("Got an error recreating the test database: %s\n" % e)
-                    sys.exit(2)
@@ -148 +165 @@
-    # the side effect of initializing the test database.
-    cursor = connection.cursor()
-
-
+
+
+
+
+
+
+
+
+
+
+
-    # 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

@@ -224 +224 @@
-        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):
@@ -233 +239 @@
-    content = property(_get_content, _set_content)
-
-    def __iter__(self):
-
-
+
+
+
+
-
-    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

@@ -309 +309 @@
-        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

@@ -6 +6 @@
-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
-connection, backend, 
+
-from django.db.models import signals
-from django.db.models.loading import register_models, get_model
-from django.dispatch import dispatcher
@@ -22 +22 @@
-    "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)
@@ -201 +204 @@
-    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()
-
@@ -211 +218 @@
-        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
+qn(self._meta.db_table), qn
-                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
-backend.quote_name
-backend.quote_name
+qn
+qn
+qn
-                        db_values + self._meta.pk.get_db_prep_lookup('exact', pk_val))
-            else:
-                record_exists = False
-        if not pk_set or not record_exists:
-backend.quote_name
+qn
-            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:
@@ -233 +240 @@
-                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:
-backend.quote_name
+qn
-                # 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
+qn(self._meta.db_table), qn
-                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
+qn
-                    ','.join(placeholders)), db_values)
-            else:
-                # Create a new record with defaults for everything.
-                cursor.execute("INSERT INTO %s (%s) VALUES (%s)" %
-backend.quote_name
-backend.quote_name
+qn
+qn
-                     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))
-
+[connection]
-
-        # Run any post-save hooks.
-        dispatcher.send(signal=signals.post_save, sender=self.__class__, instance=self)
@@ -321 +328 @@
-        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
-backend.quote_name(self._meta.db_table), backend.quote_name
+qn(field.column), op, qn
+qn(self._meta.db_table), qn
-        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)
@@ -335 +343 @@
-            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
-backend.quote_name(self._meta.db_table), backend.quote_name
-backend.quote_name
+qn('_order'), op, qn
+qn(self._meta.db_table), qn
+qn
-            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)
@@ -424 +434 @@
-# 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
-backend.quote_name
-backend.quote_name
+qn(ordered_obj._meta.db_table), qn
+qn
+qn
-    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)])
-
+[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
-backend.quote_name
-backend.quote_name
-backend.quote_name
+qn
+qn
+qn
+qn
-    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

@@ +1 @@
+from django.db import ConnectionInfoDescriptor
-from django.db.models.query import QuerySet, EmptyQuerySet
-from django.dispatch import dispatcher
-
+, 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
@@ -17 +25 @@
-        except FieldDoesNotExist:
-            pass
-        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
-
+
+
-    def __init__(self):
-        super(Manager, self).__init__()
-        # Increase the creation counter, and save our local copy.
@@ -35 +48 @@
-        # TODO: Use weakref because of possible memory leak / circular reference.
-        self.model = model
-        setattr(model, name, ManagerDescriptor(self))
-
+
+
+
-            model._default_manager = self
-
+
-    #######################
-    # PROXIES TO QUERYSET #
-    #######################
@@ -105 +120 @@
-    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.
@@ -115 +194 @@
-        if instance != None:
-            raise AttributeError, "Manager isn't accessible via %s instances" % type.__name__
-        return self.manager
+

django/db/models/options.py

@@ -1 +1 @@
-from django.conf import settings
+from django.db import connection_info, connections
-from django.db.models.related import RelatedObject
-from django.db.models.fields.related import ManyToManyRel
-from django.db.models.fields import AutoField, FieldDoesNotExist
@@ -7 +8 @@
-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()
@@ -79 +81 @@
-            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.
@@ -105 +110 @@
-                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

@@ -12 +12 @@
-_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.
@@ -61 +64 @@
-    get_apps() # Run get_apps() to populate the _app_list cache. Slightly hackish.
-    return _app_errors
-
-
+, 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:
-
+
+
+
+
+
+
-    else:
-        model_list = []
-        for app_mod in app_list:

django/db/models/fields/__init__.py

@@ -536 +536 @@
-                except ValueError:
-                    raise validators.ValidationError, gettext('Enter a valid date/time in YYYY-MM-DD HH:MM format.')
-
-get_db_prep_save(self, value
-# Casts dates into string format for entry into database.
+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)
-
@@ -909 +915 @@
-        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

@@ -1 @@
-backend, 
+
-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
@@ -318 +318 @@
-            # 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 = self.model._default_manager.db.
-
-            # If there aren't any objects, there is nothing to do.
-            if objs:
@@ -343 +343 @@
-                    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 = self.model._default_manager.db.
-
-            # If there aren't any objects, there is nothing to do.
-            if objs:
@@ -366 +366 @@
-                    (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 = self.model._default_manager.db.
-            cursor = connection.cursor()
-            cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
-                (self.join_table, source_col_name),
-                [self._pk_val])
-
+connection
-
-    return ManyRelatedManager
-
@@ -399 +399 @@
-        superclass = rel_model._default_manager.__class__
-        RelatedManager = create_many_related_manager(superclass)
-
-
+rel_model._default_manager.db.
-        manager = RelatedManager(
-            model=rel_model,
-            core_filters={'%s__pk' % self.related.field.name: instance._get_pk_val()},
@@ -440 +440 @@
-        superclass = rel_model._default_manager.__class__
-        RelatedManager = create_many_related_manager(superclass)
-
-
+rel_model._default_manager.db.
-        manager = RelatedManager(
-            model=rel_model,
-            core_filters={'%s__pk' % self.field.related_query_name(): instance._get_pk_val()},

django/db/models/query.py

@@ -182 +182 @@
-        # 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.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params)
-
-        fill_cache = self._select_related
@@ -217 +216 @@
-        """
-        if self._result_cache is not None:
-            return len(self._result_cache)
-
+
+
+
+
+
-        counter = self._clone()
-        counter._order_by = ()
-        counter._select_related = False
@@ -304 +307 @@
-        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."
@@ -481 +485 @@
-
-    def _get_sql_clause(self):
-        opts = self.model._meta
-
+
+
-        # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z.
-
+
+
-        tables = [quote_only_if_word(t) for t in self._tables]
-        joins = SortedDict()
-        where = self._where[:]
@@ -504 +510 @@
-
-        # Add any additional SELECTs.
-        if self._select:
-
+
+
-
-        # Start composing the body of the SQL statement.
-backend.quote_name
+qn
-
-        # Compose the join dictionary into SQL describing the joins.
-        if joins:
@@ -540 +547 @@
-                    order = "ASC"
-                if "." in col_name:
-                    table_prefix, col_name = col_name.split('.', 1)
-backend.quote_name
+qn
-                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 ()):
-backend.quote_name
+qn
-                    else:
-                        table_prefix = ''
-backend.quote_name
+qn
-        if order_by:
-            sql.append("ORDER BY " + ", ".join(order_by))
-
@@ -597 +604 @@
-
-        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')
@@ -623 +639 @@
-    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' % \
-
+
+
-        try:
-            select, sql, params = self._get_sql_clause()
-        except EmptyResultSet:
-            raise StopIteration
-
-backend.quote_name
-backend.quote_name
+qn
+qn
-
-        if backend.allows_group_by_ordinal:
-            group_by = '1'
@@ -768 +790 @@
-            return SortedDict(), [], []
-        return joins, where2, params
-
-
+
+
+
+
-    if table_prefix.endswith('.'):
-backend.quote_name
-backend.quote_name
+qn
+qn
-    if type(value) == datetime.datetime and backend.get_datetime_cast_sql():
-        cast_sql = backend.get_datetime_cast_sql()
-    else:
@@ -832 +857 @@
-    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
@@ -935 +960 @@
-    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
@@ -1092 +1120 @@
-            # Last query term was a normal field.
-            column = field.column
-
-
+current_opts, 
-        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