Flask & SQLAlchemy Tutorial Sinhala | Python Web Development Databases

ආයුබෝවන් යාළුවනේ! වෙබ් සංවර්ධනයේදී දත්ත ගබඩා අත්‍යවශ්‍යයි නේද?

අද අපි කතා කරන්න යන්නේ Flask Web Framework එක සමඟ දත්ත ගබඩා (Databases) වැඩ කරන විදිය ගැන. විශේෂයෙන්ම, Python ලෝකයේ බොහොම ජනප්‍රිය ORM එකක් (Object-Relational Mapper) වෙන SQLAlchemy භාවිතයෙන් කොහොමද අපේ Flask ඇප්ලිකේෂන් එකට දත්ත ගබඩා සම්බන්ධ කරගන්නේ, දත්ත එකතු කරන්නේ, ගන්නෙ, වෙනස් කරන්නෙ සහ මකා දාන්නේ කොහොමද කියලා සරලව බලමු. මේක ඔයාලට අලුතින් Flask project එකක් පටන් ගන්නකොට ගොඩක් වැදගත් වෙයි!

1. ORM (Object-Relational Mapper) සහ SQLAlchemy හඳුන්වාදීම

දත්ත ගබඩා ගැන කතා කරනකොට මුලින්ම තේරුම් ගන්න ඕන දෙයක් තමයි ORM කියන්නේ මොකක්ද කියන එක. හිතන්න, ඔයාගේ Python ඇප්ලිකේෂන් එකේ තියෙන්නේ Python objects (objects කියන්නේ classes වලින් හදන ඒවා, උදාහරණයක් විදියට User object එකක්) විතරයි. හැබැයි දත්ත ගබඩාවක තියෙන්නේ tables, rows, columns වගේ දේවල්. මේ දෙක අතර පාලමක් (bridge) හදන එක තමයි ORM එකක් කරන්නේ. ඒ කියන්නේ, ඔයාට පුළුවන් Python objects විදියටම දත්ත ගබඩාවත් එක්ක වැඩ කරන්න. SQL queries ලියන්න ඕනේ නැහැ, ORM එකෙන් ඒක ඔයා වෙනුවෙන් කරනවා.

SQLAlchemy කියන්නේ Python සඳහා තියෙන බොහොම ප්‍රබල, flexible ORM එකක්. ඒක විවිධ දත්ත ගබඩා වර්ග (SQLite, PostgreSQL, MySQL වගේ) සමඟ වැඩ කරන්න පුළුවන්. Flask සමඟ SQLAlchemy භාවිත කරන්න Flask-SQLAlchemy කියන extension එක අපිට උදව් වෙනවා. මේක Flask ඇප්ලිකේෂන් එකට SQLAlchemy පහසුවෙන් integrate කරගන්න පුළුවන් විදියට හදලා තියෙනවා.

2. Flask සමඟ SQLAlchemy සකස් කරගනිමු (Setting up SQLAlchemy with Flask)

හරි, දැන් අපි බලමු අපේ Flask project එකට Flask-SQLAlchemy එකතු කරගන්නේ කොහොමද කියලා. මුලින්ම, අවශ්‍ය libraries install කරගන්න ඕනේ:

pip install Flask Flask-SQLAlchemy

ඊළඟට, අපේ Flask ඇප්ලිකේෂන් එකේ SQLAlchemy init කරගන්න ඕනේ. අපි මේ උදාහරණය සඳහා සරල SQLite දත්ත ගබඩාවක් භාවිතා කරනවා. මේක ෆයිල් එකක් විදියට save වෙන නිසා පටන් ගන්න ගොඩක් පහසුයි.

app.py කියන file එක හදාගෙන මේ code එක දාගන්න:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# Database Configuration
# 'sqlite:///site.db' කියන්නේ site.db කියන file එකේ database එක හදන්න කියන එකයි.
# මේක ඔයාගේ Flask project folder එක ඇතුළෙම හැදෙයි.
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # මේක True කරොත් warnings එන්න පුළුවන්

db = SQLAlchemy(app)

# Database tables ටික හදන්න (models හැදුවට පස්සේ මේක run කරන්න ඕනේ)
# මේක run කරන්නේ app context එකක් ඇතුළේ.
# python shell එකෙන් run කරන්න පුළුවන්: python -> from app import db, app -> with app.app_context(): db.create_all()
with app.app_context():
    db.create_all()

