Method set_transaction() renamed to set_session()

In fact it doesn't change "the transaction", as there has to be no
transaction when invoked. The effect instead is to execute SET SESSION
CHARACTERISTICS.

7 files changed, 43 insertions, 43 deletions

diff --git a/NEWS b/NEWS
index 0966910..dd59596 100644
--- a/NEWS
+++ b/NEWS
@@ -1,7 +1,7 @@
 What's new in psycopg 2.4.2
 ---------------------------
 
-  - Added 'set_transaction()' method and 'autocommit' property to the
+  - Added 'set_session()' method and 'autocommit' property to the
     connection. Added support for read-only sessions and, for PostgreSQL
     9.1, for the "repeatable read" isolation level and the "deferrable"
     transaction property.
diff --git a/doc/src/advanced.rst b/doc/src/advanced.rst
index c7625b1..c2c3a15 100644
--- a/doc/src/advanced.rst
+++ b/doc/src/advanced.rst
@@ -378,7 +378,7 @@ transaction is not implicitly started at the first query and is not possible
 to use methods `~connection.commit()` and `~connection.rollback()`: you can
 manually control transactions using `~cursor.execute()` to send database
 commands such as :sql:`BEGIN`, :sql:`COMMIT` and :sql:`ROLLBACK`. Similarly
-`set_transaction()` can't be used but it is still possible to invoke the
+`~connection.set_session()` can't be used but it is still possible to invoke the
 :sql:`SET` command with the proper :sql:`default_transaction_...` parameter.
 
 With asynchronous connections it is also not possible to use
diff --git a/doc/src/connection.rst b/doc/src/connection.rst
index 970b037..a38a560 100644
--- a/doc/src/connection.rst
+++ b/doc/src/connection.rst
@@ -327,7 +327,7 @@ The ``connection`` class
         pair: Transaction; Autocommit
         pair: Transaction; Isolation level
 
-    .. method:: set_transaction([isolation_level,] [readonly,] [deferrable,] [autocommit])
+    .. method:: set_session([isolation_level,] [readonly,] [deferrable,] [autocommit])
 
         Set one or more parameters for the next transactions or statements in
         the current session. See |SET TRANSACTION|_ for further details.
@@ -411,7 +411,7 @@ The ``connection`` class
 
         .. note::
 
-            From version 2.4.2, `set_transaction()` and `autocommit`, offer
+            From version 2.4.2, `set_session()` and `autocommit`, offer
             finer control on the transaction characteristics.
 
         Read or set the `transaction isolation level`_ for the current session.
diff --git a/psycopg/connection.h b/psycopg/connection.h
index 14d58a0..7f512a1 100644
--- a/psycopg/connection.h
+++ b/psycopg/connection.h
@@ -136,7 +136,7 @@ HIDDEN int  conn_connect(connectionObject *self, long int async);
 HIDDEN void conn_close(connectionObject *self);
 HIDDEN int  conn_commit(connectionObject *self);
 HIDDEN int  conn_rollback(connectionObject *self);
-HIDDEN int  conn_set_transaction(connectionObject *self, const char *isolevel,
+HIDDEN int  conn_set_session(connectionObject *self, const char *isolevel,
                                  const char *readonly, const char *deferrable,
                                  int autocommit);
 HIDDEN int  conn_set_autocommit(connectionObject *self, int value);
diff --git a/psycopg/connection_int.c b/psycopg/connection_int.c
index 732b22e..441d362 100644
--- a/psycopg/connection_int.c
+++ b/psycopg/connection_int.c
@@ -959,7 +959,7 @@ conn_rollback(connectionObject *self)
 }
 
 int
