SQLite CREATE TABLE: תחביר, אילוצים ודוגמאות

CREATE TABLE מגדירה סכמה

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

הדוגמה השימושית הקטנה ביותר:

CREATE TABLE users (
    id    INTEGER PRIMARY KEY,
    name  TEXT NOT NULL,
    email TEXT
);

INSERT INTO users (name, email) VALUES ('Ada', 'ada@example.com');
INSERT INTO users (name)        VALUES ('Boris');

SELECT * FROM users;

שלוש עמודות, מפתח ראשי אחד, כלל NOT NULL אחד. SQLite מילאה את id אוטומטית כי הוא מפתח ראשי מסוג integer, ונתנה ל-email להיות NULL בשורה השנייה כי שום דבר לא אמר אחרת. זה כל המבנה: שם, עמודות, אילוצים, וכל השאר בעמוד הזה הוא וריאציה עליו.

התחביר, חלק אחר חלק

הגדרת עמודה היא name TYPE constraint constraint .... ב-SQLite הקלאסית הטיפוס אופציונלי (עוד על זה בעמוד על type affinity), אבל זה הרגל טוב לכלול תמיד טיפוס: קוראים וכלים מסתמכים עליו.

CREATE TABLE products (
    id          INTEGER PRIMARY KEY,
    sku         TEXT    NOT NULL UNIQUE,
    name        TEXT    NOT NULL,
    price_cents INTEGER NOT NULL,
    in_stock    INTEGER NOT NULL DEFAULT 1
);

INSERT INTO products (sku, name, price_cents)
VALUES ('SKU-001', 'Notebook', 499);

SELECT * FROM products;

כמה דברים שכדאי לשים לב אליהם:

• אילוצים משורשרים עם רווחים: NOT NULL UNIQUE על sku אומר ששני הכללים חלים.
• DEFAULT 1 על in_stock מאפשר ל-INSERT לדלג על העמודה הזו.
• SQLite משתמשת ב-INTEGER לערכים בוליאניים: אין טיפוס BOOLEAN מובנה. 0 הוא שקר, 1 הוא אמת.
• פסיק אחרי העמודה האחרונה הוא שגיאת תחביר. כאן SQL מחמירה יותר מ-JavaScript.

IF NOT EXISTS: לא לקרוס בהרצות חוזרות

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

Error: table users already exists

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

CREATE TABLE IF NOT EXISTS users (
    id   INTEGER PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS users (
    id   INTEGER PRIMARY KEY,
    name TEXT NOT NULL
);

SELECT name FROM sqlite_master WHERE type = 'table';

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

אזהרה, בכל זאת: IF NOT EXISTS בודק רק את ה_שם_. אם קיימת טבלה בשם הזה אבל עם עמודות אחרות, SQLite משאירה אותה כמו שהיא. היא לא "תתקן" ולא "תשדרג" את הסכמה בשבילכם. לזה נועדו מיגרציות.

אילוצים: כללים שנוסעים עם הסכמה

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

CREATE TABLE orders (
    id          INTEGER PRIMARY KEY,
    user_id     INTEGER NOT NULL,
    total_cents INTEGER NOT NULL CHECK (total_cents >= 0),
    status      TEXT    NOT NULL DEFAULT 'pending',
    created_at  TEXT    NOT NULL DEFAULT (datetime('now')),
    UNIQUE (user_id, created_at)
);

INSERT INTO orders (user_id, total_cents) VALUES (1, 1500);
INSERT INTO orders (user_id, total_cents, status) VALUES (1, 800, 'shipped');

SELECT * FROM orders;

• PRIMARY KEY: מזהה שורה באופן ייחודי. עוד על זה במדריך על מפתחות ראשיים.
• NOT NULL: לעמודה חייב להיות ערך.
• DEFAULT value: משמש כש-INSERT משמיט את העמודה. יכול להיות ערך מילולי או ביטוי כמו datetime('now').
• CHECK (expr): חייב להיות אמת בכל שורה.
• UNIQUE (col, col): אילוץ ברמת הטבלה שאוכף ייחודיות על הצירוף.

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

מפתחות זרים

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

PRAGMA foreign_keys = ON;

CREATE TABLE users (
    id   INTEGER PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE posts (
    id      INTEGER PRIMARY KEY,
    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    title   TEXT NOT NULL
);

INSERT INTO users (name) VALUES ('Ada');
INSERT INTO posts (user_id, title) VALUES (1, 'Hello, world');

SELECT p.id, u.name, p.title FROM posts p JOIN users u ON u.id = p.user_id;

מלכודת של SQLite ששווה לזכור: אכיפת מפתחות זרים כבויה כברירת מחדל. צריך להריץ PRAGMA foreign_keys = ON בכל חיבור שרוצה שהאילוצים ייבדקו. רוב הדרייברים של אפליקציות עושים את זה בשבילכם או חושפים הגדרה; אם שלכם לא, הריצו את ה-pragma מיד אחרי ההתחברות.

ON DELETE CASCADE כאן אומר שמחיקת משתמש מוחקת אוטומטית את הפוסטים שלו. אפשרויות אחרות הן SET NULL, RESTRICT וברירת המחדל, NO ACTION, שדוחה את המחיקה אם יש שורות צאצא.

CREATE TABLE AS SELECT

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

CREATE TABLE products (
    id          INTEGER PRIMARY KEY,
    name        TEXT NOT NULL,
    price_cents INTEGER NOT NULL
);

INSERT INTO products (name, price_cents) VALUES
    ('Notebook', 499), ('Pen', 199), ('Stapler', 1299);

CREATE TABLE expensive_products AS
SELECT id, name, price_cents
FROM products
WHERE price_cents >= 500;

SELECT * FROM expensive_products;

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

אם אתם רוצים את המבנה בלי הנתונים, הוסיפו WHERE 0:

CREATE TABLE products (
    id          INTEGER PRIMARY KEY,
    name        TEXT NOT NULL,
    price_cents INTEGER NOT NULL
);

CREATE TABLE products_archive AS SELECT * FROM products WHERE 0;

SELECT * FROM products_archive;
SELECT name FROM sqlite_master WHERE type = 'table';

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

טבלאות זמניות

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

CREATE TEMP TABLE recent_signups (
    user_id    INTEGER PRIMARY KEY,
    signed_up  TEXT NOT NULL
);

INSERT INTO recent_signups VALUES (1, '2026-01-15'), (2, '2026-01-18');

SELECT * FROM recent_signups;

שימושים טובים: הכנת שורות לשאילתה של כמה שלבים, החזקת תוצאות ביניים מבולגנות מדי ל-CTE, בידוד נתונים לכל חיבור בסשן ארוך. CREATE TEMP TABLE ו-CREATE TEMPORARY TABLE הם אותו דבר.

אפשר לשלב גם עם AS SELECT: CREATE TEMP TABLE snapshot AS SELECT ... הוא דפוס נפוץ להקפאת תוצאה באמצע ניתוח.

מירכאות סביב שמות

ברוב הזמן, שמות עמודות וטבלאות הם מזהים פשוטים. אם חייבים להשתמש במילה שמורה או בשם עם רווחים, עטפו אותו במירכאות כפולות (תקן SQL) או ב-backticks (הרגל של MySQL ש-SQLite גם מקבלת):

CREATE TABLE "order" (
    id        INTEGER PRIMARY KEY,
    "select"  TEXT,
    "user id" INTEGER
);

INSERT INTO "order" ("select", "user id") VALUES ('a', 1);
SELECT * FROM "order";

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

דוגמה מציאותית

כשמחברים את החלקים, הנה סכמה קטנה לאפליקציית משימות, עם IF NOT EXISTS כדי שתוכל לרוץ בכל עלייה:

PRAGMA foreign_keys = ON;

CREATE TABLE IF NOT EXISTS users (
    id    INTEGER PRIMARY KEY,
    email TEXT NOT NULL UNIQUE,
    name  TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS tasks (
    id          INTEGER PRIMARY KEY,
    user_id     INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    title       TEXT    NOT NULL,
    done        INTEGER NOT NULL DEFAULT 0 CHECK (done IN (0, 1)),
    created_at  TEXT    NOT NULL DEFAULT (datetime('now'))
);

INSERT INTO users (email, name) VALUES ('ada@example.com', 'Ada');
INSERT INTO tasks (user_id, title) VALUES (1, 'Write the docs');

SELECT u.name, t.title, t.done FROM tasks t JOIN users u ON u.id = t.user_id;

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

הבא בתור: טיפוסי נתונים

CREATE TABLE מאפשרת לכתוב INTEGER, TEXT, REAL, אבל SQLite ידועה בגישה הנינוחה שלה לאופן שבו היא שומרת את הערכים האלה. העמוד הבא מכסה את חמש מחלקות האחסון ש-SQLite באמת משתמשת בהן, ולמה הטיפוס שכתבתם הוא לא תמיד הטיפוס שתקבלו.