מה זה SQL: טבלאות, שאילתות ומה באמת קורה כשמריצים SELECT

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

במאמר הזה נבנה בסיס מעשי: מהי טבלה, מהי שאילתה, איך נראית פקודת SELECT, מה קורה מאחורי הקלעים, ואיך מתרגלים את זה בלי להתקין שרת מסד נתונים כבד. נשתמש ב־sqlite3, ספרייה שמגיעה עם Python 3, כך שאפשר להריץ את הדוגמאות מקובץ רגיל במחשב.

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

מה צריך להכין מראש

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

• Python 3 מותקן במחשב.
• עורך טקסט פשוט או סביבת פיתוח.
• טרמינל: Linux/macOS עם bash, או Windows עם PowerShell.
• כמה דקות להריץ דוגמאות ולשנות אותן.

בדקו ש־Python זמין:

python3 --version

ב־Windows ייתכן שהפקודה תהיה:

py --version

כל הדוגמאות בהמשך הן קבצי Python מלאים. ב־Linux/macOS מריצים עם python3 file.py. ב־Windows אפשר להריץ עם py file.py.

מה זה SQL בפועל: שפה לטבלאות, לא לגיליונות

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

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

SQL היא לא שפה שבה אומרים “לך שורה־שורה ותעשה כך”. בדרך כלל היא שפה הצהרתית: כותבים איזה מידע רוצים, למשל “תן לי את שמות המשתמשים שנרשמו אחרי תאריך מסוים”, ומנוע מסד הנתונים בוחר את הדרך המתאימה לשלוף אותו.

דוגמה ראשונה: יצירת טבלה והרצת SELECT

ניצור מסד נתונים בזיכרון, נוסיף אליו טבלת משתמשים, נכניס שלוש שורות ונריץ SELECT. שמרו את הקוד בקובץ בשם sql_intro.py.

import sqlite3

# Create an in-memory database
connection = sqlite3.connect(":memory:")
cursor = connection.cursor()

# Create a table
cursor.execute("""
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT NOT NULL UNIQUE
)
""")

# Insert rows
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Dana", "[email protected]"))
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Noam", "[email protected]"))
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Maya", "[email protected]"))

# Read rows
cursor.execute("SELECT id, name, email FROM users")
rows = cursor.fetchall()

for row in rows:
    print(row)

connection.close()

הרצה ב־Linux/macOS:

python3 sql_intro.py

פלט צפוי:

(1, 'Dana', '[email protected]')
(2, 'Noam', '[email protected]')
(3, 'Maya', '[email protected]')

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

מבנה בסיסי של SELECT

פקודת SELECT יכולה להיות פשוטה מאוד, אבל גם עשירה. המבנה הנפוץ נראה כך:

SELECT column_name
FROM table_name
WHERE condition
ORDER BY column_name
LIMIT number

החלקים החשובים:

• SELECT — אילו עמודות להחזיר.
• FROM — מאיזו טבלה לקרוא.
• WHERE — אילו שורות לסנן.
• ORDER BY — איך למיין את התוצאה.
• LIMIT — כמה שורות להחזיר לכל היותר.

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

מה קורה כשמריצים SELECT מאחורי הקלעים

כשמריצים SELECT, מסד הנתונים לא פשוט “מדפיס את הטבלה”. הוא עובר כמה שלבים לוגיים:

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

סינון, מיון ופרמטרים: הדוגמה הכי שימושית ביומיום

ברוב הקוד שנכתוב, לא נרצה את כל הטבלה. נרצה שורות שמתאימות לתנאי. לדוגמה: משתמשים שהשם שלהם מתחיל באות מסוימת, או הזמנות מעל סכום מסוים. הנה דוגמה מלאה עם WHERE, ORDER BY ו־LIMIT.

import sqlite3

# Create an in-memory database
connection = sqlite3.connect(":memory:")
cursor = connection.cursor()

cursor.execute("""
CREATE TABLE books (
    id INTEGER PRIMARY KEY,
    title TEXT NOT NULL,
    author TEXT NOT NULL,
    pages INTEGER NOT NULL
)
""")

books = [
    ("Small Systems", "Dana", 180),
    ("Learning SQL", "Noam", 260),
    ("Python Notes", "Maya", 220),
    ("Data Basics", "Dana", 140),
]

cursor.executemany(
    "INSERT INTO books (title, author, pages) VALUES (?, ?, ?)",
    books
)

minimum_pages = 200

cursor.execute("""
SELECT title, author, pages
FROM books
WHERE pages >= ?
ORDER BY pages DESC
LIMIT 2
""", (minimum_pages,))

for title, author, pages in cursor.fetchall():
    print(f"{title} by {author}: {pages} pages")

connection.close()

פלט צפוי:

Learning SQL by Noam: 260 pages
Python Notes by Maya: 220 pages

הערך minimum_pages מועבר כפרמטר. שימו לב לפסיק ב־(minimum_pages,): ב־Python זו הדרך ליצור tuple עם איבר אחד. בלי הפסיק, זה לא יהיה tuple, ועלולה להופיע שגיאת bindings.

קשרים בין טבלאות: למה לא לשמור הכול בטבלה אחת

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

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

JOIN: חיבור מידע מכמה טבלאות

כדי לקרוא מידע משתי טבלאות יחד משתמשים ב־JOIN. הנה דוגמה מלאה:

import sqlite3

# Create an in-memory database
connection = sqlite3.connect(":memory:")
cursor = connection.cursor()

cursor.execute("""
CREATE TABLE customers (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL
)
""")

cursor.execute("""
CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer_id INTEGER NOT NULL,
    total INTEGER NOT NULL,
    FOREIGN KEY (customer_id) REFERENCES customers(id)
)
""")

cursor.executemany(
    "INSERT INTO customers (name) VALUES (?)",
    [("Dana",), ("Noam",), ("Maya",)]
)

cursor.executemany(
    "INSERT INTO orders (customer_id, total) VALUES (?, ?)",
    [(1, 120), (1, 80), (2, 200)]
)

cursor.execute("""
SELECT customers.name, COUNT(orders.id) AS order_count, COALESCE(SUM(orders.total), 0) AS total_spent
FROM customers
LEFT JOIN orders ON orders.customer_id = customers.id
GROUP BY customers.id, customers.name
ORDER BY total_spent DESC
""")

for name, order_count, total_spent in cursor.fetchall():
    print(f"{name}: {order_count} orders, total {total_spent}")

connection.close()

פלט צפוי:

Noam: 1 orders, total 200
Dana: 2 orders, total 200
Maya: 0 orders, total 0

השתמשנו כאן ב־LEFT JOIN כדי לקבל גם לקוחות שאין להם הזמנות. בלי זה, Maya לא הייתה מופיעה בתוצאה. הפונקציה COALESCE מחזירה ערך חלופי כאשר הביטוי הוא NULL; במקרה שלנו, סכום ההזמנות של לקוח בלי הזמנות הוא NULL, ואנחנו מציגים 0.

NULL הוא לא אפס ולא מחרוזת ריקה

NULL הוא אחד הדברים שמבלבלים מפתחים בתחילת הדרך. הוא לא 0, לא false, ולא טקסט ריק. הוא מייצג “אין ערך ידוע”. לכן השוואות רגילות לא תמיד עובדות כפי שמצפים.

במקום:

WHERE deleted_at = NULL

כותבים:

WHERE deleted_at IS NULL

ובמקום:

WHERE deleted_at != NULL

כותבים:

WHERE deleted_at IS NOT NULL

כאשר רוצים להציג ערך ברירת מחדל, COALESCE שימושית מאוד: COALESCE(nickname, name) יחזיר כינוי אם יש, ואם אין — שם.

אינדקסים ו־EXPLAIN: למה אותה שאילתה יכולה להיות איטית או מהירה

אינדקס במסד נתונים דומה במידה מסוימת לאינדקס בסוף ספר: הוא מאפשר להגיע מהר יותר לערכים מסוימים בלי לסרוק הכול. לא צריך ליצור אינדקס על כל עמודה; אינדקסים עוזרים בעיקר לעמודות שמופיעות הרבה ב־WHERE, ב־JOIN או ב־ORDER BY.

SQLite מאפשר לראות תוכנית ביצוע בסיסית עם EXPLAIN QUERY PLAN:

import sqlite3

# Create an in-memory database
connection = sqlite3.connect(":memory:")
cursor = connection.cursor()

cursor.execute("""
CREATE TABLE logs (
    id INTEGER PRIMARY KEY,
    level TEXT NOT NULL,
    message TEXT NOT NULL
)
""")

rows = []
for number in range(1, 101):
    level = "ERROR" if number % 10 == 0 else "INFO"
    rows.append((level, f"Message {number}"))

cursor.executemany(
    "INSERT INTO logs (level, message) VALUES (?, ?)",
    rows
)

print("Before index:")
cursor.execute("EXPLAIN QUERY PLAN SELECT message FROM logs WHERE level = ?", ("ERROR",))
print(cursor.fetchall())

cursor.execute("CREATE INDEX idx_logs_level ON logs(level)")

print("After index:")
cursor.execute("EXPLAIN QUERY PLAN SELECT message FROM logs WHERE level = ?", ("ERROR",))
print(cursor.fetchall())

connection.close()

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

טעויות נפוצות והודעות שגיאה אמיתיות

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

sqlite3.OperationalError: no such table: users

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

• לא הרצתם CREATE TABLE.
• התחברתם לקובץ מסד נתונים אחר.
• השתמשתם ב־":memory:", וכל הרצה מתחילה מסד נתונים ריק.

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

sqlite3.OperationalError: near "FORM": syntax error

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

sqlite3.OperationalError: no such column: username

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

sqlite3.ProgrammingError: Incorrect number of bindings supplied. The current statement uses 1, and there are 0 supplied.

המשמעות: בשאילתה יש placeholder כמו ?, אבל לא העברתם ערך מתאים. לדוגמה:

cursor.execute("SELECT * FROM users WHERE id = ?")

צריך להעביר tuple של פרמטרים:

cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))

גם כאן הפסיק חשוב כאשר יש פרמטר אחד בלבד.

sqlite3.IntegrityError: UNIQUE constraint failed: users.email

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

איך לתרגל בלי ללכת לאיבוד

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

• צרו טבלת books או tasks.
• הכניסו 5–10 שורות.
• כתבו שאילתות עם WHERE.
• הוסיפו ORDER BY ו־LIMIT.
• נסו לשבור בכוונה: שם עמודה שגוי, פרמטר חסר, ערך כפול בעמודת UNIQUE.

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

שאלות שקוראים באמת שואלים

האם SQL היא מסד נתונים?

לא. SQL היא שפה. מסד נתונים הוא המערכת ששומרת ומנהלת את הנתונים. SQLite, PostgreSQL, MySQL ו־SQL Server הן מערכות שונות שמבינות SQL, עם הבדלים מסוימים בתחביר ובהתנהגות.

האם חייבים לדעת SQL אם עובדים עם Python?

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

מתי משתמשים ב־SELECT *?

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

סיכום: SQL מתחיל בשאלות פשוטות

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

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