def __init__(self, queryset, chunked_fetch=False, chunk_size=GET_ITERATOR_CHUNK_SIZE):

self.queryset = queryset

self.chunked_fetch = chunked_fetch

"""Iterable that yields a model instance for each row."""

def __iter__(self):

queryset = self.queryset

db = queryset.db

compiler = queryset.query.get_compiler(using=db)

# Execute the query. This will also fill compiler.select, klass_info,

# and annotations.

results = compiler.execute_sql(chunked_fetch=self.chunked_fetch, chunk_size=self.chunk_size)

select, klass_info, annotation_col_map = (compiler.select, compiler.klass_info,

compiler.annotation_col_map)

model_cls = klass_info['model']

select_fields = klass_info['select_fields']

model_fields_start, model_fields_end = select_fields[0], select_fields[-1] + 1

init_list = [f[0].target.attname

for f in select[model_fields_start:model_fields_end]]

related_populators = get_related_populators(klass_info, select, db)

known_related_objects = [

(field, related_objs, operator.attrgetter(*[

field.attname

if from_field == 'self' else

queryset.model._meta.get_field(from_field).attname

for from_field in field.from_fields

])) for field, related_objs in queryset._known_related_objects.items()

]

for row in compiler.results_iter(results):

obj = model_cls.from_db(db, init_list, row[model_fields_start:model_fields_end])

for rel_populator in related_populators:

rel_populator.populate(row, obj)

if annotation_col_map:

for attr_name, col_pos in annotation_col_map.items():

setattr(obj, attr_name, row[col_pos])

# Add the known related objects to the model.

for field, rel_objs, rel_getter in known_related_objects:

# Avoid overwriting objects loaded by, e.g., select_related().

if field.is_cached(obj):

continue

rel_obj_id = rel_getter(obj)

try:

rel_obj = rel_objs[rel_obj_id]

except KeyError:

pass # May happen in qs1 | qs2 scenarios.

else:

setattr(obj, field.name, rel_obj)

"""

def __iter__(self):

queryset = self.queryset

query = queryset.query

compiler = query.get_compiler(queryset.db)

# extra(select=...) cols are always at the start of the row.

names = [

*query.extra_select,

*query.values_select,

*query.annotation_select,

]

indexes = range(len(names))

for row in compiler.results_iter(chunked_fetch=self.chunked_fetch, chunk_size=self.chunk_size):

"""

def __iter__(self):

queryset = self.queryset

query = queryset.query

compiler = query.get_compiler(queryset.db)

if queryset._fields:

# extra(select=...) cols are always at the start of the row.

names = [

*query.extra_select,

*query.values_select,

*query.annotation_select,

]

fields = [*queryset._fields, *(f for f in query.annotation_select if f not in queryset._fields)]

if fields != names:

# Reorder according to fields.

index_map = {name: idx for idx, name in enumerate(names)}

rowfactory = operator.itemgetter(*[index_map[f] for f in fields])

return map(

rowfactory,

compiler.results_iter(chunked_fetch=self.chunked_fetch, chunk_size=self.chunk_size)

)

"""

@staticmethod

@lru_cache()

def create_namedtuple_class(*names):

# Cache namedtuple() with @lru_cache() since it's too slow to be

# called for every QuerySet evaluation.

return namedtuple('Row', names)

def __iter__(self):

queryset = self.queryset

if queryset._fields:

names = queryset._fields

else:

query = queryset.query

names = [*query.extra_select, *query.values_select, *query.annotation_select]

tuple_class = self.create_namedtuple_class(*names)

new = tuple.__new__

for row in super().__iter__():

"""

def __iter__(self):

queryset = self.queryset

compiler = queryset.query.get_compiler(queryset.db)

for row in compiler.results_iter(chunked_fetch=self.chunked_fetch, chunk_size=self.chunk_size):

"""Represent a lazy database lookup for a set of objects."""

def __init__(self, model=None, query=None, using=None, hints=None):

self.model = model

self._db = using

self._hints = hints or {}

self.query = query or sql.Query(self.model)

self._result_cache = None

self._sticky_filter = False

self._for_write = False

self._prefetch_related_lookups = ()

self._prefetch_done = False

self._known_related_objects = {} # {rel_field: {pk: rel_obj}}

self._iterable_class = ModelIterable

self._fields = None

def as_manager(cls):

# Address the circular dependency between `Queryset` and `Manager`.

from django.db.models.manager import Manager

manager = Manager.from_queryset(cls)()

manager._built_with_as_manager = True

return manager

as_manager.queryset_only = True

as_manager = classmethod(as_manager)

########################

# PYTHON MAGIC METHODS #

########################

def __deepcopy__(self, memo):

"""Don't populate the QuerySet's cache."""

obj = self.__class__()

for k, v in self.__dict__.items():

if k == '_result_cache':

obj.__dict__[k] = None

else:

obj.__dict__[k] = copy.deepcopy(v, memo)

return obj

def __getstate__(self):

# Force the cache to be fully populated.

self._fetch_all()

return {**self.__dict__, DJANGO_VERSION_PICKLE_KEY: get_version()}

def __setstate__(self, state):

msg = None

pickled_version = state.get(DJANGO_VERSION_PICKLE_KEY)

if pickled_version:

current_version = get_version()

if current_version != pickled_version:

msg = (

"Pickled queryset instance's Django version %s does not "

"match the current version %s." % (pickled_version, current_version)

)

else:

msg = "Pickled queryset instance's Django version is not specified."

if msg:

warnings.warn(msg, RuntimeWarning, stacklevel=2)

self.__dict__.update(state)

def __repr__(self):

data = list(self[:REPR_OUTPUT_SIZE + 1])

if len(data) > REPR_OUTPUT_SIZE:

data[-1] = "…(remaining elements truncated)…"

return '<%s %r>' % (self.__class__.__name__, data)

def __len__(self):

self._fetch_all()

return len(self._result_cache)

def __iter__(self):

"""

self._fetch_all()

return iter(self._result_cache)

def __bool__(self):

self._fetch_all()

return bool(self._result_cache)

def __getitem__(self, k):

"""Retrieve an item or slice from the set of results."""

if not isinstance(k, (int, slice)):

raise TypeError

assert ((not isinstance(k, slice) and (k >= 0)) or

(isinstance(k, slice) and (k.start is None or k.start >= 0) and

(k.stop is None or k.stop >= 0))), \

"Negative indexing is not supported."

if self._result_cache is not None:

return self._result_cache[k]

if isinstance(k, slice):

qs = self._chain()

if k.start is not None:

start = int(k.start)

else:

start = None

if k.stop is not None:

stop = int(k.stop)

else:

stop = None

qs.query.set_limits(start, stop)

return list(qs)[::k.step] if k.step else qs

qs = self._chain()

qs.query.set_limits(k, k + 1)

qs._fetch_all()

return qs._result_cache[0]

def __and__(self, other):

self._merge_sanity_check(other)

if isinstance(other, EmptyQuerySet):

return other

if isinstance(self, EmptyQuerySet):

return self

combined = self._chain()

combined._merge_known_related_objects(other)

combined.query.combine(other.query, sql.AND)

return combined

def __or__(self, other):

self._merge_sanity_check(other)

if isinstance(self, EmptyQuerySet):

return other

if isinstance(other, EmptyQuerySet):

return self

query = self if self.query.can_filter() else self.model._base_manager.filter(pk__in=self.values('pk'))

combined = query._chain()

combined._merge_known_related_objects(other)

if not other.query.can_filter():

other = other.model._base_manager.filter(pk__in=other.values('pk'))

combined.query.combine(other.query, sql.OR)

return combined

####################################

# METHODS THAT DO DATABASE QUERIES #

####################################

def _iterator(self, use_chunked_fetch, chunk_size):

yield from self._iterable_class(self, chunked_fetch=use_chunked_fetch, chunk_size=chunk_size)

def iterator(self, chunk_size=2000):

"""

if chunk_size <= 0:

raise ValueError('Chunk size must be strictly positive.')

use_chunked_fetch = not connections[self.db].settings_dict.get('DISABLE_SERVER_SIDE_CURSORS')

return self._iterator(use_chunked_fetch, chunk_size)

def aggregate(self, *args, **kwargs):

"""

if self.query.distinct_fields:

raise NotImplementedError("aggregate() + distinct(fields) not implemented.")

self._validate_values_are_expressions((*args, *kwargs.values()), method_name='aggregate')

for arg in args:

# The default_alias property raises TypeError if default_alias

# can't be set automatically or AttributeError if it isn't an

# attribute.

try:

arg.default_alias

except (AttributeError, TypeError):

raise TypeError("Complex aggregates require an alias")

kwargs[arg.default_alias] = arg

query = self.query.chain()

for (alias, aggregate_expr) in kwargs.items():

query.add_annotation(aggregate_expr, alias, is_summary=True)

if not query.annotations[alias].contains_aggregate:

raise TypeError("%s is not an aggregate expression" % alias)

return query.get_aggregation(self.db, kwargs)

def count(self):

"""

