diff --git a/django/db/models/query.py b/django/db/models/query.py
index 9323e9b..8b0bce6 100644
--- a/django/db/models/query.py
+++ b/django/db/models/query.py
@@ -698,9 +698,6 @@ class ValuesQuerySet(QuerySet):
 
     def iterator(self):
         # Purge any extra columns that haven't been explicitly asked for
-        if self.extra_names is not None:
-            self.query.trim_extra_select(self.extra_names)
-
         extra_names = self.query.extra_select.keys()
         field_names = self.field_names
         aggregate_names = self.query.aggregate_select.keys()
@@ -724,13 +721,15 @@ class ValuesQuerySet(QuerySet):
         if self._fields:
             self.extra_names = []
             self.aggregate_names = []
-            if not self.query.extra_select and not self.query.aggregate_select:
+            if not self.query._extra_select and not self.query.aggregate_select:
                 self.field_names = list(self._fields)
             else:
                 self.query.default_cols = False
                 self.field_names = []
                 for f in self._fields:
-                    if self.query.extra_select.has_key(f):
+                    # we poke at the inner attribute here since we might be adding
+                    # back an extra select item that we hadn't had selected previously.
+                    if self.query._extra_select.has_key(f):
                         self.extra_names.append(f)
                     elif self.query.aggregate_select.has_key(f):
                         self.aggregate_names.append(f)
@@ -743,6 +742,8 @@ class ValuesQuerySet(QuerySet):
             self.aggregate_names = None
 
         self.query.select = []
+        if self.extra_names is not None:
+            self.query.set_extra_mask(self.extra_names)
         self.query.add_fields(self.field_names, False)
         if self.aggregate_names is not None:
             self.query.set_aggregate_mask(self.aggregate_names)
@@ -799,9 +800,6 @@ class ValuesQuerySet(QuerySet):
 
 class ValuesListQuerySet(ValuesQuerySet):
     def iterator(self):
-        if self.extra_names is not None:
-            self.query.trim_extra_select(self.extra_names)
-
         if self.flat and len(self._fields) == 1:
             for row in self.query.results_iter():
                 yield row[0]
diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index f4bf8b2..8960e8e 100644
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -88,7 +88,9 @@ class BaseQuery(object):
 
         # These are for extensions. The contents are more or less appended
         # verbatim to the appropriate clause.
-        self.extra_select = SortedDict()  # Maps col_alias -> (col_sql, params).
+        self._extra_select = SortedDict()  # Maps col_alias -> (col_sql, params).
+        self.extra_select_mask = None # says which items from extra_select should
+                                      # actually be selected
         self.extra_tables = ()
         self.extra_where = ()
         self.extra_params = ()
@@ -220,7 +222,11 @@ class BaseQuery(object):
         else:
             obj._aggregate_select_cache = self._aggregate_select_cache.copy()
         obj.max_depth = self.max_depth
-        obj.extra_select = self.extra_select.copy()
+        obj._extra_select = self._extra_select.copy()
+        if self.extra_select_mask is None:
+            obj.extra_select_mask = None
+        else:
+            obj.extra_select_mask = self.extra_select_mask[:]
         obj.extra_tables = self.extra_tables
         obj.extra_where = self.extra_where
         obj.extra_params = self.extra_params
@@ -325,7 +331,7 @@ class BaseQuery(object):
             query = self
             self.select = []
             self.default_cols = False
-            self.extra_select = {}
+            self._extra_select = {}
             self.remove_inherited_models()
 
         query.clear_ordering(True)
@@ -540,13 +546,21 @@ class BaseQuery(object):
             # It would be nice to be able to handle this, but the queries don't
             # really make sense (or return consistent value sets). Not worth
             # the extra complexity when you can write a real query instead.
-            if self.extra_select and rhs.extra_select:
+            if self._extra_select and rhs._extra_select:
                 raise ValueError("When merging querysets using 'or', you "
                         "cannot have extra(select=...) on both sides.")
             if self.extra_where and rhs.extra_where:
                 raise ValueError("When merging querysets using 'or', you "
                         "cannot have extra(where=...) on both sides.")
-        self.extra_select.update(rhs.extra_select)
+        self._extra_select.update(rhs._extra_select)
+        extra_select_mask = []
+        if self.extra_select_mask is not None:
+            extra_select_mask.extend(self.extra_select_mask)
+        if rhs.extra_select_mask is not None:
+            extra_select_mask.extend(rhs.extra_select_mask)
+        if not extra_select_mask:
+            extra_select_mask = None
+        self.extra_select_mask = extra_select_mask
         self.extra_tables += rhs.extra_tables
         self.extra_where += rhs.extra_where
         self.extra_params += rhs.extra_params
