பைதான் போஸ்ட்கிரஸ் ஒருங்கிணைப்பு: Psycopg2-க்கான ஒரு விரிவான வழிகாட்டி

மென்பொருள் மேம்பாட்டு உலகில், ஒரு நிரலாக்க மொழிக்கும் தரவுத்தளத்திற்கும் இடையிலான ஒருங்கிணைப்பு, உறுதியான, அளவிடக்கூடிய மற்றும் தரவு சார்ந்த பயன்பாடுகளை உருவாக்க அடிப்படையானது. அதன் எளிமை மற்றும் சக்திக்கு அறியப்பட்ட பைதான் மற்றும் அதன் நம்பகத்தன்மை மற்றும் மேம்பட்ட அம்சங்களுக்குப் புகழ்பெற்ற போஸ்ட்கிரஸ் ஆகியவற்றுக்கு இடையிலான சேர்க்கை, எந்தவொரு அளவிலான திட்டங்களுக்கும் ஒரு வலிமையான அடுக்கை உருவாக்குகிறது. இந்த இரண்டு தொழில்நுட்பங்களையும் இணைக்கும் பாலம் ஒரு தரவுத்தள அடாப்டர் ஆகும், மேலும் போஸ்ட்கிரஸ்-ஐப் பொறுத்தவரை, பைதான் சூழலியல் அமைப்பில் உள்ள நடைமுறைத் தரநிலை psycopg2 ஆகும்.

இந்த விரிவான வழிகாட்டி, தரவுத்தள ஒருங்கிணைப்பில் புதிதாகத் தொடங்குபவர்கள் முதல் தங்கள் திறன்களை மேம்படுத்த விரும்பும் அனுபவம் வாய்ந்த பொறியாளர்கள் வரை உலகளாவிய டெவலப்பர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. Psycopg2 நூலகத்தை ஆழமாக ஆராய்வோம், முதல் இணைப்பு முதல் மேம்பட்ட செயல்திறன் மேம்பாட்டு நுட்பங்கள் வரை அனைத்தையும் உள்ளடக்குவோம். உங்கள் பயன்பாடு பாதுகாப்பானது, திறமையானது மற்றும் பராமரிக்கக்கூடியது என்பதை உறுதிப்படுத்தும் சிறந்த நடைமுறைகளில் எங்கள் கவனம் இருக்கும்.

பைதான் மற்றும் போஸ்ட்கிரஸ் ஏன்? ஒரு சக்திவாய்ந்த கூட்டணி

Psycopg2-ன் தொழில்நுட்ப விவரங்களுக்குள் செல்வதற்கு முன், இந்த சேர்க்கை ஏன் மிகவும் மதிக்கப்படுகிறது என்பதைப் புரிந்துகொள்வது பயனுள்ளது:

• பைதான்-ன் பலங்கள்: அதன் சுத்தமான தொடரியல், விரிவான நிலையான நூலகம், மற்றும் மூன்றாம் தரப்பு தொகுப்புகளின் பெரிய சூழலியல் அமைப்பு, வலை மேம்பாடு, தரவு பகுப்பாய்வு, செயற்கை நுண்ணறிவு மற்றும் பலவற்றிற்கு இதை சிறந்ததாக்குகிறது. இது டெவலப்பர் உற்பத்தித்திறன் மற்றும் குறியீடு படிக்கும் திறனுக்கு முன்னுரிமை அளிக்கிறது.
• போஸ்ட்கிரஸ்-ன் பலங்கள்: பெரும்பாலும் "உலகின் மிக மேம்பட்ட திறந்த மூல ரிலேஷனல் தரவுத்தளம்" என்று அழைக்கப்படும் போஸ்ட்கிரஸ், ACID-இணக்கமானது, மிகவும் நீட்டிக்கக்கூடியது, மேலும் JSON, XML மற்றும் புவியியல் தரவு உட்பட பலதரப்பட்ட தரவு வகைகளை ஆதரிக்கிறது. அதன் தரவு ஒருமைப்பாடு மற்றும் செயல்திறனுக்காக ஸ்டார்ட்அப்கள் மற்றும் பெரிய நிறுவனங்களால் நம்பப்படுகிறது.
• Psycopg2: சரியான மொழிபெயர்ப்பாளர்: Psycopg2 ஒரு முதிர்ந்த, சுறுசுறுப்பாகப் பராமரிக்கப்படும் மற்றும் அம்சம் நிறைந்த அடாப்டர் ஆகும். இது பைதான் தரவு வகைகளை போஸ்ட்கிரஸ் வகைகளாகவும், நேர்மாறாகவும் திறமையாக மொழிபெயர்க்கிறது, தரவுத்தளத் தொடர்புக்கு தடையற்ற மற்றும் செயல்திறன் மிக்க இடைமுகத்தை வழங்குகிறது.

