OracleBranch: django-oracle-rev5046.diff

django/db/backends/mysql/base.py

@@ -131 +131 @@
             self.server_version = tuple([int(x) for x in m.groups()])
         return self.server_version
 
+
+
+
+
+
 supports_constraints = True
+
+
 
 def quote_name(name):
     if name.startswith("`") and name.endswith("`"):
@@ -164 +171 @@
         sql = "CAST(DATE_FORMAT(%s, '%s') AS DATETIME)" % (field_name, format_str)
     return sql
 
+
+
+
 def get_limit_offset_sql(limit, offset=None):
     sql = "LIMIT "
     if offset and offset != 0:
@@ -185 +195 @@
 def get_pk_default_value():
     return "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

django/db/backends/ado_mssql/base.py

@@ -88 +88 @@
             self.connection.close()
             self.connection = None
 
+
+
+
+
+
 supports_constraints = True
+
+
 
 def quote_name(name):
     if name.startswith('[') and name.endswith(']'):
@@ -116 +123 @@
     if lookup_type=='day':
         return "Convert(datetime, Convert(varchar(12), %s))" % field_name
 
+
+
+
 def get_limit_offset_sql(limit, offset=None):
     # TODO: This is a guess. Make sure this is correct.
     sql = "LIMIT %s" % limit
@@ -138 +148 @@
 def get_pk_default_value():
     return "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

django/db/backends/postgresql/base.py

@@ -104 +104 @@
             self.connection.close()
             self.connection = None
 
+
+
+
+
+
 supports_constraints = True
+
+
 
 def quote_name(name):
     if name.startswith('"') and name.endswith('"'):
@@ -137 +144 @@
     # http://www.postgresql.org/docs/8.0/static/functions-datetime.html#FUNCTIONS-DATETIME-TRUNC
     return "DATE_TRUNC('%s', %s)" % (lookup_type, field_name)
 
+
+
+
 def get_limit_offset_sql(limit, offset=None):
     sql = "LIMIT %s" % limit
     if offset and offset != 0:
@@ -158 +168 @@
 def get_pk_default_value():
     return "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

django/db/backends/sqlite3/base.py

@@ -99 +99 @@
     def convert_query(self, query, num_params):
         return query % tuple("?" * num_params)
 
+
+
+
+
+
 supports_constraints = False
+
+
 
 def quote_name(name):
     if name.startswith('"') and name.endswith('"'):
@@ -131 +138 @@
     # sqlite doesn't support DATE_TRUNC, so we fake it as above.
     return 'django_date_trunc("%s", %s)' % (lookup_type.lower(), field_name)
 
+
+
+
 def get_limit_offset_sql(limit, offset=None):
     sql = "LIMIT %s" % limit
     if offset and offset != 0:
@@ -152 +162 @@
 def get_pk_default_value():
     return "NULL"
 
+
+
+
+
+
+
+
+
+
 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

django/db/backends/util.py

@@ -1 +1 @@
 import datetime
+
 from time import time
 
 class CursorDebugWrapper(object):
@@ -92 +93 @@
 def rev_typecast_boolean(obj, d):
     return obj and '1' or '0'
 
+
+
+
+
+
+
+
+
+
+
 ##################################################################################
 # Helper functions for dictfetch* for databases that don't natively support them #
 ##################################################################################

django/db/backends/oracle/base.py

@@ -4 +4 @@
 Requires cx_Oracle: http://www.python.net/crew/atuining/cx_Oracle/
 """
 
+
 from django.db.backends import util
 try:
     import cx_Oracle as Database
 except ImportError, e:
     from django.core.exceptions import ImproperlyConfigured
     raise ImproperlyConfigured, "Error loading cx_Oracle module: %s" % e
+
+
 
+
 DatabaseError = Database.Error
 
 try:
@@ -30 +34 @@
         return self.connection is not None
 
     def cursor(self):
-        from django.conf import settings
         if not self._valid_connection():
             if len(settings.DATABASE_HOST.strip()) == 0:
                 settings.DATABASE_HOST = 'localhost'
@@ -40 +43 @@
             else:
                 conn_string = "%s/%s@%s" % (settings.DATABASE_USER, settings.DATABASE_PASSWORD, settings.DATABASE_NAME)
                 self.connection = Database.connect(conn_string, **self.options)
-        return FormatStylePlaceholderCursor(self.connection)
+        cursor = FormatStylePlaceholderCursor(self.connection)
+        # default arraysize of 1 is highly sub-optimal
+        cursor.arraysize = 100
+        # set oracle date to ansi date format
+        cursor.execute("ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD'")
+        cursor.execute("ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'")
+        if settings.DEBUG:
+            return util.CursorDebugWrapper(cursor, self)
+        return cursor
 
     def _commit(self):
         if self.connection is not None:
-            self.connection.commit()
+            self.connection.commit()
 
     def _rollback(self):
         if self.connection is not None:
-            try:
-                self.connection.rollback()
-            except Database.NotSupportedError:
-                pass
+            return self.connection.rollback()
 
     def close(self):
         if self.connection is not None:
             self.connection.close()
             self.connection = None
 
+
+
+
+
+
 supports_constraints = True
+
+
 
 class FormatStylePlaceholderCursor(Database.Cursor):
     """
