Flask Web Development with Databases (SQLAlchemy) Sinhala Guide

ආයුබෝවන් යාළුවනේ! අද අපි කතා කරන්න යන්නේ Web Development වලදී නැතුවම බැරි කොටසක් ගැන – ඒ තමයි Databases. විශේෂයෙන්ම, Python වල Flask Framework එක භාවිතයෙන් අපේ Web Application එකකට Database එකක් සම්බන්ධ කරගන්නෙ කොහොමද, ඒ වගේම SQLAlchemy කියන ජනප්‍රිය Object-Relational Mapper (ORM) එක භාවිතයෙන් Data එක්ක වැඩ කරන්නේ කොහොමද කියලා.

ඔබ Web Application එකක් හදනවා නම්, Users ලගේ විස්තර, Products වල තොරතුරු, Posts වගේ දේවල් ගබඩා කරගන්න තැනක් අවශ්‍යයි නේද? ඒකට තමයි Databases ඕන වෙන්නේ. සාමාන්‍යයෙන් Database එකක් එක්ක කෙලින්ම වැඩ කරන්න SQL Queries ලියන්න වෙනවා. ඒත් ORMs ආවට පස්සේ ඒ වැඩේ ගොඩක් පහසු වුණා. මේ Tutorial එක අවසාන වෙද්දී, ඔබට Flask Application එකකට Database එකක් සාර්ථකව සම්බන්ධ කරගන්න, Data Add කරන්න, Read කරන්න, Update කරන්න, Delete කරන්න අවශ්‍ය දැනුම ලැබිලා තියේවි. එහෙනම්, අපි පටන් ගමු!

ORMs (Object-Relational Mappers) සහ SQLAlchemy

මුලින්ම බලමු මේ ORM එකක් කියන්නේ මොකක්ද කියලා. සරලව කිව්වොත්, ORM එකක් කියන්නේ, ඔබ ලියන Code එක (අපේ මේ අවස්ථාවේදී Python Code) සහ Relational Database එකක් (වගේ SQL Database එකක්) අතර පාලමක් වගේ දෙයක්. සාමාන්‍යයෙන් ඔබ Database එකකින් Data ගන්න, දාන්න, වෙනස් කරන්න ඕන වුණාම SQL Queries ලියන්න වෙනවා. උදාහරණයක් විදියට, Users ලාගේ Table එකක Details ගන්න ඕන නම් SELECT * FROM users; කියලා Query එකක් ලියන්න වෙනවා. ඒත් ORM එකක් භාවිත කරද්දී, ඔබට SQL ලියන්න ඕන වෙන්නේ නැහැ. ඒ වෙනුවට, ඔබ ඔබේ Programming Language එකේ Objects සමඟ වැඩ කරනවා. ORM එක ඒ Objects සහ Database Tables අතර පරිවර්තනය කරනවා.

ORM එකක වාසි:

• සරල බව (Simplicity): SQL ගැන ගැඹුරින් දැනුමක් නැතිව Database එකක් එක්ක වැඩ කරන්න පුළුවන්.
• වේගය (Speed): සංකීර්ණ SQL Queries ලියනවාට වඩා ඉක්මනින් Data Operations කරන්න පුළුවන්.
• Code එක පිරිසිදු වීම (Cleaner Code): Database Logic එක Application Logic එකෙන් වෙන් කරලා තියාගන්න පුළුවන්.
• Database එක මාරු කිරීමේ පහසුව (Database Agnosticism): ඔබ භාවිත කරන Database වර්ගය (MySQL, PostgreSQL, SQLite, ආදී) වෙනස් කරන්න වුවමනා වුණොත්, Code එකේ ලොකු වෙනසක් කරන්න ඕන වෙන්නේ නැහැ. ORM එක ඒ වෙනස බලාගන්නවා.

දැන් අපි බලමු SQLAlchemy ගැන. SQLAlchemy කියන්නේ Python Programming Language එක සඳහා තියෙන ඉතාමත් බලවත්, Flexible සහ ජනප්‍රිය ORM එකක්. එයට Data Access Patterns ගොඩක් Support කරනවා. Flask Application එකක් එක්ක SQLAlchemy භාවිත කරන්න Flask-SQLAlchemy කියන Extension එක භාවිත කරන එක තමයි සුදුසුම දේ. මේ Extension එක නිසා Flask Application එකක SQLAlchemy Setup කරන එක ඉතාමත් පහසු වෙනවා.

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

මුලින්ම අපිට අවශ්‍ය Dependencies Install කරගමු. ඔබට pip භාවිතයෙන් මේවා Install කරගන්න පුළුවන්:

pip install Flask Flask-SQLAlchemy

දැන් අපි අපේ Flask Application එකේ Database එකක් Configure කරමු. මේ Tutorial එක සඳහා අපි සරල SQLite Database එකක් භාවිත කරනවා. SQLite කියන්නේ File-based Database එකක් නිසා එයට වෙනම Server එකක් Install කරන්න ඕන වෙන්නේ නැහැ. Development වලදී එය ගොඩක් පහසුයි.

අපේ app.py (හෝ ඔබ තෝරාගන්නා වෙනත් නමක් සහිත) file එක මේ විදියට හදාගමු:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import os

# Flask App එක initialize කරමු
app = Flask(__name__)

# Database එකේ Path එක define කරමු
# os.path.abspath(os.getcwd()) කියන්නේ වර්තමාන Folder එකේ සම්පූර්ණ Path එක
basedir = os.path.abspath(os.path.dirname(__file__))
app.config['SQLALCHEMY_DATABASE_URI'] = \
    'sqlite:///' + os.path.join(basedir, 'database.db')
# මේක True කළොත් සෑම Request එකකදීම Database Modifications ගැන Signal එකක් දෙනවා.
# ඒකේ ලොකු වාසියක් නැති නිසා False කරන එක වඩා හොඳයි.
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# SQLAlchemy Object එක initialize කරමු
db = SQLAlchemy(app)


@app.route('/')
def hello():
    return "ආයුබෝවන්, Flask සහ SQLAlchemy ලෝකයට!"


if __name__ == '__main__':
    # Database Tables නිර්මාණය කරන්න මේ Method එක භාවිත කරනවා.
    # මෙය Application එක Run වෙන්න කලින් Run වෙන්න ඕන.
    with app.app_context():
        db.create_all()
    app.run(debug=True)

මේ Code එකේ වෙන්නේ මොනවද කියලා බලමු:

• app = Flask(__name__): අපේ Flask Application එක හදාගන්නවා.
• app.config['SQLALCHEMY_DATABASE_URI']: මේක තමයි Database එකේ Path එක. අපි sqlite:///database.db කියල දුන්නාම database.db කියලා File එකක් අපේ Project Folder එකේම හැදෙනවා.
• app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False: මේක Performance වලට වැදගත්. Database Changes Track කිරීම Disable කරනවා.
• db = SQLAlchemy(app): SQLAlchemy Extension එක අපේ Flask Application එකට සම්බන්ධ කරනවා.
• with app.app_context(): db.create_all(): මේක ඉතා වැදගත්! අපේ Application එකේ define කරන Database Models (ඊළඟ කොටසේ කතා කරමු) වලට අදාළ Tables Database එකේ නිර්මාණය කරන්න මේකෙන් පුළුවන්. අපි මේක app.run() එකට කලින් call කරන්නේ, Tables හැදුනාට පස්සේ Application එක Run වෙන්න ඕන නිසා.

මේ Code එක Save කරලා Run කළාට පස්සේ, ඔබේ Project Folder එකේ database.db කියලා File එකක් හැදිලා තියේවි. ඒක තවම හිස්, මොකද අපි තවම Models define කරලා නැහැ.

