الوحدة sqlite3 في بايثون

من موسوعة حسوب
اذهب إلى: تصفح، ابحث


SQLite هي مكتبة مكتوبة بلغة C تتيح إنشاء قواعد بيانات على القرص الصلب ولا تحتاج إلى خادوم خاص لمعالجتها، وتتيح الوصول إلى قاعدة البيانات باستخدام نسخة غير قياسية من لغة الاستعلام SQL.

تستخدم بعض التطبيقات والبرامج قاعدة بيانات SQLite لتخزين بياناتها الداخلية، ويمكن إنشاء نماذج أولية من التطبيق باستخدام SQLite ثم نقل الشيفرة إلى قواعد بيانات أكبر مثل PostgreSQL أو Oracle.

كُتبت وحدة sqlite3 من قبل Gerhard Häring، وتقدّم واجهة SQL متوافقة مع معايير DB-API 2.0 الموصوفة في PEP 249.

محتويات

الاتصال بقاعدة بيانات SQLite

لاستخدام هذه الوحدة يجب إنشاء كائن اتصال Connection يمثّل قاعدة البيانات. يبين المثال التالي طريقة استخدام الوحدة مع افتراض أن البيانات مخزّنة في ملف باسم example.db.
import sqlite3
conn = sqlite3.connect('example.db')
يمكن كذلك استخدام الاسم الخاص :memory: لإنشاء قاعدة البيانات في ذاكرة الوصول العشوائي RAM. بعد إجراء الاتصال مع قاعدة البيانات يمكن إنشاء كائن مؤشر Cursor واستدعاء التابع execute()‎ لتنفيذ أوامر SQL:
c = conn.cursor()

# إنشاء جدول
c.execute('''CREATE TABLE stocks
             (date text, trans text, symbol text, qty real, price real)''')

# إدراج صف من البيانات
c.execute("INSERT INTO stocks VALUES ('2006-01-05','BUY','RHAT',100,35.14)")

# حفظ التعديلات
conn.commit()

# يمكن كذلك إغلاق الاتصال بعد الانتهاء
# ولكن يجب التأكد من حفظ جميع التعديلات تجنبًا لفقدانها كلّها
conn.close()
تكون البيانات المحفوظة من النوع المستمر persistent وهي متاحة للاستخدام في الجلسات اللاحقة:
import sqlite3
conn = sqlite3.connect('example.db')
c = conn.cursor()
ستحتاج في العادة إلى استخدام القيم المخزّنة في متغيرات بايثون لإجراء عمليات SQL، ولكن عليك أن تتجنب استخدام سلاسل بايثون النصية لإنشاء أوامر الاستعلام عن البيانات لأنّ ذلك غير آمن، إذ يكون برنامجك عرضة لهجمات حقن SQL. ينصح باستخدام معامل الاستبدال الخاصّ بواجهة DB-API، حيث يوضع الرمز ? عوضًا عن القيم التي تريد إدراجها في جملة الاستعلام، ثم تزويد تابعexecute()‎بمعامل ثانٍ يكون على هيئة صفّ tuple يتضمّن تلك القيم حسب ترتيبها في جملة الاستعلام. (قد تستخدم وحدات قواعد البيانات الأخرى رموز مختلفة، مثل ‎%s أو ‎:1). فعلى سبيل المثال:
# لا تقم بهذا - هذا خطر.
symbol = 'RHAT'
c.execute("SELECT * FROM stocks WHERE symbol = '%s'" % symbol)

# استخدم هذه الطريقة
t = ('RHAT',)
c.execute('SELECT * FROM stocks WHERE symbol=?', t)
print(c.fetchone())

# يبين المثال التالي طريقة إدراج عدد من القيم
purchases = [('2006-03-28', 'BUY', 'IBM', 1000, 45.00),
             ('2006-04-05', 'BUY', 'MSFT', 1000, 72.00),
             ('2006-04-06', 'SELL', 'IBM', 500, 53.00),
            ]
c.executemany('INSERT INTO stocks VALUES (?,?,?,?,?)', purchases)
بعد تنفيذ جملة الاستعلام SELECT يمكن استرجاع البيانات إمّا عن طريق التعامل مع المؤشر كمكرِّر iterator، أو استدعاء التابع fetchone() لاسترجاع صفّ row واحد فقط، أو استدعاء التابع fetchall() للحصول على قائمة بالصفوف rows المطابقة. يستخدم المثال التالي طريقة المكرِّر:
>>> for row in c.execute('SELECT * FROM stocks ORDER BY price'):
        print(row)