@app.route('/')
def home():
    return "Hello, Flask & SQLAlchemy!"

if __name__ == '__main__':
    app.run(debug=True)

පැහැදිලි කිරීම:

• app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db': මේකෙන් කියන්නේ දත්ත ගබඩාව තියෙන්නේ කොහෙද කියලා. sqlite:///site.db කියන්නේ site.db කියන ෆයිල් එකේ SQLite database එකක් හදන්න කියන එකයි.
• db = SQLAlchemy(app): මේකෙන් තමයි Flask application එකත් එක්ක SQLAlchemy connect කරන්නේ.
• with app.app_context(): db.create_all(): මේක බොහොම වැදගත්. මේකෙන් කරන්නේ අපි හදන Database Models වලට අදාළ tables ටික database එකේ හදන එක. මේක Flask application context එකක් ඇතුළේ run කරන්න ඕනේ. මුලින්ම database එක හදනකොට විතරක් මේක run කරන්න. (සෑම පාරක්ම run කරන්න ඕන නැහැ).

3. Database Models නිර්මාණය කිරීම (Creating Database Models)

දැන් අපි බලමු කොහොමද database tables වලට අදාළ Python classes හදන්නේ කියලා. මේවාට තමයි Models කියන්නේ. අපි සරල User Model එකක් හදමු.

app.py file එකේම, db = SQLAlchemy(app) කියන line එකට පස්සේ මේ code එක එකතු කරන්න:

# User Model එක නිර්මාණය කිරීම
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    # Object එකක් print කරනකොට පෙන්වන්න ඕන විදිය
    def __repr__(self):
        return f'<User {self.username}>'

පැහැදිලි කිරීම:

• class User(db.Model):: db.Model එකෙන් inherit කරලා තමයි අපි models හදන්නේ. මේකෙන් කියන්නේ මේ User class එක database එකේ user කියන table එකට අනුරූපයි කියන එකයි.
• id = db.Column(db.Integer, primary_key=True): id කියන්නේ table එකේ තියෙන Column එකක්. ඒක Integer වර්ගයේ එකක්. primary_key=True කියන්නේ මේක unique identifier එක (ප්‍රාථමික යතුර) කියන එකයි.
• username = db.Column(db.String(80), unique=True, nullable=False): username column එක String වර්ගයේ එකක් (උපරිම අක්ෂර 80). unique=True කියන්නේ මේ username එක database එකේ වෙනත් කිසිම User කෙනෙකුට ගන්න බැහැ කියන එකයි. nullable=False කියන්නේ මේ column එක හිස්ව තියන්න බැහැ, අනිවාර්යයෙන්ම අගයක් දෙන්න ඕනේ කියන එකයි.
• email = db.Column(db.String(120), unique=True, nullable=False): email එකත් ඒ වගේමයි.
• __repr__(self): මේ method එකෙන් කියන්නේ අපි User object එකක් print (මුද්‍රණය) කරනකොට ඒක කොහොමද පෙන්වන්න ඕනේ කියලා.

දැන්, site.db file එක හදන්න:
ඔයාගේ terminal එකේ python කියලා ගහලා Python shell එකට යන්න. ඊට පස්සේ මේ commands ටික run කරන්න:

from app import db, app, User # app.py එකෙන් db, app, User import කරගන්න
with app.app_context(): # app context එකක් ඇතුළේ
    db.create_all() # database tables ටික හදන්න

දැන් ඔයාගේ project folder එකේ site.db කියන file එක හැදිලා තියෙන්න ඕනේ. ඒක ඇතුළේ user කියන table එකත් හැදිලා ඇති.

4. Database Operations: CRUD ප්‍රායෝගිකව

හරි, දැන් අපි Models හදාගත්තා. Database tables ටිකත් හැදුවා. දැන් බලමු කොහොමද දත්ත ගබඩාවට දත්ත එකතු කරන්නේ (Create), තියෙන දත්ත හොයාගන්නේ (Retrieve), වෙනස් කරන්නේ (Update) සහ මකලා දාන්නේ (Delete) කියලා. මේවට තමයි CRUD Operations කියන්නේ.

අපි මේ operations ටික Python shell එකෙන් කරලා බලමු. (ඔයාට මේවා Flask routes ඇතුළේ භාවිත කරන්න පුළුවන්).