@@ -66 +81 @@
     This fixes it -- but note that if you want to use a literal "%s" in a query,
     you'll need to use "%%s".
     """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     def execute(self, query, params=None):
-        if params is None: params = []
-        query = self.convert_arguments(query, len(params))
+        query, params = self._rewrite_args(query, params)
         return Database.Cursor.execute(self, query, params)
 
     def executemany(self, query, params=None):
-        if params is None: params = []
-        query = self.convert_arguments(query, len(params[0]))
+        query, params = self._rewrite_args(query, params)
         return Database.Cursor.executemany(self, query, params)
 
-    def convert_arguments(self, query, num_params):
-        # replace occurances of "%s" with ":arg" - Oracle requires colons for parameter placeholders.
-        args = [':arg' for i in range(num_params)]
-        return query % tuple(args)
-
 def quote_name(name):
-    return name
+    # SQL92 requires delimited (quoted) names to be case-sensitive.  When
+    # not quoted, Oracle has case-insensitive behavior for identifiers, but
+    # always defaults to uppercase.
+    # We simplify things by making Oracle identifiers always uppercase.
+    if not name.startswith('"') and not name.endswith('"'):
+        name = '"%s"' % util.truncate_name(name.upper(), get_max_name_length())
+    return name.upper()
 
 dictfetchone = util.dictfetchone
 dictfetchmany = util.dictfetchmany
 dictfetchall  = util.dictfetchall
 
 def get_last_insert_id(cursor, table_name, pk_name):
-    query = "SELECT %s_sq.currval from dual" % table_name
-    cursor.execute(query)
+    
+    cursor.execute()
     return cursor.fetchone()[0]
 
 def get_date_extract_sql(lookup_type, table_name):
     # lookup_type is 'year', 'month', 'day'
-    # http://www.psoug.org/reference/date_func.html
+    # http://
     return "EXTRACT(%s FROM %s)" % (lookup_type, table_name)
 
 def get_date_trunc_sql(lookup_type, field_name):
-    return "EXTRACT(%s FROM TRUNC(%s))" % (lookup_type, field_name)
+    # lookup_type is 'year', 'month', 'day'
+    # Oracle uses TRUNC() for both dates and numbers.
+    # http://download-east.oracle.com/docs/cd/B10501_01/server.920/a96540/functions155a.htm#SQLRF06151
+    if lookup_type == 'day':
+        sql = 'TRUNC(%s)' % (field_name,)
+    else:
+        sql = "TRUNC(%s, '%s')" % (field_name, lookup_type)
+    return sql
 
+
+
+
 def get_limit_offset_sql(limit, offset=None):
     # Limits and offset are too complicated to be handled here.
-    # Instead, they are handled in django/db/query.py.
-    pass
+    # Instead, they are handled in django/db/query.py.
+    
 
 def get_random_function_sql():
     return "DBMS_RANDOM.RANDOM"
@@ -116 +158 @@
     raise NotImplementedError
 
 def get_drop_foreignkey_sql():
-    return "DROP FOREIGN KEY"
+    return "DROP "
 
 def get_pk_default_value():
     return "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
     """
