OracleBranch: django-oracle-rev5036.diff

django.oracle/django/test/utils.py

@@ -1 +1 @@
-import sys, time
-from django.conf import settings
-transaction, backend
+backend, get_creation_module
-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 the database backend wants to create the test DB itself, let it
+    creation_module = get_creation_module()
+    if hasattr(creation_module, "create_test_db"):
+        creation_module.create_test_db(settings, connection, backend, verbosity, autoclobber)
+        return
+    
-    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):
+    # If the database wants to drop the test DB itself, let it
+    creation_module = get_creation_module()
+    if hasattr(creation_module, "destroy_test_db"):
+        creation_module.destroy_test_db(settings, connection, backend, old_database_name, verbosity)
+        return
+    
-    # 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

django.oracle/django/db/models/base.py

@@ -210 +210 @@
-        record_exists = True
-        if pk_set:
-            # Determine whether a record with the primary key already exists.
-1 FROM %s WHERE %s=%%s LIMIT 1
+COUNT(*) FROM %s WHERE %s=%%s
-                (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)), [pk_val])
-            # If it does already exist, do an UPDATE.
-
+[0] > 0
-                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.oracle/django/db/models/options.py

@@ -13 +13 @@
-
-DEFAULT_NAMES = ('verbose_name', 'db_table', 'ordering',
-                 'unique_together', 'permissions', 'get_latest_by',
-
+, 'db_tablespace'
-
-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.db_tablespace = None
-        self.admin = None
-        self.meta = meta
-        self.pk = None
@@ -59 +60 @@
-        del self.meta
-
-    def _prepare(self, model):
+        from django.db import backend
+        from django.db.backends.util import truncate_name
-        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)
+            self.db_table = truncate_name(self.db_table,
+                                          backend.get_max_name_length())
-
-    def add_field(self, field):
-        # Insert the given field in the order in which it was created, using
@@ -88 +93 @@
-
-    def __repr__(self):
-        return '<Options for %s>' % self.object_name
-
+
-    def __str__(self):
-        return "%s.%s" % (self.app_label, self.module_name)
-
+
-    def get_field(self, name, many_to_many=True):
-        "Returns the requested field by name. Raises FieldDoesNotExist on error."
-        to_search = many_to_many and (self.fields + self.many_to_many) or self.fields

django.oracle/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,
-
+, db_tablespace=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
+        self.db_tablespace = db_tablespace
-
-        # 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."
+        # Oracle treats empty strings ('') the same as NULLs.
+        # To get around this wart, we need to change it to something else...
+        if settings.DATABASE_ENGINE == 'oracle' and value == '':
+            value = ' '
-        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:
- will throw a warning if microseconds are given, because it
-doesn't support
-== 'mysql'
+/Oracle will throw a warning if microseconds are given, because
+neither database supports
+in ('mysql', 'oracle')
-                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):
+        # Oracle will throw an error if microseconds are given, because it
+        # doesn't support microseconds.
+        if settings.DATABASE_ENGINE == 'oracle' and hasattr(value, 'microsecond'):
+            value = value.replace(microsecond=0)
-        if lookup_type == 'range':
-            value = [str(v) for v in value]
-        else:
@@ -808 +816 @@
-        Field.__init__(self, verbose_name, name, **kwargs)
-
-    def get_db_prep_lookup(self, lookup_type, value):
+        if settings.DATABASE_ENGINE == 'oracle':
+            # Oracle requires a date in order to parse.
+            def prep(value):
+                if isinstance(value, datetime.time):
+                    value = datetime.datetime.combine(datetime.date(1900, 1, 1), value)
+                return str(value)
+        else:
+            prep = str
-        if lookup_type == 'range':
-str
+prep
-        else:
-str
+prep
-        return Field.get_db_prep_lookup(self, lookup_type, value)
-
-    def pre_save(self, model_instance, add):
@@ -827 +843 @@
-        if value is not None:
-            # MySQL will throw a warning if microseconds are given, because it
-            # doesn't support microseconds.
-== 'mysql'
+in ('mysql', 'oracle')
-                value = value.replace(microsecond=0)
-
+
+
+
+
+
+
+
+
-        return Field.get_db_prep_save(self, value)
-
-    def get_manipulator_field_objs(self):

django.oracle/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))
-
-
-
-
+
-
-                # Add the ones that aren't there already
-                for obj_id in (new_ids - existing_ids):

django.oracle/django/db/models/query.py

@@ -4 +4 @@
-from django.db.models import signals
-from django.dispatch import dispatcher
-from django.utils.datastructures import SortedDict
+from django.conf import settings
+import datetime
-import operator
-import re
-
@@ -77 +79 @@
-    else:
-        return backend.quote_name(word)
-
-
+_
-    "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
-
+
+
+
-        while 1:
-            rows = cursor.fetchmany(GET_ITERATOR_CHUNK_SIZE)
-            if not rows:
-                raise StopIteration
-            for row in rows:
+                if has_resolve_columns:
+                    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)
@@ -551 +558 @@
-
-        return select, " ".join(sql), params
-
+# Use the backend's QuerySet class if it defines one, otherwise use _QuerySet.
+if hasattr(backend, 'get_query_set_class'):
+    QuerySet = backend.get_query_set_class(_QuerySet)
+else:
+    QuerySet = _QuerySet
+
-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:
-
-
+
-        else: # Default to all 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)
+
+        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 has_resolve_columns:
+                    row = self.resolve_columns(row, fields)
-                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
+        from django.db.models.fields import DateTimeField
-        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
-
-
+
+
+
+
+
+
+
+
+
+
-            (backend.get_date_trunc_sql(self._kind, '%s.%s' % (backend.quote_name(self.model._meta.db_table),
-
+group_by, 
-        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()]
-
+        has_resolve_columns = hasattr(self, 'resolve_columns')
+        needs_datetime_string_cast = backend.needs_datetime_string_cast
+        dates = []
+        # It would be better to use self._field here instead of DateTimeField(),
+        # but in Oracle that will result in a list of datetime.date instead of
+        # datetime.datetime.
+        fields = [DateTimeField()]
+        while 1:
+            rows = cursor.fetchmany(GET_ITERATOR_CHUNK_SIZE)
+            if not rows:
+                return dates
+            for row in rows:
+                date = row[0]
+                if has_resolve_columns:
+                    date = self.resolve_columns([date], fields)[0]
+                elif needs_datetime_string_cast:
+                    date = typecast_timestamp(str(date))
+                dates.append(date)
+
-    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)
+    if type(value) == datetime.datetime and backend.get_datetime_cast_sql():
+        cast_sql = backend.get_datetime_cast_sql()
+    else:
+        cast_sql = '%s'
+    if lookup_type in ('iexact', 'icontains', 'istartswith', 'iendswith') and backend.needs_upper_for_iops:
+        format = 'UPPER(%s%s) %s'
+    else:
+        format = '%s%s %s'
-    try:
-
+
+
-    except KeyError:
-        pass
-    if lookup_type == 'in':

django.oracle/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.oracle/django/db/backends/postgresql/base.py

@@ -86 +86 @@
-        global postgres_version
-        if not postgres_version:
-            cursor.execute("SELECT version()")
-        
+
-        if settings.DEBUG:
-            return util.CursorDebugWrapper(cursor, self)
-        return cursor
@@ -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:
@@ -148 +158 @@
-
-def get_deferrable_sql():
-    return " DEFERRABLE INITIALLY DEFERRED"
-
+
-def get_fulltext_search_sql(field_name):
-    raise NotImplementedError
-
@@ -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
-    themselves) and put the database in an empty 'initial' state
-
-    
+
+
-    if tables:
-        if postgres_version[0] >= 8 and postgres_version[1] >= 1:
-            # Postgres 8.1+ can do 'TRUNCATE x, y, z...;'. In fact, it *has to* in order to be able to
@@ -174 +193 @@
-                 style.SQL_FIELD(', '.join([quote_name(table) for table in tables]))
-            )]
-        else:
- 
+
-            # a simple delete.
-            sql = ['%s %s %s;' % \
-                    (style.SQL_KEYWORD('DELETE'),
@@ -237 +256 @@
-                style.SQL_KEYWORD('FROM'),
-                style.SQL_TABLE(f.m2m_db_table())))
-    return output
-
+
-# Register these custom typecasts, because Django expects dates/times to be
-# in Python's native (standard-library) datetime/time format, whereas psycopg
-# use mx.DateTime by default.