if self._result_cache is not None:

return len(self._result_cache)

return self.query.get_count(using=self.db)

def get(self, *args, **kwargs):

"""

clone = self.filter(*args, **kwargs)

if self.query.can_filter() and not self.query.distinct_fields:

clone = clone.order_by()

num = len(clone)

if num == 1:

return clone._result_cache[0]

if not num:

raise self.model.DoesNotExist(

"%s matching query does not exist." %

self.model._meta.object_name

)

raise self.model.MultipleObjectsReturned(

"get() returned more than one %s -- it returned %s!" %

(self.model._meta.object_name, num)

)

def create(self, **kwargs):

"""

obj = self.model(**kwargs)

self._for_write = True

obj.save(force_insert=True, using=self.db)

return obj

def _populate_pk_values(self, objs):

for obj in objs:

if obj.pk is None:

obj.pk = obj._meta.pk.get_pk_value_on_save(obj)

def bulk_create(self, objs, batch_size=None, ignore_conflicts=False):

"""

# When you bulk insert you don't get the primary keys back (if it's an

# autoincrement, except if can_return_ids_from_bulk_insert=True), so

# you can't insert into the child tables which references this. There

# are two workarounds:

# 1) This could be implemented if you didn't have an autoincrement pk

# 2) You could do it by doing O(n) normal inserts into the parent

# tables to get the primary keys back and then doing a single bulk

# insert into the childmost table.

# We currently set the primary keys on the objects when using

# PostgreSQL via the RETURNING ID clause. It should be possible for

# Oracle as well, but the semantics for extracting the primary keys is

# trickier so it's not done yet.

assert batch_size is None or batch_size > 0

# Check that the parents share the same concrete model with the our

# model to detect the inheritance pattern ConcreteGrandParent ->

# MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy

# would not identify that case as involving multiple tables.

for parent in self.model._meta.get_parent_list():

if parent._meta.concrete_model is not self.model._meta.concrete_model:

raise ValueError("Can't bulk create a multi-table inherited model")

if not objs:

return objs

self._for_write = True

connection = connections[self.db]

fields = self.model._meta.concrete_fields

objs = list(objs)

self._populate_pk_values(objs)

with transaction.atomic(using=self.db, savepoint=False):

objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)

if objs_with_pk:

self._batched_insert(objs_with_pk, fields, batch_size, ignore_conflicts=ignore_conflicts)

for obj_with_pk in objs_with_pk:

obj_with_pk._state.adding = False

obj_with_pk._state.db = self.db

if objs_without_pk:

fields = [f for f in fields if not isinstance(f, AutoField)]

ids = self._batched_insert(objs_without_pk, fields, batch_size, ignore_conflicts=ignore_conflicts)

if connection.features.can_return_ids_from_bulk_insert and not ignore_conflicts:

assert len(ids) == len(objs_without_pk)

for obj_without_pk, pk in zip(objs_without_pk, ids):

obj_without_pk.pk = pk

obj_without_pk._state.adding = False

obj_without_pk._state.db = self.db

return objs

def bulk_update(self, objs, fields, batch_size=None):

"""

if batch_size is not None and batch_size < 0:

raise ValueError('Batch size must be a positive integer.')

if not fields:

raise ValueError('Field names must be given to bulk_update().')

objs = tuple(objs)

if not all(obj.pk for obj in objs):

raise ValueError('All bulk_update() objects must have a primary key set.')

fields = [self.model._meta.get_field(name) for name in fields]

if any(not f.concrete or f.many_to_many for f in fields):

raise ValueError('bulk_update() can only be used with concrete fields.')

if any(f.primary_key for f in fields):

raise ValueError('bulk_update() cannot be used with primary key fields.')

if not objs:

return

# PK is used twice in the resulting update query, once in the filter

# and once in the WHEN. Each field will also have one CAST.

max_batch_size = connections[self.db].ops.bulk_batch_size(['pk', 'pk'] + fields, objs)

batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size

requires_casting = connections[self.db].features.requires_casted_case_in_updates

batches = (objs[i:i + batch_size] for i in range(0, len(objs), batch_size))

updates = []

for batch_objs in batches:

update_kwargs = {}

for field in fields:

when_statements = []

for obj in batch_objs:

attr = getattr(obj, field.attname)

if not isinstance(attr, Expression):

attr = Value(attr, output_field=field)

when_statements.append(When(pk=obj.pk, then=attr))

case_statement = Case(*when_statements, output_field=field)

if requires_casting:

case_statement = Cast(case_statement, output_field=field)

update_kwargs[field.attname] = case_statement

updates.append(([obj.pk for obj in batch_objs], update_kwargs))

with transaction.atomic(using=self.db, savepoint=False):

for pks, update_kwargs in updates:

self.filter(pk__in=pks).update(**update_kwargs)

bulk_update.alters_data = True

def get_or_create(self, defaults=None, **kwargs):

"""

# The get() needs to be targeted at the write database in order

# to avoid potential transaction consistency problems.

self._for_write = True

try:

return self.get(**kwargs), False

except self.model.DoesNotExist:

params = self._extract_model_params(defaults, **kwargs)

return self._create_object_from_params(kwargs, params)

def update_or_create(self, defaults=None, **kwargs):

"""

defaults = defaults or {}

self._for_write = True

with transaction.atomic(using=self.db):

try:

obj = self.select_for_update().get(**kwargs)

except self.model.DoesNotExist:

params = self._extract_model_params(defaults, **kwargs)

# Lock the row so that a concurrent update is blocked until

# after update_or_create() has performed its save.

obj, created = self._create_object_from_params(kwargs, params, lock=True)

if created:

return obj, created

for k, v in defaults.items():

setattr(obj, k, v() if callable(v) else v)

obj.save(using=self.db)

return obj, False

def _create_object_from_params(self, lookup, params, lock=False):

"""

try:

with transaction.atomic(using=self.db):

params = {k: v() if callable(v) else v for k, v in params.items()}

obj = self.create(**params)

return obj, True

except IntegrityError as e:

try:

qs = self.select_for_update() if lock else self

return qs.get(**lookup), False

except self.model.DoesNotExist:

pass

raise e

def _extract_model_params(self, defaults, **kwargs):

"""

defaults = defaults or {}

params = {k: v for k, v in kwargs.items() if LOOKUP_SEP not in k}

params.update(defaults)

property_names = self.model._meta._property_names

invalid_params = []

for param in params:

try:

self.model._meta.get_field(param)

except exceptions.FieldDoesNotExist:

# It's okay to use a model's property if it has a setter.

if not (param in property_names and getattr(self.model, param).fset):

invalid_params.append(param)

if invalid_params:

raise exceptions.FieldError(

"Invalid field name(s) for model %s: '%s'." % (

self.model._meta.object_name,

"', '".join(sorted(invalid_params)),

))

return params

def _earliest_or_latest(self, *fields, field_name=None):

"""

if fields and field_name is not None:

raise ValueError('Cannot use both positional arguments and the field_name keyword argument.')

if field_name is not None:

warnings.warn(

'The field_name keyword argument to earliest() and latest() '

'is deprecated in favor of passing positional arguments.',

RemovedInDjango30Warning,

)

order_by = (field_name,)

elif fields:

order_by = fields

else:

order_by = getattr(self.model._meta, 'get_latest_by')

if order_by and not isinstance(order_by, (tuple, list)):

order_by = (order_by,)

if order_by is None:

raise ValueError(

"earliest() and latest() require either fields as positional "

"arguments or 'get_latest_by' in the model's Meta."

)

assert self.query.can_filter(), \

"Cannot change a query once a slice has been taken."

obj = self._chain()

obj.query.set_limits(high=1)

obj.query.clear_ordering(force_empty=True)

obj.query.add_ordering(*order_by)

return obj.get()

def earliest(self, *fields, field_name=None):

return self._earliest_or_latest(*fields, field_name=field_name)

def latest(self, *fields, field_name=None):

return self.reverse()._earliest_or_latest(*fields, field_name=field_name)

def first(self):

"""Return the first object of a query or None if no match is found."""

for obj in (self if self.ordered else self.order_by('pk'))[:1]:

return obj

def last(self):

"""Return the last object of a query or None if no match is found."""

for obj in (self.reverse() if self.ordered else self.order_by('-pk'))[:1]:

return obj

def in_bulk(self, id_list=None, *, field_name='pk'):

"""

assert self.query.can_filter(), \

"Cannot use 'limit' or 'offset' with in_bulk"

if field_name != 'pk' and not self.model._meta.get_field(field_name).unique:

raise ValueError("in_bulk()'s field_name must be a unique field but %r isn't." % field_name)

if id_list is not None:

if not id_list:

return {}

filter_key = '{}__in'.format(field_name)

batch_size = connections[self.db].features.max_query_params

id_list = tuple(id_list)

# If the database has a limit on the number of query parameters

# (e.g. SQLite), retrieve objects in batches if necessary.

if batch_size and batch_size < len(id_list):

qs = ()

for offset in range(0, len(id_list), batch_size):

batch = id_list[offset:offset + batch_size]

qs += tuple(self.filter(**{filter_key: batch}).order_by())

else:

qs = self.filter(**{filter_key: id_list}).order_by()

else:

qs = self._chain()

return {getattr(obj, field_name): obj for obj in qs}

def delete(self):

"""Delete the records in the current QuerySet."""

assert self.query.can_filter(), \

"Cannot use 'limit' or 'offset' with delete."

if self._fields is not None:

raise TypeError("Cannot call delete() after .values() or .values_list()")

del_query = self._chain()

# The delete is actually 2 queries - one to find related objects,

# and one to delete. Make sure that the discovery of related

# objects is performed on the same database as the deletion.

del_query._for_write = True

# Disable non-supported fields.

del_query.query.select_for_update = False

del_query.query.select_related = False

del_query.query.clear_ordering(force_empty=True)

collector = Collector(using=del_query.db)

collector.collect(del_query)

deleted, _rows_count = collector.delete()

# Clear the result cache, in case this QuerySet gets reused.

self._result_cache = None

return deleted, _rows_count

delete.alters_data = True

delete.queryset_only = True

def _raw_delete(self, using):

"""

return sql.DeleteQuery(self.model).delete_qs(self, using)

_raw_delete.alters_data = True

def update(self, **kwargs):

"""

assert self.query.can_filter(), \

"Cannot update a query once a slice has been taken."

self._for_write = True

query = self.query.chain(sql.UpdateQuery)

query.add_update_values(kwargs)

# Clear any annotations so that they won't be present in subqueries.

query._annotations = None

with transaction.mark_for_rollback_on_error(using=self.db):

rows = query.get_compiler(self.db).execute_sql(CURSOR)

self._result_cache = None

return rows

update.alters_data = True

def _update(self, values):

"""

assert self.query.can_filter(), \

"Cannot update a query once a slice has been taken."

query = self.query.chain(sql.UpdateQuery)

query.add_update_fields(values)

# Clear any annotations so that they won't be present in subqueries.

query._annotations = None

self._result_cache = None

return query.get_compiler(self.db).execute_sql(CURSOR)

_update.alters_data = True

_update.queryset_only = False

def exists(self):

if self._result_cache is None:

return self.query.has_results(using=self.db)

return bool(self._result_cache)

def _prefetch_related_objects(self):

# This method can only be called once the result cache has been filled.

prefetch_related_objects(self._result_cache, *self._prefetch_related_lookups)

self._prefetch_done = True

def explain(self, *, format=None, **options):

return self.query.explain(using=self.db, format=format, **options)

##################################################

# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #

##################################################

def raw(self, raw_query, params=None, translations=None, using=None):

if using is None:

using = self.db

qs = RawQuerySet(raw_query, model=self.model, params=params, translations=translations, using=using)

qs._prefetch_related_lookups = self._prefetch_related_lookups[:]

return qs

def _values(self, *fields, **expressions):

clone = self._chain()

if expressions:

clone = clone.annotate(**expressions)

clone._fields = fields

clone.query.set_values(fields)

return clone

def values(self, *fields, **expressions):

fields += tuple(expressions)

clone = self._values(*fields, **expressions)

clone._iterable_class = ValuesIterable

return clone

def values_list(self, *fields, flat=False, named=False):

if flat and named:

raise TypeError("'flat' and 'named' can't be used together.")

if flat and len(fields) > 1:

raise TypeError("'flat' is not valid when values_list is called with more than one field.")

field_names = {f for f in fields if not hasattr(f, 'resolve_expression')}

_fields = []

expressions = {}

counter = 1

for field in fields:

if hasattr(field, 'resolve_expression'):

field_id_prefix = getattr(field, 'default_alias', field.__class__.__name__.lower())

while True:

field_id = field_id_prefix + str(counter)

counter += 1

if field_id not in field_names:

break

expressions[field_id] = field

_fields.append(field_id)

else:

_fields.append(field)

clone = self._values(*_fields, **expressions)

clone._iterable_class = (

NamedValuesListIterable if named

else FlatValuesListIterable if flat

else ValuesListIterable

)

return clone

def dates(self, field_name, kind, order='ASC'):

"""