-    # Return a list of 'TRUNCATE x;', 'TRUNCATE y;', 'TRUNCATE z;'... style SQL statements
-    # TODO - SQL not actually tested against Oracle yet!
-    # TODO - autoincrement indices reset required? See other get_sql_flush() implementations
-    sql = ['%s %s;' % \
-            (style.SQL_KEYWORD('TRUNCATE'),
+    # Return a list of 'TRUNCATE x;', 'TRUNCATE y;',
+    # 'TRUNCATE z;'... style SQL statements
+    if tables:
+        # Oracle does support TRUNCATE, but it seems to get us into
+        # FK referential trouble, whereas DELETE FROM table works.
+        sql = ['%s %s %s;' % \
+                (style.SQL_KEYWORD('DELETE'),
+                 style.SQL_KEYWORD('FROM'),
              style.SQL_FIELD(quote_name(table))
              )  for table in tables]
+
+
+
+
+
+
+
+
+
+
+
 
+
+
+
+
 def get_sql_sequence_reset(style, model_list):
     "Returns a list of the SQL statements to reset sequences for the given models."
-    # No sequence reset required
-    return []
+    from django.db import models
+    output = []
+    query = _get_sequence_reset_sql()
+    for model in model_list:
+        for f in model._meta.fields:
+            if isinstance(f, models.AutoField):
+                sequence_name = get_sequence_name(model._meta.db_table)
+                output.append(query % {'sequence':sequence_name,
+                                       'table':model._meta.db_table})
+                break # Only one AutoField is allowed per model, so don't bother continuing.
+        for f in model._meta.many_to_many:
+            sequence_name = get_sequence_name(f.m2m_db_table())
+            output.append(query % {'sequence':sequence_name,
+                                   'table':f.m2m_db_table()})
+    return output
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 OPERATOR_MAPPING = {
     'exact': '= %s',
-    'iexact': 'LIKE %s',
-    'contains': 'LIKE %s',
-    'icontains': 'LIKE %s',
+    'iexact': '',
+    'contains': ,
+    'icontains': ,
     'gt': '> %s',
     'gte': '>= %s',
     'lt': '< %s',
     'lte': '<= %s',
-    'startswith': 'LIKE %s',
-    'endswith': 'LIKE %s',
-    'istartswith': 'LIKE %s',
-    'iendswith': 'LIKE %s',
+    'startswith': ,
+    'endswith': ,
+    'istartswith': ,
+    'iendswith': ,
 }

django/db/backends/oracle/client.py

@@ -2 +2 @@
 import os
 
 def runshell():
-    args = ''
-    args += settings.DATABASE_USER
+    dsn = settings.DATABASE_USER
     if settings.DATABASE_PASSWORD:
-        args += "/%s" % settings.DATABASE_PASSWORD
-    args += "@%s" % settings.DATABASE_NAME
-    os.execvp('sqlplus', args)
+        dsn += "/%s" % settings.DATABASE_PASSWORD
+    if settings.DATABASE_NAME:
+        dsn += "@%s" % settings.DATABASE_NAME
+    args = ["sqlplus", "-L", dsn]
+    os.execvp("sqlplus", args)

django/db/backends/oracle/introspection.py

@@ +1 @@
+
 import re
+
 
+
 foreign_key_re = re.compile(r"\sCONSTRAINT `[^`]*` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)` \(`([^`]*)`\)")
 
 def get_table_list(cursor):
     "Returns a list of table names in the current database."
     cursor.execute("SELECT TABLE_NAME FROM USER_TABLES")
-    return [row[0] for row in cursor.fetchall()]
+    return [row[0] for row in cursor.fetchall()]
 
 def get_table_description(cursor, table_name):
-    return table_name
+    "Returns a description of the table, with the DB-API cursor.description interface."
+    cursor.execute("SELECT * FROM %s WHERE ROWNUM < 2" % quote_name(table_name))
+    return cursor.description
 
 def _name_to_index(cursor, table_name):
     """
@@ -22 +27 @@
     Returns a dictionary of {field_index: (field_index_other_table, other_table)}
     representing all relationships to the given table. Indexes are 0-based.
     """
-    raise NotImplementedError
+    cursor.execute("""
+SELECT ta.column_id - 1, tb.table_name, tb.column_id - 1
+FROM   user_constraints, USER_CONS_COLUMNS ca, USER_CONS_COLUMNS cb,
+       user_tab_cols ta, user_tab_cols tb
+WHERE  user_constraints.table_name = %s AND
+       ta.table_name = %s AND
+       ta.column_name = ca.column_name AND
+       ca.table_name = %s AND
+       user_constraints.constraint_name = ca.constraint_name AND
+       user_constraints.r_constraint_name = cb.constraint_name AND
+       cb.table_name = tb.table_name AND
+       cb.column_name = tb.column_name AND
+       ca.position = cb.position""", [table_name, table_name, table_name])
 
+
+
+
+
+
 def get_indexes(cursor, table_name):
     """
     Returns a dictionary of fieldname -> infodict for the given table,
@@ -31 +53 @@
         {'primary_key': boolean representing whether it's the primary key,
          'unique': boolean representing whether it's a unique index}
     """
-    raise NotImplementedError
+    # This query retrieves each index on the given table, including the
+    # first associated field name
+    # "We were in the nick of time; you were in great peril!"
+    sql = """
+WITH primarycols AS (
+ SELECT user_cons_columns.table_name, user_cons_columns.column_name, 1 AS PRIMARYCOL
+ FROM   user_cons_columns, user_constraints
+ WHERE  user_cons_columns.constraint_name = user_constraints.constraint_name AND
+        user_constraints.constraint_type = 'P' AND
+        user_cons_columns.table_name = %s),
+ uniquecols AS (
+ SELECT user_ind_columns.table_name, user_ind_columns.column_name, 1 AS UNIQUECOL
+ FROM   user_indexes, user_ind_columns
+ WHERE  uniqueness = 'UNIQUE' AND
+        user_indexes.index_name = user_ind_columns.index_name AND
+        user_ind_columns.table_name = %s)
+SELECT allcols.column_name, primarycols.primarycol, uniquecols.UNIQUECOL
+FROM   (SELECT column_name FROM primarycols UNION SELECT column_name FROM
+uniquecols) allcols,
+      primarycols, uniquecols
+WHERE  allcols.column_name = primarycols.column_name (+) AND
+      allcols.column_name = uniquecols.column_name (+)
+    """
+    cursor.execute(sql, [table_name, table_name])
+    indexes = {}
+    for row in cursor.fetchall():
+        # row[1] (idx.indkey) is stored in the DB as an array. It comes out as
+        # a string of space-separated integers. This designates the field
+        # indexes (1-based) of the fields that have indexes on the table.
+        # Here, we skip any indexes across multiple fields.
+        indexes[row[0]] = {'primary_key': row[1], 'unique': row[2]}
+    return indexes
 
-# Maps type codes to Django Field types.
+# Maps type s to Django Field types.
 DATA_TYPES_REVERSE = {
-    16: 'BooleanField',
-    21: 'SmallIntegerField',
-    23: 'IntegerField',
-    25: 'TextField',
-    869: 'IPAddressField',
-    1043: 'CharField',
-    1082: 'DateField',
-    1083: 'TimeField',
-    1114: 'DateTimeField',
-    1184: 'DateTimeField',
-    1266: 'TimeField',
-    1700: 'FloatField',
+    cx_Oracle.CLOB: 'TextField',
+    cx_Oracle.DATETIME: 'DateTimeField',
+    cx_Oracle.FIXED_CHAR: 'CharField',
+    cx_Oracle.NCLOB: 'TextField',
+    cx_Oracle.NUMBER: 'FloatField',
+    cx_Oracle.STRING: 'TextField',
+    cx_Oracle.TIMESTAMP: 'DateTimeField',
 }

django/db/backends/oracle/creation.py

@@ +1 @@
+
+
+
+
+
+
+
 DATA_TYPES = {
-    'AutoField':         'number(38)',
-    'BooleanField':      'number(1)',
-    'CharField':         'varchar2(%(maxlength)s)',
-    'CommaSeparatedIntegerField': 'varchar2(%(maxlength)s)',
-    'DateField':         'date',
-    'DateTimeField':     'date',
-    'FileField':         'varchar2(100)',
-    'FilePathField':     'varchar2(100)',
-    'FloatField':        'number(%(max_digits)s, %(decimal_places)s)',
-    'ImageField':        'varchar2(100)',
-    'IntegerField':      'integer',
-    'IPAddressField':    'char(15)',
+    'AutoField':         )',
+    'BooleanField':      )',
+    'CharField':         2(%(maxlength)s)',
+    'CommaSeparatedIntegerField': 2(%(maxlength)s)',
+    'DateField':         ',
+    'DateTimeField':     ',
+    'FileField':         2(100)',
+    'FilePathField':     2(100)',
+    'FloatField':        (%(max_digits)s, %(decimal_places)s)',
+    'ImageField':        2(100)',
+    'IntegerField':      ',
+    'IPAddressField':    (15)',
     'ManyToManyField':   None,
-    'NullBooleanField':  'integer',
-    'OneToOneField':     'integer',
-    'PhoneNumberField':  'varchar(20)',
-    'PositiveIntegerField': 'integer',
-    'PositiveSmallIntegerField': 'smallint',
-    'SlugField':         'varchar(50)',
-    'SmallIntegerField': 'smallint',
-    'TextField':         'long',
-    'TimeField':         'timestamp',
-    'USStateField':      'varchar(2)',
+    'NullBooleanField':             'NUMBER(1) CHECK ((%(column)s IN (0,1)) OR (%(column)s IS NULL))',
+    'OneToOneField':                'NUMBER(11)',
+    'PhoneNumberField':             'VARCHAR2(20)',
+    'PositiveIntegerField':         'NUMBER(11) CHECK (%(column)s >= 0)',
+    'PositiveSmallIntegerField':    'NUMBER(11) CHECK (%(column)s >= 0)',
+    'SlugField':                    'VARCHAR2(50)',
+    'SmallIntegerField':            'NUMBER(11)',
+    'TextField':                    'NCLOB',
+    'TimeField':                    'TIMESTAMP',
+    'URLField':                     'VARCHAR2(200)',
+    'USStateField':                 'CHAR(2)',
 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/db/backends/postgresql_psycopg2/base.py

@@ -72 +72 @@
             self.connection.close()
             self.connection = None
 
+
+
+
+
+
 supports_constraints = True
+
+
 
 def quote_name(name):
     if name.startswith('"') and name.endswith('"'):
@@ -97 +104 @@
     # http://www.postgresql.org/docs/8.0/static/functions-datetime.html#FUNCTIONS-DATETIME-TRUNC
     return "DATE_TRUNC('%s', %s)" % (lookup_type, field_name)
 
+
+
+
 def get_limit_offset_sql(limit, offset=None):
     sql = "LIMIT %s" % limit
     if offset and offset != 0:
@@ -118 +128 @@
 def get_pk_default_value():
     return "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

django/db/backends/dummy/base.py

@@ -27 +27 @@
         pass # close()
 
 supports_constraints = False
+
 quote_name = complain
 dictfetchone = complain
 dictfetchmany = complain

django/db/models/base.py

@@ -210 +210 @@
         record_exists = True
         if pk_set:
             # Determine whether a record with the primary key already exists.
-            cursor.execute("SELECT 1 FROM %s WHERE %s=%%s LIMIT 1" % \
+            cursor.execute("SELECT " % \
                 (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)), [pk_val])
             # If it does already exist, do an UPDATE.
-            if cursor.fetchone():
+            if cursor.fetchone():
                 db_values = [f.get_db_prep_save(f.pre_save(self, False)) for f in non_pks]
                 if db_values:
                     cursor.execute("UPDATE %s SET %s WHERE %s=%%s" % \

django/db/models/options.py

@@ -13 +13 @@
 
 DEFAULT_NAMES = ('verbose_name', 'db_table', 'ordering',
                  'unique_together', 'permissions', 'get_latest_by',
-                 'order_with_respect_to', 'app_label')
+                 'order_with_respect_to', 'app_label')
 
 class Options(object):
     def __init__(self, meta):
@@ -27 +27 @@
         self.object_name, self.app_label = None, None
         self.get_latest_by = None
         self.order_with_respect_to = None
+
         self.admin = None
         self.meta = meta
         self.pk = None
@@ -59 +60 @@
         del self.meta
 
     def _prepare(self, model):
+
+
         if self.order_with_respect_to:
             self.order_with_respect_to = self.get_field(self.order_with_respect_to)
             self.ordering = ('_order',)
@@ -73 +76 @@
         # If the db_table wasn't provided, use the app_label + module_name.
         if not self.db_table:
             self.db_table = "%s_%s" % (self.app_label, self.module_name)
+
+
 
     def add_field(self, field):
         # Insert the given field in the order in which it was created, using

django/db/models/fields/__init__.py

@@ -70 +70 @@
         core=False, rel=None, default=NOT_PROVIDED, editable=True, serialize=True,
         prepopulate_from=None, unique_for_date=None, unique_for_month=None,
         unique_for_year=None, validator_list=None, choices=None, radio_admin=None,
-        help_text='', db_column=None):
+        help_text='', db_column=None):
         self.name = name
         self.verbose_name = verbose_name
         self.primary_key = primary_key
