diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py
index dd24878..c89dcd9 100644
--- a/django/db/backends/__init__.py
+++ b/django/db/backends/__init__.py
@@ -340,6 +340,9 @@ class BaseDatabaseFeatures(object):
     # 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
 
diff --git a/django/db/backends/oracle/base.py b/django/db/backends/oracle/base.py
index c197422..2223e6c 100644
--- a/django/db/backends/oracle/base.py
+++ b/django/db/backends/oracle/base.py
@@ -9,6 +9,8 @@ import datetime
 import decimal
 import sys
 
+from django.utils.functional import cached_property
+
 
 def _setup_environment(environ):
     import platform
@@ -83,6 +85,14 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     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,21 +259,15 @@ WHEN (new.%(col_name)s IS NULL)
     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,7 +438,6 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     def __init__(self, *args, **kwargs):
         super(DatabaseWrapper, self).__init__(*args, **kwargs)
 
-        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,6 +447,14 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         self.introspection = DatabaseIntrospection(self)
         self.validation = BaseDatabaseValidation(self)
 
+    @cached_property
+    def oracle_version(self):
+        if self.connection is None:
+            # To check the server version, we need a connection - open and
+            # immediately close a cursor to ensure an open connection.
+            self.cursor().close()
+        return int(self.connection.version.split('.')[0])
+
     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,19 +528,6 @@ class DatabaseWrapper(BaseDatabaseWrapper):
                     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,7 +648,7 @@ class FormatStylePlaceholderCursor(object):
         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,12 +720,12 @@ class FormatStylePlaceholderCursor(object):
     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))
diff --git a/tests/modeltests/lookup/tests.py b/tests/modeltests/lookup/tests.py
index 9c2b0c6..068b5f7 100644
--- a/tests/modeltests/lookup/tests.py
+++ b/tests/modeltests/lookup/tests.py
@@ -479,6 +479,7 @@ class LookupTests(TestCase):
             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():