Database Models නිර්මාණය කිරීම (Defining Database Models)

දැන් අපි බලමු ORM එකක් හරහා Database Tables කොහොමද Python Classes විදියට Define කරන්නේ කියලා. අපි User කෙනෙක්ගේ විස්තර ගබඩා කරගන්න User කියන Model එක නිර්මාණය කරමු. මේ Model එක database.db එකේ users කියලා Table එකක් විදියට හැදේවි.

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

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)
    is_admin = db.Column(db.Boolean, default=False)

    def __repr__(self):
        return f'<User {self.username}>'

මේ Code එකේ තේරුම බලමු:

• class User(db.Model):: අපි User කියලා Class එකක් හදනවා. මේක db.Model එකෙන් Inherit කරනවා. ඒ කියන්නේ මේ Class එක Database Table එකකට Map වෙනවා කියලා.
• id = db.Column(db.Integer, primary_key=True): id කියලා Column එකක්. ඒක Integer වර්ගයේ එකක්. primary_key=True කියන්නේ මේක Table එකේ Unique Identify එක (ප්‍රාථමික යතුර) බව.
• username = db.Column(db.String(80), unique=True, nullable=False): username Column එක. මේක String වර්ගයේ එකක් (උපරිම අකුරු 80ක්). unique=True කියන්නේ මේ Column එකේ එකම Username එක දෙපාරක් දාන්න බැහැ. nullable=False කියන්නේ මේ Column එක හිස්ව තියන්න බැහැ (අනිවාර්යයෙන්ම Value එකක් තිබිය යුතුයි).
• email = db.Column(db.String(120), unique=True, nullable=False): email Column එකත් username වගේමයි.
• is_admin = db.Column(db.Boolean, default=False): is_admin Column එක. මේක True/False Value එකක් ගන්නවා. අලුතෙන් User කෙනෙක් Add කරද්දී මේකට Value එකක් දුන්නේ නැත්නම් Default එක False වෙනවා.
• def __repr__(self):: මේ Method එකෙන් කරන්නේ Python Object එකක් Print කරද්දී කොහොමද Display වෙන්න ඕන කියලා කියන එක. Debugging වලදී මේක ගොඩක් ප්‍රයෝජනවත්.

දැන් ඔබ app.py File එක Save කරලා Run කළාම (හෝ දැනට Run වෙවී තියෙනවා නම් Restart කළාම), database.db File එකේ users කියලා Table එකක් හැදිලා තියේවි. ඒක බලන්න ඔබට DB Browser for SQLite වගේ Tool එකක් භාවිත කරන්න පුළුවන්.

Data සමඟ වැඩ කරමු (Working with Data - CRUD Operations)

දැන් අපි බලමු මේ User Model එක භාවිතයෙන් Database එකට Data Add කරන්න, Read කරන්න, Update කරන්න සහ Delete කරන්නෙ කොහොමද කියලා. මේවාට CRUD Operations කියනවා (Create, Read, Update, Delete).

1. Data Add කිරීම (Create)

අලුත් User කෙනෙක් Database එකට එකතු කරන්න, අපි User Class එකේ Object එකක් හදලා, ඒක Database Session එකට දාලා, Commit කරනවා.

මේක Run කරන්න පුළුවන් විවිධ ක්‍රම තියෙනවා. අපිට Temporary Route එකක් හදන්න පුළුවන්, එහෙම නැත්නම් Flask Shell එක භාවිත කරන්න පුළුවන්. Flask Shell එක තමයි Development වලට ගොඩක් පහසු. Terminal එකේ මේ විදියට Type කරන්න:

flask shell

දැන් Flask Shell එක ඇතුලේ මේ Code එක Run කරන්න:

>>> from app import db, User

>>> # අලුත් User කෙනෙක් හදමු
>>> new_user = User(username='kasun', email='[email protected]')

