Changeset 7048

Timestamp:

01/29/08 09:44:21 (9 months ago)

Author:

mtredinnick

Message:

queryset-refactor: Ported almost all of the raw SQL statements in the Model
class over to use queryset operations. This is the first part of a long process
of removing raw SQL from all over the place. The tests pass, but it's quite
possible other stuff won't work yet.

In the process, added tests for order_with_respect_to so that I didn't screw it
up.

Files:

• django/branches/queryset-refactor/django/db/models/base.py (modified) (5 diffs)
• django/branches/queryset-refactor/django/db/models/fields/proxy.py (added)
• django/branches/queryset-refactor/django/db/models/manager.py (modified) (4 diffs)
• django/branches/queryset-refactor/django/db/models/options.py (modified) (2 diffs)
• django/branches/queryset-refactor/django/db/models/query.py (modified) (2 diffs)
• django/branches/queryset-refactor/django/db/models/sql/query.py (modified) (8 diffs)
• django/branches/queryset-refactor/tests/modeltests/model_inheritance/models.py (modified) (1 diff)
• django/branches/queryset-refactor/tests/modeltests/order_with_respect_to (added)
• django/branches/queryset-refactor/tests/modeltests/order_with_respect_to/__init__.py (added)
• django/branches/queryset-refactor/tests/modeltests/order_with_respect_to/models.py (added)

django/branches/queryset-refactor/django/db/models/base.py