මුලින්ම, terminal එකේ python කියලා ගහලා shell එකට ගිහින් අපිට අවශ්‍ය දේවල් import කරගමු:

from app import db, app, User
app_context = app.app_context()
app_context.push() # app context එකක් ආරම්භ කරනවා

දත්ත එකතු කිරීම (Create / Add)

අලුත් user කෙනෙක් database එකට එකතු කරමු:

# අලුත් User object එකක් හදනවා
user_john = User(username='john_doe', email='[email protected]')
user_jane = User(username='jane_smith', email='[email protected]')

# Database session එකට add කරනවා
db.session.add(user_john)
db.session.add(user_jane)

# වෙනස්කම් database එකට save කරනවා (commit කරනවා)
db.session.commit()
print("Users added successfully!")

දත්ත ලබා ගැනීම (Retrieve / Read)

දැන් අපි එකතු කරපු දත්ත ටික retrieve කරලා බලමු:

සියලුම Users ලා ලබා ගැනීම:

all_users = User.query.all()
print("All Users:")
for user in all_users:
    print(user.id, user.username, user.email)

ID එකෙන් User කෙනෙක් ලබා ගැනීම:

# ID 1 තියෙන User කෙනෙක්ව හොයනවා
user_by_id = User.query.get(1)
if user_by_id:
    print(f"User with ID 1: {user_by_id.username}, {user_by_id.email}")
else:
    print("User with ID 1 not found.")

නමින් (username) හෝ ඊමේල් (email) එකෙන් User කෙනෙක්ව හොයා ගැනීම (Filter):

# username 'john_doe' තියෙන User කෙනෙක්ව හොයනවා
user_by_username = User.query.filter_by(username='john_doe').first()
if user_by_username:
    print(f"User by username: {user_by_username.username}, {user_by_username.email}")
else:
    print("User 'john_doe' not found.")

# email '[email protected]' තියෙන User කෙනෙක්ව හොයනවා
user_by_email = User.query.filter_by(email='[email protected]').first()
if user_by_email:
    print(f"User by email: {user_by_email.username}, {user_by_email.email}")
else:
    print("User with email '[email protected]' not found.")

.first() කියන්නේ filter එකට අදාළව හමුවෙන පළමු user කෙනාව ගන්න කියන එකයි. මොකද filter එකකින් usersලා ගොඩක් එන්න පුළුවන්.

දත්ත වෙනස් කිරීම (Update)

දැන් අපි ID 1 තියෙන User කෙනාගේ email එක වෙනස් කරමු:

# ID 1 තියෙන User කෙනෙක්ව හොයාගන්නවා
user_to_update = User.query.get(1)

if user_to_update:
    user_to_update.email = '[email protected]' # email එක වෙනස් කරනවා
    db.session.commit() # වෙනස්කම් database එකට save කරනවා
    print(f"User {user_to_update.username} email updated to {user_to_update.email}")
else:
    print("User with ID 1 not found for update.")

දත්ත මකා දැමීම (Delete)

අවසාන වශයෙන්, අපි ID 2 තියෙන User කෙනාව database එකෙන් මකා දමමු:

# ID 2 තියෙන User කෙනෙක්ව හොයාගන්නවා
user_to_delete = User.query.get(2)

if user_to_delete:
    db.session.delete(user_to_delete) # session එකෙන් delete කරනවා
    db.session.commit() # වෙනස්කම් database එකට save කරනවා
    print(f"User {user_to_delete.username} deleted successfully.")
else:
    print("User with ID 2 not found for deletion.")

Note: CRUD operations ටික ඉවර වුනාට පස්සේ shell එකෙන් එළියට එන්න: app_context.pop() ඊට පස්සේ exit().

5. පොදු ගැටළු සහ විසඳුම් (Common Issues & Solutions)

වැඩ කරගෙන යනකොට පොඩි පොඩි ගැටළු එන්න පුළුවන්. මෙන්න ඒවාට පොදු විසඳුම්:

• Database tables හැදෙන්නේ නැහැ / site.db file එක නැහැ:
  db.create_all() command එක නිවැරදිව run වුනේ නැති වෙන්න පුළුවන්. මතක තියාගන්න, ඒක Flask application context එකක් ඇතුළේ run කරන්න ඕනේ. මුලින්ම app.py එක run කරලා බලන්න. නැත්නම් Python shell එකේ from app import db, app; with app.app_context(): db.create_all() කියලා run කරන්න. මේක හැම පාරක්ම කරන්න ඕනේ නැහැ, database එක මුලින්ම හදනකොට විතරයි.
