שקולט SQLite הוא אחד משרתי הבסיסיים הנפוצים ביותר לניהול מערכות מסדי נתונים רלסציונליות (RDBMS). הוא קליל במשמעות שלו לא נוטל הרבה מקום במערכת שלך. אחד מהיכולות הטובות ביותר שלו הוא שהוא ללא שרת, כך שאין צורך להתקין או לנהל שרת נפרד כדי להשתמש בו.

במקום זה, הוא שומר על הכל בקובץ פשוט על המחשב שלך. יש גם צורך באפס קונפיגורציה, כך שאין תהליך התקנה מסובך, גורם לו להיות מושלם למתחילים ולפרוייקטים קטנים.

SQLite הוא בחירה טובה ליישומים קטנים עד בינוניים בגלל שהוא קל לשימוש, מהיר ויכול להתמודד עם רוב המשימות שמסדי נתונים גדולים יותר יכולים לבצע, אבל בלי הסתבך של ניהול תוכנה נוספת. בין אם אתה בונה פרוייקט אישי או מתקדם דגם חדש של אפליקציה, SQLite הינה אפשרות מוצלחת להביא דברים לריצה מהר.

במדריך זה, תלמד איך לעבוד עם SQLite באמצעות Python. הנה מה שאנחנו עומדים לכסות במדריך זה:

הסידרה הזו מושלמת עבור כל אדם שרוצה להתחיל עם בסיס נתונים בלי להיות מודע להגדרות מורכבות.

איך להגדיר את הסביבת הפיתוח של הפיתוח שלך

לפני שיתחילו עם SQLite, בואו נוודא שסביבת הפיתוח שלך מוכנה. הנה איך להגדיר את הכל.

התקנת Python

אם עדיין לא התקנתם Python על המערכת שלכם, תוכלו ל下载 אותו מהאתר הרשמי של Python. עיוורות את ההוראות להתקנה עבור המערכת הפעלה שלכם (Windows, macOS או Linux).

כדי לבדוק אם Python מותקן, פתחו את התמנון שלכם (או תמנון הפקטים) והקלדו:

python --version

זה צריך להראות את הגיון המוצע של Python המותקן. אם הוא לא מותקן, עיוורות את ההוראות על האתר הרשמי של Python.

התקנת מודל SQLite3

החדשות הטובות הן ש- SQLite3 מובנה ב-Python! אין צורך להתקין אותו בנפרד מכיוון שהוא כלול בספריית התקנה התקנית של Python. זה אומר שניתן להתחיל להשתמש בו מייד בלי צורך בהתקנה נוספת.

כדאי ליצור סביבה וירטואלית עבור כל פרוייקט כדי לשמור על התלותים שלך מאורגנים. סביבה וירטואלית היא כמו טבלה נקיה בה תוכל להתקין חבילות בלי להשפיע על ההתקנה הגלובלית של Python שלך.

כדי ליצור סביבה וירטואלית, עקוב אחר השלבים הבאים:

  1. ראשית, פתח את הטרמינל או פקודת הפעולה שלך ונווט לתיקייה בה ברצונך ליצור את הפרוייקט שלך.

  2. הרץ את הפקודה הבאה כדי ליצור סביבה וירטואלית:

python -m venv env

כאן, env הוא שם הסביבה הוירטואלית. אתה יכול לתת לה שם כלשהו שתרצה.

  1. הפעל את הסביבה הוירטואלית:
# השתמש בפקודה זו עבור Windows
env\Scripts\activate

# השתמש בפקודה זו עבור macOS/Linux:
env/bin/activate

לאחר הפעלת הסביבה הוירטואלית, תגלה כי מזהה הטרמינל שלך משתנה, מציג את שם הסביבה הוירטואלית. זה אומר שאתה כעת עובד בתוך הסביבה.

התקנת ספריות הכרחיות

נצטרך מספר ספריות נוספות עבור פרויקט זה. במפורט, נשתמש ב:

  • pandas: זו היא ספריה אופציונלית לטיפול ותצוגת נתונים בפורמט טבלאי, שימושית למקרים מתקדמים.

  • faker: ספריה זו תעזור לנו ליצור נתונים מזוייפים, כמו שמות וכתובות אקראיות, שנוכל להכניס לבסיס הנתונים שלנו לצורך בדיקות.

כדי להתקין את pandas ואת faker, פשוט הריצו את הפקודות הבאות:

pip install pandas faker

זה מתקין את pandas ואת faker בסביבת העבודה הווירטואלית שלכם. בעזרת זה, הסביבה שלכם מוכנה ואתם מוכנים להתחיל ליצור ולנהל את בסיס הנתונים של SQLite בפייתון!

איך ליצור בסיס נתונים מסוג SQLite

בסיס נתונים הוא דרך מאורגנת לאחסון וניהול נתונים כך שיהיה ניתן לגשת אליהם, לעדכן אותם ולארגן אותם בקלות. זה כמו מערכת דיגיטלית לאיחסון נתונים בצורה יעילה, בין אם זה לאפליקציה פשוטה או למערכת מורכבת יותר. בסיסי נתונים משתמשים בטבלאות כדי לארגן נתונים, עם שורות ועמודות המייצגות רשומות יחידות ומאפייניהן.

איך עובדים בסיסי נתונים מסוג SQLite

בניגוד לרוב מערכות המסדים הנתונים האחרות, SQLite היא מסד נתונים ללא שרת. זה אומר שאין צורך להתקין או לנהל שרת, והופך אותו לקל משקל וקל לשימוש. כל הנתונים מאוחסנים בקובץ אחד במחשב שלך, שאתה יכול להעביר, לשתף או לגבות בקלות. למרות פשטותו, SQLite מסוגל להתמודד עם מגוון רחב של משימות בסיסיות למסד נתונים והוא נפוץ ביישומים ניידים, מערכות משובצות ופרויקטים בגודל בינוני וקטן.

איך ליצור מסד נתונים חדש של SQLite

בואו ניצור מסד נתונים חדש של SQLite ונלמד איך לשגשג איתו באמצעות ספריה של Python בשם sqlite3.

התחברות למסד נתונים

מאחר ו־sqlite3 מותקנת מראש, אתם רק צריכים לייבא אותה בתסריט שלכם ב־Python. כדי ליצור מסד נתונים חדש או להתחבר לקיים, אנחנו משתמשים בשיטה sqlite3.connect(). שיטה זו מקבלת את שם קובץ מסד הנתונים כארגומנט. אם הקובץ אינו קיים, SQLite ייצורו באופן אוטומטי. 

import sqlite3

# התחברות למסד הנתונים של SQLite (או יצירתו אם אינו קיים)
connection = sqlite3.connect('my_database.db')

בדוגמה זו, קובץ בשם my_database.db נוצר באותו התיקייה כמו התסריט שלך. אם קובץ זה כבר קיים, SQLite יפתח את החיבור אליו פשוט.

יצירת סמן

לאחר שיש לך חיבור, השלב הבא הוא ליצור אובייקט סמן. הסמן אחראי לביצוע פקודות SQL ושאילתות על מסד הנתונים. 

# יצירת אובייקט סמן
cursor = connection.cursor()

סגירת החיבור

אחרי שתסיימו לעבוד עם הבסיס הנתונים, חשוב לסגור את החיבור כדי לשחרר את כל המשאבים. ניתן לסגור את החיבור בהצגה הפעם בפקודה הבאה:

# סגור את החיבור לבסיס הנתונים
connection.close()

אך ורק אתם צריכים לסגור את החיבור אחרי שביצעתם את כל העיבודים שלכם.

כשתבצעו את הסקripט הפיתוחי שלכם בפיתוח Python, יוצא קובץ בשם my_database.db בתוך האופקים העובדים הנוכחיים שלכם. עכשיו יצרתם בהצלחה את הבסיס הנתונים SQLite הראשון שלכם!

איך להשתמש במנהל ההקשר כדי לפתוח ולסגור חיבורים

Python מעניק דרך יעילה יותר ונקיה יותר להדביקת חיבורי הבסיס הנתונים בעזרת המילה with, הידוע גם כמנהל ההקשר. המילה with פועלת באופן אוטומטי לפתוח ולסגור את החיבור, ומובטחת שהחיבור יסגור בהדרגה אפילו אם תקרה שגיאה במהלך העיבודים בבסיס הנתונים. זה מסיים את הצורך בקריאה מידי יד ל connection.close().

הנה איך ניתן להשתמש במילה with להדביק חיבורי הבסיס:

import sqlite3

# שלב 1: השתמשו ב 'with' כדי להתחבר לבסיס הנתונים (או ליצור אחד) ולסגור אותו בהסתיים
with sqlite3.connect('my_database.db') as connection:

    # שלב 2: יצרו את האובייקט המבוקר כדי לתקשר עם הבסיס הנתונים
    cursor = connection.cursor()

    print("Database created and connected successfully!")

# אין צו

למעשה, נשתמש בהצהרה with בדוגמאות הקוד הקרובות כדי לנהל חיבורי בסיס נתונים בצורה יעילה. זה יעשה את הקוד קצר יותר ויותר קל לתחזוקה.

איך ליצור טבלאות בסיס נתונים

לאחר שיצרנו מסד נתונים של SQLite והתחברנו אליו, השלב הבא הוא ליצור טבלאות בתוך המסד. טבלה היא המקום בו נאחסן את המידע שלנו, מאורגן בשורות (רשומות) ועמודות (מאפיינים). בדוגמה זו, ניצור טבלה בשם Students לאחסן מידע על סטודנטים, שנשתמש בו בחלקים הבאים.

כדי ליצור טבלה, אנחנו משתמשים בהצהרה CREATE TABLE של SQL. פקודה זו מגדירה את מבנה הטבלה, כולל שמות העמודות וסוגי הנתונים לכל עמודה.

הנה פקודת SQL פשוטה ליצירת טבלת Students עם השדות הבאים:

  • id: מזהה ייחודי לכל סטודנט (מספר שלם).

  • name: שם הסטודנט (טקסט).

  • age: גיל הסטודנט (מספר שלם).

  • email: כתובת הדוא"ל של הסטודנט (טקסט).

הפקודה SQL ליצירת ה

CREATE TABLE Students (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    age INTEGER,
    email TEXT
);

אנחנו יכולים לבצע את הפקודה CREATE TABLE SQL הזו בפיתוח ה Python בעזרת הספרייה sqlite3. בואו נראה איך לעשות את זה.

import sqlite3

# השתמשות ב 'with' כדי להתחבר לבסיס נתונים SQLite ולסגור את הקישור באופן אוטומטי ברגע שהעבודה תהיה מסתיימת
with sqlite3.connect('my_database.db') as connection:

    # יצירת אובייקט סקורר
    cursor = connection.cursor()

    # כתיבת הפקודה SQL ליצירת הטבלה Students
    create_table_query = '''
    CREATE TABLE IF NOT EXISTS Students (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        age INTEGER,
        email TEXT
    );
    '''

    # ביצוע הפקודה SQL
    cursor.execute(create_table_query)

    # אישור השינויים
    connection.commit()

    # הוצאת מסר אישור
    print("Table 'Students' created successfully!")

  • IF NOT EXISTS: זה מובטח שהטבלה יוצרת רק אם היא לא קיימת, וזה ממנה ממנע שגיאות אם הטבלה נוצרה קודם.

  • connection.commit(): זה שומר (מוכרם) את השינויים בבסיס נתונים.

כשתרצו את הקוד הפיתוח העליון, הוא ייצר את הטבלה Students בקבצים הבסיס הנתונים my_database.db. תראו גם מסר מסביר בתורם המסגרת שהטבלה נוצרה בהצלחה.

אם אתה משתמש ב-Visual Studio Code, תוכל להתקין את ההרחבה SQLite Viewer כדי להצגת מסדרוני SQLite.

סוגי מידע ב-SQLite וההתאמה שלהם ל-Python

SQLite מספקת סוגים מסויימים של מידע, שעלינו להבין בעוד אנחנו מגדירים את הטאבלות שלנו. הנה סקירה מהירה של סוגי מידע ב-SQLite ואיך הם מתאמים לסוגים של מידע ב-Python:

סוג מידע SQLite תיאור סוג מידע ב-Python אותו משווה
INTEGER מספרים כלליים int
TEXT משתמשים טקסט str
REAL מספרים בעלי מקום רחב float
BLOB מידע בינארי (לדוגמא, תמונות, קבצים) bytes
NULL מייצג אין-ערך או חוסר מידע None

בטאבלה שלנו Students:

  • id הוא בסוג INTEGER, שמתאם לint ב-Python.

  • name וemail הם בסוג TEXT, שמתאמים לstr ב-Python.

  • גיל גם מקבל סוג מספר, שמתאים לint בפיוני.

איך להכניס מידע לטבלה

עכשיו שיצרנו את הטבלה סטודנטים, הגיע הזמן להתחיל להכניס מידע לבסיס נתונים. בהיתרה מהם, אנחנו נעסק באופן בו להכניס רק רשימה אחת או רשימות רבות בעזרת פיוני וSQLite, ואיך להימנע מבעיות הבטיחות הנפוצות כמו SQL injection על-ידי שימוש בשאלות משתנות.

איך להכניס רשימה יחידה

כדי להכניס מידע לבסיס נתונים, אנחנו משתמשים בפקודה SQL INSERT INTO. בואו נתחיל בהכניסת רשימה אחת לטבלת סטודנטים שלנו.

הנה הסינtax הבסיסי להכניסת רשימה אחת:

INSERT INTO Students (name, age, email) 
VALUES ('John Doe', 20, '[email protected]');

אך במקום לכתוב SQL ישירות בתסכול הפיוני שלנו עם ערכים קבעיים, אנחנו נשתמש בשאלות משתנות להפוך את הקוד שלנו ליותר בטוח וגמיש. שאלות משתנות עוזרות למנוע SQL injection, התקף הנפוצה הזו בה משתמשים מכוונים מסוימים יכולים למנוע את הSQL על-ידי עליית קולט למידע רע.

הנה איך אנחנו יכולים להכניס רשימה אחת לטבלת סטודנטים בעזרת שאלה משתנה:

import sqlite3

# השתמשות ב 'with' על מנת לפתוח ולסגור את החיבור באופן אוטומטי
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # הוסף רשומה לטבלת סטודנטים
    insert_query = '''
    INSERT INTO Students (name, age, email) 
    VALUES (?, ?, ?);
    '''
    student_data = ('Jane Doe', 23, '[email protected]')

    cursor.execute(insert_query, student_data)

    # בודד את השינויים באופן אוטומטי
    connection.commit()

    # אין צורך בקריאת connection.close(); זה נעשה אוטומטית!
    print("Record inserted successfully!")