உங்கள் மேம்பாட்டுச் சூழலை அமைத்தல்

இந்த வழிகாட்டியுடன் நீங்கள் தொடர்ந்து செயல்பட, சில முன் நிபந்தனைகள் உங்களுக்குத் தேவைப்படும். உங்களிடம் ஏற்கனவே பைதான் மற்றும் ஒரு போஸ்ட்கிரஸ் சர்வர் இயங்குவதாகக் கருதி, நூலகத்தை நிறுவுவதில் கவனம் செலுத்துவோம்.

முன்நிபந்தனைகள்

• பைதான்: உங்கள் கணினியில் நிறுவப்பட்ட பைதான்-ன் ஒரு நவீன பதிப்பு (3.7+ பரிந்துரைக்கப்படுகிறது).
• போஸ்ட்கிரஸ்: ஒரு போஸ்ட்கிரஸ் சர்வருக்கான அணுகல். இது உங்கள் கணினியில் ஒரு உள்ளூர் நிறுவலாகவோ, ஒரு கொள்கலன்ப்படுத்தப்பட்ட நிகழ்வாகவோ (எ.கா., டாக்கரைப் பயன்படுத்தி), அல்லது ஒரு கிளவுட்-ஹோஸ்ட் செய்யப்பட்ட தரவுத்தள சேவையாகவோ இருக்கலாம். உங்களுக்கு அங்கீகார விவரங்கள் (தரவுத்தளப் பெயர், பயனர், கடவுச்சொல்) மற்றும் இணைப்பு விவரங்கள் (ஹோஸ்ட், போர்ட்) தேவைப்படும்.
• பைதான் விர்ச்சுவல் என்விரான்மென்ட் (அதிகமாகப் பரிந்துரைக்கப்படுகிறது): சிஸ்டம் முழுவதும் உள்ள தொகுப்புகளுடன் மோதல்களைத் தவிர்க்க, ஒரு விர்ச்சுவல் என்விரான்மென்டில் வேலை செய்வது ஒரு சிறந்த நடைமுறை. நீங்கள் `python3 -m venv myproject_env` ஐப் பயன்படுத்தி ஒன்றை உருவாக்கி அதைச் செயல்படுத்தலாம்.

Psycopg2 ஐ நிறுவுதல்

Psycopg2 ஐ நிறுவ பரிந்துரைக்கப்பட்ட வழி அதன் பைனரி தொகுப்பைப் பயன்படுத்துவதாகும், இது மூலத்திலிருந்து தொகுப்பதற்கும் C-நிலை சார்புகளை நிர்வகிப்பதற்கும் உள்ள சிரமத்தைத் தவிர்க்கிறது. உங்கள் டெர்மினல் அல்லது கட்டளை வரியில் (உங்கள் விர்ச்சுவல் என்விரான்மென்ட் செயல்படுத்தப்பட்ட நிலையில்) திறந்து இயக்கவும்:

pip install psycopg2-binary

நீங்கள் `pip install psycopg2` க்கான குறிப்புகளைக் காணலாம். `psycopg2` தொகுப்பிற்கு உங்கள் கணினியில் உருவாக்க கருவிகள் மற்றும் போஸ்ட்கிரஸ் மேம்பாட்டுத் தலைப்புகள் நிறுவப்பட்டிருக்க வேண்டும், இது சிக்கலானதாக இருக்கலாம். `psycopg2-binary` தொகுப்பு என்பது பெரும்பாலான நிலையான இயக்க முறைமைகளுக்கு உடனடியாக வேலை செய்யும் ஒரு முன்-தொகுக்கப்பட்ட பதிப்பாகும், இது பயன்பாட்டு மேம்பாட்டிற்கான விருப்பமான தேர்வாக அமைகிறது.

ஒரு தரவுத்தள இணைப்பை நிறுவுதல்

எந்தவொரு தரவுத்தள தொடர்புகளிலும் முதல் படி ஒரு இணைப்பை நிறுவுவதாகும். Psycopg2, `psycopg2.connect()` செயல்பாட்டின் மூலம் இதை எளிதாக்குகிறது.