• sqlalchemy.exc.IntegrityError:
  මේ error එක එන්නේ සාමාන්‍යයෙන් ඔයා unique=True කියලා දීලා තියෙන column එකකට (උදා: username හෝ email) දැනටමත් database එකේ තියෙන අගයක් ආයෙත් දෙන්න ගියොත්. ඒ වගේම nullable=False තියෙන column එකකට අගයක් නොදුන්නොත් මේ error එක එන්න පුළුවන්.
• SQLALCHEMY_TRACK_MODIFICATIONS warning:
  මේ warning එක එන්නේ app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] කියන එක True වෙලා තියෙන හින්දා. ඒක False කරන එක තමයි හොඳම භාවිතය. අපි උඩින් දීලා තියෙන code එකේ ඒක False කරලා තියෙන්නේ.
• Database locked (SQLite):
  බොහෝ වෙලාවට මේක වෙන්නේ එකම database file එකට එකම වෙලාවේ requests කිහිපයක් එනකොට. ඒ වගේම Python shell එකේ database එක open කරලා තියෙද්දි Flask server එක run කරන්න හැදුවොත් එහෙම වෙන්න පුළුවන්. Shell එකෙන් exit() වෙලා server එක run කරන්න. Production environments වලදී SQLite වෙනුවට PostgreSQL හෝ MySQL වගේ databases පාවිච්චි කරන එක මේ ගැටළුවට හොඳ විසඳුමක්.

6. හොඳම භාවිතයන් (Best Practices)

• Models වෙනම Files වලට වෙන් කරන්න: ලොකු project එකකදී app.py එකේම හැම model එකම තියෙන එක අවුල් වෙන්න පුළුවන්. models.py වගේ file එකක් හදලා ඒකට models ටික දාන්න. එතකොට from .models import User වගේ import කරගන්න පුළුවන්.
• Error Handling: Database operations කරනකොට try-except blocks භාවිත කරලා errors handle කරන්න පුරුදු වෙන්න. දත්ත එකතු කරනකොට IntegrityError වගේ ඒවා එන්න පුළුවන්, ඒවට නිසි ප්‍රතිචාරයක් දෙන්න පුළුවන් වෙනවා.
• Migrations: ඔයාගේ database schema එක වෙනස් වෙනකොට (අලුත් column එකක් එකතු කරනකොට, column එකක data type එක වෙනස් කරනකොට) දැනටමත් database එකේ තියෙන data වලට හානියක් නොවී ඒ වෙනස්කම් apply කරන්න Flask-Migrate වගේ tools භාවිත කරන්න. මේක Alembic මත පදනම් වෙලා තියෙන්නේ.
• Sessions නිවැරදිව භාවිත කරන්න: හැම database operation එකකින් පස්සේම db.session.commit() කරලා වෙනස්කම් save කරන්න. Error එකක් ආවොත් db.session.rollback() කරලා කලින් තිබ්බ තත්වෙට එන්න පුළුවන්.

නිගමනය

Flask සමඟ SQLAlchemy භාවිතයෙන් දත්ත ගබඩා කළමනාකරණය කරන ආකාරය ගැන ඔයාලට දැන් හොඳ අවබෝධයක් තියෙනවා කියලා හිතනවා. ORM එකක් විදියට SQLAlchemy භාවිතා කිරීමෙන් Python objects භාවිතයෙන්ම database එකත් එක්ක වැඩ කරන්න පුළුවන් වීම විශාල වාසියක්. අපි අද Model එකක් නිර්මාණය කරන ආකාරය, CRUD operations කරන ආකාරය සහ පොදු ගැටළු වගේම හොඳම භාවිතයන් ගැනත් කතා කළා.

දැන් මේක ඔයාගේ ඊළඟ Flask project එකට එකතු කරලා උත්සාහ කරන්න. මොනවා හරි ගැටළුවක් ආවොත්, නැත්නම් ඔයාගේ අත්දැකීම් කොහොමද කියලා පහතින් comment එකක් දාලා කියන්න. ඒ වගේම මේ tutorial එක ඔයාගේ යාළුවන්ටත් share කරන්න අමතක කරන්න එපා!

තවත් අලුත් දෙයක් අරගෙන ඉක්මනටම හමුවෙමු! Happy Coding! 🎉