Ticket #17291: ora_version.diff

django/db/backends/__init__.py

@@ -340 +340 @@
     # Do time/datetime fields have microsecond precision?
     supports_microsecond_precision = True
 
+    # Is there support for __regex lookups?
+    supports_regex = True
+
     # Does the __regex lookup support backreferencing and grouping?
     supports_regex_backreferencing = True
 

django/db/backends/oracle/base.py

@@ -83 +83 @@
     has_bulk_insert = True
     supports_tablespaces = True
 
+    def _supports_regex(self):
+        if self.connection.oracle_version > 9:
+            return True
+        else:
+            return False
+    supports_regex = property(_supports_regex)
+    supports_regex_backreferencing = supports_regex
+
 class DatabaseOperations(BaseDatabaseOperations):
     compiler_module = "django.db.backends.oracle.compiler"
 
@@ -249 +257 @@
     def random_function_sql(self):
         return "DBMS_RANDOM.RANDOM"
 
-    def regex_lookup_9(self, lookup_type):
-        raise NotImplementedError("Regexes are not supported in Oracle before version 10g.")
-
-    def regex_lookup_10(self, lookup_type):
-        if lookup_type == 'regex':
-            match_option = "'c'"
-        else:
-            match_option = "'i'"
-        return 'REGEXP_LIKE(%%s, %%s, %s)' % match_option
-
     def regex_lookup(self, lookup_type):
-        # If regex_lookup is called before it's been initialized, then create
-        # a cursor to initialize it and recur.
-        self.connection.cursor()
-        return self.connection.ops.regex_lookup(lookup_type)
+        if self.connection.oracle_version > 9:
+            if lookup_type == 'regex':
+                match_option = "'c'"
+            else:
+                match_option = "'i'"
+            return 'REGEXP_LIKE(%%s, %%s, %s)' % match_option
+        else:
+            raise NotImplementedError("Regexes are not supported in Oracle before version 10g.")
 
     def return_insert_id(self):
         return "RETURNING %s INTO %%s", (InsertIdVar(),)
@@ -434 +436 @@
     def __init__(self, *args, **kwargs):
         super(DatabaseWrapper, self).__init__(*args, **kwargs)
 
-        self.oracle_version = None
+        self._oracle_version = None
         self.features = DatabaseFeatures(self)
         use_returning_into = self.settings_dict["OPTIONS"].get('use_returning_into', True)
         self.features.can_return_id_from_insert = use_returning_into
@@ -444 +446 @@
         self.introspection = DatabaseIntrospection(self)
         self.validation = BaseDatabaseValidation(self)
 
+    def _get_ora_version(self):
+        if self._oracle_version is None:
+            # To check the server version, we need a connection
+            if self.connection is None:
+                self._cursor().close()
+            self._oracle_version = int(self.connection.version.split('.')[0])
+        return self._oracle_version
+    oracle_version = property(_get_ora_version)
+
     def check_constraints(self, table_names=None):
         """
         To check constraints, we set constraints to immediate. Then, when, we're done we must ensure they
@@ -517 +528 @@
                     self.operators = self._likec_operators
                 else:
                     self.operators = self._standard_operators
-
-            try:
-                self.oracle_version = int(self.connection.version.split('.')[0])
-                # There's no way for the DatabaseOperations class to know the
-                # currently active Oracle version, so we do some setups here.
-                # TODO: Multi-db support will need a better solution (a way to
-                # communicate the current version).
-                if self.oracle_version <= 9:
-                    self.ops.regex_lookup = self.ops.regex_lookup_9
-                else:
-                    self.ops.regex_lookup = self.ops.regex_lookup_10
-            except ValueError:
-                pass
             try:
                 self.connection.stmtcachesize = 20
             except:
@@ -650 +648 @@
         self.cursor.arraysize = 100
 
     def _format_params(self, params):
-        return tuple([OracleParam(p, self, True) for p in params])
+        return tuple(OracleParam(p, self, True) for p in params)
 
     def _guess_input_sizes(self, params_list):
         sizes = [None] * len(params_list[0])
@@ -722 +720 @@
     def fetchmany(self, size=None):
         if size is None:
             size = self.arraysize
-        return tuple([_rowfactory(r, self.cursor)
-                      for r in self.cursor.fetchmany(size)])
+        return tuple(_rowfactory(r, self.cursor)
+                     for r in self.cursor.fetchmany(size))
 
     def fetchall(self):
-        return tuple([_rowfactory(r, self.cursor)
-                      for r in self.cursor.fetchall()])
+        return tuple(_rowfactory(r, self.cursor)
+                     for r in self.cursor.fetchall())
 
     def var(self, *args):
         return VariableWrapper(self.cursor.var(*args))

tests/modeltests/lookup/tests.py

@@ -479 +479 @@
             self.assertEqual(str(ex), "Join on field 'headline' not permitted. "
                              "Did you misspell 'starts' for the lookup type?")
 
+    @skipUnlessDBFeature('supports_regex')
     def test_regex(self):
         # Create some articles with a bit more interesting headlines for testing field lookups:
         for a in Article.objects.all():