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
-
+allows_group_by_ordinal = True
+allows_unique_and_pk = True
+autoindexes_primary_keys = False
+needs_datetime_string_cast = True     # MySQLdb requires a typecast for dates
+needs_upper_for_iops = False
-supports_constraints = True
+supports_tablespaces = False
+uses_case_insensitive_names = False
-
-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_datetime_cast_sql():
+    return None
+
-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_max_name_length():
+    return 64;
+
+def get_start_transaction_sql():
+    return "BEGIN;"
+
+def get_autoinc_sql(table):
+    return None
+
-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
-
+allows_group_by_ordinal = True
+allows_unique_and_pk = True
+autoindexes_primary_keys = True
+needs_datetime_string_cast = True
+needs_upper_for_iops = False
-supports_constraints = True
+supports_tablespaces = True
+uses_case_insensitive_names = False
-
-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_datetime_cast_sql():
+    return None
+
-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_max_name_length():
+    return None
+
+def get_start_transaction_sql():
+    return "BEGIN;"
+
+def get_tablespace_sql(tablespace, inline=False):
+    return "ON %s" % quote_name(tablespace)
+
+def get_autoinc_sql(table):
+    return None
+
-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
-
+allows_group_by_ordinal = True
+allows_unique_and_pk = True
+autoindexes_primary_keys = True
+needs_datetime_string_cast = True
+needs_upper_for_iops = False
-supports_constraints = True
+supports_tablespaces = False
+uses_case_insensitive_names = False
-
-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_datetime_cast_sql():
+    return None
+
-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_max_name_length():
+    return None
+
+def get_start_transaction_sql():
+    return "BEGIN;"
+
+def get_autoinc_sql(table):
+    return None
+
-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)
-
+allows_group_by_ordinal = True
+allows_unique_and_pk = True
+autoindexes_primary_keys = True
+needs_datetime_string_cast = True
+needs_upper_for_iops = False
-supports_constraints = False
+supports_tablespaces = False
+uses_case_insensitive_names = 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_datetime_cast_sql():
+    return None
+
-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_max_name_length():
+    return None
+
+def get_start_transaction_sql():
+    return "BEGIN;"
+
+def get_autoinc_sql(table):
+    return None
+
-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
+import md5
-from time import time
-
-class CursorDebugWrapper(object):
@@ -92 +93 @@
-def rev_typecast_boolean(obj, d):
-    return obj and '1' or '0'
-
+def truncate_name(name, length=None):
+    """Shortens a string to a repeatable mangled version with the given length.
+    """
+    if length is None or len(name) <= length:
+        return name
+
+    hash = md5.md5(name).hexdigest()[:4]
+
+    return '%s%s' % (name[:length-4], hash)
+
-##################################################################################
-# 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.conf import settings
-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
+import datetime
+from django.utils.datastructures import SortedDict
-
+
-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)
-
+
+
+
+
+
+
+
+
+
-
-    def _commit(self):
-        if self.connection is not None:
-
+return 
-
-    def _rollback(self):
-        if self.connection is not None:
-
-
-
-
+
-
-    def close(self):
-        if self.connection is not None:
-            self.connection.close()
-            self.connection = None
-
+allows_group_by_ordinal = False
+allows_unique_and_pk = False        # Suppress UNIQUE/PK for Oracle (ORA-02259)
+autoindexes_primary_keys = True
+needs_datetime_string_cast = False
+needs_upper_for_iops = True
-supports_constraints = True
+supports_tablespaces = True
+uses_case_insensitive_names = 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 _rewrite_args(self, query, params=None):
+        if params is None:
+            params = []
+        else:
+            # cx_Oracle can't handle unicode parameters, so cast to str for now
+            for i, param in enumerate(params):
+                if type(param) == unicode:
+                    try:
+                        params[i] = param.encode('utf-8')
+                    except UnicodeError:
+                        params[i] = str(param)
+        args = [(':arg%d' % i) for i in range(len(params))]
+        query = query % tuple(args)
+        # cx_Oracle cannot execute a query with the closing ';'
+        if query.endswith(';'):
+            query = query[:-1]
+        return query, params
+
-    def execute(self, query, params=None):
-
-
+
-        return Database.Cursor.execute(self, query, params)
-
-    def executemany(self, query, params=None):
-
-
+
-        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):
-
+
+
+
+
+
+
+
-
-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
-query
+sq_name = util.truncate_name(table_name, get_max_name_length()-3)
+'SELECT %s_sq.currval FROM dual' % sq_name
-    return cursor.fetchone()[0]
-
-def get_date_extract_sql(lookup_type, table_name):
-    # lookup_type is 'year', 'month', 'day'
-www.psoug.org/reference/date_func.html
+download-east.oracle.com/docs/cd/B10501_01/server.920/a96540/functions42a.htm#1017163
-    return "EXTRACT(%s FROM %s)" % (lookup_type, table_name)
-
-def get_date_trunc_sql(lookup_type, field_name):
-
+
+
+
+
+
+
+
+
-
+def get_datetime_cast_sql():
+    return "TO_TIMESTAMP(%s, 'YYYY-MM-DD HH24:MI:SS')"
+
-def get_limit_offset_sql(limit, offset=None):
-    # Limits and offset are too complicated to be handled here.
-
-pass
+backends/oracle/
+return ""
-
-def get_random_function_sql():
-    return "DBMS_RANDOM.RANDOM"
@@ -116 +158 @@
-    raise NotImplementedError
-
-def get_drop_foreignkey_sql():
-FOREIGN KEY
+CONSTRAINT
-
-def get_pk_default_value():
-    return "DEFAULT"
-
+def get_max_name_length():
+    return 30
+
+def get_start_transaction_sql():
+    return None
+
+def get_tablespace_sql(tablespace, inline=False):
+    return "%sTABLESPACE %s" % ((inline and "USING INDEX " or ""), quote_name(tablespace))
+
+def get_autoinc_sql(table):
+    # To simulate auto-incrementing primary keys in Oracle, we have to
+    # create a sequence and a trigger.
+    sq_name = get_sequence_name(table)
+    tr_name = get_trigger_name(table)
+    sequence_sql = 'CREATE SEQUENCE %s;' % sq_name
+    trigger_sql = """CREATE OR REPLACE TRIGGER %s
+  BEFORE INSERT ON %s
+  FOR EACH ROW
+  WHEN (new.id IS NULL)
+    BEGIN
+      SELECT %s.nextval INTO :new.id FROM dual;
+    END;\n""" % (tr_name, quote_name(table), sq_name)
+    return sequence_sql, trigger_sql
+
+def get_drop_sequence(table):
+    return "DROP SEQUENCE %s;" % quote_name(get_sequence_name(table))
+
+def _get_sequence_reset_sql():
+    # TODO: colorize this SQL code with style.SQL_KEYWORD(), etc.
+    return """
+        DECLARE
+            startvalue integer;
+            cval integer;
+        BEGIN
+            LOCK TABLE %(table)s IN SHARE MODE;
+            SELECT NVL(MAX(id), 0) INTO startvalue FROM %(table)s;
+            SELECT %(sequence)s.nextval INTO cval FROM dual;
+            cval := startvalue - cval;
+            IF cval != 0 THEN
+                EXECUTE IMMEDIATE 'ALTER SEQUENCE %(sequence)s MINVALUE 0 INCREMENT BY '||cval;
+                SELECT %(sequence)s.nextval INTO cval FROM dual;
+                EXECUTE IMMEDIATE 'ALTER SEQUENCE %(sequence)s INCREMENT BY 1';
+            END IF;
+            COMMIT;
+        END;\n"""
+
-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
-    """
-
-
-
-
-
+
+
+
+
+
+
+
+
-             style.SQL_FIELD(quote_name(table))
-             )  for table in tables]
+        # Since we've just deleted all the rows, running our sequence
+        # ALTER code will reset the sequence to 0.
+        for sequence_info in sequences:
+            table_name = sequence_info['table']
+            seq_name = get_sequence_name(table_name)
+            query = _get_sequence_reset_sql() % {'sequence':seq_name,
+                                                 'table':quote_name(table_name)}
+            sql.append(query)
+        return sql
+    else:
+        return []
-
+def get_sequence_name(table):
+    name_length = get_max_name_length() - 3
+    return '%s_SQ' % util.truncate_name(table, name_length).upper()
+
-def get_sql_sequence_reset(style, model_list):
-    "Returns a list of the SQL statements to reset sequences for the given models."
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+def get_trigger_name(table):
+    name_length = get_max_name_length() - 3
+    return '%s_TR' % util.truncate_name(table, name_length).upper()
+
+def get_query_set_class(DefaultQuerySet):
+    "Create a custom QuerySet class for Oracle."
+
+    from django.db import backend, connection
+    from django.db.models.query import EmptyResultSet, GET_ITERATOR_CHUNK_SIZE
+
+    class OracleQuerySet(DefaultQuerySet):
+
+        def iterator(self):
+            "Performs the SELECT database lookup of this QuerySet."
+
+            from django.db.models.query import get_cached_row
+
+            # self._select is a dictionary, and dictionaries' key order is
+            # undefined, so we convert it to a list of tuples.
+            extra_select = self._select.items()
+
+            full_query = None
+
+            try:
+                try:
+                    select, sql, params, full_query = self._get_sql_clause(get_full_query=True)
+                except TypeError:
+                    select, sql, params = self._get_sql_clause()
+            except EmptyResultSet:
+                raise StopIteration
+            if not full_query:
+                full_query = "SELECT %s%s\n%s" % \
+                             ((self._distinct and "DISTINCT " or ""),
+                              ', '.join(select), sql)
+
+            cursor = connection.cursor()
+            cursor.execute(full_query, params)
+
+            fill_cache = self._select_related
+            fields = self.model._meta.fields
+            index_end = len(fields)
+
+            # so here's the logic;
+            # 1. retrieve each row in turn
+            # 2. convert NCLOBs
+
+            while 1:
+                rows = cursor.fetchmany(GET_ITERATOR_CHUNK_SIZE)
+                if not rows:
+                    raise StopIteration
+                for row in rows:
+                    row = self.resolve_columns(row, fields)
+                    if fill_cache:
+                        obj, index_end = get_cached_row(klass=self.model, row=row,
+                                                        index_start=0, max_depth=self._max_related_depth)
+                    else:
+                        obj = self.model(*row[:index_end])
+                    for i, k in enumerate(extra_select):
+                        setattr(obj, k[0], row[index_end+i])
+                    yield obj
+
+
+        def _get_sql_clause(self, get_full_query=False):
+            from django.db.models.query import fill_table_cache, \
+                handle_legacy_orderlist, orderfield2column
+
+            opts = self.model._meta
+
+            # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z.
+            select = ["%s.%s" % (backend.quote_name(opts.db_table), backend.quote_name(f.column)) for f in opts.fields]
+            tables = [quote_only_if_word(t) for t in self._tables]
+            joins = SortedDict()
+            where = self._where[:]
+            params = self._params[:]
+
+            # Convert self._filters into SQL.
+            joins2, where2, params2 = self._filters.get_sql(opts)
+            joins.update(joins2)
+            where.extend(where2)
+            params.extend(params2)
+
+            # Add additional tables and WHERE clauses based on select_related.
+            if self._select_related:
+                fill_table_cache(opts, select, tables, where, opts.db_table, [opts.db_table])
+
+            # Add any additional SELECTs.
+            if self._select:
+                select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), backend.quote_name(s[0])) for s in self._select.items()])
+
+            # Start composing the body of the SQL statement.
+            sql = [" FROM", backend.quote_name(opts.db_table)]
+
+            # Compose the join dictionary into SQL describing the joins.
+            if joins:
+                sql.append(" ".join(["%s %s %s ON %s" % (join_type, table, alias, condition)
+                                for (alias, (table, join_type, condition)) in joins.items()]))
+
+            # Compose the tables clause into SQL.
+            if tables:
+                sql.append(", " + ", ".join(tables))
+
+            # Compose the where clause into SQL.
+            if where:
+                sql.append(where and "WHERE " + " AND ".join(where))
+
+            # ORDER BY clause
+            order_by = []
+            if self._order_by is not None:
+                ordering_to_use = self._order_by
+            else:
+                ordering_to_use = opts.ordering
+            for f in handle_legacy_orderlist(ordering_to_use):
+                if f == '?': # Special case.
+                    order_by.append(backend.get_random_function_sql())
+                else:
+                    if f.startswith('-'):
+                        col_name = f[1:]
+                        order = "DESC"
+                    else:
+                        col_name = f
+                        order = "ASC"
+                    if "." in col_name:
+                        table_prefix, col_name = col_name.split('.', 1)
+                        table_prefix = backend.quote_name(table_prefix) + '.'
+                    else:
+                        # Use the database table as a column prefix if it wasn't given,
+                        # and if the requested column isn't a custom SELECT.
+                        if "." not in col_name and col_name not in (self._select or ()):
+                            table_prefix = backend.quote_name(opts.db_table) + '.'
+                        else:
+                            table_prefix = ''
+                    order_by.append('%s%s %s' % (table_prefix, backend.quote_name(orderfield2column(col_name, opts)), order))
+            if order_by:
+                sql.append("ORDER BY " + ", ".join(order_by))
+
+            # Look for column name collisions in the select elements
+            # and fix them with an AS alias.  This allows us to do a
+            # SELECT * later in the paging query.
+            cols = [clause.split('.')[-1] for clause in select]
+            for index, col in enumerate(cols):
+                if cols.count(col) > 1:
+                    col = '%s%d' % (col.replace('"', ''), index)
+                    cols[index] = col
+                    select[index] = '%s AS %s' % (select[index], col)
+
+            # LIMIT and OFFSET clauses
+            # To support limits and offsets, Oracle requires some funky rewriting of an otherwise normal looking query.
+            select_clause = ",".join(select)
+            distinct = (self._distinct and "DISTINCT " or "")
+
+            if order_by:
+                order_by_clause = " OVER (ORDER BY %s )" % (", ".join(order_by))
+            else:
+                #Oracle's row_number() function always requires an order-by clause.
+                #So we need to define a default order-by, since none was provided.
+                order_by_clause = " OVER (ORDER BY %s.%s)" % \
+                    (backend.quote_name(opts.db_table),
+                    backend.quote_name(opts.fields[0].db_column or opts.fields[0].column))
+            # limit_and_offset_clause
+            if self._limit is None:
+                assert self._offset is None, "'offset' is not allowed without 'limit'"
+
+            if self._offset is not None:
+                offset = int(self._offset)
+            else:
+                offset = 0
+            if self._limit is not None:
+                limit = int(self._limit)
+            else:
+                limit = None
+
+            limit_and_offset_clause = ''
+            if limit is not None:
+                limit_and_offset_clause = "WHERE rn > %s AND rn <= %s" % (offset, limit+offset)
+            elif offset:
+                limit_and_offset_clause = "WHERE rn > %s" % (offset)
+
+            if len(limit_and_offset_clause) > 0:
+                fmt = \
+"""SELECT * FROM
+  (SELECT %s%s,
+          ROW_NUMBER()%s AS rn
+   %s)
+%s"""
+                full_query = fmt % (distinct, select_clause,
+                                    order_by_clause, ' '.join(sql).strip(),
+                                    limit_and_offset_clause)
+            else:
+                full_query = None
+
+            if get_full_query:
+                return select, " ".join(sql), params, full_query
+            else:
+                return select, " ".join(sql), params
+
+        def resolve_columns(self, row, fields=()):
+            from django.db.models.fields import DateField, DateTimeField, \
+                TimeField, BooleanField, NullBooleanField
+            values = []
+            for value, field in map(None, row, fields):
+                if isinstance(value, Database.LOB):
+                    value = value.read()
+                # Since Oracle won't distinguish between NULL and an empty
+                # string (''), we store empty strings as a space.  Here is
+                # where we undo that treachery.
+                if value == ' ':
+                    value = ''
+                # Convert 1 or 0 to True or False
+                elif value in (1, 0) and isinstance(field, (BooleanField, NullBooleanField)):
+                    value = bool(value)
+                # cx_Oracle always returns datetime.datetime objects for
+                # DATE and TIMESTAMP columns, but Django wants to see a
+                # python datetime.date, .time, or .datetime.  We use the type
+                # of the Field to determine which to cast to, but it's not
+                # always available.
+                # As a workaround, we cast to date if all the time-related
+                # values are 0, or to time if the date is 1/1/1900.
+                # This could be cleaned a bit by adding a method to the Field
+                # classes to normalize values from the database (the to_python
+                # method is used for validation and isn't what we want here).
+                elif isinstance(value, Database.Timestamp):
+                    # In Python 2.3, the cx_Oracle driver returns its own
+                    # Timestamp object that we must convert to a datetime class.
+                    if not isinstance(value, datetime.datetime):
+                        value = datetime.datetime(value.year, value.month, value.day, value.hour,
+                                                  value.minute, value.second, value.fsecond)
+                    if isinstance(field, DateTimeField):
+                        pass  # DateTimeField subclasses DateField so must be checked first.
+                    elif isinstance(field, DateField):
+                        value = value.date()
+                    elif isinstance(field, TimeField) or (value.year == 1900 and value.month == value.day == 1):
+                        value = value.time()
+                    elif value.hour == value.minute == value.second == value.microsecond == 0:
+                        value = value.date()
+                values.append(value)
+            return values
+
+    return OracleQuerySet
+
+
-OPERATOR_MAPPING = {
-    'exact': '= %s',
-LIKE %s
-'LIKE %s'
-'LIKE %s'
+= UPPER(%s)
+"LIKE %s ESCAPE '\\'"
+"LIKE UPPER(%s) ESCAPE '\\'"
-    'gt': '> %s',
-    'gte': '>= %s',
-    'lt': '< %s',
-    'lte': '<= %s',
-'LIKE %s'
-'LIKE %s'
-'LIKE %s'
-'LIKE %s'
+"LIKE %s ESCAPE '\\'"
+"LIKE %s ESCAPE '\\'"
+"LIKE UPPER(%s) ESCAPE '\\'"
+"LIKE UPPER(%s) ESCAPE '\\'"
-}

django/db/backends/oracle/client.py

@@ -2 +2 @@
-import os
-
-def runshell():
-
-
+
-    if settings.DATABASE_PASSWORD:
-
-
-
+
+
+
+
+

django/db/backends/oracle/introspection.py

@@ +1 @@
+from django.db.backends.oracle.base import quote_name
-import re
+import cx_Oracle
-
+
-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")
-
+.upper()
-
-def get_table_description(cursor, table_name):
-
+
+
+
-
-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.
-    """
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+    relations = {}
+    for row in cursor.fetchall():
+        relations[row[0]] = (row[2], row[1])
+    return relations
+
-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}
-    """
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-code
+object
-DATA_TYPES_REVERSE = {
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-}

django/db/backends/oracle/creation.py

@@ +1 @@
+import sys, time
+from django.core import management
+
+# This dictionary maps Field objects to their associated Oracle 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 = {
-'number(38
-'number(1
-'varchar
-'varchar
-'date
-'date
-'varchar
-'varchar
-'number
-'varchar
-'integer
-'char
+           'NUMBER(11
+           'NUMBER(1) CHECK (%(column)s IN (0,1)
+           'VARCHAR
+  'VARCHAR
+           'DATE
+           'TIMESTAMP
+           'VARCHAR
+           'VARCHAR
+           'NUMBER
+           'VARCHAR
+           'NUMBER(11)
+           'VARCHAR2
-    'ManyToManyField':   None,
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-}
+
+TEST_DATABASE_PREFIX = 'test_'
+PASSWORD = 'Im_a_lumberjack'
+REMEMBER = {}
+
+
+def create_test_db(settings, connection, backend, verbosity=1, autoclobber=False):
+
+    TEST_DATABASE_NAME = _test_database_name(settings)
+    TEST_DATABASE_USER = _test_database_user(settings)
+    TEST_DATABASE_PASSWD = _test_database_passwd(settings)
+    TEST_DATABASE_TBLSPACE = _test_database_tblspace(settings)
+    TEST_DATABASE_TBLSPACE_TMP = _test_database_tblspace_tmp(settings)
+
+    parameters = {
+        'dbname': TEST_DATABASE_NAME,
+        'user': TEST_DATABASE_USER,
+  &nbs