Ticket #1261: firebird-6669-update.diff

django/db/models/base.py

@@ -4 +4 @@
-from django.core.exceptions import ObjectDoesNotExist
-from django.db.models.fields import AutoField, ImageField, FieldDoesNotExist
-from django.db.models.fields.related import OneToOneRel, ManyToOneRel
+from django.db.models.fields.computed import ComputedField
-from django.db.models.query import delete_objects
-from django.db.models.options import Options, AdminOptions
-from django.db import connection, transaction
@@ -227 +228 @@
-                self._meta.pk.get_db_prep_lookup('exact', pk_val))
-            # If it does already exist, do an UPDATE.
-            if cursor.fetchone():
-
+ if not isinstance(f, ComputedField)
-                if db_values:
-                    cursor.execute("UPDATE %s SET %s WHERE %s=%%s" % \
-                        (qn(self._meta.db_table),
-
+ if not isinstance(f, ComputedField)
-                        qn(self._meta.pk.column)),
-                        db_values + self._meta.pk.get_db_prep_lookup('exact', pk_val))
-            else:
-                record_exists = False
-        if not pk_set or not record_exists:
-AutoField
-AutoField
+(AutoField, ComputedField)
+(AutoField, ComputedField)
-            # If the PK has been manually set, respect that.
-            if pk_set:
-
+
+
+
+
-                db_values += [f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True)) for f in self._meta.fields if isinstance(f, AutoField)]
-            placeholders = ['%s'] * len(field_names)
-            if self._meta.order_with_respect_to:

django/db/models/manager.py

@@ -77 +77 @@
-    def filter(self, *args, **kwargs):
-        return self.get_query_set().filter(*args, **kwargs)
-
+    def firefilter(self, *args, **kwargs):
+        return self.get_query_set().firefilter(*args, **kwargs)
+    
-    def complex_filter(self, *args, **kwargs):
-        return self.get_query_set().complex_filter(*args, **kwargs)
-

django/db/models/fields/__init__.py

@@ -6 +6 @@
-except ImportError:
-    from django.utils import _decimal as decimal    # for Python 2.3
-
-
+connection, 
-from django.db.models import signals
-from django.dispatch import dispatcher
-from django.conf import settings
@@ -66 +66 @@
-#
-#     getattr(obj, opts.pk.attname)
-
-
+_
-    # Provide backwards compatibility for the maxlength attribute and
-    # argument for this class and all subclasses.
-    __metaclass__ = LegacyMaxlength
@@ -83 +83 @@
-        core=False, rel=None, default=NOT_PROVIDED, editable=True, serialize=True,
-        prepopulate_from=None, unique_for_date=None, unique_for_month=None,
-        unique_for_year=None, validator_list=None, choices=None, radio_admin=None,
-
+
+
-        self.name = name
-        self.verbose_name = verbose_name
-        self.primary_key = primary_key
-        self.max_length, self.unique = max_length, unique
+        self.encoding = encoding
-        self.blank, self.null = blank, null
-        # Oracle treats the empty string ('') as null, so coerce the null
-        # option whenever '' is a possible value.
@@ -105 +107 @@
-        self.help_text = help_text
-        self.db_column = db_column
-        self.db_tablespace = db_tablespace
+        self.on_update = on_update
+        self.on_delete = on_delete
-
-        # Set db_index to True if the field has a relationship and doesn't explicitly set db_index.
-        self.db_index = db_index
@@ -148 +152 @@
-        data_types = get_creation_module().DATA_TYPES
-        internal_type = self.get_internal_type()
-        if internal_type not in data_types:
-
+    
-        return data_types[internal_type] % self.__dict__
-
-    def validate_full(self, field_data, all_data):
@@ -402 +406 @@
-        "Returns the value of this field in the given model instance."
-        return getattr(obj, self.attname)
-
+# Use the backend's Field class if it defines one. Otherwise, use _Field.
+if connection.features.uses_custom_field:
+    Field = connection.ops.field_class(_Field)
+else:
+    Field = _Field
+
-class AutoField(Field):
-    empty_strings_allowed = False
-    def __init__(self, *args, **kwargs):
@@ -688 +698 @@
-        defaults.update(kwargs)
-        return super(DecimalField, self).formfield(**defaults)
-
+class DefaultCharField(CharField):
+    def __init__(self, *args, **kwargs):
+        DEFAULT_MAX_LENGTH = 100
+        if hasattr(settings, 'DEFAULT_MAX_LENGTH'):
+           DEFAULT_MAX_LENGTH = settings.DEFAULT_MAX_LENGT
+        kwargs['max_length'] = kwargs.get('max_length', DEFAULT_MAX_LENGTH)
+        CharField.__init__(self, *args, **kwargs)
+
-class EmailField(CharField):
-    def __init__(self, *args, **kwargs):
-        kwargs['max_length'] = kwargs.get('max_length', 75)
@@ -890 +908 @@
-        defaults.update(kwargs)
-        return super(IPAddressField, self).formfield(**defaults)
-
+class LargeTextField(Field):
+    def get_manipulator_field_objs(self):
+        return [oldforms.LargeTextField]
+
+    def formfield(self, **kwargs):
+        defaults = {'widget': forms.Textarea}
+        defaults.update(kwargs)
+        return super(LargeTextField, self).formfield(**defaults)
+
-class NullBooleanField(Field):
-    empty_strings_allowed = False
-    def __init__(self, *args, **kwargs):
@@ -997 +1024 @@
-            # doesn't support microseconds.
-            if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'):
-                value = value.replace(microsecond=0)
-== 'oracle'
-expects
+in ('oracle', 'firebird')
+and kinterbasdb expect
-                if isinstance(value, datetime.time):
-                    value = datetime.datetime(1900, 1, 1, value.hour, value.minute,
-                                              value.second, value.microsecond)