django.oracle/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
-    themselves) and put the database in an empty 'initial' state
-
+
-    """
-    # NB: The generated SQL below is specific to SQLite
-    # Note: The DELETE FROM... SQL generated below works for SQLite databases
@@ -174 +193 @@
-    "Returns a list of the SQL statements to reset sequences for the given models."
-    # No sequence reset required
-    return []
-
+
-def _sqlite_date_trunc(lookup_type, dt):
-    try:
-        dt = util.typecast_timestamp(dt)

django.oracle/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.oracle/django/db/backends/mysql/base.py

@@ -15 +15 @@
-# lexicographic ordering in this check because then (1, 2, 1, 'gamma')
-# inadvertently passes the version test.
-version = Database.version_info
- 
+
-        (len(version) < 5 or version[3] != 'final' or version[4] < 2))):
-    raise ImportError, "MySQLdb-1.2.1p2 or newer is required; you have %s" % Database.__version__
-
@@ -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
-    themselves) and put the database in an empty 'initial' state
-
+
-    """
-    # NB: The generated SQL below is specific to MySQL
-    # 'TRUNCATE x;', 'TRUNCATE y;', 'TRUNCATE z;'... style SQL statements
@@ -201 +220 @@
-                 style.SQL_FIELD(quote_name(table))
-                )  for table in tables] + \
-              ['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;" % \

django.oracle/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
-    """
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+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
+            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 = ''
+                # 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.oracle/django/db/backends/oracle/client.py

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

django.oracle/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.oracle/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 = {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
+
+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,
+        'password': TEST_DATABASE_PASSWD,
+        'tblspace': TEST_DATABASE_TBLSPACE,
+        'tblspace_temp': TEST_DATABASE_TBLSPACE_TMP,
+        }
+
+    REMEMBER['user'] = settings.DATABASE_USER
+    REMEMBER['passwd'] = settings.DATABASE_PASSWORD
+
+    cursor = connection.cursor()
+    if _test_database_create(settings):
+        if verbosity >= 1:
+            print 'Creating test database...'
+        try:
+            _create_test_db(cursor, parameters, verbosity)
+        except Exception, e:
+            sys.stderr.write("Got an error creating the test database: %s\n" % e)
+            if not autoclobber:
+                confirm = raw_input("It appears the test database, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_DATABASE_NAME)
+            if autoclobber or confirm == 'yes':
+                try:
+                    if verbosity >= 1:
+                        print "Destroying old test database..."
+                    _destroy_test_db(cursor, parameters, verbosity)
+                    if verbosity >= 1:
+                        print "Creating test database..."
+                    _create_test_db(cursor, parameters, verbosity)
+                except Exception, e:
+                    sys.stderr.write("Got an error recreating the test database: %s\n" % e)
+                    sys.exit(2)
+            else:
+                print "Tests cancelled."
+                sys.exit(1)
+
+    if _test_user_create(settings):
+        if verbosity >= 1:
+            print "Creating test user..."
+        try:
+            _create_test_user(cursor, parameters, verbosity)
+        except Exception, e:
+            sys.stderr.write("Got an error creating the test user: %s\n" % e)
+            if not autoclobber:
+                confirm = raw_input("It appears the test user, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_DATABASE_USER)
+            if autoclobber or confirm == 'yes':
+                try:
+                    if verbosity >= 1:
+                        print "Destroying old test user..."
+                    _destroy_test_user(cursor, parameters, verbosity)
+                    if verbosity >= 1:
+                        print "Creating test user..."
+                    _create_test_user(cursor, parameters, verbosity)
+                except Exception, e:
+                    sys.stderr.write("Got an error recreating the test user: %s\n" % e)
+                    sys.exit(2)
+            else:
+                print "Tests cancelled."
+                sys.exit(1)
+
+    connection.close()
+    settings.DATABASE_USER = TEST_DATABASE_USER
+    settings.DATABASE_PASSWORD = TEST_DATABASE_PASSWD
+
+    management.syncdb(verbosity, interactive=False)
+
+    # Get a cursor (even though we don't need one yet). This has
+    # the side effect of initializing the test database.
+    cursor = connection.cursor()
+
+
+def destroy_test_db(settings, connection, backend, old_database_name, verbosity=1):
+    connection.close()
+
+    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)
+
+    settings.DATABASE_NAME = old_database_name
+    settings.DATABASE_USER = REMEMBER['user']
+    settings.DATABASE_PASSWORD = REMEMBER['passwd']
+
+    parameters = {
+        'dbname': TEST_DATABASE_NAME,
+        'user': TEST_DATABASE_USER,
+        'password': TEST_DATABASE_PASSWD,
+        'tblspace': TEST_DATABASE_TBLSPACE,
+        'tblspace_temp': TEST_DATABASE_TBLSPACE_TMP,
+        }
+
+    REMEMBER['user'] = settings.DATABASE_USER
+    REMEMBER['passwd'] = settings.DATABASE_PASSWORD
+
+    cursor = connection.cursor()
+    time.sleep(1) # To avoid "database is being accessed by other users" errors.
+    if _test_user_create(settings):
+        if verbosity >= 1:
+            print 'Destroying test user...'
+        _destroy_test_user(cursor, parameters, verbosity)
+    if _test_database_create(settings):
+        if verbosity >= 1:
+            print 'Destroying test database...'
+        _destroy_test_db(cursor, parameters, verbosity)
+    connection.close()
+
+
+def _create_test_db(cursor, parameters, verbosity):
+    if verbosity >= 2:
+        print "_create_test_db(): dbname = %s" % parameters['dbname']
+    statements = [
+        """CREATE TABLESPACE %(tblspace)s
+           DATAFILE '%(tblspace)s.dbf' SIZE 20M
+           REUSE AUTOEXTEND ON NEXT 10M MAXSIZE 100M
+        """,
+        """CREATE TEMPORARY TABLESPACE %(tblspace_temp)s
+           TEMPFILE '%(tblspace_temp)s.dbf' SIZE 20M
+           REUSE AUTOEXTEND ON NEXT 10M MAXSIZE 100M
+        """,
+    ]
+    _execute_statements(cursor, statements, parameters, verbosity)
+
+
+def _create_test_user(cursor, parameters, verbosity):
+    if verbosity >= 2:
+        print "_create_test_user(): username = %s" % parameters['user']
+    statements = [
+        """CREATE USER %(user)s
+           IDENTIFIED BY %(password)s
+           DEFAULT TABLESPACE %(tblspace)s
+           TEMPORARY TABLESPACE %(tblspace_temp)s
+        """,
+        """GRANT CONNECT, RESOURCE TO %(user)s""",
+    ]
+    _execute_statements(cursor, statements, parameters, verbosity)
+
+
+def _destroy_test_db(cursor, parameters, verbosity):
+    if verbosity >= 2:
+        print "_destroy_test_db(): dbname=%s" % parameters['dbname']
+    statements = [
+        'DROP TABLESPACE %(tblspace)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS',
+        'DROP TABLESPACE %(tblspace_temp)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS',
+        ]
+    _execute_statements(cursor, statements, parameters, verbosity)
+
+
+def _destroy_test_user(cursor, parameters, verbosity):
+    if verbosity >= 2:
+        print "_destroy_test_user(): user=%s" % parameters['user']
+        print "Be patient.  This can take some time..."
+    statements = [
+        'DROP USER %(user)s CASCADE',
+    ]
+    _execute_statements(cursor, statements, parameters, verbosity)
+
+
+def _execute_statements(cursor, statements, parameters, verbosity):
+    for template in statements:
+        stmt = template % parameters
+        if verbosity >= 2:
+            print stmt
+        try:
+            cursor.execute(stmt)
+        except Exception, err:
+            sys.stderr.write("Failed (%s)\n" % (err))
+            raise
+
+
+def _test_database_name(settings):
+    name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME
+    try:
+        if settings.TEST_DATABASE_NAME:
+            name = settings.TEST_DATABASE_NAME
+    except AttributeError:
+        pass
+    except:
+        raise
+    return name
+
+
+def _test_database_create(settings):
+    name = True
+    try:
+        if settings.TEST_DATABASE_CREATE:
+            name = True
+        else:
+            name = False
+    except AttributeError:
+        pass
+    except:
+        raise
+    return name
+
+
+def _test_user_create(settings):
+    name = True
+    try:
+        if settings.TEST_USER_CREATE:
+            name = True
+        else:
+            name = False
+    except AttributeError:
+        pass
+    except:
+        raise
+    return name
+
+
+def _test_database_user(settings):
+    name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME
+    try:
+        if settings.TEST_DATABASE_USER:
+            name = settings.TEST_DATABASE_USER
+    except AttributeError:
+        pass
+    except:
+        raise
+    return name
+
+
+def _test_database_passwd(settings):
+    name = PASSWORD
+    try:
+        if settings.TEST_DATABASE_PASSWD:
+            name = settings.TEST_DATABASE_PASSWD
+    except AttributeError:
+        pass
+    except:
+        raise
+    return name
+
+
+def _test_database_tblspace(settings):
+    name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME
+    try:
+        if settings.TEST_DATABASE_TBLSPACE:
+            name = settings.TEST_DATABASE_TBLSPACE
+    except AttributeError:
+        pass
+    except:
+        raise
+    return name
+
+
+def _test_database_tblspace_tmp(settings):
+    name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME + '_temp'
+    try:
+        if settings.TEST_DATABASE_TBLSPACE_TMP:
+            name = settings.TEST_DATABASE_TBLSPACE_TMP
+    except AttributeError:
+        pass
+    except:
+        raise
+    return name

django.oracle/django/db/backends/postgresql_psycopg2/base.py

@@ -54 +54 @@
-        global postgres_version
-        if not postgres_version:
-            cursor.execute("SELECT version()")
-        
+
-        if settings.DEBUG:
-            return util.CursorDebugWrapper(cursor, self)
-        return cursor
@@ -72 +72 @@
-            self.connection.close()
-            self.connection = None
-
+allows_group_by_ordinal = True
+allows_unique_and_pk = True
+autoindexes_primary_keys = True
+needs_datetime_string_cast = False
+needs_upper_for_iops = False
-supports_constraints = True
+supports_tablespaces = False
+uses_case_insensitive_names = 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_datetime_cast_sql():
+    return None
+
-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_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
@@ -138 +157 @@
-                     style.SQL_KEYWORD('FROM'),
-                     style.SQL_FIELD(quote_name(table))
-                     ) for table in tables]
-
+
-        # 'ALTER SEQUENCE sequence_name RESTART WITH 1;'... style SQL statements
-        # to reset sequence indices
-        for sequence in sequences:
@@ -194 +213 @@
-                style.SQL_KEYWORD('FROM'),
-                style.SQL_TABLE(f.m2m_db_table())))
-    return output
-
+
-OPERATOR_MAPPING = {
-    'exact': '= %s',
-    'iexact': 'ILIKE %s',

django.oracle/django/db/backends/dummy/base.py

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

django.oracle/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"
-
+backend, 
-    all_models = []
-    for app in models.get_apps():
-        for model in models.get_models(app):
-            all_models.append(model)
-
+
+
+
+
+
-
-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]
+        tablespace = f.db_tablespace or opts.db_tablespace
-        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 '')))
-
+ and (not f.primary_key or backend.allows_unique_and_pk)
-                field_output.append(style.SQL_KEYWORD('UNIQUE'))
-            if f.primary_key:
-                field_output.append(style.SQL_KEYWORD('PRIMARY KEY'))
+            if tablespace and backend.supports_tablespaces and (f.unique or f.primary_key) and backend.autoindexes_primary_keys:
+                # We must specify the index tablespace inline, because we
+                # won't be generating a CREATE INDEX statement for this field.
+                field_output.append(backend.get_tablespace_sql(tablespace, inline=True))
-            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 ''))
-
+
+
+
+
-    final_output.append('\n'.join(full_statement))
-
+    if opts.has_auto_field and hasattr(backend, 'get_autoinc_sql'):
+        # Add any extra SQL needed to support auto-incrementing primary keys
+        autoinc_sql = backend.get_autoinc_sql(opts.db_table)
+        if autoinc_sql:
+            for stmt in autoinc_sql:
+                final_output.append(stmt)
+
-    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
+    from django.db.backends.util import truncate_name
-    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
-
-
-
+
-                final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)%s;' % \
-r_name
+truncate_name(r_name, backend.get_max_name_length())
-                    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):
+            tablespace = f.db_tablespace or opts.db_tablespace
+            if tablespace and backend.supports_tablespaces and backend.autoindexes_primary_keys:
+                tablespace_sql = ' ' + backend.get_tablespace_sql(tablespace, inline=True)
+            else:
+                tablespace_sql = ''
-            table_output = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + \
-                style.SQL_TABLE(backend.quote_name(f.m2m_db_table())) + ' (']
-
+%s
-                (style.SQL_FIELD(backend.quote_name('id')),
-                style.SQL_COLTYPE(data_types['AutoField']),
-
+
+
-            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()))
-
+%s
-                (style.SQL_KEYWORD('UNIQUE'),
-                style.SQL_FIELD(backend.quote_name(f.m2m_column_name())),
-
-
+
+
+
+
+
+
+
-            final_output.append('\n'.join(table_output))
+
+            # Add any extra SQL needed to support auto-incrementing PKs
+            autoinc_sql = backend.get_autoinc_sql(f.m2m_db_table())
+            if autoinc_sql:
+                for stmt in autoinc_sql:
+                    final_output.append(stmt)
+
-    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
+    from django.db.backends.util import truncate_name
-    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 = []
+    if backend.uses_case_insensitive_names:
+        table_name_converter = str.upper
+    else:
+        table_name_converter = lambda x: x
-
-    output = []
-
@@ -300 +342 @@
-    references_to_delete = {}
-    app_models = models.get_models(app)
-    for model in app_models:
-model._meta.db_table
+table_name_converter(model._meta.db_table)
-            # 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:
-model._meta.db_table
+table_name_converter(model._meta.db_table)
-            # 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
+                    r_name = '%s_refs_%s_%s_%s' % (col, r_col, table, r_table)
-                    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()),
-backend.quote_name('%s_refs_%s_%x' % (col, r_col, abs(hash((table, r_table)))
+truncate_name(r_name, backend.get_max_name_length(
-                del references_to_delete[model]
+            if hasattr(backend, 'get_drop_sequence'):
+                output.append(backend.get_drop_sequence(model._meta.db_table))
-
-    # Output DROP TABLE statements for many-to-many tables.
-    for model in app_models:
-        opts = model._meta
-        for f in opts.many_to_many:
-f.m2m_db_table(
+table_name_converter(f.m2m_db_table()
-                output.append("%s %s;" % (style.SQL_KEYWORD('DROP TABLE'),
-                    style.SQL_TABLE(backend.quote_name(f.m2m_db_table()))))
+                if hasattr(backend, 'get_drop_sequence'):
+                    output.append(backend.get_drop_sequence("%s_%s" % (model._meta.db_table, f.column)))
-
+
-    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
+    from django.db.backends.util import truncate_name
-    output = []
-
-    for f in model._meta.fields:
-
+ and not ((f.primary_key or f.unique) and backend.autoindexes_primary_keys)
-            unique = f.unique and 'UNIQUE ' or ''
+            tablespace = f.db_tablespace or model._meta.db_tablespace
+            if tablespace and backend.supports_tablespaces:
+                tablespace_sql = ' ' + backend.get_tablespace_sql(tablespace)
+            else:
+                tablespace_sql = ''
-            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)) + ' ' + \
-
+
+
-            )
-    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."
-
+backend, 
-    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()
+    if backend.uses_case_insensitive_names:
+        table_name_converter = str.upper
+    else:
+        table_name_converter = lambda x: x
-
-    # 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)
-model._meta.db_table
+table_name_converter(model._meta.db_table)
-                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)
-model._meta.db_table
+table_name_converter(model._meta.db_table)
-
-    # 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)):
-
+.lower()
-            comment_notes = [] # Holds Field notes, to be displayed in a Python comment.
-            extra_params = {}  # Holds Field parameters such as 'db_column'.
-
@@ -1321 +1380 @@
-    # Keep a count of the installed objects and fixtures
-    count = [0,0]
-    models = set()
-
+
-    humanize = lambda dirname: dirname and "'%s'" % dirname or 'absolute path'
-
-    # Get a cursor (even though we don't need one yet). This has
@@ -1621 +1680 @@
-        if not mod_list:
-            parser.print_usage_and_exit()
-        if action not in NO_SQL_TRANSACTION:
-
+
+
+
-        for mod in mod_list:
-            if action == 'reset':
-                output = action_mapping[action](mod, options.interactive)

django.oracle/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=''):
-object_id
+str(object_id)
-        e.save()
-
-class LogEntry(models.Model):

django.oracle/docs/install.txt

@@ -62 +62 @@
-
-* If you're using SQLite, you'll need pysqlite_. Use version 2.0.3 or higher.
-
+* If you're using Oracle, you'll need cx_Oracle_, version 4.3.1 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/
+.. _cx_Oracle: http://www.python.net/crew/atuining/cx_Oracle/
-
-Remove any old versions of Django
-=================================

django.oracle/docs/settings.txt

@@ -245 +245 @@
-Default: ``''`` (Empty string)
-
-Which database backend to use. Either ``'postgresql_psycopg2'``, 
- or
-
+,
+oracle'``, or ``'
-
-DATABASE_HOST
--------------

django.oracle/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
- and `SQLite 3`
+, `SQLite 3`_, and Oracle
-
-.. _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/
+.. _Oracle: http://www.oracle.com/
-
-Do I lose anything by using Python 2.3 versus newer Python versions, such as Python 2.5?
-----------------------------------------------------------------------------------------