psycopg/psycopg2
1
1
Fork 0
mirror of https://github.com/psycopg/psycopg2.git synced 2025-02-07 12:50:32 +03:00
Code Issues Packages Projects Releases Wiki Activity

Method set_transaction() renamed to set_session()

Browse Source 
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.
This commit is contained in:
Daniele Varrazzo 2011-06-08 14:22:11 +01:00
parent 1a51cfe274
commit d2b28abced
7 changed files with 43 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
NEWS
View File

@ -1,7 +1,7 @@
What's new in psycopg 2.4.2 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 connection. Added support for read-only sessions and, for PostgreSQL
9.1, for the "repeatable read" isolation level and the "deferrable" 9.1, for the "repeatable read" isolation level and the "deferrable"
transaction property. transaction property.

2
doc/src/advanced.rst
View File

@ -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 to use methods `~connection.commit()` and `~connection.rollback()`: you can
manually control transactions using `~cursor.execute()` to send database manually control transactions using `~cursor.execute()` to send database
commands such as :sql:`BEGIN`, :sql:`COMMIT` and :sql:`ROLLBACK`. Similarly 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. :sql:`SET` command with the proper :sql:`default_transaction_...` parameter.
With asynchronous connections it is also not possible to use With asynchronous connections it is also not possible to use

4
doc/src/connection.rst
View File

@ -327,7 +327,7 @@ The ``connection`` class
pair: Transaction; Autocommit pair: Transaction; Autocommit
pair: Transaction; Isolation level 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 Set one or more parameters for the next transactions or statements in
the current session. See |SET TRANSACTION|_ for further details. the current session. See |SET TRANSACTION|_ for further details.
@ -411,7 +411,7 @@ The ``connection`` class
.. note:: .. 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. finer control on the transaction characteristics.
Read or set the `transaction isolation level`_ for the current session. Read or set the `transaction isolation level`_ for the current session.

2
psycopg/connection.h
View File

@ -136,7 +136,7 @@ HIDDEN int conn_connect(connectionObject *self, long int async);
HIDDEN void conn_close(connectionObject *self); HIDDEN void conn_close(connectionObject *self);
HIDDEN int conn_commit(connectionObject *self); HIDDEN int conn_commit(connectionObject *self);
HIDDEN int conn_rollback(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, const char *readonly, const char *deferrable,
int autocommit); int autocommit);
HIDDEN int conn_set_autocommit(connectionObject *self, int value); HIDDEN int conn_set_autocommit(connectionObject *self, int value);

10
psycopg/connection_int.c
View File

@ -959,7 +959,7 @@ conn_rollback(connectionObject *self)
} }
int int
conn_set_transaction(connectionObject *self, conn_set_session(connectionObject *self,
const char *isolevel, const char *readonly, const char *deferrable, const char *isolevel, const char *readonly, const char *deferrable,
int autocommit) int autocommit)
{ {
@ -971,7 +971,7 @@ conn_set_transaction(connectionObject *self,
pthread_mutex_lock(&self->lock); pthread_mutex_lock(&self->lock);
if (isolevel) { 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, if ((res = pq_set_guc_locked(self,
"default_transaction_isolation", isolevel, "default_transaction_isolation", isolevel,
&pgres, &error, &_save))) { &pgres, &error, &_save))) {
@ -980,7 +980,7 @@ conn_set_transaction(connectionObject *self,
} }
if (readonly) { 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, if ((res = pq_set_guc_locked(self,
"default_transaction_read_only", readonly, "default_transaction_read_only", readonly,
&pgres, &error, &_save))) { &pgres, &error, &_save))) {
@ -989,7 +989,7 @@ conn_set_transaction(connectionObject *self,
} }
if (deferrable) { 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, if ((res = pq_set_guc_locked(self,
"default_transaction_deferrable", deferrable, "default_transaction_deferrable", deferrable,
&pgres, &error, &_save))) { &pgres, &error, &_save))) {
@ -998,7 +998,7 @@ conn_set_transaction(connectionObject *self,
} }
if (self->autocommit != autocommit) { 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; self->autocommit = autocommit;
} }