assert kind in ('year', 'month', 'week', 'day'), \

"'kind' must be one of 'year', 'month', 'week', or 'day'."

assert order in ('ASC', 'DESC'), \

"'order' must be either 'ASC' or 'DESC'."

return self.annotate(

datefield=Trunc(field_name, kind, output_field=DateField()),

plain_field=F(field_name)

).values_list(

'datefield', flat=True

).distinct().filter(plain_field__isnull=False).order_by(('-' if order == 'DESC' else '') + 'datefield')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):

"""

assert kind in ('year', 'month', 'week', 'day', 'hour', 'minute', 'second'), \

"'kind' must be one of 'year', 'month', 'week', 'day', 'hour', 'minute', or 'second'."

assert order in ('ASC', 'DESC'), \

"'order' must be either 'ASC' or 'DESC'."

if settings.USE_TZ:

if tzinfo is None:

tzinfo = timezone.get_current_timezone()

else:

tzinfo = None

return self.annotate(

datetimefield=Trunc(field_name, kind, output_field=DateTimeField(), tzinfo=tzinfo),

plain_field=F(field_name)

).values_list(

'datetimefield', flat=True

).distinct().filter(plain_field__isnull=False).order_by(('-' if order == 'DESC' else '') + 'datetimefield')

def none(self):

"""Return an empty QuerySet."""

clone = self._chain()

clone.query.set_empty()

return clone

##################################################################

# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #

##################################################################

def all(self):

"""

return self._chain()

def filter(self, *args, **kwargs):

"""

return self._filter_or_exclude(False, *args, **kwargs)

def exclude(self, *args, **kwargs):

"""

return self._filter_or_exclude(True, *args, **kwargs)

def _filter_or_exclude(self, negate, *args, **kwargs):

if args or kwargs:

assert self.query.can_filter(), \

"Cannot filter a query once a slice has been taken."

clone = self._chain()

if negate:

clone.query.add_q(~Q(*args, **kwargs))

else:

clone.query.add_q(Q(*args, **kwargs))

return clone

def complex_filter(self, filter_obj):

"""

if isinstance(filter_obj, Q):

clone = self._chain()

clone.query.add_q(filter_obj)

return clone

else:

return self._filter_or_exclude(None, **filter_obj)

def _combinator_query(self, combinator, *other_qs, all=False):

# Clone the query to inherit the select list and everything

clone = self._chain()

# Clear limits and ordering so they can be reapplied

clone.query.clear_ordering(True)

clone.query.clear_limits()

clone.query.combined_queries = (self.query,) + tuple(qs.query for qs in other_qs)

clone.query.combinator = combinator

clone.query.combinator_all = all

return clone

def union(self, *other_qs, all=False):

# If the query is an EmptyQuerySet, combine all nonempty querysets.

if isinstance(self, EmptyQuerySet):

qs = [q for q in other_qs if not isinstance(q, EmptyQuerySet)]

return qs[0]._combinator_query('union', *qs[1:], all=all) if qs else self

return self._combinator_query('union', *other_qs, all=all)

def intersection(self, *other_qs):

# If any query is an EmptyQuerySet, return it.

if isinstance(self, EmptyQuerySet):

return self

for other in other_qs:

if isinstance(other, EmptyQuerySet):

return other

return self._combinator_query('intersection', *other_qs)

def difference(self, *other_qs):

# If the query is an EmptyQuerySet, return it.

if isinstance(self, EmptyQuerySet):

return self

return self._combinator_query('difference', *other_qs)

def select_for_update(self, nowait=False, skip_locked=False, of=()):

"""

if nowait and skip_locked:

raise ValueError('The nowait option cannot be used with skip_locked.')

obj = self._chain()

obj._for_write = True

obj.query.select_for_update = True

obj.query.select_for_update_nowait = nowait

obj.query.select_for_update_skip_locked = skip_locked

obj.query.select_for_update_of = of

return obj

def select_related(self, *fields):

"""

if self._fields is not None:

raise TypeError("Cannot call select_related() after .values() or .values_list()")

obj = self._chain()

if fields == (None,):

obj.query.select_related = False

elif fields:

obj.query.add_select_related(fields)

else:

obj.query.select_related = True

return obj

def prefetch_related(self, *lookups):