django/db/models/fields/related.py

@@ -331 +331 @@
-                        new_ids.add(obj)
-                # Add the newly created or already existing objects to the join table.
-                # First find out which items are already added, to avoid adding them twice
+                qn = connection.ops.quote_name
-                cursor = connection.cursor()
-                cursor.execute("SELECT %s FROM %s WHERE %s = %%s AND %s IN (%s)" % \
-target_col_name, self.join_table, source_col_name
-target_col_name
+qn(target_col_name), qn(self.join_table), qn(source_col_name)
+qn(target_col_name)
-                    [self._pk_val] + list(new_ids))
-                existing_ids = set([row[0] for row in cursor.fetchall()])
-
-                # Add the ones that aren't there already
-                for obj_id in (new_ids - existing_ids):
-"INSERT INTO %s (%s, %s) VALUES (%%s, %%s)"
-self.join_table, source_col_name, target_col_name
-[self._pk_val, obj_id]
+'INSERT INTO %s (%s, %s) VALUES (%%s, %%s)'
+qn(self.join_table), qn(source_col_name), qn(target_col_name)
+(self._pk_val, obj_id)
-                transaction.commit_unless_managed()
-
-        def _remove_items(self, source_col_name, target_col_name, *objs):

django/db/models/fields/computed.py