@@ -87 +87 @@
         self.radio_admin = radio_admin
         self.help_text = help_text
         self.db_column = db_column
+
 
         # Set db_index to True if the field has a relationship and doesn't explicitly set db_index.
         self.db_index = db_index
@@ -161 +162 @@
 
     def get_db_prep_save(self, value):
         "Returns field's value prepared for saving into a database."
+
+
+
+
         return value
 
     def get_db_prep_lookup(self, lookup_type, value):
@@ -528 +533 @@
     def get_db_prep_save(self, value):
         # Casts dates into string format for entry into database.
         if value is not None:
-            # MySQL will throw a warning if microseconds are given, because it
-            # doesn't support microseconds.
-            if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'):
+            # MySQL
+            #  microseconds.
+            if settings.DATABASE_ENGINE  and hasattr(value, 'microsecond'):
                 value = value.replace(microsecond=0)
             value = str(value)
         return Field.get_db_prep_save(self, value)
 
     def get_db_prep_lookup(self, lookup_type, value):
+
+
+
+
         if lookup_type == 'range':
             value = [str(v) for v in value]
         else:
@@ -808 +817 @@
         Field.__init__(self, verbose_name, name, **kwargs)
 
     def get_db_prep_lookup(self, lookup_type, value):
+
+
+
+
+
+
+
+
         if lookup_type == 'range':