המרמזים ? מייצגים את הערכים שייסדרו לטבלה. הערכים האמתיים מועברים בתור טופל (student_data) בתהליך cursor.execute() המתוך.

איך להוסיף רשומות מרובות

אם תרצו להוסיף רשומות רבות בו-פעם, תוכלו להשתמש בשיטה executemany() במערכת פיתוח פיוני. השיטה לוקחת רשימה של טופלים, בהם כל טוף מייצג רשומה אחת.

על מנת להפוך את הדוגמא שלנו ליותר דינמית, נוכל להשתמש בספריית Faker כדי לייצר מידע סטודנטי אקראי. זה שימושי לבדיקות ולשחזור סיטאציות של העולם האמיתי.

from faker import Faker
import sqlite3

# התחל את Faker
fake = Faker(['en_IN'])

# השתמשות ב 'with' על מנת לפתוח ולסגור את החיבור באופן אוטומטי
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # הוסף רשומה לטבלת סטודנטים
    insert_query = '''
    INSERT INTO Students (name, age, email) 
    VALUES (?, ?, ?);
    '''
    students_data = [(fake.name(), fake.random_int(
        min=18, max=25), fake.email()) for _ in range(5)]

    # בודד את השאלה עבור רשומות מספרים
    cursor.executemany(insert_query, students_data)

    # בודד את השינויים
    connection.commit()

    # הדגימה של מסר האישור
    print("Fake student records inserted successfully!")

בתוך הקוד הזה:

  • מערכת Faker() מייצרת שמות אקראיים, גילים ואימיילים עבור סטודנטים. השדה locale([‘en_IN’]) הוא אופציינטי.

  • cursor.executemany(): השיטה הזו מאפשרת לנו להכניס רשימות רבות בו-זמנית, שגורם לקוד להיות יעיל יותר.

    students_data: רשימת קבצים בה כל קבץ מייצג את המידע של סטודנט אחד.

  • איך לטפל בבעיות נפוצות: התקיף בSQL

התקיף בSQL הוא פגם בבטיחות שבו אתגרים יכולים להכניס או לערבב שאלות SQL על ידי ספקת מידע רע. לדוגמה, אותו אתגר עשוי לנסות להכניס קוד כמו '; DROP TABLE Students; -- כדי למחוק את הטבלה.

על ידי שימוש בשאלות מוגדרות בפרמטרים (כפי שהודגם למעלה), אנחנו ממנעים את הבעיה הזו. התווספים ? בשאלות המוגדרות בפרמטרים ודאי שהמידע יהיה מטופל כמות נתונים ולא כחלק מהפקט הSQL. זה מוביל למצב בו קידוח רע באופן מושעי אינו אפשרי.

איך לבצע שאילת מידע

עכשיו שהוספנו מידע לטבלה סטודנטים שלנו, בואו נלמד איך להוציא את המידע מהטבלה. נלך ונחפש דרך שונות להוציא מידע בפיתוח הקוד הפיתוחי שלנו, כולל fetchone(), fetchall() ו fetchmany().

כדי לבקש מידע מטבלה, אנחנו משתמשים בהצעה SELECT. הנה הצעה סידורית פשוטה של SQL על מנת לבחון כל העמודות בטבלה סטודנטים:

SELECT * FROM Students;

הצעה זו משחיטה את כל השורות והעמודות מהטבלה סטודנטים. אנחנו יכולים לבצע את הבחינה SELECT הזו בפיתוח הקוד הפיתוחי שלנו ולהוציא את התוצאות.

איך להוציא את כל השורות

הנה איך אנחנו יכולים להוציא את כל השורות מהטבלה סטודנטים:

import sqlite3

# השתמשות ב 'with' כדי להתחבר למסדר הגיוני של SQLite
with sqlite3.connect('my_database.db') as connection:

    # יצרו אובייקט סרטור
    cursor = connection.cursor()

    # כתבו את הצעה SQL לבחינה כל השורות מהטבלה Students
    select_query = "SELECT * FROM Students;"

    # בצעו את הצעה הSQL
    cursor.execute(select_query)

    # הוציאו את כל השורות
    all_students = cursor.fetchall()

    # הצגו את התוצאות בטרמינל
    print("All Students:")
    for student in all_students:
        print(student)

בדוגמה זו, שיטת fetchall() משחיטה את כל השורות שמושקעות על ידי הבחינה בתור רשימת פעמים של קבצים.

All Students:
(1, 'Jane Doe', 23, '[email protected]')
(2, 'Bahadurjit Sabharwal', 18, '[email protected]')
(3, 'Zayyan Arya', 20, '[email protected]')
(4, 'Hemani Shukla', 18, '[email protected]')
(5, 'Warda Kara', 20, '[email protected]')
(6, 'Mitali Nazareth', 19, '[email protected]')

איך להוציא שורה יחידה

אם אתה רוצה להוציא רק שורה אחת, אתה

import sqlite3

# השתמשות ב 'with' כדי להתחבר למסד הנתונים SQLite
with sqlite3.connect('my_database.db') as connection:

    # יצירת אובייקט סרטור
    cursor = connection.cursor()

    # כתיבת הפקודה SQL עבור בחירת כל השירותים מהטבלה Students
    select_query = "SELECT * FROM Students;"

    # ביצוע הפקודה SQL
    cursor.execute(select_query)

    # שימוש בסרטור אחד
    student = cursor.fetchone()

    # הצגת התוצאה
    print("First Student:")
    print(student)

יוצאת:

First Student:
(1, 'Jane Doe', 23, '[email protected]')

איך להוציא רשימות רבות

כדי להוציא מספר ספציפי של שירותים, ניתן להשתמש בfetchmany(size):

import sqlite3

# השתמשות ב 'with' כדי להתחבר למסד הנתונים SQLite
with sqlite3.connect('my_database.db') as connection:

    # יצירת אובייקט סרטור
    cursor = connection.cursor()

    # כתיבת הפקודה SQL עבור בחירת כל השירותים מהטבלה Students
    select_query = "SELECT * FROM Students;"

    # ביצוע הפקודה SQL
    cursor.execute(select_query)

    # שימוש בשלושה שירותים
    three_students = cursor.fetchmany(3)

    # הצגת התוצאות
    print("Three Students:")
    for student in three_students:
        print(student)

יוצאת:

Three Students:
(1, 'Jane Doe', 23, '[email protected]')
(2, 'Bahadurjit Sabharwal', 18, '[email protected]')
(3, 'Zayyan Arya', 20, '[email protected]')

איך להשתמש בpandasעבור תצגת מידע טובה יותר

כדי לתצוגת מידע טובה יותר, אנחנו יכולים להשתמש בספרייתpandasכדי ליצור מערך מידע מתוצאות השאילתים שלנו. זה מקל יותר לשינוי ולתצוגת המידע.

הנה איך להוציא את כל השירותים ולהציג אותם בתבנית DataFrame של pandas:

import sqlite3
import pandas as pd