இணைப்பு அளவுருக்கள்

The `connect()` செயல்பாடு சில வழிகளில் இணைப்பு அளவுருக்களை ஏற்கலாம், ஆனால் மிகவும் பொதுவான மற்றும் படிக்கக்கூடிய முறை கீவேர்ட் ஆர்கியுமென்ட்ஸ் அல்லது ஒரு ஒற்றை இணைப்பு சரம் (DSN - Data Source Name) பயன்படுத்துவதாகும்.

முக்கிய அளவுருக்கள்:

• dbname: நீங்கள் இணைக்க விரும்பும் தரவுத்தளத்தின் பெயர்.
• user: அங்கீகாரத்திற்கான பயனர் பெயர்.
• password: குறிப்பிட்ட பயனருக்கான கடவுச்சொல்.
• host: தரவுத்தள சர்வர் முகவரி (எ.கா., 'localhost' அல்லது ஒரு IP முகவரி).
• port: சர்வர் கேட்கும் போர்ட் எண் (போஸ்ட்கிரஸ்-க்கு இயல்புநிலை 5432).

பாதுகாப்பு குறித்த ஒரு குறிப்பு: அங்கீகார விவரங்களை குறியீட்டில் நேரடியாக எழுத வேண்டாம்!

உங்கள் தரவுத்தள அங்கீகார விவரங்களை உங்கள் மூலக் குறியீட்டில் நேரடியாக எப்போதும் ஹார்ட்கோட் செய்யக்கூடாது என்பது ஒரு முக்கியமான பாதுகாப்புச் சிறந்த நடைமுறையாகும். இது முக்கியமான தகவல்களை வெளிப்படுத்துகிறது மற்றும் வெவ்வேறு சூழல்களை (மேம்பாடு, சோதனை, உற்பத்தி) நிர்வகிப்பதை கடினமாக்குகிறது. அதற்குப் பதிலாக, சூழல் மாறிகள் அல்லது ஒரு பிரத்யேக உள்ளமைவு மேலாண்மை அமைப்பைப் பயன்படுத்தவும்.

ஒரு சூழல் மேலாளருடன் இணைத்தல்

ஒரு இணைப்பை நிர்வகிக்க மிகவும் பைதான் சார்ந்த மற்றும் பாதுகாப்பான வழி `with` கூற்றைப் பயன்படுத்துவதாகும். இது தொகுதிக்குள் பிழைகள் ஏற்பட்டாலும் இணைப்பு தானாகவே மூடப்படுவதை உறுதி செய்கிறது.

            
import psycopg2
import os # Used to get environment variables

try:
    # It's a best practice to load credentials from environment variables
    # or a secure configuration file, not hardcode them.
    with psycopg2.connect(
        dbname=os.environ.get("DB_NAME"),
        user=os.environ.get("DB_USER"),
        password=os.environ.get("DB_PASSWORD"),
        host=os.environ.get("DB_HOST", "127.0.0.1"),
        port=os.environ.get("DB_PORT", "5432")
    ) as conn:
        print("Connection to PostgreSQL successful!")
        # You can perform database operations here

except psycopg2.OperationalError as e:
    print(f"Could not connect to the database: {e}")

            

              
                Copy
              
            
          

கர்சர்கள்: கட்டளைகளைச் செயல்படுத்துவதற்கான உங்கள் நுழைவாயில்

ஒரு இணைப்பு நிறுவப்பட்டவுடன், நீங்கள் நேரடியாக அதில் வினவல்களை இயக்க முடியாது. உங்களுக்கு கர்சர் எனப்படும் ஒரு இடைநிலை பொருள் தேவை. ஒரு கர்சர் ஒரு தரவுத்தள அமர்வை உள்ளடக்கியது, அந்த அமர்வுக்குள் பல கட்டளைகளை அதன் நிலையைப் பராமரிக்கும்போது நீங்கள் இயக்க அனுமதிக்கிறது.

இணைப்பை தரவுத்தளத்திற்கு ஒரு தொலைபேசி வரியாகவும், கர்சரை அந்த வரியில் நீங்கள் பேசும் உரையாடலாகவும் சிந்தியுங்கள். நீங்கள் ஒரு செயலில் உள்ள இணைப்பிலிருந்து ஒரு கர்சரை உருவாக்குகிறீர்கள்.