18
psycopg/connection_type.c
View File

@ -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 \ #define psyco_conn_set_session_doc \
"set_transaction(...) -- Set one or more parameters for the next transactions.\n\n" \ "set_session(...) -- Set one or more parameters for the next transactions.\n\n" \
"Accepted arguments are 'isolation_level', 'readonly', 'deferrable', 'autocommit'." "Accepted arguments are 'isolation_level', 'readonly', 'deferrable', 'autocommit'."
static PyObject * 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 *isolevel = Py_None;
PyObject *readonly = 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}; {"isolation_level", "readonly", "deferrable", "autocommit", NULL};
EXC_IF_CONN_CLOSED(self); EXC_IF_CONN_CLOSED(self);
EXC_IF_CONN_ASYNC(self, set_transaction); EXC_IF_CONN_ASYNC(self, set_session);
EXC_IF_IN_TRANSACTION(self, set_transaction); EXC_IF_IN_TRANSACTION(self, set_session);
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO", kwlist, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO", kwlist,
&isolevel, &readonly, &deferrable, &autocommit)) { &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 (-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)) { c_isolevel, c_readonly, c_deferrable, c_autocommit)) {
return NULL; return NULL;
} }
@ -904,8 +904,8 @@ static struct PyMethodDef connectionObject_methods[] = {
{"tpc_recover", (PyCFunction)psyco_conn_tpc_recover, {"tpc_recover", (PyCFunction)psyco_conn_tpc_recover,
METH_NOARGS, psyco_conn_tpc_recover_doc}, METH_NOARGS, psyco_conn_tpc_recover_doc},
#ifdef PSYCOPG_EXTENSIONS #ifdef PSYCOPG_EXTENSIONS
{"set_transaction", (PyCFunction)psyco_conn_set_transaction, {"set_session", (PyCFunction)psyco_conn_set_session,
METH_VARARGS|METH_KEYWORDS, psyco_conn_set_transaction_doc}, METH_VARARGS|METH_KEYWORDS, psyco_conn_set_session_doc},
{"set_isolation_level", (PyCFunction)psyco_conn_set_isolation_level, {"set_isolation_level", (PyCFunction)psyco_conn_set_isolation_level,
METH_VARARGS, psyco_conn_set_isolation_level_doc}, METH_VARARGS, psyco_conn_set_isolation_level_doc},
{"set_client_encoding", (PyCFunction)psyco_conn_set_client_encoding, {"set_client_encoding", (PyCFunction)psyco_conn_set_client_encoding,

48
tests/test_connection.py
View File

@ -729,18 +729,18 @@ class TransactionControlTests(unittest.TestCase):
cur = self.conn.cursor() cur = self.conn.cursor()
cur.execute("select 1") cur.execute("select 1")
self.assertRaises(psycopg2.ProgrammingError, self.assertRaises(psycopg2.ProgrammingError,
self.conn.set_transaction, self.conn.set_session,
psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE) psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE)
def test_set_isolation_level(self): def test_set_isolation_level(self):
cur = self.conn.cursor() cur = self.conn.cursor()
self.conn.set_transaction( self.conn.set_session(
psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE) psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE)
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
self.assertEqual(cur.fetchone()[0], 'serializable') self.assertEqual(cur.fetchone()[0], 'serializable')
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction( self.conn.set_session(
psycopg2.extensions.ISOLATION_LEVEL_REPEATABLE_READ) psycopg2.extensions.ISOLATION_LEVEL_REPEATABLE_READ)
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
if self.conn.server_version > 80000: if self.conn.server_version > 80000:
@ -749,13 +749,13 @@ class TransactionControlTests(unittest.TestCase):
self.assertEqual(cur.fetchone()[0], 'serializable') self.assertEqual(cur.fetchone()[0], 'serializable')
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction( self.conn.set_session(
isolation_level=psycopg2.extensions.ISOLATION_LEVEL_READ_COMMITTED) isolation_level=psycopg2.extensions.ISOLATION_LEVEL_READ_COMMITTED)
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
self.assertEqual(cur.fetchone()[0], 'read committed') self.assertEqual(cur.fetchone()[0], 'read committed')
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction( self.conn.set_session(
isolation_level=psycopg2.extensions.ISOLATION_LEVEL_READ_UNCOMMITTED) isolation_level=psycopg2.extensions.ISOLATION_LEVEL_READ_UNCOMMITTED)
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
if self.conn.server_version > 80000: if self.conn.server_version > 80000:
@ -766,12 +766,12 @@ class TransactionControlTests(unittest.TestCase):
def test_set_isolation_level_str(self): def test_set_isolation_level_str(self):
cur = self.conn.cursor() cur = self.conn.cursor()
self.conn.set_transaction("serializable") self.conn.set_session("serializable")
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
self.assertEqual(cur.fetchone()[0], 'serializable') self.assertEqual(cur.fetchone()[0], 'serializable')
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction("repeatable read") self.conn.set_session("repeatable read")
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
if self.conn.server_version > 80000: if self.conn.server_version > 80000:
self.assertEqual(cur.fetchone()[0], 'repeatable read') self.assertEqual(cur.fetchone()[0], 'repeatable read')
@ -779,12 +779,12 @@ class TransactionControlTests(unittest.TestCase):
self.assertEqual(cur.fetchone()[0], 'serializable') self.assertEqual(cur.fetchone()[0], 'serializable')
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction("read committed") self.conn.set_session("read committed")
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
self.assertEqual(cur.fetchone()[0], 'read committed') self.assertEqual(cur.fetchone()[0], 'read committed')
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction("read uncommitted") self.conn.set_session("read uncommitted")
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
if self.conn.server_version > 80000: if self.conn.server_version > 80000:
self.assertEqual(cur.fetchone()[0], 'read uncommitted') self.assertEqual(cur.fetchone()[0], 'read uncommitted')
@ -793,13 +793,13 @@ class TransactionControlTests(unittest.TestCase):
self.conn.rollback() self.conn.rollback()
def test_bad_isolation_level(self): def test_bad_isolation_level(self):
self.assertRaises(ValueError, self.conn.set_transaction, 0) self.assertRaises(ValueError, self.conn.set_session, 0)
self.assertRaises(ValueError, self.conn.set_transaction, 5) self.assertRaises(ValueError, self.conn.set_session, 5)
self.assertRaises(ValueError, self.conn.set_transaction, 'whatever') self.assertRaises(ValueError, self.conn.set_session, 'whatever')
def test_set_read_only(self): def test_set_read_only(self):
cur = self.conn.cursor() cur = self.conn.cursor()
self.conn.set_transaction(readonly=True) self.conn.set_session(readonly=True)
cur.execute("SHOW default_transaction_read_only;") cur.execute("SHOW default_transaction_read_only;")
self.assertEqual(cur.fetchone()[0], 'on') self.assertEqual(cur.fetchone()[0], 'on')
self.conn.rollback() self.conn.rollback()
@ -808,12 +808,12 @@ class TransactionControlTests(unittest.TestCase):
self.conn.rollback() self.conn.rollback()
cur = self.conn.cursor() cur = self.conn.cursor()
self.conn.set_transaction(readonly=None) self.conn.set_session(readonly=None)
cur.execute("SHOW default_transaction_read_only;") cur.execute("SHOW default_transaction_read_only;")
self.assertEqual(cur.fetchone()[0], 'on') self.assertEqual(cur.fetchone()[0], 'on')
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction(readonly=False) self.conn.set_session(readonly=False)
cur.execute("SHOW default_transaction_read_only;") cur.execute("SHOW default_transaction_read_only;")
self.assertEqual(cur.fetchone()[0], 'off') self.assertEqual(cur.fetchone()[0], 'off')
self.conn.rollback() self.conn.rollback()
@ -826,8 +826,8 @@ class TransactionControlTests(unittest.TestCase):
default_readonly = cur.fetchone()[0] default_readonly = cur.fetchone()[0]
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction(isolation_level='serializable', readonly=True) self.conn.set_session(isolation_level='serializable', readonly=True)
self.conn.set_transaction(isolation_level='default', readonly='default') self.conn.set_session(isolation_level='default', readonly='default')
cur.execute("SHOW default_transaction_isolation;") cur.execute("SHOW default_transaction_isolation;")
self.assertEqual(cur.fetchone()[0], default_isolevel) self.assertEqual(cur.fetchone()[0], default_isolevel)
@ -837,7 +837,7 @@ class TransactionControlTests(unittest.TestCase):
@skip_before_postgres(9, 1) @skip_before_postgres(9, 1)
def test_set_deferrable(self): def test_set_deferrable(self):
cur = self.conn.cursor() 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;") cur.execute("SHOW default_transaction_read_only;")
self.assertEqual(cur.fetchone()[0], 'on') self.assertEqual(cur.fetchone()[0], 'on')
cur.execute("SHOW default_transaction_deferrable;") cur.execute("SHOW default_transaction_deferrable;")
@ -847,7 +847,7 @@ class TransactionControlTests(unittest.TestCase):
self.assertEqual(cur.fetchone()[0], 'on') self.assertEqual(cur.fetchone()[0], 'on')
self.conn.rollback() self.conn.rollback()
self.conn.set_transaction(deferrable=False) self.conn.set_session(deferrable=False)
cur.execute("SHOW default_transaction_read_only;") cur.execute("SHOW default_transaction_read_only;")
self.assertEqual(cur.fetchone()[0], 'on') self.assertEqual(cur.fetchone()[0], 'on')
cur.execute("SHOW default_transaction_deferrable;") cur.execute("SHOW default_transaction_deferrable;")
@ -857,7 +857,7 @@ class TransactionControlTests(unittest.TestCase):
@skip_after_postgres(9, 1) @skip_after_postgres(9, 1)
def test_set_deferrable_error(self): def test_set_deferrable_error(self):
self.assertRaises(psycopg2.ProgrammingError, self.assertRaises(psycopg2.ProgrammingError,
self.conn.set_transaction, readonly=True, deferrable=True) self.conn.set_session, readonly=True, deferrable=True)
class AutocommitTests(unittest.TestCase): class AutocommitTests(unittest.TestCase):
@ -915,8 +915,8 @@ class AutocommitTests(unittest.TestCase):
self.assertRaises(psycopg2.ProgrammingError, self.assertRaises(psycopg2.ProgrammingError,
setattr, self.conn, 'autocommit', True) setattr, self.conn, 'autocommit', True)
def test_set_transaction_autocommit(self): def test_set_session_autocommit(self):
self.conn.set_transaction(autocommit=True) self.conn.set_session(autocommit=True)
self.assert_(self.conn.autocommit) self.assert_(self.conn.autocommit)
self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY) self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY)
self.assertEqual(self.conn.get_transaction_status(), self.assertEqual(self.conn.get_transaction_status(),
@ -928,7 +928,7 @@ class AutocommitTests(unittest.TestCase):
self.assertEqual(self.conn.get_transaction_status(), self.assertEqual(self.conn.get_transaction_status(),
psycopg2.extensions.TRANSACTION_STATUS_IDLE) psycopg2.extensions.TRANSACTION_STATUS_IDLE)
self.conn.set_transaction(autocommit=False) self.conn.set_session(autocommit=False)
self.assert_(not self.conn.autocommit) self.assert_(not self.conn.autocommit)
self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY) self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY)
self.assertEqual(self.conn.get_transaction_status(), self.assertEqual(self.conn.get_transaction_status(),
@ -940,7 +940,7 @@ class AutocommitTests(unittest.TestCase):
psycopg2.extensions.TRANSACTION_STATUS_INTRANS) psycopg2.extensions.TRANSACTION_STATUS_INTRANS)
self.conn.rollback() 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) self.assert_(self.conn.autocommit)
cur.execute('select 1;') cur.execute('select 1;')
self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY) self.assertEqual(self.conn.status, psycopg2.extensions.STATUS_READY)