Renamed qn to compiler

django/contrib/gis/db/backends/base.py

@@ -186,7 +186,7 @@ def get_distance(self, f, value, lookup_type):
         """
         raise NotImplementedError('Distance operations not available on this spatial backend.')
 
-    def get_geom_placeholder(self, f, value, qn):
+    def get_geom_placeholder(self, f, value, compiler):
         """
         Returns the placeholder for the given geometry field with the given
         value.  Depending on the spatial backend, the placeholder may contain a

django/contrib/gis/db/backends/mysql/operations.py

@@ -35,14 +35,14 @@ class MySQLOperations(DatabaseOperations, BaseSpatialOperations):
     def geo_db_type(self, f):
         return f.geom_type
 
-    def get_geom_placeholder(self, f, value, qn):
+    def get_geom_placeholder(self, f, value, compiler):
         """
         The placeholder here has to include MySQL's WKT constructor.  Because
         MySQL does not support spatial transformations, there is no need to
         modify the placeholder based on the contents of the given value.
         """
         if hasattr(value, 'as_sql'):
-            placeholder, _ = qn.compile(value)
+            placeholder, _ = compiler.compile(value)
         else:
             placeholder = '%s(%%s)' % self.from_text
         return placeholder

django/contrib/gis/db/backends/oracle/operations.py

@@ -186,7 +186,7 @@ def get_distance(self, f, value, lookup_type):
 
         return [dist_param]
 
-    def get_geom_placeholder(self, f, value, qn):
+    def get_geom_placeholder(self, f, value, compiler):
         """
         Provides a proper substitution value for Geometries that are not in the
         SRID of the field.  Specifically, this routine will substitute in the
@@ -205,7 +205,7 @@ def transform_value(val, srid):
                 placeholder = '%s'
             # No geometry value used for F expression, substitute in
             # the column name instead.
-            sql, _ = qn.compile(value)
+            sql, _ = compiler.compile(value)
             return placeholder % sql
         else:
             if transform_value(value, f.srid):

django/contrib/gis/db/backends/postgis/operations.py

@@ -284,7 +284,7 @@ def get_distance(self, f, dist_val, lookup_type):
         else:
             return [dist_param]
 
-    def get_geom_placeholder(self, f, value, qn):
+    def get_geom_placeholder(self, f, value, compiler):
         """
         Provides a proper substitution value for Geometries that are not in the
         SRID of the field.  Specifically, this routine will substitute in the
@@ -300,7 +300,7 @@ def get_geom_placeholder(self, f, value, qn):
             # If this is an F expression, then we don't really want
             # a placeholder and instead substitute in the column
             # of the expression.
-            sql, _ = qn.compile(value)
+            sql, _ = compiler.compile(value)
             placeholder = placeholder % sql
 
         return placeholder

django/contrib/gis/db/backends/spatialite/operations.py

@@ -178,7 +178,7 @@ def get_distance(self, f, value, lookup_type):
             dist_param = value
         return [dist_param]
 
