Ticket #7210: expr.2.diff

a/django/contrib/sites/management.py

@@ -13 +13 @@
-            print "Creating example.com Site object"
-        s = Site(domain="example.com", name="example.com")
-        s.save()
-    Site.objects.clear_cache()
-
-dispatcher.connect(create_default_site, sender=site_app, signal=signals.post_syncdb)

a/django/contrib/sites/models.py

@@ -44 +44 @@
-    def __unicode__(self):
-        return self.domain
-
-    def delete(self):
-        pk = self.pk
-        super(Site, self).delete()
-        try:
-            del(SITE_CACHE[pk])
-        except KeyError:
-            pass
-        
-
-class RequestSite(object):
-    """
-    A class that shares the primary interface of Site (i.e., it has

/dev/null

@@ -1 @@
-"""
->>> # Make sure that get_current() does not return a deleted Site object.
->>> from django.contrib.sites.models import Site
->>> s = Site.objects.get_current()
->>> s
-<Site: example.com>
-
->>> s.delete()
->>> Site.objects.get_current()
-Traceback (most recent call last):
-...
-DoesNotExist: Site matching query does not exist.
-"""

a/django/db/models/__init__.py

@@ -4 +4 @@
-from django.db import connection
-from django.db.models.loading import get_apps, get_app, get_models, get_model, register_models
-from django.db.models.query import Q
+from django.db.models.sql.expressions import F
-from django.db.models.manager import Manager
-from django.db.models.base import Model, AdminOptions
-from django.db.models.fields import *

a/django/db/models/base.py

@@ -10 +10 @@
-from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned, FieldError
-from django.db.models.fields import AutoField, ImageField, FieldDoesNotExist
-from django.db.models.fields.related import OneToOneRel, ManyToOneRel, OneToOneField
-, CollectedObjects
+
-from django.db.models.options import Options, AdminOptions
-from django.db import connection, transaction
-from django.db.models import signals
@@ -368 +368 @@
-                error_dict[f.name] = errors
-        return error_dict
-
-, parent=None, nullable=False
+
-        """
-        Recursively populates seen_objs with all objects related to this object.
-.items()
-[(model_class, {pk_val: obj, pk_val: obj, ...})
-(model_class, {pk_val: obj, pk_val: obj, ...}),...]
+
+{model_class: {pk_val: obj, pk_val: obj, ...}
+model_class: {pk_val: obj, pk_val: obj, ...}, ...}
-        """
-        pk_val = self._get_pk_val()
-seen_objs.add(self.__class__, pk_val, self, parent, nullable
+pk_val in seen_objs.setdefault(self.__class__, {}
-            return
+        seen_objs[self.__class__][pk_val] = self
-
-        for related in self._meta.get_all_related_objects():
-            rel_opts_name = related.get_accessor_name()
@@ -387 +388 @@
-                except ObjectDoesNotExist:
-                    pass
-                else:
-, self.__class__, related.field.null
+
-            else:
-                for sub_obj in getattr(self, rel_opts_name).all():
-, self.__class__, related.field.null
+
-
-    def delete(self):
-        assert self._get_pk_val() is not None, "%s object can't be deleted because its %s attribute is set to None." % (self._meta.object_name, self._meta.pk.attname)
-
-        # Find all the objects than need to be deleted
-CollectedObjects
+SortedDict
-        self._collect_sub_objects(seen_objs)
-
-        # Actually delete the objects

a/django/db/models/loading.py

@@ -2 +2 @@
-
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
-from django.utils.datastructures import SortedDict
-
-import sys
-import os
-import threading
@@ -20 +18 @@
-    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66531.
-    __shared_state = dict(
-        # Keys of app_store are the model modules for each application.
-SortedDict()
+{}
-
-        # Mapping of app_labels to a dictionary of model names to model code.
-SortedDict()
+{}
-
-        # Mapping of app_labels to errors raised when trying to import the app.
-        app_errors = {},
@@ -135 +133 @@
-        """
-        self._populate()
-        if app_mod:
-SortedDict()
+{}
-        else:
-            model_list = []
-            for app_entry in self.app_models.itervalues():
@@ -151 +149 @@
-        """
-        if seed_cache:
-            self._populate()
-SortedDict()
+{}
-
-    def register_models(self, app_label, *models):
-        """
@@ -161 +159 @@
-            # Store as 'name: model' pair in a dictionary
-            # in the app_models dictionary
-            model_name = model._meta.object_name.lower()
-SortedDict()
+{}
-            if model_name in model_dict:
-                # The same model may be imported via different paths (e.g.
-                # appname.models and project.appname.models). We use the source

a/django/db/models/query.py

@@ -16 +16 @@
-# Pull into this namespace for backwards compatibility
-EmptyResultSet = sql.EmptyResultSet
-
-class CyclicDependency(Exception):
-    pass
-
-class CollectedObjects(object):
-    """
-    A container that stores keys and lists of values along with
-    remembering the parent objects for all the keys.
-
-    This is used for the database object deletion routines so that we
-    can calculate the 'leaf' objects which should be deleted first.
-    """
-
-    def __init__(self):
-        self.data = {}
-        self.children = {}
-
-    def add(self, model, pk, obj, parent_model, nullable=False):
-        """
-        Adds an item.
-        model is the class of the object being added,
-        pk is the primary key, obj is the object itself, 
-        parent_model is the model of the parent object
-        that this object was reached through, nullable should
-        be True if this relation is nullable.
-
-        If the item already existed in the structure,
-        returns true, otherwise false.
-        """
-        d = self.data.setdefault(model, SortedDict())
-        retval = pk in d
-        d[pk] = obj
-        # Nullable relationships can be ignored -- they
-        # are nulled out before deleting, and therefore
-        # do not affect the order in which objects have
-        # to be deleted.
-        if parent_model is not None and not nullable:
-            self.children.setdefault(parent_model, []).append(model)
-
-        return retval
-
-    def __contains__(self, key):
-        return self.data.__contains__(key)
-
-    def __getitem__(self, key):
-        return self.data[key]
-
-    def __nonzero__(self):
-        return bool(self.data)
-
-    def iteritems(self):
-        for k in self.ordered_keys():
-            yield k, self[k]
-
-    def items(self):
-        return list(self.iteritems())
-
-    def keys(self):
-        return self.ordered_keys()
-
-    def ordered_keys(self):
-        """
-        Returns the models in the order that they should be 
-        dealth with i.e. models with no dependencies first.
-        """
-        dealt_with = SortedDict()
-        # Start with items that have no children
-        models = self.data.keys()
-        while len(dealt_with) < len(models):
-            found = False
-            for model in models:
-                children = self.children.setdefault(model, [])
-                if len([c for c in children if c not in dealt_with]) == 0:
-                    dealt_with[model] = None
-                    found = True
-            if not found:
-                raise CyclicDependency("There is a cyclic dependency of items to be processed.")
-            
-        return dealt_with.keys()
-
-    def unordered_keys(self):
-        """
-        Fallback for the case where is a cyclic dependency but we
-        don't care.
-        """
-        return self.data.keys()
-
-class QuerySet(object):
-    "Represents a lazy database lookup for a set of objects"
-    def __init__(self, model=None, query=None):
@@ -361 +275 @@
-        while 1:
-            # Collect all the objects to be deleted in this chunk, and all the
-            # objects that are related to the objects that are to be deleted.
-CollectedObjects
+SortedDict
-            for object in del_query[:CHUNK_SIZE]:
-                object._collect_sub_objects(seen_objs)
-
@@ -768 +682 @@
-    Iterate through a list of seen classes, and remove any instances that are
-    referred to.
-    """
-
-
-
-
-
-
-
-
-
-
+
+
+
-    for cls in ordered_classes:
-
-
-
+
+
-
-        # Pre notify all instances to be deleted
-items
+seen_objs[cls]
-            dispatcher.send(signal=signals.pre_delete, sender=cls,
-                    instance=instance)
-
-items
+seen_objs[cls]
-        del_query = sql.DeleteQuery(cls, connection)
-        del_query.delete_batch_related(pk_list)
-
@@ -799 +705 @@
-
-    # Now delete the actual data
-    for cls in ordered_classes:
-
-
-
-
+
+
-        del_query = sql.DeleteQuery(cls, connection)
-        del_query.delete_batch(pk_list)
-
-        # Last cleanup; set NULLs where there once was a reference to the
-        # object, NULL the primary key of the found objects, and perform
-        # post-notification.
-items
+seen_objs[cls]
-            for field in cls._meta.fields:
-                if field.rel and field.null and field.rel.to in seen_objs:
-                    setattr(instance, field.attname, None)

/dev/null

@@ +1 @@
+from copy import deepcopy
+from datetime import datetime
+
+from django.utils import tree
+from django.core.exceptions import FieldError
+from django.db import connection
+from django.db.models.fields import Field, FieldDoesNotExist
+from django.db.models.query_utils import QueryWrapper
+
+class Expression(object):
+    """
+    Base class for all sql expressions, expected by QuerySet.update.
+    """
+    # Arithmetic connection types
+    ADD = '+'
+    SUB = '-'
+    MUL = '*'
+    DIV = '/'
+    MOD = '%%'
+
+    # Bitwise connection types
+    AND = '&'
+    OR = '|'
+
+    def _combine(self, other, conn, reversed, node=None):
+        if reversed:
+            obj = ExpressionNode([Literal(other)], conn)
+            obj.add(node or self, conn)
+        else:
+            obj = node or ExpressionNode([self], conn)
+            if isinstance(other, Expression):
+                obj.add(other, conn)
+            else:
+                obj.add(Literal(other), conn)
+        return obj
+
+    def __add__(self, other):
+        return self._combine(other, self.ADD, False)
+
+    def __sub__(self, other):
+        return self._combine(other, self.SUB, False)
+
+    def __mul__(self, other):
+        return self._combine(other, self.MUL, False)
+
+    def __div__(self, other):
+        return self._combine(other, self.DIV, False)
+
+    def __mod__(self, other):
+        return self._combine(other, self.MOD, False)
+
+    def __and__(self, other):
+        return self._combine(other, self.AND, False)
+
+    def __or__(self, other):
+        return self._combine(other, self.OR, False)
+
+    def __radd__(self, other):
+        return self._combine(other, self.ADD, True)
+
+    def __rsub__(self, other):
+        return self._combine(other, self.SUB, True)
+
+    def __rmul__(self, other):
+        return self._combine(other, self.MUL, True)
+
+    def __rdiv__(self, other):
+        return self._combine(other, self.DIV, True)
+
+    def __rmod__(self, other):
+        return self._combine(other, self.MOD, True)
+
+    def __rand__(self, other):
+        return self._combine(other, self.AND, True)
+
+    def __ror__(self, other):
+        return self._combine(other, self.OR, True)
+
+    def as_sql(self, opts, field, prep_func=None, qn=None):
+        raise NotImplementedError
+
+class ExpressionNode(Expression, tree.Node):
+    default = None
+
+    def __init__(self, children=None, connector=None, negated=False):
+        if children is not None and len(children) > 1 and connector is None:
+            raise TypeError('You have to specify a connector.')
+        super(ExpressionNode, self).__init__(children, connector, negated)
+
+    def _combine(self, *args, **kwargs):
+        return super(ExpressionNode, self)._combine(node=deepcopy(self), *args, **kwargs)
+
+    def as_sql(self, opts, field, prep_func=None, qn=None, node=None):
+        if not qn:
+            qn = connection.ops.quote_name
+        if node is None:
+            node = self
+
+        result = []
+        result_params = []
+        for child in node.children:
+            if hasattr(child, 'as_sql'):
+                sql, params = child.as_sql(opts, field, prep_func, qn)
+                format = '%s'
+            else:
+                sql, params = self.as_sql(opts, field, prep_func, qn, child)
+                if len(child.children) > 1:
+                    format = '(%s)'
+                else:
+                    format = '%s'
+            if sql:
+                result.append(format % sql)
+                result_params.extend(params)
+        conn = ' %s ' % node.connector
+        return conn.join(result), result_params
+
+class Literal(Expression):
+    """
+    An expression representing the given value.
+    """
+    def __init__(self, value):
+        self.value = value
+
+    def as_sql(self, opts, field, prep_func=None, qn=None):
+        if self.value is None:
+            return 'NULL', ()
+
+        if isinstance(self.value, datetime):
+            sql = connection.ops.datetime_cast_sql()
+        else:
+            sql = '%s'
+        params = prep_func and prep_func(self.value) or (self.value,)
+
+        if isinstance(params, QueryWrapper):
+            return params.data
+        return sql, params
+
+class F(Expression):
+    """
+    An expression representing the value of the given field.
+    """
+    def __init__(self, name):
+        self.name = name
+
+    def as_sql(self, opts, field, prep_func=None, qn=None):
+        if not qn:
+            qn = connection.ops.quote_name
+
+        try:
+            src_field = opts.get_field(self.name)
+        except FieldDoesNotExist:
+            names = opts.get_all_field_names()
+            raise FieldError('Cannot resolve keyword %r into field. '
+                    'Choices are: %s' % (self.name, ', '.join(names)))
+
+        field_sql = connection.ops.field_cast_sql(src_field.db_type())
+        lhs = '%s.%s' % (qn(opts.db_table), qn(src_field.column))
+        return field_sql % lhs, ()

a/django/db/models/sql/query.py

@@ -250 +250 @@
-        # get_from_clause() for details.
-        from_, f_params = self.get_from_clause()
-
-
+self.get_meta(), 
-        params = list(self.extra_select_params)
-
-        result = ['SELECT']

a/django/db/models/sql/subqueries.py

@@ -7 +7 @@
-from django.db.models.sql.datastructures import Date
-from django.db.models.sql.query import Query
-from django.db.models.sql.where import AND
+from django.db.models.sql.expressions import Expression, Literal
-
-__all__ = ['DeleteQuery', 'UpdateQuery', 'InsertQuery', 'DateQuery',
-        'CountQuery']
@@ -24 +25 @@
-        assert len(self.tables) == 1, \
-                "Can only delete from one table at a time."
-        result = ['DELETE FROM %s' % self.quote_name_unless_alias(self.tables[0])]
-
+self.get_meta()
-        result.append('WHERE %s' % where)
-        return ' '.join(result), tuple(params)
-
@@ -126 +127 @@
-        result = ['UPDATE %s' % qn(table)]
-        result.append('SET')
-        values, update_params = [], []
-
-
-
-
-
-
+
+
+
-        result.append(', '.join(values))
-
+self.get_meta()
-        if where:
-            result.append('WHERE %s' % where)
-        return ' '.join(result), tuple(update_params + params)
@@ -207 +205 @@
-            self.where.add((None, f.column, f, 'in',
-                    pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]),
-                    AND)
-None, '%s'
+'NULL', ()
-            self.execute_sql(None)
-
-    def add_update_values(self, values):
@@ -232 +230 @@
-        """
-        from django.db.models.base import Model
-        for field, model, val in values_seq:
-
-
-
-
-
-
-
+
+
-            else:
-
+
+
+
+
+
+
+
-
-            if model:
-val, placeholder
+sql, params
-            else:
-val, placeholder
+sql, params
-
-value, placeholder
+sql, params
-        """
-        Adds (name, value) to an update query for an ancestor model.
-
-        Updates are coalesced so that we only run one update query per ancestor.
-        """
-        try:
-value, placeholder
+sql, params
-        except KeyError:
-value, placeholder
+sql, params
-
-    def get_related_updates(self):
-        """
@@ -312 +311 @@
-        parameters. This provides a way to insert NULL and DEFAULT keywords
-        into the query, for example.
-        """
-placeholders, values = [],
+values =
-        for field, val in insert_values:
-            if hasattr(field, 'get_placeholder'):
-                # Some fields (e.g. geo fields) need special munging before
-                # they can be inserted.
-                placeholders.append(field.get_placeholder(val))
-            else:
-                placeholders.append('%s')
-
-            self.columns.append(field.column)
-            values.append(val)
-        if raw_values:
-            self.values.extend(values)
-        else:
-            self.params += tuple(values)
-placeholders
+['%s'] * len(values)
-
-class DateQuery(Query):
-    """

a/django/db/models/sql/where.py

@@ -4 +4 @@
-import datetime
-
-from django.utils import tree
+from django.utils.functional import curry
-from django.db import connection
-from django.db.models.fields import Field
-from django.db.models.query_utils import QueryWrapper
+from django.db.models.sql.expressions import Expression, Literal
-from datastructures import EmptyResultSet, FullResultSet
-
-# Connection types
@@ -26 +28 @@
-    """
-    default = AND
-
-
+opts, 
-        """
-        Returns the SQL version of the where clause and the value to be
-        substituted in. Returns None, None if this node is empty.
@@ -47 +49 @@
-        for child in node.children:
-            try:
-                if hasattr(child, 'as_sql'):
-
+opts, 
-                    format = '(%s)'
-                elif isinstance(child, tree.Node):
-
+opts, 
-                    if child.negated:
-                        format = 'NOT (%s)'
-                    elif len(child.children) == 1:
@@ -58 +60 @@
-                    else:
-                        format = '(%s)'
-                else:
-
+opts, 
-                    format = '%s'
-            except EmptyResultSet:
-                if node.connector == AND and not node.negated:
@@ -86 +88 @@
-        conn = ' %s ' % node.connector
-        return conn.join(result), result_params
-
-
+opts, 
-        """
-        Turn a tuple (table_alias, field_name, field_class, lookup_type, value)
-        into valid SQL.
@@ -99 +101 @@
-            lhs = '%s.%s' % (qn(table_alias), qn(name))
-        else:
-            lhs = qn(name)
+        if not field:
+            field = Field()
-        db_type = field and field.db_type() or None
-        field_sql = connection.ops.field_cast_sql(db_type) % lhs
+        prep_func = curry(field.get_db_prep_lookup, lookup_type)
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        if isinstance(params, QueryWrapper):
-            extra, params = params.data
-        else:
-            extra = ''
-
-        if lookup_type in connection.operators:
-            format = "%s %%s %s" % (connection.ops.lookup_cast(lookup_type),
-                    extra)
-            return (format % (field_sql,
-                    connection.operators[lookup_type] % cast_sql), params)
-
-        if lookup_type == 'in':
-            if not value:
-                raise EmptyResultSet
-            if extra:
-                return ('%s IN %s' % (field_sql, extra), params)
-
-
+
-        elif lookup_type in ('range', 'year'):
-            return ('%s BETWEEN %%s and %%s' % field_sql, params)
-        elif lookup_type in ('month', 'day'):
@@ -164 +169 @@
-    """
-    A node that matches everything.
-    """
-
+opts, 
-        raise FullResultSet
-
-    def relabel_aliases(self, change_map, node=None):

/dev/null

@@ -1 @@
-# coding: utf-8
-"""
-Tests for some corner cases with deleting.
-"""
-
-from django.db import models
-
-class DefaultRepr(object):
-    def __repr__(self):
-        return u"<%s: %s>" % (self.__class__.__name__, self.__dict__)
-
-class A(DefaultRepr, models.Model):
-    pass
-
-class B(DefaultRepr, models.Model):
-    a = models.ForeignKey(A)
-
-class C(DefaultRepr, models.Model):
-    b = models.ForeignKey(B)
-
-class D(DefaultRepr, models.Model):
-    c = models.ForeignKey(C)
-    a = models.ForeignKey(A)
-
-# Simplified, we have:
-# A
-# B -> A
-# C -> B
-# D -> C
-# D -> A
-
-# So, we must delete Ds first of all, then Cs then Bs then As.
-# However, if we start at As, we might find Bs first (in which 
-# case things will be nice), or find Ds first.
-
-# Some mutually dependent models, but nullable
-class E(DefaultRepr, models.Model):
-    f = models.ForeignKey('F', null=True, related_name='e_rel')
-
-class F(DefaultRepr, models.Model):
-    e = models.ForeignKey(E, related_name='f_rel')
-
-
-__test__ = {'API_TESTS': """
-# First, some tests for the datastructure we use
-
->>> from django.db.models.query import CollectedObjects
-
->>> g = CollectedObjects()
->>> g.add("key1", 1, "item1", None)
-False
->>> g["key1"]
-{1: 'item1'}
->>> g.add("key2", 1, "item1", "key1")
-False
->>> g.add("key2", 2, "item2", "key1")
-False
->>> g["key2"]
-{1: 'item1', 2: 'item2'}
->>> g.add("key3", 1, "item1", "key1")
-False
->>> g.add("key3", 1, "item1", "key2")
-True
->>> g.ordered_keys()
-['key3', 'key2', 'key1']
-
->>> g.add("key2", 1, "item1", "key3")
-True
->>> g.ordered_keys()
-Traceback (most recent call last):
-    ...
-CyclicDependency: There is a cyclic dependency of items to be processed.
-
-
-
-# Due to the way that transactions work in the test harness,
-# doing m.delete() here can work but fail in a real situation,
-# since it may delete all objects, but not in the right order.
-# So we manually check that the order of deletion is correct.
-
-# Also, it is possible that the order is correct 'accidentally', due
-# solely to order of imports etc.  To check this, we set the order
-# that 'get_models()' will retrieve to a known 'nice' order, and
-# then try again with a known 'tricky' order.  Slightly naughty
-# access to internals here :-)
-
->>> from django.db.models.loading import cache
-
-# Nice order
->>> cache.app_models['delete'].keyOrder = ['a', 'b', 'c', 'd']
->>> del A._meta._related_objects_cache
->>> del B._meta._related_objects_cache
->>> del C._meta._related_objects_cache
->>> del D._meta._related_objects_cache
-
->>> a1 = A()
->>> a1.save()
->>> b1 = B(a=a1)
->>> b1.save()
->>> c1 = C(b=b1)
->>> c1.save()
->>> d1 = D(c=c1, a=a1)
->>> d1.save()
-
->>> o = CollectedObjects()
->>> a1._collect_sub_objects(o)
->>> o.keys()
-[<class 'modeltests.delete.models.D'>, <class 'modeltests.delete.models.C'>, <class 'modeltests.delete.models.B'>, <class 'modeltests.delete.models.A'>]
->>> a1.delete()
-
-# Same again with a known bad order
->>> cache.app_models['delete'].keyOrder = ['d', 'c', 'b', 'a']
->>> del A._meta._related_objects_cache
->>> del B._meta._related_objects_cache
->>> del C._meta._related_objects_cache
->>> del D._meta._related_objects_cache
-
->>> a2 = A()
->>> a2.save()
->>> b2 = B(a=a2)
->>> b2.save()
->>> c2 = C(b=b2)
->>> c2.save()
->>> d2 = D(c=c2, a=a2)
->>> d2.save()
-
->>> o = CollectedObjects()
->>> a2._collect_sub_objects(o)
->>> o.keys()
-[<class 'modeltests.delete.models.D'>, <class 'modeltests.delete.models.C'>, <class 'modeltests.delete.models.B'>, <class 'modeltests.delete.models.A'>]
->>> a2.delete()
-
-# Tests for nullable related fields
-
->>> g = CollectedObjects()
->>> g.add("key1", 1, "item1", None)
-False
->>> g.add("key2", 1, "item1", "key1", nullable=True)
-False
->>> g.add("key1", 1, "item1", "key2")
-True
->>> g.ordered_keys()
-['key1', 'key2']
-
->>> e1 = E()
->>> e1.save()
->>> f1 = F(e=e1)
->>> f1.save()
->>> e1.f = f1
->>> e1.save()
-
-# Since E.f is nullable, we should delete F first (after nulling out
-# the E.f field), then E.
-
->>> o = CollectedObjects()
->>> e1._collect_sub_objects(o)
->>> o.keys()
-[<class 'modeltests.delete.models.F'>, <class 'modeltests.delete.models.E'>]
-
->>> e1.delete()
-
->>> e2 = E()
->>> e2.save()
->>> f2 = F(e=e2)
->>> f2.save()
->>> e2.f = f2
->>> e2.save()
-
-# Same deal as before, though we are starting from the other object.
-
->>> o = CollectedObjects()
->>> f2._collect_sub_objects(o)
->>> o.keys()
-[<class 'modeltests.delete.models.F'>, <class 'modeltests.delete.models.E'>]
-
->>> f2.delete()
-
-"""
-}