@@ +1 @@
+from django.db.models.fields import CharField, DateField, DateTimeField, DecimalField
+from django.db.models.fields import IntegerField, FloatField, SmallIntegerField, TimeField
+
+class ComputedField(object):
+    def __init__(self, **kwargs):
+        expression = kwargs.pop('expression')
+        if 'params' in kwargs:
+            raw_params = kwargs.pop('params')
+            params = []
+            for rp in raw_params:
+                params.append('"%s"' % rp)
+            self.expression = expression % tuple(params)
+        else:
+            self.expression = expression    
+    def db_type(self):
+        return 'ComputedField'
+
+class ComputedCharField(ComputedField, CharField):
+    def __init__(self, **kwargs):
+        ComputedField.__init__(self, **kwargs)
+        if 'params' in kwargs:
+            del kwargs['params']
+        if 'expression' in kwargs:
+            del kwargs['expression']
+        CharField.__init__(self, **kwargs)
+
+class ComputedDateField(ComputedField, DateField):
+    def __init__(self, **kwargs):
+        ComputedField.__init__(self, **kwargs)
+        if 'params' in kwargs:
+            del kwargs['params']
+        if 'expression' in kwargs:
+            del kwargs['expression']
+        DateField.__init__(self, **kwargs)  
+
+class ComputedDateTimeField(ComputedField, DateTimeField):
+    def __init__(self, **kwargs):
+        ComputedField.__init__(self, **kwargs)
+        if 'params' in kwargs:
+            del kwargs['params']
+        if 'expression' in kwargs:
+            del kwargs['expression'] 
+        DateTimeField.__init__(self, **kwargs) 
+
+class ComputedDecimalField(ComputedField, DecimalField):
+    def __init__(self, **kwargs):
+        ComputedField.__init__(self, **kwargs)
+        if 'params' in kwargs:
+            del kwargs['params']
+        if 'expression' in kwargs:
+            del kwargs['expression']
+        DecimalField.__init__(self, **kwargs)
+        
+class ComputedFloatField(ComputedField, FloatField):
+    def __init__(self, **kwargs):
+        ComputedField.__init__(self, **kwargs)
+        if 'params' in kwargs:
+            del kwargs['params']
+        if 'expression' in kwargs:
+            del kwargs['expression']
+        FloatField.__init__(self, **kwargs)
+
+class ComputedIntegerField(ComputedField, IntegerField):
+    def __init__(self, **kwargs):
+        ComputedField.__init__(self, **kwargs)
+        if 'params' in kwargs:
+            del kwargs['params']
+        if 'expression' in kwargs:
+            del kwargs['expression']
+        IntegerField.__init__(self, **kwargs)
+
+class ComputedSmallIntegerField(ComputedField, SmallIntegerField):
+    def __init__(self, **kwargs):
+        ComputedField.__init__(self, **kwargs)
+        if 'params' in kwargs:
+            del kwargs['params']
+        if 'expression' in kwargs:
+            del kwargs['expression']
+        SmallIntegerField.__init__(self, **kwargs)
+
+class ComputedTimeField(ComputedField, TimeField):
+    def __init__(self, **kwargs):
+        ComputedField.__init__(self, **kwargs)
+        if 'params' in kwargs:
+            del kwargs['params']
+        if 'expression' in kwargs:
+            del kwargs['expression'] 
+        TimeField.__init__(self, **kwargs)    
+

django/db/models/__init__.py

@@ -7 +7 @@
-from django.db.models.manager import Manager
-from django.db.models.base import Model, AdminOptions
-from django.db.models.fields import *
+from django.db.models.procedures import Procedure, Trigger
-from django.db.models.fields.subclassing import SubfieldBase
-from django.db.models.fields.related import ForeignKey, OneToOneField, ManyToManyField, ManyToOneRel, ManyToManyRel, OneToOneRel, TABULAR, STACKED
+from django.db.models.fields.computed import *
-from django.db.models import signals
-from django.utils.functional import curry
-from django.utils.text import capfirst

django/db/models/procedures/__init__.py

