Ticket #10096: added linter backend.diff

django/db/backends/linter/base.py

@@ +1 @@
+"""
+LINTER database backend for Django.
+"""
+from django.db.backends import *
+                                        
+from django.db.backends.linter import query
+from django.db.backends.linter.client import DatabaseClient
+from django.db.backends.linter.creation import DatabaseCreation
+from django.db.backends.linter.introspection import DatabaseIntrospection
+from django.utils.encoding import smart_str, force_unicode
+
+try:
+    import LinPy as Database
+except ImportError, e:
+    from django.core.exceptions import ImproperlyConfigured
+    raise ImproperlyConfigured, "Error loading LinPy module: %s" % e
+
+DatabaseError = Database.Error
+IntegrityError = Database.IntegrityError
+
+class DatabaseFeatures(BaseDatabaseFeatures):
+    uses_custom_query_class = True
+   
+class DatabaseOperations(BaseDatabaseOperations):
+
+    _lookup_types_dict = {'day' : 'D', 'month' : 'M', 'year' : 'Y'}
+
+    def date_extract_sql(self, lookup_type, table_name):      
+        return "DATESPLIT (%s, '%s')" % (table_name, self._lookup_types_dict[lookup_type])
+
+    def date_trunc_sql(self, lookup_type, field_name):
+        return "TRUNC(%s, '%s')" % (field_name, self._lookup_types_dict[lookup_type])
+
+    def drop_foreignkey_sql(self):
+        return "DROP FOREIGN KEY"
+
+    def fulltext_search_sql(self, field_name):
+        return "%s CONTAINS '%%s'" % field_name
+
+    def last_executed_query(self, cursor, sql, params):
+        """
+        Returns a string of the query last executed by the given cursor, with
+        placeholders replaced with actual values.
+        """
+        from django.utils.encoding import smart_unicode, force_unicode
+
+        if not params:
+            return smart_unicode(sql)
+
+        # Convert params to contain Unicode values.
+        to_unicode = lambda s: force_unicode(s, strings_only=True)
+        if isinstance(params, (list, tuple)):
+            u_params = tuple([to_unicode(val) for val in params])
+        else:
+            u_params = dict([(to_unicode(k), to_unicode(v)) for k, v in params.items()])
+
+        return smart_unicode(sql) % u_params
+
+    def last_insert_id(self, cursor, table_name, pk_name):
+        query = "SELECT %s FROM %s WHERE ROWID = LAST_ROWID" % (self.quote_name(pk_name), self.quote_name(table_name)) # 23.09.
+        cursor.execute(query)
+        return cursor.fetchone()[0]
+
+    def lookup_cast(self, lookup_type):
+        if lookup_type in ('iexact', 'icontains', 'iregex', 'istartswith', 'iendswith'):
+            return "UPPER(%s)"
+        return "%s"
+
+    def no_limit_value(self):
+        return -1
+
+    def query_class(self, DefaultQueryClass):
+        return query.query_class(DefaultQueryClass, Database)
+
+    def quote_name(self, name):   
+        if name.startswith('"') and name.endswith('"'):
+            return name # Quoting once is enough.
+        return '"%s"' % name.upper()
+    
+    def random_function_sql(self):
+        return "RAND()"
+
+    def sql_flush(self, style, tables, sequences):  
+        # Return a list of 'TRUNCATE x;', 'TRUNCATE y;',
+        # 'TRUNCATE z;'... style SQL statements          
+        
+        sql = ['%s %s %s;' % \
+                (style.SQL_KEYWORD('TRUNCATE'),
+                 style.SQL_KEYWORD('TABLE'),
+                 style.SQL_FIELD(self.quote_name(table))
+                 )  for table in tables]
+        return sql
+
+class DatabaseWrapper(BaseDatabaseWrapper):
+
+    operators = {
+        'exact': '= %s',
+        'iexact': '= UPPER(%s)',
+        'contains': 'LIKE %s',
+        'icontains': 'LIKE UPPER(%s)',
+        'regex': 'SIMILAR TO %s',
+        'iregex': 'SIMILAR TO UPPER(%s)',
+        'gt': '> %s',
+        'gte': '>= %s',
+        'lt': '< %s',
+        'lte': '<= %s',
+        'startswith': 'LIKE %s',
+        'endswith': 'LIKE %s',                                  
+        'istartswith': 'LIKE UPPER(%s)',
+        'iendswith': 'LIKE UPPER(%s)',
+    }
+    
+    def __init__(self, **kwargs):
+        super(DatabaseWrapper, self).__init__(**kwargs)
+
+        self.features = DatabaseFeatures()   
+        self.ops = DatabaseOperations()
+        self.client = DatabaseClient()
+        self.creation = DatabaseCreation(self)
+        self.introspection = DatabaseIntrospection(self)
+        self.validation = BaseDatabaseValidation()
+
+    def _valid_connection(self):
+        return self.connection is not None
+
+    def _cursor(self, settings):
+        # SetUnicodeData(1) - set output data mode in unicode
+        Database.SetUnicodeData(1)
+        from django.conf import settings
+
+        if not self._valid_connection():
+            self.connection = Database.connect(settings.DATABASE_USER, settings.DATABASE_PASSWORD, settings.DATABASE_NAME, **self.options)
+        cursor = self.connection.cursor(mode=Database.M_EXCLUSIVE)   
+        cursor = LinterCursorWrapper(cursor)
+        return cursor
+
+    def _commit(self):
+        if self.connection is not None:
+            self.connection.commit()
+                       
+    def _rollback(self):
+        if self.connection is not None:
+            try:
+                self.connection.rollback()
+            except Database.NotSupportedError:
+                pass
+
+    def set_date_emulation(self, value=0):
+        # Set mode conversion values datetime type to date type,
+        # if data contain values only for year, month and day.
+        # By default always returned data in datetime type.
+        Database.SetDateEmulation(value)
+
+class LinterCursorWrapper(object):
+    """
+    Django uses "format" style placeholders, but LinPy 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 __init__(self, cursor):
+        self.cursor = cursor
+                                         
+    def __getattr__(self, attr):
+        if self.__dict__.has_key(attr):
+            return self.__dict__[attr]
+        else:
+            return getattr(self.cursor, attr)
+
+    def execute(self, query, params=()):
+        query = self.convert_query(query, len(params))
+
+        try:
+            return self.cursor.execute(query, params)    
+        except DatabaseError, e:
+            if type(e) != IntegrityError:
+                e = IntegrityError(e)
+        raise e
+
+    def executemany(self, query, param_list):
+        try:
+            query = self.convert_query(query, len(param_list[0]))
+            return self.cursor.executemany(query, param_list)
+        except (IndexError,TypeError):
+            # No parameter list provided
+            return None
+                                          
+    def convert_query(self, query, num_params):
+        if num_params:
+            return smart_str(query % tuple("?" * num_params))
+        else:      
+            return smart_str(query)

django/db/backends/linter/client.py

@@ +1 @@
+from django.db.backends import BaseDatabaseClient
+from django.conf import settings
+import os
+
+class DatabaseClient(BaseDatabaseClient):
+    def runshell(self):
+        args = ['']
+        if settings.DATABASE_PASSWORD:
+            args = ["-u %s/%s" % (settings.DATABASE_USER, settings.DATABASE_PASSWORD)]
+        else:
+            args = ["-u %s/" % settings.DATABASE_USER]
+        args += [" -n %s" % settings.DATABASE_NAME]
+        os.execvp('inl', args)
+
+

django/db/backends/linter/introspection.py

@@ +1 @@
+from django.db.backends import BaseDatabaseIntrospection
+import string
+
+class DatabaseIntrospection(BaseDatabaseIntrospection):
+    # Maps type codes to Django Field types.
+    data_types_reverse = {
+        'CHAR': 'CharField',
+        'NCHAR': 'CharField',
+        'VARCHAR': 'CharField',   
+        'NACHAR VARYING': 'CharField',
+        'SMALLINT': 'SmallIntegerField',
+        'INTEGER': 'IntegerField',
+        'BIGINT': 'IntegerField',
+        'REAL': 'FloatField', 
+        'DOUBLE': 'FloatField',
+        'NUMERIC': 'FloatField',
+        'BOOLEAN': 'BooleanField',
+        'DATE': 'DateField',
+        'DATE': 'DateFieldWrapper',
+        'BLOB': 'TextField',
+        'EXTFILE': 'CharField',
+    }
+
+    def get_table_list(self, cursor):
+        "Returns a list of table names in the current database."
+        cursor.execute("""
+            SELECT TABLE_NAME  
+            FROM LINTER_SYSTEM_USER.TABLES 
+            WHERE TABLE_SCHEM = USER AND TABLE_TYPE ='TABLE' 
+            AND TABLE_NAME NOT LIKE '$$$%' AND TABLE_NAME NOT LIKE 'L\_%' 
+            AND TABLE_NAME NOT IN ('SERVERS','PRIV_TYPES','TYPEINFO','COUNTER6',
+            'COUNTER8','COUNTER31','PROVIDER_TYPES','ERRORS')""")
+        return ([string.lower(row[0]) for row in cursor.fetchall()])
+
+    def get_table_description(self, cursor, table_name):
+        qn = self.connection.ops.quote_name
+        cursor.execute("SELECT * FROM %s LIMIT 1" % qn(table_name))
+        return cursor.description
+
+    def _name_to_index(self, cursor, table_name):
+        """
+        Returns a dictionary of {field_name: field_index} for the given table.
+        Indexes are 0-based.
+        """
+        return dict([(d[0], i) for i, d in enumerate(self.get_table_description(cursor, table_name))])
+
+    def get_relations(self, 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.
+        """
+        my_field_dict = self._name_to_index(cursor, table_name)
+        relations = {}
+
+        cursor.execute("""
+            SELECT FKCOLUMN_NAME, PKTABLE_NAME, PKCOLUMN_NAME 
+            FROM LINTER_SYSTEM_USER.FOREIGN_KEYS 
+            WHERE FKTABLE_NAME = %s""" % dbo.quote_name(table_name))
+        for row in cursor.fetchall():
+            other_field_index = self._name_to_index(cursor, row[1])[row[2]]
+            my_field_index = my_field_dict[row[0]]
+            relations[my_field_index] = (other_field_index, row[1])
+
+        return relations        
+
+    def get_indexes(self, 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}
+        """
+        indexes = {}
+     
+        cursor.execute("""
+            SELECT NON_UNIQUE, COLUMN_NAME 
+            FROM LINTER_SYSTEM_USER.TABLESTATISTICS 
+            WHERE TABLE_NAME = %s""" % dbo.quote_name(table_name))
+        for row in cursor.fetchall():
+            if row[0] != None:
+                indexes[row[1]] = {'primary_key': bool(row[1]), 'unique': not bool(row[0])}
+
+        return indexes
+

django/db/backends/linter/creation.py

@@ +1 @@
+import sys
+from django.conf import settings
+from django.db.backends.creation import BaseDatabaseCreation
+
+TEST_USER_PREFIX = 'TEST_'
+
+class DatabaseCreation(BaseDatabaseCreation):
+    # This dictionary maps Field objects to their associated LINTER 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 AUTOINC',
+        'BooleanField':                 'boolean',
+        'CharField':                    'nvarchar(%(max_length)s)',
+        'CommaSeparatedIntegerField':   'varchar(%(max_length)s)',
+        'DateField':                    'date',
+        'DateTimeField':                'date',
+        'DecimalField':                 'number(%(max_digits)s, %(decimal_places)s)',
+        'FileField':                    'varchar(%(max_length)s)',
+        'FilePathField':                'varchar(%(max_length)s)',
+        'FloatField':                   'double',
+        'IntegerField':                 'integer',
+        'IPAddressField':               'char(15)',
+        'NullBooleanField':             'integer',
+        'OneToOneField':                'integer',
+        'PositiveIntegerField':         'integer',
+        'PositiveSmallIntegerField':    'smallint',
+        'SlugField':                    'varchar(%(max_length)s)',
+        'SmallIntegerField':            'smallint',
+        'TextField':                    'varchar(1000)',    
+        'TimeField':                    'date',
+        'URLField':                     'varchar(%(max_length)s)',
+    }
+
+    remember = {}
+
+    def _create_test_db(self, verbosity, autoclobber):
+        """
+        We don't created test database, we only create test user 
+        """
+
+        TEST_DATABASE_USER = TEST_USER_PREFIX + settings.DATABASE_USER
+        TEST_DATABASE_PASSWD = settings.DATABASE_PASSWORD
+
+        parameters = {
+            'user' : TEST_DATABASE_USER,
+            'password' : TEST_DATABASE_PASSWD,
+        }
+
+        self.remember['user'] = settings.DATABASE_USER
+        self.remember['passwd'] = settings.DATABASE_PASSWORD
+
+        cursor = self.connection.cursor()
+
+        if verbosity >= 1:
+            print "Creating test user..."
+        try:
+            self._create_test_user(cursor, parameters, verbosity) 
+        except Exception, e:
+            sys.stderr.write("Got an error creating the test user: %s\n" % e)
+            if not autoclobber:
+                confirm = raw_input("It appears the test user, %s, already exists. Type 'yes'  to delete it? or 'no' to cancel: " % TEST_DATABASE_USER)
+            if autoclobber or confirm == 'yes':
+                try:
+                    if verbosity >= 1:
+                        print "Destroying old test user..."
+                    self._destroy_test_user(cursor, parameters, verbosity) 
+                    if verbosity >= 1:
+                        print "Creating test user..."
+                    self._create_test_user(cursor, parameters, verbosity)  
+                except Exception, e:
+                    sys.stderr.write("Got an error recreating the test user: %s\n" % e)
+                    sys.exit(2)
+            else:
+                print "Tests cancelled."
+                sys.exit(1)
+
+        settings.DATABASE_USER = TEST_DATABASE_USER
+
+        return settings.DATABASE_NAME
+
+    def _destroy_test_db(self, test_database_name, verbosity):
+        """
+        Don't destroy database. Desrtoy test user.
+        """
+        TEST_DATABASE_USER = settings.DATABASE_USER
+        TEST_DATABASE_PASSWD = settings.DATABASE_PASSWORD
+
+        parameters = {
+            'user' : TEST_DATABASE_USER,
+            'password' : TEST_DATABASE_PASSWD
+        }
+
+        settings.DATABASE_USER = self.remember['user']
+        settings.DATABASE_PASSWORD = self.remember['passwd']
+
+        cursor = self.connection.cursor()
+
+        if verbosity >= 1:
+            print "Destroying test user..."
+        self._destroy_test_user(cursor, parameters, verbosity)
+        
+        self.connection.close()
+
+    def _create_test_user(self, cursor, parameters, verbosity):
+        if verbosity >= 2:
+            print "_crete_test_user(): username = %s" % parameters['user']
+        statements = [
+            "CREATE USER %(user)s IDENTIFIED BY '%(password)s'", 
+            "GRANT RESOURCE TO %(user)s"
+        ]
+        self._execute_statements(cursor, statements, parameters, verbosity)
+    
+    def _destroy_test_user(self, cursor, parameters, verbosity):
+        if verbosity >= 2:
+            print "_destroy_test_user(): user = %s" % parameters['user']
+        statements = ["DROP USER %(user)s CASCADE"]
+        
+        self._execute_statements(cursor, statements, parameters, verbosity)
+            
+    def _execute_statements(self, cursor, statements, parameters, verbosity):
+        for template in statements:
+            stmt = template % parameters
+            if verbosity >= 2:
+                print stmt
+            try:
+                cursor.execute(stmt)
+            except Exception, err:
+                sys.stderr.write("Failed (%s)\n" % (err))
+                raise
+
+    def sql_for_pending_references(self, model, style, pending_references):
+        """
+        Returns any ALTER TABLE statements to add constraints after the fact.
+        """                                                                  
+        qn = self.connection.ops.quote_name
+        final_output = []
+        opts = model._meta
+        if model in pending_references:
+            for rel_class, f in pending_references[model]:
+                rel_opts = rel_class._meta
+                r_table = rel_opts.db_table
+                r_col = f.column
+                table = opts.db_table
+                col = opts.get_field(f.rel.field_name).column
+                final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD FOREIGN KEY (%s) REFERENCES %s (%s)%s;' % \
+                    (qn(r_table), 
+                    qn(r_col), qn(table), qn(col),
+                    self.connection.ops.deferrable_sql()))
+            del pending_references[model]
+        return final_output
+
+    def sql_indexes_for_field(self, model, f, style):
+        """
+        Return the CREATE INDEX SQL statements for a single model field
+        """ 
+        from django.db.models.fields.related import ForeignKey
+        # LINTER create index for primary keys, unique and foreign keys 
+        # automatically
+        if f.db_index and not f.unique and (not isinstance(f, ForeignKey)):
+            qn = self.connection.ops.quote_name
+            tablespace = f.db_tablespace or model._meta.db_tablespace
+            if tablespace:
+                sql = self.connection.ops.tablespace_sql(tablespace)
+                if sql:
+                    tablespace_sql = ' ' + sql
+                else:
+                    tablespace_sql = ''
+            else:
+                tablespace_sql = ''
+            output = [style.SQL_KEYWORD('CREATE INDEX') + ' ' +
+                style.SQL_TABLE(qn('%s_%s' % (model._meta.db_table, f.column))) + ' ' +
+                style.SQL_KEYWORD('ON') + ' ' +
+                style.SQL_TABLE(qn(model._meta.db_table)) + ' ' +
+                "(%s)" % style.SQL_FIELD(qn(f.column)) +
+                "%s;" % tablespace_sql]
+        else:
+            output = []
+        return output           
+
+    def sql_remove_table_constraints(self, model, references_to_delete, style):
+        from django.db.backends.util import truncate_name
+
+        output = []
+        qn = self.connection.ops.quote_name
+        for rel_class, f in references_to_delete[model]:
+            table = rel_class._meta.db_table
+            col = f.column
+            output.append('%s %s %s (%s);' % \
+                (style.SQL_KEYWORD('ALTER TABLE'),
+                style.SQL_TABLE(qn(table)),
+                style.SQL_KEYWORD(self.connection.ops.drop_foreignkey_sql()),
+                style.SQL_FIELD(col)))
+        del references_to_delete[model]
+        return output

django/db/backends/linter/query.py

@@ +1 @@
+"""
+Custom Query class for Linter.
+Derives from: django.db.models.sql.query.Query
+"""
+
+import datetime
+
+from django.db.backends import util
+
+# Cache. Maps default query class to new Linter query class.
+_classes = {}
+
+def query_class(QueryClass, Database):
+    """
+    Returns a custom django.db.models.sql.query.Query subclass that is
+    appropriate for Linter.
+
+    """
+    global _classes
+    try:
+        return _classes[QueryClass]
+    except KeyError:
+        pass
+
+    class LinterQuery(QueryClass):
+
+        def as_sql(self, with_limits=True, with_col_aliases=False):
+            """
+            Creates the SQL for this query. Returns the SQL string and list
+            of parameters.  This is overriden from the original Query class
+            to accommodate Linter's limit/offset SQL.
+
+            If 'with_limits' is False, any limit/offset information is not
+            included in the query.
+            """
+
+            # The `do_offset` flag indicates whether we need to construct
+            # the SQL needed to use limit/offset.        
+            do_offset = with_limits and (self.high_mark is not None
+                                         or self.low_mark)
+
+            # If no offsets, just return the result of the base class
+            # `as_sql`.
+            if not do_offset:
+                return super(LinterQuery, self).as_sql(with_limits=False,
+                        with_col_aliases=with_col_aliases)
+
+            # `get_columns` needs to be called before `get_ordering` to
+            # populate `_select_alias`.
+            self.pre_sql_setup()
+            out_cols = self.get_columns()
+            ordering = self.get_ordering()
+
+            sql, params = super(LinterQuery, self).as_sql(with_limits=False,
+                    with_col_aliases=True)
+
+            # Constructing the result SQL, using the initial select SQL
+            # obtained above.
+            result =['%s' % sql]      
+
+            if self.low_mark:
+                if self.high_mark == self.low_mark:
+                    return None
+                elif self.high_mark is not None:
+                    result.append('LIMIT %d, %d' % (self.low_mark, (self.high_mark - self.low_mark)))
+                else:
+                    val = self.connection.ops.no_limit_value()
+                    if val:
+                        result.append('LIMIT %d, %d' % (self.low_mark, val))
+            else:
+                result.append('LIMIT %d' % self.high_mark)      
+
+            # Returning the SQL w/params.
+            return ' '.join(result), params
+
+    _classes[QueryClass] = LinterQuery
+    return LinterQuery

docs/faq/install.txt

@@ -30 +30 @@
 
 If you want to use Django with a database, which is probably the case, you'll
 also need a database engine. PostgreSQL_ is recommended, because we're
-PostgreSQL fans, and MySQL_, `SQLite 3`_, and Oracle_ are also supported.
+PostgreSQL fans, and MySQL_, `SQLite 3`_, Oracle_, and LINTER_ are also supported.
 
 .. _Python: http://www.python.org/
 .. _Apache 2: http://httpd.apache.org/
@@ -40 +40 @@
 .. _MySQL: http://www.mysql.com/
 .. _`SQLite 3`: http://www.sqlite.org/
 .. _Oracle: http://www.oracle.com/
+.. _LINTER: http://www.lintersql.com/
 
 Do I lose anything by using Python 2.3 versus newer Python versions, such as Python 2.5?
 ----------------------------------------------------------------------------------------

docs/ref/databases.txt

@@ -460 +460 @@
     Oracle. A workaround to this is to keep ``TextField`` columns out of any
     models that you foresee performing ``distinct()`` queries on, and to
     include the ``TextField`` in a related model instead.
+
+.. _linter-notes:
+
+.. versionadded:: 1.0
+
+LINTER notes
+============
+
+Django supports `DBMS LINTER`_ versions 5.9 and higher. For working Django 
+with LINTER you will need the `LinPy.dll`. It's library based on 
+`Python Database API Specification v2.0`_ included in distributive `LINTER` 
+and supports Python versions 2.1-2.6.
+
+.. _`DBMS LINTER`: http://www.lintersql.com/
+.. _`Python Database API Specification v2.0`: http://www.python.org/dev/peps/pep-0249/
+
+In order for the ``python manage.py syncdb`` command to work, your LINTER
+database user must have access category ``resource`` or ``dba``.
+To run Django's test suite, the user needs access category ``dba``.
+    
+Connecting to the database
+--------------------------
+
+Your Django settings.py file should look something like this for LINTER::
+
+    DATABASE_ENGINE = 'linter'
+    DATABASE_NAME = 'DEMO'
+    DATABASE_USER = 'a_user'
+    DATABASE_PASSWORD = 'a_password'
+    DATABASE_HOST = ''
+    DATABASE_PORT = ''
+
+``DateField`` and ``DateTimeField`` data
+----------------------------------------
+
+All date and time data LINTER storage in one type `DATE`_. LinPy by default 
+returned all data in ``datetime.datetime`` format, if need get data in 
+``datetime.date`` format, then you will use LINTER backend function 
+``set_date_emulation``. This function set mode conversion values ``datetime`` 
+type to ``date`` type, if data contain values only for year, month and day.
+This mode conversion values used in tests ``serializers``, ``model_forms``
+from Django's test suite. This tests is necessary edit in the following way.
+At the beggining of tests need to add strings::
+    
+    >>> from django.db import connection
+    >>> connection.set_date_emulation(1)
+
+In this case tests will execute completely.
+
+.. _`DATE`: http://www.lintersql.com/en/documentation/pdf/sql.pdf

docs/ref/settings.txt

@@ -152 +152 @@
 Default: ``''`` (Empty string)
 
 The database backend to use. The built-in database backends are
-``'postgresql_psycopg2'``, ``'postgresql'``, ``'mysql'``, ``'sqlite3'``, and
-``'oracle'``.
+``'postgresql_psycopg2'``, ``'postgresql'``, ``'mysql'``, ``'sqlite3'``,
+``'oracle'`` and ``'linter'``.
 
 You can use a database backend that doesn't ship with Django by setting
 ``DATABASE_ENGINE`` to a fully-qualified path (i.e.

docs/topics/install.txt

@@ -61 +61 @@
 
 If you plan to use Django's database API functionality, you'll need to
 make sure a database server is running. Django works with PostgreSQL_,
-MySQL_, Oracle_ and SQLite_ (although SQLite doesn't require a separate server
+MySQL_, Oracle_, LINTER_ and SQLite_ (although SQLite doesn't require a separate server
 to be running).
 
 Additionally, you'll need to make sure your Python database bindings are
@@ -86 +86 @@
   4.3.1 or higher. You will also want to read the database-specific notes for
   the :ref:`Oracle backend <oracle-notes>`.
 
+* If you're using LINTER, you'll need LinPy.dll. You will also want to read
+  the database-specific notes for the :ref:`LINTER backend <ref-databases>`.
+
 If you plan to use Django's ``manage.py syncdb`` command to
 automatically create database tables for your models, you'll need to
 ensure that Django has permission to create and alter tables in the
@@ -108 +111 @@
 .. _pysqlite: http://initd.org/pub/software/pysqlite/
 .. _cx_Oracle: http://cx-oracle.sourceforge.net/
 .. _Oracle: http://www.oracle.com/
+.. _LINTER: http://www.lintersql.com/
 
 .. _removing-old-versions-of-django: