मैं psycopg2/पायथन डीबी एपीआई के साथ डेटाबेस लेनदेन कैसे कर सकता हूं?

Question

Im psycopg2 के साथ झुकाव, और जबकि .comit() और .rollback() कोई है .begin() या लेनदेन शुरू करने के समान है, या ऐसा लगता है? मैं कैसे लेनदेन psycopg2 के साथ काम करते हैं

db.begin() # possible even set the isolation level here 
curs = db.cursor() 
cursor.execute('select etc... for update') 
... 
cursor.execute('update ... etc.') 
db.commit(); 

करने के लिए तो सक्षम होने के लिए उम्मीद थी,? मैं अलगाव स्तर को कैसे सेट/बदलूं?

Answer 1

db.set_isolation_level(n) का उपयोग करें, मान लें कि db आपकी कनेक्शन ऑब्जेक्ट है। फेडरिको रूप here लिखा था, n का अर्थ है:

0 -> autocommit 
1 -> read committed 
2 -> serialized (but not officially supported by pg) 
3 -> serialized 

रूप here प्रलेखित, psycopg2.extensions आप इस प्रयोजन के लिए प्रतीकात्मक स्थिरांक देता है:

Setting transaction isolation levels 
==================================== 

psycopg2 connection objects hold informations about the PostgreSQL `transaction 
isolation level`_. The current transaction level can be read from the 
`.isolation_level` attribute. The default isolation level is ``READ 
COMMITTED``. A different isolation level con be set through the 
`.set_isolation_level()` method. The level can be set to one of the following 
constants, defined in `psycopg2.extensions`: 

`ISOLATION_LEVEL_AUTOCOMMIT` 
    No transaction is started when command are issued and no 
    `.commit()`/`.rollback()` is required. Some PostgreSQL command such as 
    ``CREATE DATABASE`` can't run into a transaction: to run such command use 
    `.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)`. 

`ISOLATION_LEVEL_READ_COMMITTED` 
    This is the default value. A new transaction is started at the first 
    `.execute()` command on a cursor and at each new `.execute()` after a 
    `.commit()` or a `.rollback()`. The transaction runs in the PostgreSQL 
    ``READ COMMITTED`` isolation level. 

`ISOLATION_LEVEL_SERIALIZABLE` 
    Transactions are run at a ``SERIALIZABLE`` isolation level. 


.. _transaction isolation level: 
    http://www.postgresql.org/docs/8.1/static/transaction-iso.html 

Answer 2

मैं स्पष्ट रूप से देखने के लिए मेरी लेनदेन कर रहे हैं जहां पसंद करते हैं:

• कर्सर.एक्सक्यूट ("BEGIN")
• कर्सर .execute ("COMMIT")

Answer 3

BEGIN पायथन मानक डीबी एपीआई हमेशा निहित है। जब आप डेटाबेस के साथ काम करना शुरू करते हैं तो ड्राइवर BEGIN जारी करता है और COMMIT या ROLLBACK के बाद BEGIN जारी किया जाता है। विनिर्देश के साथ अनुपालन एक पायथन डीबी एपीआई हमेशा इस तरह से काम करना चाहिए (न केवल postgresql)।

आप एलेक्स मार्टेलि द्वारा इंगित db.set_isolation_level(n) के साथ इस सेटिंग को अलोकॉमीट में बदल सकते हैं।

जैसा कि Tebas ने कहा कि शुरुआत अंतर्निहित है लेकिन SQL को निष्पादित होने तक निष्पादित नहीं किया जाता है, इसलिए यदि आप किसी SQL को निष्पादित नहीं करते हैं, तो सत्र लेनदेन में नहीं है।