@@ +1 @@
+from django.db import connection, transaction
+
+
+class procedure_meta(type):
+    """
+    Metaclass for native stored procedures behaving as normal Django model methods
+    Subclass Procedure inside your model, create procedures tuple
+    and use the class as ordinary method
+    Please treat the resulting classes as methods because they don't
+    behave like classes anymore
+    Look at tests/customtests/custom_methods/model.py for demonstration
+    """
+    def __init__(cls, name, bases, attrs):
+        super(procedure_meta, cls).__init__(name, bases, attrs)
+        params, returns, vars, body = None, None, None, None
+        if '__params__' in attrs:
+            params = attrs['__params__']
+        if '__returns__' in attrs:
+            returns = attrs['__returns__']
+        if '__vars__' in attrs:
+            vars = attrs['__vars__']
+        if name != 'Procedure':
+            assert '__body__' in attrs, "Procedure must have body"   
+            header = ['CREATE OR ALTER PROCEDURE %s ' % name]
+            if params:
+                header.append('(')
+                header.append(', '.join([param + ' ' + paramtype for param, paramtype in params]))
+                header.append(')')
+            if returns:
+                header.append('\nRETURNS (')
+                header.append(', '.join([ret + ' ' + rettype for ret, rettype in returns]))
+                header.append(')')   
+            cls.__sql__ = [''.join(header)]
+            cls.__sql__.append('AS')
+            if vars:
+                var_declare = ['DECLARE VARIABLE ']
+                var_declare.append(', '.join([var + ' ' + vartype for var, vartype in vars]))
+                var_declare.append(';')
+                cls.__sql__.append(''.join(var_declare))
+            cls.__sql__.extend(['BEGIN', attrs['__body__'], 'END'])
+            cls.sql = '\n'.join(cls.__sql__)
+            cls.params = params
+            cls.returns = returns
+            cls.procedure_name = name
+    
+    def create_procedure_sql(cls):
+        return cls.sql
+    
+    def execute(cls, cursor, *args):
+        if args:
+            return cursor.execute_straight('SELECT %s FROM %s(%s);' %\
+                    (', '.join("%s" % ret[0] for ret in cls.returns),
+                     cls.procedure_name,
+                     ', '.join("?" * len(args))), args)
+        else:
+            return cursor.execute_straight('SELECT %s FROM %s;' %\
+                    (', '.join("%s" % ret[0] for ret in cls.returns),
+                     cls.procedure_name))
+
+    def __call__(cls, *args):
+        cursor = connection.cursor()
+        if not cls.returns:
+            cursor.execute('EXECUTE PROCEDURE "%s" %s;' %\
+                (cls.procedure_name,
+                 ' ,'.join("'%s'" % arg for arg in args)))
+        elif len(cls.returns) == 1:
+            # Procedure returns value
+            cursor.callproc(cls.procedure_name, args)
+            return cursor.fetchone()[0]
+        
+        else:
+            cursor.execute_straight('SELECT %s FROM %s(%s);' %\
+                (', '.join("%s" % ret[0] for ret in cls.returns),
+                 cls.procedure_name,
+                 ', '.join("?" * len(args))), args)       
+            return cursor.fetchall()
+
+class trigger_meta(type):
+    """
+    """
+    def __init__(cls, name, bases, attrs):
+        super(trigger_meta, cls).__init__(name, bases, attrs)
+        vars, body, table, mode = None, None, None, None
+        if '__vars__' in attrs:
+            vars = attrs['__vars__']
+        if name != 'Trigger':
+            assert '__body__' in attrs, "Triggers must have some SQL code"
+            assert '__table__' in attrs, "Triggers must have the table"
+            assert '__mode__' in attrs, "Triggers must have a mode, e.g. AFTER INSERT"   
+            header = 'CREATE OR ALTER TRIGGER %s FOR %s\n%s AS' %\
+             (name, connection.ops.quote_name(attrs['__table__']), attrs['__mode__'])
+            cls.__sql__ = [header]
+            if vars:
+                var_declare = ['DECLARE VARIABLE ']
+                var_declare.append(', '.join([var + ' ' + vartype for var, vartype in vars]))
+                var_declare.append(';')
+                cls.__sql__.append(''.join(var_declare))
+            cls.__sql__.extend(['BEGIN', attrs['__body__'], 'END'])
+            cls.sql = '\n'.join(cls.__sql__)
+            cls.trigger_name = name
+    def create_trigger_sql(cls):
+        return cls.sql
+
+class Procedure(object):
+    __metaclass__ = procedure_meta
+
+class Trigger(object):
+    __metaclass__ = trigger_meta
+

django/db/models/procedures/firemethod.py

@@ +1 @@
+# Stored procedures' Django model method wrapper
+#
+# Works only with Python 2.5+
+# For Python < 2.5 use class notation
+#
+#    Example:
+#
+#    @firemethod    
+#    def was_published_today_from_id(self_id='integer'):
+#        """
+#        SELECT "id"
+#        FROM "firemethod_article"
+#        WHERE "pub_date" = 'today' AND "id" = :self_id
+#        INTO :result;
+#        IF (result IS NULL) THEN
+#            result = 0;
+#        ELSE
+#            result = 1;    
+#        EXIT;
+#        """
+#        return ('result', 'integer')
+#   
+#    @firemethod    
+#    def was_published_today_filter():
+#        """
+#        FOR SELECT "id", "headline", "pub_date"
+#        FROM "firemethod_article"
+#        WHERE "pub_date" = 'today'
+#        INTO :other_id, :other_headline, :other_pub_date
+#        DO BEGIN SUSPEND; END
+#        """
+#        # Dummy variable just to show how to declare
+#        declare = ('dummy', 'varchar(200)')
+#        return ('other_id', 'integer'), ('other_headline', 'varchar(100)'), ('other_pub_date', 'date')
+#   
+#   procedures = (was_published_today_filter, was_published_today_from_id)
+#
+#
+# >>> article.was_published_today_from_id(article.pk)
+# 1
+# >>> bool(art.was_published_today_from_id(other_article.pk))
+# False
+# >>>Article.objects.firefilter(self.was_published_today_filter)
+# [<Article: Only for today>, <Article: The life is always in a current moment>]
+
+from functools import *
+from django.db.models import Procedure
+from django.db.models.procedures import procedure_meta
+
+def firemethod(f):
+    @wraps(f)
+    def wrapper():
+        params, returns, vars, ret = None, None, None, f()
+        attrs = {}
+        if f.func_code.co_varnames:
+            all_vars = list(f.func_code.co_varnames)
+            if 'declare' in all_vars:
+                all_tuples = set([ d for d in f.func_code.co_consts if isinstance(d, tuple) ])
+                if isinstance(ret[0], basestring):
+                    ret = [ret]
+                ret_tuples = set(ret)
+                all_vars.remove('declare')
+                vars = []
+                for var, var_type in all_tuples - ret_tuples:
+                    vars.append((var, var_type))
+            if len(all_vars) > 0 and f.func_defaults:
+                params = []
+                for key, value in zip(all_vars, f.func_defaults) :
+                     params.append((key, value))
+        if ret:
+            returns = []
+            if isinstance(ret[0], basestring):
+                    ret = [ret]
+            for var, var_type in ret:
+                returns.append((var, var_type))         
+        if params:
+            attrs['__params__'] = params
+        if returns:
+            attrs['__returns__'] = returns
+        if vars:
+            attrs['__vars__'] = vars
+        attrs['__body__'] = f.__doc__
+        return procedure_meta(f.__name__, (Procedure,), attrs)
+    return wrapper()
+        

