[MERGE] sync with the trunk

bzr revid: ls@numerigraphe.fr-20101112141041-19kpvr7pzxqankqo

1 files changed, 26 insertions, 17 deletions

diff --git a/bin/sql_db.py b/bin/sql_db.py
index 02b3e57676c..6c2c17beeb3 100644
--- a/bin/sql_db.py
+++ b/bin/sql_db.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 ##############################################################################
-#    
+#
 #    OpenERP, Open Source Management Solution
 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
 #
@@ -15,12 +15,13 @@
 #    GNU Affero General Public License for more details.
 #
 #    You should have received a copy of the GNU Affero General Public License
-#    along with this program.  If not, see <http://www.gnu.org/licenses/>.     
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 ##############################################################################
 
 __all__ = ['db_connect', 'close_db']
 
+from threading import currentThread
 import logging
 from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT, ISOLATION_LEVEL_READ_COMMITTED, ISOLATION_LEVEL_SERIALIZABLE
 from psycopg2.psycopg1 import cursor as psycopg1cursor
@@ -77,7 +78,11 @@ class Cursor(object):
     def __init__(self, pool, dbname, serialized=False):
         self.sql_from_log = {}
         self.sql_into_log = {}
-        self.sql_log = False
+
+        # default log level determined at cursor creation, could be
+        # overridden later for debugging purposes
+        self.sql_log = self.__logger.isEnabledFor(logging.DEBUG_SQL)
+
         self.sql_log_count = 0
         self.__closed = True    # avoid the call of close() (by __del__) if an exception
                                 # is raised by any of the following initialisations
@@ -103,13 +108,11 @@ class Cursor(object):
             self._close(True)
 
     @check
-    def execute(self, query, params=None):
+    def execute(self, query, params=None, log_exceptions=True):
         if '%d' in query or '%f' in query:
             self.__logger.warn(query)
             self.__logger.warn("SQL queries cannot contain %d or %f anymore. "
                                "Use only %s")
-            if params:
-                query = query.replace('%d', '%s').replace('%f', '%s')
 
         if self.sql_log:
             now = mdt.now()
@@ -118,17 +121,19 @@ class Cursor(object):
             params = params or None
             res = self._obj.execute(query, params)
         except psycopg2.ProgrammingError, pe:
-            self.__logger.error("Programming error: %s, in query %s", pe, query)
+            if log_exceptions or self.sql_log:
+                self.__logger.error("Programming error: %s, in query %s", pe, query)
             raise
         except Exception:
-            self.__logger.exception("bad query: %s", self._obj.query)
+            if log_exceptions or self.sql_log:
+                self.__logger.exception("bad query: %s", self._obj.query or query)
             raise
 
         if self.sql_log:
             delay = mdt.now() - now
             delay = delay.seconds * 1E6 + delay.microseconds
 
-            self.__logger.debug("query: %s", self._obj.query)
+            self.__logger.log(logging.DEBUG_SQL, "query: %s", self._obj.query)
             self.sql_log_count+=1
             res_from = re_from.match(query.lower())
             if res_from:
@@ -159,15 +164,16 @@ class Cursor(object):
             if sqllogs[type]:
                 sqllogitems = sqllogs[type].items()
                 sqllogitems.sort(key=lambda k: k[1][1])
-                self.__logger.debug("SQL LOG %s:", type)
+                self.__logger.log(logging.DEBUG_SQL, "SQL LOG %s:", type)
+                sqllogitems.sort(lambda x,y: cmp(x[1][0], y[1][0]))
                 for r in sqllogitems:
                     delay = timedelta(microseconds=r[1][1])
-                    self.__logger.debug("table: %s: %s/%s",
+                    self.__logger.log(logging.DEBUG_SQL, "table: %s: %s/%s",
                                         r[0], delay, r[1][0])
                     sum+= r[1][1]
                 sqllogs[type].clear()
             sum = timedelta(microseconds=sum)
-            self.__logger.debug("SUM %s:%s/%d [%d]",
+            self.__logger.log(logging.DEBUG_SQL, "SUM %s:%s/%d [%d]",
                                 type, sum, self.sql_log_count, sql_counter)
             sqllogs[type].clear()
         process('from')
@@ -251,8 +257,7 @@ class ConnectionPool(object):
         return "ConnectionPool(used=%d/count=%d/max=%d)" % (used, count, self._maxconn)
 
     def _debug(self, msg, *args):
-        msg = '%r ' + msg
-        self.__logger.debug(msg, self, *args)
+        self.__logger.log(logging.DEBUG_SQL, ('%r ' + msg), self, *args)
 
     @locked
     def borrow(self, dsn):
@@ -264,7 +269,7 @@ class ConnectionPool(object):
                 delattr(cnx, 'leaked')
                 self._connections.pop(i)
                 self._connections.append((cnx, False))
-                self._debug('Free leaked connection to %r', cnx.dsn)
+                self.__logger.warn('%r: Free leaked connection to %r', self, cnx.dsn)
 
         for i, (cnx, used) in enumerate(self._connections):
             if not used and dsn_are_equals(cnx.dsn, dsn):
@@ -307,7 +312,7 @@ class ConnectionPool(object):
 
     @locked
     def close_all(self, dsn):
-        self._debug('Close all connections to %r', dsn)
+        self.__logger.info('%r: Close all connections to %r', self, dsn)
         for i, (cnx, used) in tools.reverse_enumerate(self._connections):
             if dsn_are_equals(cnx.dsn, dsn):
                 cnx.close()
@@ -323,7 +328,7 @@ class Connection(object):
 
     def cursor(self, serialized=False):
         cursor_type = serialized and 'serialized ' or ''
-        self.__logger.debug('create %scursor to %r', cursor_type, self.dbname)
+        self.__logger.log(logging.DEBUG_SQL, 'create %scursor to %r', cursor_type, self.dbname)
         return Cursor(self._pool, self.dbname, serialized=serialized)
 
     def serialized_cursor(self):
@@ -359,11 +364,15 @@ def dsn_are_equals(first, second):
 _Pool = ConnectionPool(int(tools.config['db_maxconn']))
 
 def db_connect(db_name):
+    currentThread().dbname = db_name
     return Connection(_Pool, db_name)
 
 def close_db(db_name):
     _Pool.close_all(dsn(db_name))
     tools.cache.clean_caches_for_db(db_name)
+    ct = currentThread()
+    if hasattr(ct, 'dbname'):
+        delattr(ct, 'dbname')
 
 
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: