דלג לתוכן
נושאים
  • 1 בסיסי שאילתות
    1.1

    SELECT ו-FROM

    מאגר נתונים שומר נתונים בטבלאות. שאילתה קוראת נתונים באמצעות SELECT. SELECT * מחזירה את כל העמודות; FROM מציין את שם הטבלה.

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
    SELECT * FROM student;
    
    טבלה מאחסנת רשומות: כל שורה היא רשומה אחת, כל עמודה היא שדה אחד
    טבלה מאחסנת רשומות: כל שורה היא רשומה אחת, כל עמודה היא שדה אחד
    • כל שורה היא רשומה אחת. מילות מפתח SQL נכתבות באותיות גדולות לפי הרגל.
    • הוראה מסתיימת בסימן נקודה-פסיק ;.
    1.2

    בחירת עמודות

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

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
    SELECT name, score AS mark FROM student;
    

    עמודה שנבחרה יכולה להיות גם חישוב — הצמד אותה ל-AS כדי לקרוא לעמודה החדשה:

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
    SELECT name, score + 5 AS bonus FROM student;
    
    • SELECT DISTINCT col מסיר ערכים כפולים מהתוצאה.
    1.3

    סינון עם WHERE

    WHERE משאיר רק שורות העונים לתנאי. השווה ל-=, <> (לא שווה), <, >, <=, >=. כתוב טקסט בתוך סימני ציטוט יחידים.

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71), (3, 'Ana', 95);
    SELECT name, score FROM student WHERE score >= 80;
    
    • קרא את החלקים בסדר הלוגי הזה: FROM → WHERE → SELECT. (המסד יעשוי לבצע את העבודה בצורה שונה, אך התוצאה זהה.)

    שגיאות נפוצות

    • כתוב ערכי טקסט בתוך סימני ציטוט יחידים: WHERE name = 'Ann'; שמות עמודות אינם זקוקים לסימנים.
    • SELECT * מחזיר כל עמודה — ציין רק את העמודות שהן נחוצות לך.
    • WHERE מסנן שורות; הוא בא לאחר FROM.
  • 2 סינון ולוגיקה
    2.1

    AND, OR, NOT

    שלב תנאים ב-AND, OR, NOT. AND דורש שהכל יהיה אמת; OR דורש שרק אחד יהיה אמת; NOT הופך אחד. השתמש בסוגריים כדי לקבוע עדיפות.

    CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
    INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
    SELECT name FROM student WHERE form = '11A' AND score >= 90;
    
    AND דורש שהכל יהיה אמת; OR דורש שאחד יהיה אמת; NOT הופך אחד
    AND דורש שהכל יהיה אמת; OR דורש שאחד יהיה אמת; NOT הופך אחד
    2.2

    LIKE, IN ו-BETWEEN

    LIKE תואם דפוס של טקסט: % מייצג כל טקסט ו-_ מייצג תווה אחד — אלו הם פסי תווים (wildcards).

    CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
    INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
    SELECT name FROM student WHERE name LIKE 'M%';        -- starts with M
    
    דפוס תואם
    'M%' מתחיל ב-M
    '%a' מסתיים ב-a
    '%an%' מכיל "an"
    'M_i' M, ולאחריו בדיוק תווה אחד, ואז i

    IN תואם קבוצה של ערכים; BETWEEN תואם טווח (שתי הקצוות כלולות).

    CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
    INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
    SELECT name, score FROM student
    WHERE form IN ('11A', '11C') AND score BETWEEN 80 AND 100;
    
    2.3

    NULL

    NULL מסמן ערך חסר — לא נשמר כל דבר בתא זה. NULL אינו 0 ואינו מחרוזת ריקה. השוואה ל-= או ל-<> לעולם לא תתאים לו; בדיקה יש לבצע עם IS NULL או IS NOT NULL.

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', NULL), (3, 'Ana', 95);
    SELECT name FROM student WHERE score IS NULL;
    
    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', NULL), (3, 'Ana', 95);
    SELECT name, score FROM student WHERE score IS NOT NULL;
    
    • WHERE score = NULL מחזירה אף שורה כלל — גם לא את שורת סם.
    • NULL באריתמטיקה נותן NULL: score + 5 נשאר NULL עבור סם.

    שגיאות נפוצות

    • בדוק ערך ריק עם IS NULL, לעולם אל תשתמש ב-= NULL.
    • ב-LIKE, % מתאים לכל טקסט ו-_ מתאים לאות אחת: 'A%' פירושו "מתחיל ב-A".
    • IN (1, 2, 3) קצר ממספר ORs; BETWEEN a AND b כולל את שני הקצוות.
  • 3 מיון והגבלה
    3.1

    ORDER BY ו-LIMIT

    ORDER BY ממיינת את שורות התוצאה. הוספת DESC תסדר יורד (גבוה לנמוך); ברירת המחדל היא עולה (נמוך לגבוה).

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',71),(3,'Ana',95);
    SELECT name, score FROM student ORDER BY score DESC;
    

    סידור לפי יותר מעמודה אחת

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

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',88),(3,'Ana',95);
    SELECT name, score FROM student ORDER BY score DESC, name ASC;
    

    LIMIT (N העליונים)

    LIMIT n משארת רק את n השורות הראשונות — שלב אותה עם ORDER BY ליצירת רשימת N העליונים.

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',71),(3,'Ana',95);
    SELECT name, score FROM student ORDER BY score DESC LIMIT 2;
    
    • ORDER BY יכול גם למיין לפי כינוי או חישוב: ORDER BY avg_score DESC.
    • טקסט ממוין אלפביתית: ORDER BY name מריץ A → Z.

    שגיאות נפוצות

    • ORDER BY ממיין ברירת מחדל עולה; הוספת DESC תסדר יורד.
    • ORDER BY נמצא בסוף, לאחר WHERE ו-GROUP BY.
    • LIMIT מגבילה את מספר השורות החוזרות, אך רק לאחר הסידור.
    ORDER BY סודה; LIMIT משארת את n הראשונים לאחר סידור
    ORDER BY סודה; LIMIT משארת את n הראשונים לאחר סידור
  • 4 צבירה וקבוצה
    4.1

    פונקציות אגרוגט

    פונקציית סיכום ממירה שורות רבים לערך סיכום אחד. עטוף ממוצע בROUND(x, 2) כדי לסדר אותו.

    פונקציה נותנת
    COUNT(*) כמה שורות יש
    SUM(col) הסכום הכולל
    AVG(col) הממוצע האריטמטי
    MIN(col) / MAX(col) הערך הקטן ביותר / הגדול ביותר
    CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
    INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
    SELECT COUNT(*), ROUND(AVG(score), 2), MAX(score) FROM student;
    
    4.2

    קבוצה לפי (GROUP BY) וסינון (HAVING)

    GROUP BY יוצר שורת סיכום אחת לכל קבוצה. HAVING מסנן את הקבוצות הללו — זהו כמו WHERE, אך הוא מתבצע לאחר הקבוצה.

    CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
    INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
    SELECT form, COUNT(*) AS n, ROUND(AVG(score), 2) AS avg_score
    FROM student
    GROUP BY form
    HAVING COUNT(*) > 1;
    
    GROUP BY אוסף שורות לתוך מיכל אחד עבור כל ערך; כל מיכל הופך לשורת סיכום אחת
    GROUP BY אוסף שורות לתוך מיכל אחד עבור כל ערך; כל מיכל הופך לשורת סיכום אחת

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

    שלב סעיף
    1 FROM (וגם כל JOIN)
    2 WHERE — סינון שורות
    3 GROUP BY — יצירת קבוצות
    4 HAVING — סינון קבוצות
    5 SELECT — חישוב עמודות התוצאה
    6 ORDER BY, ולאחר מכן LIMIT

    שגיאות נפוצות

    • לתוצאות מקבוצות צפויות, קבץ כל עמודה נבחרת שאינה אגרגט (או השתמש בתלות פונקציונלית ידועה התומכת במאגר). SQLite מאפשר עמודה חשופה מחוץ לGROUP BY, אך היא עשויה לבוא משורה אקראית בקבוצה; שאילתה מוצלחת אינה מבטיחה את הערך שרצית.
    • סנן שורות עם WHERE (לפני הקבוצה) וסנן קבוצות עם HAVING (אחרי).
    • COUNT(*) סופר שורות; COUNT(col) דורש NULLים בעמודה זו.
  • 5 חיבורים (Joins)
    5.1

    מפתחות ויחסים

    מפתח ראשי (primary key) מזוהה באופן ייחודי כל שורה בטבלה. מפתח זר (foreign key) בטבלה אחת מצביע למפתח הראשי בטבלה אחרת — הדבר בונה קשר ביניהן.

    CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
    CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
    INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
    INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2);
    SELECT * FROM student;
    
    5.2

    INNER JOIN

    חיבור (join) משלב שורות משתי טבלות. INNER JOIN ... ON ... שומר רק שורות בהן המפתחות תואמים. כינוי קצר (s, c) שומר על קריאות השאלה.

    CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
    CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
    INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
    INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2);
    SELECT s.name, c.name AS class
    FROM student s INNER JOIN class c ON s.class_id = c.id;
    
    INNER JOIN מתאים כל מפתח זר למפתח ראוי ומשלב את השורות התואמות
    INNER JOIN מתאים כל מפתח זר למפתח ראשי ומשלב את השורות התואמות
    5.3

    חיבור עם קבוצה

    חבר תחילה, ואז GROUP BY לסיכום לאורך השורות המחוברות.

    CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
    CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
    INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
    INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2), (3, 'Ana', 1);
    SELECT c.name AS class, COUNT(*) AS n
    FROM student s INNER JOIN class c ON s.class_id = c.id
    GROUP BY c.id, c.name;
    

    להתאגד לפי המקל c.id גם יחד עם השם: שתי כיתות שמקריא לשם זה יתמזגו אחרת לשורה אחת.

    5.4

    LEFT JOIN

    חיבור INNER JOIN שומר רק שורות תואמות. חיבור LEFT JOIN שומר על כל השורות בטבלה השמאלית (הראשונה); במקרה שאין התאמה, עמודות הטבלה הימנית חוזרות כ-NULL.

    CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
    CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
    INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
    INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', NULL);
    SELECT s.name, c.name AS class
    FROM student s LEFT JOIN class c ON s.class_id = c.id;
    
    • לסם אין שיעור, אך השורה עדיין מופיעה — עם class כNULL.
    • למצוא רק את השורות שאינן תואמות, הוסף WHERE c.id IS NULL.

    שגיאות נפוצות

    • חיבור ללא תנאי ON זוגי כל שורה לכל שורה (cross join).
    • התאם את המפתח הזר למפתח הראשי: ON orders.customer_id = customers.id.
    • INNER JOIN מוריד שורות שאין להן התא בצד השני; השתמש ב-LEFT JOIN כדי לשמר אותן.
  • 6 שינוי נתונים
    6.1

    הכנסה

    INSERT INTO ... VALUES ... מוסיף שורות חדשות. ציין את העמודות, ולאחר מכן את הערכים באותו סדר. (כל בלוק למטה מסתיים ב-SELECT כך שתוכל לראות את התוצאה.)

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student (id, name, score) VALUES (1, 'Mei', 88);
    INSERT INTO student VALUES (2, 'Sam', 71);
    SELECT * FROM student;
    
    • INSERT INTO t VALUES (...), (...); מוסיף מספר שורות במשמר אחד.
    INSERT מוסיף שורה חדשה לטבלה
    INSERT מוסיף שורה חדשה לטבלה
    6.2

    UPDATE

    UPDATE ... SET ... WHERE ... משנה שורות קיימות. תמיד יש להוסיף WHERE, אחרת כל השורות ישתנו.

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
    UPDATE student SET score = 75 WHERE name = 'Sam';
    SELECT * FROM student;
    
    6.3

    DELETE

    DELETE FROM ... WHERE ... מחק שורות. ללא WHERE הוא ריק את כל הטבלה.

    CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
    INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
    DELETE FROM student WHERE score < 80;
    SELECT * FROM student;
    

    שגיאות נפוצות

    • UPDATE ו-DELETE ללא WHERE משנים כל שורה — תמיד יש להוסיף את הWHERE.
    • ב-INSERT, הערכים חייבים להיות מסודרים לפי רשימת העמודות בסדר ובסוג נתונים מתאים.
    • בדוק פקודה DELETE סיכוןית תחילה כ-SELECT עם אותו WHERE.
  • 7 הגדרת טבלאות
    7.1

    CREATE TABLE & סוגי נתונים

    CREATE TABLE מגדיר סכמת טבלה: שמות העמודות וסוגי הנתונים שלהם. סוגי הנתונים העיקריים ב-SQLite הם INTEGER, TEXT, וREAL (מספר עם נקודה צפה: מהיר, אך לא תמיד מדויק, ולכן 0.1 + 0.2 = 0.3 שגוי).

    CREATE TABLE student (id INTEGER, name TEXT, score REAL);
    INSERT INTO student VALUES (1, 'Mei', 88.5);
    SELECT * FROM student;
    
    CREATE TABLE שם עמודות וסוגי נתונים
    CREATE TABLE שם עמודות וסוגי נתונים
    7.2

    מקראות ומגבלות

    מגבלה היא חוק על עמודה: PRIMARY KEY (מזהה ייחודי), NOT NULL (חייב לעבור ערך), UNIQUE, ו-DEFAULT (ערך ברירת מחדל).

    CREATE TABLE student (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        score INTEGER DEFAULT 0
    );
    INSERT INTO student (id, name) VALUES (1, 'Mei');
    SELECT * FROM student;
    

    הגדר מקור זר עם REFERENCES. ב-SQLite, הפעל אכיפה לכל חיבור עם PRAGMA foreign_keys = ON; לפני תחילת עסקה. הכרזה לבדה אינה מבטיחה אכיפה.

    PRAGMA foreign_keys = ON;
    CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
    CREATE TABLE student (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        class_id INTEGER REFERENCES class(id)
    );
    INSERT INTO class VALUES (1, 'Maths');
    INSERT INTO student VALUES (1, 'Mei', 1);
    SELECT s.name, c.name AS class
    FROM student s INNER JOIN class c ON s.class_id = c.id;
    
    • הצורה הארוכה היא FOREIGN KEY (class_id) REFERENCES class(id) בשורה עצמאית.
    7.3

    ALTER TABLE

    ALTER TABLE ... ADD COLUMN ... משנה את הסכמה של טבלה קיימת. ערך DEFAULT ממלא את העמודה החדשה בשורות הישנות.

    CREATE TABLE student (id INTEGER, name TEXT);
    INSERT INTO student VALUES (1, 'Mei');
    ALTER TABLE student ADD COLUMN score INTEGER DEFAULT 0;
    SELECT * FROM student;
    
    • ALTER TABLE student RENAME TO pupil; משנה את שם כל הטבלה.
    • DROP TABLE student; מחק את הטבלה לחלוטין — המבנה וגם הנתונים.

    שגיאות נפוצות

    • הכרז סוג מתאים לכל עמודה. SQLite מאפשר שמות סוגים מושמטים ומשתמש בדרך כלל בסוגים גמישים; הכרז סוג לבדה אינה מאמת כל ערך מאוחסן.
    • Design a primary key to be unique and non-NULL. In ordinary SQLite tables, some primary-key declarations still permit NULL; use NOT NULL explicitly for a text key. INTEGER PRIMARY KEY has special row-id behavior: inserting NULL allocates an integer id.
    • כאשר אכיפת מקור זר מופעלת, ערך מקור זר שאינו NULL חייב להתאים למקור המיועד. NULL מותר אלא אם העמודה גם היא מחזיקה בNOT NULL.
  • 8 עיצוב מסדי נתונים
    8.1

    קשרים ותרגילי ER

    טבלות מחוברות דרך קשרים. קשר אחד-לרבים הוא הנפוץ ביותר: כיתה אחת מכילה תלמידים רבים. קשר רבים-לרבים דורש טבלת חיבור באמצע. דיאגרמת אובייקט-קשר (ER diagram) מציירת כל אובייקט כתיבה וכל קשר כקו.

    קשר דוגמה
    אחד-לאחד אדם והדרכון שלו
    אחד-לרבים כיתה ותלמידיה
    רבים-לרבים תלמידים ומועדונים
    הצד "רבים" מכיל את המפתח הזר; קשר רבים-לרבים דורש טבלת חיבור
    הצד "רבים" מכיל את המפתח הזר; קשר רבים-לרבים דורש טבלת חיבור

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

    CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT);
    CREATE TABLE club (id INTEGER PRIMARY KEY, name TEXT);
    CREATE TABLE membership (
      student_id INTEGER NOT NULL REFERENCES student(id),
      club_id INTEGER NOT NULL REFERENCES club(id),
      PRIMARY KEY (student_id, club_id)
    );
    INSERT INTO student VALUES (1, 'Mei'), (2, 'Sam');
    INSERT INTO club VALUES (1, 'Chess'), (2, 'Art');
    INSERT INTO membership VALUES (1, 1), (1, 2), (2, 1);
    SELECT s.name, c.name AS club
    FROM membership m
    INNER JOIN student s ON m.student_id = s.id
    INNER JOIN club c ON m.club_id = c.id;
    
    8.2

    נורמליזציה

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

    • 1NF: כל תא מכיל ערך אטומי בלבד — אין רשימות בתוך תא.
    • 2NF: אין עמודה שתלויה רק בחלק ממפתח מורכב.
    • 3NF: אין עמודה שתלויה בעמודה אחרת שאינה מפתח.
    לא נורמלי (גרוע) נורמלי (טוב יותר)
    student(name, club1, club2) student(name) + membership(student, club)

    שגיאות נפוצות

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

היכנס או צור חשבון

IGCSE, A-Level & AP