django/db/models/query.py

@@ -612 +612 @@
-        columns = [f.column for f in fields]
-        select = ['%s.%s' % (qn(self.model._meta.db_table), qn(c)) for c in columns]
-        if extra_select:
-
+
+
+
+
-            field_names.extend([f[0] for f in extra_select])
-
-        cursor = connection.cursor()
@@ -1111 +1114 @@
-            # Last query term was a normal field.
-            column = field.column
-            db_type = field.db_type()
-
-        where.append(get_where_clause(lookup_type, current_table + '.', column, value, db_type))
-        params.extend(field.get_db_prep_lookup(lookup_type, value))
-
@@ -1146 +1148 @@
-            if isinstance(f, generic.GenericRelation):
-                from django.contrib.contenttypes.models import ContentType
-                query_extra = 'AND %s=%%s' % f.rel.to._meta.get_field(f.content_type_field_name).column
+                if settings.DATABASE_ENGINE == 'firebird':
+                    query_extra = 'AND %s=%%s' % qn(f.rel.to._meta.get_field(f.content_type_field_name).column)
-                args_extra = [ContentType.objects.get_for_model(cls).id]
-            else:
-                query_extra = ''

django/db/backends/__init__.py

@@ -48 +48 @@
-    needs_upper_for_iops = False
-    supports_constraints = True
-    supports_tablespaces = False
+    quote_autofields = False
-    uses_case_insensitive_names = False
+    uses_custom_field = False
-    uses_custom_queryset = False
-
-class BaseDatabaseOperations(object):
@@ -199 +201 @@
-        """
-        raise NotImplementedError()
-
+    def reference_name(self, r_col, col, r_table, table):
+        return '%s_refs_%s_%x' % (r_col, col, abs(hash((r_table, table))))
+
-    def random_function_sql(self):
-        """
-        Returns a SQL expression that returns a random value.

django/db/backends/firebird/base.py

