Ticket #7732: oracle_pool.5.diff

django/db/backends/oracle/base.py

@@ -273 +273 @@
         'iendswith': "LIKEC UPPER(%s) ESCAPE '\\'",
     }
     oracle_version = None
+    _pool_defaults = {'SESSION_POOL_MIN': 1,
+                      'SESSION_POOL_MAX': 3,
+                      'SESSION_POOL_INCREMENT': 1,}
 
     def __init__(self, *args, **kwargs):
         super(DatabaseWrapper, self).__init__(*args, **kwargs)
@@ -284 +287 @@
         self.introspection = DatabaseIntrospection(self)
         self.validation = BaseDatabaseValidation()
 
+        # Fetch connection pool settings
+        opts = self.settings_dict['DATABASE_OPTIONS']
+        if not isinstance(opts, dict):
+            # Insurance against foolish users...
+            opts = {}
+        if opts.get('SESSION_POOL', False):
+            self._use_pool = True
+            self._pool_settings = dict(self._pool_defaults)
+            self._pool_settings.update(opts)
+        else:
+            self._use_pool = False
+
+    def _get_pool (self):
+        if not hasattr (self.__class__, '_pool'):
+            settings_dict = self.settings_dict
+            Database.OPT_Threading = 1
+            if len(settings_dict['DATABASE_HOST'].strip()) == 0:
+                settings_dict['DATABASE_HOST'] = 'localhost'
+            if len(settings_dict['DATABASE_PORT'].strip()) != 0:
+                dsn = Database.makedsn(settings_dict['DATABASE_HOST'],
+                                       int(settings_dict['DATABASE_PORT']),
+                                       settings_dict['DATABASE_NAME'])
+                p = Database.SessionPool(settings_dict['DATABASE_USER'],
+                                         settings_dict['DATABASE_PASSWORD'],
+                                         dsn,
+                                         self._pool_settings['SESSION_POOL_MIN'],
+                                         self._pool_settings['SESSION_POOL_MAX'],
+                                         self._pool_settings['SESSION_POOL_INCREMENT'],
+                                         threaded = True)
+            else:
+                p = Database.SessionPool(settings_dict['DATABASE_USER'],
+                                         settings_dict['DATABASE_PASSWORD'],
+                                         settings_dict['DATABASE_NAME'],
+                                         self._pool_settings['SESSION_POOL_MIN'],
+                                         self._pool_settings['SESSION_POOL_MAX'],
+                                         self._pool_settings['SESSION_POOL_INCREMENT'],
+                                         threaded = True)
+            setattr(self.__class__, '_pool', p)
+            # TODO I think the init stuff only needs to happen once per pool,
+            # but it may be once per connection...
+            conn = p.acquire()
+            self._init_oracle_settings(conn)
+            p.release(conn)
+        return getattr(self.__class__, '_pool')
+
+    pool = property (_get_pool)
+
     def _valid_connection(self):
         return self.connection is not None
 
@@ -300 +350 @@
         return "%s/%s@%s" % (settings_dict['DATABASE_USER'],
                              settings_dict['DATABASE_PASSWORD'], dsn)
 
-    def _cursor(self):
-        cursor = None
-        if not self._valid_connection():
-            conn_string = self._connect_string()
-            self.connection = Database.connect(conn_string, **self.settings_dict['DATABASE_OPTIONS'])
-            cursor = FormatStylePlaceholderCursor(self.connection)
+    def _init_oracle_settings(self, connection):
+        cursor = FormatStylePlaceholderCursor(connection)
             # Set oracle date to ansi date format.  This only needs to execute
             # once when we create a new connection. We also set the Territory
             # to 'AMERICA' which forces Sunday to evaluate to a '1' in TO_CHAR().
@@ -313 +359 @@
                            "NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF' "
                            "NLS_TERRITORY = 'AMERICA'")
             try:
-                self.oracle_version = int(self.connection.version.split('.')[0])
+            self.oracle_version = int(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
@@ -324 +370 @@
                     self.ops.regex_lookup = self.ops.regex_lookup_10
             except ValueError:
                 pass
+        return cursor
+
+    def _cursor(self):
+        cursor = None
+        if not self._valid_connection():
+            if self._use_pool and self.pool is not None:
+                self.connection = self.pool.acquire()
+            else:
+                    self.connection = Database.connect(self._connect_string(),
+                        **self.settings_dict['DATABASE_OPTIONS'])
+                    cursor = self._init_oracle_settings(self.connection)
             try:
                 self.connection.stmtcachesize = 20
             except:
                 # Django docs specify cx_Oracle version 4.3.1 or higher, but
                 # stmtcachesize is available only in 4.3.2 and up.
                 pass
+            # TODO Does pulling a connection from the pool count as "creation"?
             connection_created.send(sender=self.__class__)
         if not cursor:
             cursor = FormatStylePlaceholderCursor(self.connection)
         return cursor
 
+    def close(self):
+       from django.conf import settings
+       if self._use_pool:
+           if self.connection is not None:
+               self.pool.release(self.connection)
+               self.connection = None
+       else:
+           if self.connection is not None:
+               self.connection.close()
+               self.connection = None
+
     # Oracle doesn't support savepoint commits.  Ignore them.
     def _savepoint_commit(self, sid):
         pass

django/db/backends/oracle/creation.py

@@ -111 +111 @@
         settings.TEST_DATABASE_USER = settings.DATABASE_USER = self.connection.settings_dict["DATABASE_USER"] = TEST_DATABASE_USER
         settings.DATABASE_PASSWORD = self.connection.settings_dict["DATABASE_PASSWORD"] = TEST_DATABASE_PASSWD
 
+        if hasattr(self.connection, '_pool'):
+            self.connection.close()
+            del self.connection.__class__._pool
+
         return settings.DATABASE_NAME
 
     def _destroy_test_db(self, test_database_name, verbosity=1):
@@ -118 +122 @@
         Destroy a test database, prompting the user for confirmation if the
         database already exists. Returns the name of the test database created.
         """
+
+        if hasattr(self.connection, '_pool'):
+            self.connection.close()
+            del self.connection.__class__._pool
+
         TEST_DATABASE_NAME = self._test_database_name(settings)
         TEST_DATABASE_USER = self._test_database_user(settings)
         TEST_DATABASE_PASSWD = self._test_database_passwd(settings)