இணைப்புகளைப் போலவே, கர்சர்களும் `with` கூற்றைப் பயன்படுத்தி நிர்வகிக்கப்பட வேண்டும், அவை சரியாக மூடப்பட்டு, அவை வைத்திருக்கும் எந்தவொரு ஆதாரங்களையும் வெளியிடுவதை உறுதி செய்ய.

            
# ... inside the 'with psycopg2.connect(...) as conn:' block

with conn.cursor() as cur:
    # Now you can execute queries using 'cur'
    cur.execute("SELECT version();")
    db_version = cur.fetchone()
    print(f"Database version: {db_version}")

            

              
                Copy
              
            
          

வினவல்களைச் செயல்படுத்துதல்: முக்கிய CRUD செயல்பாடுகள்

CRUD என்பது உருவாக்குதல், படித்தல், புதுப்பித்தல் மற்றும் நீக்குதல் என்பதன் சுருக்கமாகும். இவை எந்தவொரு நீடித்த சேமிப்பக அமைப்பின் நான்கு அடிப்படை செயல்பாடுகளாகும். Psycopg2 உடன் ஒவ்வொன்றையும் எவ்வாறு செய்வது என்று பார்ப்போம்.

ஒரு முக்கியமான பாதுகாப்பு குறிப்பு: SQL இன்ஜெக்ஷன்

பயனர் உள்ளீட்டை உள்ளடக்கிய எந்தவொரு வினவல்களையும் எழுதுவதற்கு முன், நாம் மிக முக்கியமான பாதுகாப்பு அச்சுறுத்தலைச் சமாளிக்க வேண்டும்: SQL இன்ஜெக்ஷன். தரவு உள்ளீடுகளில் தீங்கிழைக்கும் SQL குறியீட்டைச் செருகுவதன் மூலம் ஒரு தாக்குபவர் உங்கள் SQL வினவல்களை கையாளும் போது இந்த தாக்குதல் நிகழ்கிறது.

வெளிப்புற தரவுகளுடன் உங்கள் வினவல்களை உருவாக்க பைதான்-ன் சரம் வடிவமைப்பை (f-strings, `%` ஆபரேட்டர், அல்லது `.format()`) ஒருபோதும் பயன்படுத்த வேண்டாம். இது மிகவும் ஆபத்தானது.

தவறு மற்றும் ஆபத்தானது:

cur.execute(f"SELECT * FROM users WHERE username = '{user_input}';")

சரியானது மற்றும் பாதுகாப்பானது:

Psycopg2 உங்கள் வினவல்களுக்கு அளவுருக்களை அனுப்ப ஒரு பாதுகாப்பான வழியை வழங்குகிறது. உங்கள் SQL சரத்தில் ப்ளேஸ்ஹோல்டர்களை (%s) பயன்படுத்துகிறீர்கள் மற்றும் `execute()` க்கு இரண்டாவது ஆர்கியுமென்ட்டாக மதிப்புகளின் ஒரு டூப்லை அனுப்புகிறீர்கள். அடாப்டர் மதிப்புகளின் சரியான எஸ்கேப்பிங் மற்றும் மேற்கோளைக் கையாள்கிறது, எந்தவொரு தீங்கிழைக்கும் உள்ளீட்டையும் நடுநிலையாக்குகிறது.

cur.execute("SELECT * FROM users WHERE username = %s;", (user_input,))

உங்கள் வினவல்களில் தரவை அனுப்ப எப்போதும் இந்த முறையைப் பயன்படுத்தவும். `(user_input,)` இல் உள்ள பின்னோக்கிய காற்புள்ளி, பைதான் ஒரு ஒற்றை உறுப்புடன் இருந்தாலும் ஒரு டூப்லை உருவாக்குவதை உறுதிப்படுத்த முக்கியமானது.

உருவாக்குதல்: தரவைச் செருகுதல்

தரவைச் செருக, நீங்கள் ஒரு `INSERT` கூற்றைப் பயன்படுத்துகிறீர்கள். வினவலை இயக்கிய பிறகு, மாற்றங்களை நிரந்தரமாக்க பரிவர்த்தனையை நீங்கள் உறுதிப்படுத்த வேண்டும்.

            
# Assume we have a table: CREATE TABLE employees (id SERIAL PRIMARY KEY, name VARCHAR(100), department VARCHAR(50));