@@ +1 @@
+"""
+Firebird database backend for Django.
+
+Requires KInterbasDB 3.2: http://kinterbasdb.sourceforge.net/
+The egenix mx (mx.DateTime) is NOT required
+
+Database charset should be UNICODE_FSS or UTF8 (FireBird 2.0+)
+To use UTF8 encoding add FIREBIRD_CHARSET = 'UTF8' to your settings.py 
+UNICODE_FSS works with all versions and uses less memory
+"""
+
+from django.db.backends import BaseDatabaseWrapper, BaseDatabaseFeatures, BaseDatabaseOperations, util
+import sys
+try:
+    import decimal
+except ImportError:
+    from django.utils import _decimal as decimal    # for Python 2.3
+
+try:
+    import kinterbasdb as Database
+except ImportError, e:
+    from django.core.exceptions import ImproperlyConfigured
+    raise ImproperlyConfigured, "Error loading KInterbasDB module: %s" % e
+
+DatabaseError = Database.DatabaseError
+IntegrityError = Database.IntegrityError
+
+class DatabaseFeatures(BaseDatabaseFeatures):
+    inline_fk_references = False 
+    needs_datetime_string_cast = False
+    needs_upper_for_iops = True
+    quote_autofields = True
+    uses_custom_field = True
+    uses_custom_queryset = True
+
+################################################################################
+# Database operations (db.connection.ops)  
+class DatabaseOperations(BaseDatabaseOperations):
+    """
+    This class encapsulates all backend-specific differences, such as the way
+    a backend performs ordering or calculates the ID of a recently-inserted
+    row.
+    """
+    # Utility ops: names, version, page size etc.: 
+    _max_name_length = 31
+    def __init__(self):
+        self._firebird_version = None
+        self._page_size = None
+    
+    def get_generator_name(self, name):
+        return '%s$G' % util.truncate_name(name.strip('"'), self._max_name_length-2).upper()
+        
+    def get_trigger_name(self, name):
+        return '%s$T' % util.truncate_name(name.strip('"'), self._max_name_length-2).upper() 
+    
+    def _get_firebird_version(self):
+        if self._firebird_version is None:
+            from django.db import connection
+            self._firebird_version = [int(val) for val in connection.server_version.split()[-1].split('.')]
+        return self._firebird_version
+    firebird_version = property(_get_firebird_version)
+  
+    def reference_name(self, r_col, col, r_table, table):
+        base_name = util.truncate_name('%s$%s' % (r_col, col), self._max_name_length-5)
+        return ('%s$%x' % (base_name, abs(hash((r_table, table))))).upper()
+    
+    def _get_page_size(self):
+        if self._page_size is None:
+            from django.db import connection
+            self._page_size = connection.database_info(Database.isc_info_page_size, 'i')
+        return self._page_size
+    page_size = property(_get_page_size)
+    
+    def _get_index_limit(self):
+        if self.firebird_version[0] < 2:
+            self._index_limit = 252 
+        else:
+            page_size = self._get_page_size()
+            self._index_limit = page_size/4
+        return self._index_limit
+    index_limit = property(_get_index_limit)
+    
+    def max_name_length(self):
+        return self._max_name_length
+    
+    def quote_name(self, name):
+        name = '"%s"' % util.truncate_name(name.strip('"'), self._max_name_length)
+        return name
+    
+    def quote_id_plus_number(self, name):
+        try:
+            return '"%s" + %s' % tuple(s.strip() for s in name.strip('"').split('+'))
+        except:
+            return self.quote_name(name)
+    
+    def field_cast_sql(self, db_type):
+        return '%s'
+
+    ############################################################################
+    # Basic SQL ops:    
+    def last_insert_id(self, cursor, table_name, pk_name=None):
+        generator_name = self.get_generator_name(table_name)
+        cursor.execute('SELECT GEN_ID(%s, 0) from RDB$DATABASE' % generator_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, 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 drop_sequence_sql(self, table):
+        return "DROP GENERATOR %s;" % self.get_generator_name(table)
+    
+    def drop_foreignkey_sql(self):
+        return "DROP CONSTRAINT"
+        
+    def limit_offset_sql(self, limit, offset=None):
+        # limits are handled in custom FirebirdQuerySet 
+        assert False, 'Limits are handled in a different way in Firebird'
+        return ""
+
+    def random_function_sql(self):
+        return "rand()"
+
+    def pk_default_value(self):
+        """
+        Returns the value to use during an INSERT statement to specify that
+        the field should use its default value.
+        """
+        return 'NULL'
+    
+    def start_transaction_sql(self):
+        return ""
+
+    def fulltext_search_sql(self, field_name):
+        # We use varchar for TextFields so this is possible
+        # Look at http://www.volny.cz/iprenosil/interbase/ip_ib_strings.htm
+        return '%%s CONTAINING %s' % self.quote_name(field_name)
+
+    ############################################################################
+    # Advanced SQL ops:
+    def autoinc_sql(self, style, table_name, column_name):
+        """
+        To simulate auto-incrementing primary keys in Firebird, we have to
+        create a generator and a trigger.
+    
+        Create the generators and triggers names based only on table name
+        since django only support one auto field per model
+        """
+   
+        generator_name = self.get_generator_name(table_name)
+        trigger_name = self.get_trigger_name(table_name)
+        column_name = self.quote_name(column_name)
+        table_name = self.quote_name(table_name)
+        
+        generator_sql = "%s %s;" % ( style.SQL_KEYWORD('CREATE GENERATOR'), 
+                                     generator_name)      
+        trigger_sql = "\n".join([
+            "%s %s %s %s" % ( \
+            style.SQL_KEYWORD('CREATE TRIGGER'), trigger_name, style.SQL_KEYWORD('FOR'),
+            style.SQL_TABLE(table_name)),
+            "%s 0 %s" % (style.SQL_KEYWORD('ACTIVE BEFORE INSERT POSITION'), style.SQL_KEYWORD('AS')),
+            style.SQL_KEYWORD('BEGIN'), 
+            "  %s ((%s.%s %s) %s (%s.%s = 0)) %s" % ( \
+                style.SQL_KEYWORD('IF'),
+                style.SQL_KEYWORD('NEW'), style.SQL_FIELD(column_name), style.SQL_KEYWORD('IS NULL'),
+                style.SQL_KEYWORD('OR'), style.SQL_KEYWORD('NEW'), style.SQL_FIELD(column_name),
+                style.SQL_KEYWORD('THEN')
+            ),
+            "  %s" % style.SQL_KEYWORD('BEGIN'), 
+            "    %s.%s = %s(%s, 1);" % ( \
+                style.SQL_KEYWORD('NEW'), style.SQL_FIELD(column_name),
+                style.SQL_KEYWORD('GEN_ID'), generator_name
+            ),
+            "  %s" % style.SQL_KEYWORD('END'),
+            "%s;" % style.SQL_KEYWORD('END')])
+        return (generator_sql, trigger_sql)
+    
+    def sequence_reset_sql(self, style, model_list):
+        from django.db import models
+        output = []
+        sql = ['%s %s %s' % (style.SQL_KEYWORD('CREATE OR ALTER PROCEDURE'),
+                             style.SQL_TABLE('"GENERATOR_RESET"'),
+                             style.SQL_KEYWORD('AS'))]
+        sql.append('%s %s' % (style.SQL_KEYWORD('DECLARE VARIABLE'), style.SQL_COLTYPE('start_val integer;')))
+        sql.append('%s %s' % (style.SQL_KEYWORD('DECLARE VARIABLE'), style.SQL_COLTYPE('gen_val integer;')))
+        sql.append('\t%s' % style.SQL_KEYWORD('BEGIN'))
+        sql.append('\t\t%s %s %s %s %s %s;' % (style.SQL_KEYWORD('SELECT MAX'), style.SQL_FIELD('(%(col)s)'),
+                                           style.SQL_KEYWORD('FROM'), style.SQL_TABLE('%(table)s'),
+                                           style.SQL_KEYWORD('INTO'), style.SQL_COLTYPE(':start_val')))
+        sql.append('\t\t%s (%s %s) %s' % (style.SQL_KEYWORD('IF'), style.SQL_COLTYPE('start_val'),
+                                    style.SQL_KEYWORD('IS NULL'), style.SQL_KEYWORD('THEN')))
+        sql.append('\t\t\t%s = %s(%s, 1 - %s(%s, 0));' %\
+            (style.SQL_COLTYPE('gen_val'), style.SQL_KEYWORD('GEN_ID'), style.SQL_TABLE('%(gen)s'),
+             style.SQL_KEYWORD('GEN_ID'), style.SQL_TABLE('%(gen)s')))
+        sql.append('\t\t%s' % style.SQL_KEYWORD('ELSE'))
+        sql.append('\t\t\t%s = %s(%s, %s - %s(%s, 0));' %\
+            (style.SQL_COLTYPE('gen_val'), style.SQL_KEYWORD('GEN_ID'),
+             style.SQL_TABLE('%(gen)s'), style.SQL_COLTYPE('start_val'), style.SQL_KEYWORD('GEN_ID'),
+             style.SQL_TABLE('%(gen)s')))
+        sql.append('\t\t%s;' % style.SQL_KEYWORD('EXIT'))
+        sql.append('%s;' % style.SQL_KEYWORD('END'))
+        sql ="\n".join(sql)
+        for model in model_list:
+            for f in model._meta.fields:
+                if isinstance(f, models.AutoField):
+                    generator_name = self.get_generator_name(model._meta.db_table)
+                    column_name = self.quote_name(f.db_column or f.name)
+                    table_name = self.quote_name(model._meta.db_table)
+                    output.append(sql % {'col' : column_name, 'table' : table_name, 'gen' : generator_name})
+                    output.append('%s %s;' % (style.SQL_KEYWORD('EXECUTE PROCEDURE'), 
+                                              style.SQL_TABLE('"GENERATOR_RESET"')))
+                    break # Only one AutoField is allowed per model, so don't bother continuing.
+            for f in model._meta.many_to_many:
+                generator_name = self.get_generator_name(f.m2m_db_table())
+                table_name = self.quote_name(f.m2m_db_table())
+                column_name = '"id"'
+                output.append(sql % {'col' : column_name, 'table' : table_name, 'gen' : generator_name})
+                output.append('%s %s;' % (style.SQL_KEYWORD('EXECUTE PROCEDURE'), 
+                                          style.SQL_TABLE('"GENERATOR_RESET"')))
+        return output
+    
+    def sql_flush(self, style, tables, sequences):
+        if tables:
+            sql = ['%s %s %s;' % \
+                    (style.SQL_KEYWORD('DELETE'),
+                     style.SQL_KEYWORD('FROM'),
+                     style.SQL_TABLE(self.quote_name(table))
+                     ) for table in tables]
+            for generator_info in sequences:
+                table_name = generator_info['table']
+                query = "%s %s %s 0;" % (style.SQL_KEYWORD('SET GENERATOR'), 
+                    self.get_generator_name(table_name), style.SQL_KEYWORD('TO'))
+                sql.append(query)
+            return sql
+        else:
+            return []
+            
+    ############################################################################
+    # Custom classes
+    def field_class(this, DefaultField):
+        from django.db import connection
+        from django.db.models.fields import prep_for_like_query
+        class FirebirdField(DefaultField):
+            def get_db_prep_lookup(self, lookup_type, value):       
+                "Returns field's value prepared for database lookup."
+                if lookup_type in ('exact', 'regex', 'iregex', 'gt', 'gte', 'lt', 
+                    'lte', 'month', 'day', 'search', 'icontains', 
+                    'startswith', 'istartswith'):
+                    return [value]
+                elif lookup_type in ('range', 'in'):
+                    return value
+                elif lookup_type in ('contains',):
+                    return ["%%%s%%" % prep_for_like_query(value)]
+                elif lookup_type == 'iexact':
+                    return [prep_for_like_query(value)]
+                elif lookup_type in ('endswith', 'iendswith'):
+                    return ["%%%s" % prep_for_like_query(value)]
+                elif lookup_type == 'isnull':
+                    return []
+                elif lookup_type == 'year':
+                    try:
+                        value = int(value)
+                    except ValueError:
+                        raise ValueError("The __year lookup type requires an integer argument")
+                    return ['%s-01-01 00:00:00' % value, '%s-12-31 23:59:59.999999' % value]
+                raise TypeError("Field has invalid lookup: %s" % lookup_type)
+        return FirebirdField
+
+    def query_set_class(this, DefaultQuerySet):
+        from django.db import connection
+        from django.db.models.query import EmptyResultSet, GET_ITERATOR_CHUNK_SIZE
+        
+        class FirebirdQuerySet(DefaultQuerySet):
+            __firefilter__ = None
+            ___fireargs__ = ()
+            def _get_sql_clause(self):
+                from django.db.models.query import SortedDict, handle_legacy_orderlist, orderfield2column, fill_table_cache
+                qn = this.quote_name
+                opts = self.model._meta
+
+                # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z.
+                select = ["%s.%s" % (qn(opts.db_table), qn(f.column)) for f in opts.fields]
+                tables = [qn(t) for t in self._tables]
+                joins = SortedDict()
+                where = self._where[:]
+                params = self._params[:]
+
+                # Convert self._filters into SQL.
+                joins2, where2, params2 = self._filters.get_sql(opts)
+                joins.update(joins2)
+                where.extend(where2)
+                params.extend(params2)
+
+                # Add additional tables and WHERE clauses based on select_related.
+                if self._select_related:
+                    fill_table_cache(opts, select, tables, where,
+                                     old_prefix=opts.db_table,
+                                     cache_tables_seen=[opts.db_table],
+                                     max_depth=self._max_related_depth)
+                
+                # Add any additional SELECTs.
+                if self._select:
+                    select.extend([('(%s AS %s') % (qn(s[1]), qn(s[0])) for s in self._select.items()])
+
+                # Start composing the body of the SQL statement.
+                sql = [" FROM", qn(opts.db_table)]
+
+                # Compose the join dictionary into SQL describing the joins.
+                if joins:
+                    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.
+                if tables:
+                    sql.append(", " + ", ".join(tables))
+
+                # Compose the where clause into SQL.
+                if where: 
+  &n