Changeset 3646

Timestamp:

08/22/06 11:16:38 (2 years ago)

Author:

danderson

Message:

implemented schema evolution

Files:

• django/branches/schema-evolution/django/core/management.py (modified) (33 diffs)
• django/branches/schema-evolution/django/db/backends/mysql/base.py (modified) (2 diffs)
• django/branches/schema-evolution/django/db/backends/mysql/introspection.py (modified) (2 diffs)
• django/branches/schema-evolution/django/db/backends/postgresql/base.py (modified) (1 diff)
• django/branches/schema-evolution/django/db/backends/postgresql/introspection.py (modified) (2 diffs)
• django/branches/schema-evolution/django/db/backends/sqlite3/base.py (modified) (1 diff)
• django/branches/schema-evolution/django/db/backends/sqlite3/introspection.py (modified) (2 diffs)
• django/branches/schema-evolution/django/db/models/fields/__init__.py (modified) (7 diffs)
• django/branches/schema-evolution/django/db/models/options.py (modified) (3 diffs)

django/branches/schema-evolution/django/core/management.py

@@ -46 +46 @@
-    style = dummy()
-
-
-
+, Pocket PC,
+sys.platform == 'Pocket PC' or 
-    disable_termcolors()
-
@@ -79 +79 @@
-    v = '.'.join([str(i) for i in VERSION[:-1]])
-    if VERSION[-1]:
- (%s)' %
+-' +
-    return v
-
@@ -95 +95 @@
-        sys.exit(1)
-
-
-
-
+
+
+
+
+
-    final_output = []
-models_output = set(installed_models
+known_models = set([model for model in _get_installed_models(_get_table_list()) if model not in app_models]
-    pending_references = {}
-
-
-
-
-
+
+
+
-        final_output.extend(output)
-        for refto, refs in references.items():
-
-
-
-
-
+
+
-        # Keep track of the fact that we've created the table for this model.
-models_output.add(klass
+known_models.add(model
-
-    # Create the many-to-many join tables.
-klass
-klass
+model
+model
-
-    # Handle references to tables that are from other apps
@@ -124 +122 @@
-    not_installed_models = set(pending_references.keys())
-    if not_installed_models:
-
-
-
-
+
+
+
+
+
+
+
-
-    return final_output
@@ -133 +134 @@
-get_sql_create.args = APP_ARGS
-
-klass, models_already_seen
+model, known_models
-    """
-    Get the SQL required to create a single model.
@@ -142 +143 @@
-    data_types = get_creation_module().DATA_TYPES
-
-klass
+model
-    final_output = []
-    table_output = []
@@ -164 +165 @@
-                field_output.append(style.SQL_KEYWORD('PRIMARY KEY'))
-            if f.rel:
-models_already_seen
+known_models
-                    field_output.append(style.SQL_KEYWORD('REFERENCES') + ' ' + \
-                        style.SQL_TABLE(backend.quote_name(f.rel.to._meta.db_table)) + ' (' + \
@@ -172 +173 @@
-                    # We haven't yet created the table to which this field
-                    # is related, so save it for later.
-klass
+model
-            table_output.append(' '.join(field_output))
-    if opts.order_with_respect_to:
@@ -190 +191 @@
-    return final_output, pending_references
-
-klass
+model
-    """
-    Get any ALTER TABLE statements to add constraints after the fact.
@@ -199 +200 @@
-    final_output = []
-    if backend.supports_constraints:
-klass
-klass
-klass
+model
+model
+model
-                rel_opts = rel_class._meta
-                r_table = rel_opts.db_table
@@ -207 +208 @@
-                table = opts.db_table
-                col = opts.get_field(f.rel.field_name).column
+                # For MySQL, r_name must be unique in the first 64 characters.
+                # So we are careful with character usage here.
+                r_name = '%s_refs_%s_%x' % (r_col, col, abs(hash((r_table, table))))
-                final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s);' % \
-
-
+
-                    backend.quote_name(r_col), backend.quote_name(table), backend.quote_name(col)))
-klass
+model
-    return final_output
-
-klass
+model
-    from django.db import backend, get_creation_module
-    from django.db.models import GenericRel
-
+
-    data_types = get_creation_module().DATA_TYPES
-
-klass
+model
-    final_output = []
-    for f in opts.many_to_many:
@@ -274 +277 @@
-    references_to_delete = {}
-    app_models = models.get_models(app)
-klass
-klass
+model
+model
-            # The table exists, so it needs to be dropped
-klass
+model
-            for f in opts.fields:
-                if f.rel and f.rel.to not in to_delete:
-klass
-
-klass
-
-klass
-klass
+model
+
+model
+
+model
+model
-            # Drop the table now
-            output.append('%s %s;' % (style.SQL_KEYWORD('DROP TABLE'),
-klass
-klass
-klass
+model
+model
+model
-                    table = rel_class._meta.db_table
-                    col = f.column
-klass
-klass
+model
+model
-                    output.append('%s %s %s %s;' % \
-                        (style.SQL_KEYWORD('ALTER TABLE'),
-                        style.SQL_TABLE(backend.quote_name(table)),
-                        style.SQL_KEYWORD(backend.get_drop_foreignkey_sql()),
-"%s_referencing_%s_%s" % (col, r_table, r_col
-klass
+'%s_refs_%s_%x' % (col, r_col, abs(hash((table, r_table)))
+model
-
-    # Output DROP TABLE statements for many-to-many tables.
-klass
-klass
+model
+model
-        for f in opts.many_to_many:
-            if cursor and f.m2m_db_table() in table_names:
@@ -361 +364 @@
-    app_dir = os.path.normpath(os.path.join(os.path.dirname(app.__file__), 'sql'))
-
-klass
-klass
+model
+model
-
-    return output
@@ -372 +375 @@
-    from django.db import backend, models
-    output = []
-klass
-klass
+model
+model
-            if isinstance(f, models.AutoField):
-                output.append("%s setval('%s', (%s max(%s) %s %s));" % \
-                    (style.SQL_KEYWORD('SELECT'),
-klass
+model
-                    style.SQL_KEYWORD('SELECT'),
-                    style.SQL_FIELD(backend.quote_name(f.column)),
-                    style.SQL_KEYWORD('FROM'),
-klass
+model
-                break # Only one AutoField is allowed per model, so don't bother continuing.
-klass
+model
-            output.append("%s setval('%s', (%s max(%s) %s %s));" % \
-                (style.SQL_KEYWORD('SELECT'),
@@ -400 +403 @@
-    output = []
-
-klass
-klass
+model
+model
-            if f.db_index:
-                unique = f.unique and 'UNIQUE ' or ''
-                output.append(
-                    style.SQL_KEYWORD('CREATE %sINDEX' % unique) + ' ' + \
-klass
+model
-                    style.SQL_KEYWORD('ON') + ' ' + \
-klass
+model
-                    "(%s);" % style.SQL_FIELD(backend.quote_name(f.column))
-                )
@@ -414 +417 @@
-get_sql_indexes.help_doc = "Prints the CREATE INDEX SQL statements for the given model module name(s)."
-get_sql_indexes.args = APP_ARGS
+
+def get_sql_evolution(app):
+    "Returns SQL to update an existing schema to match the existing models."
+    from django.db import get_creation_module, models, backend, get_introspection_module, connection
+    data_types = get_creation_module().DATA_TYPES
+
+    if not data_types:
+        # This must be the "dummy" database backend, which means the user
+        # hasn't set DATABASE_ENGINE.
+        sys.stderr.write(style.ERROR("Error: Django doesn't know which syntax to use for your SQL statements,\n" +
+            "because you haven't specified the DATABASE_ENGINE setting.\n" +
+            "Edit your settings file and change DATABASE_ENGINE to something like 'postgresql' or 'mysql'.\n"))
+        sys.exit(1)
+
+    # First, try validating the models.
+    _check_for_validation_errors()
+
+    final_output = []
+
+    # stolen and trimmed from syncdb so that we know which models are about 
+    # to be created (so we don't check them for updates)
+    table_list = _get_table_list()
+    seen_models = _get_installed_models(table_list)
+    created_models = set()
+    pending_references = {}
+
+    model_list = models.get_models(app)
+    for model in model_list:
+        # Create the model's database table, if it doesn't already exist.
+        if model._meta.db_table in table_list or model._meta.aka in table_list or len(set(model._meta.aka) & set(table_list))>0:
+            continue
+        sql, references = _get_sql_model_create(model, seen_models)
+        seen_models.add(model)
+        created_models.add(model)
+        table_list.append(model._meta.db_table)
+
+    introspection = get_introspection_module()
+    # This should work even if a connecton isn't available
+    try:
+        cursor = connection.cursor()
+    except:
+        cursor = None
+
+    # get the existing models, minus the models we've just created
+    app_models = models.get_models(app)
+    for model in created_models:
+        if model in app_models:
+            app_models.remove(model)
+
+    for klass in app_models:
+        
+        output, new_table_name = get_sql_evolution_check_for_changed_model_name(klass)
+        final_output.extend(output)
+        
+        output = get_sql_evolution_check_for_changed_field_flags(klass, new_table_name)
+        final_output.extend(output)
+    
+        output = get_sql_evolution_check_for_changed_field_name(klass, new_table_name)
+        final_output.extend(output)
+        
+        output = get_sql_evolution_check_for_new_fields(klass, new_table_name)
+        final_output.extend(output)
+        
+        output = get_sql_evolution_check_for_dead_fields(klass, new_table_name)
+        final_output.extend(output)
+        
+    return final_output
+get_sql_evolution.help_doc = "Returns SQL to update an existing schema to match the existing models."
+get_sql_evolution.args = APP_ARGS
+
+def get_sql_evolution_check_for_new_fields(klass, new_table_name):
+    "checks for model fields that are not in the existing data structure"
+    from django.db import backend, get_creation_module, models, get_introspection_module, connection
+    data_types = get_creation_module().DATA_TYPES
+    cursor = connection.cursor()
+    introspection = get_introspection_module()
+    opts = klass._meta
+    output = []
+    db_table = klass._meta.db_table
+    if new_table_name: 
+        db_table = new_table_name
+    for f in opts.fields:
+        existing_fields = introspection.get_columns(cursor,db_table)
+        if f.column not in existing_fields and f.aka not in existing_fields and len(set(f.aka) & set(existing_fields))==0:
+            rel_field = f
+            data_type = f.get_internal_type()
+            col_type = data_types[data_type]
+            if col_type is not None:
+#                field_output = []
+#                field_output.append('ALTER TABLE')
+#                field_output.append(db_table)
+#                field_output.append('ADD COLUMN')
+#                field_output.append(backend.quote_name(f.column))
+#                field_output.append(style.SQL_COLTYPE(col_type % rel_field.__dict__))
+#                field_output.append(style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or '')))
+#                if f.unique:
+#                    field_output.append(style.SQL_KEYWORD('UNIQUE'))
+#                if f.primary_key:
+#                    field_output.append(style.SQL_KEYWORD('PRIMARY KEY'))
+#                output.append(' '.join(field_output) + ';')
+                output.append( backend.get_add_column_sql( db_table, f.column, style.SQL_COLTYPE(col_type % rel_field.__dict__), f.null, f.unique, f.primary_key ) )
+    return output
+
+def get_sql_evolution_check_for_changed_model_name(klass):
+    from django.db import backend, get_creation_module, models, get_introspection_module, connection
+    cursor = connection.cursor()
+    introspection = get_introspection_module()
+    table_list = introspection.get_table_list(cursor)
+    if klass._meta.db_table in table_list:
+        return [], None
+    if klass._meta.aka in table_list:
+        return [ 'ALTER TABLE '+ backend.quote_name(klass._meta.aka) +' RENAME TO '+ backend.quote_name(klass._meta.db_table) + ';' ], klass._meta.aka
+    elif len(set(klass._meta.aka) & set(table_list))==1:
+        return [ 'ALTER TABLE '+ backend.quote_name(klass._meta.aka[0]) +' RENAME TO '+ backend.quote_name(klass._meta.db_table) + ';' ], klass._meta.aka[0]
+    else:
+        return [], None
+    
+def get_sql_evolution_check_for_changed_field_name(klass, new_table_name):
+    from django.db import backend, get_creation_module, models, get_introspection_module, connection
+    data_types = get_creation_module().DATA_TYPES
+    cursor = connection.cursor()
+    introspection = get_introspection_module()
+    opts = klass._meta
+    output = []
+    db_table = klass._meta.db_table
+    if new_table_name: 
+        db_table = new_table_name
+    for f in opts.fields:
+        existing_fields = introspection.get_columns(cursor,db_table)
+        if f.column not in existing_fields and (f.aka in existing_fields or len(set(f.aka) & set(existing_fields)))==1:
+            old_col = None
+            if isinstance( f.aka, str ):
+                old_col = f.aka
+            else:
+                old_col = f.aka[0]
+            rel_field = f
+            data_type = f.get_internal_type()
+            col_type = data_types[data_type]
+            if col_type is not None:
+                field_output = []
+                col_def = style.SQL_COLTYPE(col_type % rel_field.__dict__) +' '+ style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or ''))
+                if f.unique:
+                    col_def += style.SQL_KEYWORD(' UNIQUE')
+                if f.primary_key:
+                    col_def += style.SQL_KEYWORD(' PRIMARY KEY')
+                field_output.append( backend.get_change_column_name_sql( klass._meta.db_table, introspection.get_indexes(cursor,db_table), backend.quote_name(old_col), backend.quote_name(f.column), col_def ) )
+                output.append(' '.join(field_output))
+    return output
+    
+def get_sql_evolution_check_for_changed_field_flags(klass, new_table_name):
+    from django.db import backend, get_creation_module, models, get_introspection_module, connection
+    from django.db.models.fields import CharField, SlugField
+    from django.db.models.fields.related import RelatedField, ForeignKey
+    data_types = get_creation_module().DATA_TYPES
+    cursor = connection.cursor()
+    introspection = get_introspection_module()
+    opts = klass._meta
+    output = []
+    db_table = klass._meta.db_table
+    if new_table_name: 
+        db_table = new_table_name
+    for f in opts.fields:
+        existing_fields = introspection.get_columns(cursor,db_table)
+        cf = None # current field, ie what it is before any renames
+        if f.column in existing_fields:
+            cf = f.column
+        elif f.aka in existing_fields:
+            cf = f.aka
+        elif len(set(f.aka) & set(existing_fields))==1:
+            cf = f.aka[0]
+        else:
+            continue # no idea what column you're talking about - should be handled by get_sql_evolution_check_for_new_fields())
+        data_type = f.get_internal_type()
+        if data_types.has_key(data_type):
+            column_flags = introspection.get_known_column_flags(cursor, db_table, cf)
+            if column_flags['allow_null']!=f.null or \
+                    ( not f.primary_key and isinstance(f, CharField) and column_flags['maxlength']!=str(f.maxlength) ) or \
+                    ( not f.primary_key and isinstance(f, SlugField) and column_flags['maxlength']!=str(f.maxlength) ) or \
+                    column_flags['unique']!=f.unique or \
+                    column_flags['primary_key']!=f.primary_key:
+                    #column_flags['foreign_key']!=f.foreign_key:
+#                print 
+#                print db_table, f.column, column_flags
+#                print "column_flags['allow_null']!=f.null", column_flags['allow_null']!=f.null
+#                print "not f.primary_key and isinstance(f, CharField) and column_flags['maxlength']!=str(f.maxlength)", not f.primary_key and isinstance(f, CharField) and column_flags['maxlength']!=str(f.maxlength)
+#                print "not f.primary_key and isinstance(f, SlugField) and column_flags['maxlength']!=str(f.maxlength)", not f.primary_key and isinstance(f, SlugField) and column_flags['maxlength']!=str(f.maxlength)
+#                print "column_flags['unique']!=f.unique", column_flags['unique']!=f.unique
+#                print "column_flags['primary_key']!=f.primary_key", column_flags['primary_key']!=f.primary_key
+                col_type = data_types[data_type]
+                col_type_def = style.SQL_COLTYPE(col_type % f.__dict__)
+#                col_def = style.SQL_COLTYPE(col_type % f.__dict__) +' '+ style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or ''))
+#                if f.unique:
+#                    col_def += ' '+ style.SQL_KEYWORD('UNIQUE')
+#                if f.primary_key:
+#                    col_def += ' '+ style.SQL_KEYWORD('PRIMARY KEY')
+                output.append( backend.get_change_column_def_sql( db_table, cf, col_type_def, f.null, f.unique, f.primary_key ) )
+                    #print db_table, cf, f.maxlength, introspection.get_known_column_flags(cursor, db_table, cf)
+    return output
+
+def get_sql_evolution_check_for_dead_fields(klass, new_table_name):
+    from django.db import backend, get_creation_module, models, get_introspection_module, connection
+    from django.db.models.fields import CharField, SlugField
+    from django.db.models.fields.related import RelatedField, ForeignKey
+    data_types = get_creation_module().DATA_TYPES
+    cursor = connection.cursor()
+    introspection = get_introspection_module()
+    opts = klass._meta
+    output = []
+    db_table = klass._meta.db_table
+    if new_table_name: 
+        db_table = new_table_name
+    suspect_fields = set(introspection.get_columns(cursor,db_table))
+    for f in opts.fields:
+        suspect_fields.discard(f.column)
+        suspect_fields.discard(f.aka)
+        suspect_fields.difference_update(f.aka)
+    if len(suspect_fields)>0:
+        output.append( '-- warning: as the following may cause data loss, it/they must be run manually' )
+    for suspect_field in suspect_fields:
+        output.append( backend.get_drop_column_sql( db_table, suspect_field ) )
+        output.append( '-- end warning' )
+    return output
-
-def get_sql_all(app):
@@ -458 +683 @@
-        for model in model_list:
-            # Create the model's database table, if it doesn't already exist.
-
+ or model._meta.aka in table_list or len(set(model._meta.aka) & set(table_list))>0
-                continue
-            sql, references = _get_sql_model_create(model, seen_models)
@@ -482 +707 @@
-                        cursor.execute(statement)
-
+        for sql in get_sql_evolution(app):
+            print sql
+#            cursor.execute(sql)
+
-        transaction.commit_unless_managed()
-
+
-    # Send the post_syncdb signal, so individual apps can do whatever they need
-    # to do at this point.
@@ -518 +747 @@
-    output.append('{%% if perms.%s %%}' % app_label)
-    output.append('<div class="module"><h2>%s</h2><table>' % app_label.title())
-klass
-klass
+model
+model
-            output.append(MODULE_TEMPLATE % {
-                'app': app_label,
-klass
-klass
-klass
-klass
+model
+model
+model
+model
-            })
-    output.append('</table></div>')
@@ -593 +822 @@
-    "Executes the equivalent of 'get_sql_reset' in the current database."
-    from django.db import connection, transaction
-    from cStringIO import StringIO
-    app_name = app.__name__.split('.')[-2]
-
@@ -693 +921 @@
-    "Generator that introspects the tables in the given database name and returns a Django model, one line at a time."
-    from django.db import connection, get_introspection_module
-    from django.conf import settings
-    import keyword
-
-    introspection_module = get_introspection_module()
-
-
-
-
+
-
-    cursor = connection.cursor()
@@ -729 +954 @@
-            extra_params = {}  # Holds Field parameters such as 'db_column'.
-
+            if ' ' in att_name:
+                extra_params['db_column'] = att_name
+                att_name = att_name.replace(' ', '')
+                comment_notes.append('Field renamed to remove spaces.')
-            if keyword.iskeyword(att_name):
-                extra_params['db_column'] = att_name
@@ -819 +1048 @@
-
-    e = ModelErrorCollection(outfile)
-
+
-    for (app_name, error) in get_app_errors().items():
-        e.add(app_name, error)
-
+
-    for cls in models.get_models(app):
-        opts = cls._meta
@@ -887 +1116 @@
-                            e.add(opts, "Reverse query name for field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'." % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
-
-
+
-        for i, f in enumerate(opts.many_to_many):
-            # Check to see if the related m2m field will clash with any
@@ -959 +1188 @@
-                        except models.FieldDoesNotExist:
-                            e.add(opts, '"admin.list_filter" refers to %r, which isn\'t a field.' % fn)
+                # date_hierarchy
+                if opts.admin.date_hierarchy:
+                    try:
+                        f = opts.get_field(opts.admin.date_hierarchy)
+                    except models.FieldDoesNotExist:
+                        e.add(opts, '"admin.date_hierarchy" refers to %r, which isn\'t a field.' % opts.admin.date_hierarchy)
-
-        # Check ordering attribute.
@@ -1025 +1260 @@
-        sys.exit(1)
-
-
+, use_reloader=True
-    "Starts a lightweight Web server for development."
-    from django.core.servers.basehttp import run, AdminMediaHandler, WSGIServerException
@@ -1059 +1294 @@
-        except KeyboardInterrupt:
-            sys.exit(0)
-
-
-
+
+
+
+
+
+
-
-def createcachetable(tablename):
@@ -1131 +1369 @@
-
-def runfcgi(args):
-
+
+
+
+
+
+
+
+
-    from django.core.servers.fastcgi import runfastcgi
-    runfastcgi(args)
@@ -1156 +1401 @@
-    'sqlreset': get_sql_reset,
-    'sqlsequencereset': get_sql_sequence_reset,
+    'sqlevolve': get_sql_evolution,
-    'startapp': startapp,
-    'startproject': startproject,
@@ -1210 +1456 @@
-    parser.add_option('--plain', action='store_true', dest='plain',
-        help='Tells Django to use plain Python, not IPython, for "shell" command.')
+    parser.add_option('--noreload', action='store_false', dest='use_reloader', default=True,
+        help='Tells Django to NOT use the auto-reloader when running the development server.')
-    options, args = parser.parse_args(argv[1:])
-
@@ -1265 +1513 @@
-            except ValueError:
-                addr, port = '', args[1]
-
+, options.use_reloader
-    elif action == 'runfcgi':
-        action_mapping[action](args[1:])
@@ -1286 +1534 @@
-            print style.SQL_KEYWORD("COMMIT;")
-
-
+
+
+
+
+
-    # Add this project to sys.path so that it's importable in the conventional
-    # way. For example, if this file (manage.py) lives in a directory
@@ -1298 +1550 @@
-    # Set DJANGO_SETTINGS_MODULE appropriately.
-    os.environ['DJANGO_SETTINGS_MODULE'] = '%s.settings' % project_name
-
+
+
+
+
-    action_mapping = DEFAULT_ACTION_MAPPING.copy()
-

django/branches/schema-evolution/django/db/backends/mysql/base.py

@@ -41 +41 @@
-        try:
-            return self.cursor.executemany(sql, param_list)
-
+, w
-            self.cursor.execute("SHOW WARNINGS")
-            raise Database.Warning, "%s: %s" % (w, self.cursor.fetchall())
@@ -162 +162 @@
-    return "DEFAULT"
-
+def get_change_column_name_sql( table_name, indexes, old_col_name, new_col_name, col_def ):
+    # mysql doesn't support column renames (AFAIK), so we fake it
+    # TODO: only supports a single primary key so far
+    pk_name = None
+    for key in indexes.keys():
+        if indexes[key]['primary_key']: pk_name = key
+    output = []
+    output.append( 'ALTER TABLE '+ quote_name(table_name) +' CHANGE COLUMN '+ quote_name(old_col_name) +' '+ quote_name(new_col_name) +' '+ col_def + ';' )
+    return '\n'.join(output)
+
+def get_change_column_def_sql( table_name, col_name, col_type, null, unique, primary_key ):
+    output = []
+    col_def = col_type +' '+ ('%sNULL' % (not null and 'NOT ' or ''))
+    if unique:
+        col_def += ' '+ 'UNIQUE'
+    if primary_key:
+        col_def += ' '+ 'PRIMARY KEY'
+    output.append( 'ALTER TABLE '+ quote_name(table_name) +' MODIFY COLUMN '+ quote_name(col_name) +' '+ col_def + ';' )
+    return '\n'.join(output)
+
+def get_add_column_sql( table_name, col_name, col_type, null, unique, primary_key  ):
+    output = []
+    field_output = []
+    field_output.append('ALTER TABLE')
+    field_output.append(quote_name(table_name))
+    field_output.append('ADD COLUMN')
+    field_output.append(quote_name(col_name))
+    field_output.append(col_type)
+    field_output.append(('%sNULL' % (not null and 'NOT ' or '')))
+    if unique:
+        field_output.append(('UNIQUE'))
+    if primary_key:
+        field_output.append(('PRIMARY KEY'))
+    output.append(' '.join(field_output) + ';')
+    return '\n'.join(output)
+
+def get_drop_column_sql( table_name, col_name ):
+    output = []
+    output.append( '-- ALTER TABLE '+ quote_name(table_name) +' DROP COLUMN '+ quote_name(col_name) + ';' )
+    return '\n'.join(output)
+    
+    
-OPERATOR_MAPPING = {
-    'exact': '= %s',

django/branches/schema-evolution/django/db/backends/mysql/introspection.py

@@ -1 @@
-from django.db import transaction
-from django.db.backends.mysql.base import quote_name
-from MySQLdb import ProgrammingError, OperationalError
@@ -74 +73 @@
-    return indexes
-
+def get_columns(cursor, table_name):
+    try:
+        cursor.execute("describe %s" % quote_name(table_name))
+        return [row[0] for row in cursor.fetchall()]
+    except:
+        return []
+    
+def get_known_column_flags( cursor, table_name, column_name ):
+    cursor.execute("describe %s" % quote_name(table_name))
+    dict = {}
+    for row in cursor.fetchall():
+        if row[0] == column_name:
+
+            # maxlength check goes here
+            if row[1][0:7]=='varchar':
+                dict['maxlength'] = row[1][8:len(row[1])-1]
+            
+            # default flag check goes here
+            if row[2]=='YES': dict['allow_null'] = True
+            else: dict['allow_null'] = False
+            
+            # primary/foreign/unique key flag check goes here
+            if row[3]=='PRI': dict['primary_key'] = True
+            else: dict['primary_key'] = False
+            if row[3]=='FOR': dict['foreign_key'] = True
+            else: dict['foreign_key'] = False
+            if row[3]=='UNI': dict['unique'] = True
+            else: dict['unique'] = False
+            
+            # default value check goes here
+            # if row[4]=='NULL': dict['default'] = None
+            # else: dict['default'] = row[4]
+            dict['default'] = row[4]
+            
+    # print table_name, column_name, dict
+    return dict
+    
-DATA_TYPES_REVERSE = {
-    FIELD_TYPE.BLOB: 'TextField',

django/branches/schema-evolution/django/db/backends/postgresql/base.py

@@ -112 +112 @@
-    return "DEFAULT"
-
+def get_change_column_name_sql( table_name, indexes, old_col_name, new_col_name, col_def ):
+    # TODO: only supports a single primary key so far
+    pk_name = None
+    for key in indexes.keys():
+        if indexes[key]['primary_key']: pk_name = key
+    output = []
+    output.append( 'ALTER TABLE '+ quote_name(table_name) +' RENAME COLUMN '+ quote_name(old_col_name) +' TO '+ quote_name(new_col_name) +';' )
+    return '\n'.join(output)
+
+def get_change_column_def_sql( table_name, col_name, col_type, null, unique, primary_key ):
+    output = []
+    output.append( 'ALTER TABLE '+ quote_name(table_name) +' ADD COLUMN '+ quote_name(col_name+'_tmp') +' '+ col_type + ';' )
+    output.append( 'UPDATE '+ quote_name(table_name) +' SET '+ quote_name(col_name+'_tmp') +' = '+ quote_name(col_name) + ';' )
+    output.append( 'ALTER TABLE '+ quote_name(table_name) +' DROP COLUMN '+ quote_name(col_name) +';' )
+    output.append( 'ALTER TABLE '+ quote_name(table_name) +' RENAME COLUMN '+ quote_name(col_name+'_tmp') +' TO '+ quote_name(col_name) + ';' )
+    if not null:
+        output.append( 'ALTER TABLE '+ quote_name(table_name) +' ALTER COLUMN '+ quote_name(col_name) +' SET NOT NULL;' )
+    if unique:
+        output.append( 'ALTER TABLE '+ quote_name(table_name) +' ADD CONSTRAINT '+ table_name +'_'+ col_name +'_unique_constraint UNIQUE('+ col_name +');' )
+    
+    return '\n'.join(output)
+
+def get_add_column_sql( table_name, col_name, col_type, null, unique, primary_key  ):
+    output = []
+    output.append( 'ALTER TABLE '+ quote_name(table_name) +' ADD COLUMN '+ quote_name(col_name) +' '+ col_type + ';' )
+    if not null:
+        output.append( 'ALTER TABLE '+ quote_name(table_name) +' ALTER COLUMN '+ quote_name(col_name) +' SET NOT NULL;' )
+    if unique:
+        output.append( 'ALTER TABLE '+ quote_name(table_name) +' ADD CONSTRAINT '+ table_name +'_'+ col_name +'_unique_constraint UNIQUE('+ col_name +');' )
+    return '\n'.join(output)
+    
+def get_drop_column_sql( table_name, col_name ):
+    output = []
+    output.append( '-- ALTER TABLE '+ quote_name(table_name) +' DROP COLUMN '+ quote_name(col_name) + ';' )
+    return '\n'.join(output)
+
-# Register these custom typecasts, because Django expects dates/times to be
-# in Python's native (standard-library) datetime/time format, whereas psycopg

django/branches/schema-evolution/django/db/backends/postgresql/introspection.py

@@ -1 @@
-from django.db import transaction
-from django.db.backends.postgresql.base import quote_name
-
@@ -68 +67 @@
-    return indexes
-
+def get_columns(cursor, table_name):
+    try:
+        cursor.execute("SELECT a.attname, pg_catalog.format_type(a.atttypid, a.atttypmod), (SELECT substring(d.adsrc for 128) FROM pg_catalog.pg_attrdef d WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef), a.attnotnull, a.attnum, pg_catalog.col_description(a.attrelid, a.attnum) FROM pg_catalog.pg_attribute a WHERE a.attrelid = (SELECT c.oid from pg_catalog.pg_class c where c.relname ~ '^%s$') AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum" % table_name)
+        return [row[0] for row in cursor.fetchall()]
+    except:
+        return []
+    
+def get_known_column_flags( cursor, table_name, column_name ):