"""

Create SQL statements for QuerySets.

The code in here encapsulates all of the SQL construction so that QuerySets

themselves do not have to (and could be backed by things other than SQL

databases). The abstraction barrier only works one way: this module has to know

all about the internals of models in order to get the information it needs.

"""

from django.utils.copycompat import deepcopy

from django.utils.tree import Node

from django.utils.datastructures import SortedDict

from django.utils.encoding import force_unicode

from django.db import connections, DEFAULT_DB_ALIAS

from django.db.models import signals

from django.db.models.fields import FieldDoesNotExist

from django.db.models.query_utils import select_related_descend, InvalidQuery

from django.db.models.sql import aggregates as base_aggregates_module

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

from django.db.models.sql.datastructures import EmptyResultSet, Empty, MultiJoin

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

from django.db.models.sql.where import (WhereNode, Constraint, EverythingNode,

    ExtraWhere, AND, OR)

from django.core.exceptions import FieldError

__all__ = ['Query', 'RawQuery']

class RawQuery(object):

    """

    A single raw SQL query

    """

    def __init__(self, sql, using, params=None):

        self.validate_sql(sql)

        self.params = params or ()

        self.sql = sql

        self.using = using

        self.cursor = None

        # Mirror some properties of a normal query so that

        # the compiler can be used to process results.

        self.low_mark, self.high_mark = 0, None  # Used for offset/limit

        self.extra_select = {}

        self.aggregate_select = {}

    def clone(self, using):

        return RawQuery(self.sql, using, params=self.params)

    def convert_values(self, value, field, connection):

        """Convert the database-returned value into a type that is consistent

        across database backends.

        By default, this defers to the underlying backend operations, but

        it can be overridden by Query classes for specific backends.

        """

        return connection.ops.convert_values(value, field)

    def get_columns(self):

        if self.cursor is None:

            self._execute_query()

        converter = connections[self.using].introspection.table_name_converter

        return [converter(column_meta[0])

                for column_meta in self.cursor.description]

    def validate_sql(self, sql):

        if not sql.lower().strip().startswith('select'):

            raise InvalidQuery('Raw queries are limited to SELECT queries. Use '

                               'connection.cursor directly for other types of queries.')

    def __iter__(self):

        # Always execute a new query for a new iterator.

        # This could be optimized with a cache at the expense of RAM.

        self._execute_query()

        if not connections[self.using].features.can_use_chunked_reads:

            # If the database can't use chunked reads we need to make sure we

            # evaluate the entire query up front.

            result = list(self.cursor)

        else:

            result = self.cursor

        return iter(result)

    def __repr__(self):

        return "<RawQuery: %r>" % (self.sql % self.params)

    def _execute_query(self):

        self.cursor = connections[self.using].cursor()

        self.cursor.execute(self.sql, self.params)