try:
    with psycopg2.connect(...) as conn:
        with conn.cursor() as cur:
            sql = "INSERT INTO employees (name, department) VALUES (%s, %s);"
            cur.execute(sql, ("Alice Wonderland", "Engineering"))

            # Commit the transaction to make the changes permanent
            conn.commit()
            print("Employee record inserted successfully.")

except (Exception, psycopg2.DatabaseError) as error:
    print(error)
    # If an error occurs, you might want to rollback any partial changes
    # conn.rollback() # The 'with' statement handles this implicitly on error exit

            

              
                Copy
              
            
          

பல வரிசைகளைச் செருகுதல்

பல வரிசைகளைச் செருக, `execute()` உடன் ஒரு சுழற்சியைப் பயன்படுத்துவது திறமையற்றது. Psycopg2, `executemany()` முறையை வழங்குகிறது, இது மிக வேகமாக இருக்கும்.

            
# ... inside the cursor block

employees_to_add = [
    ("Bob Builder", "Construction"),
    ("Charlie Chaplin", "Entertainment"),
    ("Dora Explorer", "Logistics")
]

sql = "INSERT INTO employees (name, department) VALUES (%s, %s);"
cur.executemany(sql, employees_to_add)
conn.commit()
print(f"{cur.rowcount} records inserted successfully.")

            

              
                Copy
              
            
          

படித்தல்: தரவைப் பெறுதல்

தரவைப் படித்தல் `SELECT` கூற்றுடன் செய்யப்படுகிறது. வினவலை இயக்கிய பிறகு, முடிவுகளைப் பெற கர்சரின் பெறுதல் முறைகளில் ஒன்றைப் பயன்படுத்துகிறீர்கள்.

• fetchone(): ஒரு வினவல் முடிவுத் தொகுப்பின் அடுத்த வரிசையைப் பெற்று ஒரு ஒற்றை டூப்லை வழங்குகிறது, அல்லது `None`-ஐ வழங்குகிறது.
• fetchall(): ஒரு வினவல் முடிவின் மீதமுள்ள அனைத்து வரிசைகளையும் பெற்று, டூப்லாய்களின் பட்டியலை வழங்குகிறது. மிக பெரிய முடிவுத் தொகுப்புகளுடன் இதைப் பயன்படுத்தும் போது எச்சரிக்கையாக இருங்கள், ஏனெனில் இது அதிக நினைவகத்தை உட்கொள்ளும்.
• fetchmany(size=cursor.arraysize): ஒரு வினவல் முடிவிலிருந்து அடுத்த வரிசைகளை பெற்று, டூப்லாய்களின் பட்டியலை வழங்குகிறது. மேலும் வரிசைகள் இல்லாதபோது ஒரு வெற்றுப் பட்டியல் வழங்கப்படுகிறது.

            
# ... inside the cursor block

cur.execute("SELECT name, department FROM employees WHERE department = %s;", ("Engineering",))

print("Fetching all engineering employees:")
all_engineers = cur.fetchall()
for engineer in all_engineers:
    print(f"Name: {engineer[0]}, Department: {engineer[1]}")

# Example with fetchone to get a single record
cur.execute("SELECT name FROM employees WHERE id = %s;", (1,))
first_employee = cur.fetchone()
if first_employee:
    print(f"Employee with ID 1 is: {first_employee[0]}")

            

              
                Copy
              
            
          

புதுப்பித்தல்: தரவை மாற்றுதல்

ஏற்கனவே உள்ள பதிவுகளைப் புதுப்பிப்பது `UPDATE` கூற்றைப் பயன்படுத்துகிறது. எந்த வரிசைகளை மாற்ற வேண்டும் என்பதைக் குறிப்பிட `WHERE` விதியை பயன்படுத்த நினைவில் கொள்ளுங்கள், மேலும் எப்போதும் அளவுரு பதிலீட்டைப் பயன்படுத்தவும்.

            
# ... inside the cursor block

sql = "UPDATE employees SET department = %s WHERE name = %s;"
cur.execute(sql, ("Senior Management", "Alice Wonderland"))
conn.commit()
print(f"{cur.rowcount} record(s) updated.")

            

              
                Copy
              
            
          

நீக்குதல்: தரவை அகற்றுதல்

அதேபோல், `DELETE` கூற்று பதிவுகளை நீக்குகிறது. உங்கள் முழு அட்டவணையையும் தற்செயலாக நீக்குவதைத் தவிர்க்க, `WHERE` விதி இங்கே முக்கியமானது.

            
# ... inside the cursor block

