डेटाबेस संसाधनों का उचित प्रबंधन:कर्सर और कनेक्शन

यह एक अजगर संदर्भ प्रबंधक के लिए एक महान उपयोग के मामले की तरह लगता है . प्रसंग प्रबंधक आपको संसाधनों को ठीक से प्रबंधित करने . की अनुमति देते हैं , जैसे डेटाबेस कनेक्शन, आपको यह निर्दिष्ट करने की अनुमति देकर कि आपके संसाधन के सेट-अप और फाड़ने के तरीके कैसे काम करने चाहिए . आप दो तरीकों में से एक में अपना स्वयं का कस्टम संदर्भ प्रबंधक बना सकते हैं:पहला, अपने डेटाबेस वर्ग को लपेटकर, और संदर्भ प्रबंधक के लिए आवश्यक विधियों को लागू करके:__init__() , __enter__() , और __exit__() . दूसरा, @contextmanager . का उपयोग करके फ़ंक्शन परिभाषा पर डेकोरेटर और उक्त फ़ंक्शन परिभाषा के भीतर अपने डेटाबेस संसाधन के लिए एक जनरेटर बनाना। मैं दोनों दृष्टिकोण दिखाऊंगा और आपको यह तय करने दूंगा कि आपकी पसंद कौन सी है। __init__() विधि आरंभीकरण विधि है आपके कस्टम संदर्भ प्रबंधक के लिए, कस्टम पायथन कक्षाओं के लिए उपयोग की जाने वाली प्रारंभिक विधि के समान। __enter__() विधि आपका सेटअप कोड है आपके कस्टम संदर्भ प्रबंधक के लिए। अंत में, __exit()__ तरीका है आपका फाड़ना आपके कस्टम संदर्भ प्रबंधक के लिए कोड। दोनों दृष्टिकोण इन विधियों का उपयोग करते हैं मुख्य अंतर के साथ पहली विधि स्पष्ट रूप से इन विधियों को आपकी कक्षा परिभाषा के भीतर बताएगी। जहां दूसरे दृष्टिकोण की तरह, आपके जनरेटर के yield . तक के सभी कोड स्टेटमेंट आपका आरंभीकरण और सेटअप कोड है और सभी कोड yield . के बाद स्टेटमेंट आपका टियरडाउन कोड है। मैं आपके उपयोगकर्ता आधारित डेटाबेस क्रियाओं को उपयोगकर्ता मॉडल वर्ग में निकालने पर भी विचार करूंगा। की तर्ज पर कुछ:

कस्टम संदर्भ प्रबंधक:(वर्ग आधारित दृष्टिकोण ):

import pymysql

class MyDatabase():
    def __init__(self):
        self.host = '127.0.0.1'
        self.user = 'root'
        self.password = ''
        self.db = 'API'

        self.con = None
        self.cur = None

    def __enter__(self):
        # connect to database
        self.con = pymysql.connect(host=self.host, user=self.user, password=self.password, db=self.db, cursorclass=pymysql.cursors.DictCursor, autocommit=True)
        self.cur = self.con.cursor()
        return self.cur

    def __exit__(self, exc_type, exc_val, traceback):
        # params after self are for dealing with exceptions
        self.con.close()

user.py (refactored) :'

# import your custom context manager created from the step above
# if you called your custom context manager file my_database.py: from my_database import MyDatabase

import <custom_context_manager>

class User:
    def getUser(self, id):
        sql = 'SELECT * from users where id = %d'
        with MyDatabase() as db: 
            db.execute(sql, (id))
            result = db.fetchall()

        return result

    def getAllUsers(self):
        sql = 'SELECT * from users'
        with MyDatabase() as db: 
            db.execute(sql)
            result = db.fetchall()
        return result

    def AddUser(self, firstName, lastName, email):
        sql = "INSERT INTO `users` (`firstName`, `lastName`, `email`) VALUES (%s, %s, %s)"
        with MyDatabase() as db:
            db.execute(sql, (firstName, lastName, email))

संदर्भ प्रबंधक (सज्जाकार दृष्टिकोण) :

from contextlib import contextmanager
import pymysql


@contextmanager
def my_database():
    try:
        host = '127.0.0.1'
        user = 'root'
        password = ''
        db = 'API'
        con = pymysql.connect(host=host, user=user, password=password, db=db, cursorclass=pymysql.cursors.DictCursor, autocommit=True)
        cur = con.cursor()
        yield cur
    finally:
        con.close()

फिर अपने User . के अंदर आप पहले फ़ाइल को आयात करके और फिर इसे पहले की तरह उपयोग करके संदर्भ प्रबंधक का उपयोग कर सकते हैं:

with my_database() as db:
   sql = <whatever sql stmt you wish to execute>
   #db action 
   db.execute(sql)

उम्मीद है कि इससे मदद मिलेगी!