# השתמשות ב 'with' כדי להתחבר למסד הנתונים SQLite
with sqlite3.connect('my_database.db') as connection:
    # כתבו את הפקודה SQL על מנת לבחור את כל השירותים מהטבלה Students
    select_query = "SELECT * FROM Students;"

    # השתמשות ב pandas כדי לקרוא SQL שאלה ישירות לתשתית DataFrame
    df = pd.read_sql_query(select_query, connection)

# הצגות התשתית
print("All Students as DataFrame:")
print(df)

היצאה:

All Students as DataFrame:
   id                  name  age                        email
0   1              Jane Doe   23             [email protected]
1   2  Bahadurjit Sabharwal   18  [email protected]
2   3           Zayyan Arya   20  [email protected]
3   4         Hemani Shukla   18    [email protected]
4   5            Warda Kara   20           [email protected]
5   6       Mitali Nazareth   19          [email protected]

pd.read_sql_query() תפקיד מבצע את השאלה SQL ומחזיר ישירות את התוצאות בתשתית DataFrame pandas.

איך לעדכן ולמחוק מידע

בחלק זה, נלמד איך לעדכן רשימות קיימות ולמחוק שירותים מטבלת Students בעזרת פקודות SQL במערכת Python. זה חיוני לניהול ושימור המידע בצורה יעילה.

עדכון שירותים קיימים

כדי לשנות שירותים קיימים במסד הנתונים, אנו משתמשים בפקודה SQL UPDATE. הפקודה הזו מאפשרת לנו לשנות את הערכים בעמודות ספציפיות בשורה אחת או יותר בהתבסס על תנאים ספציפיים.

לדוגמה, אם אנו רוצים לעדכן הגיל של סטודנט, הפקודה SQL תראה כך:

UPDATE Students 
SET age = 21 
WHERE name = 'Jane Doe';

עכשיו, בואו נכתוב את הקוד הפנימי לעדכון הגיל של סטודנט מסויים בטבלת Students שלנו.

import sqlite3

# בשימוש ב 'with' כדי להתחבר לבסיס נתונים SQLite
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # הצהרה SQL עבור עדכון הגיל של סטודנט
    update_query = '''
    UPDATE Students 
    SET age = ? 
    WHERE name = ?;
    '''

    # נתונים עבור העדכון
    new_age = 21
    student_name = 'Jane Doe'

    # ביצוע הצהרה SQL עם הנתונים
    cursor.execute(update_query, (new_age, student_name))

    # בחינם השינויים כדי לשמור על העדכון
    connection.commit()

    # הוצאת מסר אימות
    print(f"Updated age for {student_name} to {new_age}.")

במודל זה, השתמשנו בשאלות מבוססות פרמטרים כדי למנוע SQL injection.

איך למחוק רשימות מהטבלה

כדי להסיר רשימות מהבסיס נתונים, אנחנו משתמשים בהצהרה SQL DELETE. ההצהרה זו מאפשרת לנו למחוק שורה אחת או יותר על פי תנאי מסויים.

לדוגמה, אם אנחנו רוצים למחוק סטודנט בשם 'Jane Doe', ההצהרה SQL תראה כך:

DELETE FROM Students 
WHERE name = 'Jane Doe';

בואו נעשה קוד בפינגווין כדי להסיר סטודנט ספציפי מהטבלה Students בעזרת המשפט with.

import sqlite3

# בשימוש ב 'with' כדי להתחבר לבסיס נתונים SQLite
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # הצהרה SQL עבור מחיקת סטודנט
    delete_query = '''
    DELETE FROM Students 
    WHERE name = ?;
    '''

    # שם הסטודנט שימושך למחיקה
    student_name = 'Jane Doe'

    # ביצוע הצהרה SQL עם הנתונים
    cursor.execute(delete_query, (student_name,))

    # בחינם השינויים כדי לשמור על המחיקה
    connection.commit()

    # הוצאת מסר אימות
    print(f"Deleted student record for {student_name}.")

הדברים החשובים לחשוב.

  • תנאים: תמיד יש להשתמש ב-ClauseWHERE כאשר מתבצעים עדכונים או מחיקות רשומות כדי למנוע שינוי או הסרת כל השורות בטבלה. בלע-WHERE, הפקודה משפיעה על כל שורה בטבלה.

  • גיבוי: כדאי לגבות את מסד הנתונים שלך לפני ביצוע עדכונים או מחיקות, במיוחד בסביבות ייצור.

כיצד להשתמש בעסקאות

עסקה היא רצף של פעולות SQL אחת או יותר שמטופלות כיחידה אחת של עבודה. בהקשר של מסד נתונים, עסקה מאפשרת לך לבצע מספר פעולות שאם יצליחו כולן או שלא תצליח אף אחת מהן. זה מבטיח שהמסד נתונים שלך יישאר במצב עקבי, גם בפני שגיאות או בעיות בלתי צפויות.

לדוגמה, אם אתה מעביר כסף בין שני חשבונות בנק, אתה רוצה שהחיוב מחשבון אחד והזיכוי לשני יצליחו או יכשלו יחד. אם פעולה אחת נכשלת, השנייה לא צריכה להתבצע כדי לשמור על עיקריות.

למה להשתמש בעסקאות?

  1. אטומיות: עסקאות מבטיחות שסדרת פעולות תתוות אחת. אם פעולה אחת נכשלת, אף אחת מהפעולות לא תיושם על מסד הנתונים.

  2. עקביות: עסקאות עוזרות לשמור על תקינות המסד נתונים על ידי הבטחה שכל החוקים והאילוצים יתקיימו.

  3. בידוד: כל עסקה פועלת באופן עצמאי ללא השפעה בלתי רצויה מעסקאות אחרות.

  4. קיימות: לאחר שעסקה מוצלחת, השינויים הם קבועים, גם במקרה של כשל במערכת.

מתי להשתמש בעסקאות?

עליך להשתמש בעסקאות כאשר:

  • ביצוע מספר פעולות קשורות שחייבות להצליח או לנכשל ביחד.

  • שינוי נתונים קריטיים שדורשים עקביות ותקינות.

  • עבודה עם פעולות שיכולות להיכשל, כמו עסקאות פיננסיות או העברת נתונים.

איך לנהל עסקאות בפייתון

ב-SQLite, עסקאות מנוהלות באמצעות הפקודות BEGIN, COMMIT, ו-ROLLBACK. עם זאת, כאשר משתמשים במודול sqlite3 בפייתון, בדרך כלל מנהלים עסקאות באמצעות אובייקט הקשר.

התחלת עסקאה

עסקאה מתחילה באופן בלתי מודע כאשר מבצעים פקודת SQL. כדי להתחיל עסקאה באופן מודע, ניתן להשתמש בפקודה BEGIN:

cursor.execute("BEGIN;")

עם זאת, בדרך כלל איננה נחוצה להתחיל עסקאה באופן ידני, כיוון ש-SQLite מתחילה עסקאה אוטומטית כאשר מבצעים פקודת SQL.

איך להחזיר עסקאה

כדי לשמור את כל השינויים שנעשו במהלך העסקאה, ניתן להשתמש בשימוש בפעולה commit(). זה יגרום לכל השינויים להיות קבועים בבסיס הנתונים.

connection.commit()

כבר השתמשנו בפעולה commit() בדוגמאות שניתן למעלה.

ביטול עסקאה

אם משהו השתבש וברצונך להחזיר את השינויים שנעשו במהלך העסקאה, ניתן להשתמש בפעולה rollback(). זה יבטל את כל השינויים שנעשו מאז התחלת העסקאה.

connection.rollback()

דוג

כדי להדגים את השימוש בעיסקאות במקרה מעשי, ניצור טבלה חדשה בשם לקוחות כדי לנהל חשבונות לקוחות. בדוגמה הזו, נניח שלכל לקוח יש סבר. אנחנו נוסיף שני לקוחות לטבלה הזו ונבצע תעסוקה בעלי הכסף ביניהם.

ראשית, בואו ניצור את הטבלה לקוחות ונשלוח שני לקוחות:

import sqlite3

# יצירת הטבלה לקוחות והוספת שני לקוחות
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # יצירת טבלת לקוחות
    create_customers_table = '''
    CREATE TABLE IF NOT EXISTS Customers (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL UNIQUE,
        balance REAL NOT NULL
    );
    '''
    cursor.execute(create_customers_table)

    # הוספת שני לקוחות
    cursor.execute(
        "INSERT INTO Customers (name, balance) VALUES (?, ?);", ('Ashutosh', 100.0))
    cursor.execute(
        "INSERT INTO Customers (name, balance) VALUES (?, ?);", ('Krishna', 50.0))

    connection.commit()

עכשיו, בואו נבצע את תעסוקת ההעברה בין Ashutosh ו-Krishna:

import sqlite3


def transfer_funds(from_customer, to_customer, amount):
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        try:
            # התחלת עיסקה
            cursor.execute("BEGIN;")

            # הסרת סכם ממשליח
            cursor.execute(
                "UPDATE Customers SET balance = balance - ? WHERE name = ?;", (amount, from_customer))
            # הוספת סכם למקבל
            cursor.execute(
                "UPDATE Customers SET balance = balance + ? WHERE name = ?;", (amount, to_customer))

            # מחייה שינויים
            connection.commit()
            print(
                f"Transferred {amount} from {from_customer} to {to_customer}.")

        except Exception as e:
            # אם קרה שגיאה, ביטול עיסקה
            connection.rollback()
            print(f"Transaction failed: {e}")


# דוגמה לשימוש
transfer_funds('Ashutosh', 'Krishna', 80.0)

בדוגמה זו, ראשית יצרנו טבלת לקוחות והוספנו שני לקוחות, Ashutosh עם סך חשבון של ₹100 וKrishna עם סך חשבון של ₹50. אחר כך ביצענו שיתוף המזומן של ₹80 מAshutosh לKrishna. על ידי שימוש בעסקאות, אנחנו מוודאים שההוצאה מחשבון Ashutosh והקבלה לחשבון Krishna מבצעות כמות אטומית אחת, שומרים על היושרה של הנתונים במקרה של שגיאות כלשהן. אם השיתוף נכשל (לדוגמה, בגלל חסרון מזומן), העסקה תפנה חזרה, ושני החשבונות ישארו במצב מקוון.

איך לאופיין את הביצועים של SQLite בעזרת סינון

סינון הוא טכניקה חזקה שמשמשת בבנקים על מנת לשפר ביצועים השאלות. סינון הוא בעצם מבנה מידע שאחסן את המיקום של השורות בהתבסס על ערכים מסויימים לשיח, דומה לסינון שבספר עוזר לך למצוא מוצא מהר.

בלי סינון, SQLite צריך לסרוק את כל הטבלה שורה אחר שורה כדי למצוא את הנתונים הרלוונטיים, שזה נעשה בעי יעילות כשהנתונים נגדלים. על ידי שימוש בסינון, SQLite יכולה לקפץ ישר אל השורות הנחוצות, שיאט באופן משמעותי את ההבצע של השאלות.

איך למלא את הבסיס המידעי עם מידע מדומה

כדי לבדוק את ההשפעה של הסינון, צריך לקיים מאגר נתונים גדול. במקום להוסיף באופן ידני, נוכל להשתמש בספריית faker

נשתמש בשיטת executemany() כדי להכניס את הרשומות כפי שמופיע למטה:

import sqlite3
from faker import Faker

# אתחל את ספריית Faker
fake = Faker(['en_IN'])


def insert_fake_students(num_records):
    """Generate and insert fake student data into the Students table."""
    fake_data = [(fake.name(), fake.random_int(min=18, max=25),
                  fake.email()) for _ in range(num_records)]

    # השתמש ב-'with' כדי לנהל את חיבור בסיס הנתונים
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # הכנס נתונים מדומים לטבלת התלמידים
        cursor.executemany('''
        INSERT INTO Students (name, age, email) 
        VALUES (?, ?, ?);
        ''', fake_data)

        connection.commit()

    print(f"{num_records} fake student records inserted successfully.")


# הכנס 10,000 רשומות מדומות לטבלת התלמידים
insert_fake_students(10000)

בריצת סקריפט זה, 10,000 רשומות תלמיד מדומות יתווספו לטבלת Students. בקטע הבא, נשאל את מסד הנתונים ונשווה את ביצועי השאילתות עם ובלעדי אינדקסים.

כיצד לבצע שאילתות בלעדי אינדקסים

בקטע זה, נבצע שאילתה בטבלת Students בלעדי כל אינדקסים כדי לראות כיצד SQLite מבצע כאשר אין אופטימיזציות במקום. זה ישמש כבסיס להשוואת הביצועים כאשר נוסיף אינדקסים מאוחר יותר.

בלעדי אינדקסים, SQLite מבצע סריקה מלאה של הטבלה, כלומר עליו לבדוק כל שורה בטבלה כדי למצוא תוצאות תואמות. עבור קבוצות נתונים קטנות, זה ניתן לניהול, אך ככל שמספר הרשומות גדל, הזמן הנדרש לחיפוש עולה באופן דרמטי. נראה זאת בפעולה על ידי הרצת שאילתת SELECT בסיסית לחיפוש אחר תלמיד מסוים לפי שם ולמדוד כמה זמן זה לוקח.

לראשונה, נבצע שאילתה בטבלת Students על ידי חיפוש אחר תלמיד עם שם מסוים. נרשום את הזמן שנדרש לביצוע השאילתה באמצעות מודול הזמן של פייתון כדי למדוד את הביצועים.

import sqlite3
import time


def query_without_index(search_name):
    """Query the Students table by name without an index and measure the time taken."""

    # יצירת חיבור לבסיס נתונים בעזרת 'with'
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # מדדת זמן ההתחלה
        start_time = time.perf_counter_ns()

        # ביצוע שאלה SELECT כדי למצוא סטודנט לפי שם
        cursor.execute('''
        SELECT * FROM Students WHERE name = ?;
        ''', (search_name,))

        # משלוחה כל התוצאות (בעיקר יכול להיות רק אחת או כמה במעשה)
        results = cursor.fetchall()

        # מדדת זמן הסיום
        end_time = time.perf_counter_ns()

        # חישוב הזמן המסך
        elapsed_time = (end_time - start_time) / 1000

        # הצגת התוצאות והזמן הוצא
        print(f"Query completed in {elapsed_time:.5f} microseconds.")
        print("Results:", results)


# דוגמה: חיפוש סטודנט לפי שם
query_without_index('Ojasvi Dhawan')

הפיצות הזו:

Query completed in 1578.10000 microseconds.
Results: [(104, 'Ojasvi Dhawan', 21, '[email protected]')]

על ידי הרצת התסריט העליון, תראו כמה זמן נדרש לחיפוש בטבלת Students ללא מפתחים. לדוגמה, אם יש 10,000 רשימות בטבלה, השאלה עלולה לקחת 1000-2000 מיקרושניות תלוי בגודל הטבלה ובחומרה שלך. זה אולי לא נראה די איטי עבור קטע קטן, אבל הביצועים ירדו בעולם שלם כשיותר רשימות נוספות.

אנחנו משתמשים ב time.perf_counter_ns() כדי למדוד את הזמן של הביצוע של השאלה בננוסקלומים. השיטה הזו מאוד מדויקת לביצועים של זמן קטן. אנחנו ממהגרה את הזמן למיקרושניות (us) כדי לקבל קלט קל יותר.

הצגת התוכנית השאלה

כשמתמקדים בבסיסי נתונים, הבנה של איך ששאילתות מורצות יכולה לעזור לך לזהות תחנות תפוקה ולאופטימליזך את הקוד שלך. SQLite מספק כלי עזר שנקרא EXPLAIN QUERY PLAN, שמאפשר לך לנתח את השלבים שSQLite עושה כדי להשיג נתונים.

בחלק זה, נציג איך להשתמש ב- EXPLAIN QUERY PLAN כדי להדמיה ולהבין את המהלכים הפנימיים של שאילתה — במיוחד, איך SQLite מבצע סריקת שולחן מלא כאשר אין מדד.

בואו נשתמש ב- EXPLAIN QUERY PLAN כדי לראות איך SQLite משיג נתונים מהטבלה Students ללא כל מדדים. נחפש סטודנט בשם, ותוכנית השאילתה תגלה את השלבים שSQLite עושה כדי למצוא שורות התואמות.

import sqlite3


def explain_query(search_name):
    """Explain the query execution plan for a SELECT query without an index."""

    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # השתמש ב- EXPLAIN QUERY PLAN כדי לנתח איך השאילתה מורצת
        cursor.execute('''
        EXPLAIN QUERY PLAN
        SELECT * FROM Students WHERE name = ?;
        ''', (search_name,))

        # הביא והציג את תוכנית השאילתה
        query_plan = cursor.fetchall()

        print("Query Plan:")
        for step in query_plan:
            print(step)


# דוגמה: ניתוח תוכנית השאילתה לחיפוש לפי שם
explain_query('Ojasvi Dhawan')

כשתריץ את הקוד הזה, SQLite יחזיר פירוט של איך הוא מתכנן לרצת את השאילתה. הנה דוגמה של איך הפלט עשוי להיראות:

Query Plan:
(2, 0, 0, 'SCAN Students')

זה מראה ש SQLite עושה סריקת כל הטבלה Students (סריקת שולחן מלא) כדי למצוא כמה שורות שהעמודה name מתאימה לערך הספציפי (Ojasvi Dhawan). מאחר ואין מדד על העמודה name, SQLite חייב לבדוק כל שורה בטבלה.

איך ליצור מדד?

יצירת אינדקס על עמודה מאפשרת ל־SQLite למצוא רשומות במהירות רבה בזמן פעולות שאילתות. במקום לסרוק את כל הטבלה, SQLite יכול להשתמש באינדקס כדי לקפוץ ישירות לרשומות הרלוונטיות, מאיץ באופן משמעותי את השאילתות—במיוחד אלו המעורבות במערכות נתונים גדולות.

כדי ליצור אינדקס, יש להשתמש בפקודת SQL הבאה:

CREATE INDEX IF NOT EXISTS index-name ON table (column(s));

בדוגמה זו, ניצור אינדקס על העמודה name של הטבלה Students. הנה כיצד תוכלו לעשות זאת בעזרת Python:

import sqlite3
import time


def create_index():
    """Create an index on the name column of the Students table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # פקודת SQL ליצירת אינדקס על העמודה שם
        create_index_query = '''
        CREATE INDEX IF NOT EXISTS idx_name ON Students (name);
        '''

        # מדידת זמן התחלה
        start_time = time.perf_counter_ns()

        # ביצוע הפקודת SQL ליצירת האינדקס
        cursor.execute(create_index_query)

        # מדידת זמן התחלה
        end_time = time.perf_counter_ns()

        # הפעלת השינויים
        connection.commit()

        print("Index on 'name' column created successfully!")

        # חישוב הזמן הכולל
        elapsed_time = (end_time - start_time) / 1000

        # הצגת התוצאות והזמן שלקח
        print(f"Query completed in {elapsed_time:.5f} microseconds.")


# הפעלת הפונקציה ליצירת האינדקס
create_index()

Output:

Index on 'name' column created successfully!
Query completed in 102768.60000 microseconds.

למרות שיצירת האינדקס לוקחת זמן כזה (102768.6 מיקרושניות), זו פעולה חד-פעמית. עדיין תקבלו האצה גדולה כשתריצו שאילתות מרובות. בחלקים הבאים, נחזור לבצע שאילתות בבסיס הנתונים כדי לראות את השיפורים בביצועים שניתנו על-ידי האינדקס הזה.

איך לבצע שאילתות עם אינדקסים

בחלק זה, אנחנו נבצע את אותו הבקשה SELECT שביצענו קודם, אך הפעם נהנו מהשימוש בעמידה שנוצרה על עמוד הname של העמודה Students. אנחנו נמדד ונרשמ את זמני הביצוע כדי להבחין בשיפור הביצועים שמעניין את העמידה.

import sqlite3
import time


def query_with_index(student_name):
    """Query the Students table using an index on the name column."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # הוצאה לדוגמה של בקשה SQL לבחירת סטודנט על פי שם
        select_query = 'SELECT * FROM Students WHERE name = ?;'

        # מדדת הזמן לביצוע
        start_time = time.perf_counter_ns()  # התחלת המצלמה

        # ביצוע הבקשה עם השם הסטודנט המסוגל להיות נתנה
        cursor.execute(select_query, (student_name,))
        result = cursor.fetchall()  # אספת את כל התוצאות

        end_time = time.perf_counter_ns()  # סיום המצלמה

        # חישוב הזמן המבולגן במיקרושניות
        execution_time = (end_time - start_time) / 1000

        # הצגת התוצאות והזמן הביצוע
        print(f"Query result: {result}")
        print(f"Execution time with index: {execution_time:.5f} microseconds")


# דוגמה: חיפוש סטודנט על פי שם
query_with_index('Ojasvi Dhawan')

זה מה שאנחנו מקבלים בתוצאה:

Query result: [(104, 'Ojasvi Dhawan', 21, '[email protected]')]
Execution time with index: 390.70000 microseconds

אנחנו יכולים להבחין בירידה משמעותית בזמן הביצוע בהשוואה לבצע הבקשה בלי עמידה.

בואו ננתן אינטרפרציה לתוכנית הבקשה בבקשה עם העמידה על עמוד הname של העמודה Students. אם תבצעו את אותה התוכנית שוב על מנת הסבר הבקשה, תקבלו את התוצאות הבאות:

Query Plan:
(3, 0, 0, 'SEARCH Students USING INDEX idx_name (name=?)')

התוכנית הזו עכשיו מראה שהבקשה משתמשת בעמידה idx_name, שגורם לירידה משמעותית במספר השורות שצריך לסר

השוואה בין תוצאות הביצוע הפורמנטיביות

עכשיו, בואו נסכם את התוצאות הפורמנטיביות שהשגנו בזמן שאלות עם ובלי מפתחים.

השוואה בין הזמן הביצוע

סוג השאלה זמן הביצוע (מיקרושניות)
בלי מפתח 1578.1
עם מפתח 390.7

סכם השיפור בפורמנטיביות

  • השאלה עם מפתח היא בערך 4.04 פעמים מהרה מאשר השאלה בלי מפתח.

  • הזמן הביצוע השתפר בערך ב-75.24% אחרי הוספת המפתח.

מדידות טובה לשימוש במפתחים

מפתחים יכולים לשכפל באופן משמעותי את ביצועי הבסיס של בסיס הנתונים SQLite שלך, אך הם צריכים להיות משמשים בצדק. הנה כמה מהמדידות הטובות להיקשיב בעוד אתה עובד עם מפתחים:

מתי ומדוע להשתמש במפתחים

  1. עמודות קלט לשאילות פעמיות: השתמש במפתחים על עמודות שבהן מופץ הרבה בשאילות SELECT, בעיקר אלה שבהן משמשים בפירושים WHERE, JOIN, וORDER BY. מפתחים בעמודות אלה יכולים להפחית ב
  2. מגבלות ייחודיות: כשיש עמודות שחייבות להחזיק ערכים ייחודיים (כמו שם משתמש או כתוביות דוא״ל), יצירת אינדקס יכולה לאמץ בצורה יעילה את המגבלה הזו.
  3. מידע גדול: לטבלות עם מספר גדול של רשומים, האינדקסים נהיים יותר ויותר מועילים. הם מאפשרים חיפושים מהירים, שהם בעלי את החשיבות המיועדת עבור השימור בביצועים בעולם גדלה של המידע.
  4. אינדקסים מאוחדים: קחי בחשבון את יצירת אינ

ההיפotential Downsides of Indexes

על המדפים

  1. עידן אחרון אטי לשים/עדכון מידע: כשאתה מעדיף או מעדכן רשומים בטבלה עם מדפים, SQLite צריך גם לעדכן את המדף, שעלול להאט את הפעילויות האלה. זה מפני שלכל העדכון או השים חובה עליה נוספת כדי לשמר את מבנת המדף.
  2. דרישות אחסון גבוהות יותר: מדפים צורכים מקום דיסק נוסף. לטבלות גדולות, העלויות האחסוניות יכולות להיות substantial. קחי בחשבון את זה בזמן תכנון הסכמה המחשבת, בעיקר עבור מערכות עם משאבי אחסון מגבלים.

  3. ניהול מפתחות מורכב: יש להקפיד מאוד מכמות המפתחות במסד הנתונים כי הם יכולים לקשקש על תהליכי הניהול. ייתכן שיהיו פה מפתחות חוזרים שיכולים להזדקק על הביצועים במקום לשפרם. יש לבצע בדיקה ומיטוב תקופתיים של המפתחות שלך כדי לשפר את פעולות מסד הנתונים.

מפתחות הם כלי עוצמתי למיטוב שאילתות במסד הנתונים, אך הם דורשים תשומת לב רבה. למצוא איזון בין שיפור בביצועי קריאה והעומס האפשרי על פעולות כתיבה הוא מרכזי. הנה כמה אסטרטגיות להשגת האיזון הזה:

  • מעקב אחר ביצועי השאילתות: להשתמש ב־EXPLAIN QUERY PLAN של SQLite כדי לנתח איך השאילתות שלך מבצעות עם ובלעדיו של מפתחות. זה יכול לעזור לזהות אילו מפתחות הם מועילים ואילו עשויים להיות מיותרים.

  • תחזוקה רגילה: לבצע בדיקה תקופתית של המפתחות שלך ולהעריך אם הם עדיין נדרשים. להסיר מפתחות מיותרים או לא בשימוש כדי לקצר את פעולות מסד הנתונים שלך.

  • בדיקה והערכה: לפני שימוש באינדקסים בסביבה הפרודוקציונלית, ביצע בדיקות מאוד מפורטות כדי להבין את ההשפעה שלהם על הפעולות הקריאה והכתיבה.

על ידי עיצוב המידע הזה, ניתן להשתמש ביתרונות האינדקסים בעוד מינימizing הסיבוכים האפשריים, ולהגביר את הביצועים והיעילות של מאגר המידע SQLite שלך.

איך לטפל בשגיאות והערצות

במודול זה, נדבר על איך לטפל בשגיאות והערצות בעבודה עם SQLite בפיותרם. הטיפול המתאים בשגיאות הוא חשוב לשמירה על האורגניזציה של המאגר המידעי שלך ולוודא שהיישום שלך מתהגה בצורה צפויה.

שגיאות רגילות בעבודות SQLite

בזמן התנגדות למאגר המידע SQLite, עשויים להתרחש שגיאות רגילות:

  1. הפרעות משקל: זה מתרחש כש

  2. התאמות מנגד סוגי מידע: נסיון להכניס מידע של סוג שגוי (לדוגמה, הכניסה של סיסמא במקום בו צפוי מספר) עלול להוביל לשגיאה.

  3. שגיאות בגבי המאגר הנע锁: אם מאגר הנתונים מופעל על ידי תהליך אחר או חיבור אחר, הנסיון לגשת אליו יכול להוביל לשגיאה "המאגר נע锁".

  4. שגיאות בסינTAX של SQL: טעויות בסינTAX שלך של SQL יגיעו לשגיאות כשאתה מנסה לבצע את הפקודות שלך.

איך להשתמש במנג

במערכת Python, המנגנונים הבניינים של התייחסות להיותרותים (הבנים try וexcept) הם בסיסיים לניהול השגיאות בעבודות על SQLite. על ידי שימוש בבנים אלה, ניתן לעמוד בהיותרותים ולהגיב מתאימות בלי להתקוצץ את התוכנה.

הנה דוגמה בסיסית לאופן התייחסות לשגיאות בזמן הכניסה של מידע למאגר:

import sqlite3


def add_customer_with_error_handling(name, balance):
    """Add a new customer with error handling."""
    try:
        with sqlite3.connect('my_database.db') as connection:
            cursor = connection.cursor()
            cursor.execute(
                "INSERT INTO Customers (name, balance) VALUES (?, ?);", (name, balance))
            connection.commit()
            print(f"Added customer: {name} with balance: {balance}")

    except sqlite3.IntegrityError as e:
        print(f"Error: Integrity constraint violated - {e}")

    except sqlite3.OperationalError as e:
        print(f"Error: Operational issue - {e}")

    except Exception as e:
        print(f"An unexpected error occurred: {e}")


# השתמשות דוגמא
add_customer_with_error_handling('Vishakha', 100.0)  # חוקי
add_customer_with_error_handling('Vishakha', 150.0)  # כניסה מקבלת

בדוגמה זו:

  • אנחנו מוצאים IntegrityError, שמועלה עבור הפרכים כמו הגבלות ייחודיות.

  • אנחנו מוצאים OperationalError עבור בעיות דרך אגב שקשורות למאגר (כמו שגיאות על המאגר נעול).

  • גם יש לנו בלוק כללי except במטרה לטפל בהיותרותים בלתי צפויים.

היוצא:

Added customer: Vishakha with balance: 100.0
Error: Integrity constraint violated - UNIQUE constraint failed: Customers.name

מערכות מיטבים לבטיחת יושרת המאגר.

  1. השתמש בעסקאות: תמיד השתמש בעסקאות (כפי שנדון בקטע הקודם) כאשר מבצעים פעולות מרובות הקשורות אחת לשנייה. זה יסייע לוודא שאו כל הפעולות יצליחו או כלום, מתחזק את ההתאמה.

  2. אמת נתוני קלט: לפני ביצוע פקודות SQL, אמת את נתוני הקלט כדי לוודא שהם עומדים בקריטריונים המצופים (לדוגמה, סוגים נכונים, בטווחים המותרים).

  3. לכוד שגיאות ספציפיות: תמיד לכוד שגיאות ספציפיות כדי לטפל בצורה תקינה בסוגים שונים של שגיאות. זה מאפשר טיפול בשגיאות ותיקונן מובנה יותר.

  4. רשום שגיאות: במקום להדפיס רק שגיאות למסוף, שקול לרשום אותן לקובץ או למערכת מעקב. זה יעזור לך לעקוב אחרי בעיות בפרודקשן.

  5. התדרדרות חסרת תפאורה: עיצוב האפליקציה שלך כך שתטפל בשגיאות בצורה חסרת תפאורה. אם פעולה נכשלת, ספק משוב משמעותי למשתמש במקום להתרסק האפליקציה.

  6. גיבוי נתונים באופן קבוע: גבה את מסד הנתונים שלך באופן קבוע כדי למנוע אובדן נתונים במקרה של כשלים קריטיים או פגיעות.

  7. שימוש בהצהרות מוכנות: הצהרות מוכנות עוזרות למנוע התקפות חדירת SQL ויכולות גם לספק ביצועים טובים יותר עבור שאילתות חוזרות.

כיצד לייצא ולייבא נתונים [חלק בונוס]

בחלק זה, נלמד כיצד לייצא נתונים ממסד נתונים של SQLite לפורמטים נפוצים כמו CSV ו-JSON, וכן כיצד לייבא נתונים ל-SQLite מתוך פורמטים אלה באמצעות Python. זה מועיל לשיתוף נתונים, גיבוי ואינטגרציה עם אפליקציות אחרות.

ייצוא נתונים מ-SQLite ל-CSV

ייצוא נתונים לקובץ CSV (ערכים מופרדים בפסיק) הוא פשוט בעזרת ספריות המובנות של Python. קבצי CSV משמשים בצורה רחבה לאחסון נתונים והחלפה, מה שהופך אותם לפורמט נוח לייצוא נתונים.

כך אתה מייצא מידע משולשת SQLite לקובץ CSV:

import sqlite3
import csv

def export_to_csv(file_name):
    """Export data from the Customers table to a CSV file."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # בואו בפעולה שאלה כדי לשלוף את כל מידע הלקוחות
        cursor.execute("SELECT * FROM Customers;")
        customers = cursor.fetchall()

        # כתוב מידע לקובץ CSV
        with open(file_name, 'w', newline='') as csv_file:
            csv_writer = csv.writer(csv_file)
            csv_writer.writerow(['ID', 'Name', 'Balance'])  # כתוב הראשים
            csv_writer.writerows(customers)  # כתוב שורות המידע

        print(f"Data exported successfully to {file_name}.")

# השתמשות דוגמה
export_to_csv('customers.csv')

איך לייצא מידע לJSON

בדומה, אתה יכול לייצא מידע לקובץ JSON (תבנית ערימות ג 'יפוס בעלת שם מועילה בשימושים מקוריים, בעיקר ביישומים רשתיים.

הנה דוגמה אחת לאופן בו אתה מייצא מידע לJSON:

import json
import sqlite3


def export_to_json(file_name):
    """Export data from the Customers table to a JSON file."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # בואו בפעולה שאלה כדי לשלוף את כל מידע הלקוחות
        cursor.execute("SELECT * FROM Customers;")
        customers = cursor.fetchall()

        # הממלא מידע לרשימה של מילונים
        customers_list = [{'ID': customer[0], 'Name': customer[1],
                           'Balance': customer[2]} for customer in customers]

        # כתוב מידע לJSON
        with open(file_name, 'w') as json_file:
            json.dump(customers_list, json_file, indent=4)

        print(f"Data exported successfully to {file_name}.")


# השתמשות דוגמה
export_to_json('customers.json')

איך לייבד מידע לSQLite מקובץ CSV

אתה גם יכול לייבד מידע מקובץ CSV אל בסיס מידע SQLite. זה שימושי בשביל להאריך את הבסיס המידעי שלך עם מערכות מידע קיימות.

הנה איך לייבד מידע מקובץ CSV:

import csv
import sqlite3


def import_from_csv(file_name):
    """Import data from a CSV file into the Customers table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        פתח את הקובץ CSV עבור קריאה
        with open(file_name, 'r') as csv_file:
            csv_reader = csv.reader(csv_file)
            next(csv_reader)  העבר על השורה הראשונה בראשן

            הכנס כל שורה אחת לטבלת לקוחות
            for row in csv_reader:
                cursor.execute(
                    "INSERT INTO Customers (name, balance) VALUES (?, ?);", (row[1], row[2]))

        connection.commit()
        print(f"Data imported successfully from {file_name}.")


השימוש מודל למשמעות
import_from_csv('customer_data.csv')

איך ליבד מידע אל תוך SQLite מקובץ JSON

באופן דומה, יבדול מידע מקובץ JSON הוא פשוט. ניתן לקרוא את הקובץ JSON ולהכניס את המידע לטבלה שלך בSQLite.

וזו הדרך בה לעשות את זה:

import json
import sqlite3


def import_from_json(file_name):
    """Import data from a JSON file into the Customers table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        פתח את הקובץ JSON עבור קריאה
        with open(file_name, 'r') as json_file:
            customers_list = json.load(json_file)

            הכנס כל לקוח אחד לטבלת לקוחות
            for customer in customers_list:
                cursor.execute("INSERT INTO Customers (name, balance) VALUES (?, ?);", (customer['Name'], customer['Balance']))

        connection.commit()
        print(f"Data imported successfully from {file_name}.")


השימוש מודל למשמעות
import_from_json('customer_data.json')

סיימת המאמר

וזה סיים! המדריך הזה הציג את היסודות של עבודה עם SQLite בPython, כולל הכנת הסביבה שלך עד לבחינה ושינוי המידע, בנוסף לייצוא והיבט במידע. אני מקווה שמצאת את זה מועיל ושזה די הדהים את העניין בשימוש בSQLite בפרוייקטים שלך.

עכשיו הגיע הזמן להשתמש בידע החדש שלך! אני מעודד אתך ליצור את הפרוייקט שלך בעזרת SQLite וPython. בין אם זה יותר אפליקציה פשוטה לניהול ספרייך, כלי בינה תקציבי, או משהו ייחודי, האפשרויות נטולות גבולות.

אחרי שביצעת את הפרוייקט שלך, חלק אותו בטוויטר ותתגייה אלי! אני רוצה לראות מה יצרת, ולחגג את ההישגים שלך

אתם יכולים למצוא את כל הקוד מהטוריאלור הזה על GitHub. תודה שעקבתם אחר אחד, ושימו שמח בכיתוב!

ייצרו תור תוכן למאמרים שלכם ב טולדור של תורים בחינם.