[multi-db] Updated Model and its utility functions to access the db connection through the default manager.

git-svn-id: http://code.djangoproject.com/svn/django/branches/multiple-db-support@3365 bcc190cf-cafb-0310-a4f2-bffc1f526a37

1 files changed, 43 insertions, 41 deletions

diff --git a/django/db/models/base.py b/django/db/models/base.py
index e40c3350ae..c9336c8fdb 100644
--- a/django/db/models/base.py
+++ b/django/db/models/base.py
@@ -163,9 +163,10 @@ class Model(object):
     def save(self):
         dispatcher.send(signal=signals.pre_save, sender=self.__class__, instance=self)
 
-        info = self._meta.connection_info
-        connection = info.connection
-        backend = info.backend
+        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()
 
@@ -176,19 +177,19 @@ class Model(object):
         if pk_set:
             # Determine whether a record with the primary key already exists.
             cursor.execute("SELECT 1 FROM %s WHERE %s=%%s LIMIT 1" % \
-                (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)), [pk_val])
+                (qn(self._meta.db_table), qn(self._meta.pk.column)), [pk_val])
             # If it does already exist, do an UPDATE.
             if cursor.fetchone():
                 db_values = [f.get_db_prep_save(f.pre_save(self, False)) for f in non_pks]
                 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 + [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:
@@ -196,20 +197,20 @@ class Model(object):
                 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))
@@ -284,11 +285,11 @@ class Model(object):
         return dict(field.choices).get(value, value)
 
     def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
-        backend = self._meta.connection_info.backend
+        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)
@@ -299,15 +300,16 @@ class Model(object):
             raise self.DoesNotExist, "%s matching query does not exist." % self.__class__._meta.object_name
 
     def _get_next_or_previous_in_order(self, is_next):
-        backend = self._meta.connection_info.backend
+        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)
@@ -388,17 +390,17 @@ class Model(object):
         rel = rel_field.rel.to
         m2m_table = rel_field.m2m_db_table()
         this_id = self._get_pk_val()
-        info = self._meta.connection_info
-        connection = info.connection
-        backend = info.backend
+        db = self._default_manager.db
+        connection = db.connection
+        qn = db.backend.quote_name
         cursor = connection.cursor()
         cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
-            (backend.quote_name(m2m_table),
-            backend.quote_name(rel_field.m2m_column_name())), [this_id])
+            (qn(m2m_table),
+            qn(rel_field.m2m_column_name())), [this_id])
         sql = "INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
-            (backend.quote_name(m2m_table),
-            backend.quote_name(rel_field.m2m_column_name()),
-            backend.quote_name(rel_field.m2m_reverse_name()))
+            (qn(m2m_table),
+            qn(rel_field.m2m_column_name()),
+            qn(rel_field.m2m_reverse_name()))
         cursor.executemany(sql, [(this_id, i) for i in id_list])
         transaction.commit_unless_managed([connection])
 
@@ -409,30 +411,30 @@ class Model(object):
 # ORDERING METHODS #########################
 
 def method_set_order(ordered_obj, self, id_list):
-    connection_info = ordered_obj._meta.connection_info
-    connection = info.connection
-    backend = info.backend    
+    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([connection])
 
 def method_get_order(ordered_obj, self):
-    connection_info = ordered_obj.connection_info
-    connection = info.connection
-    backend = info.backend
+    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()]