>>> # User ව Database Session එකට Add කරමු
>>> db.session.add(new_user)

>>> # Database එකට Changes Commit කරමු (Changes Save කරමු)
>>> db.session.commit()

>>> print("User added successfully!")

දැන් kasun කියන User Database එකට එකතු වෙලා තියේවි. තව User කෙනෙක් Add කරමු:

>>> new_user2 = User(username='amara', email='[email protected]', is_admin=True)
>>> db.session.add(new_user2)
>>> db.session.commit()
>>> print("Second user added!")

2. Data Retrieve කිරීම (Read)

Database එකෙන් Data ගන්න විවිධ ක්‍රම තියෙනවා.

• සියලුම Users ලා ගන්න (Get all users):
• ID එකකින් User කෙනෙක් ගන්න (Get user by ID):
• Filter කරලා User කෙනෙක් ගන්න (Get user by filter):

>>> user_by_email = User.query.filter_by(email='[email protected]').first() # .first() එකෙන් ගැලපෙන පළවෙනි එක දෙනවා
>>> if user_by_email:
...     print(f"Found User by Email: {user_by_email.username}")
... else:
...     print("User not found!")

>>> # Admin Users ලා විතරක් ගන්න
>>> admin_users = User.query.filter_by(is_admin=True).all()
>>> for user in admin_users:
...     print(f"Admin User: {user.username}")

>>> user_by_id = User.query.get(1) # ID එක 1 වන User
>>> if user_by_id:
...     print(f"Found User by ID: {user_by_id.username}")
... else:
...     print("User not found!")

>>> all_users = User.query.all()
>>> for user in all_users:
...     print(f"ID: {user.id}, Username: {user.username}, Email: {user.email}, Admin: {user.is_admin}")
... 

3. Data Update කිරීම (Update)

තියෙන Data එකක් වෙනස් කරන්න, මුලින්ම ඒ Object එක Database එකෙන් Retrieve කරගෙන, පස්සේ ඒකේ Properties වෙනස් කරලා, Session එක Commit කරනවා.

>>> # Kasun ගේ Email එක update කරමු
>>> user_to_update = User.query.filter_by(username='kasun').first()
>>> if user_to_update:
...     user_to_update.email = '[email protected]'
...     db.session.commit()
...     print(f"Kasun's email updated to {user_to_update.email}")
... else:
...     print("User 'kasun' not found!")

4. Data Delete කිරීම (Delete)

Database එකෙන් Data එකක් Delete කරන්න, මුලින්ම ඒ Object එක Retrieve කරගෙන, පස්සේ ඒක Session එකෙන් Delete කරලා, Commit කරනවා.

>>> # Amara ව Delete කරමු
>>> user_to_delete = User.query.filter_by(username='amara').first()
>>> if user_to_delete:
...     db.session.delete(user_to_delete)
...     db.session.commit()
...     print(f"User '{user_to_delete.username}' deleted successfully!")
... else:
...     print("User 'amara' not found!")

දැන් ඔබ User.query.all() කියලා ගැහුවොත් amara කියන User ඉන්නේ නැති බව පෙනේවි.

පොදු ගැටළු සහ හොඳ පුරුදු (Common Issues & Best Practices)

පොදු ගැටළු:

• Database Connection Errors: SQLALCHEMY_DATABASE_URI එක වැරදි නම් මේ Error එක එන්න පුළුවන්. Path එක හරිද කියලා දෙපාරක් Check කරන්න.
• Table Not Found Error: ඔබ db.create_all() Call කළේ නැත්නම් හෝ Application එක Restart කළේ නැත්නම් මේ Error එක එන්න පුළුවන්. Models define කළාට පස්සේ අනිවාර්යයෙන්ම db.create_all() Run වෙන්න ඕන.
• Unique Constraint Errors: ඔබ unique=True කියලා දුන්න Column එකකට (උදා: username, email) දැනටමත් තියෙන Value එකක් නැවත Add කරන්න හැදුවොත් මේ Error එක එනවා.
• Missing Commit Error: Data Add, Update, Delete කළාට පස්සේ db.session.commit() Call නොකළොත් Changes Database එකේ Save වෙන්නේ නැහැ.