('2006-01-05', 'BUY', 'RHAT', 100, 35.14)
('2006-03-28', 'BUY', 'IBM', 1000, 45.0)
('2006-04-06', 'SELL', 'IBM', 500, 53.0)
('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)

ثوابت الوحدة sqlite

تقدّم وحدة sqlite الثوابت التالية:

الثابت sqlite3.version

رقم الإصدار الخاص بالوحدة -وليس مكتبة SQLite- على هيئة سلسلة نصية.

الثابت sqlite3.version_info

رقم الإصدار الخاص بالوحدة -وليس مكتبة SQLite- على هيئة صفّ من الأعداد الصحيحة.

الثابت sqlite3.sqlite_version

رقم الإصدار الخاص بمكتبة SQLite في وقت التشغيل، على هيئة سلسلة نصية.

الثابت sqlite3.sqlite_version_info

رقم الإصدار الخاص بمكتبة SQLite في وقت التشغيل، على هيئة صفّ من الأعداد الصحيحة.

الثابت sqlite3.PARSE_DECLTYPES

يستخدم هذا الثابت مع معامل detect_types في دالة connect().

تفسر وحدة sqlite3 -عند تعيين قيمة لهذا الثابت- الأنواع المصرّح عنها لكل عمود تعيده. تفسّر الوحدة أول كلمة في النوع المصرّح عنه، أي تفسر النوع "integer primary key" إلى "integer"، والنوع "number(10)‎" إلى "number". ثم تبحث الوحدة في قاموس المحوّلات عن الدالة المحوّلة المسجَّلة لذلك النوع.

الثابت sqlite3.PARSE_COLNAMES

يستخدم هذا الثابت مع معامل detect_types في دالة connect()‎.

تفسّر واجهة SQLite -عند تعيين قيمة لهذا الثابت- اسم العمود لكل عمود تعيده.

ستبحث الواجهة عن سلسلة نصية بهيئة [mytype] في جملة الاستعلام لتقرّر أن العمود هو من نوع 'mytype'. ستحاول الواجهة البحث عن مدخل من نوع 'mytype' في قاموس المحوّلات ثم تستخدم الدالة المحوّلة التي تجدها لإعادة القيمة.

يكون اسم العمود الموجود في الخاصية Cursor.description مقصورًا على الكلمة الأولى من اسم العمود، بمعنى أنّه لو استخدمت مثلًا العبارة ‎'as "x [datetime]"'‎ في SQL، فإنّها ستفسّر إلى حين الوصول إلى أول فراغ في اسم العمود، وبهذا يصبح اسم العمود هو "x" فقط.

دوال وحدة sqlite3

الدالة sqlite3.connect()

تفتح هذه الدالة اتصالًا مع قاعدة بيانات SQLite عبر الملف المعطى، وتعيد افتراضيًا كائن اتصال.

الدالة sqlite3.register_converter()‎

تسجّل الدالة كائنًا قابلًا للاستدعاء callable لتحويل سلسلة بايتات نصية من قاعدة البيانات إلى نوع خاص من أنواع بيانات بايثون. 

الدالة sqlite3.register_adapter()‎

تسجّل الدالة كائنًا قابلًا للاستدعاء لتحويل نوع بيانات بايثون المعطى إلى إحدى الأنواع التي تدعمها قواعد بيانات SQLite.

الدالة sqlite3.complete_statement()‎

تختبر الدالة ما إذا كانت السلسلة النصية المعطاة تتضمن جملة SQL واحدة أو أكثر تنتهي بالفاصلة المنقوطة. 

الدالة sqlite3.enable_callback_tracebacks()‎

تتيح هذه الدالة عرض الأخطاء tracebacks الناتجة عن الدوال والمجاميع aggregates  والمحوّلات converters  والاستدعاءات الخلفية authorizer callbacks المفوِّضة المعرّفة من قبل المستخدم.

كائنات الاتصال Connection

تقدّم كائنات الاتصال Connection عددًا من الخصائص والتوابع التي تساعد المستخدم في التعامل مع قواعد بيانات SQLite، كالاتصال بقاعدة البيانات وتحميل الملحقات وإنشاء النسخ الاحتياطية وغيرها. تنشأ كائنات الاتصال كنتيجة لاستدعاء الدالة sqlite3.connect()‎.

كائنات المؤشر Cursor

كائنات Cursor هي وسيلة التواصل بين المستخدم وقاعدة البيانات، حيث يمكن باستخدام الخصائص والتوابع التي تقدّمها هذه الكائنات تنفيذ جمل SQL وإجراء الاستعلامات وجلب النتائج من قاعدة البيانات.

كائنات الصف Row

نسخة من الصنف Row وتعدّ صورة محسّنة من الخاصية row_factory في كائنات الاتصال.

الاستثناءات في وحدة sqlite3

الاستثناء sqlite3.Warning

صنف متفرّع من الصنف Exception.

الاستثناء sqlite3.Error

الصنف الأساسي لبقية الاستثناءات في هذه الوحدة، وهو صنف متفرّع من الصنف Exception.

الاستثناء sqlite3.DatabaseError

يطلق هذا الاستثناء عند حدوث الأخطاء المتعلّقة بقاعدة البيانات.

الاستثناء sqlite3.IntegrityError

يطلق هذا الاستثناء عند حدوث خلل في العلاقات التي تربط بين جداول قاعدة البيانات، كحدوث خلل في المفتاح الخارجي foreign key. هذا الاستثناء متفرّع من الصنف DatabaseError.

الاستثناء sqlite3.ProgrammingError

يُطلق هذا الاستثناء عند حدوث أخطاء برمجية، مثل عدم العثور على الجدول المحدّد أو وجود الجدول المراد إنشاؤه أصلًا، أو وجود خلل في جمل SQL، أو تحديد عدد خاطئ من المعاملات... الخ. هذا الاستثناء متفرّع من الصنف DatabaseError.

الاستثناء sqlite3.OperationalError

يُطلق هذا الاستثناء عند حدوث الأخطاء المتعلّقة بالعمليات الخاصّة بقواعد البيانات والتي لا تكون بالضرورة تحت سيطرة المبرمج، مثل: انقطاع الاتصال بقاعدة البيانات على نحو مفاجئ، أو عدم العثور على اسم مصدر البيانات، أو تعذّر معالجة إجراء معيّن... الخ. هذا الاستثناء متفرّع من الصنف DatabaseError.

الاستثناء sqlite3.NotSupportedError

يُطلق هذا الاستثناء عند استخدام تابع أو واجهة برمجية لقواعد البيانات لا تدعمها قاعدة البيانات الحالية، مثل: استدعاء التابع rollback() مع اتصال لا يدعم الإجراءات transaction أو أنّ الإجراءات تكون مغلقة. هذا الاستثناء متفرّع من الصنف DatabaseError.

قواعد بيانات SQLite وأنواع بيانات بايثون

مقدمة

تدعم قواعد بيانات SQLite الأنواع التالية: Null، INTEGER، REAL، TEXT، BLOB.

لذا يمكن إرسال أنواع بيانات بايثون التالية إلى SQLite دون مشاكل:

نوع بيانات بايثون نوع بيانات SQLite
None Null
int INTEGER
float REAL
str TEXT
bytes BLOB

تحوّل أنواع بيانات SQLite إلى أنواع بيانات بايثون -افتراضيًا- على النحو التالي:

نوع بيانات SQLite نوع بيانات بايثون
Null None
INTEGER int
REAL float
TEXT تعتمد على خاصية text_factory ولكن تحوّل افتراضيًا إلىstr
BLOB bytes

إن نظام أنواع البيانات في وحدة sqlite3 قابلة للتوسع بطريقتين: يمكن تخزين أنواع بايثون إضافية في قاعدة بيانات SQLite عن طريق تكييف الكائنات object adaptation، ويمكن الاعتماد على وحدة sqlite3 في تحويل أنواع بيانات SQLite إلى أنواع بيانات بايثون متنوعة عن طريق المحولات.

استخدام المكيّفات adapters لتخزين أنواع بيانات بايثون إضافية في قواعد بيانات SQLite

ذكرنا سابقًا أنّ قواعد بيانات SQLite تدعم عددًا محدودًا من أنواع البيانات، ولاستخدام أنواع بيانات بايثون مع SQLite يجب تكييف adapt هذه الأنواع إلى أحد الأنواع التي تدعمها وحدة sqlite3 وهي: NoneType، int، float، str، bytes.

هناك طريقتان لتكييف أحد أنواع بيانات بايثون إلى أنواع البيانات المدعومة من قبل الوحدة:

ترك الكائن ليكيّف نفسه

هذه الطريقة مناسبة إن كنت تكتب الصنف بنفسك. لنفترض أنّ لديك الصنف التالي:
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
تريد الآن تخزين النقطة في عمود SQLite واحد. يجب عليك في البداية اختيار أحد الأنواع المدعومة لاستخدامها في تمثيل النقطة. سنستخدم النوع str وسنفصل إحداثيات النقطة بفاصلة منقوطة. بعد ستحتاج إلى تزويد الصنف بتابع ‎__conform__(self,protocl)‎ ومهمّته إعادة القيمة المحوّلة، وسيأخذ المعامل protocol القيمة PrepareProtocol.
import sqlite3

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __conform__(self, protocol):
        if protocol is sqlite3.PrepareProtocol:
            return "%f;%f" % (self.x, self.y)

con = sqlite3.connect(":memory:")
cur = con.cursor()

p = Point(4.0, -3.2)
cur.execute("select ?", (p,))
print(cur.fetchone()[0])

تسجيل مكيّف قابل للاستدعاء

تتلخص الطريقة الثانية لتكيف الكائنات في إنشاء دالة تحوّل النوع إلى تمثيل نصّي وتسجيل الدالة باستخدام الدالة register_adapter().
import sqlite3

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

def adapt_point(point):
    return "%f;%f" % (point.x, point.y)

sqlite3.register_adapter(Point, adapt_point)

con = sqlite3.connect(":memory:")
cur = con.cursor()

p = Point(4.0, -3.2)
cur.execute("select ?", (p,))
print(cur.fetchone()[0])
تتضمن وحدة sqlite3 نوعين افتراضيين من المكيّفات لنوعي بيانات بايثون الداخليين datetime.date و datetime.datetime. يبين المثال التالي طريقة تخزين كائن datetime.datetime في قاعدة البيانات كختم زمني وليس بصيغة ISO.
import sqlite3
import datetime
import time

def adapt_datetime(ts):
    return time.mktime(ts.timetuple())

sqlite3.register_adapter(datetime.datetime, adapt_datetime)

con = sqlite3.connect(":memory:")
cur = con.cursor()

now = datetime.datetime.now()
cur.execute("select ?", (now,))
print(cur.fetchone()[0])

تحويل قيم SQLite إلى أنواع بايثون خاصّة

يمكن إنشاء مكيّفات خاصّة تسمح بإرسال أنواع بيانات بايثون مخصّصة إلى قاعدة بيانات SQLite. ولكن يجب تمهيد الطريق لتحويل البيانات من بايثون إلى SQLite ثم إلى بايثون رجوعًا، وهنا يأتي دور المحوّلات.

لنعد إلى صنف Point المعروض سابقًا. جرى في هذا الصنف تخزين قيم الإحداثيات x و y مفصولة بفاصلة منقوطة وعلى هيئة سلسلة نصية في قاعدة بيانات SQLite.

في البداية، سنعرّف دالة تحويل تأخذ السلسلة النصية كمعامل وتنشئ كائن Point منها.

ملاحظة: يجب استدعاء دوال التحويل دائمًا مع كائن من نوع bytes، بصرف النظر عن نوع البيانات المرسلة إلى SQLite.
def convert_point(s):
    x, y = map(float, s.split(b";"))
    return Point(x, y)
سنحتاج الآن إلى إخبار وحدة sqlite3 بأنّ ما حدّدناه من قاعدة البيانات هو نقطة في الواقع. وهناك طريقتان للقيام بذلك:
  • التضمين عن طريق النوع المصرّح عنه.
  • التصريح عن طريق اسم العمود.

كلتا الطريقتين موضحتان في قسم دوال وثوابت الوحدة، في الثابتين PARSE_DECLTYPES و PARSE_COLNAMES.

يبين المثال التالي هاتين الطريقتين:
import sqlite3

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "(%f;%f)" % (self.x, self.y)

def adapt_point(point):
    return ("%f;%f" % (point.x, point.y)).encode('ascii')

def convert_point(s):
    x, y = list(map(float, s.split(b";")))
    return Point(x, y)

# تسجيل المكيف
sqlite3.register_adapter(Point, adapt_point)

# تسجيل المحول
sqlite3.register_converter("point", convert_point)

p = Point(4.0, -3.2)

#########################
# 1) استخدام الأنواع المصرّح عنها
con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES)
cur = con.cursor()
cur.execute("create table test(p point)")

cur.execute("insert into test(p) values (?)", (p,))
cur.execute("select p from test")
print("with declared types:", cur.fetchone()[0])
cur.close()
con.close()

#######################
# 2) استخدام أسماء الأعمدة
con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_COLNAMES)
cur = con.cursor()
cur.execute("create table test(p)")

cur.execute("insert into test(p) values (?)", (p,))
cur.execute('select p as "p [point]" from test')
print("with column names:", cur.fetchone()[0])
cur.close()
con.close()

المكيّفات والمحوّلات الافتراضية

تتضمن وحدة datetime افتراضيًّا بعض المكيّفات لنوعي date و datetime. يُرسل هذان النوعان كتواريخ أو أختام زمنية بصيغة ISO إلى قاعدة بيانات SQLite.

أما المحوّلات الافتراضية فهي مسجّلة تحت اسم "date" للنوع datetime.date وتحت اسم "timestamp" للنوع datetime.datetime.

وبهذه الطريقة يمكنك استخدام date/timestamp من بايثون دون الحاجة إلى القيام بشيء آخر في معظم الحالات. إلى جانب ذلك فإنّ تنسيق المكيّفات متوافق مع دوال date/time التجريبية في SQLite.

يمكن توضيح ما سبق في المثال التالي:
import sqlite3
import datetime

con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
cur = con.cursor()
cur.execute("create table test(d date, ts timestamp)")

today = datetime.date.today()
now = datetime.datetime.now()

cur.execute("insert into test(d, ts) values (?, ?)", (today, now))
cur.execute("select d, ts from test")
row = cur.fetchone()
print(today, "=>", row[0], type(row[0]))
print(now, "=>", row[1], type(row[1]))

cur.execute('select current_date as "d [date]", current_timestamp as "ts [timestamp]"')
row = cur.fetchone()
print("current_date", row[0], type(row[0]))
print("current_timestamp", row[1], type(row[1]))
إن تضمن الختم الزمني المخزّن في قاعدة بيانات SQLite جزءًا كسريًّا يتجاوز ستة أعداد، فإنّ قيمته ستقتطع إلى مايكرو ثانية بواسطة محول الختم الزمني.

التحكم بالإجراءات

تعمل مكتبة sqlite3 الداخلية افتراضيًا في وضع الحفظ التلقائي autocommit، ولكن وحدة sqlite3 في بايثون ليست كذلك افتراضيًا.

وضع الحفظ التلقائي يعني أنّ الجمل التي تعدّل قاعدة البيانات تأخذ مفعولها على نحو مباشر. تعطّل جملة BEGIN أو SAVEPOINT وضع الحفظ التلقائي، وتفعّل جملة COMMIT أو ROLLBACK أو RELEASE والتي تنهي الإجراء الأخير، وضع الحفظ التلقائي مرة أخرى.

تطلق وحدة sqlite3 في بايثون وعلى نحو تلقائي الجملة BEGIN ضمنيًا قبل أي جملة تعديل للبيانات Data Modification Language (DML)‎ (أي الجمل INSERT/UPDATE/DELETE/REPLACE).

يمكن التحكم في طبيعة جمل BEGIN التي تنفّذها sqlite3 ضمنيًا بواسطة المعامل isolation_level عند استدعاء الدالة connect()‎، أو عن طريق خاصية isolation_level في كائنات الاتصال. 

في حال عدم تعيين قيمة لمستوى العزل isolation_level فستستخدم sqlite3 جملة BEGIN صرفة، وهذا مكافئ لتعيين القيمة DEFERRED، وهناك قيم أخرى يمكن استخدامها وهي IMMEDIATE و EXCLUSIVE.

يمكن تعطيل الآلية الضمنية للتحكم في الإجراءات في وحدة sqlite3 عن طريق تعيين القيمة None للمعامل أو الخاصية isolation_level، وسيؤدي هذا إلى تحويل عمل مكتبة sqlite3 الداخلية إلى وضع التخزين التلقائي، وعندها يمكنك التحكم في الإجراءات بصورة كاملة عن طريق استخدام جمل BEGIN و ROLLBACK و SAVEPOINT و RELEASE في شيفرتك.

ملاحظة: تحفظ sqlite3 الإجراءات المفتوحة ضمنيًا قبل جمل DDL. لم يعد هذا يحدث في الإصدار 3.6 من بايثون.

استخدام sqlite3 بكفاءة

استخدام التوابع المختصرة

يؤدي استخدام التوابع غير المعيارية execute()‎ و executemany() و executescript()‎ في كائن Connection إلى اختصار الشيفرة البرمجية المكتوبة نظرًا لانتفاء الحاجة إلى إنشاء كائن المؤشر Cursor والذي يكون في كثير من الأحيان زائدًا عن الحاجة.

عوضًا عن ذلك، يجري إنشاء كائن Cursor ضمنيًا وتعيد هذه التوابع المختصرة كائنات المؤشر، وهكذا يمكنك تنفيذ جملة SELECT والمرور على النتائج مباشرة وعن طريق تنفيذ استدعاء واحد فقط على كائن الاتصال.
import sqlite3

persons = [
    ("Hugo", "Boss"),
    ("Calvin", "Klein")
    ]

con = sqlite3.connect(":memory:")

# إنشاء الجدول
con.execute("create table person(firstname, lastname)")

# تعبئة الجدول بالبيانات
con.executemany("insert into person(firstname, lastname) values (?, ?)", persons)

# طباعة محتويات الجدول
for row in con.execute("select firstname, lastname from person"):
    print(row)

print("I just deleted", con.execute("delete from person").rowcount, "rows")

الوصول إلى الأعمدة عن طريق أسمائها عوضًا عن فهارسها

الصنف الداخلي sqlite3.Row هو من الميزات المفيدة في وحدة sqlite3، وقد صمّم هذا الصنف لاستخدامه كمنتج للصفوف row factory.

يمكن الوصول إلى الصفوف rows المغلّفة بهذا الصنف إما عن طريق الفهرس (مثل الصفوف tuples) أو عن طريق الاسم دون تحسس حالة الأحرف:
import sqlite3

con = sqlite3.connect(":memory:")
con.row_factory = sqlite3.Row

cur = con.cursor()
cur.execute("select 'John' as name, 42 as age")
for row in cur:
    assert row[0] == row["name"]
    assert row["name"] == row["nAmE"]
    assert row[1] == row["age"]
    assert row[1] == row["AgE"]

استخدام الاتصال كمدير للسياق context manager

يمكن استخدام كائنات الاتصال كمدراء للسياق يمكنها حفظ أو استرجاع الإجراءات على نحو تلقائي. في حال حدوث أي استثناء، يتم التراجع عن الإجراء، وفيما عدا ذلك يُحفظ الإجراء:
import sqlite3

con = sqlite3.connect(":memory:")
con.execute("create table person (id integer primary key, firstname varchar unique)")

# يستدعى التابع con.commit()‎ تلقائيًا بعد ذلك ودون حدوث أي مشاكل

with con:
    con.execute("insert into person(firstname) values (?)", ("Joe",))

# يستدعى التابع con.rollback()‎ بعد انتهاء الإجراء باستثناء، وسيبقى الاستثناء طليقًا ويجب الإمساك به.

try:
    with con:
        con.execute("insert into person(firstname) values (?)", ("Joe",))
except sqlite3.IntegrityError:
    print("couldn't add Joe twice")

مشاكل شائعة

تعدد الخيوط Multithreading

تعاني إصدارات SQLite القديمة من مشاكل في مشاركة الاتصال بين خيوط متعددة، ولهذا السبب تمنع وحدة بايثون مشاركة الاتصالات والمؤشرات بين الخيوط، وتطلق اللغة استثناء في وقت التشغيل عند القيام بذلك.

الاستثناء الوحيد هو في استدعاء التابع interrupt() والذي يعدّ استدعاؤه من خيط آخر أمرًا منطقيًا.

انظر أيضًا

  • وحدة dbm: تمثّل وحدة dbm واجهة عامّة للأشكال المختلفة من قواعد بيانات DBM، مثل dbm.gnu أو dbm.ndbm.

مصادر