sql = "DELETE FROM employees WHERE name = %s;"
cur.execute(sql, ("Charlie Chaplin",))
conn.commit()
print(f"{cur.rowcount} record(s) deleted.")

            

              
                Copy
              
            
          

பரிவர்த்தனை மேலாண்மை: தரவு ஒருமைப்பாட்டை உறுதி செய்தல்

பரிவர்த்தனைகள் ரிலேஷனல் தரவுத்தளங்களில் ஒரு முக்கிய கருத்தாகும். ஒரு பரிவர்த்தனை என்பது ஒரு ஒற்றை தர்க்கரீதியான வேலை அலகு என செய்யப்படும் செயல்பாடுகளின் வரிசையாகும். பரிவர்த்தனைகளின் முக்கிய பண்புகள் பெரும்பாலும் ACID என்ற சுருக்கத்தால் சுருக்கப்படுகின்றன: அணுக்கத்தன்மை (Atomicity), ஒருமைப்பாடு (Consistency), தனிமைப்படுத்தல் (Isolation) மற்றும் நிலைப்புத்தன்மை (Durability).

Psycopg2 இல், உங்கள் முதல் SQL கட்டளையை நீங்கள் செயல்படுத்தும்போது ஒரு பரிவர்த்தனை தானாகவே தொடங்கப்படும். பரிவர்த்தனையை முடிப்பது உங்கள் கைகளில் உள்ளது:

• உறுதிப்படுத்துதல் (Committing): `conn.commit()` பரிவர்த்தனைக்குள் செய்யப்பட்ட அனைத்து மாற்றங்களையும் தரவுத்தளத்தில் சேமிக்கிறது.
• மீளமைத்தல் (Rolling back): `conn.rollback()` பரிவர்த்தனைக்குள் செய்யப்பட்ட அனைத்து மாற்றங்களையும் நிராகரிக்கிறது.

சரியான பரிவர்த்தனை மேலாண்மை மிக முக்கியம். இரண்டு வங்கிக் கணக்குகளுக்கு இடையே நிதி பரிமாற்றம் செய்வதாக கற்பனை செய்து பாருங்கள். நீங்கள் ஒரு கணக்கில் பற்று வைத்து மற்றொன்றில் வரவு வைக்க வேண்டும். இரண்டு செயல்பாடுகளும் வெற்றிபெற வேண்டும், அல்லது இரண்டும் தோல்வியடைய வேண்டும். பற்று வெற்றிபெற்ற பிறகு வரவு செயல்பாடு தோல்வியுற்றால், தரவு முரண்பாட்டைத் தடுக்க நீங்கள் பற்றை மீளமைக்க வேண்டும்.

            
# A robust transaction example
conn = None
try:
    conn = psycopg2.connect(...)
    with conn.cursor() as cur:
        # Operation 1: Debit from account A
        cur.execute("UPDATE accounts SET balance = balance - 100 WHERE id = 1;")

        # Operation 2: Credit to account B
        cur.execute("UPDATE accounts SET balance = balance + 100 WHERE id = 2;")

        # If both operations succeed, commit the transaction
        conn.commit()
        print("Transaction completed successfully.")

except (Exception, psycopg2.DatabaseError) as error:
    print(f"Error in transaction: {error}")
    # If there is any error, roll back the changes
    if conn:
        conn.rollback()
        print("Transaction rolled back.")

finally:
    # Ensure the connection is closed
    if conn:
        conn.close()

            

              
                Copy
              
            
          

The `with psycopg2.connect(...) as conn:` வடிவம் இதை எளிதாக்குகிறது. தொகுதி சாதாரணமாக வெளியேறினால், psycopg2 மறைமுகமாக உறுதிப்படுத்துகிறது. ஒரு விதிவிலக்கு காரணமாக வெளியேறினால், அது மறைமுகமாக மீளமைக்கிறது. இது பல பயன்பாட்டு நிகழ்வுகளுக்கு பெரும்பாலும் போதுமானது மற்றும் மிகவும் சுத்தமானது.

மேம்பட்ட Psycopg2 அம்சங்கள்

அகராதிகளுடன் பணிபுரிதல் (DictCursor)