@@ -2011,7 +2025,7 @@ class BaseQuery(object):
         except MultiJoin:
             raise FieldError("Invalid field name: '%s'" % name)
         except FieldError:
-            names = opts.get_all_field_names() + self.extra_select.keys() + self.aggregate_select.keys()
+            names = opts.get_all_field_names() + self._extra_select.keys() + self.aggregate_select.keys()
             names.sort()
             raise FieldError("Cannot resolve keyword %r into field. "
                     "Choices are: %s" % (name, ", ".join(names)))
@@ -2139,7 +2153,7 @@ class BaseQuery(object):
                     pos = entry.find("%s", pos + 2)
                 select_pairs[name] = (entry, entry_params)
             # This is order preserving, since self.extra_select is a SortedDict.
-            self.extra_select.update(select_pairs)
+            self._extra_select.update(select_pairs)
         if where:
             self.extra_where += tuple(where)
         if params:
@@ -2213,22 +2227,19 @@ class BaseQuery(object):
         """
         target[model] = set([f.name for f in fields])
 
-    def trim_extra_select(self, names):
-        """
-        Removes any aliases in the extra_select dictionary that aren't in
-        'names'.
-
-        This is needed if we are selecting certain values that don't incldue
-        all of the extra_select names.
-        """
-        for key in set(self.extra_select).difference(set(names)):
-            del self.extra_select[key]
-
     def set_aggregate_mask(self, names):
         "Set the mask of aggregates that will actually be returned by the SELECT"
         self.aggregate_select_mask = names
         self._aggregate_select_cache = None
 
+    def set_extra_mask(self, names):
+        """
+        Set the mask of extra select items that will be returned by SELECT,
+        we don't actually remove them from the Query since they might be used
+        later
+        """
+        self.extra_select_mask = names
+
     def _aggregate_select(self):
         """The SortedDict of aggregate columns that are not masked, and should
         be used in the SELECT clause.
@@ -2247,6 +2258,15 @@ class BaseQuery(object):
             return self.aggregates
     aggregate_select = property(_aggregate_select)
 
+    def _extra_select(self):
+        if self.extra_select_mask is None:
+            return self._extra_select
+        return SortedDict([
+            (k, v) for k, v in self._extra_select.items()
+            if k in self.extra_select_mask
+        ])
+    extra_select = property(_extra_select)
+
     def set_start(self, start):
         """
         Sets the table from which to start joining. The start position is
diff --git a/django/db/models/sql/subqueries.py b/django/db/models/sql/subqueries.py
index 4c62457..9b78131 100644
--- a/django/db/models/sql/subqueries.py
+++ b/django/db/models/sql/subqueries.py
@@ -178,7 +178,7 @@ class UpdateQuery(Query):
         # from other tables.
         query = self.clone(klass=Query)
         query.bump_prefix()
-        query.extra_select = {}
+        query._extra_select = {}
         query.select = []
         query.add_fields([query.model._meta.pk.name])
         must_pre_select = count > 1 and not self.connection.features.update_can_self_select
@@ -409,7 +409,7 @@ class DateQuery(Query):
         self.select = [select]
         self.select_fields = [None]
         self.select_related = False # See #7097.
-        self.extra_select = {}
+        self._extra_select = {}
         self.distinct = True
         self.order_by = order == 'ASC' and [1] or [-1]
 
diff --git a/tests/regressiontests/extra_regress/models.py b/tests/regressiontests/extra_regress/models.py
index fd34982..0a31e5b 100644
--- a/tests/regressiontests/extra_regress/models.py
+++ b/tests/regressiontests/extra_regress/models.py
@@ -35,6 +35,9 @@ class TestObject(models.Model):
     second = models.CharField(max_length=20)
     third = models.CharField(max_length=20)
 
+    def __unicode__(self):
+        return "%s-%s-%s" % (self.first, self.second, self.third)
+
 __test__ = {"API_TESTS": """
 # Regression tests for #7314 and #7372
 
@@ -189,6 +192,16 @@ True
 >>> TestObject.objects.extra(select=SortedDict((('foo','first'),('bar','second'),('whiz','third')))).values_list('whiz', 'first', 'bar', 'id')
 [(u'third', u'first', u'second', 1)]
 
-"""}
+>>> list(TestObject.objects.filter(pk__in=TestObject.objects.extra(select={'extra': 1}).values('pk'))) == list(TestObject.objects.all())
+True
 
+>>> TestObject.objects.values('pk').extra(select={'extra': 1})
+[{'pk': 1}]
 
+>>> TestObject.objects.filter(pk__in=TestObject.objects.values('pk').extra(select={'extra': 1}))
+[<TestObject: first-second-third>]
+
+>>> TestObject.objects.values('pk').extra(select={'extra': 5}).values_list('pk', 'extra')
+[(1, 5)]
+
+"""}