/dev/null

@@ +1 @@
+"""
+Tests for the update() queryset method that allows in-place, multi-object
+updates.
+"""
+
+from django.db import models
+
+#
+# Model for testing arithmetic expressions.
+#
+
+class Number(models.Model):
+    integer = models.IntegerField()
+    float = models.FloatField(null=True)
+
+    def __unicode__(self):
+        return u'%i, %.3f' % (self.integer, self.float)
+
+#
+# A more ordinary use case.
+#
+
+class Employee(models.Model):
+    firstname = models.CharField(max_length=50)
+    lastname = models.CharField(max_length=50)
+
+    def __unicode__(self):
+        return u'%s %s' % (self.firstname, self.lastname)
+
+class Company(models.Model):
+    name = models.CharField(max_length=100)
+    num_employees = models.PositiveIntegerField()
+    num_chairs = models.PositiveIntegerField()
+    ceo = models.ForeignKey(
+        Employee,
+        related_name='company_ceo_set')
+    point_of_contact = models.ForeignKey(
+        Employee,
+        related_name='company_point_of_contact_set',
+        null=True)
+
+    def __unicode__(self):
+        return self.name
+
+
+__test__ = {'API_TESTS': """
+>>> from django.db.models import F
+
+>>> Number(integer=-1).save()
+>>> Number(integer=42).save()
+>>> Number(integer=1337).save()
+
+We can fill a value in all objects with an other value of the same object.
+
+>>> Number.objects.update(float=F('integer'))
+>>> Number.objects.all()
+[<Number: -1, -1.000>, <Number: 42, 42.000>, <Number: 1337, 1337.000>]
+
+We can increment a value of all objects in a query set.
+
+>>> Number.objects.filter(integer__gt=0).update(integer=F('integer') + 1)
+>>> Number.objects.all()
+[<Number: -1, -1.000>, <Number: 43, 42.000>, <Number: 1338, 1337.000>]
+
+We can filter for objects, where a value is not equals the value of an other field.
+
+>>> Number.objects.exclude(float=F('integer'))
+[<Number: 43, 42.000>, <Number: 1338, 1337.000>]
+
+Complex expressions of different connection types are possible.
+
+>>> n = Number.objects.create(integer=10, float=123.45)
+>>> Number.objects.filter(pk=n.pk).update(float=F('integer') + F('float') * 2)
+>>> Number.objects.get(pk=n.pk)
+<Number: 10, 256.900>
+
+All supported operators, work as expected in native and reverse order.
+
+>>> from operator import add, sub, mul, div, mod, and_, or_
+>>> for op in (add, sub, mul, div, mod, and_, or_):
+...     n = Number.objects.create(integer=42, float=15.)
+...     Number.objects.filter(pk=n.pk).update(
+...         integer=op(F('integer'), 15), float=op(42., F('float')))
+...     Number.objects.get(pk=n.pk)
+<Number: 57, 57.000>
+<Number: 27, 27.000>
+<Number: 630, 630.000>
+<Number: 3, 2.800>
+<Number: 12, 12.000>
+<Number: 10, 10.000>
+<Number: 47,