හොඳ පුරුදු (Best Practices):

• ORM භාවිතය: Database Interaction සඳහා හැමවිටම ORM එකක් භාවිත කරන්න. මෙය SQL Injection වැනි ආරක්ෂක ගැටළු අවම කරනවා වගේම, Code එක කියවන්න සහ maintain කරන්න පහසු කරනවා. ඉතාමත් විශේෂ අවස්ථා වලදී පමණක් Raw SQL Queries ලියන්න.
• Migrations භාවිතය: ඔබේ Application එක වර්ධනය වෙද්දී Database Schema එක වෙනස් කරන්න වෙනවා (උදා: අලුත් Column එකක් Add කරන්න). මේ සඳහා Flask-Migrate වැනි Library එකක් භාවිත කරලා Migrations කරන්න පුළුවන්. මෙය Database Changes Systematic විදියට Manage කරන්න උදව් වෙනවා.
• Separate Model Files: Application එක ලොකු වෙද්දී, සියලුම Models app.py එකේ තියන එක සුදුසු නැහැ. models.py වැනි වෙනම File එකක Models Define කරලා, එය app.py එකට Import කරගන්න.
• Error Handling: Database Operations වලදී Error ඇතිවෙන්න පුළුවන් (උදා: Network issues, Unique Constraint violations). ඒ නිසා try-except Blocks භාවිතයෙන් Error Handling කරන්න පුරුදු වෙන්න.
• Session Management: db.session.add(), db.session.commit() වගේම db.session.rollback() ගැනත් අවධානය යොමු කරන්න. යම්කිසි හේතුවක් නිසා Operation එකක් අසාර්ථක වුණොත් Changes Rollback කරන්න සිදුවෙනවා.

නිගමනය

අද අපි Flask Web Application එකකට Database එකක් සම්බන්ධ කරගන්නෙ කොහොමද, ඒ වගේම SQLAlchemy ORM එක භාවිතයෙන් Data එක්ක වැඩ කරන්නේ කොහොමද කියලා විස්තරාත්මකව ඉගෙන ගත්තා. අපි Models define කරන ආකාරය, Data Add (Create) කරන ආකාරය, Retrieve (Read) කරන ආකාරය, Update කරන ආකාරය සහ Delete කරන ආකාරය ගැන පැහැදිලිව කතා කළා. ඒ වගේම Database Operations වලදී ඇතිවෙන්න පුළුවන් පොදු ගැටළු සහ හොඳ පුරුදු ගැනත් සාකච්ඡා කළා.

දැන් ඔබට Flask Application එකක් සඳහා Database Layer එකක් සාදාගෙන, Data Management කරන්න අවශ්‍ය මූලික දැනුම තියෙනවා. මේක ඉතා වැදගත් පියවරක්, මොකද ඕනෑම Real-world Application එකක Data තමයි හදවත. මේ Tutorial එකේ තියෙන Code එක ඔබටම Run කරලා බලන්න. විවිධ Models හදලා, ඒවට අදාළ Operations කරලා බලන්න. එතකොට තමයි මේ Concepts ඔලුවට හරියටම යන්නේ.

මීට වඩා ගැඹුරට යන්න, ඔබට Flask Blueprints සහ Database Migrations (Flask-Migrate) වගේ දේවල් ගැනත් ඉගෙන ගන්න පුළුවන්. ඒවා ඔබේ Application එක තවදුරටත් Scalable සහ Maintainable කරන්න උදව් වේවි. යම් ගැටළුවක් ආවොත් හෝ අදහසක් බෙදාගන්න කැමති නම්, පහළින් Comment කරන්න!