இயல்புநிலையாக, பெறுதல் முறைகள் டூப்லை வழங்குகின்றன. குறியீட்டின் மூலம் தரவை அணுகுவது (எ.கா., `row[0]`, `row[1]`) படிப்பதற்கும் பராமரிப்பதற்கும் கடினமாக இருக்கலாம். Psycopg2, `DictCursor` போன்ற சிறப்பு கர்சர்களை வழங்குகிறது, இது வரிசைகளை அகராதி போன்ற பொருட்களாக வழங்குகிறது, அவற்றின் பெயர்களைக் கொண்டு நிரல்களை அணுக உங்களை அனுமதிக்கிறது.

            
from psycopg2.extras import DictCursor

# ... inside the 'with psycopg2.connect(...) as conn:' block

# Note the cursor_factory argument
with conn.cursor(cursor_factory=DictCursor) as cur:
    cur.execute("SELECT id, name, department FROM employees WHERE id = %s;", (1,))
    employee = cur.fetchone()
    if employee:
        print(f"ID: {employee['id']}, Name: {employee['name']}")

            

              
                Copy
              
            
          

போஸ்ட்கிரஸ் தரவு வகைகளைக் கையாளுதல்

Psycopg2, பைதான் வகைகளுக்கும் போஸ்ட்கிரஸ் வகைகளுக்கும் இடையே தானாக மாற்றியமைப்பதில் சிறந்த வேலையைச் செய்கிறது.

• பைதான் `None` என்பது SQL `NULL`-க்கு இணையாகிறது.
• பைதான் `int` என்பது `integer`-க்கு இணையாகிறது.
• பைதான் `float` என்பது `double precision`-க்கு இணையாகிறது.
• பைதான் `datetime` பொருள்கள் `timestamp`-க்கு இணையாகிறது.
• பைதான் `list` ஆனது போஸ்ட்கிரஸ் `ARRAY` வகைகளுக்கு இணையாகலாம்.
• பைதான் `dict` ஆனது `JSONB` அல்லது `JSON`-க்கு இணையாகலாம்.

இந்த தடையற்ற தழுவல் சிக்கலான தரவு கட்டமைப்புகளுடன் பணிபுரிவதை நம்பமுடியாத அளவிற்கு உள்ளுணர்வாக ஆக்குகிறது.

உலகளாவிய பார்வையாளர்களுக்கான செயல்திறன் மற்றும் சிறந்த நடைமுறைகள்

செயல்பாட்டு தரவுத்தள குறியீட்டை எழுதுவது ஒரு விஷயம்; செயல்திறன் மிக்க மற்றும் உறுதியான குறியீட்டை எழுதுவது மற்றொரு விஷயம். உயர்தர பயன்பாடுகளை உருவாக்குவதற்கான அத்தியாவசிய நடைமுறைகள் இங்கே:

இணைப்பு திரட்டுதல்

ஒரு புதிய தரவுத்தள இணைப்பை நிறுவுவது ஒரு விலையுயர்ந்த செயல்பாடாகும். இதில் பிணைய ஹேண்ட்ஷேக்குகள், அங்கீகாரம் மற்றும் தரவுத்தள சேவையகத்தில் செயல்முறை உருவாக்கம் ஆகியவை அடங்கும். ஒரு வலை பயன்பாட்டில் அல்லது பல ஒரே நேரத்தில் கோரிக்கைகளைக் கையாளும் எந்தவொரு சேவையிலும், ஒவ்வொரு கோரிக்கைக்கும் ஒரு புதிய இணைப்பை உருவாக்குவது மிகவும் திறமையற்றது மற்றும் அளவிடப்படாது.

தீர்வு இணைப்பு திரட்டுதல் (connection pooling). ஒரு இணைப்புத் திரட்டு என்பது தரவுத்தள இணைப்புகளின் கேச் ஆகும், அவை மீண்டும் பயன்படுத்தப்படலாம். ஒரு பயன்பாட்டிற்கு ஒரு இணைப்பு தேவைப்படும்போது, அது திரட்டிலிருந்து ஒன்றைக் கடன் வாங்குகிறது. அது முடிந்ததும், அதை மூடுவதற்குப் பதிலாக இணைப்பைத் திரட்டிற்குத் திருப்பி விடுகிறது.

Psycopg2 அதன் `psycopg2.pool` தொகுதியில் உள்ளமைக்கப்பட்ட இணைப்புத் திரட்டை வழங்குகிறது.

            
import psycopg2.pool
import os

