ATTACH DATABASE di SQLite: Query ke Banyak File Sekaligus

Satu Koneksi, Banyak File

Koneksi SQLite tidak terkunci pada satu file saja. Dengan ATTACH DATABASE, kamu bisa membuka file .db tambahan di samping file awal, lalu menjalankan query ke semuanya seolah-olah semuanya adalah skema di dalam satu database. Inilah hal yang paling mendekati "banyak database dalam satu server" di SQLite.

Bentuk dasarnya:

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;

File archive.db dibuat kalau belum ada, sama seperti database utama. Mulai sekarang dalam sesi ini, apa pun yang diawali archive. berada di file kedua itu. Apa pun yang diawali main. (atau tanpa prefiks) berada di file aslinya.

Koneksimu selalu punya dua skema tersirat: main (file yang pertama kali kamu buka) dan temp (ruang coretan untuk tabel sementara). Melampirkan database menambah skema lagi.

Sintaks dan Fungsi Alias

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

Alias adalah nama skema yang akan kamu pakai untuk menandai tabel. Alias hanya berlaku di koneksi saat ini: koneksi lain yang melampirkan file yang sama boleh memilih alias berbeda. Pilih nama yang pendek dan jelas (archive, analytics, cache) karena kamu akan sering mengetiknya.

Beberapa hal yang perlu diketahui:

• Path dihitung relatif terhadap direktori kerja proses, kecuali berupa path absolut.
• String ':memory:' melampirkan database in-memory yang baru di bawah alias tersebut.
• Alias tidak boleh bentrok dengan main atau temp, dan tidak boleh dipakai dua kali.

Join Lintas Database

Inilah fitur yang paling sering menjadi alasan orang melampirkan database. Begitu dua file berada di koneksi yang sama, kamu bisa melakukan join pada tabel-tabelnya dalam satu query:

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;

Query planner memperlakukan kedua skema sama seperti tabel di main. Index pada tabel terlampir tetap dipakai. EXPLAIN QUERY PLAN juga bekerja lintas skema. Tidak ada perjalanan bolak-balik lewat jaringan, karena kedua file terbuka di proses yang sama.

Ini sangat berguna untuk memisahkan data yang sering diakses dari arsip lama, memisahkan file per tenant, atau mengambil data referensi dari database lookup yang read-only.

Lampiran Read-Only dan In-Memory

Kalau database kedua adalah sesuatu yang ingin kamu baca tapi tidak pernah kamu ubah, misalnya dataset referensi yang ikut dikirim, lampirkan sebagai read-only dengan URI:

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

Bentuk URI mengharuskan library SQLite mengaktifkan SQLITE_OPEN_URI (aktif di CLI dan sebagian besar binding bahasa pemrograman). Setiap INSERT, UPDATE, atau DELETE ke ref.* akan memunculkan error sebelum menyentuh file.

Lampiran in-memory juga praktis untuk menampung data sementara:

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 hilang saat koneksi ditutup. Mirip temp, tapi kamu yang mengatur masa hidupnya.

Transaksi Mencakup Setiap Database Terlampir

Satu BEGIN/COMMIT mencakup penulisan ke main dan setiap skema terlampir. Semuanya di-commit atau semuanya di-rollback, jadi atomisitas tetap terjaga lintas file:

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;

Memindahkan baris dari tabel aktif ke file arsip adalah contoh operasi yang membutuhkan jaminan ini. Tanpa atomisitas lintas file, crash di tengah proses bisa meninggalkan duplikat atau, lebih buruk lagi, baris yang hilang.

Satu catatan: saat lebih dari satu database terlampir ditulisi dalam satu transaksi, SQLite memakai protokol commit yang lebih hati-hati dan membutuhkan journal sementara. Prosesnya lebih lambat dibanding commit satu file, tapi tetap aman.

Melepas Database

Kalau kamu sudah selesai memakai database terlampir, lepaskan:

DETACH DATABASE archive;

File-nya tetap utuh di disk: DETACH hanya menutup handle di koneksi saat ini. Ada dua batasan yang perlu diingat:

• Kamu tidak bisa melepas main atau temp.
• Kamu tidak bisa melepas database yang sedang berada di dalam transaksi atau masih punya pernyataan yang terbuka terhadapnya.

Kalau kamu lupa melepasnya, itu bukan masalah besar: menutup koneksi akan membereskan semuanya.

Batasan dan Error yang Umum

Beberapa batasan praktis yang perlu diketahui:

• Batas bawaannya adalah 10 database terlampir per koneksi (ditambah main dan temp). Maksimum saat kompilasi adalah 125. Kalau mencapai batas, kamu akan melihat too many attached databases - max 10.
• Setiap file terlampir memakai page cache. Melampirkan selusin database besar tidak gratis, karena pemakaian RAM ikut naik.
• ATTACH sendiri tidak bisa dijalankan di dalam transaksi. Jalankan sebelum BEGIN, atau setelah COMMIT.

Beberapa error yang kemungkinan besar akan kamu temui:

-- File doesn't exist and the directory isn't writable:
Error: unable to open database: 'missing/path.db'

-- You tried to write to a read-only attachment:
Error: attempt to write a readonly database

-- You used the same alias twice:
Error: database archive is already in use

Sebagian besar langsung jelas begitu kamu membacanya. Yang "already in use" sering menjebak orang: ATTACH tidak menggantikan alias yang sudah ada, jadi kamu harus menjalankan DETACH lebih dulu.

Pola Nyata: Memisahkan Data Aktif dan Arsip

Kalau semuanya digabungkan, berikut alur kerja arsip kecil yang memindahkan pesanan berumur lebih dari setahun keluar dari database utama:

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;

Baris lama pindah ke archive.orders, baris yang baru tetap di main. Laporan yang butuh riwayat bisa melakukan join ke keduanya, sementara query sehari-hari ke main.orders tetap cepat karena tabelnya lebih kecil. Satu koneksi, dua file, satu transaksi.

Berikutnya: Prepared Statement

ATTACH adalah tentang memberi satu koneksi akses ke lebih banyak data. Topik-topik berikutnya membahas cara aplikasi berkomunikasi dengan SQLite secara aman dan efisien, dimulai dari prepared statement, fondasi dari parameter binding dan query yang kebal terhadap injection.