← Back to branch summary

~ubuntu-branches/ubuntu/quantal/python-django/quantal-security

« back to all changes in this revision

Viewing changes to django/db/backends/creation.py

  • Committer: Bazaar Package Importer
  • Author(s): Chris Lamb
  • Date: 2010-05-21 07:52:55 UTC
  • mfrom: (1.3.6 upstream)
  • mto: This revision was merged to the branch mainline in revision 28.
  • Revision ID: james.westby@ubuntu.com-20100521075255-ii78v1dyfmyu3uzx
Tags: upstream-1.2
Import upstream version 1.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
django/db/backends/creation.py
1
1
import sys
2
2
import time
3
 
try:
4
 
    set
5
 
except NameError:
6
 
    # Python 2.3 compat
7
 
    from sets import Set as set
8
3
 
9
4
from django.conf import settings
10
5
from django.core.management import call_command
47
42
        pending_references = {}
48
43
        qn = self.connection.ops.quote_name
49
44
        for f in opts.local_fields:
50
 
            col_type = f.db_type()
 
45
            col_type = f.db_type(connection=self.connection)
51
46
            tablespace = f.db_tablespace or opts.db_tablespace
52
47
            if col_type is None:
53
48
                # Skip ManyToManyFields, because they're not represented as
73
68
                else:
74
69
                    field_output.extend(ref_output)
75
70
            table_output.append(' '.join(field_output))
76
 
        if opts.order_with_respect_to:
77
 
            table_output.append(style.SQL_FIELD(qn('_order')) + ' ' + \
78
 
                style.SQL_COLTYPE(models.IntegerField().db_type()))
79
71
        for field_constraints in opts.unique_together:
80
72
            table_output.append(style.SQL_KEYWORD('UNIQUE') + ' (%s)' % \
81
73
                ", ".join([style.SQL_FIELD(qn(opts.get_field(f).column)) for f in field_constraints]))
145
137
 
146
138
    def sql_for_many_to_many(self, model, style):
147
139
        "Return the CREATE TABLE statments for all the many-to-many tables defined on a model"
 
140
        import warnings
 
141
        warnings.warn(
 
142
            'Database creation API for m2m tables has been deprecated. M2M models are now automatically generated',
 
143
            PendingDeprecationWarning
 
144
        )
 
145
 
148
146
        output = []
149
147
        for f in model._meta.local_many_to_many:
150
148
            if model._meta.managed or f.rel.to._meta.managed:
153
151
 
154
152
    def sql_for_many_to_many_field(self, model, f, style):
155
153
        "Return the CREATE TABLE statements for a single m2m field"
 
154
        import warnings
 
155
        warnings.warn(
 
156
            'Database creation API for m2m tables has been deprecated. M2M models are now automatically generated',
 
157
            PendingDeprecationWarning
 
158
        )
 
159
 
156
160
        from django.db import models
157
161
        from django.db.backends.util import truncate_name
158
162
 
159
163
        output = []
160
 
        if f.creates_table:
 
164
        if f.auto_created:
161
165
            opts = model._meta
162
166
            qn = self.connection.ops.quote_name
163
167
            tablespace = f.db_tablespace or opts.db_tablespace
173
177
                style.SQL_TABLE(qn(f.m2m_db_table())) + ' (']
174
178
            table_output.append('    %s %s %s%s,' %
175
179
                (style.SQL_FIELD(qn('id')),
176
 
                style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type()),
 
180
                style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type(connection=self.connection)),
177
181
                style.SQL_KEYWORD('NOT NULL PRIMARY KEY'),
178
182
                tablespace_sql))
179
183
 
210
214
 
211
215
    def sql_for_inline_many_to_many_references(self, model, field, style):
212
216
        "Create the references to other tables required by a many-to-many table"
 
217
        import warnings
 
218
        warnings.warn(
 
219
            'Database creation API for m2m tables has been deprecated. M2M models are now automatically generated',
 
220
            PendingDeprecationWarning
 
221
        )
 
222
 
213
223
        from django.db import models
214
224
        opts = model._meta
215
225
        qn = self.connection.ops.quote_name
