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 dicti