from django.core.exceptions import FieldError

from django.db import connections

from django.db.backends.util import truncate_name

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

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

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

from django.db.models.sql.query import get_proxied_model, get_order_dir, \

     select_related_descend, Query

class SQLCompiler(object):

    def __init__(self, query, connection, using):

        self.query = query

        self.connection = connection

        self.using = using

        self.quote_cache = {}

    def pre_sql_setup(self):

        """

        Does any necessary class setup immediately prior to producing SQL. This

        is for things that can't necessarily be done in __init__ because we

        might not have all the pieces in place at that time.

        """

        if not self.query.tables:

            self.query.join((None, self.query.model._meta.db_table, None, None))

        if (not self.query.select and self.query.default_cols and not

                self.query.included_inherited_models):

            self.query.setup_inherited_models()

        if self.query.select_related and not self.query.related_select_cols:

            self.fill_related_selections()

    def quote_name_unless_alias(self, name):

        """

        A wrapper around connection.ops.quote_name that doesn't quote aliases

        for table names. This avoids problems with some SQL dialects that treat

        quoted strings specially (e.g. PostgreSQL).

        """

        if name in self.quote_cache:

            return self.quote_cache[name]

        if ((name in self.query.alias_map and name not in self.query.table_map) or

                name in self.query.extra_select):

            self.quote_cache[name] = name

            return name

        r = self.connection.ops.quote_name(name)

        self.quote_cache[name] = r

        return r

    def as_sql(self, with_limits=True, with_col_aliases=False):

        """

        Creates the SQL for this query. Returns the SQL string and list of

        parameters.

        If 'with_limits' is False, any limit/offset information is not included

        in the query.

        """

        self.pre_sql_setup()

        out_cols = self.get_columns(with_col_aliases)

        ordering, ordering_group_by = self.get_ordering()

        # This must come after 'select' and 'ordering' -- see docstring of

        # get_from_clause() for details.

        from_, f_params = self.get_from_clause()

        qn = self.quote_name_unless_alias

        where, w_params = self.query.where.as_sql(qn=qn, connection=self.connection)

        having, h_params = self.query.having.as_sql(qn=qn, connection=self.connection)

        params = []

        for val in self.query.extra_select.itervalues():

            params.extend(val[1])

        result = ['SELECT']

        if self.query.distinct:

            result.append('DISTINCT')

        result.append(', '.join(out_cols + self.query.ordering_aliases))

        result.append('FROM')

        result.extend(from_)

        params.extend(f_params)

        if where:

            result.append('WHERE %s' % where)

            params.extend(w_params)

        grouping, gb_params = self.get_grouping()

        if grouping:

            if ordering:

                # If the backend can't group by PK (i.e., any database

                # other than MySQL), then any fields mentioned in the

                # ordering clause needs to be in the group by clause.

                if not self.connection.features.allows_group_by_pk:

                    for col, col_params in ordering_group_by:

                        if col not in grouping:

                            grouping.append(str(col))

                            gb_params.extend(col_params)

            else:

                ordering = self.connection.ops.force_no_ordering()

            result.append('GROUP BY %s' % ', '.join(grouping))

            params.extend(gb_params)

        if having:

            result.append('HAVING %s' % having)

            params.extend(h_params)

        if ordering:

            result.append('ORDER BY %s' % ', '.join(ordering))

        if with_limits:

            if self.query.high_mark is not None:

                result.append('LIMIT %d' % (self.query.high_mark - self.query.low_mark))

            if self.query.low_mark:

                if self.query.high_mark is None:

                    val = self.connection.ops.no_limit_value()

                    if val:

                        result.append('LIMIT %d' % val)

                result.append('OFFSET %d' % self.query.low_mark)

        return ' '.join(result), tuple(params)

    def as_nested_sql(self):

        """

        Perform the same functionality as the as_sql() method, returning an

        SQL string and parameters. However, the alias prefixes are bumped

        beforehand (in a copy -- the current query isn't changed), and any

        ordering is removed if the query is unsliced.

        Used when nesting this query inside another.

        """

        obj = self.query.clone()

        if obj.low_mark == 0 and obj.high_mark is None:

            # If there is no slicing in use, then we can safely drop all ordering

            obj.clear_ordering(True)

        obj.bump_prefix()

        return obj.get_compiler(connection=self.connection).as_sql()

    def get_columns(self, with_aliases=False):

        """

        Returns the list of columns to use in the select statement. If no

        columns have been specified, returns all columns relating to fields in

        the model.

        If 'with_aliases' is true, any column names that are duplicated

        (without the table names) are given unique aliases. This is needed in

        some cases to avoid ambiguity with nested queries.

        """

        qn = self.quote_name_unless_alias

        qn2 = self.connection.ops.quote_name

        result = ['(%s) AS %s' % (col[0], qn2(alias)) for alias, col in self.query.extra_select.iteritems()]

        aliases = set(self.query.extra_select.keys())

        if with_aliases:

            col_aliases = aliases.copy()

        else:

            col_aliases = set()

        if self.query.select:

            only_load = self.deferred_to_columns()

            for col in self.query.select:

                if isinstance(col, (list, tuple)):

                    alias, column = col

                    table = self.query.alias_map[alias][TABLE_NAME]

                    if table in only_load and col not in only_load[table]:

                        continue

                    r = '%s.%s' % (qn(alias), qn(column))

                    if with_aliases:

                        if col[1] in col_aliases:

                            c_alias = 'Col%d' % len(col_aliases)

                            result.append('%s AS %s' % (r, c_alias))

                            aliases.add(c_alias)

                            col_aliases.add(c_alias)

                        else:

                            result.append('%s AS %s' % (r, qn2(col[1])))

                            aliases.add(r)

                            col_aliases.add(col[1])

                    else:

                        result.append(r)

                        aliases.add(r)

                        col_aliases.add(col[1])

                else:

                    result.append(col.as_sql(qn, self.connection))

                    if hasattr(col, 'alias'):

                        aliases.add(col.alias)

                        col_aliases.add(col.alias)

        elif self.query.default_cols:

            cols, new_aliases = self.get_default_columns(with_aliases,

                    col_aliases)

            result.extend(cols)

            aliases.update(new_aliases)

        max_name_length = self.connection.ops.max_name_length()

        result.extend([

            '%s%s' % (

                aggregate.as_sql(qn, self.connection),

                alias is not None

                    and ' AS %s' % qn(truncate_name(alias, max_name_length))

                    or ''

            )

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

        ])

        for table, col in self.query.related_select_cols:

            r = '%s.%s' % (qn(table), qn(col))

            if with_aliases and col in col_aliases:

                c_alias = 'Col%d' % len(col_aliases)

                result.append('%s AS %s' % (r, c_alias))

                aliases.add(c_alias)

                col_aliases.add(c_alias)

            else:

                result.append(r)

                aliases.add(r)

                col_aliases.add(col)

        self._select_aliases = aliases

        return result

    def get_default_columns(self, with_aliases=False, col_aliases=None,

            start_alias=None, opts=None, as_pairs=False, local_only=False):

        """

        Computes the default columns for selecting every field in the base

        model. Will sometimes be called to pull in related models (e.g. via

        select_related), in which case "opts" and "start_alias" will be given

        to provide a starting point for the traversal.

        Returns a list of strings, quoted appropriately for use in SQL

        directly, as well as a set of aliases used in the select statement (if

        'as_pairs' is True, returns a list of (alias, col_name) pairs instead

        of strings as the first component and None as the second component).

        """

        result = []

        if opts is None:

            opts = self.query.model._meta

        qn = self.quote_name_unless_alias

        qn2 = self.connection.ops.quote_name

        aliases = set()

        only_load = self.deferred_to_columns()

        # Skip all proxy to the root proxied model

        proxied_model = get_proxied_model(opts)

        if start_alias:

            seen = {None: start_alias}

        for field, model in opts.get_fields_with_model():

            if local_only and model is not None:

                continue

            if start_alias:

                try:

                    alias = seen[model]

                except KeyError:

                    if model is proxied_model:

                        alias = start_alias

                    else:

                        link_field = opts.get_ancestor_link(model)

                        alias = self.query.join((start_alias, model._meta.db_table,

                                link_field.column, model._meta.pk.column))

                    seen[model] = alias

            else:

                # If we're starting from the base model of the queryset, the

                # aliases will have already been set up in pre_sql_setup(), so

                # we can save time here.

                alias = self.query.included_inherited_models[model]

            table = self.query.alias_map[alias][TABLE_NAME]

            if table in only_load and field.column not in only_load[table]:

                continue

            if as_pairs:

                result.append((alias, field.column))

                aliases.add(alias)

                continue

            if with_aliases and field.column in col_aliases:

                c_alias = 'Col%d' % len(col_aliases)

                result.append('%s.%s AS %s' % (qn(alias),

                    qn2(field.column), c_alias))

                col_aliases.add(c_alias)

                aliases.add(c_alias)

            else:

                r = '%s.%s' % (qn(alias), qn2(field.column))

                result.append(r)

                aliases.add(r)

                if with_aliases:

                    col_aliases.add(field.column)

        return result, aliases

    def get_ordering(self):

        """

        Returns a tuple containing a list representing the SQL elements in the

        "order by" clause, and the list of SQL elements that need to be added

        to the GROUP BY clause as a result of the ordering.

        Also sets the ordering_aliases attribute on this instance to a list of

        extra aliases needed in the select.

        Determining the ordering SQL can change the tables we need to include,

        so this should be run *before* get_from_clause().

        """

        if self.query.extra_order_by:

            ordering = self.query.extra_order_by

        elif not self.query.default_ordering:

            ordering = self.query.order_by

        else:

            ordering = self.query.order_by or self.query.model._meta.ordering

        qn = self.quote_name_unless_alias

        qn2 = self.connection.ops.quote_name

        distinct = self.query.distinct

        select_aliases = self._select_aliases

        result = []

        group_by = []

        ordering_aliases = []

        if self.query.standard_ordering:

            asc, desc = ORDER_DIR['ASC']

        else:

            asc, desc = ORDER_DIR['DESC']

        # It's possible, due to model inheritance, that normal usage might try

        # to include the same field more than once in the ordering. We track

        # the table/column pairs we use and discard any after the first use.

        processed_pairs = set()

        for field in ordering:

            if field == '?':

                result.append(self.connection.ops.random_function_sql())

                continue

            if isinstance(field, int):

                if field < 0:

                    order = desc

                    field = -field

                else:

                    order = asc

                result.append('%s %s' % (field, order))

                group_by.append((field, []))

                continue

            col, order = get_order_dir(field, asc)

            if col in self.query.aggregate_select:

                result.append('%s %s' % (col, order))

                continue

            if '.' in field:

                # This came in through an extra(order_by=...) addition. Pass it

                # on verbatim.

                table, col = col.split('.', 1)

                if (table, col) not in processed_pairs:

                    elt = '%s.%s' % (qn(table), col)

                    processed_pairs.add((table, col))

                    if not distinct or elt in select_aliases:

                        result.append('%s %s' % (elt, order))

                        group_by.append((elt, []))

            elif get_order_dir(field)[0] not in self.query.extra_select:

                # 'col' is of the form 'field' or 'field1__field2' or

                # '-field1__field2__field', etc.

                for table, col, order in self.find_ordering_name(field,

                        self.query.model._meta, default_order=asc):

                    if (table, col) not in processed_pairs:

                        elt = '%s.%s' % (qn(table), qn2(col))

                        processed_pairs.add((table, col))

                        if distinct and elt not in select_aliases:

                            ordering_aliases.append(elt)

                        result.append('%s %s' % (elt, order))

                        group_by.append((elt, []))

            else:

                elt = qn2(col)

                if distinct and col not in select_aliases:

                    ordering_aliases.append(elt)

                result.append('%s %s' % (elt, order))

                group_by.append(self.query.extra_select[col])

        self.query.ordering_aliases = ordering_aliases

        return result, group_by

    def find_ordering_name(self, name, opts, alias=None, default_order='ASC',

            already_seen=None):

        """

        Returns the table alias (the name might be ambiguous, the alias will

        not be) and column name for ordering by the given 'name' parameter.

        The 'name' is of the form 'field1__field2__...__fieldN'.

        """

        name, order = get_order_dir(name, default_order)

        pieces = name.split(LOOKUP_SEP)

        if not alias:

            alias = self.query.get_initial_alias()

        field, target, opts, joins, last, extra = self.query.setup_joins(pieces,

                opts, alias, False)

        alias = joins[-1]

        col = target.column

        if not field.rel:

            # To avoid inadvertent trimming of a necessary alias, use the

            # refcount to show that we are referencing a non-relation field on

            # the model.

            self.query.ref_alias(alias)

        # Must use left outer joins for nullable fields and their relations.