-            value = [str(v) for v in value]
+            value = [(v) for v in value]
         else:
-            value = str(value)
+            value = (value)
         return Field.get_db_prep_lookup(self, lookup_type, value)
 
     def pre_save(self, model_instance, add):
@@ -827 +844 @@
         if value is not None:
             # MySQL will throw a warning if microseconds are given, because it
             # doesn't support microseconds.
-            if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'):
+            if settings.DATABASE_ENGINE  and hasattr(value, 'microsecond'):
                 value = value.replace(microsecond=0)
+
+
+
+
+
+
+
             value = str(value)
         return Field.get_db_prep_save(self, value)
 

django/db/models/fields/related.py

@@ -335 +335 @@
                     (target_col_name, self.join_table, source_col_name,
                     target_col_name, ",".join(['%s'] * len(new_ids))),
                     [self._pk_val] + list(new_ids))
-                if cursor.rowcount is not None and cursor.rowcount != 0:
-                    existing_ids = set([row[0] for row in cursor.fetchmany(cursor.rowcount)])
-                else:
-                    existing_ids = set()
+                existing_ids = set([row[0] for row in cursor.fetchall()])
 
                 # Add the ones that aren't there already
                 for obj_id in (new_ids - existing_ids):

django/db/models/query.py

@@ -4 +4 @@
 from django.db.models import signals
 from django.dispatch import dispatcher
 from django.utils.datastructures import SortedDict
+
+
 import operator
 import re
 
@@ -77 +79 @@
     else:
         return backend.quote_name(word)
 
-class QuerySet(object):
+class QuerySet(object):
     "Represents a lazy database lookup for a set of objects"
     def __init__(self, model=None):
         self.model = model
@@ -181 +183 @@
 
         cursor = connection.cursor()
         cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params)
+
         fill_cache = self._select_related
-        index_end = len(self.model._meta.fields)
+        fields = self.model._meta.fields
+        index_end = len(fields)
+        has_resolve_columns = hasattr(self, 'resolve_columns')
         while 1:
             rows = cursor.fetchmany(GET_ITERATOR_CHUNK_SIZE)
             if not rows:
                 raise StopIteration
             for row in rows:
+
+
                 if fill_cache:
                     obj, index_end = get_cached_row(klass=self.model, row=row,
                                                     index_start=0, max_depth=self._max_related_depth)
@@ -551 +558 @@
 
         return select, " ".join(sql), params
 
+
+
+
+
+
+
 class ValuesQuerySet(QuerySet):
     def __init__(self, *args, **kwargs):
         super(ValuesQuerySet, self).__init__(*args, **kwargs)
@@ -566 +579 @@
 
         # self._fields is a list of field names to fetch.
         if self._fields:
-            columns = [self.model._meta.get_field(f, many_to_many=False).column for f in self._fields]
-            field_names = self._fields
+            fields = [self.model._meta.get_field(f, many_to_many=False) for f in self._fields]
         else: # Default to all fields.
-            columns = [f.column for f in self.model._meta.fields]
-            field_names = [f.attname for f in self.model._meta.fields]
+            fields = self.model._meta.fields
+        columns = [f.column for f in fields]
+        field_names = [f.attname for f in fields]
 
         select = ['%s.%s' % (backend.quote_name(self.model._meta.db_table), backend.quote_name(c)) for c in columns]
         cursor = connection.cursor()
         cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params)
+
+
         while 1:
             rows = cursor.fetchmany(GET_ITERATOR_CHUNK_SIZE)
             if not rows:
                 raise StopIteration
             for row in rows:
+
+
                 yield dict(zip(field_names, row))
 
     def _clone(self, klass=None, **kwargs):
@@ -590 +607 @@
 class DateQuerySet(QuerySet):
     def iterator(self):
         from django.db.backends.util import typecast_timestamp
