Index: django/db/backends/linter/base.py =================================================================== --- django/db/backends/linter/base.py (revision 0) +++ django/db/backends/linter/base.py (revision 0) @@ -0,0 +1,191 @@ +""" +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) Index: django/db/backends/linter/client.py =================================================================== --- django/db/backends/linter/client.py (revision 0) +++ django/db/backends/linter/client.py (revision 0) @@ -0,0 +1,15 @@ +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) + + Index: django/db/backends/linter/__init__.py =================================================================== Index: django/db/backends/linter/introspection.py =================================================================== --- django/db/backends/linter/introspection.py (revision 0) +++ django/db/backends/linter/introspection.py (revision 0) @@ -0,0 +1,84 @@ +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 + Index: django/db/backends/linter/creation.py =================================================================== --- django/db/backends/linter/creation.py (revision 0) +++ django/db/backends/linter/creation.py (revision 0) @@ -0,0 +1,196 @@ +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 Index: django/db/backends/linter/query.py =================================================================== --- django/db/backends/linter/query.py (revision 0) +++ django/db/backends/linter/query.py (revision 0) @@ -0,0 +1,77 @@ +""" +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 Index: docs/faq/install.txt =================================================================== --- docs/faq/install.txt (revision 9781) +++ docs/faq/install.txt (working copy) @@ -30,7 +30,7 @@ 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,6 +40,7 @@ .. _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? ---------------------------------------------------------------------------------------- Index: docs/ref/databases.txt =================================================================== --- docs/ref/databases.txt (revision 9781) +++ docs/ref/databases.txt (working copy) @@ -460,3 +460,53 @@ 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 Index: docs/ref/settings.txt =================================================================== --- docs/ref/settings.txt (revision 9781) +++ docs/ref/settings.txt (working copy) @@ -152,8 +152,8 @@ 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. Index: docs/topics/install.txt =================================================================== --- docs/topics/install.txt (revision 9781) +++ docs/topics/install.txt (working copy) @@ -61,7 +61,7 @@ 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,6 +86,9 @@ 4.3.1 or higher. You will also want to read the database-specific notes for the :ref:`Oracle backend `. +* 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 `. + 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,6 +111,7 @@ .. _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: