Skip to content

19. استخدام SQLAlchemy ORM

أظهر الفصل السابق أنه في بعض الحالات، يمكننا كتابة كود مستقل عن نظام إدارة قواعد البيانات المستخدم باستخدام البنية التالية:

Image

في هذا الفصل، سنستخدم ORM (Object Relational Mapper) [SQLAlchemy] للوصول إلى أنظمة إدارة قواعد البيانات (DBMS) بشكل موحد، بغض النظر عن نظام إدارة قواعد البيانات المستخدم. يتيح ORM أمرين:

  • يسمح للبرنامج النصي بالتفاعل مع نظام إدارة قواعد البيانات دون إصدار أوامر SQL؛
  • يخفي تفاصيل كل نظام إدارة قواعد البيانات عن البرنامج النصي؛

تصبح البنية كما يلي:

Image

أصبح البرنامج النصي الآن منفصلاً عن الموصلات بواسطة ORM. ويتواصل مع ORM باستخدام الفئات والأساليب. ولا يقوم بتنفيذ كود SQL. يقوم ORM بذلك باستخدام الموصلات التي يتصل بها. ويخفي تفاصيل هذه الموصلات عن البرنامج النصي. وبالتالي، لا يتأثر كود البرنامج النصي بأي تغيير في الموصل (وبالتالي في نظام إدارة قواعد البيانات)؛

ستكون بنية الدليل للبرامج النصية قيد النظر على النحو التالي:

Image

19.1. تثبيت ORM [SQLAlchemy]

يأتي ORM [SQLAlchemy] كحزمة Python يجب تثبيتها في محطة Python:


(venv) C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\databases\sqlalchemy>pip install sqlalchemy
Collecting sqlalchemy
  Downloading SQLAlchemy-1.3.18-cp38-cp38-win_amd64.whl (1.2 MB)
     || 1.2 MB 3.3 MB/s
Installing collected packages: sqlalchemy
Successfully installed sqlalchemy-1.3.18

19.2. البرامج النصية 01: الأساسيات

Image

  • في [1]، البرامج النصية التي سيتم دراستها. ستستخدم هذه البرامج النصية الفئات من [2]: BaseEntity، MyException، Person، Utils؛

19.2.1. التكوين

يقوم ملف [config] بتكوين التطبيق على النحو التالي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def configure():
    #  root_dir
    #  absolute path configuration relative path reference
    root_dir = "C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020"
    #  absolute paths of dependencies
    absolute_dependencies = [
        #  BaseEntity, MyException, Person, Utilities
        f"{root_dir}/classes/02/entities",
    ]

    #  set the syspath
    from myutils import set_syspath
    set_syspath(absolute_dependencies)

    #  class configuration
    from Personne import Personne
    Personne.excluded_keys = ['_sa_instance_state']

    #  return the config
    return {}

تعليقات

  • السطر 8: أضف المجلد الذي يحتوي على الفئات [BaseEntity، MyException، Person، Utils] إلى مسار Python؛
  • السطران 12-13: نحدد مسار Python للتطبيق؛
  • السطران 16-17: قد تتذكر أن فئة |BaseEntity| تحتوي على سمة فئة تسمى [excluded_keys]. هذه السمة عبارة عن قائمة نضع فيها خصائص الفئة التي لا نريدها أن تظهر في قاموس الفئة (وظيفة asdict). هنا نستبعد الخاصية [_sa_instance_state] من حالة فئة [Person]. سنرى السبب قريبًا؛

19.2.2. نص [demo]

يُظهر البرنامج النصي [demo] الاستخدام الأولي لـ ORM [sqlalchemy]:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#  retrieve application configuration
import config

config = config.configure()

#  imports
from sqlalchemy import Table, Column, Integer, String, MetaData, UniqueConstraint
from sqlalchemy.orm import mapper

from Personne import Personne

#  metadata
metadata = MetaData()

#  the table
personnes_table = Table("personnes", metadata,
                        Column('id', Integer, primary_key=True),
                        Column('prenom', String(30), nullable=False),
                        Column("nom", String(30), nullable=False),
                        Column("age", Integer, nullable=False),
                        UniqueConstraint('nom', 'prenom', name='uix_1')
                        )
#  the Person class before mapping
personne1 = Personne().fromdict({"id": 67, "prénom": "x", "nom": "y", "âge": 10})
print(f"personne1={personne1.__dict__}")

#  mapping
mapper(Personne, personnes_table, properties={
    'id': personnes_table.c.id,
    'prénom': personnes_table.c.prenom,
    'nom': personnes_table.c.nom,
    'âge': personnes_table.c.age
})

#  person1 has not been modified
print(f"personne1={personne1.__dict__}")
#  the Person class has been modified - it has been "enriched"
personne2 = Personne().fromdict({"id": 68, "prénom": "x1", "nom": "y1", "âge": 11})
print(f"personne2={personne2.__dict__}")

تعليقات

  • الأسطر 1-4: نقوم بتكوين التطبيق؛
  • الأسطر 6-10: نستورد الوحدات النمطية اللازمة للنص البرمجي؛
  • السطر 13: [MetaData] هي فئة في [sqlalchemy]؛
  • الأسطر 15-22: [Table] هي فئة في [sqlalchemy]. تُستخدم لوصف جدول قاعدة بيانات. هنا، سنصف جدول [people] في قاعدة بيانات MySQL [dbpeople] التي تمت تغطيتها في فصل |MySQL|؛
    • السطر 16: المعلمة الأولى [people] هي اسم الجدول الذي يتم وصفه؛
    • السطر 16: المعلمة الثانية [metadata] هي مثيل [MetaData] الذي تم إنشاؤه في السطر 13؛
    • الأسطر 17–22: تصف كل معلمة من المعلمات التالية عمودًا من أعمدة الجدول باستخدام صيغة خاصة بـ [SQLAlchemy] ولكنها مشابهة لصيغة SQL؛
    • يتم وصف كل عمود باستخدام مثيل لفئة [Column] من [sqlalchemy]؛
      • المعلمة الأولى هي اسم العمود؛
      • المعلمة الثانية هي نوعه؛
      • المعلمات التالية هي معلمات مسماة:
        • السطر 17: [primary_key=True] للإشارة إلى أن عمود [id] هو المفتاح الأساسي لجدول [people]؛
        • السطر 18: [nullable=False] للإشارة إلى أن العمود يجب أن يحتوي على قيمة عند إدراج صف في الجدول؛
    • السطر 21: أخيرًا، تسمح لك فئة [UniqueConstraint] بتعريف قيد التفرد. هنا، نحدد أن الأعمدة (last_name، first_name) يجب أن تكون فريدة داخل الجدول. تسمح لك الخاصية المسماة [name] بإعطاء اسم لهذا القيد. هنا، هناك حالتان يجب أخذهما في الاعتبار:
      • نحن نصف جدولًا موجودًا. في هذه الحالة، يجب أن نبحث عن اسم القيد في خصائص الجدول (phpMyAdmin أو pgAdmin)؛
      • نحن نصف جدولًا نحن على وشك إنشائه. في هذه الحالة، ندخل الاسم الذي نريده؛
  • الأسطر 23–25: نقوم بإنشاء شخص [person1] وعرض قاموسه [__dict__]. هنا سيكون لدينا: 
personne1={'_BaseEntity__id': 67, '_Personne__prénom': 'x', '_Personne__nom': 'y', '_Personne__âge': 10}
  • الأسطر 27–33: نقوم بعملية تعيين، أي ننشئ توافقًا بين الفئة [Person] والجدول [people]. وهذا في الأساس تعيين [خصائص الفئة  أعمدة الجدول]. تأخذ الدالة [mapper] هنا ثلاثة معلمات:
    • السطر 28: المعلمة الأولى هي اسم الفئة التي يتم إجراء التعيين لها؛
    • السطر 28: المعلمة الثانية هي الجدول الذي سيتم ربطه بها. هذا هو كائن [Table] الذي تم إنشاؤه في السطر 16؛
    • السطر 28: المعلمة الثالثة هنا هي معلمة تُسمى [properties]. وهي عبارة عن قاموس تكون مفاتيحه هي خصائص الفئة المُعَدَّلة، وقيمه هي أعمدة الجدول المُعَدَّل. للإشارة إلى العمود X في جدول [personnes_table]، نكتب [personnes_table.c.X]؛
  • السطران 35-36: نعرض الشخص [person1] مرة أخرى بمجرد اكتمال التعيين. نرى أنه لم يتغير: 
personne1={'_BaseEntity__id': 67, '_Personne__prénom': 'x', '_Personne__nom': 'y', '_Personne__âge': 10}
  • السطور 37-39: نقوم بإنشاء شخص جديد [person2] وعرضه. ثم نرى النتيجة التالية: 
personne2={'_sa_instance_state': <sqlalchemy.orm.state.InstanceState object at 0x00000259A6747FA0>, 'id': 68, 'prénom': 'x1', 'nom': 'y1', 'âge': 11}

يمكننا أن نرى أن القاموس [__dict__] قد تم تعديله بشكل كبير:

  • (تابع)
    • ظهرت خاصية جديدة [_sa_instance_state]. يمكننا أن نرى أنها كائن ORM [sqlalchemy]؛
    • تمت إزالة البادئات من الخصائص الأخرى، والتي كانت تشير سابقًا إلى الفئة التي تنتمي إليها؛

وبالتالي يمكننا أن نستنتج أن عملية التعيين في الأسطر 27–33 قد عدلت فئة [Person].

عندما نرغب في عرض حالة كائن [Person]، فإننا لا نرغب عمومًا في الخاصية [_sa_instance_state]. فهي موجودة فقط من أجل العمليات الداخلية لـ [SQLAlchemy] ولا تهمنا عمومًا. ولهذا السبب كتبنا في البرنامج النصي [config]:

1
2
3
    #  class configuration
    from Personne import Personne
    Personne.excluded_keys = ['_sa_instance_state']

19.2.3. البرنامج النصي [main]

سيقوم البرنامج النصي [main] بمعالجة الجدول [people] في قاعدة بيانات MySQL [dbpeople] من خلال التفاعل مع [sqlalchemy]. لفهم ما يلي، نحتاج إلى تذكر البنية المستخدمة هنا:

Image

إذا كانت [Database1] هي قاعدة البيانات [dbpersonnes]، فيمكننا أن نرى أن الاتصال بين البرنامج النصي وقاعدة البيانات هذه يتضمن مكونين:

  • موصل Python بنظام إدارة قواعد البيانات MySQL؛
  • نظام إدارة قواعد البيانات MySQL؛

سيتواصل البرنامج النصي [main] مع ORM، الذي سيتواصل بدوره مع موصل Python. يتواصل ORM مع هذا الموصل باستخدام الأدوات الموضحة في أقسام |MySQL| و|PostgreSQL|، ولا سيما عن طريق إصدار أوامر SQL. لن يستخدم البرنامج النصي [main] أوامر SQL. سيعتمد على واجهة برمجة التطبيقات (API) الخاصة بـ ORM، والتي تتكون من فئات وواجهات.

النص البرمجي [main] هو كما يلي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#  configure the application
import config

config = config.configure()

#  imports
from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, UniqueConstraint
from sqlalchemy.exc import IntegrityError, InterfaceError
from sqlalchemy.orm import mapper, sessionmaker

from Personne import Personne

#  database connection string MySQL
engine = create_engine("mysql+mysqlconnector://admpersonnes:nobody@localhost/dbpersonnes")

#  metadata
metadata = MetaData()

#  the table
personnes_table = Table("personnes", metadata,
                        Column('id', Integer, primary_key=True),
                        Column('prenom', String(30), nullable=False),
                        Column("nom", String(30), nullable=False),
                        Column("age", Integer, nullable=False),
                        UniqueConstraint('nom', 'prenom', name='uix_1')
                        )

#  mapping
mapper(Personne, personnes_table, properties={
    'id': personnes_table.c.id,
    'prénom': personnes_table.c.prenom,
    'nom': personnes_table.c.nom,
    'âge': personnes_table.c.age
})

#  the factory session
Session = sessionmaker()
Session.configure(bind=engine)

session = None
try:
    #  a session
    session = Session()

    #  delete [people] table
    session.execute("drop table if exists personnes")

    #  table recreation from mapping
    metadata.create_all(engine)

    #  insertion
    session.add(Personne().fromdict({"id": 67, "prénom": "x", "nom": "y", "âge": 10}))
    #  session.commit()

    #  a request
    personnes = session.query(Personne).all()

    #  display
    print("Liste des personnes ---------")
    for personne in personnes:
        print(personne)

    #  two other insertions, the second of which fails due to uniqueness (first name, last name)
    session.add(Personne().fromdict({"id": 68, "prénom": "x1", "nom": "y1", "âge": 10}))
    session.add(Personne().fromdict({"id": 69, "prénom": "x1", "nom": "y1", "âge": 10}))

    #  a request
    personnes = session.query(Personne).all()

    #  display
    print("Liste des personnes ---------")
    for personne in personnes:
        print(personne)

    #  session validation
    session.commit()

except (InterfaceError, IntegrityError) as erreur:
    #  display
    print(f"L'erreur suivante s'est produite : {erreur}")
    #  cancellation of last session
    if session:
        print("rollback...")
        session.rollback()
finally:
    #  release session resources
    if session:
        session.close()

تعليقات

  • الأسطر 1–4: يتم تكوين التطبيق؛
  • الأسطر 7–9: نستورد سلسلة كاملة من الفئات والواجهات من مكتبة [sqlalchemy]؛
  • السطر 11: يتم استيراد فئة [Person]؛
  • السطر 14: سلسلة اتصال قاعدة البيانات. وهي تحدد:
    • نظام إدارة قواعد البيانات المستخدم (mysql)؛
    • موصل Python المستخدم (mysql.connector بدون النقطة)؛
    • المستخدم الذي يقوم بتسجيل الدخول (admpersonnes)؛
    • كلمة المرور الخاصة به (nobody)؛
    • الجهاز الذي يوجد عليه نظام إدارة قواعد البيانات (localhost = الجهاز الذي يعمل عليه البرنامج النصي)؛
    • اسم قاعدة البيانات (dbpersonnes)؛

باستخدام هذه المعلومات، يمكن لـ [sqlalchemy] الاتصال بقاعدة البيانات. لاحظ أن موصل Python المستخدم يجب أن يكون مثبتًا بالفعل. [sqlalchemy] لا يقوم بتثبيته.

  • الأسطر 19–26: وصف جدول [people]؛
  • الأسطر 28–34: التعيين بين فئة [Person] وجدول [people]؛
  • الأسطر 36–38: تُنفَّذ معظم عمليات [sqlalchemy] ضمن جلسة عمل. ويشبه مفهوم جلسة عمل [sqlalchemy] مفهوم معاملة SQL. يتم إنشاء جلسات العمل من فئة [Session] التي تُرجعها الدالة [sessionmaker] في السطر 37؛
  • السطر 38: ترتبط فئة [Session] بقاعدة البيانات [dbpeople] عبر سلسلة الاتصال في السطر 14؛
  • السطر 43: يتم إنشاء جلسة عمل. كما ذكرنا، يمكن تشبيه جلسة العمل بمعاملة؛
  • السطران 45-46: تسمح طريقة [Session.execute] بتنفيذ عبارة SQL. هذه ليست ممارسة شائعة، حيث ذكرنا أن ORM يسمح بتجنب استخدام SQL؛
  • السطران 48-49: تقوم طريقة [metadata.create_all] بإنشاء جميع الجداول باستخدام مثيل [MetaData] من السطر 17. لدينا جدول واحد فقط: جدول [people] المحدد في الأسطر 20-26. سيستخدم [SQLAlchemy] المعلومات الواردة في هذه الأسطر لإنشاء الجدول. هنا نرى فائدة رئيسية لـ ORM: إنه يخفي تفاصيل نظام إدارة قواعد البيانات (DBMS). في الواقع، يمكن أن تختلف عبارة SQL [create] بشكل كبير من نظام إدارة قواعد البيانات (DBMS) إلى آخر بسبب أنواع البيانات المخصصة للأعمدة. لم تكن هناك توحيد لأنواع البيانات في SQL. وبالتالي، تختلف عبارة [create] من نظام إدارة قواعد البيانات (DBMS) إلى آخر. هنا، بفضل [SQLAlchemy]:
    • نصف الجدول الذي نريده بطريقة واحدة ومتسقة؛
    • يتمكن [SQLAlchemy] من إنشاء جملة [create] المناسبة لنظام إدارة قواعد البيانات الذي يعمل معه؛
  • السطر 52: نضيف كائن [Person] إلى الجلسة. هذا لا يضيفه تلقائيًا إلى قاعدة البيانات. في الواقع، يتبع ORM قواعده الخاصة للتزامن مع قاعدة البيانات. سيسعى دائمًا إلى تحسين عدد الاستعلامات التي يقوم بها. لنأخذ مثالاً. يضيف البرنامج النصي (add) شخصين (person1، person2) إلى الجلسة ثم يقوم باستعلام: يريد رؤية جميع الأشخاص في الجدول. يمكن لـ [SQLAlchemy] المضي قدماً على النحو التالي:
    • يمكن إضافة [person1] في الذاكرة. لا داعي لإدراجه في قاعدة البيانات في الوقت الحالي؛
    • وينطبق الأمر نفسه على [person2]؛
    • يأتي بعد ذلك استعلام [select]. يجب علينا بعد ذلك استرداد جميع الصفوف من جدول [people]. سيقوم [SQLAlchemy] بعد ذلك بإدراج [person1، person2] في قاعدة البيانات وتنفيذ الاستعلام؛

وبالتالي، سيقوم [SQLAlchemy] بإجراء تحسينات تكون شفافة للمطور.

  • السطر 56: لتنفيذ استعلام [select] (أريد أن أرى...)، نستخدم طريقة [Session.query]. المعلمة لطريقة [query] هي الفئة المرتبطة بالجدول الذي يتم الاستعلام عنه. ترجع هذه الطريقة كائن [Query]. تسترد طريقة [Query.all] جميع كائنات [Person] من الجلسة. وهي تُرجع جميع الصفوف من جدول [people]، كل منها في شكل كائن [Person]. للقيام بذلك، يستخدم [SQLAlchemy] التعيين الذي تم إنشاؤه بين فئة [Person] وجدول [people]. نتيجة السطر 56 هي قائمة بكائنات [Person]؛
  • الأسطر 58–61: نعرض عناصر قائمة [people]. ونظرًا لأن فئة [Person] مشتقة من فئة [BaseEntity]، فإن الدالة [Person.__str__] المستخدمة هنا ضمناً في السطر 61 هي في الواقع الدالة [BaseEntity.__str__]، والتي تُرجع سلسلة JSON للكائن المستدعي. هذه السلسلة هي سلسلة JSON الخاصة بقاموس [Person.asdict] (انظر |BaseEntity|). ذكرنا أنه بعد التعيين، سنجد الخاصية [_sa_instance_state] في كل كائن [Person]. ومع ذلك، فإن قيمة هذه الخاصية ليست من النوع [BaseEntity]. لذلك يجب استبعادها من قاموس فئة [Person]؛ وإلا، فسوف يتعطل العرض. وهذا ما تم في البرنامج النصي [config]؛
  • الأسطر 63-65: نضيف شخصين آخرين لهما نفس الاسم الأول واسم العائلة. ومع ذلك، هناك قيد تفرد على اتحاد هذين العمودين. لذلك، من المفترض أن يحدث خطأ. وهذا ما نحاول التحقق منه؛
  • الأسطر 67-68: نطلب قائمة بجميع الأشخاص في قاعدة البيانات مرة أخرى؛
  • الأسطر 70-73: ونعرضهم؛
  • السطور 75-76: يتم تثبيت الجلسة. كما يوحي الاسم، سيتم تثبيت المعاملة الأساسية؛
  • سنرى أثناء التنفيذ أن الأسطر 67-76 لن يتم تنفيذها بسبب الاستثناء الذي أثاره السطر 65. سننتقل بعد ذلك إلى الأسطر 78-84 لمعالجة الاستثناء؛
  • السطر 78: يحدث استثناء [InterfaceError] إذا تعذر على [SQLAlchemy] الاتصال بقاعدة البيانات [dbpersonnes]. يحدث استثناء [IntegrityError] في السطر 65؛
  • السطر 80: يتم عرض الخطأ؛
  • الأسطر 82-84: إذا كانت الجلسة موجودة، نقوم بإرجاعها. وهذا يعادل إرجاع المعاملة الأساسية؛
  • الأسطر 85–88: في جميع الحالات، سواء حدث خطأ أم لا، يتم إغلاق الجلسة لتحرير الموارد؛

نتائج التنفيذ هي كما يلي:


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/databases/sqlalchemy/01/main.py
Liste des personnes ---------
{"nom": "y", "prénom": "x", "id": 67, "âge": 10}
L'erreur suivante s'est produite : (raised as a result of Query-invoked autoflush; consider using a session.no_autoflush block if this flush is occurring prematurely)
(mysql.connector.errors.IntegrityError) 1062 (23000): Duplicate entry 'y1-x1' for key 'uix_1'
[SQL: INSERT INTO personnes (id, prenom, nom, age) VALUES (%(id)s, %(prenom)s, %(nom)s, %(age)s)]
[parameters: ({'id': 68, 'prenom': 'x1', 'nom': 'y1', 'age': 10}, {'id': 69, 'prenom': 'x1', 'nom': 'y1', 'age': 10})]
(Background on this error at: http://sqlalche.me/e/13/gkpj)
rollback...
 
Process finished with exit code 0
  • السطران 2-3: قائمة الأشخاص بعد الإدراج الأول؛
  • السطر 5: استثناء [IntegrityError] الذي حدث عند إضافة شخصين يحملان نفس الاسم الأول واسم العائلة؛
  • السطران 6-7: لاحظ عبارة SQL التي فشلت. إنها عبارة INSERT معلمة: [SQLAlchemy] أدخلت كلا الشخصين بعبارة INSERT واحدة. هنا يمكننا أن نرى أنها حاولت تحسين عبارات SQL الصادرة؛

الآن دعونا نستخدم phpMyAdmin لعرض محتويات جدول [people]:

Image

يمكننا أن نرى في [6] أن الجدول فارغ. حتى الشخص الأول الذي أضافه البرنامج النصي إلى الجلسة غير موجود. ويرجع ذلك إلى أن الجلسة كانت جزءًا من معاملة، وتم التراجع عن تلك المعاملة في جملة [except] في البرنامج النصي [main].

دعونا الآن نجري التغيير التالي في [main]:

1
2
3
    #  insertion
    session.add(Personne().fromdict({"id": 67, "prénom": "x", "nom": "y", "âge": 10}))
    #  session.commit()

بعد إضافة شخص في السطر 2، نقوم بإلغاء تعليق السطر 3. ستقوم عملية [session.commit] بتثبيت المعاملة الأساسية، وستبدأ معاملة جديدة. بعد التنفيذ، يكون محتوى جدول [people] كما يلي:

Image

يمكننا أن نلاحظ في [6] أن عملية الإدراج الأولى قد تم الاحتفاظ بها. ويرجع ذلك إلى أنها تمت ضمن المعاملة 1، بينما وقع الخطأ اللاحق ضمن المعاملة 2.

19.3. البرامج النصية 02: تعيينات [sqlalchemy]

Image

النصوص البرمجية 02 هي نسخة معدلة من النصوص البرمجية 01. نحاول التهيئة قدر الإمكان في [config.py]. نقوم الآن بتهيئة بيئة [sqlalchemy] للتطبيق هناك:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
def configure():
    #  absolute path configuration relative path reference
    root_dir = "C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020"
    #  absolute paths of dependencies
    absolute_dependencies = [
        #  BaseEntity, MyException, Person, Utilities
        f"{root_dir}/classes/02/entities",
    ]

    #  set the syspath
    from myutils import set_syspath
    set_syspath(absolute_dependencies)

    #  imports
    from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, UniqueConstraint
    from sqlalchemy.orm import mapper, sessionmaker

    #  link to a database MySQL
    engine = create_engine("mysql+mysqlconnector://admpersonnes:nobody@localhost/dbpersonnes")

    #  metadata
    metadata = MetaData()

    #  the table
    personnes_table = Table("personnes", metadata,
                            Column('id', Integer, primary_key=True),
                            Column('prenom', String(30), nullable=False),
                            Column("nom", String(30), nullable=False),
                            Column("age", Integer, nullable=False),
                            UniqueConstraint('nom', 'prenom', name='uix_1')
                            )

    #  mapping
    from Personne import Personne

    mapper(Personne, personnes_table, properties={
        'id': personnes_table.c.id,
        'prénom': personnes_table.c.prenom,
        'nom': personnes_table.c.nom,
        'âge': personnes_table.c.age
    })

    #  the factory session
    Session = sessionmaker()
    Session.configure(bind=engine)

    #  we put this information in the config
    config = {}
    config["Session"] = Session
    config["metadata"] = metadata
    config["engine"] = engine
    config["personnes_table"] = personnes_table

    #  class configuration
    from Personne import Personne
    Personne.excluded_keys = ['_sa_instance_state']

    #  return the config
    return config

تعليقات

  • الأسطر 2–12: تكوين مسار Python؛
  • الأسطر 14–45: تكوين بيئة [sqlalchemy]؛
  • الأسطر 47–52: تتم إضافة بيئة [sqlalchemy] إلى قاموس التكوين؛
  • الأسطر 54–56: تكوين فئة [Person]؛

مع هذا التكوين، يصبح البرنامج النصي [main] كما يلي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#  configure the application
import config

config = config.configure()

#  syspath is configured - imports are made
from sqlalchemy.exc import IntegrityError, DatabaseError, InterfaceError
from sqlalchemy.orm.exc import FlushError

from Personne import Personne

session = None
try:
    #  a session
    session = config["Session"]()

    #  delete [people] table
    session.execute("drop table if exists personnes")

    #  table recreation from mapping
    config["metadata"].create_all(config["engine"])

    #  two inserts
    session.add(Personne().fromdict({"prénom": "x", "nom": "y", "âge": 10}))
    personne = Personne().fromdict({"prénom": "x1", "nom": "y1", "âge": 7})
    session.add(personne)

    #  validation of the two inserts
    session.commit()

    #  a request
    personnes = session.query(Personne).all()

    #  display
    print("Liste des personnes-----------")
    for personne in personnes:
        print(personne)

    #  two other insertions, the second of which fails
    session.add(Personne().fromdict({"prénom": "x2", "nom": "y2", "âge": 10}))
    session.add(Personne().fromdict({"prénom": "x2", "nom": "y2", "âge": 10}))

    #  a request
    personnes = session.query(Personne).all()

    #  display
    print("Liste des personnes-----------")
    for personne in personnes:
        print(personne)

    #  session validation
    session.commit()

except (FlushError, DatabaseError, InterfaceError, IntegrityError) as erreur:
    #  display
    print(f"L'erreur suivante s'est produite : {erreur}")
    #  cancellation of last session
    if session:
        print("rollback...")
        session.rollback()
finally:
    #  display
    print("Travail terminé...")
    #  release session resources
    if session:
        session.close()

نتائج التنفيذ هي كما يلي:


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/databases/sqlalchemy/02/main.py
Liste des personnes-----------
{"âge": 10, "nom": "y", "prénom": "x", "id": 1}
{"âge": 7, "nom": "y1", "prénom": "x1", "id": 2}
L'erreur suivante s'est produite : (raised as a result of Query-invoked autoflush; consider using a session.no_autoflush block if this flush is occurring prematurely)
(mysql.connector.errors.IntegrityError) 1062 (23000): Duplicate entry 'y2-x2' for key 'uix_1'
[SQL: INSERT INTO personnes (prenom, nom, age) VALUES (%(prenom)s, %(nom)s, %(age)s)]
[parameters: {'prenom': 'x2', 'nom': 'y2', 'age': 10}]
(Background on this error at: http://sqlalche.me/e/13/gkpj)
rollback...
Travail terminé...
 
Process finished with exit code 0

في phpMyAdmin، يبدو جدول [people] الآن كما يلي:

Image

الآن، دعونا نلقي نظرة على جدول [people] الذي تم إنشاؤه بواسطة [SQLAlchemy]:

Image

  • في [6]، الأنواع المستخدمة للأعمدة المختلفة؛
  • في [7]، نلاحظ أن العمود [id] يحمل السمة [AUTO_INCREMENT]. وهذا يعني أنه عند إدراج صف في الجدول، إذا لم يكن لهذا الصف قيمة في عمود [id]، فسوف يقوم MySQL بإنشائها بشكل متزايد: 1، 2، 3، … هذه الخاصية توفر علينا عناء القلق بشأن قيمة المفتاح الأساسي عند الإدراج في الجدول: فنحن نترك MySQL يتولى إنشائها؛
  • في [8]، نرى أن العمود [id] هو المفتاح الأساسي؛
  • في [9]، نرى قيد التفرد على الحقول [last_name, first_name]؛

19.4. البرامج النصية 03: معالجة كيانات الجلسة [sqlalchemy]

Image

ملف التكوين [config] هو نفسه كما في المثال السابق. في البرنامج النصي [main]، نقوم بإجراء عمليات قياسية [INSERT، UPDATE، DELETE، SELECT] على الجدول [people] باستخدام أساليب [SQLAlchemy]:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
#  configure the application
import config

config = config.configure()

#  imports
from sqlalchemy import func
from sqlalchemy.exc import IntegrityError, DatabaseError, InterfaceError
from sqlalchemy.orm.session import Session
from Personne import Personne

#  displays the contents of table [people]
def affiche_table(session: Session):
    print("----------------")
    #  a request
    personnes = session.query(Personne).all()
    #  display
    affiche_personnes(personnes)

#  displays a list of people
def affiche_personnes(personnes: list):
    print("----------------")
    #  display
    for personne in personnes:
        print(personne)


#  main ---------------------------
session = None
try:
    #  a session
    session = config["Session"]()

    #  delete [people] table
    #  checkfirst=True: first checks that the table exists
    config["personnes_table"].drop(config["engine"], checkfirst=True)

    #  table recreation from mapping
    config["metadata"].create_all(config["engine"])

    #  inserts
    session.add(Personne().fromdict({"prénom": "Pierre", "nom": "Nicazou", "âge": 35}))
    session.add(Personne().fromdict({"prénom": "Géraldine", "nom": "Colou", "âge": 26}))
    session.add(Personne().fromdict({"prénom": "Paulette", "nom": "Girondé", "âge": 56}))

    #  displays the session content
    affiche_table(session)

    #  list of persons in alphabetical order of surnames and, for equal surnames, in alphabetical order of first names
    personnes = session.query(Personne).order_by(Personne.nom.desc(), Personne.prénom.desc())

    #  display
    affiche_personnes(personnes)

    #  list of people with an age in the range [20,40] in descending order of age
    #  then for equal ages in alphabetical order of surnames and for equal surnames in alphabetical order of first names
    personnes = session.query(Personne). \
        filter(Personne.âge >= 20, Personne.âge <= 40). \
        order_by(Personne.âge.desc(), Personne.nom.asc(), Personne.prénom.asc())

    #  display
    affiche_personnes(personnes)

    #  insertion of mrs Bruneau
    bruneau = Personne().fromdict({"prénom": "Josette", "nom": "Bruneau", "âge": 46})
    session.add(bruneau)
    #  change of age
    bruneau.âge = 47

    #  list of people named Bruneau
    personne = session.query(Personne).filter(func.lower(Personne.nom) == "bruneau").first()

    #  display
    affiche_personnes([personne])

    #  deletion of Mme Bruneau
    session.delete(personne)

    #  list of people named Bruneau
    personnes = session.query(Personne).filter(func.lower(Personne.nom) == "bruneau")

    #  display
    affiche_personnes(personnes)

    #  session validation
    session.commit()

except (DatabaseError, InterfaceError, IntegrityError) as erreur:
    #  display
    print(f"L'erreur suivante s'est produite : {erreur}")
    #  cancellation of last session
    if session:
        session.rollback()

finally:
    #  display
    print("Travail terminé...")
    #  release session resources
    if session:
        session.close()

تعليقات

  • الأسطر 20–25: تعرض الدالة [display_people] العناصر الموجودة في قائمة الأشخاص؛
  • الأسطر 12–18: تعرض الدالة [display_people] محتويات جدول [people]؛
  • الأسطر 34–36: نقوم بإسقاط الجدول [people]. على عكس الإصدارات السابقة، لا نستخدم استعلام SQL بل طريقة [SQLAlchemy]:
    • config["people_table"] هو كائن [Table] الذي يصف جدول [people]؛
    • config["engine"] هو سلسلة الاتصال بقاعدة البيانات [dbpersonnes]؛
    • يضمن المعامل المسمى [checkfirst=True] أن العملية لا تُنفذ إلا إذا كان الجدول [people] موجودًا؛
  • السطور 38–39: يتم إعادة إنشاء جدول [people]؛
  • الأسطر 41–44: تتم إضافة ثلاثة أشخاص إلى الجلسة. لاحظ أنهم لا يتم إدراجهم بالضرورة على الفور في جدول [people]. يعتمد هذا على استراتيجية [SQLAlchemy] الموجهة نحو الأداء؛
  • السطران 46-47: يتم عرض محتويات جدول [people]. إذا لم يتم إدراج الأشخاص الثلاثة بعد، فسيتم إدراجهم الآن بسبب هذا الطلب؛
  • السطور 49-50: مثال على استخدام طريقة [order_by]، التي تسمح بعرض نتائج الاستعلام بترتيب معين. تعرض صيغة [order_by(criterion1, criterion2)] النتائج أولاً وفقًا للمعيار [criterion1]، وعندما تحتوي الصفوف على نفس القيمة لـ [criterion1]، يتم فرزها وفقًا للمعيار [criterion2]. يمكن تحديد معايير متعددة بهذه الطريقة؛
  • الأسطر 55-59: تقدم مفهوم التصفية باستخدام طريقة [filter]. تقوم الصيغة [filter(criterion1, criterion2)] بإجراء عملية منطقية AND بين المعايير المستخدمة؛
  • الأسطر 64–67: يتم تسجيل دخول مستخدم جديد؛
  • السطران 70-71: مثال آخر على استعلام مُصفى. تقوم الدالة [func.lower(param)] بتحويل [param] إلى أحرف صغيرة. وهناك دوال أخرى متاحة يُشار إليها بـ [func.xx]. في التعبير الموجود في السطر 71:
    • [session.query.filter] تُرجع قائمة من كائنات [Person]؛
    • [session.query.filter.first] تُرجع العنصر الأول من هذه القائمة؛
  • السطر 77: يتم إزالة عنصر من الجلسة؛
  • السطر 86: يتم التحقق من صحة الجلسة؛

نتائج التنفيذ هي كما يلي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/databases/sqlalchemy/03/main.py
----------------
----------------
{"âge": 35, "nom": "Nicazou", "prénom": "Pierre", "id": 1}
{"âge": 26, "nom": "Colou", "prénom": "Géraldine", "id": 2}
{"âge": 56, "nom": "Girondé", "prénom": "Paulette", "id": 3}
----------------
{"âge": 35, "nom": "Nicazou", "prénom": "Pierre", "id": 1}
{"âge": 56, "nom": "Girondé", "prénom": "Paulette", "id": 3}
{"âge": 26, "nom": "Colou", "prénom": "Géraldine", "id": 2}
----------------
{"âge": 35, "nom": "Nicazou", "prénom": "Pierre", "id": 1}
{"âge": 26, "nom": "Colou", "prénom": "Géraldine", "id": 2}
----------------
{"prénom": "Josette", "nom": "Bruneau", "âge": 47, "id": 4}
----------------
Travail terminé...

Process finished with exit code 0
  • الأسطر 4-6: محتوى الجلسة؛
  • الأسطر 8-10: محتوى الجلسة مرتبة حسب الأسماء من الأكبر إلى الأصغر؛
  • السطور 12–13: محتوى الجلسة للأشخاص الذين تتراوح أعمارهم بين [20، 40]؛
  • السطر 15: الشخص المسمى "bruneau"؛

في phpMyAdmin، يكون محتوى جدول [people] في نهاية التنفيذ كما يلي:

Image

19.5. البرامج النصية 04: استخدام قاعدة بيانات [PostgreSQL]

Image

المجلد [04] هو نسخة من المجلد [03]. نغير شيئًا واحدًا فقط: سلسلة الاتصال في ملف [config]:


    # lien vers une base de données PostgreSQL
    engine = create_engine("postgresql+psycopg2://admpersonnes:nobody@localhost/dbpersonnes")

تشير سلسلة الاتصال هذه الآن إلى قاعدة البيانات [dbpersonnes] في نظام إدارة قواعد البيانات [PostgreSQL]. لاحظ استخدام موصل [psycopg2]. يجب تثبيت هذا الموصل.

يؤدي تشغيل البرنامج النصي [main] إلى النتائج التالية:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/databases/sqlalchemy/04/main.py
----------------
----------------
{"nom": "Nicazou", "prénom": "Pierre", "id": 1, "âge": 35}
{"nom": "Colou", "prénom": "Géraldine", "id": 2, "âge": 26}
{"nom": "Girondé", "prénom": "Paulette", "id": 3, "âge": 56}
----------------
{"nom": "Nicazou", "prénom": "Pierre", "id": 1, "âge": 35}
{"nom": "Girondé", "prénom": "Paulette", "id": 3, "âge": 56}
{"nom": "Colou", "prénom": "Géraldine", "id": 2, "âge": 26}
----------------
{"nom": "Nicazou", "prénom": "Pierre", "id": 1, "âge": 35}
{"nom": "Colou", "prénom": "Géraldine", "id": 2, "âge": 26}
----------------
{"prénom": "Josette", "nom": "Bruneau", "âge": 47, "id": 4}
----------------
Travail terminé...

Process finished with exit code 0

باستخدام أداة [pgAdmin] (انظر قسم |pgAdmin|)، تكون حالة الجدول [people] كما يلي:

Image

تم إنشاء الجدول [people] باستخدام كود SQL التالي:

Image

  • في [4-5]، نرى أن العمود [id] هو المفتاح الأساسي. ونرى أيضًا أنه يحتوي على قيمة افتراضية [كلمة DEFAULT]، مما يعني أنه إذا تم إدراج صف بدون مفتاح أساسي، فسيقوم نظام إدارة قواعد البيانات (DBMS) بإنشاء واحد. هذه ممارسة شائعة: نترك نظام إدارة قواعد البيانات (DBMS) يقوم بإنشاء المفاتيح الأساسية؛

توضح هذه النسخة 05 من نصوص [sqlalchemy] بوضوح مدى سهولة التبديل من نظام إدارة قواعد البيانات (DBMS) إلى آخر: كل ما كان مطلوبًا هو تغيير سلسلة الاتصال في نص التكوين. لم يتغير أي شيء آخر. إذا قارنا أنواع الأعمدة [id, last_name, first_name, age] أعلاه بتلك الموجودة في جدول MySQL من المثال |02|، نرى أنها مختلفة. يقوم [sqlalchemy] بتكييفها مع نظام إدارة قواعد البيانات المستخدم. هذه القدرة على التكيف مع نظام إدارة قواعد بيانات جديد هي سبب كافٍ لاعتماد [sqlalchemy] أو أي ORM آخر.

19.6. البرامج النصية 05: مثال كامل

Image

المثال الذي ننظر إليه هو إعادة صياغة للمثال الذي تمت تغطيته في القسم |troiscouches-v01|. تضمن ذلك المثال بنية ثلاثية المستويات [UI، منطق الأعمال، DAO] التي تعاملت مع الكيانات [Class، Student، Subject، Grade]. تم ترميز الكيانات بشكل ثابت في طبقة [DAO]. نحن الآن نضعها في قاعدة بيانات. سنستخدم نظامي إدارة قواعد البيانات: MySQL و PostgreSQL.

19.6.1. بنية التطبيق

ستكون بنية التطبيق كما يلي:

Image

  • في [1-3]، نجد الطبقات [UI، Business، DAO] الموجودة بالفعل في المثال |troiscouches-v01|. تتواصل طبقة [DAO] الآن مع طبقة [ORM]؛
  • يتم تنفيذ الطبقات [1-5] باستخدام كود Python؛

19.6.2. قواعد البيانات

نقوم بإنشاء قاعدة بيانات MySQL باسم [dbecole] مملوكة للمستخدم [admecole] بكلمة مرور [mdpecole]. للقيام بذلك، نتبع الإجراء الموضح في قسم |إنشاء قاعدة بيانات|:

Image

Image

  • في [1]، لا تحتوي قاعدة البيانات [dbecole] على أي جداول [3]؛
  • في [7]، يتمتع المستخدم [admecole] بامتيازات كاملة على قاعدة البيانات هذه؛

نقوم بنفس الشيء مع نظام إدارة قواعد البيانات PostgreSQL. ننشئ قاعدة بيانات باسم [dbecole] يملكها المستخدم [admecole] بكلمة مرور [mdpecole]. للقيام بذلك، نتبع الإجراء الموصوف في قسم |إنشاء قاعدة بيانات|:

Image

  • في [1]، قاعدة البيانات [dbecole]؛
  • في [2]، المستخدم [admecole]؛
  • في [3-4]، قاعدة البيانات [dbecole] مملوكة للمستخدم [admecole]؛

19.6.3. الكيانات التي يتعامل معها التطبيق

في تطبيق |troiscouches v01|، كانت الكيانات التي تم التعامل معها كما يلي (انظر |entities|). هذه هي الكيانات التي سيتم تخزينها في قواعد البيانات السابقة. لن نقوم بتكرار هذه الكيانات في التطبيق الجديد. سنقوم باستردادها من المكان الذي تم تعريفها فيه بالفعل.

فئة [Class]:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#  imports
from BaseEntity import BaseEntity
from MyException import MyException
from Utils import Utils


class Classe(BaseEntity):
    #  attributes excluded from class state
    excluded_keys = []

    #  class properties
    @staticmethod
    def get_allowed_keys() -> list:
        #  id: class identifier
        #  name: class name
        return BaseEntity.get_allowed_keys() + ["nom"]

    #  getter
    @property
    def nom(self: object) -> str:
        return self.__nom

    #   setters
    @nom.setter
    def nom(self: object, nom: str):
        #  name must be a non-empty string
        if Utils.is_string_ok(nom):
            self.__nom = nom
        else:
            raise MyException(11, f"Le nom de la classe {self.id} doit être une chaîne de caractères non vide")

فئة [Student]:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#  imports
from BaseEntity import BaseEntity
from Classe import Classe
from MyException import MyException

from Utils import Utils


class Elève(BaseEntity):
    #  attributes excluded from class state
    excluded_keys = []

    #  class properties
    @staticmethod
    def get_allowed_keys() -> list:
        #  id: student identifier
        #  name: student's name
        #  first name: student's first name
        #  class: student's class
        return BaseEntity.get_allowed_keys() + ["nom", "prénom", "classe"]

    #  getters
    @property
    def nom(self: object) -> str:
        return self.__nom

    @property
    def prénom(self: object) -> str:
        return self.__prénom

    @property
    def classe(self: object) -> Classe:
        return self.__classe

    #   setters
    @nom.setter
    def nom(self: object, nom: str) -> str:
        #  name must be a non-empty string
        if Utils.is_string_ok(nom):
            self.__nom = nom
        else:
            raise MyException(41, f"Le nom de l'élève {self.id} doit être une chaîne de caractères non vide")

    @prénom.setter
    def prénom(self: object, prénom: str) -> str:
        #  first name must be a non-empty string
        if Utils.is_string_ok(prénom):
            self.__prénom = prénom
        else:
            raise MyException(42, f"Le prénom de l'élève {self.id} doit être une chaîne de caractères non vide")

    @classe.setter
    def classe(self: object, value):
        try:
            #  we expect a Class type
            if isinstance(value, Classe):
                self.__classe = value
            #  or a type dict
            elif isinstance(value,dict):
                self.__classe=Classe().fromdict(value)
            #  or a json type
            elif isinstance(value,str):
                self.__classe = Classe().fromjson(value)
        except BaseException as erreur:
            raise MyException(43, f"L'attribut [{value}] de l'élève {self.id} doit être de type Classe ou dict ou json. Erreur : {erreur}")

فئة [Subject]:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#  imports
from BaseEntity import BaseEntity
from MyException import MyException
from Utils import Utils


class Matière(BaseEntity):
    #  attributes excluded from class state
    excluded_keys = []

    #  class properties
    @staticmethod
    def get_allowed_keys() -> list:
        #  id: material identifier
        #  name: material name
        #  coefficient: subject coefficient
        return BaseEntity.get_allowed_keys() + ["nom", "coefficient"]

    #  getter
    @property
    def nom(self: object) -> str:
        return self.__nom

    @property
    def coefficient(self: object) -> float:
        return self.__coefficient

    #   setters
    @nom.setter
    def nom(self: object, nom: str):
        #  name must be a non-empty string
        if Utils.is_string_ok(nom):
            self.__nom = nom
        else:
            raise MyException(21, f"Le nom de la matière {self.id} doit être une chaîne de caractères non vide")

    @coefficient.setter
    def coefficient(self, coefficient: float):
        #  the coefficient must be a real number >=0
        erreur = False
        if isinstance(coefficient, (int, float)):
            if coefficient >= 0:
                self.__coefficient = coefficient
            else:
                erreur = True
        else:
            erreur = True
        #  mistake?
        if erreur:
            raise MyException(22, f"Le coefficient de la matière {self.nom} doit être un réel >=0")

فئة [Grade]:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#  imports
from BaseEntity import BaseEntity
from Elève import Elève
from Matière import Matière
from MyException import MyException


class Note(BaseEntity):
    #  attributes excluded from class state
    excluded_keys = []

    #  class properties
    @staticmethod
    def get_allowed_keys() -> list:
        #  id: note identifier
        #  value: the note itself
        #  student: student (of type Student) concerned by the note
        #  subject: subject (of type Subject) concerned by the grade
        #  the Note object is therefore a student's grade in a subject
        return BaseEntity.get_allowed_keys() + ["valeur", "élève", "matière"]

    #  getters
    @property
    def valeur(self: object) -> float:
        return self.__valeur

    @property
    def élève(self: object) -> Elève:
        return self.__élève

    @property
    def matière(self: object) -> Matière:
        return self.__matière

    #  getters
    @valeur.setter
    def valeur(self: object, valeur: float):
        #  the score must be a real number between 0 and 20
        if isinstance(valeur, (int, float)) and 0 <= valeur <= 20:
            self.__valeur = valeur
        else:
            raise MyException(31,
                f"L'attribut {valeur} de la note {self.id} doit être un nombre dans l'intervalle [0,20]")

    @élève.setter
    def élève(self: object, value):
        try:
            #  we expect a Student type
            if isinstance(value, Elève):
                self.__élève = value
            #  or a type dict
            elif isinstance(value, dict):
                self.__élève = Elève().fromdict(value)
            #  or a json type
            elif isinstance(value, str):
                self.__élève = Elève().fromjson(value)
        except BaseException as erreur:
            raise MyException(32,
                f"L'attribut [{value}] de la note {self.id} doit être de type Elève ou dict ou json. Erreur : {erreur}")

    @matière.setter
    def matière(self: object, value):
        try:
            #  we expect a Material type
            if isinstance(value, Matière):
                self.__matière = value
            #  or a type dict
            elif isinstance(value, dict):
                self.__matière = Matière().fromdict(value)
            #  or a json type
            elif isinstance(value, str):
                self.__matière = Matière().fromjson(value)
        except BaseException as erreur:
            raise MyException(33,
                f"L'attribut [{value}] de la note {self.id} doit être de type Matière ou dict ou json. Erreur : {erreur}")

19.6.4. التكوين

Image

تم تقسيم التكوين على عدة ملفات:

  • التكوين العام في [config.py]: يحدد مسار Python للتطبيق ويقوم بإنشاء مثيلات لطبقات البنية؛
  • تكوين [SQLAlchemy] في [config_database]: يتولى معالجة تعيينات الفئات/الجداول؛
  • يتم تكوين طبقات التطبيق في [config_layers]؛

ملف [config] كما يلي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
def configure(config: dict) -> dict:
    import os

    #  step 1 ---
    #  establish the application's Python Path
    #  absolute path of this script's folder
    script_dir = os.path.dirname(os.path.abspath(__file__))

    #  absolute path configuration relative path reference
    root_dir = "C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020"

    #  absolute paths of dependencies
    absolute_dependencies = [
        #  BaseEntity, MyException
        f"{root_dir}/classes/02/entities",
        #  projet troiscouches v01
        f"{root_dir}/troiscouches/v01/interfaces",
        f"{root_dir}/troiscouches/v01/services",
        f"{root_dir}/troiscouches/v01/entities",
        #  project files
        script_dir,
        f"{script_dir}/../services",
    ]

    #  update syspath
    from myutils import set_syspath
    set_syspath(absolute_dependencies)

    #  step 2 ------
    #  database configuration
    import config_database
    config = config_database.configure(config)

    #  step 3 ------
    #  instantiation of application layers
    import config_layers
    config = config_layers.configure(config)

    #  return the config
    return config
  • الأسطر 4–27: إنشاء مسار Python للتطبيق؛
  • الأسطر 29–32: تكوين [SQLAlchemy]؛
  • الأسطر 34–37: تكوين طبقات التطبيق؛

ملف [config_database] كما يلي:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
def configure(config: dict) -> dict:
    #  config['sgbd'] is the name of the SGBD used
    #  mysql : MySQL
    #  pgres : PostgreSQL

    #  sqlalchemy configuration
    from sqlalchemy import Table, Column, Integer, MetaData, String, Float, ForeignKey, create_engine

    from sqlalchemy.orm import mapper, relationship, sessionmaker

    #  connection chains to the databases used
    engines = {
        'mysql': "mysql+mysqlconnector://admecole:mdpecole@localhost/dbecole",
        'pgres': "postgresql+psycopg2://admecole:mdpecole@localhost/dbecole"
    }
    #  connection chain to the database used
    engine = create_engine(engines[config['sgbd']])

    #  metadata
    metadata = MetaData()

    #  database tables
    tables = {}
    #  mapped classes
    from Classe import Classe
    from Elève import Elève
    from Note import Note
    from Matière import Matière

    #  the class table
    tables['classes'] = classes_table = \
        Table("classes", metadata,
              Column('id', Integer, primary_key=True),
              Column('nom', String(30), nullable=False),
              )

    mapper(Classe, tables['classes'], properties={
        'id': classes_table.c.id,
        'nom': classes_table.c.nom
    })

    #  the student table
    tables['élèves'] = élèves_table = \
        Table("élèves", metadata,
              Column('id', Integer, primary_key=True),
              Column('nom', String(30), nullable=False),
              Column('prénom', String(30), nullable=False),
              #  a student belongs to a class
              Column('classe_id', Integer, ForeignKey('classes.id')),
              )
    #  mapping
    mapper(Elève, tables['élèves'], properties={
        'id': élèves_table.c.id,
        'nom': élèves_table.c.nom,
        'prénom': élèves_table.c.prénom,
        'classe': relationship(Classe, backref="élèves", lazy="select")
    })

    #  table of contents
    tables['matières'] = matières_table = \
        Table("matières", metadata,
              Column('id', Integer, primary_key=True),
              Column('nom', String(30), nullable=False),
              Column('coefficient', Float, nullable=False)
              )
    #  mapping
    mapper(Matière, tables['matières'], properties={
        'id': matières_table.c.id,
        'nom': matières_table.c.nom,
        "coefficient": matières_table.c.coefficient
    })

    #  notes table
    tables['notes'] = notes_table = \
        Table("notes", metadata,
              Column('id', Integer, primary_key=True),
              Column('valeur', Float, nullable=False),
              #  a grade is a student's grade
              Column('élève_id', Integer, ForeignKey('élèves.id')),
              #  a grade is a subject grade
              Column('matière_id', Integer, ForeignKey('matières.id')),
              )

    #  mapping
    mapper(Note, tables['notes'], properties={
        'id': notes_table.c.id,
        'valeur': notes_table.c.valeur,
        'élève': relationship(Elève, backref="notes", lazy="select"),
        'matière': relationship(Matière, backref="notes", lazy="select")
    })

    #  entity configuration [BaseEntity]
    Elève.excluded_keys = ['_sa_instance_state', 'notes', 'classe']
    Classe.excluded_keys = ['_sa_instance_state', 'élèves']
    Matière.excluded_keys = ['_sa_instance_state', 'notes']
    Note.excluded_keys = ['_sa_instance_state', 'matière', 'élève']

    #  the factory session
    Session = sessionmaker()
    Session.configure(bind=engine)

    #  a session
    session = Session()

    #  certain information is stored in the configuration dictionary
    config['database'] = {"engine": engine, "metadata": metadata, "tables": tables, "session": session}

    #  return the config
    return config

تعليقات

  • الأسطر 1-4: تستقبل الدالة [configure] قاموسًا كمعلمة. يتم استخدام المفتاح [db] فقط. يتم تعيينه إلى [mysql] إذا كانت قاعدة البيانات هي قاعدة بيانات MySQL، وإلى [pgres] إذا كانت قاعدة البيانات هي قاعدة بيانات PostgreSQL؛
  • الأسطر 6-9: استيراد عناصر من [sqlalchemy]. يقوم البرنامج النصي [config_database] بإجراء التعيينات بين الجداول في قاعدة البيانات [dbecole] والكيانات [Classes، Student، Subject، Grade]. في الجدول، يتم تغليف بيانات الكيان في صف. في كود Python، يتم تغليفها في كائن. ومن هنا جاء اسم ORM (Object Relational Mapper): يقوم ORM بإنشاء تعيين (رابط) بين صفوف قاعدة البيانات العلائقية والكائنات. في هذا التطبيق، لدينا أربعة كيانات [Class، Student، Subject، Grade] سيتم ربطها بأربعة جداول [classes، students، subjects، grades]. لاحظ أن أسماء الجداول قد تحتوي على أحرف مشددة؛
  • الأسطر 11–17: سلسلة الاتصال بقاعدة البيانات المستخدمة. يعتمد هذا على config['db'].
  • الأسطر 24-28: كيانات التطبيق التي سيتم تعيينها [SQLAlchemy]. عند تنفيذ هذه الأسطر، سيكون مسار Python قد تم إنشاؤه بالفعل بواسطة البرنامج النصي [config]؛
  • الأسطر 30–40: التعيين بين كيان [Class] وجدول [classes]؛
  • الأسطر 30–35: يتم تعريف جدول [classes] باستخدام فئة [Table] من [sqlalchemy]. نحدد أن هذا الجدول يحتوي على عمودين:
    • عمود [id]، وهو المفتاح الأساسي ويمثل رقم الفئة، السطر 33؛
    • العمود [name]، الذي يحتوي على اسم الفئة، السطر 34؛
  • السطران 31-32: لاحظ أن صيغة x=y=z صحيحة في لغة Python: يتم تعيين قيمة z إلى y، ثم قيمة y إلى x؛
  • الأسطر 37-40: يتم سرد التعيينات بين أعمدة جدول [classes] وخصائص كيان [Class]؛
  • الأسطر 42–57: التعيين بين كيان [Student] وجدول [students]؛
  • الأسطر 51–57: يتم تعريف جدول [students] باستخدام فئة [Table] من [SQLAlchemy]. نحدد أن هذا الجدول يحتوي على أربعة أعمدة:
    • عمود [id]، وهو المفتاح الأساسي ويمثل معرف الطالب، السطر 45؛
    • العمود [name]، الذي يحتوي على لقب الطالب، السطر 46؛
    • العمود [first_name]، الذي يحتوي على الاسم الأول للطالب، السطر 47. لاحظ أن اسم العمود يمكن أن يحتوي على أحرف مشطوبة؛
    • السطر 49، العمود [class_id]، الذي سيحتوي على معرّف الفصل الذي ينتمي إليه الطالب. وهذا ما يُسمى بالمفتاح الخارجي. [students.class_id] هو مفتاح خارجي (ForeignKey) في العمود [classes.id]. وهذا يعني أن قيمة [students.class_id] يجب أن تكون موجودة في العمود [classes.id]؛
  • الأسطر 51–57: نسرد التعيينات بين أعمدة جدول [students] وخصائص كيان [Student]:
    • السطور 53-55 سهلة الفهم؛
    • السطر 56 أكثر صعوبة: فهو يحدد قيمة خاصية [Student.class] على أنها محسوبة بواسطة علاقة المفتاح الأجنبي التي تربط بين الجدولين [students] و [classes]. معلمات دالة [relationship] هي كما يلي:
      • [Class]: هذا هو اسم الكيان الذي تربطه علاقة مفتاح خارجي بكيان [Student]. يجب أن ينعكس هذا في جدول [students] من خلال وجود مفتاح خارجي يشير إلى جدول [classes]. ونحن نعلم أن هذا موجود؛
      • [backref="students"]: اسم الخاصية التي ستُضاف إلى كيان [Class]. [Class.students] ستكون قائمة بجميع الطلاب في الفصل. يجب ألا تكون هذه الخاصية موجودة بالفعل . إذا كانت موجودة بالفعل، فما عليك سوى اختيار اسم مختلف هنا لـ [backref]. لا يحتاج المطور إلى إدارة هذه الخاصية. سيتولى [SQLAlchemy] التعامل معها. يحتاج المطور فقط إلى معرفة أنها موجودة، وأن [SQLAlchemy] أضافها، وأنه يمكنه استخدامها في كوده؛
      • [lazy='select']: هذا يعني أن ORM يجب ألا يحاول تعيين قيمة على الفور لخاصية [Student.class]. يجب أن يسترد قيمتها فقط عندما يطلبها الكود صراحةً. وبالتالي:
      • إذا طلب الكود قائمة بجميع الطلاب، فسيتم إرجاعهم ولكن لن يتم حساب خاصية [class] الخاصة بهم؛
      • بعد ذلك بقليل، يركز الكود على طالب معين [e] ويشير إلى فصله [e.class]. ستجبر هذه الإشارة [SQLAlchemy] على إجراء استعلام قاعدة بيانات لاسترداد فصل الطالب، كل ذلك بشكل شفاف للمطور؛
      • يهدف تعيين [lazy='select'] أيضًا إلى تجنب استعلامات قاعدة البيانات غير الضرورية؛
  • السطر 56: عندما يسترد ORM صفًا من جدول [students]، فإنه يسترد الحقول [id، last_name، first_name، class_id]. ومن هناك، يجب عليه إنشاء كائن Student (id، last_name، first_name، class). بالنسبة للخصائص [id، last_name، first_name]، لا يمثل هذا أي صعوبة. أما بالنسبة للخاصية [class]، فالأمر أكثر تعقيدًا. فقيمتها هي مرجع كائن من النوع [Class]. ومع ذلك، لا يمتلك ORM سوى معلومة واحدة: [students.class_id]. نظرًا لأن [students.class_id] هو مفتاح خارجي في عمود [classes.id]، فإننا نوجهه هنا لاستخدام هذه العلاقة لاسترداد الصف الذي يحتوي على id=[students.class_id] من جدول [classes] (يجب أن يكون موجودًا) وإنشاء كائن [Class] المتوقع بواسطة خاصية [Student.class] من هذا الصف؛
  • الأسطر 59–71: التعيين بين كيان [Subject] وجدول [subjects]؛
  • الأسطر 59–65: تعريف جدول [SQLAlchemy] المسمى [subjects]؛
  • الأسطر 66–71: نسرد التعيينات بين أعمدة جدول [subjects] وخصائص كيان [Subject]. لا توجد صعوبات هنا؛
  • الأسطر 73–90: التعيين بين كيان [Note] وجدول [notes]؛
  • الأسطر 73-82: تعريف جدول [sqlalchemy] المسمى [notes]. يحتوي على مفتاحين خارجيين:
    • السطر 79، العمود [notes.student_id] يأخذ قيمه من العمود [students.id]. يعكس هذا المفتاح الأجنبي حقيقة أن الملاحظة تخص طالبًا معينًا؛
    • السطر 81: العمود [notes.subject_id] يأخذ قيمه من العمود [subjects.id]. يمثل هذا المفتاح الأجنبي حقيقة أن الدرجة هي درجة في مادة معينة؛
  • الأسطر 84-90: التعيين بين كيان [Note] وجدول [notes]:
    • السطر 88: يجب أن تكون قيمة الخاصية [Note.student] مثيلًا من النوع [Student]. لا يحتوي ORM إلا على عمود [notes.student_id] في صف جدول [notes]، والذي يشير إلى عمود [students.id]. هنا، نحدد استخدام علاقة المفتاح الخارجي هذه لاسترداد مثيل [Student] الذي لدينا درجته. علاوة على ذلك، سيؤدي [relationship(Student, backref="grades", …)] إلى إنشاء الخاصية الجديدة [Student.grades]، والتي ستكون قائمة بدرجات الطالب. يجب ألا تكون هذه الخاصية موجودة بالفعل في فئة [Student]؛
    • السطر 89: يجب أن يكون لقيمة الخاصية [Grade.subject] قيمة مثيل من النوع [Subject]. لا يحتوي ORM إلا على عمود [notes.subject_id] في صف جدول [grades]، والذي يشير إلى عمود [subjects.id]. هنا، نحدد استخدام علاقة المفتاح الخارجي هذه لاسترداد مثيل [Subject] الذي لدينا درجته. بالإضافة إلى ذلك، سيؤدي [relationship(Subject, backref="grades", …)] إلى إنشاء الخاصية الجديدة [Subject.grades]، والتي ستكون قائمة الدرجات للموضوع. يجب ألا تكون هذه الخاصية موجودة بالفعل في فئة [Subject]؛
  • الأسطر 92–96: بالنسبة لكل كيان مشتق من [BaseEntity]، نحدد قائمة الخصائص التي يجب استبعادها من قاموس خصائص الكيان (BaseEntity.asdict). لقد رأينا أن [sqlalchemy] تضيف خاصية [_sa_instance_state] إلى جميع الكيانات المخططة. لا نريد وجود هذه الخاصية في قاموس الخصائص. علاوة على ذلك، رأينا أن التخطيطات السابقة أضافت خصائص جديدة إلى الكيانات:
    • [Student.grades]: جميع درجات الطالب؛
    • [Class.students]: جميع الطلاب في الفصل؛
    • [Subject.grades]: جميع الدرجات للمادة؛

بشكل عام، لا نريد إضافة هذه الخصائص إلى حالة الكيان. في الواقع، يتطلب حساب قيمتها تكلفة SQL، وغالبًا ما تكون هذه القيمة غير ضرورية. لذا، إذا استرجعنا الطالب المسمى "X":

  • (تابع)
    • فإن ORM سيعرض كيان [Student(id, last_name, first_name, class, grades)]. وبسبب [lazy='select'], لن يتم حساب الخصائص [class, grades] المرتبطة بالمفاتيح الخارجية في قاعدة البيانات؛
    • الآن، إذا قمت بعرض سلسلة JSON لهذا الطالب، فإننا نعلم أنها ستكون سلسلة JSON من قاموس [asdict] الخاص بالكيان. إذا تم تضمين الخصائص [class] و [grades]، فسيضطر [SQLAlchemy] إلى تنفيذ استعلامات SQL لحساب قيمها. وهذا مكلف. إذا كان بإمكاننا تجنب هذه الاستعلامات، فهذا هو الأفضل؛
    • هنا، قمنا باستبعاد جميع الخصائص المرتبطة بمفتاح خارجي؛
  • الأسطر 98-100: إنشاء وتكوين [Session factory] (المصنع = مصنع الإنتاج). يُستخدم كائن [Session] لإنشاء جلسات [SQLAlchemy] مدعومة بالمعاملات؛
  • الأسطر 102–103: إنشاء جلسة [SQLAlchemy]؛
  • السطر 106: يتم وضع عناصر معينة من تكوين [SQLAlchemy] في قاموس التكوين العام للتطبيق؛
  • السطر 109: يتم إرجاع هذا القاموس؛

يقوم ملف [config_layers] بتكوين طبقات التطبيق:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def configure(config: dict) -> dict:
    #  layer instantiation [dao]
    from DatabaseDao import DatabaseDao
    dao = DatabaseDao(config)

    #  instantiation of the [business] layer
    from Métier import Métier
    métier = Métier(dao)

    #  instantiation of the [ui] layer
    from Console import Console
    ui = Console(métier)

    #  we put the layers in the config
    config['dao'] = dao
    config['métier'] = métier
    config['ui'] = ui

    #  return the config
    return config
  • السطر 1: تستقبل الدالة [configure] القاموس الذي يحتوي على التكوين العام للتطبيق؛
  • الأسطر 2–12: يتم إنشاء مثيلات لطبقات التطبيق؛
  • الأسطر 15-17: تتم إضافة مراجع الطبقات إلى التكوين العام؛
  • السطر 20: يتم إرجاع التكوين الجديد؛

19.6.5. طبقة [dao] - 1

Image

من المهم أن نفهم هنا أن طبقة [dao] [3] تتواصل مع ORM [sqlalchemy] [4] الذي تم تكوينه كما هو موضح في الفقرة السابقة. من بين الطبقات الثلاث [ui، business، dao] لتطبيق |troiscouches v01|، لا تحتاج سوى طبقة [dao] إلى إعادة كتابة. يتم الاحتفاظ بطبقتي [ui، business].

تم وضع تنفيذ طبقة [dao] في مجلد [services]:

Image

[InterfaceDatabaseDao] هي واجهة طبقة [DAO]:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from abc import ABC, abstractmethod

from InterfaceDao import InterfaceDao


class InterfaceDatabaseDao(InterfaceDao, ABC):

    #  database initialization
    @abstractmethod
    def init_database(self, data: dict):
        pass
  • السطر 6: واجهة [InterfaceDatabaseDao] مشتقة من فئة [ABC] لتكون فئة مجردة ومن واجهة [InterfaceDao] لمشروع |troiscouches v01|؛
  • الأسطر 8–11: نضيف الطريقة [init_database] إلى الطرق الموروثة من [InterfaceDao]. وسيكون دورها تهيئة قاعدة البيانات بالبيانات الموجودة في القاموس [data] الذي تم تمريره إليها كمعلمة في السطر 10؛

تذكر أن واجهة [InterfaceDao] كانت كما يلي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#  imports
from abc import ABC, abstractmethod

#  dao interface
from Elève import Elève


class InterfaceDao(ABC):
    #  class list
    @abstractmethod
    def get_classes(self: object) -> list:
        pass

    #  list of students
    @abstractmethod
    def get_élèves(self: object) -> list:
        pass

    #  list of materials
    @abstractmethod
    def get_matières(self: object) -> list:
        pass

    #  lIST OF NOTES
    @abstractmethod
    def get_notes(self: object) -> list:
        pass

    #  list of student grades
    @abstractmethod
    def get_notes_for_élève_by_id(self: object, élève_id: int) -> list:
        pass

    #  search for a student by id
    @abstractmethod
    def get_élève_by_id(self: object, élève_id: int) -> Elève:
        pass

تنفيذ طبقة [DAO] هو كما يلي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from sqlalchemy.exc import DatabaseError, IntegrityError, InterfaceError

from Classe import Classe
from Elève import Elève
from InterfaceDatabaseDao import InterfaceDatabaseDao
from Matière import Matière
from MyException import MyException
from Note import Note


class DatabaseDao(InterfaceDatabaseDao):

    def __init__(self, config: dict):
        #  database = {"engine": engine, "metadata": metadata, "tables": tables, "session": session}
        self.database = config['database']
        self.session = self.database['session']

    def init_database(self, data: dict):
        …
…
  • السطر 11: تنفذ فئة [DatabaseDao] واجهة [InterfaceDatabaseDao]؛
  • الأسطر 13–16: منشئ الفئة. يأخذ قاموس تكوين التطبيق كمعلمة؛
  • السطر 15: يتم تخزين تكوين [sqlalchemy]؛
  • السطر 16: يتم تخزين جلسة [sqlalchemy] التي سيتم من خلالها التعامل مع قاعدة البيانات؛
  • السطر 18: تقوم طريقة [init_database] بتهيئة قاعدة البيانات باستخدام قاموس [data]؛

يتم تنفيذ قاموس [data] بواسطة البرنامج النصي [data.py] التالي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def configure():
    from Classe import Classe
    from Elève import Elève
    from Matière import Matière
    from Note import Note

    #  classes are instantiated
    classe1 = Classe().fromdict({"id": 1, "nom": "classe1"})
    classe2 = Classe().fromdict({"id": 2, "nom": "classe2"})
    classes = [classe1, classe2]
    #  materials
    matière1 = Matière().fromdict({"id": 1, "nom": "matière1", "coefficient": 1})
    matière2 = Matière().fromdict({"id": 2, "nom": "matière2", "coefficient": 2})
    matières = [matière1, matière2]
    #  students
    élève11 = Elève().fromdict({"id": 11, "nom": "nom1", "prénom": "prénom1", "classe": classe1})
    élève21 = Elève().fromdict({"id": 21, "nom": "nom2", "prénom": "prénom2", "classe": classe1})
    élève32 = Elève().fromdict({"id": 32, "nom": "nom3", "prénom": "prénom3", "classe": classe2})
    élève42 = Elève().fromdict({"id": 42, "nom": "nom4", "prénom": "prénom4", "classe": classe2})
    élèves = [élève11, élève21, élève32, élève42]
    #  student grades in various subjects
    note1 = Note().fromdict({"id": 1, "valeur": 10, "élève": élève11, "matière": matière1})
    note2 = Note().fromdict({"id": 2, "valeur": 12, "élève": élève21, "matière": matière1})
    note3 = Note().fromdict({"id": 3, "valeur": 14, "élève": élève32, "matière": matière1})
    note4 = Note().fromdict({"id": 4, "valeur": 16, "élève": élève42, "matière": matière1})
    note5 = Note().fromdict({"id": 5, "valeur": 6, "élève": élève11, "matière": matière2})
    note6 = Note().fromdict({"id": 6, "valeur": 8, "élève": élève21, "matière": matière2})
    note7 = Note().fromdict({"id": 7, "valeur": 10, "élève": élève32, "matière": matière2})
    note8 = Note().fromdict({"id": 8, "valeur": 12, "élève": élève42, "matière": matière2})
    notes = [note1, note2, note3, note4, note5, note6, note7, note8]
    #  we group all
    data = {"élèves": élèves, "classes": classes, "matières": matières, "notes": notes}
    #  we return the data
    return data
  • السطر 34: القاموس الذي سيتم تمريره إلى طريقة [init_database]. يتكون هذا القاموس من المفاتيح التالية (السطر 32):
    • [students]: قائمة الطلاب؛
    • [classes]: قائمة الفصول؛
    • [subjects]: قائمة المواد الدراسية؛
    • [grades]: قائمة الدرجات لجميع الطلاب في جميع المواد؛

لنعد إلى طريقة [init_database]:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
def init_database(self, data: dict):
        #  comic book config
        database = self.database
        engine = database['engine']
        metadata = database['metadata']
        tables = database['tables']

        try:
            #  delete existing tables
            #  checkfirst=True: first checks that the table exists
            tables["notes"].drop(engine, checkfirst=True)
            tables["matières"].drop(engine, checkfirst=True)
            tables["élèves"].drop(engine, checkfirst=True)
            tables["classes"].drop(engine, checkfirst=True)

            #  recreate tables from mapping
            metadata.create_all(engine)

            #  table filling
            session = self.session

            #  classes
            classes = data["classes"]
            for classe in classes:
                session.add(classe)

            #  materials
            matières = data["matières"]
            for matière in matières:
                session.add(matière)

            #  students
            élèves = data["élèves"]
            for élève in élèves:
                session.add(élève)

            #  notes
            notes = data["notes"]
            for note in notes:
                session.add(note)

            #  commit
            session.commit()
        except (DatabaseError, InterfaceError, IntegrityError) as erreur:
            #  session cancellation
            if session:
                session.rollback()
            #  up the exception
            raise MyException(23, f"{erreur}")
  • الأسطر 3–6: استرداد المعلومات من تكوين قاعدة البيانات؛
  • الأسطر 9-14: رأينا أن تكوين [sqlalchemy] قد ربط أربعة كيانات بأربعة جداول [students, subjects, classes, grades]. نبدأ بحذف هذه الجداول إن وجدت؛
  • السطور 16-17: نعيد إنشاء الجداول الأربعة التي حذفناها للتو؛
  • الأسطر 22–25: نضيف جميع الفصول الدراسية إلى الجلسة؛
  • الأسطر 27–30: نضيف جميع المواد الدراسية إلى الجلسة؛
  • الأسطر 32–35: نضيف جميع الطلاب إلى الجلسة؛
  • الأسطر 37-40: نضيف جميع الدرجات إلى الجلسة؛
  • لإجراء هذه الإضافات، اتبعنا ترتيبًا محددًا. بدأنا بالكيانات التي لا توجد لها علاقات مع كيانات أخرى وانتهينا بتلك التي لها علاقات. وبالتالي، عندما نضيف الطلاب إلى الجلسة، تكون الفصول الدراسية التي يشيرون إليها موجودة بالفعل في الجلسة؛
  • السطر 43: يتم تثبيت جلسة [sqlalchemy]. بعد هذه العملية، يمكننا التأكد من أن جميع البيانات في الجلسة قد تمت مزامنتها مع قاعدة البيانات. باختصار، تم إدراج البيانات في الجداول. وقد أصبح ذلك ممكنًا بفضل التعيينات المحددة في تكوين [sqlalchemy]. يعرف [sqlalchemy] كيف يجب تخزين كل كيان في الجداول. كما أنشأ [sqlalchemy] أي مفاتيح خارجية قد تحتوي عليها الجداول؛
  • الأسطر 44–49: في حالة مواجهة مشكلة، يتم التراجع عن جلسة [sqlalchemy]، وفي السطر 49، يتم إثارة استثناء؛

19.6.6. تهيئة قاعدة البيانات

Image

يقوم البرنامج النصي [main_init_database] بتهيئة قاعدة البيانات بمحتويات البرنامج النصي [data.py]. وفيما يلي كود البرنامج النصي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#  a mysql or pgres parameter is expected
import sys

syntaxe = f"{sys.argv[0]} mysql / pgres"
erreur = len(sys.argv) != 2
if not erreur:
    sgbd = sys.argv[1].lower()
    erreur = sgbd != "mysql" and sgbd != "pgres"
if erreur:
    print(f"syntaxe : {syntaxe}")
    sys.exit()

#  configure the application
import config
config = config.configure({'sgbd': sgbd})

#  syspath is configured - imports can be made
from MyException import MyException

#  retrieve the data to be stored in the database
import data
data = data.configure()

#  we recover the [dao] layer
dao = config["dao"]

#  ----------- hand
try:
    #  database table creation and initialization
    dao.init_database(data)
except MyException as ex:
    #  error is displayed
    print(f"L'erreur suivante s'est produite : {ex}")
finally:
    #  release of resources mobilized by the application
    import shutdown
    shutdown.execute(config)
#  end
print("Travail terminé...")
  • الأسطر 1-11: يتوقع البرنامج النصي معلمة [mysql] أو [pgres] اعتمادًا على ما إذا كنت تريد تهيئة قاعدة بيانات MySQL أو PostgreSQL؛
  • الأسطر 13-15: يتم تكوين التطبيق لنظام إدارة قواعد البيانات (DBMS) الذي تم تمريره كمعلمة؛
  • الأسطر 20-22: يتم استرداد البيانات المراد إدراجها في قاعدة البيانات؛
  • السطر 25: تم بالفعل إنشاء مثيل لطبقة [dao] ويمكن الوصول إليها في تكوين التطبيق؛
  • السطر 30: يتم تهيئة قاعدة البيانات؛
  • الأسطر 34–37: بغض النظر عما إذا حدث خطأ أم لا، يتم تحرير موارد التطبيق باستخدام وحدة [shutdown]؛

وحدة [shutdown.py] هي كما يلي:

1
2
3
4
5
def execute(config: dict):
    #  release the resources mobilized by the application
    sqlalchemy_session = config['database']['session']
    if sqlalchemy_session:
        sqlalchemy_session.close()

تقوم الدالة [shutdown.execute] بإغلاق جلسة [sqlalchemy] المستخدمة لتهيئة قاعدة البيانات.

نقوم بإنشاء تكوين تنفيذ أولي (انظر |تكوين التنفيذ|) لتشغيل [main_init_database] مع نظام إدارة قواعد البيانات MySQL:

Image

فيما يلي نتائج تشغيل هذا التكوين في phpMyAdmin:

Image

Image

Image

بالنسبة لنظام إدارة قواعد البيانات [PostgreSQL]، نستخدم تكوين التنفيذ التالي:

Image

عند التنفيذ، تكون النتائج في [pgAdmin] كما يلي:

Image

Image

Image

لاحظ مدى سهولة التبديل بين أنظمة إدارة قواعد البيانات.

19.6.7. طبقة [dao] – 2

نعود إلى فئة [DatabaseDao]، التي تنفذ طبقة [DAO]. حتى الآن، لم نعرض سوى تنفيذ طريقة [init_database]. سنعرض الآن تنفيذ الطرق الأخرى:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
from sqlalchemy.exc import DatabaseError, IntegrityError, InterfaceError

from Classe import Classe
from Elève import Elève
from InterfaceDatabaseDao import InterfaceDatabaseDao
from Matière import Matière
from MyException import MyException
from Note import Note


class DatabaseDao(InterfaceDatabaseDao):

    def __init__(self, config: dict):
        #  database = {"engine": engine, "metadata": metadata, "tables": tables, "session": session}
        self.database = config['database']
        self.session = self.database['session']

    def init_database(self, data: dict):
        …

    #  list of all classes
    def get_classes(self: object) -> list:
        #  request
        return self.session.query(Classe).all()

    #  list of all students
    def get_élèves(self: object) -> list:
        #  request
        return self.session.query(Elève).all()

    #  list of all materials
    def get_matières(self: object) -> list:
        #  request
        return self.session.query(Matière).all()

    #  a list of all students' grades
    def get_notes(self: object) -> list:
        #  request
        return self.session.query(Note).all()

    #  a list of grades for a particular student
    def get_notes_for_élève_by_id(self: object, élève_id: int) -> list:
        #  we look for the student - an exception is thrown if he doesn't exist
        #  we let it rise
        élève = self.get_élève_by_id(élève_id)
        #  lazy loading of notes
        notes = élève.notes
        #  a dictionary is returned
        return {"élève": élève, "notes": notes}

    #  a student identified by his number
    def get_élève_by_id(self, élève_id: int) -> Elève:
        #  we're looking for the student
        élèves = self.session.query(Elève).filter(Elève.id == élève_id).all()
        #  have we found?
        if élèves:
            return élèves[0]
        else:
            raise MyException(11, f"L'élève d'identifiant {élève_id} n'existe pas")

    #  a student identified by name
    def get_élève_by_name(self, élève_name: str) -> Elève:
        #  we're looking for the student
        élèves = self.session.query(Elève).filter(Elève.nom == élève_name).all()
        #  have we found?
        if élèves:
            return élèves[0]
        else:
            raise MyException(12, f"L'élève de nom {élève_name} n'existe pas")

    #  a class identified by its number
    def get_classe_by_id(self, classe_id: int) -> Classe:
        #  we are looking for the
        classes = self.session.query(Classe).filter(Classe.id == classe_id).all()
        #  have we found?
        if classes:
            return classes[0]
        else:
            raise MyException(13, f"La classe d'identifiant {classe_id} n'existe pas")

    #  a class identified by its name
    def get_classe_by_name(self, classe_name: str) -> Classe:
        #  we're looking for the class
        classes = self.session.query(Classe).filter(Classe.nom == classe_name).all()
        #  have we found?
        if classes:
            return classes[0]
        else:
            raise MyException(14, f"La classe de nom {classe_name} n'existe pas")

    #  a material identified by its number
    def get_matière_by_id(self, matière_id: int) -> Matière:
        #  we're looking for material
        matières = self.session.query(Matière).filter(Matière.id == matière_id).all()
        #  have we found?
        if matières:
            return matières[0]
        else:
            raise MyException(11, f"La matière d'identifiant {matière_id} n'existe pas")

    #  a material identified by its name
    def get_matière_by_name(self, matière_name: str) -> Matière:
        #  we're looking for the material
        matières = self.session.query(Matière).filter(Matière.nom == matière_name).all()
        #  have we found?
        if matières:
            return matières[0]
        else:
            raise MyException(15, f"La matière de nom {matière_name} n'existe pas")
  • الأسطر 21–24: يجب أن تُرجع الدالة [get_classes] قائمة الفصول الدراسية في المدرسة. في السطر 20، نستخدم استعلامًا سبق أن رأيناه من قبل؛
  • الأسطر 26–39: ثلاث طرق أخرى مشابهة لاسترداد قوائم الطلاب والمواد الدراسية والدرجات؛
  • الأسطر 51–59: يجب أن تُرجع الدالة [get_student_by_id] طالبًا محددًا برقمه التعريفي. وتُثير استثناءً إذا كان الطالب غير موجود؛
    • السطر 54: نستخدم استعلامًا مفلترًا. نحصل على قائمة فارغة أو قائمة تحتوي على عنصر واحد؛
    • السطر 57: إذا لم تكن القائمة المسترجعة فارغة، فقم بإرجاع العنصر الأول من القائمة؛
    • وإلا، في السطر 59، يتم إثارة استثناء؛
  • الأسطر 41–49: يجب أن تُرجع الطريقة [get_notes_for_student_by_id] درجات الطالب المحدد برقمه التعريفي:
    • السطر 45: نستخدم الطريقة [get_student_by_id] لاسترداد كيان Student الخاص بالطالب؛
    • السطر 47: نستخدم الخاصية [Student.grades] التي تم إنشاؤها عن طريق التعيين بين كيان [Grade] وجدول [grades] (انظر قسم |تكوين SQLAlchemy|)، والتي تمثل درجات الطالب؛
    • السطر 49: نُرجع قاموسًا؛
  • الأسطر 61–109: سلسلة من الطرق المماثلة التي تسمح لنا بما يلي:
    • البحث عن طالب بالاسم، الأسطر 61–69؛
    • البحث عن فصل دراسي، الأسطر 71–89؛
    • استرداد مادة دراسية، الأسطر 91–109؛

19.6.8. نص [main_joined_queries]

Image

سمي البرنامج النصي [main_joined_queries] بهذا الاسم لأنه يهدف إلى إبراز الاستعلامات التي يقوم بها [sqlalchemy] ضمناً لاسترداد المعلومات من جداول متعددة. يتم إجراء هذه الاستعلامات، المخفية عن المبرمج، كلما تم ربط خاصية كيان ما بوظيفة [relationship] في تعيين الكيان. على سبيل المثال:


    # mapping
    mapper(Note, tables['notes'], properties={
        'id': notes_table.c.id,
        'valeur': notes_table.c.valeur,
        'élève': relationship(Elève, backref="notes", lazy="select"),
        'matière': relationship(Matière, backref="notes", lazy="select")
    })

أعلاه هو التعيين بين كيان [Note] وجدول [notes]:

  • السطر 5: عندما يُطلب خاصية [student] لكيان [Grade] لأول مرة، سيتم استردادها من جدول [students] عبر استعلام SQL. وحتى يتم طلب هذه الخاصية، تظل غير محددة (تحميل متأخر). بمجرد استرجاعها، تظل قيمتها في ذاكرة ORM. وعند الإشارة إليها للمرة الثانية، سيعرض ORM قيمتها على الفور دون إصدار استعلام SQL جديد. كل هذا شفاف بالنسبة للمطور؛
  • وينطبق الأمر نفسه على الخاصية العكسية [Student.grades] (backref)، السطر 5؛
  • وينطبق الأمر نفسه على الخاصية [Grade.subject] وخاصيتها العكسية [Subject.grades] (backref)، السطر 6؛

النص البرمجي [main_joined_queries] هو كما يلي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#  a mysql or pgres parameter is expected
import sys

syntaxe = f"{sys.argv[0]} mysql / pgres"
erreur = len(sys.argv) != 2
if not erreur:
    sgbd = sys.argv[1].lower()
    erreur = sgbd != "mysql" and sgbd != "pgres"
if erreur:
    print(f"syntaxe : {syntaxe}")
    sys.exit()

#  configure the application
import config
config = config.configure({"sgbd": sgbd})

#  syspath is configured - imports can be made
from MyException import MyException

#  the [dao] layer
dao = config["dao"]
try:
    #  student by id
    print("élève id=11 -----------")
    élève = dao.get_élève_by_id(11)
    print(f"élève={élève}")
    #  student class (lazy loading)
    classe = élève.classe
    print(f"classe de l'élève : {classe}")
    #  students in the same class (lazy loading)
    print("élèves dans la même classe :")
    for élève in classe.élèves:
        print(f"élève={élève}")

    #  a student by name
    print("élève nom='nom2' -----------")
    print(f"élève={dao.get_élève_by_name('nom2')}")
    #  its class (lazy loading)
    print(f"classe de l'élève : {élève.classe}")

    #  student notes
    print("notes de l'élève id=11 -----------")
    #  first the student
    élève = dao.get_élève_by_id(11)
    #  then its notes (lazy loading)
    for note in élève.notes:
        #  the note
        print(f"note={note}, "
              #  note material (lazy loading)
              f"matière={note.matière}")

    #  students in a class
    print("élèves de la classe nom='classe1' -----------")
    #  first the class
    classe = dao.get_classe_by_name('classe1')
    #  then the students (lazy loading)
    for élève in classe.élèves:
        print(élève)

    #  same for [class2]
    print("élèves de la classe de nom 'classe2' -----------")
    classe = dao.get_classe_by_name('classe2')
    for élève in classe.élèves:
        print(élève)

    #  subject grades
    print("matière de nom='matière1' -----------")
    #  first the material
    matière = dao.get_matière_by_name('matière1')
    print(f"matière={matière}")
    #  then grades in this subject (lazy loading)
    print("Notes dans la matière : ")
    for note in matière.notes:
        print(note)

    #  same for matière2
    print("matière de nom='matière2' -----------")
    matière = dao.get_matière_by_name('matière2')
    print(f"matière={matière}")
    print("Notes dans la matière : ")
    for note in matière.notes:
        print(f"note={note}")
except MyException as ex1:
    #  error is displayed
    print(f"L'erreur 1 suivante s'est produite : {ex1}")
except BaseException as ex2:
    #  error is displayed
    print(f"L'erreur 2 suivante s'est produite : {ex2}")
finally:
    #  free up resources
    import shutdown
    shutdown.execute(config)

التعليقات كافية لفهم الكود.

نقوم بإنشاء تكوين تنفيذ لـ MySQL:

Image

نتائج التنفيذ هي كما يلي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/databases/sqlalchemy/05/main/main_joined_queries.py mysql
élève id=11 -----------
élève={"classe_id": 1, "nom": "nom1", "prénom": "prénom1", "id": 11}
classe de l'élève : {"nom": "classe1", "id": 1}
élèves dans la même classe :
élève={"classe_id": 1, "nom": "nom1", "prénom": "prénom1", "id": 11}
élève={"classe_id": 1, "nom": "nom2", "prénom": "prénom2", "id": 21}
élève nom='nom2' -----------
élève={"classe_id": 1, "nom": "nom2", "prénom": "prénom2", "id": 21}
classe de l'élève : {"nom": "classe1", "id": 1}
notes de l'élève id=11 -----------
note={"matière_id": 1, "valeur": 10.0, "élève_id": 11, "id": 1}, matière={"coefficient": 1.0, "nom": "matière1", "id": 1}
note={"matière_id": 2, "valeur": 6.0, "élève_id": 11, "id": 5}, matière={"coefficient": 2.0, "nom": "matière2", "id": 2}
élèves de la classe nom='classe1' -----------
{"classe_id": 1, "nom": "nom1", "prénom": "prénom1", "id": 11}
{"classe_id": 1, "nom": "nom2", "prénom": "prénom2", "id": 21}
élèves de la classe de nom 'classe2' -----------
{"classe_id": 2, "nom": "nom3", "prénom": "prénom3", "id": 32}
{"classe_id": 2, "nom": "nom4", "prénom": "prénom4", "id": 42}
matière de nom='matière1' -----------
matière={"coefficient": 1.0, "nom": "matière1", "id": 1}
Notes dans la matière : 
{"matière_id": 1, "valeur": 10.0, "élève_id": 11, "id": 1}
{"matière_id": 1, "valeur": 12.0, "élève_id": 21, "id": 2}
{"matière_id": 1, "valeur": 14.0, "élève_id": 32, "id": 3}
{"matière_id": 1, "valeur": 16.0, "élève_id": 42, "id": 4}
matière de nom='matière2' -----------
matière={"coefficient": 2.0, "nom": "matière2", "id": 2}
Notes dans la matière : 
note={"matière_id": 2, "valeur": 6.0, "élève_id": 11, "id": 5}
note={"matière_id": 2, "valeur": 8.0, "élève_id": 21, "id": 6}
note={"matière_id": 2, "valeur": 10.0, "élève_id": 32, "id": 7}
note={"matière_id": 2, "valeur": 12.0, "élève_id": 42, "id": 8}

Process finished with exit code 0

لفهم هذه النتائج، تذكر أن بعض الخصائص تم استبعادها من قاموس الكيانات (انظر |التكوين|):


    # configuration des entités [BaseEntity]
    Elève.excluded_keys = ['_sa_instance_state', 'notes', 'classe']
    Classe.excluded_keys = ['_sa_instance_state', 'élèves']
    Matière.excluded_keys = ['_sa_instance_state', 'notes']
    Note.excluded_keys = ['_sa_instance_state', 'matière', 'élève']

لذلك، عندما نكتب [print(f"student={student}")] في السطر 26 من الكود، يخبرنا السطر 1 أعلاه أن الخصائص ['_sa_instance_state', 'grades', 'class'] لن يتم عرضها. وهذا ما نراه في السطر 3 من النتائج. يتم عرض جميع الخصائص الأخرى. وبالتالي، في السطر 3 أيضًا، نكتشف خاصية جديدة [class_id] لم تكن موجودة في البداية في كيان [Student]. تتوافق هذه الخاصية مباشرة مع عمود [class_id] في جدول [students]. وبالتالي، أضاف [SQLAlchemy] الخصائص التالية إلى كيان [Student]: [class_id, _sa_instance_state, grades]. من المهم أن ندرك ذلك، خاصةً لأن هذه الخصائص يجب ألا تكون موجودة بالفعل في الكيان المعين.

تعد الخصائص المستبعدة من قاموس الكيانات أمرًا مهمًا. على سبيل المثال، إذا لم نستبعد الخصائص [grades, student] من كيان [Student]، فإن العملية [print(f"student={student}")] ستعرضها، وبالتالي ستؤدي، كما أوضحنا للتو، إلى تشغيل استعلامات SQL ضمنية (التحميل المؤجل) لاسترداد قيم هذه الخصائص. إذا تم عرض قائمة بالطلاب، كما في هذه الحالة، يتم تنفيذ عمليات SQL ضمنية لكل طالب. قد يكون هذا غير ضروري وبالتأكيد مكلفًا من حيث وقت التنفيذ.

لتشغيل البرنامج النصي باستخدام قاعدة بيانات PostgreSQL، قم بإنشاء تكوين التنفيذ التالي:

Image

يؤدي التنفيذ إلى نفس النتائج كما هو الحال مع MySQL.

19.6.9. البرنامج النصي [main_stats_for_student]

البرنامج النصي [main_stats_for_student] هو البرنامج المستخدم بالفعل في تطبيق |troiscouches v01|. كان يُسمى سابقًا [main]. وهو تطبيق وحدة تحكم يسترد بعض المقاييس المتعلقة بدرجات الطالب: [المتوسط المرجح، الحد الأدنى، الحد الأقصى، القائمة]. وهو يتناسب مع البنية التالية:

Image

في هذه البنية الطبقية، لم تتغير سوى طبقة [dao] بين تطبيق |troiscouches v01| وهذا التطبيق. وبما أن طبقة [dao] الجديدة تتوافق مع واجهة [InterfaceDao] لطبقة [dao] القديمة، فلا داعي لتغيير طبقتي [ui, business]. وبالتالي، يمكننا الاستمرار في استخدام الطبقات المحددة في تطبيق |troiscouches v01|.

ينفذ البرنامج النصي [main_stats_for_élève] الطبقة [main] في الرسم البياني أعلاه على النحو التالي:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#  a mysql or pgres parameter is expected
import sys

syntaxe = f"{sys.argv[0]} mysql / pgres"
erreur = len(sys.argv) != 2
if not erreur:
    sgbd = sys.argv[1].lower()
    erreur = sgbd != "mysql" and sgbd != "pgres"
if erreur:
    print(f"syntaxe : {syntaxe}")
    sys.exit()

#  configure the application
import config
config = config.configure({'sgbd': sgbd})

#  syspath is configured - imports can be made
from MyException import MyException

#  the [ui] layer
ui = config["ui"]
try:
    #  execution layer [ui]
    ui.run()
except MyException as ex1:
    #  error is displayed
    print(f"L'erreur 1 suivante s'est produite : {ex1}")
except BaseException as ex2:
    #  error is displayed
    print(f"L'erreur 2 suivante s'est produite : {ex2}")
finally:
    #  free up resources
    import shutdown
    shutdown.execute(config)
  • السطر 20: استرداد مرجع إلى طبقة [ui] من تكوين التطبيق؛
  • السطر 24: نبدأ حوار المستخدم باستخدام الطريقة الوحيدة لطبقة [ui]؛

سيبدو تكوين التنفيذ لـ PostgreSQL كما يلي:

Image

فيما يلي مثال على التنفيذ باستخدام هذا التكوين:


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/databases/sqlalchemy/05/main/main_stats_for_élève.py pgres
Numéro de l'élève (>=1 et * pour arrêter) : 11
Elève={"prénom": "prénom1", "id": 11, "classe_id": 1, "nom": "nom1"}, notes=[10.0 6.0], max=10.0, min=6.0, moyenne pondérée=7.33
Numéro de l'élève (>=1 et * pour arrêter) : 1
L'erreur suivante s'est produite : MyException[11, L'élève d'identifiant 1 n'existe pas]
Numéro de l'élève (>=1 et * pour arrêter) : *
 
Process finished with exit code 0
https://stahe.github.io
هذا البرنامج التعليمي الذي كتبه Serge Tahé متاح للجمهور وفقًا لشروط Creative Commons Attribution – Non-commercial – ShareAlike 3.0 Unported.