-    def get_geom_placeholder(self, f, value, qn):
+    def get_geom_placeholder(self, f, value, compiler):
         """
         Provides a proper substitution value for Geometries that are not in the
         SRID of the field.  Specifically, this routine will substitute in the
@@ -193,7 +193,7 @@ def transform_value(value, srid):
                 placeholder = '%s'
             # No geometry value used for F expression, substitute in
             # the column name instead.
-            sql, _ = qn.compile(value)
+            sql, _ = compiler.compile(value)
             return placeholder % sql
         else:
             if transform_value(value, f.srid):

django/contrib/gis/db/models/fields.py

@@ -282,12 +282,12 @@ def get_db_prep_save(self, value, connection):
         else:
             return connection.ops.Adapter(self.get_prep_value(value))
 
-    def get_placeholder(self, value, qn, connection):
+    def get_placeholder(self, value, compiler, connection):
         """
         Returns the placeholder for the geometry column for the
         given value.
         """
-        return connection.ops.get_geom_placeholder(self, value, qn)
+        return connection.ops.get_geom_placeholder(self, value, compiler)
 
 
 for klass in gis_lookups.values():

django/contrib/gis/db/models/lookups.py

@@ -64,8 +64,8 @@ def get_db_prep_lookup(self, value, connection):
             params = [connection.ops.Adapter(value)]
         return ('%s', params)
 
-    def process_rhs(self, qn, connection):
-        rhs, rhs_params = super(GISLookup, self).process_rhs(qn, connection)
+    def process_rhs(self, compiler, connection):
+        rhs, rhs_params = super(GISLookup, self).process_rhs(compiler, connection)
 
         geom = self.rhs
         if isinstance(self.rhs, Col):
@@ -80,12 +80,12 @@ def process_rhs(self, qn, connection):
             raise ValueError('Complex expressions not supported for GeometryField')
         elif isinstance(self.rhs, (list, tuple)):
             geom = self.rhs[0]
-        rhs = connection.ops.get_geom_placeholder(self.lhs.output_field, geom, qn)
+        rhs = connection.ops.get_geom_placeholder(self.lhs.output_field, geom, compiler)
         return rhs, rhs_params
 
-    def as_sql(self, qn, connection):
-        lhs_sql, sql_params = self.process_lhs(qn, connection)
-        rhs_sql, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs_sql, sql_params = self.process_lhs(compiler, connection)
+        rhs_sql, rhs_params = self.process_rhs(compiler, connection)
         sql_params.extend(rhs_params)
 
         template_params = {'lhs': lhs_sql, 'rhs': rhs_sql}

django/contrib/gis/db/models/sql/aggregates.py

@@ -29,7 +29,7 @@ def __init__(self, col, source=None, is_summary=False, tolerance=0.05, **extra):
         if not isinstance(self.source, GeometryField):
             raise ValueError('Geospatial aggregates only allowed on geometry fields.')
 
-    def as_sql(self, qn, connection):
+    def as_sql(self, compiler, connection):
         "Return the aggregate, rendered as SQL with parameters."
 
         if connection.ops.oracle:
@@ -38,9 +38,9 @@ def as_sql(self, qn, connection):
         params = []
 
         if hasattr(self.col, 'as_sql'):
-            field_name, params = self.col.as_sql(qn, connection)
+            field_name, params = self.col.as_sql(compiler, connection)
         elif isinstance(self.col, (list, tuple)):
-            field_name = '.'.join(qn(c) for c in self.col)
+            field_name = '.'.join(compiler.quote_name_unless_alias(c) for c in self.col)
         else:
             field_name = self.col
 

django/contrib/postgres/fields/array.py

@@ -164,9 +164,9 @@ def formfield(self, **kwargs):
 class ArrayContainsLookup(Lookup):
     lookup_name = 'contains'
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
         type_cast = self.lhs.output_field.db_type(connection)
         return '%s @> %s::%s' % (lhs, rhs, type_cast), params
@@ -176,9 +176,9 @@ def as_sql(self, qn, connection):
 class ArrayContainedByLookup(Lookup):
     lookup_name = 'contained_by'
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
         return '%s <@ %s' % (lhs, rhs), params
 
@@ -187,9 +187,9 @@ def as_sql(self, qn, connection):
 class ArrayOverlapLookup(Lookup):
     lookup_name = 'overlap'
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
         return '%s && %s' % (lhs, rhs), params
 
@@ -202,8 +202,8 @@ class ArrayLenTransform(Transform):
     def output_field(self):
         return IntegerField()
 
-    def as_sql(self, qn, connection):
-        lhs, params = qn.compile(self.lhs)
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
         return 'array_length(%s, 1)' % lhs, params
 
 
@@ -214,8 +214,8 @@ def __init__(self, index, base_field, *args, **kwargs):
         self.index = index
         self.base_field = base_field
 
-    def as_sql(self, qn, connection):
-        lhs, params = qn.compile(self.lhs)
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
         return '%s[%s]' % (lhs, self.index), params
 
     @property
@@ -240,8 +240,8 @@ def __init__(self, start, end, *args, **kwargs):
         self.start = start
         self.end = end
 
-    def as_sql(self, qn, connection):
-        lhs, params = qn.compile(self.lhs)
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
         return '%s[%s:%s]' % (lhs, self.start, self.end), params
 
 

django/contrib/postgres/fields/hstore.py

@@ -64,9 +64,9 @@ def formfield(self, **kwargs):
 class HStoreContainsLookup(Lookup):
     lookup_name = 'contains'
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
         return '%s @> %s' % (lhs, rhs), params
 
@@ -75,9 +75,9 @@ def as_sql(self, qn, connection):
 class HStoreContainedByLookup(Lookup):
     lookup_name = 'contained_by'
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
         return '%s <@ %s' % (lhs, rhs), params
 
@@ -86,9 +86,9 @@ def as_sql(self, qn, connection):
 class HasKeyLookup(Lookup):
     lookup_name = 'has_key'
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
         return '%s ? %s' % (lhs, rhs), params
 
@@ -97,9 +97,9 @@ def as_sql(self, qn, connection):
 class HasKeysLookup(Lookup):
     lookup_name = 'has_keys'
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
         return '%s ?& %s' % (lhs, rhs), params
 
@@ -111,8 +111,8 @@ def __init__(self, key_name, *args, **kwargs):
         super(KeyTransform, self).__init__(*args, **kwargs)
         self.key_name = key_name
 
-    def as_sql(self, qn, connection):
-        lhs, params = qn.compile(self.lhs)
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
         return "%s -> '%s'" % (lhs, self.key_name), params
 
 
@@ -130,8 +130,8 @@ class KeysTransform(Transform):
     lookup_name = 'keys'
     output_field = ArrayField(TextField())
 
-    def as_sql(self, qn, connection):
-        lhs, params = qn.compile(self.lhs)
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
         return 'akeys(%s)' % lhs, params
 
 
@@ -140,6 +140,6 @@ class ValuesTransform(Transform):
     lookup_name = 'values'
     output_field = ArrayField(TextField())
 
-    def as_sql(self, qn, connection):
-        lhs, params = qn.compile(self.lhs)
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
         return 'avals(%s)' % lhs, params

django/db/models/expressions.py

@@ -490,7 +490,8 @@ def __init__(self, alias, target, source=None):
         super(Col, self).__init__(output_field=source)
         self.alias, self.target = alias, target
 
-    def as_sql(self, qn, connection):
+    def as_sql(self, compiler, connection):
+        qn = compiler.quote_name_unless_alias
         return "%s.%s" % (qn(self.alias), qn(self.target.column)), []
 
     def relabeled_clone(self, relabels):
@@ -541,8 +542,8 @@ def get_source_expressions(self):
     def set_source_expressions(self, exprs):
         self.col, = self.exprs
 
-    def as_sql(self, qn, connection):
-        sql, params = self.col.as_sql(qn, connection)
+    def as_sql(self, compiler, connection):
+        sql, params = self.col.as_sql(compiler, connection)
         assert not(params)
         return connection.ops.date_trunc_sql(self.lookup_type, sql), []
 
@@ -563,7 +564,7 @@ def get_source_expressions(self):
     def set_source_expressions(self, exprs):
         self.col, = exprs
 
-    def as_sql(self, qn, connection):
-        sql, params = self.col.as_sql(qn, connection)
+    def as_sql(self, compiler, connection):
+        sql, params = self.col.as_sql(compiler, connection)
         assert not(params)
         return connection.ops.datetime_trunc_sql(self.lookup_type, sql, self.tzname)

django/db/models/fields/related.py

@@ -1553,7 +1553,8 @@ def get_extra_descriptor_filter(self, instance):
     def get_extra_restriction(self, where_class, alias, related_alias):
         """
         Returns a pair condition used for joining and subquery pushdown. The
-        condition is something that responds to as_sql(qn, connection) method.
+        condition is something that responds to as_sql(compiler, connection)
+        method.
 
         Note that currently referring both the 'alias' and 'related_alias'
         will not work in some conditions, like subquery pushdown.