# Create the connection pool once when your application starts.
# The minconn and maxconn parameters control the pool size.
connection_pool = psycopg2.pool.SimpleConnectionPool(
    minconn=1,
    maxconn=10,
    dbname=os.environ.get("DB_NAME"),
    user=os.environ.get("DB_USER"),
    password=os.environ.get("DB_PASSWORD"),
    host=os.environ.get("DB_HOST", "127.0.0.1")
)

def execute_query_from_pool(sql, params=None):
    """Function to get a connection from the pool and execute a query."""
    conn = None
    try:
        # Get a connection from the pool
        conn = connection_pool.getconn()
        with conn.cursor() as cur:
            cur.execute(sql, params)
            # In a real app, you might fetch and return results here
            conn.commit()
            print("Query executed successfully.")
    except (Exception, psycopg2.DatabaseError) as error:
        print(f"Error executing query: {error}")
    finally:
        if conn:
            # Return the connection to the pool
            connection_pool.putconn(conn)

# When your application shuts down, close all connections in the pool
# connection_pool.closeall()

            

              
                Copy
              
            
          

பிழை கையாளுதல்

உங்கள் பிழை கையாளுதலில் குறிப்பாக இருங்கள். Psycopg2, `psycopg2.Error`-லிருந்து பெறப்பட்ட பல்வேறு விதிவிலக்குகளை எழுப்புகிறது. `IntegrityError` (முதன்மை விசை மீறல்களுக்கு) அல்லது `OperationalError` (இணைப்புச் சிக்கல்களுக்கு) போன்ற குறிப்பிட்ட துணை வகுப்புகளைப் பிடிப்பது, வெவ்வேறு தோல்வி காட்சிகளை மிகவும் நேர்த்தியாகக் கையாள உங்களை அனுமதிக்கிறது.

எதிர்காலம்: Psycopg 3

Psycopg2 இன்று நிலையான மற்றும் ஆதிக்கம் செலுத்தும் அடாப்டராக இருந்தாலும், அதன் வாரிசான Psycopg 3 கிடைக்கிறது மற்றும் எதிர்காலத்தை பிரதிபலிக்கிறது என்பதைக் கவனத்தில் கொள்ள வேண்டும். இது சிறந்த செயல்திறன், மேம்படுத்தப்பட்ட அம்சங்கள் மற்றும் மிக முக்கியமாக, பைதான்-ன் `asyncio` கட்டமைப்பிற்கான சொந்த ஆதரவை வழங்க புதிதாக எழுதப்பட்டுள்ளது. நவீன ஒத்திசைவற்ற பைதான்-ஐப் பயன்படுத்தும் ஒரு புதிய திட்டத்தைத் தொடங்கினால், Psycopg 3 ஐ ஆராய்வது மிகவும் பரிந்துரைக்கப்படுகிறது.

முடிவுரை

பைதான், போஸ்ட்கிரஸ் மற்றும் psycopg2 ஆகியவற்றின் சேர்க்கை, தரவு மையப் பயன்பாடுகளை உருவாக்குவதற்கு ஒரு சக்திவாய்ந்த, நம்பகமான மற்றும் டெவலப்பர்-நட்பு அடுக்கை வழங்குகிறது. பாதுகாப்பான இணைப்பை நிறுவுதல் முதல் CRUD செயல்பாடுகளைச் செயல்படுத்துதல், பரிவர்த்தனைகளை நிர்வகித்தல் மற்றும் இணைப்புத் திரட்டுதல் போன்ற செயல்திறன்-முக்கியமான அம்சங்களை செயல்படுத்துதல் வரை நாம் பயணித்தோம்.

இந்தக் கருத்துக்களை நன்கு புரிந்துகொண்டு, சிறந்த நடைமுறைகளைத் தொடர்ந்து பயன்படுத்துவதன் மூலம்—குறிப்பாக அளவுருவாக்கப்பட்ட வினவல்களுடன் பாதுகாப்பு மற்றும் இணைப்புத் திரட்டுகளுடன் அளவிடுதல்—ஒரு உலகளாவிய பயனர் தளத்திற்கு சேவை செய்யக்கூடிய உறுதியான பயன்பாடுகளை உருவாக்க நீங்கள் நன்கு தயாராக இருக்கிறீர்கள். செயல்படும் குறியீட்டை எழுதுவது மட்டுமல்லாமல், நீண்ட காலத்திற்கு பாதுகாப்பான, திறமையான மற்றும் பராமரிக்கக்கூடிய குறியீட்டை எழுதுவதுதான் முக்கியம். மகிழ்வுடன் குறியிடுங்கள்!