PostgreSQL
 sql >> डेटाबेस >  >> RDS >> PostgreSQL

क्या Django में कर्सर खुले लेनदेन के अंदर चलते हैं?

मेरा मानना ​​​​है कि एक अलग, एक साथ लेनदेन प्राप्त करने के लिए आपको एक अलग डीबी कनेक्शन की आवश्यकता होगी। मुझे पूरा यकीन है कि django प्रति डेटाबेस केवल एक कनेक्शन का प्रबंधन करता है। लेकिन आप एक और बना सकते हैं। ऐसा न करने का कोई अच्छा कारण हो सकता है। जटिलता दिमाग में आती है।

मुझे लगता है कि ऐसा कुछ काम करेगा:

from django.conf import settings
from django.db.utils import ConnectionHandler

def my_view(request):
    """Flirt with complexity by using two connections to db"""
    private_connections = ConnectionHandler(settings.DATABASES)
    db = router.db_for_write(model)
    new_conn = private_connections[db]
    new_conn.enter_transaction_management()
    new_conn.managed(True)
    new_cur = new_conn.cursor()
    new_cur.execute("INSERT INTO ...")
    new_conn.commit()
    new_conn.close()

ध्यान दें कि आप django.db.transaction . का उपयोग नहीं कर सकते हैं क्योंकि यह django.db.connections . में वैश्विक कनेक्शन इंस्टेंस पर काम करता है , लेकिन किसी भी मामले में, यह कनेक्शन ऑब्जेक्ट पर लेनदेन प्रबंधन विधियों के आसपास सिर्फ एक पतला आवरण है।

मुझे लगता है कि असली सवाल यह है कि आप ऐसा क्यों करना चाहते हैं?! और लक्ष्मण प्रसाद के उत्तर में क्या गलत है? आप जब चाहें कमिट/रोलबैक कर सकते हैं, इसलिए आपको एक ही दृश्य में अलग-अलग लेनदेन में अलग-अलग कार्यों को करने से कोई रोक नहीं सकता है। तथ्य यह है कि लेन-देन समानांतर होना चाहिए और उनके बीच कुछ तार्किक संबंध पर लगातार संकेत नहीं होना चाहिए, जो मेरे दिमाग में इंगित करेगा कि वे वास्तव में एक ही लेनदेन में होने चाहिए।

यदि, दूसरी ओर, आप किसी प्रकार की ऑफ़लाइन प्रक्रिया का अनुकरण करने का प्रयास कर रहे हैं, जिसकी सफलता या विफलता दृश्य के लिए विशेष रूप से प्रासंगिक नहीं है, तो एक संदेश कतार स्थापित करने और इन प्रविष्टियों को एक अलग तरीके से निष्पादित करने पर विचार करें। प्रक्रिया। अजवाइन ऐसा करने के लिए एक लोकप्रिय पैकेज है। अगर प्रतिक्रिया समय एक प्रमुख चिंता का विषय नहीं है, हालांकि, मुझे अभी भी लगता है कि लगातार लेन-देन पर्याप्त होना चाहिए।

अपडेट करें:

यदि आप चाहते हैं कि आपका डेटाबेस-समर्थित कैश एक एकल (अलग) लेनदेन में अपना व्यावसायिक तर्क चलाते हुए ऑटोकॉमिट मोड में संचालित हो, तो एक django तरीका है। आपको केवल यह सुनिश्चित करना है कि कैशिंग बाहर हो commit_on_success :

  • यदि आप केवल कैशिंग मिडलवेयर का उपयोग कर रहे हैं, तो सुनिश्चित करें कि यह TransactionMiddleware से बाहर है। ।

  • यदि आप कैशिंग व्यू डेकोरेटर्स का उपयोग करते हैं, तो मुझे लगता है कि आप TransactionMiddleware को अक्षम कर सकते हैं। (या समस्या दृश्य को autocommit . के अंदर रखें डेकोरेटर) और commit_on_success . का उपयोग करें डेकोरेटर अंदर कैशिंग डेकोरेटर। यह मज़ेदार लग रहा है, लेकिन मुझे नहीं पता कि यह काम क्यों नहीं करेगा:

    @transaction.autocommit
    @cache_page(500)
    @transaction.commit_on_success
    def my_view(request):
        "..."
    
  • यदि आप टेम्प्लेट कैशिंग का उपयोग करते हैं या अधिक शामिल मैन्युअल कैशिंग करते हैं, तो आप TransactionMiddleware को अक्षम भी कर सकते हैं (या समस्या दृश्य को autocommit . के अंदर रखें डेकोरेटर) और commit_on_success . का उपयोग करें एक संदर्भ प्रबंधक के रूप में केवल वही कोड डालने के लिए जिसकी आपको एक प्रबंधित लेनदेन में आवश्यकता होती है, शेष दृश्य को ऑटोकॉमिट में छोड़ देता है।

    @transaction.autocommit
    def my_view(request):
        data = cache.get(some_key)
        with transaction.commit_on_success():
            context = do_some_processing(data)
        cache.set(some_key, context['data'])
        return render('template/with/cache/blocks.html', context=context)
    


  1. Database
  2.   
  3. Mysql
  4.   
  5. Oracle
  6.   
  7. Sqlserver
  8.   
  9. PostgreSQL
  10.   
  11. Access
  12.   
  13. SQLite
  14.   
  15. MariaDB
  1. PostgreSQL 12 में प्रगति रिपोर्टिंग संवर्द्धन

  2. .net कोर वेब एपीआई में ssl प्रमाणपत्रों के साथ Npgsql कनेक्शन

  3. कॉन्फ़िगरेशन पैरामीटर कैसे निकालें

  4. चेंजसेट स्कोप को प्रबंधित करने के लिए लिक्विबेस चेंजसेट संदर्भ विशेषता के साथ स्प्रिंग बूट प्रोफाइल का उपयोग करना

  5. PostgreSQL में महीने के हिसाब से चयन