class Query(object):

    """

    A single SQL query.

    """

    # SQL join types. These are part of the class because their string forms

    # vary from database to database and can be customised by a subclass.

    INNER = 'INNER JOIN'

    LOUTER = 'LEFT OUTER JOIN'

    alias_prefix = 'T'

    query_terms = QUERY_TERMS

    aggregates_module = base_aggregates_module

    compiler = 'SQLCompiler'

    def __init__(self, model, where=WhereNode):

        self.model = model

        self.alias_refcount = {}

        self.alias_map = {}     # Maps alias to join information

        self.table_map = {}     # Maps table names to list of aliases.

        self.join_map = {}

        self.rev_join_map = {}  # Reverse of join_map.

        self.quote_cache = {}

        self.default_cols = True

        self.default_ordering = True

        self.standard_ordering = True

        self.ordering_aliases = []

        self.select_fields = []

        self.related_select_fields = []

        self.dupe_avoidance = {}

        self.used_aliases = set()

        self.filter_is_sticky = False

        self.included_inherited_models = {}

        # SQL-related attributes

        self.select = []

        self.tables = []    # Aliases in the order they are created.

        self.where = where()

        self.where_class = where

        self.group_by = None

        self.having = where()

        self.order_by = []

        self.low_mark, self.high_mark = 0, None  # Used for offset/limit

        self.distinct = False

        self.select_related = False

        self.related_select_cols = []

        # SQL aggregate-related attributes

        self.aggregates = SortedDict() # Maps alias -> SQL aggregate function

        self.aggregate_select_mask = None

        self._aggregate_select_cache = None

        # Arbitrary maximum limit for select_related. Prevents infinite

        # recursion. Can be changed by the depth parameter to select_related().

        self.max_depth = 5

        # These are for extensions. The contents are more or less appended

        # verbatim to the appropriate clause.

        self.extra = SortedDict()  # Maps col_alias -> (col_sql, params).

        self.extra_select_mask = None

        self._extra_select_cache = None

        self.extra_tables = ()

        self.extra_order_by = ()

        # A tuple that is a set of model field names and either True, if these

        # are the fields to defer, or False if these are the only fields to

        # load.

        self.deferred_loading = (set(), True)

    def __str__(self):

        """

        Returns the query as a string of SQL with the parameter values

        substituted in.

        Parameter values won't necessarily be quoted correctly, since that is

        done by the database interface at execution time.

        """

        sql, params = self.get_compiler(DEFAULT_DB_ALIAS).as_sql()

        return sql % params

    def __deepcopy__(self, memo):

        result = self.clone(memo=memo)

        memo[id(self)] = result

        return result

    def __getstate__(self):

        """

        Pickling support.

        """

        obj_dict = self.__dict__.copy()

        obj_dict['related_select_fields'] = []

        obj_dict['related_select_cols'] = []

        # Fields can't be pickled, so if a field list has been

        # specified, we pickle the list of field names instead.

        # None is also a possible value; that can pass as-is

        obj_dict['select_fields'] = [

            f is not None and f.name or None

            for f in obj_dict['select_fields']

        ]

        return obj_dict

    def __setstate__(self, obj_dict):

        """

        Unpickling support.

        """

        # Rebuild list of field instances

        obj_dict['select_fields'] = [

            name is not None and obj_dict['model']._meta.get_field(name) or None

            for name in obj_dict['select_fields']

        ]

        self.__dict__.update(obj_dict)

    def prepare(self):

        return self

    def get_compiler(self, using=None, connection=None):

        if using is None and connection is None:

            raise ValueError("Need either using or connection")

        if using:

            connection = connections[using]

        # Check that the compiler will be able to execute the query

        for alias, aggregate in self.aggregate_select.items():

            connection.ops.check_aggregate_support(aggregate)

        return connection.ops.compiler(self.compiler)(self, connection, using)

    def get_meta(self):

        """

        Returns the Options instance (the model._meta) from which to start

        processing. Normally, this is self.model._meta, but it can be changed

        by subclasses.

        """

        return self.model._meta

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

        """

        Creates a copy of the current instance. The 'kwargs' parameter can be

        used by clients to update attributes after copying has taken place.

        """

        obj = Empty()

        obj.__class__ = klass or self.__class__

        obj.model = self.model

        obj.alias_refcount = self.alias_refcount.copy()

        obj.alias_map = self.alias_map.copy()

        obj.table_map = self.table_map.copy()

        obj.join_map = self.join_map.copy()

        obj.rev_join_map = self.rev_join_map.copy()

        obj.quote_cache = {}

        obj.default_cols = self.default_cols

        obj.default_ordering = self.default_ordering

        obj.standard_ordering = self.standard_ordering

        obj.included_inherited_models = self.included_inherited_models.copy()

        obj.ordering_aliases = []

        obj.select_fields = self.select_fields[:]

        obj.related_select_fields = self.related_select_fields[:]

        obj.dupe_avoidance = self.dupe_avoidance.copy()

        obj.select = self.select[:]

        obj.tables = self.tables[:]

        obj.where = deepcopy(self.where, memo=memo)

        obj.where_class = self.where_class

        if self.group_by is None:

            obj.group_by = None

        else:

            obj.group_by = self.group_by[:]

        obj.having = deepcopy(self.having, memo=memo)

        obj.order_by = self.order_by[:]

        obj.low_mark, obj.high_mark = self.low_mark, self.high_mark

        obj.distinct = self.distinct

        obj.select_related = self.select_related

        obj.related_select_cols = []

        obj.aggregates = deepcopy(self.aggregates, memo=memo)

        if self.aggregate_select_mask is None:

            obj.aggregate_select_mask = None

        else:

            obj.aggregate_select_mask = self.aggregate_select_mask.copy()

        # _aggregate_select_cache cannot be copied, as doing so breaks the

        # (necessary) state in which both aggregates and

        # _aggregate_select_cache point to the same underlying objects.

        # It will get re-populated in the cloned queryset the next time it's

        # used.

        obj._aggregate_select_cache = None

        obj.max_depth = self.max_depth

        obj.extra = self.extra.copy()

        if self.extra_select_mask is None:

            obj.extra_select_mask = None

        else:

            obj.extra_select_mask = self.extra_select_mask.copy()

        if self._extra_select_cache is None:

            obj._extra_select_cache = None

        else:

            obj._extra_select_cache = self._extra_select_cache.copy()

        obj.extra_tables = self.extra_tables

        obj.extra_order_by = self.extra_order_by

        obj.deferred_loading = deepcopy(self.deferred_loading, memo=memo)

        if self.filter_is_sticky and self.used_aliases:

            obj.used_aliases = self.used_aliases.copy()

        else:

            obj.used_aliases = set()

        obj.filter_is_sticky = False

        obj.__dict__.update(kwargs)

        if hasattr(obj, '_setup_query'):

            obj._setup_query()

        return obj

    def convert_values(self, value, field, connection):

        """Convert the database-returned value into a type that is consistent

        across database backends.

        By default, this defers to the underlying backend operations, but

        it can be overridden by Query classes for specific backends.

        """

        return connection.ops.convert_values(value, field)

    def resolve_aggregate(self, value, aggregate, connection):

        """Resolve the value of aggregates returned by the database to

        consistent (and reasonable) types.

        This is required because of the predisposition of certain backends

        to return Decimal and long types when they are not needed.

        """

        if value is None:

            if aggregate.is_ordinal:

                return 0

            # Return None as-is

            return value

        elif aggregate.is_ordinal:

            # Any ordinal aggregate (e.g., count) returns an int

            return int(value)

        elif aggregate.is_computed:

            # Any computed aggregate (e.g., avg) returns a float

            return float(value)

        else:

            # Return value depends on the type of the field being processed.

            return self.convert_values(value, aggregate.field, connection)

    def get_aggregation(self, using):

        """

        Returns the dictionary with the values of the existing aggregations.

        """

        if not self.aggregate_select:

            return {}

        # If there is a group by clause, aggregating does not add useful

        # information but retrieves only the first row. Aggregate

        # over the subquery instead.

        if self.group_by is not None:

            from subqueries import AggregateQuery

            query = AggregateQuery(self.model)

            obj = self.clone()

            # Remove any aggregates marked for reduction from the subquery

            # and move them to the outer AggregateQuery.

            for alias, aggregate in self.aggregate_select.items():

                if aggregate.is_summary:

                    query.aggregate_select[alias] = aggregate

                    del obj.aggregate_select[alias]

            query.add_subquery(obj, using)

        else:

            query = self

            self.select = []

            self.default_cols = False

            self.extra = {}

            self.remove_inherited_models()

        query.clear_ordering(True)

        query.clear_limits()

        query.select_related = False

        query.related_select_cols = []

        query.related_select_fields = []

        result = query.get_compiler(using).execute_sql(SINGLE)

        if result is None:

            result = [None for q in query.aggregate_select.items()]

        return dict([

            (alias, self.resolve_aggregate(val, aggregate, connection=connections[using]))

            for (alias, aggregate), val

            in zip(query.aggregate_select.items(), result)

        ])

    def get_count(self, using):

        """

        Performs a COUNT() query using the current filter constraints.

        """

        obj = self.clone()

        if len(self.select) > 1 or self.aggregate_select:

            # If a select clause exists, then the query has already started to

            # specify the columns that are to be returned.

            # In this case, we need to use a subquery to evaluate the count.

            from subqueries import AggregateQuery

            subquery = obj

            subquery.clear_ordering(True)

            subquery.clear_limits()

            obj = AggregateQuery(obj.model)

            obj.add_subquery(subquery, using=using)

        obj.add_count_column()

        number = obj.get_aggregation(using=using)[None]

        # Apply offset and limit constraints manually, since using LIMIT/OFFSET

        # in SQL (in variants that provide them) doesn't change the COUNT

        # output.

        number = max(0, number - self.low_mark)

        if self.high_mark is not None:

            number = min(number, self.high_mark - self.low_mark)

        return number

    def has_results(self, using):

        q = self.clone()

        q.add_extra({'a': 1}, None, None, None, None, None)