@@ -5 +5 @@
-from django.db.models.fields import AutoField, ImageField, FieldDoesNotExist
-from django.db.models.fields.related import OneToOneRel, ManyToOneRel
-
+, Q
-from django.db.models.options import Options, AdminOptions
-from django.db import connection, transaction
@@ -213 +213 @@
-
-        non_pks = [f for f in self._meta.fields if not f.primary_key]
-        cursor = connection.cursor()
-
-        qn = connection.ops.quote_name
-
-        # First, try an UPDATE. If that doesn't update anything, do an INSERT.
@@ -223 +220 @@
-        pk_set = pk_val is not None and smart_unicode(pk_val) != u''
-        record_exists = True
+        manager = self.__class__._default_manager
-        if pk_set:
-            # Determine whether a record with the primary key already exists.
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-            else:
-                record_exists = False
-        if not pk_set or not record_exists:
-
-
-
-
-
-
-
+
+
+
+
+
-            if self._meta.order_with_respect_to:
-
-
-
-
-
-
-
+
+
-            record_exists = False
-
-
-
-
+
+
+
+
+
-            else:
-                # Create a new record with defaults for everything.
-cursor.execute("INSERT INTO %s (%s) VALUES (%s)" %
-(qn(self._meta.db_table), qn(self._meta.pk.column),
-
-self._meta.has_auto_field and not pk_set
-connection.ops.last_insert_id(cursor, self._meta.db_table, self._meta.pk.column)
+result = manager._insert(_return_id=update_pk,
+    _raw_values=True, pk=connection.ops.pk_default_value())
+
+update_pk
+result
-        transaction.commit_unless_managed()
-
@@ -339 +324 @@
-
-    def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
-
-
-
-
-
+
+
-        param = smart_str(getattr(self, field.attname))
-
-
-
-
-
+
+
+
-        try:
-
+s
-        except IndexError:
-            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 = connection.ops.quote_name
-        cachename = "__%s_order_cache" % is_next
-        if not hasattr(self, cachename):
+            qn = connection.ops.quote_name
-            op = is_next and '>' or '<'
+            order = not is_next and '-_order' or '_order'
-            order_field = self._meta.order_with_respect_to
+            # FIXME: When querysets support nested queries, this can be turned
+            # into a pure queryset operation.
-            where = ['%s %s (SELECT %s FROM %s WHERE %s=%%s)' % \
-                (qn('_order'), op, qn('_order'),
-
-
-
-
+
+
+
-            setattr(self, cachename, obj)
-        return getattr(self, cachename)
@@ -446 +428 @@
-
-def method_set_order(ordered_obj, self, id_list):
-    qn = connection.ops.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" % \
-        (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)
-
+
+
+
+
+
-    transaction.commit_unless_managed()
-
-def method_get_order(ordered_obj, self):
-    qn = connection.ops.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" % \
-        (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)
-
-
+
+
+
+
-
-##############################################

django/branches/queryset-refactor/django/db/models/manager.py

@@ -38 +38 @@
-    # PROXIES TO QUERYSET #
-    #######################
-
+
-    def get_empty_query_set(self):
-        return EmptyQuerySet(self.model)
@@ -47 +47 @@
-        """
-        return QuerySet(self.model)
-
+
-    def none(self):
-        return self.get_empty_query_set()
@@ -71 +71 @@
-    def get_or_create(self, **kwargs):
-        return self.get_query_set().get_or_create(**kwargs)
-
+
-    def create(self, **kwargs):
-        return self.get_query_set().create(**kwargs)
@@ -102 +102 @@
-        return self.get_query_set().values(*args, **kwargs)
-
+    def udpate(self, *args, **kwargs):
+        return self.get_query_set().updated(*args, **kwargs)
+
+    def _insert(self, *args, **kwargs):
+        return self.get_query_set()._insert(*args, **kwargs)
+
-class ManagerDescriptor(object):
-    # This class ensures managers aren't accessible via model instances.

django/branches/queryset-refactor/django/db/models/options.py

@@ -3 +3 @@
-from django.db.models.fields.related import ManyToManyRel
-from django.db.models.fields import AutoField, FieldDoesNotExist
+from django.db.models.fields.proxy import OrderWrt
-from django.db.models.loading import get_models, app_cache_ready
-from django.db.models import Manager
@@ -180 +181 @@
-        for f in self.get_all_related_objects():
-            cache[f.field.related_query_name()] = (f, False, False)
+        if self.order_with_respect_to:
+            cache['_order'] = OrderWrt(), True, False
-        if app_cache_ready():
-            self._name_map = cache

django/branches/queryset-refactor/django/db/models/query.py

@@ -264 +264 @@
-        query.add_update_values(kwargs)
-        query.execute_sql(None)
-=
-D
+ = 
+d
-
-    ##################################################
@@ -429 +429 @@
-            except StopIteration:
-                self._iter = None
+
+    def _insert(self, _return_id=False, _raw_values=False, **kwargs):
+        """
+        Inserts a new record for the given model. This provides an interface to
+        the InsertQuery class and is how Model.save() is implemented. It is not
+        part of the public API of QuerySet, though.
+        """
+        self._result_cache = None
+        query = self.query.clone(sql.InsertQuery)
+        query.insert_values(kwargs, _raw_values)
+        return query.execute_sql(_return_id)
+    _insert.alters_data = True
-
-# Use the backend's QuerySet class if it defines one. Otherwise, use _QuerySet.

django/branches/queryset-refactor/django/db/models/sql/query.py

@@ -58 +58 @@
-MULTI = 'multi'
-SINGLE = 'single'
-NONE = None
-
-ORDER_PATTERN = re.compile(r'\?|[-+]?\w+$')
@@ -67 +66 @@
-class Empty(object):
-    pass
+
+class RawValue(object):
+    def __init__(self, value):
+        self.value = value
-
-class Query(object):
@@ -462 +465 @@
-        so this should be run *before* get_from_clause().
-        """
+        # FIXME: It's an SQL-92 requirement that all ordering columns appear as
+        # output columns in the query (in the select statement) or be ordinals.
+        # We don't enforce that here, but we should (by adding to the select
+        # columns), for portability.
-        if self.extra_order_by:
-            ordering = self.extra_order_by
@@ -1070 +1077 @@
-
-        result_type is either MULTI (use fetchmany() to retrieve all rows),
-
+
+
+
-        """
-        try:
@@ -1083 +1092 @@
-        cursor.execute(sql, params)
-
-== NONE
-
+is None
+ cursor
-
-        if result_type == SINGLE:
@@ -1112 +1121 @@
-        self.tables = [table]
-        self.where = where
-ONE
+one
-
-    def delete_batch_related(self, pk_list):
@@ -1186 +1195 @@
-        self.select_related = False
-        self.pre_sql_setup()
+
-        if len(self.tables) != 1:
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        result.append('SET')
-        qn = self.quote_name_unless_alias
-        values, update_params = [], []
-        for name, val in self.values:
@@ -1230 +1251 @@
-            self.values.append((field.column, val))
-
+class InsertQuery(Query):
+    def __init__(self, *args, **kwargs):
+        super(InsertQuery, self).__init__(*args, **kwargs)
+        self._setup_query()
+
+    def _setup_query(self):
+        """
+        Run on initialisation and after cloning.
+        """
+        self.columns = []
+        self.values = []
+
+    def as_sql(self):
+        self.select_related = False
+        self.pre_sql_setup()
+        qn = self.quote_name_unless_alias
+        result = ['INSERT INTO %s' % qn(self.tables[0])]
+        result.append('(%s)' % ', '.join([qn(c) for c in self.columns]))
+        result.append('VALUES (')
+        params = []
+        first = True
+        for value in self.values:
+            prefix = not first and ', ' or ''
+            if isinstance(value, RawValue):
+                result.append('%s%s' % (prefix, value.value))
+            else:
+                result.append('%s%%s' % prefix)
+                params.append(value)
+            first = False
+        result.append(')')
+        return ' '.join(result), tuple(params)
+
+    def execute_sql(self, return_id=False):
+        cursor = super(InsertQuery, self).execute_sql(None)
+        if return_id:
+            return self.connection.ops.last_insert_id(cursor, self.tables[0],
+                    self.model._meta.pk.column)
+
+    def insert_values(self, insert_values, raw_values=False):
+        """
+        Set up the insert query from the 'insert_values' dictionary. The
+        dictionary gives the model field names and their target values.
+
+        If 'raw_values' is True, the values in the 'insert_values' dictionary
+        are inserted directly into the query, rather than passed as SQL
+        parameters. This provides a way to insert NULL and DEFAULT keywords
+        into the query, for example.
+        """
+        func = lambda x: self.model._meta.get_field_by_name(x)[0].column
+        # keys() and values() return items in the same order, providing the
+        # dictionary hasn't changed between calls. So these lines work as
+        # intended.
+        for name in insert_values:
+            if name == 'pk':
+                name = self.model._meta.pk.name
+            self.columns.append(func(name))
+        if raw_values:
+            self.values.extend([RawValue(v) for v in insert_values.values()])
+        else:
+            self.values.extend(insert_values.values())
+
-class DateQuery(Query):
-    """

django/branches/queryset-refactor/tests/modeltests/model_inheritance/models.py

@@ -27 +27 @@
-        return u"%s the italian restaurant" % self.name
-
-
+
+
+
-# Make sure Restaurant has the right fields in the right order.
->>> [f.name for f in Restaurant._meta.fields]