216 lines
8.1 KiB
Python
216 lines
8.1 KiB
Python
"""
|
|
MySQL database backend for Django.
|
|
|
|
Requires MySQLdb: http://sourceforge.net/projects/mysql-python
|
|
"""
|
|
|
|
from django.db.backends import BaseDatabaseWrapper, BaseDatabaseFeatures, BaseDatabaseOperations, util
|
|
from django.utils.encoding import force_unicode
|
|
try:
|
|
import MySQLdb as Database
|
|
except ImportError, e:
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
raise ImproperlyConfigured("Error loading MySQLdb module: %s" % e)
|
|
from MySQLdb.converters import conversions
|
|
from MySQLdb.constants import FIELD_TYPE
|
|
import types
|
|
import re
|
|
|
|
DatabaseError = Database.DatabaseError
|
|
IntegrityError = Database.IntegrityError
|
|
|
|
django_conversions = conversions.copy()
|
|
django_conversions.update({
|
|
types.BooleanType: util.rev_typecast_boolean,
|
|
FIELD_TYPE.DATETIME: util.typecast_timestamp,
|
|
FIELD_TYPE.DATE: util.typecast_date,
|
|
FIELD_TYPE.TIME: util.typecast_time,
|
|
FIELD_TYPE.DECIMAL: util.typecast_decimal,
|
|
FIELD_TYPE.STRING: force_unicode,
|
|
FIELD_TYPE.VAR_STRING: force_unicode,
|
|
# Note: We don't add a convertor for BLOB here. Doesn't seem to be required.
|
|
})
|
|
|
|
# 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})')
|
|
|
|
# This is an extra debug layer over MySQL queries, to display warnings.
|
|
# It's only used when DEBUG=True.
|
|
class MysqlDebugWrapper:
|
|
def __init__(self, cursor):
|
|
self.cursor = cursor
|
|
|
|
def execute(self, sql, params=()):
|
|
try:
|
|
return self.cursor.execute(sql, params)
|
|
except Database.Warning, w:
|
|
self.cursor.execute("SHOW WARNINGS")
|
|
raise Database.Warning("%s: %s" % (w, self.cursor.fetchall()))
|
|
|
|
def executemany(self, sql, param_list):
|
|
try:
|
|
return self.cursor.executemany(sql, param_list)
|
|
except Database.Warning, w:
|
|
self.cursor.execute("SHOW WARNINGS")
|
|
raise Database.Warning("%s: %s" % (w, self.cursor.fetchall()))
|
|
|
|
def __getattr__(self, attr):
|
|
if attr in self.__dict__:
|
|
return self.__dict__[attr]
|
|
else:
|
|
return getattr(self.cursor, attr)
|
|
|
|
class DatabaseFeatures(BaseDatabaseFeatures):
|
|
autoindexes_primary_keys = False
|
|
|
|
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 limit_offset_sql(self, limit, offset=None):
|
|
# 'LIMIT 20,40'
|
|
sql = "LIMIT "
|
|
if offset and offset != 0:
|
|
sql += "%s," % offset
|
|
return sql + str(limit)
|
|
|
|
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 []
|
|
|
|
class DatabaseWrapper(BaseDatabaseWrapper):
|
|
features = DatabaseFeatures()
|
|
ops = DatabaseOperations()
|
|
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
|
|
|
|
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 = {
|
|
# Note: use_unicode intentonally not set to work around some
|
|
# backwards-compat issues. We do it manually.
|
|
'user': settings.DATABASE_USER,
|
|
'db': settings.DATABASE_NAME,
|
|
'passwd': settings.DATABASE_PASSWORD,
|
|
'conv': django_conversions,
|
|
}
|
|
if settings.DATABASE_HOST.startswith('/'):
|
|
kwargs['unix_socket'] = settings.DATABASE_HOST
|
|
else:
|
|
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 = self.connection.cursor()
|
|
if self.connection.get_server_info() >= '4.1' and not self.connection.character_set_name().startswith('utf8'):
|
|
if hasattr(self.connection, 'charset'):
|
|
# MySQLdb < 1.2.1 backwards-compat hacks.
|
|
conn = self.connection
|
|
cursor.execute("SET NAMES 'utf8'")
|
|
cursor.execute("SET CHARACTER SET 'utf8'")
|
|
to_str = lambda u, dummy=None, c=conn: c.literal(u.encode('utf-8'))
|
|
conn.converter[unicode] = to_str
|
|
else:
|
|
self.connection.set_character_set('utf8')
|
|
else:
|
|
cursor = self.connection.cursor()
|
|
return cursor
|
|
|
|
def make_debug_cursor(self, cursor):
|
|
return BaseDatabaseWrapper.make_debug_cursor(self, MysqlDebugWrapper(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
|