""" $Id$

IBM DB2 database backend for Django

Requires PyDB2: http://sourceforge.net/projects/pydb2/
With this patch: http://sourceforge.net/tracker/index.php?func=detail&aid=1731609&group_id=67548&atid=518208
"""

from django.db.backends import util
import re
try:
	import DB2 as Database
except ImportError, e:
	from django.core.exceptions import ImproperlyConfigured
	raise ImproperlyConfigured, "Error loading DB2 python module: %s" % e

DatabaseError = Database.Error
IntegrityError = Database.IntegrityError

class Cursor(Database.Cursor):
	""" PyDB2 uses '?' as the parameter style. """
	def execute(self, stmt, *args):
		# TODO: HORRIBLE hacks.
		if stmt.find('CREATE') == 0:
			# DB2 doesn't want a 'lone' NULL (it's implied).
			stmt = re.sub('(?<!NOT) NULL', '', stmt)
		elif stmt.find('ALTER') == 0:
			# DB2 doesn't take a constraint name longer than 18 characters.
			cname = re.search(re.compile('(?<=CONSTRAINT )\w+'), stmt).group(0)
			stmt = stmt.replace(cname, cname[-18:])
		if args is not None and "%s" in stmt:
			stmt = stmt.replace("%s", "?")
		return Database.Cursor.execute(self, stmt, *args)

class Connection(Database.Connection):
	def cursor(self):
		return Cursor(self._db.cursor())

Database.connect = Connection

class DatabaseWrapper(object):
	def __init__(self, **kwargs):
		self.connection = None
		self.queries = []
		self.server_version = None
		self.options = kwargs
	
	def _valid_connection(self):
		return self.connection is not None
	
	def cursor(self):
		from django.conf import settings
		if self.connection is None:
			conn_dict = {}
			# A DB2 client is configured with nodes, and then with databases connected
			# to these nodes, I don't know if there is a way of specifying a complete
			# DSN with a hostname and port, the PyDB2 module shows no sign of this either.
			# So this DSN is actually the database name configured in the host's client instance.
			if settings.DATABASE_NAME == '':
				from django.core.exceptions import ImproperlyConfigured
				raise ImproperlyConfigured, "You need to specify DATABASE_NAME in your Django settings file."
			conn_dict['dsn'] = settings.DATABASE_NAME
			if settings.DATABASE_USER == '':
				from django.core.exceptions import ImproperlyConfigured
				raise ImproperlyConfigured, "You need to specify DATABASE_USER in your Django settings file."
			conn_dict['uid'] = settings.DATABASE_USER
			if settings.DATABASE_PASSWORD == '':
				from django.core.exceptions import ImproperlyConfigured
				raise ImproperlyConfigured, "You need to specify DATABASE_PASSWORD in your Django settings file."
			conn_dict['pwd'] = settings.DATABASE_PASSWORD
			# Just imitating others here, I haven't seen any "options" for DB2.
			conn_dict.update(self.options)
			self.connection = Database.connect(**conn_dict)
		return self.connection.cursor()
	
	def _commit(self):
		if self.connection is not None:
			return self.connection.commit()
	
	def _rollback(self):
		if self.connection is not None:
			return self.connection.rollback()
	
	def close(self):
		if self.connection is not None:
			self.connection.close()
			self.connection = None

supports_constraints = True
supports_compound_statements = True

def quote_name(name):
	# Unquoted DB2 names are automatically uppercased, which seems to be
	# the default on most databases I've seen so far, double quotes (") seem
	# to be used only for case sensitivity.
	# And, only values are quoted with single quotes, anything else throws an
	# error, so I strip them here.
	if name.startswith("'") and name.endswith("'"):
		return name.strip("'")
	return name

dictfetchone = util.dictfetchone
dictfetchmany = util.dictfetchmany
dictfetchall = util.dictfetchall

def get_last_insert_id(cursor, table_name, pk_name):
	# There is probably a 'better' way to do this.
	cursor.execute("SELECT MAX(%s) FROM %s" % (pk_name, table_name))
	return cursor.fetchone()[0]

def get_date_extract_sql(lookup_type, field_name):
	# lookup_type is 'year', 'month', 'day'
	if lookup_type == 'year':
		return "YEAR(%s)" % field_name
	elif lookup_type == 'month':
		return "MONTH(%s)" % field_name
	elif lookup_type == 'day':
		return "DAY(%s)" % field_name

def get_date_trunc_sql(lookup_type, field_name):
	# lookup_type is 'year', 'month', 'day'
	# Hard one. I have seen TRUNC_TIMESTAMP somewhere but is not present
	# in any of my databases.
	# Doesn't work 'directly' since the GROUP BY needs this as well, 
	# DB2 can't take "GROUP BY 1"
	if lookup_type == 'year':
		return "TIMESTAMP(DATE(%s -DAYOFYEAR(%s) DAYS +1 DAY),'00:00:00')" % (field_name, field_name)
	elif lookup_type == 'month':
		return "TIMESTAMP(DATE(%s -DAY(%s) DAYS +1 DAY),'00:00:00')" % (field_name, field_name)
	elif lookup_type == 'day':
		return "TIMESTAMP(DATE(%s),'00:00:00')" % field_name

def get_limit_offset_sql(limit, offset=None):
	# DB2 can only handle limit, not offset
	if offset != 0:
		#  Recommendation: don't do this on *large* databases or you'll suffer.
		return ""
	sql = "FETCH FIRST %s ROWS ONLY" % limit
	return sql

def get_random_function_sql():
	return "RAND()"

def get_deferrable_sql():
    return ""

def get_fulltext_search_sql(field_name):
	# DB2 has some nice extra packages that enables a CONTAINS() function,
	# but they're not available in my dbs.
	raise NotImplementedError

def get_drop_foreignkey_sql():
	# TODO
    return ""

def get_pk_default_value():
	return "WITH DEFAULT"

def get_sql_flush(style, tables, sequences):
	"""Return a list of SQL statements required to remove all data from
	all tables in the database (without actually removing the tables
	themselves) and put the database in an empty 'initial' state"""
	# Looks like DB2 can handle a TRUNCATE TABLE statement and there is no need to
	# disable constraints.
	if tables:
		sql = ['%s %s;' % \
			(style.SQL_KEYWORD('TRUNCATE TABLE'), 
			style.SQL_FIELD(table)) for table in tables]
		return sql
	else:
		return []

def get_sql_sequence_reset(style, model_list):
    '''Returns a list of the SQL statements to reset sequences for the given models.'''
    # TODO: No idea if it's needed, or if can be done at all.
    return []

OPERATOR_MAPPING = {
	'exact': "= %s",
	'iexact': "LIKE %s",
	'contains': "LIKE %s",
	'icontains': "LIKE %s",
	'gt': "> %s",
	'gte': ">= %s",
	'lt': "< %s",
	'lte': "<= %s",
	'startswith': "LIKE %s",
	'endswith': "LIKE %s",
	'istartswith': "LIKE %s",
	'iendswith': "LIKE %s",
}