"""

Query subclasses which provide extra functionality beyond simple data retrieval.

"""

from django.core.exceptions import FieldError

from django.db.models.sql.constants import *

from django.db.models.sql.datastructures import Date

from django.db.models.sql.expressions import SQLEvaluator

from django.db.models.sql.query import Query

from django.db.models.sql.where import AND, Constraint

__all__ = ['DeleteQuery', 'UpdateQuery', 'InsertQuery', 'DateQuery',

        'AggregateQuery']

class DeleteQuery(Query):

    """

    Delete queries are done through this class, since they are more constrained

    than general queries.

    """

        self.tables = [table]

        self.where = where

        """

        More than one physical query may be executed if there are a

        lot of values in pk_list.

        """

        for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):

            where = self.where_class()

            field = self.model._meta.pk

            where.add((Constraint(None, field.column, field), 'in',

                    pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]), AND)

class UpdateQuery(Query):

    """

    Represents an "update" SQL query.

    """

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

        super(UpdateQuery, self).__init__(*args, **kwargs)

        self._setup_query()

    def _setup_query(self):

        """

        Runs on initialization and after cloning. Any attributes that would

        normally be set in __init__ should go in here, instead, so that they

        are also set up after a clone() call.

        """

        self.values = []

        self.related_ids = None

        if not hasattr(self, 'related_updates'):

            self.related_updates = {}

    def clone(self, klass=None, **kwargs):

        return super(UpdateQuery, self).clone(klass,

                related_updates=self.related_updates.copy(), **kwargs)

        """

        Set up and execute an update query that clears related entries for the

        keys in pk_list.

        This is used by the QuerySet.delete_objects() method.

        """

        for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):

            self.where = self.where_class()

            f = self.model._meta.pk

            self.where.add((Constraint(None, f.column, f), 'in',

                    pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]),

                    AND)

    def add_update_values(self, values):

        """

        Convert a dictionary of field name to value mappings into an update

        query. This is the entry point for the public update() method on

        querysets.

        """

        values_seq = []

        for name, val in values.iteritems():

            field, model, direct, m2m = self.model._meta.get_field_by_name(name)

            if not direct or m2m:

                raise FieldError('Cannot update model field %r (only non-relations and foreign keys permitted).' % field)

            values_seq.append((field, model, val))

        return self.add_update_fields(values_seq)

    def add_update_fields(self, values_seq):

        """

        Turn a sequence of (field, model, value) triples into an update query.

        Used by add_update_values() as well as the "fast" update path when

        saving models.

        """

        """

        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:

        except KeyError:

    def get_related_updates(self):

        """

        Returns a list of query objects: one for each update required to an

        ancestor model. Each query will have the same filtering conditions as

        the current query but will only update a single table.

        """

        if not self.related_updates:

            return []

        result = []

        for model, values in self.related_updates.iteritems():

            query.values = values

                query.add_filter(('pk__in', self.related_ids))

            result.append(query)

        return result

class InsertQuery(Query):

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

        super(InsertQuery, self).__init__(*args, **kwargs)

        self.columns = []

        self.values = []

        self.params = ()

    def clone(self, klass=None, **kwargs):

        extras.update(kwargs)

        return super(InsertQuery, self).clone(klass, **extras)

    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.

        """

        placeholders, values = [], []

        for field, val in insert_values:

            self.columns.append(field.column)

            values.append(val)

        if raw_values:

        else:

            self.params += tuple(values)

            self.values.extend(placeholders)

class DateQuery(Query):

    """

    A DateQuery is a normal query, except that it specifically selects a single

    date field. This requires some special handling when converting the results

    back to Python objects, so we put it in a separate class.

    """

    def add_date_select(self, field, lookup_type, order='ASC'):

        """

        Converts the query into a date extraction query.

        """

        result = self.setup_joins([field.name], self.get_meta(),

                self.get_initial_alias(), False)

        alias = result[3][-1]

        self.select = [select]

        self.select_fields = [None]

        self.select_related = False # See #7097.

        self.distinct = True

        self.order_by = order == 'ASC' and [1] or [-1]

class AggregateQuery(Query):

    """

    An AggregateQuery takes another query as a parameter to the FROM

    clause and only selects the elements in the provided list.

    """