217
227
        table_output = [
218
228
            '    %s %s %s %s (%s)%s,' %
219
229
                (style.SQL_FIELD(qn(field.m2m_column_name())),
220
 
                style.SQL_COLTYPE(models.ForeignKey(model).db_type()),
 
230
                style.SQL_COLTYPE(models.ForeignKey(model).db_type(connection=self.connection)),
221
231
                style.SQL_KEYWORD('NOT NULL REFERENCES'),
222
232
                style.SQL_TABLE(qn(opts.db_table)),
223
233
                style.SQL_FIELD(qn(opts.pk.column)),
224
234
                self.connection.ops.deferrable_sql()),
225
235
            '    %s %s %s %s (%s)%s,' %
226
236
                (style.SQL_FIELD(qn(field.m2m_reverse_name())),
227
 
                style.SQL_COLTYPE(models.ForeignKey(field.rel.to).db_type()),
 
237
                style.SQL_COLTYPE(models.ForeignKey(field.rel.to).db_type(connection=self.connection)),
228
238
                style.SQL_KEYWORD('NOT NULL REFERENCES'),
229
239
                style.SQL_TABLE(qn(field.rel.to._meta.db_table)),
230
240
                style.SQL_FIELD(qn(field.rel.to._meta.pk.column)),
245
255
 
246
256
    def sql_indexes_for_field(self, model, f, style):
247
257
        "Return the CREATE INDEX SQL statements for a single model field"
 
258
        from django.db.backends.util import truncate_name
 
259
 
248
260
        if f.db_index and not f.unique:
249
261
            qn = self.connection.ops.quote_name
250
262
            tablespace = f.db_tablespace or model._meta.db_tablespace
256
268
                    tablespace_sql = ''
257
269
            else:
258
270
                tablespace_sql = ''
 
271
            i_name = '%s_%s' % (model._meta.db_table, self._digest(f.column))
259
272
            output = [style.SQL_KEYWORD('CREATE INDEX') + ' ' +
260
 
                style.SQL_TABLE(qn('%s_%s' % (model._meta.db_table, f.column))) + ' ' +
 
273
                style.SQL_TABLE(qn(truncate_name(i_name, self.connection.ops.max_name_length()))) + ' ' +
261
274
                style.SQL_KEYWORD('ON') + ' ' +
262
275
                style.SQL_TABLE(qn(model._meta.db_table)) + ' ' +
263
276
                "(%s)" % style.SQL_FIELD(qn(f.column)) +
300
313
                (style.SQL_KEYWORD('ALTER TABLE'),
301
314
                style.SQL_TABLE(qn(table)),
302
315
                style.SQL_KEYWORD(self.connection.ops.drop_foreignkey_sql()),
303
 
                style.SQL_FIELD(truncate_name(r_name, self.connection.ops.max_name_length()))))
 
316
                style.SQL_FIELD(qn(truncate_name(r_name, self.connection.ops.max_name_length())))))
304
317
        del references_to_delete[model]
305
318
        return output
306
319
 
307
320
    def sql_destroy_many_to_many(self, model, f, style):
308
321
        "Returns the DROP TABLE statements for a single m2m field"
 
322
        import warnings
 
323
        warnings.warn(
 
324
            'Database creation API for m2m tables has been deprecated. M2M models are now automatically generated',
 
325
            PendingDeprecationWarning
 
326
        )
 
327
 
309
328
        qn = self.connection.ops.quote_name
310
329
        output = []
311
 
        if f.creates_table:
 
330
        if f.auto_created:
312
331
            output.append("%s %s;" % (style.SQL_KEYWORD('DROP TABLE'),
313
332
                style.SQL_TABLE(qn(f.m2m_db_table()))))
314
333
            ds = self.connection.ops.drop_sequence_sql("%s_%s" % (model._meta.db_table, f.column))
322
341
        database already exists. Returns the name of the test database created.
323
342
        """
324
343
        if verbosity >= 1:
325
 
            print "Creating test database..."
 
344
            print "Creating test database '%s'..." % self.connection.alias
326
345
 
327
346
        test_database_name = self._create_test_db(verbosity, autoclobber)
328
347
 
329
348
        self.connection.close()
330
 
        settings.DATABASE_NAME = test_database_name
331
 
        self.connection.settings_dict["DATABASE_NAME"] = test_database_name
 
349
        self.connection.settings_dict["NAME"] = test_database_name
332
350
        can_rollback = self._rollback_works()
333
 
        settings.DATABASE_SUPPORTS_TRANSACTIONS = can_rollback
334
 
        self.connection.settings_dict["DATABASE_SUPPORTS_TRANSACTIONS"] = can_rollback
 
351
        self.connection.settings_dict["SUPPORTS_TRANSACTIONS"] = can_rollback
335
352
 
336
 
        call_command('syncdb', verbosity=verbosity, interactive=False)
 
353
        call_command('syncdb', verbosity=verbosity, interactive=False, database=self.connection.alias)
337
354
 
338
355
        if settings.CACHE_BACKEND.startswith('db://'):
339
356
            from django.core.cache import parse_backend_uri
350
367
        "Internal implementation - creates the test db tables."
351
368
        suffix = self.sql_table_creation_suffix()
352
369
 
353
 
        if settings.TEST_DATABASE_NAME:
354
 
            test_database_name = settings.TEST_DATABASE_NAME
 
370
        if self.connection.settings_dict['TEST_NAME']:
 
371
            test_database_name = self.connection.settings_dict['TEST_NAME']
355
372
        else:
356
 
            test_database_name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME
 
373
            test_database_name = TEST_DATABASE_PREFIX + self.connection.settings_dict['NAME']
357
374
 
358
375
        qn = self.connection.ops.quote_name
359
376
 
403
420
        database already exists. Returns the name of the test database created.
404
421
        """
405
422
        if verbosity >= 1:
406
 
            print "Destroying test database..."
 
423
            print "Destroying test database '%s'..." % self.connection.alias
407
424
        self.connection.close()
408
 
        test_database_name = settings.DATABASE_NAME
409
 
        settings.DATABASE_NAME = old_database_name
410
 
        self.connection.settings_dict["DATABASE_NAME"] = old_database_name
 
425
        test_database_name = self.connection.settings_dict['NAME']
 
426
        self.connection.settings_dict['NAME'] = old_database_name
411
427
 
412
428
        self._destroy_test_db(test_database_name, verbosity)
413
429
 
436
452
    def sql_table_creation_suffix(self):
437
453
        "SQL to append to the end of the test table creation statements"
438
454
        return ''
439