-conn_set_transaction(connectionObject *self,
+conn_set_session(connectionObject *self,
         const char *isolevel, const char *readonly, const char *deferrable,
         int autocommit)
 {
@@ -971,7 +971,7 @@ conn_set_transaction(connectionObject *self,
     pthread_mutex_lock(&self->lock);
 
     if (isolevel) {
-        Dprintf("conn_set_transaction: setting isolation to %s", isolevel);
+        Dprintf("conn_set_session: setting isolation to %s", isolevel);
         if ((res = pq_set_guc_locked(self,
                 "default_transaction_isolation", isolevel,
                 &pgres, &error, &_save))) {
@@ -980,7 +980,7 @@ conn_set_transaction(connectionObject *self,
     }
 
     if (readonly) {
-        Dprintf("conn_set_transaction: setting read only to %s", readonly);
+        Dprintf("conn_set_session: setting read only to %s", readonly);
         if ((res = pq_set_guc_locked(self,
                 "default_transaction_read_only", readonly,
                 &pgres, &error, &_save))) {
@@ -989,7 +989,7 @@ conn_set_transaction(connectionObject *self,
     }
 
     if (deferrable) {
-        Dprintf("conn_set_transaction: setting deferrable to %s", deferrable);
+        Dprintf("conn_set_session: setting deferrable to %s", deferrable);
         if ((res = pq_set_guc_locked(self,
                 "default_transaction_deferrable", deferrable,
                 &pgres, &error, &_save))) {
@@ -998,7 +998,7 @@ conn_set_transaction(connectionObject *self,
     }
 
     if (self->autocommit != autocommit) {
-        Dprintf("conn_set_transaction: setting autocommit to %d", autocommit);
+        Dprintf("conn_set_session: setting autocommit to %d", autocommit);
         self->autocommit = autocommit;
     }
 
diff --git a/psycopg/connection_type.c b/psycopg/connection_type.c
index 13c017e..e456ce4 100644
--- a/psycopg/connection_type.c
+++ b/psycopg/connection_type.c
@@ -456,14 +456,14 @@ _psyco_conn_parse_onoff(PyObject *pyval)
     }
 }
 
-/* set_transaction - default transaction characteristics */
+/* set_session - set default transaction characteristics */
 
-#define psyco_conn_set_transaction_doc \
-"set_transaction(...) -- Set one or more parameters for the next transactions.\n\n" \
+#define psyco_conn_set_session_doc \
+"set_session(...) -- Set one or more parameters for the next transactions.\n\n" \
 "Accepted arguments are 'isolation_level', 'readonly', 'deferrable', 'autocommit'."
 
 static PyObject *
-psyco_conn_set_transaction(connectionObject *self, PyObject *args, PyObject *kwargs)
+psyco_conn_set_session(connectionObject *self, PyObject *args, PyObject *kwargs)
 {
     PyObject *isolevel = Py_None;
     PyObject *readonly = Py_None;
@@ -479,8 +479,8 @@ psyco_conn_set_transaction(connectionObject *self, PyObject *args, PyObject *kwa
         {"isolation_level", "readonly", "deferrable", "autocommit", NULL};
 
     EXC_IF_CONN_CLOSED(self);
-    EXC_IF_CONN_ASYNC(self, set_transaction);
-    EXC_IF_IN_TRANSACTION(self, set_transaction);
+    EXC_IF_CONN_ASYNC(self, set_session);
+    EXC_IF_IN_TRANSACTION(self, set_session);
 
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO", kwlist,
             &isolevel, &readonly, &deferrable, &autocommit)) {
@@ -514,7 +514,7 @@ psyco_conn_set_transaction(connectionObject *self, PyObject *args, PyObject *kwa
         if (-1 == c_autocommit) { return NULL; }
     }
 
-    if (0 != conn_set_transaction(self,
+    if (0 != conn_set_session(self,
             c_isolevel, c_readonly, c_deferrable, c_autocommit)) {
         return NULL;
     }
@@ -904,8 +904,8 @@ static struct PyMethodDef connectionObject_methods[] = {
     {"tpc_recover", (PyCFunction)psyco_conn_tpc_recover,
      METH_NOARGS, psyco_conn_tpc_recover_doc},
 #ifdef PSYCOPG_EXTENSIONS
-    {"set_transaction", (PyCFunction)psyco_conn_set_transaction,
-     METH_VARARGS|METH_KEYWORDS, psyco_conn_set_transaction_doc},
+    {"set_session", (PyCFunction)psyco_conn_set_session,
+     METH_VARARGS|METH_KEYWORDS, psyco_conn_set_session_doc},
     {"set_isolation_level", (PyCFunction)psyco_conn_set_isolation_level,
      METH_VARARGS, psyco_conn_set_isolation_level_doc},
     {"set_client_encoding", (PyCFunction)psyco_conn_set_client_encoding,
diff --git a/tests/test_connection.py b/tests/test_connection.py
index dc3cfb0..ce0bf7e 100755
--- a/tests/test_connection.py
+++ b/tests/test_connection.py
@@ -729,18 +729,18 @@ class TransactionControlTests(unittest.TestCase):
         cur = self.conn.cursor()
         cur.execute("select 1")
         self.assertRaises(psycopg2.ProgrammingError,
-            self.conn.set_transaction,
+            self.conn.set_session,
             psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE)
 
     def test_set_isolation_level(self):
         cur = self.conn.cursor()
-        self.conn.set_transaction(
+        self.conn.set_session(
             psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE)
         cur.execute("SHOW default_transaction_isolation;")
         self.assertEqual(cur.fetchone()[0], 'serializable')
         self.conn.rollback()
 
-        self.conn.set_transaction(
+        self.conn.set_session(
             psycopg2.extensions.ISOLATION_LEVEL_REPEATABLE_READ)
         cur.execute("SHOW default_transaction_isolation;")
         if self.conn.server_version > 80000:
@@ -749,13 +749,13 @@ class TransactionControlTests(unittest.TestCase):
             self.assertEqual(cur.fetchone()[0], 'serializable')
         self.conn.rollback()
 
-        self.conn.set_transaction(
+        self.conn.set_session(
             isolation_level=psycopg2.extensions.ISOLATION_LEVEL_READ_COMMITTED)
         cur.execute("SHOW default_transaction_isolation;")
         self.assertEqual(cur.fetchone()[0], 'read committed')
         self.conn.rollback()
 
-        self.conn.set_transaction(
+        self.conn.set_session(
             isolation_level=psycopg2.extensions.ISOLATION_LEVEL_READ_UNCOMMITTED)
         cur.execute("SHOW default_transaction_isolation;")
         if self.conn.server_version > 80000:
@@ -766,12 +766,12 @@ class TransactionControlTests(unittest.TestCase):
 
     def test_set_isolation_level_str(self):
         cur = self.conn.cursor()
-        self.conn.set_transaction("serializable")
+        self.conn.set_session("serializable")
         cur.execute("SHOW default_transaction_isolation;")
         self.assertEqual(cur.fetchone()[0], 'serializable')
         self.conn.rollback()
 
-        self.conn.set_transaction("repeatable read")
+        self.conn.set_session("repeatable read")
         cur.execute("SHOW default_transaction_isolation;")
         if self.conn.server_version > 80000:
             self.assertEqual(cur.fetchone()[0], 'repeatable read')
@@ -779,12 +779,12 @@ class TransactionControlTests(unittest.TestCase):
             self.assertEqual(cur.fetchone()[0], 'serializable')
         self.conn.rollback()
 
-        self.conn.set_transaction("read committed")
+        self.conn.set_session("read committed")
         cur.execute("SHOW default_transaction_isolation;")
         self.assertEqual(cur.fetchone()[0], 'read committed')
         self.conn.rollback()
 
-        self.conn.set_transaction("read uncommitted")
+        self.conn.set_session("read uncommitted")
         cur.execute("SHOW default_transaction_isolation;")
         if self.conn.server_version > 80000:
             self.assertEqual(cur.fetchone()[0], 'read uncommitted')
@@ -793,13 +793,13 @@ class TransactionControlTests(unittest.TestCase):
         self.conn.rollback()
 
     def test_bad_isolation_level(self):
-        self.assertRaises(ValueError, self.conn.set_transaction, 0)
-        self.assertRaises(ValueError, self.conn.set_transaction, 5)
-        self.assertRaises(ValueError, self.conn.set_transaction, 'whatever')
+        self.assertRaises(ValueError, self.conn.set_session, 0)
+        self.assertRaises(ValueError, self.conn.set_session, 5)
+        self.assertRaises(ValueError, self.conn.set_session, 'whatever')
 
     def test_set_read_only(self):
         cur = self.conn.cursor()
-        self.conn.set_transaction(readonly=True)
+        self.conn.set_session(readonly=True)
         cur.execute("SHOW default_transaction_read_only;")
         self.assertEqual(cur.fetchone()[0], 'on')
         self.conn.rollback()
@@ -808,12 +808,12 @@ class TransactionControlTests(unittest.TestCase):
         self.conn.rollback()
 
         cur = self.conn.cursor()
-        self.conn.set_transaction(readonly=None)
+        self.conn.set_session(readonly=None)
         cur.execute("SHOW default_transaction_read_only;")
         self.assertEqual(cur.fetchone()[0], 'on')
         self.conn.rollback()
 
-        self.conn.set_transaction(readonly=False)
+        self.conn.set_session(readonly=False)
         cur.execute("SHOW default_transaction_read_only;")
         self.assertEqual(cur.fetchone()[0], 'off')
         self.conn.rollback()
@@ -826,8 +826,8 @@ class TransactionControlTests(unittest.TestCase):
         default_readonly = cur.fetchone()[0]
         self.conn.rollback()
 
-        self.conn.set_transaction(isolation_level='serializable', readonly=True)
-        self.conn.set_transaction(isolation_level='default', readonly='default')
+        self.conn.set_session(isolation_level='serializable', readonly=True)
+        self.conn.set_session(isolation_level='default', readonly='default')
 
         cur.execute("SHOW default_transaction_isolation;")
         self.assertEqual(cur.fetchone()[0], default_isolevel)
@@ -837,7 +837,7 @@ class TransactionControlTests(unittest.TestCase):
     @skip_before_postgres(9, 1)
     def test_set_deferrable(self):
         cur = self.conn.cursor()
-        self.conn.set_transaction(readonly=True, deferrable=True)
+        self.conn.set_session(readonly=True, deferrable=True)
         cur.execute("SHOW default_transaction_read_only;")
         self.assertEqual(cur.fetchone()[0], 'on')
         cur.execute("SHOW default_transaction_deferrable;")
@@ -847,7 +847,7 @@ class TransactionControlTests(unittest.TestCase):
         self.assertEqual(cur.fetchone()[0], 'on')
         self.conn.rollback()
 
-        self.conn.set_transaction(deferrable=False)
+        self.conn.set_session(deferrable=False)
         cur.execute("SHOW default_transaction_read_only;")
         self.assertEqual(cur.fetchone()[0], 'on')
         cur.execute("SHOW default_transaction_deferrable;")
@@ -857,7 +857,7 @@ class TransactionControlTests(unittest.TestCase):
     @skip_after_postgres(9, 1)
     def test_set_deferrable_error(self):
         self.assertRaises(psycopg2.ProgrammingError,
-            self.conn.set_transaction, readonly=True, deferrable=True)
+            self.conn.set_session, readonly=True, deferrable=True)
 
 
 class AutocommitTests(unittest.TestCase):
@@ -915,8 +915,8 @@ class AutocommitTests(unittest.TestCase):
         self.assertRaises(psycopg2.ProgrammingError,
             setattr, self.conn, 'autocommit', True)
 
-    def test_set_transaction_autocommit(self):
-        self.conn.set_transaction(autocommit=True)
+    def test_set_session_autocommit(self):
+        self.conn.set_session(autocommit=True)
         self.assert_(self.conn.autocommit)
         self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY)
         self.assertEqual(self.conn.get_transaction_status(),
@@ -928,7 +928,7 @@ class AutocommitTests(unittest.TestCase):
         self.assertEqual(self.conn.get_transaction_status(),
             psycopg2.extensions.TRANSACTION_STATUS_IDLE)
 
-        self.conn.set_transaction(autocommit=False)
+        self.conn.set_session(autocommit=False)
         self.assert_(not self.conn.autocommit)
         self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY)
         self.assertEqual(self.conn.get_transaction_status(),
@@ -940,7 +940,7 @@ class AutocommitTests(unittest.TestCase):
             psycopg2.extensions.TRANSACTION_STATUS_INTRANS)
         self.conn.rollback()
 
-        self.conn.set_transaction('serializable', readonly=True, autocommit=True)
+        self.conn.set_session('serializable', readonly=True, autocommit=True)
         self.assert_(self.conn.autocommit)
         cur.execute('select 1;')
         self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY)