Ticket #1261: firebird-port-svn-trunk-6186-not-completed.diff

django/db/models/query.py

@@ -184 +184 @@
         # self._select is a dictionary, and dictionaries' key order is
         # undefined, so we convert it to a list of tuples.
         extra_select = self._select.items()
+        pre_columns = ""
+        # this is perhaps solvable by custom query set
+        if settings.DATABASE_ENGINE == 'firebird' and self._limit is not None:
+            pre_columns += "FIRST %s " % self._limit
+            if self._offset:
+                pre_columns += "SKIP %s " % self._offset
+        if self._distinct:
+            pre_columns += "DISTINCT "
+        cursor = connection.cursor()
+        cursor.execute("SELECT " + pre_columns + ",".join(select) + sql, params)
 
         cursor = connection.cursor()
         cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params)
@@ -515 +525 @@
 
         # Compose the join dictionary into SQL describing the joins.
         if joins:
-            sql.append(" ".join(["%s %s AS %s ON %s" % (join_type, table, alias, condition)
+            sql.append(" ".join(["%s %s %s ON %s" % (join_type, table, alias, condition)
                             for (alias, (table, join_type, condition)) in joins.items()]))
 
         # Compose the tables clause into SQL.

django/db/backends/oracle/base.py

@@ -83 +83 @@
         cursor.execute('SELECT %s_sq.currval FROM dual' % sq_name)
         return cursor.fetchone()[0]
 
-    def limit_offset_sql(self, limit, offset=None):
-        # Limits and offset are too complicated to be handled here.
-        # Instead, they are handled in django/db/backends/oracle/query.py.
-        return ""
+#    def limit_offset_sql(self, limit, offset=None):
+#        # Limits and offset are too complicated to be handled here.
+#        # Instead, they are handled in django/db/backends/oracle/query.py.
+#        return ""
 
     def max_name_length(self):
         return 30

django/db/backends/oracle/creation.py

@@ -36 +36 @@
 PASSWORD = 'Im_a_lumberjack'
 REMEMBER = {}
 
-def create_test_db(settings, connection, verbosity=1, autoclobber=False):
+def create_test_db(settings, connection, backend, verbosity=1, autoclobber=False):
     TEST_DATABASE_NAME = _test_database_name(settings)
     TEST_DATABASE_USER = _test_database_user(settings)
     TEST_DATABASE_PASSWD = _test_database_passwd(settings)

django/db/backends/firebird/base.py

@@ +1 @@
+"""
+Firebird database backend for Django.
+
+Requires kinterbasdb: http://kinterbasdb.sourceforge.net/
+"""
+
+from django.conf import settings
+from django.db.backends import BaseDatabaseWrapper, BaseDatabaseFeatures, BaseDatabaseOperations, util
+
+import re
+try:
+    import kinterbasdb as Database
+    import kinterbasdb.typeconv_datetime_stdlib as typeconv_datetime
+except ImportError, e:
+    from django.core.exceptions import ImproperlyConfigured
+    raise ImproperlyConfigured, "Error loading kinterbasdb module: %s" % e
+
+DatabaseError = Database.DatabaseError
+IntegrityError = Database.IntegrityError
+Database.init(type_conv=200)
+Database.typeconv_text_unicode.DB_TO_PYTHON_ENCODING_MAP[127] = 'utf_8'
+
+try:
+    # Only exists in Python 2.4+
+    from threading import local
+except ImportError:
+    # Import copy of _thread_local.py from Python 2.4
+    from django.utils._threading_local import local
+
+server_version = None
+
+def unicode_conv_in(unicodeString):
+    if isinstance(unicodeString, unicode):
+        return unicodeString.encode(settings.DEFAULT_CHARSET)
+    return unicodeString
+
+#def unicode_conv_out(text):
+#    if isinstance(text, str):
+#        return text.decode(settings.DEFAULT_CHARSET)
+#    return text
+
+def timestamp_conv_in(datetime):
+    #Type converter for datetime casted strings.
+    #Replaces 6 digits microseconds to 4 digits allowed in Firebird
+    if isinstance(datetime, basestring) and datetime.find('.') > 0 and len(datetime) == 26:
+        datetime = datetime[0:-2]
+    return typeconv_datetime.timestamp_conv_in(datetime)
+
+class DatabaseFeatures(BaseDatabaseFeatures):
+    needs_upper_for_iops = True
+    autoindexes_primary_keys = False
+    
+class DatabaseOperations(BaseDatabaseOperations):
+
+    def autoinc_sql(self, table_name, column_name):
+        """To simulate auto-incrementing primary keys in Firebird, we have to
+        create a generator (sequence in Firebird 2) and a trigger.
+    
+        Create the sequences and triggers names based only on table name
+        since django only support one auto field per model"""
+        
+        # style argument disappeared, so we'll just import django's dummy
+        from django.core.management.color import no_style
+        style = no_style()
+        
+        KEYWORD = style.SQL_KEYWORD
+        TABLE = style.SQL_TABLE
+        FIELD = style.SQL_FIELD
+    
+        sequence_name = _quote_sequence_name(table_name)
+        column_name = self.quote_name(column_name)
+        
+        sequence_sql = "%s %s;" % ( \
+                KEYWORD(server_version < '2' and 'CREATE GENERATOR' or 'CREATE SEQUENCE'),
+                TABLE(sequence_name))
+        trigger_sql = "\n".join(["%s %s %s %s" % ( \
+                KEYWORD('CREATE TRIGGER'),
+                TABLE(_quote_trigger_name(table_name)),
+                KEYWORD('FOR'),
+                TABLE(self.quote_name(table_name))),
+            "%s 0 %s" % ( \
+                KEYWORD('ACTIVE BEFORE INSERT POSITION'),
+                KEYWORD('AS')),
+            KEYWORD('BEGIN'),
+            "  %s ((%s.%s %s) %s (%s.%s = 0)) %s" % ( \
+                KEYWORD('IF'),
+                KEYWORD('NEW'),
+                FIELD(column_name),
+                KEYWORD('IS NULL'),
+                KEYWORD('OR'),
+                KEYWORD('NEW'),
+                FIELD(column_name),
+                KEYWORD('THEN')),
+            "  %s" % KEYWORD('BEGIN'),
+            "    %s.%s = %s(%s, 1);" % ( \
+                KEYWORD('NEW'),
+                FIELD(column_name),
+                KEYWORD('GEN_ID'),
+                TABLE(sequence_name)),
+            "  %s" % KEYWORD('END'),
+            KEYWORD('END')])
+        
+        return (sequence_sql, trigger_sql)
+
+    def max_name_length(self):
+        return 30
+
+    def quote_name(self, name):
+        # the standard for firebird is not to quote names but in django
+        # it will quote all names uppercased so we can write sql without quotes
+        # because all names without quotes will defualt to uppercased,
+        # like oracle truncate names bigger than 30 chars
+        if not name.startswith('"') and not name.endswith('"'):
+            name = '"%s"' % util.truncate_name(name, self.max_name_length())
+        return name.upper()
+
+    def last_insert_id(self, cursor, table_name, pk_name):
+#        stmt = server_version < '2' and 'SELECT GEN_ID(%s, 0) FROM RDB$DATABASE' or 'NEXT VALUE FOR %s'
+        stmt = 'SELECT GEN_ID(%s, 0) FROM RDB$DATABASE'
+        cursor.execute(stmt % _quote_sequence_name(table_name))
+        return cursor.fetchone()[0]
+
+    def date_extract_sql(self, lookup_type, column_name):
+        # lookup_type is 'year', 'month', 'day'
+        return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), column_name)
+
+    def date_trunc_sql(self, lookup_type, column_name):
+        if lookup_type == 'year':
+             sql = "EXTRACT(year FROM %s)||'-01-01 00:00:00'" % column_name
+        elif lookup_type == 'month':
+            sql = "EXTRACT(year FROM %s)||'-'||EXTRACT(month FROM %s)||'-01 00:00:00'" % (column_name, column_name)
+        elif lookup_type == 'day':
+            sql = "EXTRACT(year FROM %s)||'-'||EXTRACT(month FROM %s)||'-'||EXTRACT(day FROM %s)||' 00:00:00'" % (column_name, column_name, column_name)
+        return "CAST(%s AS TIMESTAMP)" % sql
+
+    def datetime_cast_sql(self):
+        return None
+
+    def limit_offset_sql(self, limit, offset=None):
+        # limits are handled in models/query.py
+        return ""
+
+    def random_function_sql(self):
+        return "RAND()"
+
+    def deferrable_sql(self):
+        # Not supported, maybe in Firebird 3.0
+        return ""
+
+    def fulltext_search_sql(field_name):
+        # maybe in Firebird 3.0
+        raise NotImplementedError
+
+    def drop_foreignkey_sql(self):
+        return "DROP CONSTRAINT"
+
+    def pk_default_value(self):
+        return "NULL"
+    
+#    def start_transaction_sql(self):
+#        raise NotImplementedError
+#        #return "BEGIN TRANSACTION;"
+
+    def sql_flush(self, style, tables, sequences):
+        """Return a list of SQL statements required to remove all data from
+        all tables in the database (without actually removing the tables
+        themselves) and put the database in an empty 'initial' state
+    
+        For Firebird we gonna take a dangerous workaround:
+            - first (re)create a temporary table 'django_flush$constraints' that
+            will contain all Foreignkey definitions for this database.
+            - next import this definitions into the new table and delete them
+            from system table 'rdb$relation_constraints'.
+            - after the flush is done import the definitions back to the system table
+            and delete the temporary table.
+            - on some systems, there is a problem with dropping django_flush$constraints
+            because of object locking. Thus, we're leaving it in database (as it's used
+            only for tests)
+        """
+        KEYWORD = style.SQL_KEYWORD
+        TABLE = style.SQL_TABLE
+        FIELD = style.SQL_FIELD
+    
+        if tables:
+            temp_table_name = self.quote_name('django_flush$constraints')
+            orig_table_name = 'RDB$RELATION_CONSTRAINTS'
+            sql = ["\n".join([
+                "%s %s (" % (KEYWORD('RECREATE TABLE'), TABLE(temp_table_name)),
+                "  %s %s(31) %s," % (FIELD(self.quote_name('rdb$constraint_name')), KEYWORD('CHAR'), KEYWORD('CHARACTER SET UNICODE_FSS')),
+                "  %s %s(11)," % (FIELD(self.quote_name('rdb$constraint_type')), KEYWORD('CHAR')),
+                "  %s %s(31) %s," % (FIELD(self.quote_name('rdb$relation_name')), KEYWORD('CHAR'), KEYWORD('CHARACTER SET UNICODE_FSS')),
+                "  %s %s(3)," % (FIELD(self.quote_name('rdb$deferrable')), KEYWORD('CHAR')),
+                "  %s %s(3)," % (FIELD(self.quote_name('rdb$initially_deferred')), KEYWORD('CHAR')),
+                "  %s %s(31) %s" % (FIELD(self.quote_name('rdb$index_name')), KEYWORD('CHAR'), KEYWORD('CHARACTER SET UNICODE_FSS')),
+                ");"]),
+                "%s;" % KEYWORD('COMMIT'),
+                "%s %s %s %s %s %s %s %s = 'FOREIGN KEY';" % ( \
+                    KEYWORD('INSERT INTO'), TABLE(temp_table_name),
+                    KEYWORD('SELECT'), FIELD('*'), KEYWORD('FROM'), TABLE(orig_table_name),
+                    KEYWORD('WHERE'), FIELD('rdb$constraint_type')),
+                "%s %s %s %s = 'FOREIGN KEY';" % ( \
+                    KEYWORD('DELETE FROM'), TABLE(orig_table_name),
+                    KEYWORD('WHERE'), FIELD('rdb$constraint_type')),
+                "%s;" % KEYWORD('COMMIT')]
+    
+            sql += ['%s %s;' % \
+                    (KEYWORD('DELETE FROM'),
+                     TABLE(self.quote_name(table))
+                     ) for table in tables]
+    
+            sql += ["%s %s %s 0;" % \
+                    (KEYWORD(server_version < '2' and 'SET GENERATOR' or 'ALTER SEQUENCE'),
+                     TABLE(_quote_sequence_name(sequence['table'])),
+                     KEYWORD(server_version < '2' and 'TO' or 'RESTART WITH')
+                     ) for sequence in sequences]
+            return sql + [
+                "%s %s %s %s %s %s;" % ( \
+                    KEYWORD('INSERT INTO'), TABLE(orig_table_name),
+                    KEYWORD('SELECT'), FIELD('*'), KEYWORD('FROM'), TABLE(temp_table_name)),
+#                "%s %s;" % (KEYWORD('DROP TABLE'), TABLE(temp_table_name)),
+                "%s;" % KEYWORD('COMMIT')]
+        return []
+   
+
+class DatabaseWrapper(local):
+    features = DatabaseFeatures()
+    ops = DatabaseOperations()
+    operators = {
+        'exact': '= %s',
+        'iexact': "= UPPER(%s)",
+        'contains': "LIKE %s ESCAPE '\\'",
+        'icontains': "LIKE UPPER(%s) ESCAPE '\\'",
+        'gt': '> %s',
+        'gte': '>= %s',
+        'lt': '< %s',
+        'lte': '<= %s',
+        'startswith': "LIKE %s ESCAPE '\\'",
+        'endswith': "LIKE %s ESCAPE '\\'",
+        'istartswith': "LIKE UPPER(%s) ESCAPE '\\'",
+        'iendswith': "LIKE UPPER(%s) ESCAPE '\\'",
+    
+        'text_icontains': "CONTAINING %s",
+    }
+
+    def __init__(self, **kwargs):
+        self.connection = None
+        self.queries = []
+        self.options = kwargs
+    
+    def drop_database(self):
+        if self.connection is None:
+            self.connect()
+        self.connection.drop_database()
+        self.connection = None
+    
+    def connect(self):
+        """ Connect to database and store newly created connection in self.connection """
+        if settings.DATABASE_NAME == '':
+            from django.core.exceptions import ImproperlyConfigured
+            raise ImproperlyConfigured, "You need to specify DATABASE_NAME in your Django settings file."
+        kwargs = {'database': settings.DATABASE_NAME}
+        if settings.DATABASE_HOST:
+            kwargs['host'] = settings.DATABASE_HOST
+        if settings.DATABASE_USER:
+            kwargs['user'] = settings.DATABASE_USER
+        if settings.DATABASE_PASSWORD:
+            kwargs['password'] = settings.DATABASE_PASSWORD
+        self.connection = Database.connect(**kwargs)
+        self.connection.set_type_trans_in({
+            'TEXT': unicode_conv_in,
+            'BLOB': unicode_conv_in,
+            'TIMESTAMP': timestamp_conv_in
+        })
+#            self.connection.set_type_trans_out({
+#                'TEXT': unicode_conv_out,
+#            })
+        global server_version
+        if not server_version:
+            import re
+            version_re = re.compile('.*Firebird\s([\d\.]+)')
+            m = version_re.match(self.connection.server_version)
+            if not m:
+                raise Exception('Unable to determine Firebird version from version string %r' % self.connection.server_version)
+            server_version = m.groups()[0]
+        assert self.connection != None
+    
+    def get_connection(self):
+        if not self.connection:
+            self.connect()
+        return self.connection
+    
+    def cursor(self):
+        cursor = FirebirdCursorWrapper(self.get_connection())
+        if settings.DEBUG:
+            return util.CursorDebugWrapper(cursor, self)
+        return cursor
+
+    def _commit(self):
+        if self.connection is not None:
+            return self.connection.commit()
+
+    def _rollback(self):
+        if self.connection is not None:
+            return self.connection.rollback()
+
+    def close(self):
+        if self.connection is not None:
+            self.connection.close()
+            self.connection = None
+
+class FirebirdCursorWrapper(Database.Cursor):
+    """
+    Django uses "format" ('%s') style placeholders, but firebird uses "qmark" ('?') style.
+    This fixes it -- but note that if you want to use a literal "%s" in a query,
+    you'll need to use "%%s".
+    """
+
+    def execute(self, query, params=()):
+        query = self._convert_query(query, len(params))
+#        import logging
+#        logging.fatal("%s %s" % (query, params))
+        return Database.Cursor.execute(self, query, params)
+
+    def executemany(self, query, params):
+        query = self._convert_query(query, len(params[0]))
+        return Database.Cursor.executemany(self, query, params)
+
+    def _convert_query(self, query, num_params):
+        return query % tuple("?" * num_params)
+
+def dictfetchone(cursor):
+    "Returns a row from the cursor as a dict"
+    return cursor.fetchonemap()
+
+def dictfetchmany(cursor, number):
+    "Returns a certain number of rows from a cursor as a dict"
+    return cursor.fetchmanymap(number)
+
+def dictfetchall(cursor):
+    "Returns all rows from a cursor as a dict"
+    return cursor.fetchallmap()
+
+_quote_sequence_name = lambda n: '"%s_SQ"' % util.truncate_name(n.upper(), DatabaseOperations().max_name_length()-3)
+_quote_trigger_name = lambda n: '"%s_TR"' % util.truncate_name(n.upper(), DatabaseOperations().max_name_length()-3)

django/db/backends/firebird/client.py

@@ +1 @@
+from django.conf import settings
+import os
+
+def runshell():
+    args = [settings.DATABASE_NAME]
+    args += ["-u %s" % settings.DATABASE_USER]
+    if settings.DATABASE_PASSWORD:
+        args += ["-p %s" % settings.DATABASE_PASSWORD]
+    if 'FIREBIRD' not in os.environ:
+        path = '/opt/firebird/bin/'
+    os.system(path + 'isql ' + ' '.join(args))

django/db/backends/firebird/introspection.py

@@ +1 @@
+from django.db import transaction
+from django.db.backends.firebird.base import DatabaseOperations
+
+quote_name = DatabaseOperations().quote_name
+
+def get_table_list(cursor):
+    "Returns a list of table names in the current database."
+    cursor.execute("""
+        SELECT rdb$relation_name FROM rdb$relations
+        WHERE rdb$system_flag = 0 AND rdb$view_blr IS NULL ORDER BY rdb$relation_name""")
+    return [str(row[0].strip().lower()) for row in cursor.fetchall()]
+
+def get_table_description(cursor, table_name):
+    "Returns a description of the table, with the DB-API cursor.description interface."
+    #cursor.execute("SELECT FIRST 1 * FROM %s" % quote_name(table_name))
+    #return cursor.description
+    # (name, type_code, display_size, internal_size, precision, scale, null_ok)
+    cursor.execute("""
+        SELECT DISTINCT R.RDB$FIELD_NAME AS FNAME,
+                  F.RDB$FIELD_TYPE AS FTYPE,
+                  F.RDB$FIELD_LENGTH AS FLENGTH,
+                  F.RDB$FIELD_PRECISION AS FPRECISION,
+                  F.RDB$FIELD_SCALE AS FSCALE,
+                  R.RDB$NULL_FLAG AS NULL_FLAG,
+                  R.RDB$FIELD_POSITION
+        FROM RDB$RELATION_FIELDS R
+             JOIN RDB$FIELDS F ON R.RDB$FIELD_SOURCE=F.RDB$FIELD_NAME
+        WHERE F.RDB$SYSTEM_FLAG=0 and R.RDB$RELATION_NAME= %s
+        ORDER BY R.RDB$FIELD_POSITION
+    """, (table_name,))
+    return [(row[0].lower().rstrip(), row[1], row[2], row[2] or 0, row[3], row[4], row[5] and True or False) for row in cursor.fetchall()]
+
+
+def get_relations(cursor, table_name):
+    """
+    Returns a dictionary of {field_index: (field_index_other_table, other_table)}
+    representing all relationships to the given table. Indexes are 0-based.
+    """
+    cursor.execute("""
+        SELECT seg.rdb$field_name, seg_ref.rdb$field_name, idx_ref.rdb$relation_name
+        FROM rdb$indices idx
+        INNER JOIN rdb$index_segments seg
+            ON seg.rdb$index_name = idx.rdb$index_name
+        INNER JOIN rdb$indices idx_ref
+            ON idx_ref.rdb$index_name = idx.rdb$foreign_key
+        INNER JOIN rdb$index_segments seg_ref
+            ON seg_ref.rdb$index_name = idx_ref.rdb$index_name
+        WHERE idx.rdb$relation_name = %s
+            AND idx.rdb$foreign_key IS NOT NULL""", [table_name])
+
+    relations = {}
+    for row in cursor.fetchall():
+        relations[row[0].rstrip()] = (row[1].strip(), row[2].strip())
+    return relations
+
+def get_indexes(cursor, table_name):
+    """
+    Returns a dictionary of fieldname -> infodict for the given table,
+    where each infodict is in the format:
+        {'primary_key': boolean representing whether it's the primary key,
+         'unique': boolean representing whether it's a unique index}
+    """
+
+    # This query retrieves each field name and index type on the given table.
+    cursor.execute("""
+        SELECT seg.rdb$field_name, const.rdb$constraint_type
+        FROM rdb$relation_constraints const
+        LEFT JOIN rdb$index_segments seg
+            ON seg.rdb$index_name = const.rdb$index_name
+        WHERE const.rdb$relation_name = %s
+            AND (const.rdb$constraint_type = 'PRIMARY KEY'
+                OR const.rdb$constraint_type = 'UNIQUE')""", [table_name])
+    indexes = {}
+    for row in cursor.fetchall():
+        indexes[row[0].strip()] = {
+            'primary_key': ('PRIMARY KEY' == row[1].strip()),
+            'unique': ('UNIQUE' == row[1].strip())}
+    return indexes
+
+# Maps type codes to Django Field types.
+# !todo
+DATA_TYPES_REVERSE = {
+    7: 'BooleanField',
+    7: 'SmallIntegerField',
+    8: 'IntegerField',
+    261: 'TextField',
+    37: 'IPAddressField',
+    37: 'CharField',
+    12: 'DateField',
+    13: 'TimeField',
+    35: 'DateTimeField',
+    10: 'FloatField',
+}

django/db/backends/firebird/creation.py

@@ +1 @@
+from django.core import management
+import sys, os, time
+
+from base import server_version
+
+# This dictionary maps Field objects to their associated Firebird column
+# types, as strings. Column-type strings can contain format strings; they'll
+# be interpolated against the values of Field.__dict__ before being output.
+# If a column type is set to None, it won't be included in the output.
+
+DATA_TYPES = {
+    'AutoField':                     'INTEGER',
+    'BooleanField':                  'SMALLINT',
+    'CharField':                     'VARCHAR(%(max_length)s)',
+    'CommaSeparatedIntegerField':    'VARCHAR(%(max_length)s)',
+    'DateField':                     'DATE',
+    'DateTimeField':                 'TIMESTAMP',
+    'DecimalField':                  'DECIMAL(%(max_digits)s, %(decimal_places)s)',
+    'FileField':                     'VARCHAR(100)',
+    'FilePathField':                 'VARCHAR(100)',
+    'FloatField':                    'FLOAT',
+    'ImageField':                    'VARCHAR(100)',
+    'IntegerField':                  'INTEGER',
+    'IPAddressField':                'VARCHAR(15)',
+    'ManyToManyField':               None,
+    'NullBooleanField':              'SMALLINT',
+    'OneToOneField':                 'INTEGER',
+    'PhoneNumberField':              'VARCHAR(20)',
+    'PositiveIntegerField':          'INTEGER',
+    'PositiveSmallIntegerField':     'SMALLINT',
+    'SlugField':                     'VARCHAR(%(max_length)s)',
+    'SmallIntegerField':             'SMALLINT',
+    'TextField':                     'BLOB SUB_TYPE TEXT',
+    'TimeField':                     'TIME',
+    'URLField':                      'VARCHAR(200)',
+    'USStateField':                  'VARCHAR(2)',
+}
+
+TEST_DATABASE_PREFIX = 'test_'
+
+def create_test_db(settings, database, verbosity=1, autoclobber=False):
+
+    if verbosity >= 1:
+        print "Creating test database..."
+
+    if settings.TEST_DATABASE_NAME:
+        if os.path.isfile(settings.DATABASE_NAME):
+            TEST_DATABASE_NAME = os.path.join(
+                os.path.dirname(settings.DATABASE_NAME),
+                settings.TEST_DATABASE_NAME)
+        else:
+            import tempfile
+            tempfile.gettempdir()
+            TEST_DATABASE_NAME = os.path.join(
+                tempfile.gettempdir(),
+                settings.TEST_DATABASE_NAME)
+    else:
+        if os.path.isfile(settings.DATABASE_NAME):
+            TEST_DATABASE_NAME = os.path.join(
+                os.path.dirname(settings.DATABASE_NAME),
+                TEST_DATABASE_PREFIX + os.path.basename(settings.DATABASE_NAME))
+        else:
+            import tempfile
+            tempfile.gettempdir()
+            TEST_DATABASE_NAME = os.path.join(
+                tempfile.gettempdir(),
+                TEST_DATABASE_PREFIX + settings.DATABASE_NAME)
+
+    settings.DATABASE_NAME = TEST_DATABASE_NAME
+
+    try:
+        _create_test_db(database, settings)
+    except Exception, e:
+        sys.stderr.write("Got an error creating the test database: %s\n" % e)
+        if not autoclobber:
+            confirm = raw_input("It appears the test database, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_DATABASE_NAME)
+        if autoclobber or confirm == 'yes':
+            try:
+                if verbosity >= 1:
+                    print "Destroying old test database..."
+                _destroy_test_db(database)
+                if verbosity >= 1:
+                    print "Creating test database..."
+                _create_test_db(database, settings)
+            except Exception, e:
+                sys.stderr.write("Got an error recreating the test database: %s\n" % e)
+                sys.exit(2)
+        else:
+            print "Tests cancelled."
+            sys.exit(1)
+
+    management.call_command('syncdb', verbosity=verbosity, interactive=False)
+
+    # Get a cursor (even though we don't need one yet). This has
+    # the side effect of initializing the test database.
+    cursor = database.cursor()
+
+
+def destroy_test_db(settings, connection, old_database_name, verbosity):
+    if verbosity >= 1:
+        print "Destroying test database..."
+
+    # To avoid "database is being accessed by other users" errors.
+    time.sleep(1)
+    _destroy_test_db(connection)
+
+def _create_test_db(database, settings):
+    import kinterbasdb
+    default_charset = server_version < '2' and 'UNICODE_FSS' or 'UTF8'
+    connection = kinterbasdb.create_database("""
+        CREATE DATABASE '%s' user '%s' password '%s' DEFAULT CHARACTER SET %s""" % \
+        (settings.DATABASE_NAME, settings.DATABASE_USER, settings.DATABASE_PASSWORD, default_charset))
+    cursor = connection.cursor()
+    cursor.execute("""
+    DECLARE EXTERNAL FUNCTION rand
+        RETURNS DOUBLE PRECISION
+        BY VALUE ENTRY_POINT 'IB_UDF_rand' MODULE_NAME 'ib_udf';
+    """)
+    connection.commit()
+    connection.close()
+
+def _destroy_test_db(database):
+    database.drop_database()
+ No newline at end of file

django/core/management/sql.py

@@ -1 +1 @@
 from django.core.management.base import CommandError
+from django.conf import settings 
 import os
 import re
 
@@ -262 +263 @@
         # Make the definition (e.g. 'foo VARCHAR(30)') for this field.
         field_output = [style.SQL_FIELD(qn(f.column)),
             style.SQL_COLTYPE(col_type)]
-        field_output.append(style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or '')))
+        #field_output.append(style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or '')))
+        column_null_sql = '%sNULL' % (not f.null and 'NOT ' or '') 
+        if settings.DATABASE_ENGINE == 'firebird' and f.null: 
+            column_null_sql = (not f.null or f.primary_key) and 'NOT NULL' or '' 
+        if column_null_sql: 
+            field_output.append(style.SQL_KEYWORD(column_null_sql))
+            
         if f.unique and (not f.primary_key or connection.features.allows_unique_and_pk):
             field_output.append(style.SQL_KEYWORD('UNIQUE'))
         if f.primary_key:

tests/modeltests/serializers/models.py

@@ -125 +125 @@
 
 # You can easily create new objects by deserializing data with an empty PK
 # (It's easier to demo this with JSON...)
->>> new_author_json = '[{"pk": null, "model": "serializers.author", "fields": {"name": "Bill"}}]'
+>>> new_author_json = '[{"pk" : null, "model": "serializers.author", "fields": {"name": "Bill"}}]'
 >>> for obj in serializers.deserialize("json", new_author_json):
 ...     obj.save()
 >>> Author.objects.all()

tests/regressiontests/string_lookup/models.py

@@ -91 +91 @@
 <Foo: Foo Bjorn>
 
 # Regression tests for #5087: make sure we can perform queries on TextFields.
+# This is unsupported for Firebird < 2.1
 >>> a = Article(name='Test', text='The quick brown fox jumps over the lazy dog.')
 >>> a.save()
 >>> Article.objects.get(text__exact='The quick brown fox jumps over the lazy dog.')

tests/regressiontests/fixtures_regress/models.py

@@ -36 +36 @@
         
 # Create a new animal. Without a sequence reset, this new object
 # will take a PK of 1 (on Postgres), and the save will fail.
+# Same goes for Firebird
 # This is a regression test for ticket #3790.
 >>> animal = Animal(name='Platypus', latin_name='Ornithorhynchus anatinus')
 >>> animal.save()