+
         self._order_by = () # Clear this because it'll mess things up otherwise.
         if self._field.null:
             self._where.append('%s.%s IS NOT NULL' % \
                 (backend.quote_name(self.model._meta.db_table), backend.quote_name(self._field.column)))
-
         try:
             select, sql, params = self._get_sql_clause()
         except EmptyResultSet:
             raise StopIteration
 
-        sql = 'SELECT %s %s GROUP BY 1 ORDER BY 1 %s' % \
+        table_name = backend.quote_name(self.model._meta.db_table)
+        field_name = backend.quote_name(self._field.column)
+
+        if backend.allows_group_by_ordinal:
+            group_by = '1'
+        else:
+            group_by = backend.get_date_trunc_sql(self._kind,
+                                                  '%s.%s' % (table_name, field_name))
+
+        sql = 'SELECT %s %s GROUP BY %s ORDER BY 1 %s' % \
             (backend.get_date_trunc_sql(self._kind, '%s.%s' % (backend.quote_name(self.model._meta.db_table),
-            backend.quote_name(self._field.column))), sql, self._order)
+            backend.quote_name(self._field.column))), sql, self._order)
         cursor = connection.cursor()
         cursor.execute(sql, params)
-        # We have to manually run typecast_timestamp(str()) on the results, because
-        # MySQL doesn't automatically cast the result of date functions as datetime
-        # objects -- MySQL returns the values as strings, instead.
-        return [typecast_timestamp(str(row[0])) for row in cursor.fetchall()]
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     def _clone(self, klass=None, **kwargs):
         c = super(DateQuerySet, self)._clone(klass, **kwargs)
         c._field = self._field
@@ -716 +757 @@
     if table_prefix.endswith('.'):
         table_prefix = backend.quote_name(table_prefix[:-1])+'.'
     field_name = backend.quote_name(field_name)
+
+
+
+
+
+
+
+
     try:
-        return '%s%s %s' % (table_prefix, field_name, (backend.OPERATOR_MAPPING[lookup_type] % '%s'))
+        return format % (table_prefix, field_name,
+                         backend.OPERATOR_MAPPING[lookup_type] % cast_sql)
     except KeyError:
         pass
     if lookup_type == 'in':

django/core/management.py

@@ -55 +55 @@
 
 def _get_installed_models(table_list):
     "Gets a set of all models that are installed, given a list of existing tables"
-    from django.db import models
+    from django.db import models
     all_models = []
     for app in models.get_apps():
         for model in models.get_models(app):
             all_models.append(model)
-    return set([m for m in all_models if m._meta.db_table in table_list])
+    if backend.uses_case_insensitive_names:
+        converter = str.upper
+    else:
+        converter = lambda x: x
+    return set([m for m in all_models if converter(m._meta.db_table) in map(converter, table_list)])
 
 def _get_table_list():
     "Gets a list of all db tables that are physically installed."
@@ -104 +108 @@
 def get_sql_create(app):
     "Returns a list of the CREATE TABLE SQL statements for the given app."
     from django.db import get_creation_module, models
+
     data_types = get_creation_module().DATA_TYPES
 
     if not data_types:
@@ -173 +178 @@
             rel_field = f
             data_type = f.get_internal_type()
         col_type = data_types[data_type]
+
         if col_type is not None:
             # Make the definition (e.g. 'foo VARCHAR(30)') for this field.
             field_output = [style.SQL_FIELD(backend.quote_name(f.column)),
                 style.SQL_COLTYPE(col_type % rel_field.__dict__)]
             field_output.append(style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or '')))
-            if f.unique:
+            if f.unique:
                 field_output.append(style.SQL_KEYWORD('UNIQUE'))
             if f.primary_key:
                 field_output.append(style.SQL_KEYWORD('PRIMARY KEY'))
+
+
+
+
             if f.rel:
                 if f.rel.to in known_models:
                     field_output.append(style.SQL_KEYWORD('REFERENCES') + ' ' + \
@@ -205 +215 @@
     full_statement = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + style.SQL_TABLE(backend.quote_name(opts.db_table)) + ' (']
     for i, line in enumerate(table_output): # Combine and add commas.
         full_statement.append('    %s%s' % (line, i < len(table_output)-1 and ',' or ''))
-    full_statement.append(');')
+    full_statement.append(')')
+    if opts.db_tablespace and backend.supports_tablespaces:
+        full_statement.append(backend.get_tablespace_sql(opts.db_tablespace))
+    full_statement.append(';')
     final_output.append('\n'.join(full_statement))
 
+
+
+
+
+
+
+
     return final_output, pending_references
 
 def _get_sql_for_pending_references(model, pending_references):
