పైథాన్‌లో SQLAlchemy సెషన్ మేనేజ్‌మెంట్‌పై ఒక సమగ్ర గైడ్, ఇది మీ అప్లికేషన్‌లలో డేటా సమగ్రత మరియు స్థిరత్వాన్ని నిర్ధారించడానికి బలమైన ట్రాన్సాక్షన్ హ్యాండ్లింగ్ టెక్నిక్‌లపై దృష్టి పెడుతుంది.
పైథాన్ SQLAlchemy సెషన్ మేనేజ్‌మెంట్: డేటా సమగ్రత కోసం ట్రాన్సాక్షన్ హ్యాండ్లింగ్‌లో నైపుణ్యం సాధించడం
SQLAlchemy అనేది ఒక శక్తివంతమైన మరియు ఫ్లెక్సిబుల్ పైథాన్ లైబ్రరీ, ఇది డేటాబేస్‌లతో ఇంటరాక్ట్ అవ్వడానికి ఒక సమగ్ర టూల్‌కిట్‌ను అందిస్తుంది. SQLAlchemy యొక్క గుండెలో సెషన్ అనే భావన ఉంటుంది, ఇది మీరు మీ డేటాబేస్‌లో చేసే అన్ని ఆపరేషన్‌ల కోసం ఒక స్టేజింగ్ జోన్‌గా పనిచేస్తుంది. ముఖ్యంగా ఏకకాల అభ్యర్థనలను నిర్వహించే సంక్లిష్ట అప్లికేషన్‌లలో, డేటా సమగ్రతను కాపాడటానికి మరియు స్థిరమైన డేటాబేస్ ప్రవర్తనను నిర్ధారించడానికి సరైన సెషన్ మరియు ట్రాన్సాక్షన్ మేనేజ్‌మెంట్ చాలా ముఖ్యం.
SQLAlchemy సెషన్‌లను అర్థం చేసుకోవడం
ఒక SQLAlchemy సెషన్ ఒక యూనిట్ ఆఫ్ వర్క్, డేటాబేస్‌తో ఒక సంభాషణను సూచిస్తుంది. ఇది ఆబ్జెక్ట్‌లకు చేసిన మార్పులను ట్రాక్ చేస్తుంది, వాటిని ఒకే అటామిక్ ఆపరేషన్‌గా డేటాబేస్‌కు పర్సిస్ట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. అధికారికంగా సేవ్ చేయడానికి ముందు మీరు డేటాకు మార్పులు చేసే వర్క్‌స్పేస్‌గా దీనిని భావించండి. చక్కగా నిర్వహించబడిన సెషన్ లేకుండా, మీరు డేటా అస్థిరతలు మరియు సంభావ్య కరప్షన్‌ను ఎదుర్కొంటారు.
సెషన్‌ను సృష్టించడం
మీరు మీ డేటాబేస్‌తో ఇంటరాక్ట్ అవ్వడం ప్రారంభించే ముందు, మీరు ఒక సెషన్‌ను సృష్టించాలి. దీని కోసం మొదట SQLAlchemy యొక్క ఇంజిన్‌ను ఉపయోగించి డేటాబేస్‌కు కనెక్షన్‌ను ఏర్పాటు చేయాలి.
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
# Database connection string
db_url = 'sqlite:///:memory:' # Replace with your database URL (e.g., PostgreSQL, MySQL)
# Create an engine
engine = create_engine(db_url, echo=False) # echo=True to see the generated SQL
# Define a base for declarative models
Base = declarative_base()
# Define a simple model
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String)
email = Column(String)
def __repr__(self):
return f""
# Create the table in the database
Base.metadata.create_all(engine)
# Create a session class
Session = sessionmaker(bind=engine)
# Instantiate a session
session = Session()
ఈ ఉదాహరణలో:
- మేము అవసరమైన SQLAlchemy మాడ్యూల్స్‌ను ఇంపోర్ట్ చేస్తాము.
- మేము ఒక డేటాబేస్ కనెక్షన్ స్ట్రింగ్ (`db_url`) ను నిర్వచిస్తాము. ఈ ఉదాహరణలో సరళత కోసం ఇన్-మెమరీ SQLite డేటాబేస్‌ను ఉపయోగిస్తున్నాము, కానీ మీరు మీ డేటాబేస్ సిస్టమ్ (ఉదా., PostgreSQL, MySQL) కు తగిన కనెక్షన్ స్ట్రింగ్‌తో దాన్ని భర్తీ చేయాలి. మీరు ఉపయోగించే డేటాబేస్ ఇంజిన్ మరియు డ్రైవర్‌ను బట్టి నిర్దిష్ట ఫార్మాట్ మారుతుంది. సరైన కనెక్షన్ స్ట్రింగ్ ఫార్మాట్ కోసం SQLAlchemy డాక్యుమెంటేషన్ మరియు మీ డేటాబేస్ ప్రొవైడర్ డాక్యుమెంటేషన్‌ను సంప్రదించండి.
- మేము `create_engine()` ఉపయోగించి ఒక `engine` ను సృష్టిస్తాము. కనెక్షన్ పూల్‌ను నిర్వహించడానికి మరియు డేటాబేస్‌తో కమ్యూనికేట్ చేయడానికి ఇంజిన్ బాధ్యత వహిస్తుంది. `echo=True` పారామీటర్ డీబగ్గింగ్‌కు సహాయపడుతుంది, ఎందుకంటే ఇది ఉత్పత్తి చేయబడిన SQL స్టేట్‌మెంట్‌లను కన్సోల్‌కు ప్రింట్ చేస్తుంది.
- మేము `declarative_base()` ఉపయోగించి ఒక బేస్ క్లాస్ (`Base`) ను నిర్వచిస్తాము. ఇది మా అన్ని SQLAlchemy మోడల్స్ కోసం బేస్ క్లాస్‌గా ఉపయోగించబడుతుంది.
- మేము ఒక `User` మోడల్‌ను నిర్వచిస్తాము, దాన్ని `users` అనే డేటాబేస్ టేబుల్‌కు మ్యాప్ చేస్తాము.
- మేము `Base.metadata.create_all(engine)` ఉపయోగించి డేటాబేస్‌లో టేబుల్‌ను సృష్టిస్తాము.
- మేము `sessionmaker(bind=engine)` ఉపయోగించి ఒక సెషన్ క్లాస్‌ను సృష్టిస్తాము. ఇది నిర్దిష్ట ఇంజిన్‌ను ఉపయోగించడానికి సెషన్ క్లాస్‌ను కాన్ఫిగర్ చేస్తుంది.
- చివరగా, మేము `Session()` ఉపయోగించి ఒక సెషన్‌ను ఇన్‌స్టాన్షియేట్ చేస్తాము.
ట్రాన్సాక్షన్‌లను అర్థం చేసుకోవడం
ఒక ట్రాన్సాక్షన్ అనేది ఒకే లాజికల్ యూనిట్ ఆఫ్ వర్క్‌గా పరిగణించబడే డేటాబేస్ ఆపరేషన్‌ల క్రమం. ట్రాన్సాక్షన్‌లు ACID లక్షణాలను అనుసరిస్తాయి:
- అటామిసిటీ (Atomicity): ట్రాన్సాక్షన్‌లోని అన్ని ఆపరేషన్‌లు పూర్తిగా విజయవంతం అవుతాయి లేదా పూర్తిగా విఫలమవుతాయి. ట్రాన్సాక్షన్‌లోని ఏ భాగం విఫలమైనా, మొత్తం ట్రాన్సాక్షన్ రోల్ బ్యాక్ చేయబడుతుంది.
- కన్సిస్టెన్సీ (Consistency): ట్రాన్సాక్షన్ డేటాబేస్‌ను ఒక చెల్లుబాటు అయ్యే స్థితిలో నిర్వహించాలి. ఇది ఏ డేటాబేస్ పరిమితులు లేదా నియమాలను ఉల్లంఘించదు.
- ఐసోలేషన్ (Isolation): ఏకకాల ట్రాన్సాక్షన్‌లు ఒకదానికొకటి వేరుచేయబడతాయి. ఒక ట్రాన్సాక్షన్ చేసిన మార్పులు మొదటి ట్రాన్సాక్షన్ కమిట్ అయ్యే వరకు ఇతర ట్రాన్సాక్షన్‌లకు కనిపించవు.
- డ్యూరబిలిటీ (Durability): ఒకసారి ఒక ట్రాన్సాక్షన్ కమిట్ అయిన తర్వాత, దాని మార్పులు శాశ్వతంగా ఉంటాయి మరియు సిస్టమ్ వైఫల్యాల నుండి కూడా తట్టుకుంటాయి.
SQLAlchemy ఈ ACID లక్షణాలను నిర్వహించేలా చూసేందుకు, ట్రాన్సాక్షన్‌లను నిర్వహించడానికి మెకానిజంలను అందిస్తుంది.
ప్రాథమిక ట్రాన్సాక్షన్ హ్యాండ్లింగ్
అత్యంత సాధారణ ట్రాన్సాక్షన్ ఆపరేషన్‌లు కమిట్ మరియు రోల్‌బ్యాక్.
ట్రాన్సాక్షన్‌లను కమిట్ చేయడం
ఒక ట్రాన్సాక్షన్‌లోని అన్ని ఆపరేషన్‌లు విజయవంతంగా పూర్తయినప్పుడు, మీరు ట్రాన్సాక్షన్‌ను కమిట్ చేస్తారు. ఇది మార్పులను డేటాబేస్‌కు పర్సిస్ట్ చేస్తుంది.
try:
# Add a new user
new_user = User(name='Alice Smith', email='alice.smith@example.com')
session.add(new_user)
# Commit the transaction
session.commit()
print("Transaction committed successfully!")
except Exception as e:
# Handle exceptions
print(f"An error occurred: {e}")
session.rollback()
print("Transaction rolled back.")
finally:
session.close()
ఈ ఉదాహరణలో:
- మేము సెషన్‌కు ఒక కొత్త `User` ఆబ్జెక్ట్‌ను జోడిస్తాము.
- డేటాబేస్‌కు మార్పులను పర్సిస్ట్ చేయడానికి మేము `session.commit()` ను పిలుస్తాము.
- సంభావ్య మినహాయింపులను నిర్వహించడానికి మేము కోడ్‌ను `try...except...finally` బ్లాక్‌లో చుట్టివేస్తాము.
- ఒక మినహాయింపు సంభవిస్తే, ట్రాన్సాక్షన్ సమయంలో చేసిన ఏవైనా మార్పులను రద్దు చేయడానికి మేము `session.rollback()` ను పిలుస్తాము.
- సెషన్‌ను విడుదల చేయడానికి మరియు కనెక్షన్‌ను కనెక్షన్ పూల్‌కు తిరిగి ఇవ్వడానికి మేము ఎల్లప్పుడూ `finally` బ్లాక్‌లో `session.close()` ను పిలుస్తాము. రిసోర్స్ లీక్‌లను నివారించడానికి ఇది చాలా ముఖ్యం. సెషన్‌లను మూసివేయడంలో విఫలమైతే కనెక్షన్ ఎగ్జాషన్ మరియు అప్లికేషన్ అస్థిరతకు దారితీస్తుంది.
ట్రాన్సాక్షన్‌లను రోల్ బ్యాక్ చేయడం
ఒక ట్రాన్సాక్షన్ సమయంలో ఏదైనా లోపం సంభవిస్తే, లేదా మార్పులను పర్సిస్ట్ చేయకూడదని మీరు నిర్ణయించుకుంటే, మీరు ట్రాన్సాక్షన్‌ను రోల్‌బ్యాక్ చేస్తారు. ఇది ట్రాన్సాక్షన్ ప్రారంభానికి ముందు డేటాబేస్‌ను దాని స్థితికి తిరిగి తీసుకువస్తుంది.
try:
# Add a user with an invalid email (example to force a rollback)
invalid_user = User(name='Bob Johnson', email='invalid-email')
session.add(invalid_user)
# The commit will fail if the email is not validated on the database level
session.commit()
print("Transaction committed.")
except Exception as e:
print(f"An error occurred: {e}")
session.rollback()
print("Transaction rolled back successfully.")
finally:
session.close()
ఈ ఉదాహరణలో, `invalid_user` ను జోడించడం వలన ఒక మినహాయింపు (ఉదా., డేటాబేస్ కన్‌స్ట్రైంట్ ఉల్లంఘన కారణంగా) సంభవిస్తే, `session.rollback()` కాల్ ప్రయత్నించిన ఇన్‌సర్షన్‌ను రద్దు చేస్తుంది, డేటాబేస్‌ను మార్చకుండా వదిలివేస్తుంది.
అధునాతన ట్రాన్సాక్షన్ మేనేజ్‌మెంట్
ట్రాన్సాక్షన్ స్కోపింగ్ కోసం `with` స్టేట్‌మెంట్‌ను ఉపయోగించడం
ట్రాన్సాక్షన్‌లను నిర్వహించడానికి ఒక మరింత పైథానిక్ మరియు బలమైన మార్గం `with` స్టేట్‌మెంట్‌ను ఉపయోగించడం. ఇది మినహాయింపులు సంభవించినప్పటికీ, సెషన్ సరిగ్గా మూసివేయబడుతుందని నిర్ధారిస్తుంది.
from contextlib import contextmanager
@contextmanager
def session_scope():
"""Provide a transactional scope around a series of operations."""
session = Session()
try:
yield session
session.commit()
except Exception:
session.rollback()
raise
finally:
session.close()
# Usage:
with session_scope() as session:
new_user = User(name='Charlie Brown', email='charlie.brown@example.com')
session.add(new_user)
# Operations within the 'with' block
# If no exceptions occur, the transaction is committed automatically.
# If an exception occurs, the transaction is rolled back automatically.
print("User added.")
print("Transaction completed (committed or rolled back).")
`session_scope` ఫంక్షన్ ఒక కాంటెక్స్ట్ మేనేజర్. మీరు `with` బ్లాక్‌లోకి ప్రవేశించినప్పుడు, ఒక కొత్త సెషన్ సృష్టించబడుతుంది. మీరు `with` బ్లాక్ నుండి నిష్క్రమించినప్పుడు, సెషన్ కమిట్ చేయబడుతుంది (ఏ మినహాయింపులు సంభవించకపోతే) లేదా రోల్ బ్యాక్ చేయబడుతుంది (ఒక మినహాయింపు సంభవిస్తే). సెషన్ ఎల్లప్పుడూ `finally` బ్లాక్‌లో మూసివేయబడుతుంది.
నెస్ట్ చేయబడిన ట్రాన్సాక్షన్‌లు (సేవ్‌పాయింట్లు)
SQLAlchemy సేవ్‌పాయింట్‌లను ఉపయోగించి నెస్ట్ చేయబడిన ట్రాన్సాక్షన్‌లకు మద్దతు ఇస్తుంది. ఒక సేవ్‌పాయింట్ మొత్తం ట్రాన్సాక్షన్‌ను ప్రభావితం చేయకుండా, ఒక పెద్ద ట్రాన్సాక్షన్‌లో ఒక నిర్దిష్ట పాయింట్‌కు రోల్ బ్యాక్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
try:
with session_scope() as session:
user1 = User(name='David Lee', email='david.lee@example.com')
session.add(user1)
session.flush() # Send changes to the database but don't commit yet
# Create a savepoint
savepoint = session.begin_nested()
try:
user2 = User(name='Eve Wilson', email='eve.wilson@example.com')
session.add(user2)
session.flush()
# Simulate an error
raise ValueError("Simulated error during nested transaction")
except Exception as e:
print(f"Nested transaction error: {e}")
savepoint.rollback()
print("Nested transaction rolled back to savepoint.")
# Continue with the outer transaction, user1 will still be added
user3 = User(name='Frank Miller', email='frank.miller@example.com')
session.add(user3)
except Exception as e:
print(f"Outer transaction error: {e}")
#Commit will commit user1 and user3, but not user2 due to the nested rollback
try:
with session_scope() as session:
#Verify only user1 and user3 exist
users = session.query(User).all()
for user in users:
print(user)
except Exception as e:
print(f"Unexpected Exception: {e}") #Should not happen
ఈ ఉదాహరణలో:
- మేము `session_scope()` ఉపయోగించి ఒక బయటి ట్రాన్సాక్షన్‌ను ప్రారంభిస్తాము.
- మేము `user1` ను సెషన్‌కు జోడించి, మార్పులను డేటాబేస్‌కు ఫ్లష్ చేస్తాము. `flush()` మార్పులను డేటాబేస్ సర్వర్‌కు పంపుతుంది కానీ వాటిని *కమిట్ చేయదు*. ఇది మొత్తం ట్రాన్సాక్షన్‌ను కమిట్ చేయడానికి ముందు మార్పులు చెల్లుబాటు అవుతాయో లేదో (ఉదా., కన్‌స్ట్రైంట్ ఉల్లంఘనలు లేవు) చూడటానికి మిమ్మల్ని అనుమతిస్తుంది.
- మేము `session.begin_nested()` ఉపయోగించి ఒక సేవ్‌పాయింట్‌ను సృష్టిస్తాము.
- నెస్ట్ చేయబడిన ట్రాన్సాక్షన్‌లో, మేము `user2` ను జోడించి ఒక లోపాన్ని అనుకరిస్తాము.
- మేము `savepoint.rollback()` ఉపయోగించి నెస్ట్ చేయబడిన ట్రాన్సాక్షన్‌ను సేవ్‌పాయింట్‌కు రోల్ బ్యాక్ చేస్తాము. ఇది నెస్ట్ చేయబడిన ట్రాన్సాక్షన్‌లో చేసిన మార్పులను మాత్రమే (అంటే, `user2` జోడింపు) రద్దు చేస్తుంది.
- మేము బయటి ట్రాన్సాక్షన్‌తో కొనసాగుతాము మరియు `user3` ను జోడిస్తాము.
- బయటి ట్రాన్సాక్షన్ కమిట్ చేయబడుతుంది, `user1` మరియు `user3` ను డేటాబేస్‌కు పర్సిస్ట్ చేస్తుంది, అయితే `user2` సేవ్‌పాయింట్ రోల్‌బ్యాక్ కారణంగా విస్మరించబడుతుంది.
ఐసోలేషన్ స్థాయిలను నియంత్రించడం
ఐసోలేషన్ స్థాయిలు ఏకకాల ట్రాన్సాక్షన్‌లు ఒకదానికొకటి ఎంతవరకు వేరుచేయబడతాయో నిర్వచిస్తాయి. అధిక ఐసోలేషన్ స్థాయిలు ఎక్కువ డేటా స్థిరత్వాన్ని అందిస్తాయి కానీ కాంకరెన్సీ మరియు పనితీరును తగ్గించగలవు. SQLAlchemy మీ ట్రాన్సాక్షన్‌ల ఐసోలేషన్ స్థాయిని నియంత్రించడానికి మిమ్మల్ని అనుమతిస్తుంది.
సాధారణ ఐసోలేషన్ స్థాయిలు:
- Read Uncommitted: అత్యల్ప ఐసోలేషన్ స్థాయి. ట్రాన్సాక్షన్‌లు ఇతర ట్రాన్సాక్షన్‌లు చేసిన కమిట్ చేయని మార్పులను చూడగలవు. ఇది డర్టీ రీడ్‌లకు దారితీయవచ్చు.
- Read Committed: ట్రాన్సాక్షన్‌లు ఇతర ట్రాన్సాక్షన్‌లు చేసిన కమిట్ చేయబడిన మార్పులను మాత్రమే చూడగలవు. ఇది డర్టీ రీడ్‌లను నివారిస్తుంది కానీ నాన్-రిపీటబుల్ రీడ్‌లు మరియు ఫాంటమ్ రీడ్‌లకు దారితీయవచ్చు.
- Repeatable Read: ఇతర ట్రాన్సాక్షన్‌లు దాన్ని సవరించినప్పటికీ, ట్రాన్సాక్షన్ అంతటా ట్రాన్సాక్షన్‌లు అదే డేటాను చూడగలవు. ఇది డర్టీ రీడ్‌లు మరియు నాన్-రిపీటబుల్ రీడ్‌లను నివారిస్తుంది కానీ ఫాంటమ్ రీడ్‌లకు దారితీయవచ్చు.
- Serializable: అత్యధిక ఐసోలేషన్ స్థాయి. ట్రాన్సాక్షన్‌లు ఒకదానికొకటి పూర్తిగా వేరుచేయబడతాయి. ఇది డర్టీ రీడ్‌లు, నాన్-రిపీటబుల్ రీడ్‌లు, మరియు ఫాంటమ్ రీడ్‌లను నివారిస్తుంది కానీ కాంకరెన్సీని గణనీయంగా తగ్గించగలదు.
డిఫాల్ట్ ఐసోలేషన్ స్థాయి డేటాబేస్ సిస్టమ్‌పై ఆధారపడి ఉంటుంది. మీరు ఇంజిన్‌ను సృష్టించేటప్పుడు లేదా ఒక ట్రాన్సాక్షన్‌ను ప్రారంభించేటప్పుడు ఐసోలేషన్ స్థాయిని సెట్ చేయవచ్చు.
ఉదాహరణ (PostgreSQL):
from sqlalchemy.dialects.postgresql import dialect
# Set isolation level when creating the engine
engine = create_engine('postgresql://user:password@host:port/database',
connect_args={'options': '-c statement_timeout=1000'} #Example of timeout
)
# Set the isolation level when beginning a transaction (database specific)
# For postgresql, it's recommended to set it on the connection, not engine.
from sqlalchemy import event
from sqlalchemy.pool import Pool
@event.listens_for(Pool, "connect")
def set_isolation_level(dbapi_connection, connection_record):
existing_autocommit = dbapi_connection.autocommit
dbapi_connection.autocommit = True
cursor = dbapi_connection.cursor()
cursor.execute("SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE")
dbapi_connection.autocommit = existing_autocommit
cursor.close()
# Then transactions created via SQLAlchemy will use the configured isolation level.
ముఖ్యమైనది: ఐసోలేషన్ స్థాయిలను సెట్ చేసే పద్ధతి డేటాబేస్-నిర్దిష్టమైనది. సరైన సింటాక్స్ కోసం మీ డేటాబేస్ డాక్యుమెంటేషన్‌ను చూడండి. ఐసోలేషన్ స్థాయిలను తప్పుగా సెట్ చేయడం వలన ఊహించని ప్రవర్తన లేదా లోపాలు సంభవించవచ్చు.
కాంకరెన్సీని నిర్వహించడం
బహుళ వినియోగదారులు లేదా ప్రక్రియలు ఏకకాలంలో అదే డేటాను యాక్సెస్ చేసినప్పుడు, డేటా కరప్షన్‌ను నివారించడానికి మరియు డేటా స్థిరత్వాన్ని నిర్ధారించడానికి కాంకరెన్సీని సరిగ్గా నిర్వహించడం చాలా ముఖ్యం. SQLAlchemy కాంకరెన్సీని నిర్వహించడానికి అనేక మెకానిజంలను అందిస్తుంది, ఇందులో ఆప్టిమిస్టిక్ లాకింగ్ మరియు పెసిమిస్టిక్ లాకింగ్ ఉన్నాయి.
ఆప్టిమిస్టిక్ లాకింగ్
ఆప్టిమిస్టిక్ లాకింగ్ విభేదాలు అరుదుగా ఉంటాయని ఊహిస్తుంది. ఇది ఒక ట్రాన్సాక్షన్‌ను కమిట్ చేయడానికి ముందు ఇతర ట్రాన్సాక్షన్‌లు చేసిన మార్పులను తనిఖీ చేస్తుంది. ఒక విభేదం గుర్తించబడితే, ట్రాన్సాక్షన్ రోల్ బ్యాక్ చేయబడుతుంది.
ఆప్టిమిస్టిక్ లాకింగ్‌ను అమలు చేయడానికి, మీరు సాధారణంగా మీ టేబుల్‌కు ఒక వెర్షన్ కాలమ్‌ను జోడిస్తారు. రో అప్‌డేట్ అయినప్పుడల్లా ఈ కాలమ్ స్వయంచాలకంగా ఇంక్రిమెంట్ అవుతుంది.
from sqlalchemy import Column, Integer, String, Integer
from sqlalchemy.orm import declarative_base
Base = declarative_base()
class Article(Base):
__tablename__ = 'articles'
id = Column(Integer, primary_key=True)
title = Column(String)
content = Column(String)
version = Column(Integer, nullable=False, default=1)
def __repr__(self):
return f""
#Inside of the try catch block
def update_article(session, article_id, new_content):
article = session.query(Article).filter_by(id=article_id).first()
if article is None:
raise ValueError("Article not found")
original_version = article.version
# Update the content and increment the version
article.content = new_content
article.version += 1
# Attempt to update, checking the version column in the WHERE clause
rows_affected = session.query(Article).filter(
Article.id == article_id,
Article.version == original_version
).update({
Article.content: new_content,
Article.version: article.version
}, synchronize_session=False)
if rows_affected == 0:
session.rollback()
raise ValueError("Conflict: Article has been updated by another transaction.")
session.commit()
ఈ ఉదాహరణలో:
- మేము `Article` మోడల్‌కు ఒక `version` కాలమ్‌ను జోడిస్తాము.
- ఆర్టికల్‌ను అప్‌డేట్ చేయడానికి ముందు, మేము ప్రస్తుత వెర్షన్ నంబర్‌ను నిల్వ చేస్తాము.
- `UPDATE` స్టేట్‌మెంట్‌లో, వెర్షన్ కాలమ్ ఇప్పటికీ నిల్వ చేసిన వెర్షన్ నంబర్‌కు సమానంగా ఉందో లేదో తనిఖీ చేసే `WHERE` క్లాజ్‌ను చేర్చుతాము. `synchronize_session=False` SQLAlchemy అప్‌డేట్ చేయబడిన ఆబ్జెక్ట్‌ను మళ్లీ లోడ్ చేయకుండా నిరోధిస్తుంది; మేము వెర్షనింగ్‌ను స్పష్టంగా నిర్వహిస్తున్నాము.
- వెర్షన్ కాలమ్ మరొక ట్రాన్సాక్షన్ ద్వారా మార్చబడితే, `UPDATE` స్టేట్‌మెంట్ ఏ రోలను ప్రభావితం చేయదు (rows_affected 0 అవుతుంది), మరియు మేము ఒక మినహాయింపును రైజ్ చేస్తాము.
- మేము ట్రాన్సాక్షన్‌ను రోల్ బ్యాక్ చేసి, ఒక విభేదం సంభవించిందని వినియోగదారుకు తెలియజేస్తాము.
పెసిమిస్టిక్ లాకింగ్
పెసిమిస్టిక్ లాకింగ్ విభేదాలు ఎక్కువగా ఉంటాయని ఊహిస్తుంది. ఇది ఒక రో లేదా టేబుల్‌ను సవరించడానికి ముందు దానిపై ఒక లాక్‌ను పొందుతుంది. ఇది లాక్ విడుదలయ్యే వరకు ఇతర ట్రాన్సాక్షన్‌లు డేటాను సవరించకుండా నిరోధిస్తుంది.
SQLAlchemy లాక్‌లను పొందడానికి అనేక ఫంక్షన్‌లను అందిస్తుంది, ఉదాహరణకు `with_for_update()`.
# Example using PostgreSQL
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
# Database setup (replace with your actual database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False) #Set echo to true if you would like to see the SQL generated
Base = declarative_base()
class Item(Base):
__tablename__ = 'items'
id = Column(Integer, primary_key=True)
name = Column(String)
value = Column(Integer)
def __repr__(self):
return f""
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
#Function to update the item (within a try/except)
def update_item_value(session, item_id, new_value):
# Acquire a pessimistic lock on the item
item = session.query(Item).filter(Item.id == item_id).with_for_update().first()
if item is None:
raise ValueError("Item not found")
# Update the item's value
item.value = new_value
session.commit()
return True
ఈ ఉదాహరణలో:
- `Item` రోను అప్‌డేట్ చేయడానికి ముందు దానిపై లాక్‌ను పొందడానికి మేము `with_for_update()` ను ఉపయోగిస్తాము. ఇది ప్రస్తుత ట్రాన్సాక్షన్ కమిట్ అయ్యే వరకు లేదా రోల్ బ్యాక్ అయ్యే వరకు ఇతర ట్రాన్సాక్షన్‌లు రోను సవరించకుండా నిరోధిస్తుంది. `with_for_update()` ఫంక్షన్ డేటాబేస్-నిర్దిష్టమైనది; వివరాల కోసం మీ డేటాబేస్ డాక్యుమెంటేషన్‌ను సంప్రదించండి. కొన్ని డేటాబేస్‌లు వేర్వేరు లాకింగ్ మెకానిజంలు లేదా సింటాక్స్‌ను కలిగి ఉండవచ్చు.
ముఖ్యమైనది: పెసిమిస్టిక్ లాకింగ్ కాంకరెన్సీ మరియు పనితీరును తగ్గించగలదు, కాబట్టి అవసరమైనప్పుడు మాత్రమే దాన్ని ఉపయోగించండి.
ఎక్సెప్షన్ హ్యాండ్లింగ్ ఉత్తమ పద్ధతులు
డేటా సమగ్రతను నిర్ధారించడానికి మరియు అప్లికేషన్ క్రాష్‌లను నివారించడానికి సరైన ఎక్సెప్షన్ హ్యాండ్లింగ్ చాలా ముఖ్యం. ఎల్లప్పుడూ మీ డేటాబేస్ ఆపరేషన్‌లను `try...except` బ్లాక్‌లలో చుట్టి, మినహాయింపులను తగిన విధంగా నిర్వహించండి.
ఎక్సెప్షన్ హ్యాండ్లింగ్ కోసం కొన్ని ఉత్తమ పద్ధతులు ఇక్కడ ఉన్నాయి:
- నిర్దిష్ట మినహాయింపులను పట్టుకోండి: `Exception` వంటి సాధారణ మినహాయింపులను పట్టుకోవడం మానుకోండి. `sqlalchemy.exc.IntegrityError` లేదా `sqlalchemy.exc.OperationalError` వంటి నిర్దిష్ట మినహాయింపులను పట్టుకుని వివిధ రకాల లోపాలను విభిన్నంగా నిర్వహించండి.
- ట్రాన్సాక్షన్‌లను రోల్ బ్యాక్ చేయండి: ఒక మినహాయింపు సంభవిస్తే ఎల్లప్పుడూ ట్రాన్సాక్షన్‌ను రోల్ బ్యాక్ చేయండి.
- మినహాయింపులను లాగ్ చేయండి: సమస్యలను నిర్ధారించడానికి మరియు పరిష్కరించడంలో సహాయపడటానికి మినహాయింపులను లాగ్ చేయండి. మీ లాగ్‌లలో వీలైనంత ఎక్కువ సందర్భాన్ని చేర్చండి (ఉదా., యూజర్ ఐడి, ఇన్‌పుట్ డేటా, టైమ్‌స్టాంప్).
- తగినప్పుడు మినహాయింపులను తిరిగి రైజ్ చేయండి: మీరు ఒక మినహాయింపును నిర్వహించలేకపోతే, దానిని ఉన్నత స్థాయి హ్యాండ్లర్ నిర్వహించడానికి అనుమతించడానికి దాన్ని తిరిగి రైజ్ చేయండి.
- వనరులను శుభ్రం చేయండి: ఎల్లప్పుడూ `finally` బ్లాక్‌లో సెషన్‌ను మూసివేసి, ఏవైనా ఇతర వనరులను విడుదల చేయండి.
import logging
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
from sqlalchemy.exc import IntegrityError, OperationalError
# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
# Database setup (replace with your actual database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False)
Base = declarative_base()
class Product(Base):
__tablename__ = 'products'
id = Column(Integer, primary_key=True)
name = Column(String)
price = Column(Integer)
def __repr__(self):
return f""
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
# Function to add a product
def add_product(session, name, price):
try:
new_product = Product(name=name, price=price)
session.add(new_product)
session.commit()
logging.info(f"Product '{name}' added successfully.")
return True
except IntegrityError as e:
session.rollback()
logging.error(f"IntegrityError: {e}")
#Handle database constraint violations (e.g., duplicate name)
return False
except OperationalError as e:
session.rollback()
logging.error(f"OperationalError: {e}")
#Handle connection errors or other operational issues
return False
except Exception as e:
session.rollback()
logging.exception(f"An unexpected error occurred: {e}")
# Handle any other unexpected errors
return False
finally:
session.close()
ఈ ఉదాహరణలో:
- ప్రక్రియ సమయంలో ఈవెంట్‌లను రికార్డ్ చేయడానికి మేము లాగింగ్‌ను కాన్ఫిగర్ చేస్తాము.
- మేము `IntegrityError` (కన్‌స్ట్రైంట్ ఉల్లంఘనల కోసం) మరియు `OperationalError` (కనెక్షన్ లోపాల కోసం) వంటి నిర్దిష్ట మినహాయింపులను పట్టుకుంటాము.
- మేము `except` బ్లాక్‌లలో ట్రాన్సాక్షన్‌ను రోల్ బ్యాక్ చేస్తాము.
- మేము `logging` మాడ్యూల్‌ను ఉపయోగించి మినహాయింపులను లాగ్ చేస్తాము. `logging.exception()` పద్ధతి స్వయంచాలకంగా లాగ్ సందేశంలో స్టాక్ ట్రేస్‌ను చేర్చుతుంది.
- మేము దాన్ని నిర్వహించలేకపోతే మినహాయింపును తిరిగి రైజ్ చేస్తాము.
- మేము `finally` బ్లాక్‌లో సెషన్‌ను మూసివేస్తాము.
డేటాబేస్ కనెక్షన్ పూలింగ్
SQLAlchemy డేటాబేస్ కనెక్షన్‌లను సమర్థవంతంగా నిర్వహించడానికి కనెక్షన్ పూలింగ్‌ను ఉపయోగిస్తుంది. ఒక కనెక్షన్ పూల్ డేటాబేస్‌కు ఓపెన్ కనెక్షన్‌ల సెట్‌ను నిర్వహిస్తుంది, ప్రతి అభ్యర్థన కోసం కొత్త వాటిని సృష్టించడానికి బదులుగా అప్లికేషన్‌లు ఇప్పటికే ఉన్న కనెక్షన్‌లను తిరిగి ఉపయోగించుకోవడానికి అనుమతిస్తుంది. ఇది ప్రత్యేకంగా పెద్ద సంఖ్యలో ఏకకాల అభ్యర్థనలను నిర్వహించే అప్లికేషన్‌లలో పనితీరును గణనీయంగా మెరుగుపరుస్తుంది.
SQLAlchemy యొక్క `create_engine()` ఫంక్షన్ స్వయంచాలకంగా ఒక కనెక్షన్ పూల్‌ను సృష్టిస్తుంది. మీరు `create_engine()` కు ఆర్గ్యుమెంట్‌లను పంపడం ద్వారా కనెక్షన్ పూల్‌ను కాన్ఫిగర్ చేయవచ్చు.
సాధారణ కనెక్షన్ పూల్ పారామితులు:
- pool_size: పూల్‌లోని గరిష్ట కనెక్షన్‌ల సంఖ్య.
- max_overflow: pool_size దాటి సృష్టించగల కనెక్షన్‌ల సంఖ్య.
- pool_recycle: ఒక కనెక్షన్ రీసైకిల్ చేయబడే సెకన్ల సంఖ్య.
- pool_timeout: ఒక కనెక్షన్ అందుబాటులోకి రావడానికి వేచి ఉండే సెకన్ల సంఖ్య.
engine = create_engine('postgresql://user:password@host:port/database',
pool_size=5, #Maximum pool size
max_overflow=10, #Maximum overflow
pool_recycle=3600, #Recycle connections after 1 hour
pool_timeout=30
)
ముఖ్యమైనది: మీ అప్లికేషన్ అవసరాలు మరియు మీ డేటాబేస్ సర్వర్ సామర్థ్యాల ఆధారంగా తగిన కనెక్షన్ పూల్ సెట్టింగ్‌లను ఎంచుకోండి. సరిగ్గా కాన్ఫిగర్ చేయని కనెక్షన్ పూల్ పనితీరు సమస్యలకు లేదా కనెక్షన్ ఎగ్జాషన్‌కు దారితీస్తుంది.
అసింక్రోనస్ ట్రాన్సాక్షన్‌లు (Async SQLAlchemy)
అధిక కాంకరెన్సీ అవసరమయ్యే ఆధునిక అప్లికేషన్‌ల కోసం, ముఖ్యంగా FastAPI లేదా AsyncIO వంటి అసింక్రోనస్ ఫ్రేమ్‌వర్క్‌లతో నిర్మించబడిన వాటి కోసం, SQLAlchemy Async SQLAlchemy అనే అసింక్రోనస్ వెర్షన్‌ను అందిస్తుంది.
Async SQLAlchemy కోర్ SQLAlchemy భాగాల యొక్క అసింక్రోనస్ వెర్షన్‌లను అందిస్తుంది, ఈవెంట్ లూప్‌ను బ్లాక్ చేయకుండా డేటాబేస్ ఆపరేషన్‌లను నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇది మీ అప్లికేషన్‌ల పనితీరు మరియు స్కేలబిలిటీని గణనీయంగా మెరుగుపరుస్తుంది.
Async SQLAlchemy ఉపయోగించడానికి ఒక ప్రాథమిక ఉదాహరణ ఇక్కడ ఉంది:
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, Integer, String
import asyncio
# Database setup (replace with your actual database URL)
db_url = 'postgresql+asyncpg://user:password@host:port/database'
engine = create_async_engine(db_url, echo=False)
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String)
email = Column(String)
def __repr__(self):
return f""
async def create_db_and_tables():
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
async def add_user(name, email):
async with AsyncSession(engine) as session:
new_user = User(name=name, email=email)
session.add(new_user)
await session.commit()
async def main():
await create_db_and_tables()
await add_user("Async User", "async.user@example.com")
if __name__ == "__main__":
asyncio.run(main())
సింక్రోనస్ SQLAlchemy నుండి ముఖ్య తేడాలు:
- `create_engine` బదులుగా `create_async_engine` ఉపయోగించబడుతుంది.
- `Session` బదులుగా `AsyncSession` ఉపయోగించబడుతుంది.
- అన్ని డేటాబేస్ ఆపరేషన్‌లు అసింక్రోనస్ మరియు `await` ఉపయోగించి వేచి ఉండాలి.
- అసింక్రోనస్ డేటాబేస్ డ్రైవర్లు (ఉదా., PostgreSQL కోసం `asyncpg`) ఉపయోగించాలి.
ముఖ్యమైనది: Async SQLAlchemy కు అసింక్రోనస్ ఆపరేషన్‌లకు మద్దతు ఇచ్చే డేటాబేస్ డ్రైవర్ అవసరం. మీరు సరైన డ్రైవర్‌ను ఇన్‌స్టాల్ చేసి, కాన్ఫిగర్ చేశారని నిర్ధారించుకోండి.
ముగింపు
డేటాబేస్‌లతో ఇంటరాక్ట్ అయ్యే బలమైన మరియు నమ్మదగిన పైథాన్ అప్లికేషన్‌లను నిర్మించడానికి SQLAlchemy సెషన్ మరియు ట్రాన్సాక్షన్ మేనేజ్‌మెంట్‌లో నైపుణ్యం సాధించడం చాలా అవసరం. సెషన్‌లు, ట్రాన్సాక్షన్‌లు, ఐసోలేషన్ స్థాయిలు, మరియు కాంకరెన్సీ యొక్క భావనలను అర్థం చేసుకోవడం ద్వారా, మరియు ఎక్సెప్షన్ హ్యాండ్లింగ్ మరియు కనెక్షన్ పూలింగ్ కోసం ఉత్తమ పద్ధతులను అనుసరించడం ద్వారా, మీరు డేటా సమగ్రతను నిర్ధారించవచ్చు మరియు మీ అప్లికేషన్‌ల పనితీరును ఆప్టిమైజ్ చేయవచ్చు.
మీరు ఒక చిన్న వెబ్ అప్లికేషన్ లేదా ఒక పెద్ద-స్థాయి ఎంటర్‌ప్రైజ్ సిస్టమ్‌ను నిర్మిస్తున్నా, SQLAlchemy మీ డేటాబేస్ ఇంటరాక్షన్‌లను సమర్థవంతంగా నిర్వహించడానికి అవసరమైన సాధనాలను అందిస్తుంది. మీ అప్లికేషన్‌ల విశ్వసనీయతను నిర్ధారించడానికి ఎల్లప్పుడూ డేటా సమగ్రతకు ప్రాధాన్యత ఇవ్వండి మరియు సంభావ్య లోపాలను సున్నితంగా నిర్వహించండి.
అధునాతన అంశాలను అన్వేషించడాన్ని పరిగణించండి:
- టూ-ఫేజ్ కమిట్ (2PC): బహుళ డేటాబేస్‌లను విస్తరించే ట్రాన్సాక్షన్‌ల కోసం.
- షార్డింగ్: బహుళ డేటాబేస్ సర్వర్‌లలో డేటాను పంపిణీ చేయడానికి.
- డేటాబేస్ మైగ్రేషన్‌లు: డేటాబేస్ స్కీమా మార్పులను నిర్వహించడానికి Alembic వంటి సాధనాలను ఉపయోగించడం.