Django

Code

Changeset 5967

Show
Ignore:
Timestamp:
08/19/07 20:03:33 (1 year ago)
Author:
adrian
Message:

Refactored quote_name() to DatabaseOperations?.quote_name(). Refs #5106

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/trunk/django/contrib/auth/models.py

    r5803 r5967  
    11from django.core import validators 
    22from django.core.exceptions import ImproperlyConfigured 
    3 from django.db import backend, connection, models 
     3from django.db import connection, models 
    44from django.contrib.contenttypes.models import ContentType 
    55from django.utils.encoding import smart_str 
    …… 
    204204            #         AND ct."id" = p."content_type_id" 
    205205            #         AND ug."user_id" = %s, [self.id]) 
     206            qn = connection.ops.quote_name 
    206207            sql = """ 
    207208                SELECT ct.%s, p.%s 
    …… 
    211212                    AND ct.%s = p.%s 
    212213                    AND ug.%s = %%s""" % ( 
    213                 backend.quote_name('app_label'), backend.quote_name('codename'), 
    214                 backend.quote_name('auth_permission'), backend.quote_name('auth_group_permissions'), 
    215                 backend.quote_name('auth_user_groups'), backend.quote_name('django_content_type'), 
    216                 backend.quote_name('id'), backend.quote_name('permission_id'), 
    217                 backend.quote_name('group_id'), backend.quote_name('group_id'), 
    218                 backend.quote_name('id'), backend.quote_name('content_type_id'), 
    219                 backend.quote_name('user_id'),) 
     214                qn('app_label'), qn('codename'), 
     215                qn('auth_permission'), qn('auth_group_permissions'), 
     216                qn('auth_user_groups'), qn('django_content_type'), 
     217                qn('id'), qn('permission_id'), 
     218                qn('group_id'), qn('group_id'), 
     219                qn('id'), qn('content_type_id'), 
     220                qn('user_id'),) 
    220221            cursor.execute(sql, [self.id]) 
    221222            self._group_perm_cache = set(["%s.%s" % (row[0], row[1]) for row in cursor.fetchall()]) 

  • django/trunk/django/contrib/contenttypes/generic.py

    r5609 r5967  
    55from django import oldforms 
    66from django.core.exceptions import ObjectDoesNotExist 
    7 from django.db import backend 
     7from django.db import connection 
    88from django.db.models import signals 
    99from django.db.models.fields.related import RelatedField, Field, ManyToManyRel 
    …… 
    164164        RelatedManager = create_generic_related_manager(superclass) 
    165165 
     166        qn = connection.ops.quote_name 
     167 
    166168        manager = RelatedManager( 
    167169            model = rel_model, 
    168170            instance = instance, 
    169171            symmetrical = (self.field.rel.symmetrical and instance.__class__ == rel_model), 
    170             join_table = backend.quote_name(self.field.m2m_db_table()), 
    171             source_col_name = backend.quote_name(self.field.m2m_column_name()), 
    172             target_col_name = backend.quote_name(self.field.m2m_reverse_name()), 
     172            join_table = qn(self.field.m2m_db_table()), 
     173            source_col_name = qn(self.field.m2m_column_name()), 
     174            target_col_name = qn(self.field.m2m_reverse_name()), 
    173175            content_type = ContentType.objects.get_for_model(self.field.model), 
    174176            content_type_field_name = self.field.content_type_field_name, 

  • django/trunk/django/core/management/commands/createcachetable.py

    r5903 r5967  
    99 
    1010    def handle_label(self, tablename, **options): 
    11         from django.db import backend, connection, transaction, models 
     11        from django.db import connection, transaction, models 
    1212        fields = ( 
    1313            # "key" is a reserved word in MySQL, so use "cache_key" instead. 
    …… 
    1818        table_output = [] 
    1919        index_output = [] 
     20        qn = connection.ops.quote_name 
    2021        for f in fields: 
    21             field_output = [backend.quote_name(f.name), f.db_type()] 
     22            field_output = [qn(f.name), f.db_type()] 
    2223            field_output.append("%sNULL" % (not f.null and "NOT " or "")) 
    2324            if f.unique: 
    …… 
    2829                unique = f.unique and "UNIQUE " or "" 
    2930                index_output.append("CREATE %sINDEX %s_%s ON %s (%s);" % \ 
    30                     (unique, tablename, f.name, backend.quote_name(tablename), 
    31                     backend.quote_name(f.name))) 
     31                    (unique, tablename, f.name, qn(tablename), 
     32                    qn(f.name))) 
    3233            table_output.append(" ".join(field_output)) 
    33         full_statement = ["CREATE TABLE %s (" % backend.quote_name(tablename)] 
     34        full_statement = ["CREATE TABLE %s (" % qn(tablename)] 
    3435        for i, line in enumerate(table_output): 
    3536            full_statement.append('    %s%s' % (line, i < len(table_output)-1 and ',' or '')) 

  • django/trunk/django/core/management/sql.py

    r5966 r5967  
    117117 
    118118    output = [] 
     119    qn = connection.ops.quote_name 
    119120 
    120121    # Output DROP TABLE statements for standard application tables. 
    …… 
    137138            # Drop the table now 
    138139            output.append('%s %s;' % (style.SQL_KEYWORD('DROP TABLE'), 
    139                 style.SQL_TABLE(backend.quote_name(model._meta.db_table)))) 
     140                style.SQL_TABLE(qn(model._meta.db_table)))) 
    140141            if backend.supports_constraints and model in references_to_delete: 
    141142                for rel_class, f in references_to_delete[model]: 
    …… 
    147148                    output.append('%s %s %s %s;' % \ 
    148149                        (style.SQL_KEYWORD('ALTER TABLE'), 
    149                         style.SQL_TABLE(backend.quote_name(table)), 
     150                        style.SQL_TABLE(qn(table)), 
    150151                        style.SQL_KEYWORD(connection.ops.drop_foreignkey_sql()), 
    151152                        style.SQL_FIELD(truncate_name(r_name, connection.ops.max_name_length())))) 
    …… 
    160161            if cursor and table_name_converter(f.m2m_db_table()) in table_names: 
    161162                output.append("%s %s;" % (style.SQL_KEYWORD('DROP TABLE'), 
    162                     style.SQL_TABLE(backend.quote_name(f.m2m_db_table())))) 
     163                    style.SQL_TABLE(qn(f.m2m_db_table())))) 
    163164                if hasattr(backend, 'get_drop_sequence'): 
    164165                    output.append(backend.get_drop_sequence("%s_%s" % (model._meta.db_table, f.column))) 
    …… 
    220221    table_output = [] 
    221222    pending_references = {} 
     223    qn = connection.ops.quote_name 
    222224    for f in opts.fields: 
    223225        col_type = f.db_type() 
    …… 
    228230            continue 
    229231        # Make the definition (e.g. 'foo VARCHAR(30)') for this field. 
    230         field_output = [style.SQL_FIELD(backend.quote_name(f.column)), 
     232        field_output = [style.SQL_FIELD(qn(f.column)), 
    231233            style.SQL_COLTYPE(col_type)] 
    232234        field_output.append(style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or ''))) 
    …… 
    242244            if f.rel.to in known_models: 
    243245                field_output.append(style.SQL_KEYWORD('REFERENCES') + ' ' + \ 
    244                     style.SQL_TABLE(backend.quote_name(f.rel.to._meta.db_table)) + ' (' + \ 
    245                     style.SQL_FIELD(backend.quote_name(f.rel.to._meta.get_field(f.rel.field_name).column)) + ')' + 
     246                    style.SQL_TABLE(qn(f.rel.to._meta.db_table)) + ' (' + \ 
     247                    style.SQL_FIELD(qn(f.rel.to._meta.get_field(f.rel.field_name).column)) + ')' + 
    246248                    connection.ops.deferrable_sql() 
    247249                ) 
    …… 
    252254        table_output.append(' '.join(field_output)) 
    253255    if opts.order_with_respect_to: 
    254         table_output.append(style.SQL_FIELD(backend.quote_name('_order')) + ' ' + \ 
     256        table_output.append(style.SQL_FIELD(qn('_order')) + ' ' + \ 
    255257            style.SQL_COLTYPE(models.IntegerField().db_type()) + ' ' + \ 
    256258            style.SQL_KEYWORD('NULL')) 
    257259    for field_constraints in opts.unique_together: 
    258260        table_output.append(style.SQL_KEYWORD('UNIQUE') + ' (%s)' % \ 
    259             ", ".join([backend.quote_name(style.SQL_FIELD(opts.get_field(f).column)) for f in field_constraints])) 
    260  
    261     full_statement = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + style.SQL_TABLE(backend.quote_name(opts.db_table)) + ' ('] 
     261            ", ".join([qn(style.SQL_FIELD(opts.get_field(f).column)) for f in field_constraints])) 
     262 
     263    full_statement = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + style.SQL_TABLE(qn(opts.db_table)) + ' ('] 
    262264    for i, line in enumerate(table_output): # Combine and add commas. 
    263265        full_statement.append('    %s%s' % (line, i < len(table_output)-1 and ',' or '')) 
    …… 
    284286    from django.db.backends.util import truncate_name 
    285287 
     288    qn = connection.ops.quote_name 
    286289    final_output = [] 
    287290    if backend.supports_constraints: 
    …… 
    298301                r_name = '%s_refs_%s_%x' % (r_col, col, abs(hash((r_table, table)))) 
    299302                final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)%s;' % \ 
    300                     (backend.quote_name(r_table), truncate_name(r_name, connection.ops.max_name_length()), 
    301                     backend.quote_name(r_col), backend.quote_name(table), backend.quote_name(col), 
     303                    (qn(r_table), truncate_name(r_name, connection.ops.max_name_length()), 
     304                    qn(r_col), qn(table), qn(col), 
    302305                    connection.ops.deferrable_sql())) 
    303306            del pending_references[model] 
    …… 
    310313    opts = model._meta 
    311314    final_output = [] 
     315    qn = connection.ops.quote_name 
    312316    for f in opts.many_to_many: 
    313317        if not isinstance(f.rel, generic.GenericRel): 
    …… 
    318322                tablespace_sql = '' 
    319323            table_output = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + \ 
    320                 style.SQL_TABLE(backend.quote_name(f.m2m_db_table())) + ' ('] 
     324                style.SQL_TABLE(qn(f.m2m_db_table())) + ' ('] 
    321325            table_output.append('    %s %s %s%s,' % \ 
    322                 (style.SQL_FIELD(backend.quote_name('id')), 
     326                (style.SQL_FIELD(qn('id')), 
    323327                style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type()), 
    324328                style.SQL_KEYWORD('NOT NULL PRIMARY KEY'), 
    325329                tablespace_sql)) 
    326330            table_output.append('    %s %s %s %s (%s)%s,' % \ 
    327                 (style.SQL_FIELD(backend.quote_name(f.m2m_column_name())), 
     331                (style.SQL_FIELD(qn(f.m2m_column_name())), 
    328332                style.SQL_COLTYPE(models.ForeignKey(model).db_type()), 
    329333                style.SQL_KEYWORD('NOT NULL REFERENCES'), 
    330                 style.SQL_TABLE(backend.quote_name(opts.db_table)), 
    331                 style.SQL_FIELD(backend.quote_name(opts.pk.column)), 
     334                style.SQL_TABLE(qn(opts.db_table)), 
     335                style.SQL_FIELD(qn(opts.pk.column)), 
    332336                connection.ops.deferrable_sql())) 
    333337            table_output.append('    %s %s %s %s (%s)%s,' % \ 
    334                 (style.SQL_FIELD(backend.quote_name(f.m2m_reverse_name())), 
     338                (style.SQL_FIELD(qn(f.m2m_reverse_name())), 
    335339                style.SQL_COLTYPE(models.ForeignKey(f.rel.to).db_type()), 
    336340                style.SQL_KEYWORD('NOT NULL REFERENCES'), 
    337                 style.SQL_TABLE(backend.quote_name(f.rel.to._meta.db_table)), 
    338                 style.SQL_FIELD(backend.quote_name(f.rel.to._meta.pk.column)), 
     341                style.SQL_TABLE(qn(f.rel.to._meta.db_table)), 
     342                style.SQL_FIELD(qn(f.rel.to._meta.pk.column)), 
    339343                connection.ops.deferrable_sql())) 
    340344            table_output.append('    %s (%s, %s)%s' % \ 
    341345                (style.SQL_KEYWORD('UNIQUE'), 
    342                 style.SQL_FIELD(backend.quote_name(f.m2m_column_name())), 
    343                 style.SQL_FIELD(backend.quote_name(f.m2m_reverse_name())), 
     346                style.SQL_FIELD(qn(f.m2m_column_name())), 
     347                style.SQL_FIELD(qn(f.m2m_reverse_name())), 
    344348                tablespace_sql)) 
    345349            table_output.append(')') 
    …… 
    351355 
    352356            # Add any extra SQL needed to support auto-incrementing PKs 
    353             autoinc_sql = backend.get_autoinc_sql(f.m2m_db_table()) 
     357            autoinc_sql = connection.ops.autoinc_sql(f.m2m_db_table()) 
    354358            if autoinc_sql: 
    355359                for stmt in autoinc_sql: 
    …… 
    390394    output = [] 
    391395 
     396    qn = connection.ops.quote_name 
    392397    for f in model._meta.fields: 
    393398        if f.db_index and not ((f.primary_key or f.unique) and backend.autoindexes_primary_keys): 
    …… 
    400405            output.append( 
    401406                style.SQL_KEYWORD('CREATE %sINDEX' % unique) + ' ' + \ 
    402                 style.SQL_TABLE(backend.quote_name('%s_%s' % (model._meta.db_table, f.column))) + ' ' + \ 
     407                style.SQL_TABLE(qn('%s_%s' % (model._meta.db_table, f.column))) + ' ' + \ 
    403408                style.SQL_KEYWORD('ON') + ' ' + \ 
    404                 style.SQL_TABLE(backend.quote_name(model._meta.db_table)) + ' ' + \ 
    405                 "(%s)" % style.SQL_FIELD(backend.quote_name(f.column)) + \ 
     409                style.SQL_TABLE(qn(model._meta.db_table)) + ' ' + \ 
     410                "(%s)" % style.SQL_FIELD(qn(f.column)) + \ 
    406411                "%s;" % tablespace_sql 
    407412            ) 

  • django/trunk/django/db/backends/ado_mssql/base.py

    r5966 r5967  
    6868        return cursor.fetchone()[0] 
    6969 
     70    def quote_name(self, name): 
     71        if name.startswith('[') and name.endswith(']'): 
     72            return name # Quoting once is enough. 
     73        return '[%s]' % name 
     74 
    7075    def random_function_sql(self): 
    7176        return 'RAND()' 
    7277 
    7378    def tablespace_sql(self, tablespace, inline=False): 
    74         return "ON %s" % quote_name(tablespace) 
     79        return "ON %s" % self.quote_name(tablespace) 
    7580 
    7681class DatabaseWrapper(BaseDatabaseWrapper): 
    …… 
    98103uses_case_insensitive_names = False 
    99104 
    100 def quote_name(name): 
    101     if name.startswith('[') and name.endswith(']'): 
    102         return name # Quoting once is enough. 
    103     return '[%s]' % name 
    104  
    105105dictfetchone = util.dictfetchone 
    106106dictfetchmany = util.dictfetchmany 

  • django/trunk/django/db/backends/dummy/base.py

    r5965 r5967  
    4040supports_constraints = False 
    4141supports_tablespaces = False 
    42 quote_name = complain 
    4342dictfetchone = complain 
    4443dictfetchmany = complain 

  • django/trunk/django/db/backends/__init__.py

    r5966 r5967  
    135135        return 'DEFAULT' 
    136136 
     137    def quote_name(self, name): 
     138        """ 
     139        Returns a quoted version of the given table, index or column name. Does 
     140        not quote the given name if it's already been quoted. 
     141        """ 
     142        raise NotImplementedError() 
     143 
    137144    def random_function_sql(self): 
    138145        """ 

  • django/trunk/django/db/backends/mysql/base.py

    r5965 r5967  
    8585        return sql + str(limit) 
    8686 
     87    def quote_name(self, name): 
     88        if name.startswith("`") and name.endswith("`"): 
     89            return name # Quoting once is enough. 
     90        return "`%s`" % name 
     91 
    8792    def random_function_sql(self): 
    8893        return 'RAND()' 
    …… 
    95100            sql = ['SET FOREIGN_KEY_CHECKS = 0;'] 
    96101            for table in tables: 
    97                 sql.append('%s %s;' % (style.SQL_KEYWORD('TRUNCATE'), style.SQL_FIELD(quote_name(table)))) 
     102                sql.append('%s %s;' % (style.SQL_KEYWORD('TRUNCATE'), style.SQL_FIELD(self.quote_name(table)))) 
    98103            sql.append('SET FOREIGN_KEY_CHECKS = 1;') 
    99104 
    …… 
    103108                (style.SQL_KEYWORD('ALTER'), 
    104109                 style.SQL_KEYWORD('TABLE'), 
    105                  style.SQL_TABLE(quote_name(sequence['table'])), 
     110                 style.SQL_TABLE(self.quote_name(sequence['table'])), 
    106111                 style.SQL_KEYWORD('AUTO_INCREMENT'), 
    107112                 style.SQL_FIELD('= 1'), 
    …… 
    180185uses_case_insensitive_names = False 
    181186 
    182 def quote_name(name): 
    183     if name.startswith("`") and name.endswith("`"): 
    184         return name # Quoting once is enough. 
    185     return "`%s`" % name 
    186  
    187187dictfetchone = util.dictfetchone 
    188188dictfetchmany = util.dictfetchmany 

  • django/trunk/django/db/backends/mysql/introspection.py

    r5302 r5967  
    1 from django.db.backends.mysql.base import quote_name 
     1from django.db.backends.mysql.base import DatabaseOperations 
    22from MySQLdb import ProgrammingError, OperationalError 
    33from MySQLdb.constants import FIELD_TYPE 
    44import re 
    55 
     6quote_name = DatabaseOperations().quote_name 
    67foreign_key_re = re.compile(r"\sCONSTRAINT `[^`]*` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)` \(`([^`]*)`\)") 
    78 

  • django/trunk/django/db/backends/mysql_old/base.py

    r5965 r5967  
    9595        return sql + str(limit) 
    9696 
     97    def quote_name(self, name): 
     98        if name.startswith("`") and name.endswith("`"): 
     99            return name # Quoting once is enough. 
     100        return "`%s`" % name 
     101 
    97102    def random_function_sql(self): 
    98103        return 'RAND()' 
    …… 
    105110            sql = ['SET FOREIGN_KEY_CHECKS = 0;'] 
    106111            for table in tables: 
    107                 sql.append('%s %s;' % (style.SQL_KEYWORD('TRUNCATE'), style.SQL_FIELD(quote_name(table)))) 
     112                sql.append('%s %s;' % (style.SQL_KEYWORD('TRUNCATE'), style.SQL_FIELD(self.quote_name(table)))) 
    108113            sql.append('SET FOREIGN_KEY_CHECKS = 1;') 
    109114 
    …… 
    113118                (style.SQL_KEYWORD('ALTER'), 
    114119                 style.SQL_KEYWORD('TABLE'), 
    115                  style.SQL_TABLE(quote_name(sequence['table'])), 
     120                 style.SQL_TABLE(self.quote_name(sequence['table'])), 
    116121                 style.SQL_KEYWORD('AUTO_INCREMENT'), 
    117122                 style.SQL_FIELD('= 1'), 
    …… 
    199204uses_case_insensitive_names = False 
    200205 
    201 def quote_name(name): 
    202     if name.startswith("`") and name.endswith("`"): 
    203         return name # Quoting once is enough. 
    204     return "`%s`" % name 
    205  
    206206dictfetchone = util.dictfetchone 
    207207dictfetchmany = util.dictfetchmany 

  • django/trunk/django/db/backends/mysql_old/introspection.py

    r5876 r5967  
    1 from django.db.backends.mysql_old.base import quote_name 
     1from django.db.backends.mysql_old.base import DatabaseOperations 
    22from MySQLdb import ProgrammingError, OperationalError 
    33from MySQLdb.constants import FIELD_TYPE 
    44import re 
    55 
     6quote_name = DatabaseOperations().quote_name 
    67foreign_key_re = re.compile(r"\sCONSTRAINT `[^`]*` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)` \(`([^`]*)`\)") 
    78 

  • django/trunk/django/db/backends/oracle/base.py

    r5966 r5967  
    3636                BEGIN 
    3737                    SELECT %s.nextval INTO :new.id FROM dual; 
    38                 END;/""" % (tr_name, quote_name(table), sq_name) 
     38                END;/""" % (tr_name, self.quote_name(table), sq_name) 
    3939        return sequence_sql, trigger_sql 
    4040 
    …… 
    7070    def max_name_length(self): 
    7171        return 30 
     72 
     73    def quote_name(self, name): 
     74        # SQL92 requires delimited (quoted) names to be case-sensitive.  When 
     75        # not quoted, Oracle has case-insensitive behavior for identifiers, but 
     76        # always defaults to uppercase. 
     77        # We simplify things by making Oracle identifiers always uppercase. 
     78        if not name.startswith('"') and not name.endswith('"'): 
     79            name = '"%s"' % util.truncate_name(name.upper(), DatabaseOperations().max_name_length()) 
     80        return name.upper() 
    7281 
    7382    def random_function_sql(self): 
    …… 
    8392                    (style.SQL_KEYWORD('DELETE'), 
    8493                     style.SQL_KEYWORD('FROM'), 
    85                      style.SQL_FIELD(quote_name(table)) 
     94                     style.SQL_FIELD(self.quote_name(table)) 
    8695                     ) for table in tables] 
    8796            # Since we've just deleted all the rows, running our sequence 
    …… 
    9099                table_name = sequence_info['table'] 
    91100                seq_name = get_sequence_name(table_name) 
    92                 query = _get_sequence_reset_sql() % {'sequence':seq_name, 'table':quote_name(table_name)} 
     101                query = _get_sequence_reset_sql() % {'sequence': seq_name, 'table': self.quote_name(table_name)} 
    93102                sql.append(query) 
    94103            return sql 
    …… 
    117126 
    118127    def tablespace_sql(self, tablespace, inline=False): 
    119         return "%sTABLESPACE %s" % ((inline and "USING INDEX " or ""), quote_name(tablespace)) 
     128        return "%sTABLESPACE %s" % ((inline and "USING INDEX " or ""), self.quote_name(tablespace)) 
    120129 
    121130class DatabaseWrapper(BaseDatabaseWrapper): 
    …… 
    216225    return s 
    217226 
    218 def quote_name(name): 
    219     # SQL92 requires delimited (quoted) names to be case-sensitive.  When 
    220     # not quoted, Oracle has case-insensitive behavior for identifiers, but 
    221     # always defaults to uppercase. 
    222     # We simplify things by making Oracle identifiers always uppercase. 
    223     if not name.startswith('"') and not name.endswith('"'): 
    224         name = '"%s"' % util.truncate_name(name.upper(), DatabaseOperations().max_name_length()) 
    225     return name.upper() 
    226  
    227227dictfetchone = util.dictfetchone 
    228228dictfetchmany = util.dictfetchmany 
    …… 
    236236 
    237237def get_drop_sequence(table): 
    238     return "DROP SEQUENCE %s;" % quote_name(get_sequence_name(table)) 
     238    return "DROP SEQUENCE %s;" % DatabaseOperations().quote_name(get_sequence_name(table)) 
    239239 
    240240def _get_sequence_reset_sql(): 
    …… 
    329329 
    330330            opts = self.model._meta 
     331            qn = connection.ops.quote_name 
    331332 
    332333            # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z. 
    333             select = ["%s.%s" % (backend.quote_name(opts.db_table), backend.quote_name(f.column)) for f in opts.fields] 
     334            select = ["%s.%s" % (qn(opts.db_table), qn(f.column)) for f in opts.fields] 
    334335            tables = [quote_only_if_word(t) for t in self._tables] 
    335336            joins = SortedDict() 
    …… 
    349350            # Add any additional SELECTs. 
    350351            if self._select: 
    351                 select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), backend.quote_name(s[0])) for s in self._select.items()]) 
     352                select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), qn(s[0])) for s in self._select.items()]) 
    352353 
    353354            # Start composing the body of the SQL statement. 
    354             sql = [" FROM", backend.quote_name(opts.db_table)] 
     355            sql = [" FROM", qn(opts.db_table)] 
    355356 
    356357            # Compose the join dictionary into SQL describing the joins. 
    …… 
    385386                    if "." in col_name: 
    386387                        table_prefix, col_name = col_name.split('.', 1) 
    387                         table_prefix = backend.quote_name(table_prefix) + '.' 
     388                        table_prefix = qn(table_prefix) + '.' 
    388389                    else: 
    389390                        # Use the database table as a column prefix if it wasn't given, 
    390391                        # and if the requested column isn't a custom SELECT. 
    391392                        if "." not in col_name and col_name not in (self._select or ()): 
    392                             table_prefix = backend.quote_name(opts.db_table) + '.' 
     393                            table_prefix = qn(opts.db_table) + '.' 
    393394                        else: 
    394395                            table_prefix = '' 
    395                     order_by.append('%s%s %s' % (table_prefix, backend.quote_name(orderfield2column(col_name, opts)), order)) 
     396                    order_by.append('%s%s %s' % (table_prefix, qn(orderfield2column(col_name, opts)), order)) 
    396397            if order_by: 
    397398                sql.append("ORDER BY " + ", ".join(order_by)) 
    …… 
    418419                #So we need to define a default order-by, since none was provided. 
    419420                order_by_clause = " OVER (ORDER BY %s.%s)" % \ 
    420                     (backend.quote_name(opts.db_table), 
    421                     backend.quote_name(opts.fields[0].db_column or opts.fields[0].column)) 
     421                    (qn(opts.db_table), qn(opts.fields[0].db_column or opts.fields[0].column)) 
    422422            # limit_and_offset_clause 
    423423            if self._limit is None: 

  • django/trunk/django/db/backends/oracle/introspection.py

    r5519 r5967  
    1 from django.db.backends.oracle.base import quote_name 
     1from django.db.backends.oracle.base import DatabaseOperations 
    22import re 
    33import cx_Oracle 
    44 
    5  
     5quote_name = DatabaseOperations().quote_name 
    66foreign_key_re = re.compile(r"\sCONSTRAINT `[^`]*` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)` \(`([^`]*)`\)") 
    77 

  • django/trunk/django/db/backends/postgresql/base.py

    r5965 r5967  
    7474        return cursor.fetchone()[0] 
    7575 
     76    def quote_name(self, name): 
     77        if name.startswith('"') and name.endswith('"'): 
     78            return name # Quoting once is enough. 
     79        return '"%s"' % name 
     80 
    7681    def sql_flush(self, style, tables, sequences): 
    7782        if tables: 
    …… 
    8388                sql = ['%s %s;' % \ 
    8489                    (style.SQL_KEYWORD('TRUNCATE'), 
    85                      style.SQL_FIELD(', '.join([quote_name(table) for table in tables])) 
     90                     style.SQL_FIELD(', '.join([self.quote_name(table) for table in tables])) 
    8691                )] 
    8792            else: 
    …… 
    9196                        (style.SQL_KEYWORD('DELETE'), 
    9297                         style.SQL_KEYWORD('FROM'), 
    93                          style.SQL_FIELD(quote_name(table)) 
     98                         style.SQL_FIELD(self.quote_name(table)) 
    9499                         ) for table in tables] 
    95100 
    …… 
    104109                        (style.SQL_KEYWORD('ALTER'), 
    105110                        style.SQL_KEYWORD('SEQUENCE'), 
    106                         style.SQL_FIELD(quote_name('%s_%s_seq' % (table_name, column_name))), 
     111                        style.SQL_FIELD(self.quote_name('%s_%s_seq' % (table_name, column_name))), 
    107112                        style.SQL_KEYWORD('RESTART'), 
    108113                        style.SQL_KEYWORD('WITH'), 
    …… 
    115120                        (style.SQL_KEYWORD('ALTER'), 
    116121                         style.SQL_KEYWORD('SEQUENCE'), 
    117                          style.SQL_FIELD(quote_name('%s_id_seq' % table_name)), 
     122                         style.SQL_FIELD(self.quote_name('%s_id_seq' % table_name)), 
    118123                         style.SQL_KEYWORD('RESTART'), 
    119124                         style.SQL_KEYWORD('WITH'), 
    …… 
    128133        from django.db import models 
    129134        output = [] 
     135        qn = self.quote_name 
    130136        for model in model_list: 
    131137            # Use `coalesce` to set the sequence for each model to the max pk value if there are records, 
    …… 
    136142                    output.append("%s setval('%s', coalesce(max(%s), 1), max(%s) %s null) %s %s;" % \ 
    137143                        (style.SQL_KEYWORD('SELECT'), 
    138                         style.SQL_FIELD(quote_name('%s_%s_seq' % (model._meta.db_table, f.column))), 
    139                         style.SQL_FIELD(quote_name(f.column)), 
    140                         style.SQL_FIELD(quote_name(f.column)), 
     144                        style.SQL_FIELD(qn('%s_%s_seq' % (model._meta.db_table, f.column))), 
     145                        style.SQL_FIELD(qn(f.column)), 
     146                        style.SQL_FIELD(qn(f.column)), 
    141147                        style.SQL_KEYWORD('IS NOT'), 
    142148                        style.SQL_KEYWORD('FROM'), 
    143                         style.SQL_TABLE(quote_name(model._meta.db_table)))) 
     149                        style.SQL_TABLE(qn(model._meta.db_table)))) 
    144150                    break # Only one AutoField is allowed per model, so don't bother continuing. 
    145151            for f in model._meta.many_to_many: 
    146152                output.append("%s setval('%s', coalesce(max(%s), 1), max(%s) %s null) %s %s;" % \ 
    147153                    (style.SQL_KEYWORD('SELECT'), 
    148                     style.SQL_FIELD(quote_name('%s_id_seq' % f.m2m_db_table())), 
    149                     style.SQL_FIELD(quote_name('id')), 
    150                     style.SQL_FIELD(quote_name('id')), 
     154                    style.SQL_FIELD(qn('%s_id_seq' % f.m2m_db_table())), 
     155                    style.SQL_FIELD(qn('id')), 
     156                    style.SQL_FIELD(qn('id')), 
    151157                    style.SQL_KEYWORD('IS NOT'), 
    152158                    style.SQL_KEYWORD('FROM'), 
    …… 
    195201uses_case_insensitive_names = False 
    196202 
    197 def quote_name(name): 
    198     if name.startswith('"') and name.endswith('"'): 
    199         return name # Quoting once is enough. 
    200     return '"%s"' % name 
    201  
    202203def dictfetchone(cursor): 
    203204    "Returns a row from the cursor as a dict" 

  • django/trunk/django/db/backends/postgresql/introspection.py

    r5302 r5967  
    1 from django.db.backends.postgresql.base import quote_name 
     1from django.db.backends.postgresql.base import DatabaseOperations 
     2 
     3quote_name = DatabaseOperations().quote_name 
    24 
    35def get_table_list(cursor): 

  • django/trunk/django/db/backends/postgresql_psycopg2/base.py

    r5965 r5967  
    3636        return cursor.fetchone()[0] 
    3737 
     38    def quote_name(self, name): 
     39        if name.startswith('"') and name.endswith('"'): 
     40            return name # Quoting once is enough. 
     41        return '"%s"' % name 
     42 
    3843    def sql_flush(self, style, tables, sequences): 
     44        qn = self.quote_name 
    3945        if tables: 
    4046            if postgres_version[0] >= 8 and postgres_version[1] >= 1: 
    …… 
    4551                sql = ['%s %s;' % \ 
    4652                    (style.SQL_KEYWORD('TRUNCATE'), 
    47                      style.SQL_FIELD(', '.join([quote_name(table) for table in tables])) 
     53                     style.SQL_FIELD(', '.join([qn(table) for table in tables])) 
    4854                )] 
    4955            else: 
    …… 
    5359                        (style.SQL_KEYWORD('DELETE'), 
    5460                         style.SQL_KEYWORD('FROM'), 
    55                          style.SQL_FIELD(quote_name(table)) 
     61                         style.SQL_FIELD(qn(table)) 
    5662                         ) for table in tables] 
    5763 
    …… 
    6672                        (style.SQL_KEYWORD('ALTER'), 
    6773                        style.SQL_KEYWORD('SEQUENCE'), 
    68                         style.SQL_FIELD(quote_name('%s_%s_seq' % (table_name, column_name))), 
     74                        style.SQL_FIELD(qn('%s_%s_seq' % (table_name, column_name))), 
    6975                        style.SQL_KEYWORD('RESTART'), 
    7076                        style.SQL_KEYWORD('WITH'), 
    …… 
    7783                        (style.SQL_KEYWORD('ALTER'), 
    7884                         style.SQL_KEYWORD('SEQUENCE'), 
    79                          style.SQL_FIELD(quote_name('%s_id_seq' % table_name)), 
     85                         style.SQL_FIELD(qn('%s_id_seq' % table_name)), 
    8086                         style.SQL_KEYWORD('RESTART'), 
    8187                         style.SQL_KEYWORD('WITH'), 
    …… 
    8995    def sequence_reset_sql(self, style, model_list): 
    9096        from django.db import models 
     97        qn = self.quote_name 
    9198        output = [] 
    9299        for model in model_list: 
    …… 
    98105                    output.append("%s setval('%s', coalesce(max(%s), 1), max(%s) %s null) %s %s;" % \ 
    99106                        (style.SQL_KEYWORD('SELECT'), 
    100                         style.SQL_FIELD(quote_name('%s_%s_seq' % (model._meta.db_table, f.column))), 
    101                         style.SQL_FIELD(quote_name(f.column)), 
    102                         style.SQL_FIELD(quote_name(f.column)), 
     107                        style.SQL_FIELD(qn('%s_%s_seq' % (model._meta.db_table, f.column))), 
     108                        style.SQL_FIELD(qn(f.column)), 
     109                        style.SQL_FIELD(qn(f.column)), 
    103110                        style.SQL_KEYWORD('IS NOT'), 
    104111                        style.SQL_KEYWORD('FROM'), 
    105                         style.SQL_TABLE(quote_name(model._meta.db_table)))) 
     112                        style.SQL_TABLE(qn(model._meta.db_table)))) 
    106113                    break # Only one AutoField is allowed per model, so don't bother continuing. 
    107114            for f in model._meta.many_to_many: 
    108115                output.append("%s setval('%s', coalesce(max(%s), 1), max(%s) %s null) %s %s;" % \ 
    109116                    (style.SQL_KEYWORD('SELECT'), 
    110                     style.SQL_FIELD(quote_name('%s_id_seq' % f.m2m_db_table())), 
    111                     style.SQL_FIELD(quote_name('id')), 
    112                     style.SQL_FIELD(quote_name('id')), 
     117                    style.SQL_FIELD(qn('%s_id_seq' % f.m2m_db_table())), 
     118                    style.SQL_FIELD(qn('id')), 
     119                    style.SQL_FIELD(qn('id')), 
    113120                    style.SQL_KEYWORD('IS NOT'), 
    114121                    style.SQL_KEYWORD('FROM'), 
    …… 
    157164uses_case_insensitive_names = False 
    158165 
    159 def quote_name(name): 
    160     if name.startswith('"') and name.endswith('"'): 
    161         return name # Quoting once is enough. 
    162     return '"%s"' % name