@@ -215 +235 @@
     Get any ALTER TABLE statements to add constraints after the fact.
     """
     from django.db import backend, get_creation_module
+
     data_types = get_creation_module().DATA_TYPES
 
     final_output = []
@@ -227 +248 @@
                 r_col = f.column
                 table = opts.db_table
                 col = opts.get_field(f.rel.field_name).column
-                # For MySQL, r_name must be unique in the first 64 characters.
-                # So we are careful with character usage here.
-                r_name = '%s_refs_%s_%x' % (r_col, col, abs(hash((r_table, table))))
+                r_name = '%s_refs_%s_%s_%s' % (r_col, col, r_table, table)
                 final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)%s;' % \
-                    (backend.quote_name(r_table), r_name,
+                    (backend.quote_name(r_table), ,
                     backend.quote_name(r_col), backend.quote_name(table), backend.quote_name(col),
                     backend.get_deferrable_sql()))
             del pending_references[model]
@@ -247 +266 @@
     final_output = []
     for f in opts.many_to_many:
         if not isinstance(f.rel, GenericRel):
+
+
+
+
+
             table_output = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + \
                 style.SQL_TABLE(backend.quote_name(f.m2m_db_table())) + ' (']
-            table_output.append('    %s %s %s,' % \
+            table_output.append('    %s %s %s,' % \
                 (style.SQL_FIELD(backend.quote_name('id')),
                 style.SQL_COLTYPE(data_types['AutoField']),
-                style.SQL_KEYWORD('NOT NULL PRIMARY KEY')))
+                style.SQL_KEYWORD('NOT NULL PRIMARY KEY'),
+                tablespace_sql))
             table_output.append('    %s %s %s %s (%s)%s,' % \
                 (style.SQL_FIELD(backend.quote_name(f.m2m_column_name())),
                 style.SQL_COLTYPE(data_types[get_rel_data_type(opts.pk)] % opts.pk.__dict__),
@@ -267 +292 @@
                 style.SQL_TABLE(backend.quote_name(f.rel.to._meta.db_table)),
                 style.SQL_FIELD(backend.quote_name(f.rel.to._meta.pk.column)),
                 backend.get_deferrable_sql()))
-            table_output.append('    %s (%s, %s)' % \
+            table_output.append('    %s (%s, %s)' % \
                 (style.SQL_KEYWORD('UNIQUE'),
                 style.SQL_FIELD(backend.quote_name(f.m2m_column_name())),
-                style.SQL_FIELD(backend.quote_name(f.m2m_reverse_name()))))
-            table_output.append(');')
+                style.SQL_FIELD(backend.quote_name(f.m2m_reverse_name())),
+                tablespace_sql))
+            table_output.append(')')
+            if opts.db_tablespace and backend.supports_tablespaces:
+                # f.db_tablespace is only for indices, so ignore its value here.
+                table_output.append(backend.get_tablespace_sql(opts.db_tablespace))
+            table_output.append(';')
             final_output.append('\n'.join(table_output))
+
+
+
+
+
+
+
     return final_output
 
 def get_sql_delete(app):
     "Returns a list of the DROP TABLE SQL statements for the given app."
     from django.db import backend, connection, models, get_introspection_module
+
     introspection = get_introspection_module()
 
     # This should work even if a connection isn't available
@@ -291 +329 @@
         table_names = introspection.get_table_list(cursor)
     else:
         table_names = []
+
+
+
+
 
     output = []
 
@@ -300 +342 @@
     references_to_delete = {}
     app_models = models.get_models(app)
     for model in app_models:
-        if cursor and model._meta.db_table in table_names:
+        if cursor and  in table_names:
             # The table exists, so it needs to be dropped
             opts = model._meta
             for f in opts.fields:
@@ -310 +352 @@
             to_delete.add(model)
 
     for model in app_models:
-        if cursor and model._meta.db_table in table_names:
+        if cursor and  in table_names:
             # Drop the table now
             output.append('%s %s;' % (style.SQL_KEYWORD('DROP TABLE'),
                 style.SQL_TABLE(backend.quote_name(model._meta.db_table))))
@@ -320 +362 @@
                     col = f.column
                     r_table = model._meta.db_table
                     r_col = model._meta.get_field(f.rel.field_name).column
+
                     output.append('%s %s %s %s;' % \
                         (style.SQL_KEYWORD('ALTER TABLE'),
                         style.SQL_TABLE(backend.quote_name(table)),
                         style.SQL_KEYWORD(backend.get_drop_foreignkey_sql()),
-                        style.SQL_FIELD(backend.quote_name('%s_refs_%s_%x' % (col, r_col, abs(hash((table, r_table))))))))
+                        style.SQL_FIELD()))))
                 del references_to_delete[model]
+
+
 
     # Output DROP TABLE statements for many-to-many tables.
     for model in app_models:
         opts = model._meta
         for f in opts.many_to_many:
-            if cursor and f.m2m_db_table() in table_names:
+            if cursor and ) in table_names:
                 output.append("%s %s;" % (style.SQL_KEYWORD('DROP TABLE'),
                     style.SQL_TABLE(backend.quote_name(f.m2m_db_table()))))
+
+
 
+
     app_label = app_models[0]._meta.app_label
 
     # Close database connection explicitly, in case this output is being piped
@@ -429 +477 @@
 def get_sql_indexes_for_model(model):
     "Returns the CREATE INDEX SQL statements for a single model"
     from django.db import backend
+
     output = []
 
     for f in model._meta.fields:
-        if f.db_index:
+        if f.db_index:
             unique = f.unique and 'UNIQUE ' or ''
+
+
+
+
+
             output.append(
                 style.SQL_KEYWORD('CREATE %sINDEX' % unique) + ' ' + \
                 style.SQL_TABLE(backend.quote_name('%s_%s' % (model._meta.db_table, f.column))) + ' ' + \
                 style.SQL_KEYWORD('ON') + ' ' + \
                 style.SQL_TABLE(backend.quote_name(model._meta.db_table)) + ' ' + \
-                "(%s);" % style.SQL_FIELD(backend.quote_name(f.column))
+                "(%s)" % style.SQL_FIELD(backend.quote_name(f.column)) + \
+                "%s;" % tablespace_sql
             )
     return output
 
@@ -463 +518 @@
 
 def syncdb(verbosity=1, interactive=True):
     "Creates the database tables for all apps in INSTALLED_APPS whose tables haven't already been created."
-    from django.db import connection, transaction, models, get_creation_module
+    from django.db import connection, transaction, models, get_creation_module
     from django.conf import settings
 
     disable_termcolors()
@@ -486 +541 @@
     # Get a list of all existing database tables,
     # so we know what needs to be added.
     table_list = _get_table_list()
+
+
+
+
 
     # Get a list of already installed *models* so that references work right.
     seen_models = _get_installed_models(table_list)
@@ -500 +559 @@
             # Create the model's database table, if it doesn't already exist.
             if verbosity >= 2:
                 print "Processing %s.%s model" % (app_name, model._meta.object_name)
-            if model._meta.db_table in table_list:
+            if  in table_list:
                 continue
             sql, references = _get_sql_model_create(model, seen_models)
             seen_models.add(model)
@@ -512 +571 @@
                 print "Creating table %s" % model._meta.db_table
             for statement in sql:
                 cursor.execute(statement)
-            table_list.append(model._meta.db_table)
+            table_list.append()
 
     # Create the m2m tables. This must be done after all tables have been created
     # to ensure that all referred tables will exist.
@@ -830 +889 @@
         except NotImplementedError:
             indexes = {}
         for i, row in enumerate(introspection_module.get_table_description(cursor, table_name)):
-            att_name = row[0]
+            att_name = row[0]
             comment_notes = [] # Holds Field notes, to be displayed in a Python comment.
             extra_params = {}  # Holds Field parameters such as 'db_column'.
 
@@ -1621 +1680 @@
         if not mod_list:
             parser.print_usage_and_exit()
         if action not in NO_SQL_TRANSACTION:
-            print style.SQL_KEYWORD("BEGIN;")
+            from django.db import backend
+            if backend.get_start_transaction_sql():
+                print style.SQL_KEYWORD(backend.get_start_transaction_sql())
         for mod in mod_list:
             if action == 'reset':
                 output = action_mapping[action](mod, options.interactive)

django/contrib/admin/models.py

@@ -9 +9 @@
 
 class LogEntryManager(models.Manager):
     def log_action(self, user_id, content_type_id, object_id, object_repr, action_flag, change_message=''):
-        e = self.model(None, None, user_id, content_type_id, object_id, object_repr[:200], action_flag, change_message)
+        e = self.model(None, None, user_id, content_type_id, , object_repr[:200], action_flag, change_message)
         e.save()
 
 class LogEntry(models.Model):

django/test/utils.py

@@ -1 +1 @@
 import sys, time
 from django.conf import settings
-from django.db import connection, transaction, backend
+from django.db import connection, 
 from django.core import management
 from django.dispatch import dispatcher
 from django.test import signals
@@ -44 +44 @@
         connection.connection.set_isolation_level(0)
 
 def create_test_db(verbosity=1, autoclobber=False):
+
+
+
+
+
+
     if verbosity >= 1:
         print "Creating test database..."
     # If we're using SQLite, it's more convenient to test against an
@@ -92 +98 @@
     cursor = connection.cursor()
 
 def destroy_test_db(old_database_name, verbosity=1):
+
+
+
+
+
+
     # Unless we're using SQLite, remove the test database to clean up after
     # ourselves. Connect to the previous database (not the test database)
     # to do so, because it's not allowed to delete a database while being

docs/settings.txt

@@ -245 +245 @@
 Default: ``''`` (Empty string)
 
 Which database backend to use. Either ``'postgresql_psycopg2'``, 
-``'postgresql'``, ``'mysql'``,  ``'mysql_old'``, ``'sqlite3'`` or
-``'ado_mssql'``.
+``'postgresql'``, ``'mysql'``,  ``'mysql_old'``, ``'sqlite3'``
+``'ado_mssql'``.
 
 DATABASE_HOST
 -------------

docs/faq.txt

@@ -301 +301 @@
 
 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_ and `SQLite 3`_ are also supported.
+PostgreSQL fans, and MySQL__ are also supported.
 
 .. _Python: http://www.python.org/
 .. _Apache 2: http://httpd.apache.org/
@@ -310 +310 @@
 .. _PostgreSQL: http://www.postgresql.org/
 .. _MySQL: http://www.mysql.com/
 .. _`SQLite 3`: http://www.sqlite.org/
+
 
 Do I lose anything by using Python 2.3 versus newer Python versions, such as Python 2.5?
 ----------------------------------------------------------------------------------------

docs/install.txt

@@ -62 +62 @@
 
 * If you're using SQLite, you'll need pysqlite_. Use version 2.0.3 or higher.
 
+
+
 .. _PostgreSQL: http://www.postgresql.org/
 .. _MySQL: http://www.mysql.com/
 .. _Django's ticket system: http://code.djangoproject.com/report/1
@@ -71 +73 @@
 .. _SQLite: http://www.sqlite.org/
 .. _pysqlite: http://initd.org/tracker/pysqlite
 .. _MySQL backend: ../databases/
+
 
 Remove any old versions of Django
 =================================

tests/modeltests/datatypes/models.py

@@ +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+