+
−"""
+
−MySQL database backend for Django.
+
−
+
−Requires MySQLdb: http://sourceforge.net/projects/mysql-python
+
−"""
+
−
+
−import re
+
−
+
−try:
+
−    import MySQLdb as Database
+
−except ImportError, e:
+
−    from django.core.exceptions import ImproperlyConfigured
+
−    raise ImproperlyConfigured("Error loading MySQLdb module: %s" % e)
+
−
+
−# We want version (1, 2, 1, 'final', 2) or later. We can't just use
+
−# lexicographic ordering in this check because then (1, 2, 1, 'gamma')
+
−# inadvertently passes the version test.
+
−version = Database.version_info
+
−if (version < (1,2,1) or (version[:3] == (1, 2, 1) and
+
−        (len(version) < 5 or version[3] != 'final' or version[4] < 2))):
+
−    from django.core.exceptions import ImproperlyConfigured
+
−    raise ImproperlyConfigured("MySQLdb-1.2.1p2 or newer is required; you have %s" % Database.__version__)
+
−
+
−from MySQLdb.converters import conversions
+
−from MySQLdb.constants import FIELD_TYPE, FLAG
+
−
+
−from django.db.backends import *
+
−from django.db.backends.mysql.client import DatabaseClient
+
−from django.db.backends.mysql.creation import DatabaseCreation
+
−from django.db.backends.mysql.introspection import DatabaseIntrospection
+
−from django.db.backends.mysql.validation import DatabaseValidation
+
−
+
−# Raise exceptions for database warnings if DEBUG is on
+
−from django.conf import settings
+
−if settings.DEBUG:
+
−    from warnings import filterwarnings
+
−    filterwarnings("error", category=Database.Warning)
+
−
+
−DatabaseError = Database.DatabaseError
+
−IntegrityError = Database.IntegrityError
+
−
+
−# MySQLdb-1.2.1 supports the Python boolean type, and only uses datetime
+
−# module for time-related columns; older versions could have used mx.DateTime
+
−# or strings if there were no datetime module. However, MySQLdb still returns
+
−# TIME columns as timedelta -- they are more like timedelta in terms of actual
+
−# behavior as they are signed and include days -- and Django expects time, so
+
−# we still need to override that.
+
−django_conversions = conversions.copy()
+
−django_conversions.update({
+
−    FIELD_TYPE.TIME: util.typecast_time,
+
−    FIELD_TYPE.DECIMAL: util.typecast_decimal,
+
−    FIELD_TYPE.NEWDECIMAL: util.typecast_decimal,
+
−})
+
−
+
−# This should match the numerical portion of the version numbers (we can treat
+
−# versions like 5.0.24 and 5.0.24a as the same). Based on the list of version
+
−# at http://dev.mysql.com/doc/refman/4.1/en/news.html and
+
−# http://dev.mysql.com/doc/refman/5.0/en/news.html .
+
−server_version_re = re.compile(r'(\d{1,2})\.(\d{1,2})\.(\d{1,2})')
+
−
+
−# MySQLdb-1.2.1 and newer automatically makes use of SHOW WARNINGS on
+
−# MySQL-4.1 and newer, so the MysqlDebugWrapper is unnecessary. Since the
+
−# point is to raise Warnings as exceptions, this can be done with the Python
+
−# warning module, and this is setup when the connection is created, and the
+
−# standard util.CursorDebugWrapper can be used. Also, using sql_mode
+
−# TRADITIONAL will automatically cause most warnings to be treated as errors.
+
−
+
−class CursorWrapper(object):
+
−    """
+
−    A thin wrapper around MySQLdb's normal cursor class so that we can catch
+
−    particular exception instances and reraise them with the right types.
+
−
+
−    Implemented as a wrapper, rather than a subclass, so that we aren't stuck
+
−    to the particular underlying representation returned by Connection.cursor().
+
−    """
+
−    codes_for_integrityerror = (1048,)
+
−
+
−    def __init__(self, cursor):
+
−        self.cursor = cursor
+
−
+
−    def execute(self, query, args=None):
+
−        try:
+
−            return self.cursor.execute(query, args)
+
−        except Database.OperationalError, e:
+
−            # Map some error codes to IntegrityError, since they seem to be
+
−            # misclassified and Django would prefer the more logical place.
+
−            if e[0] in self.codes_for_integrityerror:
+
−                raise Database.IntegrityError(tuple(e))
+
−            raise
+
−
+
−    def executemany(self, query, args):
+
−        try:
+
−            return self.cursor.executemany(query, args)
+
−        except Database.OperationalError, e:
+
−            # Map some error codes to IntegrityError, since they seem to be
+
−            # misclassified and Django would prefer the more logical place.
+
−            if e[0] in self.codes_for_integrityerror:
+
−                raise Database.IntegrityError(tuple(e))
+
−            raise
+
−
+
−    def __getattr__(self, attr):
+
−        if attr in self.__dict__:
+
−            return self.__dict__[attr]
+
−        else:
+
−            return getattr(self.cursor, attr)
+
−
+
−    def __iter__(self):
+
−        return iter(self.cursor)
+
−
+
−class DatabaseFeatures(BaseDatabaseFeatures):
+
−    empty_fetchmany_value = ()
+
−    update_can_self_select = False
+
−    related_fields_match_type = True
+
−
+
−class DatabaseOperations(BaseDatabaseOperations):
+
−    def date_extract_sql(self, lookup_type, field_name):
+
−        # http://dev.mysql.com/doc/mysql/en/date-and-time-functions.html
+
−        return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), field_name)
+
−
+
−    def date_trunc_sql(self, lookup_type, field_name):
+
−        fields = ['year', 'month', 'day', 'hour', 'minute', 'second']
+
−        format = ('%%Y-', '%%m', '-%%d', ' %%H:', '%%i', ':%%s') # Use double percents to escape.
+
−        format_def = ('0000-', '01', '-01', ' 00:', '00', ':00')
+
−        try:
+
−            i = fields.index(lookup_type) + 1
+
−        except ValueError:
+
−            sql = field_name
+
−        else:
+
−            format_str = ''.join([f for f in format[:i]] + [f for f in format_def[i:]])
+
−            sql = "CAST(DATE_FORMAT(%s, '%s') AS DATETIME)" % (field_name, format_str)
+
−        return sql
+
−
+
−    def drop_foreignkey_sql(self):
+
−        return "DROP FOREIGN KEY"
+
−
+
−    def fulltext_search_sql(self, field_name):
+
−        return 'MATCH (%s) AGAINST (%%s IN BOOLEAN MODE)' % field_name
+
−
+
−    def no_limit_value(self):
+
−        # 2**64 - 1, as recommended by the MySQL documentation
+
−        return 18446744073709551615L
+
−
+
−    def quote_name(self, name):
+
−        if name.startswith("`") and name.endswith("`"):
+
−            return name # Quoting once is enough.
+
−        return "`%s`" % name
+
−
+
−    def random_function_sql(self):
+
−        return 'RAND()'
+
−
+
−    def sql_flush(self, style, tables, sequences):
+
−        # NB: The generated SQL below is specific to MySQL
+
−        # 'TRUNCATE x;', 'TRUNCATE y;', 'TRUNCATE z;'... style SQL statements
+
−        # to clear all tables of all data
+
−        if tables:
+
−            sql = ['SET FOREIGN_KEY_CHECKS = 0;']
+
−            for table in tables:
+
−                sql.append('%s %s;' % (style.SQL_KEYWORD('TRUNCATE'), style.SQL_FIELD(self.quote_name(table))))
+
−            sql.append('SET FOREIGN_KEY_CHECKS = 1;')
+
−
+
−            # 'ALTER TABLE table AUTO_INCREMENT = 1;'... style SQL statements
+
−            # to reset sequence indices
+
−            sql.extend(["%s %s %s %s %s;" % \
+
−                (style.SQL_KEYWORD('ALTER'),
+
−                 style.SQL_KEYWORD('TABLE'),
+
−                 style.SQL_TABLE(self.quote_name(sequence['table'])),
+
−                 style.SQL_KEYWORD('AUTO_INCREMENT'),
+
−                 style.SQL_FIELD('= 1'),
+
−                ) for sequence in sequences])
+
−            return sql
+
−        else:
+
−            return []
+
−
+
−    def value_to_db_datetime(self, value):
+
−        if value is None:
+
−            return None
+
−        
+
−        # MySQL doesn't support tz-aware datetimes
+
−        if value.tzinfo is not None:
+
−            raise ValueError("MySQL backend does not support timezone-aware datetimes.")
+
−
+
−        # MySQL doesn't support microseconds
+
−        return unicode(value.replace(microsecond=0))
+
−
+
−    def value_to_db_time(self, value):
+
−        if value is None:
+
−            return None
+
−            
+
−        # MySQL doesn't support tz-aware datetimes
+
−        if value.tzinfo is not None:
+
−            raise ValueError("MySQL backend does not support timezone-aware datetimes.")
+
−        
+
−        # MySQL doesn't support microseconds
+
−        return unicode(value.replace(microsecond=0))
+
−
+
−    def year_lookup_bounds(self, value):
+
−        # Again, no microseconds
+
−        first = '%s-01-01 00:00:00'
+
−        second = '%s-12-31 23:59:59.99'
+
−        return [first % value, second % value]
+
−
+
−class DatabaseWrapper(BaseDatabaseWrapper):
+
−
+
−    operators = {
+
−        'exact': '= %s',
+
−        'iexact': 'LIKE %s',
+
−        'contains': 'LIKE BINARY %s',
+
−        'icontains': 'LIKE %s',
+
−        'regex': 'REGEXP BINARY %s',
+
−        'iregex': 'REGEXP %s',
+
−        'gt': '> %s',
+
−        'gte': '>= %s',
+
−        'lt': '< %s',
+
−        'lte': '<= %s',
+
−        'startswith': 'LIKE BINARY %s',
+
−        'endswith': 'LIKE BINARY %s',
+
−        'istartswith': 'LIKE %s',
+
−        'iendswith': 'LIKE %s',
+
−    }
+
−
+
−    def __init__(self, **kwargs):
+
−        super(DatabaseWrapper, self).__init__(**kwargs)
+
−        self.server_version = None
+
−
+
−        self.features = DatabaseFeatures()
+
−        self.ops = DatabaseOperations()
+
−        self.client = DatabaseClient()
+
−        self.creation = DatabaseCreation(self)
+
−        self.introspection = DatabaseIntrospection(self)
+
−        self.validation = DatabaseValidation()
+
−
+
−    def _valid_connection(self):
+
−        if self.connection is not None:
+
−            try:
+
−                self.connection.ping()
+
−                return True
+
−            except DatabaseError:
+
−                self.connection.close()
+
−                self.connection = None
+
−        return False
+
−
+
−    def _cursor(self, settings):
+
−        if not self._valid_connection():
+
−            kwargs = {
+
−                'conv': django_conversions,
+
−                'charset': 'utf8',
+
−                'use_unicode': True,
+
−            }
+
−            if settings.DATABASE_USER:
+
−                kwargs['user'] = settings.DATABASE_USER
+
−            if settings.DATABASE_NAME:
+
−                kwargs['db'] = settings.DATABASE_NAME
+
−            if settings.DATABASE_PASSWORD:
+
−                kwargs['passwd'] = settings.DATABASE_PASSWORD
+
−            if settings.DATABASE_HOST.startswith('/'):
+
−                kwargs['unix_socket'] = settings.DATABASE_HOST
+
−            elif settings.DATABASE_HOST:
+
−                kwargs['host'] = settings.DATABASE_HOST
+
−            if settings.DATABASE_PORT:
+
−                kwargs['port'] = int(settings.DATABASE_PORT)
+
−            kwargs.update(self.options)
+
−            self.connection = Database.connect(**kwargs)
+
−        cursor = CursorWrapper(self.connection.cursor())
+
−        return cursor
+
−
+
−    def _rollback(self):
+
−        try:
+
−            BaseDatabaseWrapper._rollback(self)
+
−        except Database.NotSupportedError:
+
−            pass
+
−
+
−    def get_server_version(self):
+
−        if not self.server_version:
+
−            if not self._valid_connection():
+
−                self.cursor()
+
−            m = server_version_re.match(self.connection.get_server_info())
+
−            if not m:
+
−                raise Exception('Unable to determine MySQL version from version string %r' % self.connection.get_server_info())
+
−            self.server_version = tuple([int(x) for x in m.groups()])
+
−        return self.server_version