SQLite ATTACH DATABASE: שאילתות על פני כמה קבצים

חיבור אחד, הרבה קבצים

חיבור ל-SQLite לא נעול לקובץ אחד. עם ATTACH DATABASE, אפשר לפתוח קבצי .db נוספים לצד הקובץ שהתחלתם איתו, ולתשאל את כולם כאילו היו סכמות בתוך מסד נתונים אחד. זה הדבר הכי קרוב שיש ל-SQLite ל"כמה מסדי נתונים על שרת אחד".

הצורה הבסיסית:

ATTACH DATABASE 'archive.db' AS archive;

CREATE TABLE archive.old_orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    total REAL
);

INSERT INTO archive.old_orders VALUES (1, 'Rosa', 49.99);

SELECT * FROM archive.old_orders;

הקובץ archive.db נוצר אם הוא לא קיים, בדיוק כמו מסד הנתונים הראשי. מעכשיו, בסשן הזה, כל מה שמתחיל בקידומת archive. נמצא בקובץ השני. כל מה שמתחיל ב-main. (או בלי קידומת) נמצא בקובץ המקורי.

לחיבור שלכם יש תמיד שתי סכמות מובלעות: main (הקובץ שפתחתם ראשון) ו-temp (מרחב עבודה לטבלאות זמניות). צירוף מוסיף עוד.

התחביר ומה הכינוי עושה

ATTACH DATABASE 'path/to/file.db' AS alias_name;

הכינוי הוא שם הסכמה שבו תשתמשו כדי לציין טבלאות. הוא מקומי לחיבור הנוכחי: חיבור אחר שמצרף את אותו קובץ יכול לבחור כינוי אחר. בחרו משהו קצר ותיאורי (archive, analytics, cache), כי תקלידו אותו הרבה.

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

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

JOIN בין מסדי נתונים

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

ATTACH DATABASE ':memory:' AS archive;

CREATE TABLE main.customers (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE archive.orders (id INTEGER, customer_id INTEGER, total REAL);

INSERT INTO main.customers VALUES (1, 'Rosa'), (2, 'Boris');
INSERT INTO archive.orders VALUES (101, 1, 49.99), (102, 2, 12.50);

SELECT c.name, o.total
FROM main.customers AS c
JOIN archive.orders AS o ON o.customer_id = c.id;

מתכנן השאילתות מתייחס לשתי הסכמות בדיוק כמו לטבלאות ב-main. נעשה שימוש באינדקסים על טבלאות מצורפות. EXPLAIN QUERY PLAN עובד על פני שתיהן. אין סבב רשת: שני הקבצים פתוחים באותו תהליך.

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

צירופים לקריאה בלבד ובזיכרון

אם מסד הנתונים השני הוא משהו שאתם רוצים לקרוא אבל אף פעם לא לשנות, למשל מאגר נתוני עזר שמגיע עם האפליקציה, צרפו אותו לקריאה בלבד עם URI:

ATTACH DATABASE 'file:reference.db?mode=ro' AS ref;

צורת ה-URI דורשת שבספריית SQLite יהיה SQLITE_OPEN_URI מופעל (הוא מופעל ב-CLI וברוב הספריות לשפות תכנות). כל INSERT, UPDATE או DELETE על ref.* יזרוק אז שגיאה לפני שייגע בקובץ.

צירופים בזיכרון שימושיים באותה מידה להכנת נתונים ביניים:

ATTACH DATABASE ':memory:' AS scratch;

CREATE TABLE scratch.tmp_results AS
SELECT customer_id, SUM(total) AS spend
FROM main.orders
GROUP BY customer_id;

SELECT * FROM scratch.tmp_results ORDER BY spend DESC LIMIT 5;

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

טרנזקציות חלות על כל מסד נתונים מצורף

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

ATTACH DATABASE ':memory:' AS archive;

CREATE TABLE main.orders (id INTEGER PRIMARY KEY, total REAL);
CREATE TABLE archive.orders (id INTEGER PRIMARY KEY, total REAL);

BEGIN;
    INSERT INTO archive.orders SELECT * FROM main.orders WHERE id < 100;
    DELETE FROM main.orders WHERE id < 100;
COMMIT;

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

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

ניתוק

כשסיימתם עם מסד נתונים מצורף, הסירו אותו:

DETACH DATABASE archive;

הקובץ נשאר בדיסק בלי שינוי: DETACH רק סוגר את הידית בחיבור הנוכחי. שתי מגבלות שכדאי לזכור:

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

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

מגבלות ושגיאות נפוצות

כמה מגבלות מעשיות שכדאי להכיר:

• מגבלת ברירת המחדל היא 10 מסדי נתונים מצורפים לכל חיבור (בנוסף ל-main ו-temp). המקסימום בזמן קומפילציה הוא 125. הגעתם למגבלה? תראו too many attached databases - max 10.
• כל קובץ מצורף משתמש במטמון דפים. צירוף תריסר מסדי נתונים גדולים לא בא בחינם: צריכת ה-RAM עולה.
• את ATTACH עצמו אי אפשר להריץ בתוך טרנזקציה. הריצו אותו לפני BEGIN או אחרי COMMIT.

כמה שגיאות שכנראה תפגשו:

-- הקובץ לא קיים ואין הרשאת כתיבה לתיקייה:
Error: unable to open database: 'missing/path.db'

-- ניסיתם לכתוב לצירוף שהוא לקריאה בלבד:
Error: attempt to write a readonly database

-- השתמשתם באותו כינוי פעמיים:
Error: database archive is already in use

רובן ברורות מאליהן ברגע שקוראים אותן. זו של "already in use" מבלבלת אנשים: ATTACH לא מחליף כינוי קיים; צריך לעשות DETACH קודם.

דפוס מציאותי: הפרדה בין חם לקר

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

ATTACH DATABASE ':memory:' AS archive;

CREATE TABLE main.orders (
    id INTEGER PRIMARY KEY,
    placed_at TEXT,
    total REAL
);
CREATE TABLE archive.orders AS SELECT * FROM main.orders WHERE 0;

INSERT INTO main.orders VALUES
    (1, '2022-06-01', 19.99),
    (2, '2024-11-15', 49.50),
    (3, '2025-08-22', 12.00);

BEGIN;
    INSERT INTO archive.orders
        SELECT * FROM main.orders WHERE placed_at < date('now', '-1 year');
    DELETE FROM main.orders WHERE placed_at < date('now', '-1 year');
COMMIT;

SELECT 'main' AS db, COUNT(*) FROM main.orders
UNION ALL
SELECT 'archive', COUNT(*) FROM archive.orders;

שורות ישנות עוברות ל-archive.orders, והחדשות נשארות ב-main. דוחות שצריכים היסטוריה יכולים לצרף את שתיהן; שאילתות יומיומיות על main.orders נשארות מהירות כי הטבלה קטנה יותר. אותו חיבור, שני קבצים, טרנזקציה אחת.

הבא בתור: Prepared Statements

ATTACH עוסק במתן גישה לחיבור אחד ליותר נתונים. קבוצת הנושאים הבאה עוסקת באופן שבו אפליקציות מדברות עם SQLite בצורה בטוחה ויעילה, ומתחילה ב-prepared statements, הבסיס לקשירת פרמטרים ולשאילתות חסינות מפני הזרקה.