Belajar SQLite dari Nol: Buat Database, Tulis Query, dan Kelola Data

Kamu bisa belajar fondasi database sekaligus membuat proyek yang benar-benar jalan hanya dengan satu file SQLite.

• Tidak perlu menyalakan server database atau mengatur user, port, dan password sejak awal.
• Sintaks dasarnya seperti SELECT, JOIN, GROUP BY, serta transaksi tetap relevan saat kamu nanti memakai database yang lebih besar.

SQLite cocok untuk belajar karena hambatan awalnya rendah. Kamu bisa membuat database, mengisi data, menguji query, lalu membongkar semuanya tanpa takut merusak server bersama. Buat proyek nyata pun, SQLite tetap layak dipakai selama kebutuhanmu sesuai: data tersimpan lokal, penulisan bersamaan tidak terlalu ramai, dan kamu tidak membutuhkan replikasi antarserver. Setelah memahami alur dasar sampai optimasinya, kamu akan lebih mudah memilih kapan SQLite sudah cukup dan kapan saatnya pindah ke PostgreSQL atau MySQL.

SQLite itu apa, sebenarnya?

SQLite adalah database relasional berbasis file. Tidak ada proses server terpisah yang harus terus menyala seperti pada MySQL atau PostgreSQL. Aplikasi kamu langsung membaca dan menulis file database, biasanya berekstensi .db, .sqlite, atau .sqlite3.

Satu file tersebut bisa berisi tabel, index, relasi, view, trigger, dan data aplikasi. Kamu dapat menyalinnya untuk backup, memindahkannya ke komputer lain, atau membukanya dengan tool GUI. Sifat praktis ini membuat SQLite umum dipakai pada aplikasi mobile, desktop, perangkat embedded, browser, tools internal, serta prototipe aplikasi.

SQLite bukan database “versi latihan” yang harus dibuang begitu project mulai serius. Database ini punya transaksi ACID, dukungan SQL yang luas, foreign key, full-text search, window function, JSON, dan banyak fitur lain yang cukup matang. Yang membedakan bukan soal “mampu atau tidak”, melainkan pola akses data yang paling cocok untuknya.

Menurut dokumentasi resmi tentang kapan SQLite tepat digunakan, SQLite kuat untuk penyimpanan lokal, aplikasi single-user, perangkat, dan sistem dengan kebutuhan server sederhana. Sebaliknya, jika banyak pengguna menulis data secara bersamaan melalui jaringan, database client-server biasanya lebih aman.

SQLite unggul saat kamu butuh database sederhana yang dekat dengan aplikasi, bukan server database untuk melayani banyak mesin sekaligus.

Kenapa SQLite masih relevan untuk developer

Pada 2026, pilihan database makin banyak. Ada database cloud, managed service, distributed database, sampai database khusus analitik. Namun, kebutuhan sederhana tetap banyak: aplikasi kasir offline, aplikasi pencatat pengeluaran, prototype SaaS, tool internal, cache terstruktur, atau database lokal pada aplikasi mobile.

SQLite memberi tiga keuntungan utama.

Setup cepat. Kamu tidak perlu membuat akun database, menjalankan Docker container, mengatur port, atau memastikan service hidup di background. Buat file, buka koneksi, lalu mulai menulis query.

Portabel. Database berada dalam satu file. Untuk project latihan, kamu bisa mengirim file ke teman atau menyimpan salinannya sebagai backup. Untuk aplikasi desktop, file ini dapat tinggal di direktori data aplikasi.

SQL tetap relevan. Query yang kamu pelajari di SQLite, seperti SELECT, WHERE, JOIN, GROUP BY, HAVING, ORDER BY, dan transaksi, akan tetap berguna saat kamu berpindah ke database lain. Detail sintaks memang dapat berbeda, tetapi cara berpikirnya sama.

SQLite juga sering menjadi pintu masuk yang nyaman untuk memahami hubungan antara aplikasi dan data. Kamu tidak hanya belajar menulis query, tetapi juga belajar merancang tabel, menjaga konsistensi data, menentukan index, dan membaca pola penggunaan database.

Tip: Jangan berhenti di SELECT *. Biasakan sejak awal memilih kolom yang benar-benar kamu butuhkan dan beri nama tabel yang mudah dibaca.

SQLite, MySQL, atau PostgreSQL?

Tidak ada jawaban tunggal untuk semua project. Pilihan database sebaiknya mengikuti kebutuhan akses, volume data, cara deploy, serta kemampuan tim merawat infrastrukturnya.

SQLite cocok jika aplikasi berjalan di satu perangkat atau satu server kecil, lalu aktivitas menulis datanya tidak bertabrakan terus-menerus. Misalnya, aplikasi catatan pribadi, inventory lokal, tool analisis internal, sistem POS offline, atau aplikasi mobile.

MySQL cocok untuk aplikasi web yang membutuhkan database server dengan pola kerja umum. PostgreSQL sering menjadi pilihan ketika project membutuhkan fitur data yang lebih kompleks, kontrol transaksi lebih dalam, tipe data lanjutan, atau pertumbuhan sistem yang lebih besar.

Jangan buru-buru memilih PostgreSQL hanya karena terdengar lebih “serius”. Kompleksitas tambahan juga punya biaya: konfigurasi, monitoring, backup server, akses jaringan, dan pemeliharaan. Kalau SQLite sudah memenuhi kebutuhan, memakai SQLite justru bisa membuat produk lebih sederhana untuk dirawat.

Cara memasang SQLite dan membuat database pertama

Di banyak sistem, SQLite sudah tersedia. Cek lebih dulu lewat terminal:

sqlite3 --version

Jika muncul nomor versi, kamu sudah bisa mulai. Pada macOS dan Linux, SQLite sering sudah ada sebagai bagian dari sistem. Kalau belum, gunakan package manager sesuai distribusi yang kamu pakai.

Baca juga Panduan Lengkap Ponytail: Skill AI Agar Ngoding Kayak Developer Senior

# Ubuntu atau Debian
sudo apt update
sudo apt install sqlite3

# macOS dengan Homebrew
brew install sqlite3

Untuk Windows, kamu bisa mengunduh binary SQLite dan menambahkan foldernya ke PATH. Setelah itu, buka terminal di folder project lalu buat database pertama:

sqlite3 toko.db

Perintah tersebut membuka SQLite shell dan memakai file toko.db. Jika file belum ada, SQLite akan membuatnya saat database mulai menyimpan perubahan.

Di dalam shell, kenali beberapa perintah dasar berikut:

.help
.databases
.tables
.quit

Perintah yang diawali titik adalah perintah khusus SQLite shell, bukan SQL standar. Sementara itu, perintah seperti CREATE TABLE, INSERT, dan SELECT adalah SQL.

Catatan: Jika prompt berubah menjadi ...>, biasanya ada statement SQL yang belum ditutup dengan titik koma.

Struktur tabel: mulai dari data yang rapi

Mari gunakan contoh database toko sederhana. Kita akan membuat tabel kategori dan produk. Tujuannya bukan sekadar menjalankan kode, tetapi membangun struktur yang tidak cepat berantakan saat data bertambah.

PRAGMA foreign_keys = ON;

CREATE TABLE kategori (
 id INTEGER PRIMARY KEY,
 nama TEXT NOT NULL UNIQUE
);

CREATE TABLE produk (
 id INTEGER PRIMARY KEY,
 kategori_id INTEGER NOT NULL,
 nama TEXT NOT NULL,
 harga INTEGER NOT NULL CHECK (harga >= 0),
 stok INTEGER NOT NULL DEFAULT 0 CHECK (stok >= 0),
 dibuat_pada TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
 FOREIGN KEY (kategori_id) REFERENCES kategori(id)
);

Ada beberapa bagian penting di sini.

INTEGER PRIMARY KEY memberi setiap baris identitas unik. Dalam SQLite, bentuk ini punya perilaku khusus yang praktis untuk ID utama. Kamu tidak perlu menambahkan AUTOINCREMENT untuk kebanyakan kasus. Bahkan, AUTOINCREMENT tidak selalu diperlukan dan dapat membawa overhead tambahan.

NOT NULL mencegah kolom wajib terisi kosong. UNIQUE mencegah nilai ganda pada kolom tertentu. CHECK membantu menolak data yang tidak masuk akal, misalnya harga atau stok negatif.

Foreign key menghubungkan produk.kategori_id dengan . Namun, foreign key perlu diaktifkan pada setiap koneksi melalui PRAGMA foreign_keys = ON;. Jangan menganggap relasi otomatis berlaku jika kamu belum menyalakannya.

flowchart LR
	A["Kategori"] -->|"satu kategori"| B["Banyak produk"]
	B --> C["Tabel produk"]
	C --> D["Query dan laporan"]

SQLite memakai sistem tipe data yang fleksibel. Kolom tetap punya deklarasi tipe seperti TEXT, INTEGER, REAL, atau BLOB, tetapi perilaku penyimpanan nilainya tidak seketat beberapa database lain. Karena itu, disiplin di level aplikasi dan constraint tabel tetap penting.

CRUD yang benar-benar akan kamu pakai

CRUD berarti Create, Read, Update, dan Delete. Empat operasi ini ada di hampir semua aplikasi yang menyimpan data.

Menambah data dengan INSERT

Isi kategori lebih dulu, lalu tambahkan beberapa produk.

INSERT INTO kategori (nama) VALUES
 ('Minuman'),
 ('Makanan'),
 ('Perlengkapan');

INSERT INTO produk (kategori_id, nama, harga, stok) VALUES
 (1, 'Kopi Sachet', 2500, 120),
 (1, 'Teh Botol', 5000, 40),
 (2, 'Mi Instan', 3500, 75),
 (3, 'Buku Catatan', 12000, 30);

Kamu tidak memasukkan kolom id karena SQLite mengelolanya lewat INTEGER PRIMARY KEY. Namun, jangan hanya mengandalkan ID otomatis. Nama produk, kategori, dan aturan bisnis lain tetap perlu divalidasi sesuai kebutuhan aplikasi.

Membaca data dengan SELECT

Mulai dari query sederhana:

SELECT id, nama, harga, stok
FROM produk;

Lebih sering, kamu membutuhkan filter dan urutan:

SELECT nama, harga, stok
FROM produk
WHERE stok > 0
ORDER BY harga DESC;

Hindari kebiasaan memakai SELECT * di kode aplikasi production. Saat struktur tabel berubah, query yang memilih semua kolom bisa membawa data berlebih atau membuat respons lebih sulit dirawat.

Mengubah data dengan UPDATE

Misalnya, harga kopi berubah:

UPDATE produk
SET harga = 3000
WHERE id = 1;

Bagian WHERE sangat penting. Tanpa WHERE, semua baris pada tabel akan berubah.

-- Berbahaya: mengubah harga seluruh produk
UPDATE produk
SET harga = 3000;

Biasakan menjalankan SELECT dengan kondisi yang sama sebelum melakukan perubahan besar. Ini sederhana, tetapi dapat menyelamatkan banyak waktu saat bekerja dengan data nyata.

Menghapus data dengan DELETE

DELETE FROM produk
WHERE id = 4;

Sama seperti UPDATE, DELETE tanpa WHERE menghapus seluruh isi tabel. Untuk operasi sensitif, gunakan transaksi agar kamu masih punya kesempatan membatalkan perubahan sebelum disimpan permanen.

Baca juga 9Router untuk Coding: AI Gateway Lokal agar Tidak Mudah Kena Rate

Peringatan: Data yang sudah dihapus dan di-commit tidak otomatis bisa dikembalikan. Backup bukan fitur tambahan, melainkan kebiasaan dasar.

Query yang mulai terasa seperti pekerjaan nyata

Setelah CRUD, bagian paling berguna dari SQL adalah kemampuan menggabungkan, menyaring, dan merangkum data. Di titik ini SQLite bukan lagi sekadar file penyimpanan, tetapi alat untuk menjawab pertanyaan.

WHERE, LIKE, dan rentang nilai

SELECT nama, harga
FROM produk
WHERE harga BETWEEN 3000 AND 10000
 AND stok > 0
ORDER BY harga ASC;

Untuk pencarian pola teks:

SELECT nama, harga
FROM produk
WHERE nama LIKE '%Kopi%';

Gunakan IS NULL, bukan = NULL, saat memeriksa data kosong.

SELECT nama
FROM produk
WHERE dibuat_pada IS NULL;

JOIN untuk menghubungkan tabel

Tanpa JOIN, kamu sering tergoda menyimpan nama kategori pada setiap baris produk. Itu membuat data mudah duplikat dan sulit diperbarui. Dengan relasi, nama kategori cukup disimpan satu kali.

SELECT
 p.nama AS nama_produk,
 k.nama AS nama_kategori,
 p.harga,
 p.stok
FROM produk AS p
JOIN kategori AS k ON k.id = p.kategori_id
ORDER BY k.nama, p.nama;

JOIN hanya menampilkan data yang punya pasangan di kedua tabel. Jika kamu ingin melihat semua kategori, termasuk kategori yang belum memiliki produk, gunakan LEFT JOIN.

SELECT
 k.nama AS kategori,
 COUNT(p.id) AS jumlah_produk
FROM kategori AS k
LEFT JOIN produk AS p ON p.kategori_id = k.id
GROUP BY k.id, k.nama;

GROUP BY untuk laporan ringkas

SELECT
 kategori_id,
 COUNT(*) AS total_produk,
 SUM(stok) AS total_stok,
 AVG(harga) AS harga_rata_rata
FROM produk
GROUP BY kategori_id;

Gunakan HAVING untuk menyaring hasil setelah data dikelompokkan.

SELECT
 kategori_id,
 COUNT(*) AS total_produk
FROM produk
GROUP BY kategori_id
HAVING COUNT(*) >= 2;

Kalau kamu ingin latihan SQL dengan data yang cukup mudah dipahami, pola tabel toko seperti produk, pelanggan, transaksi, dan detail transaksi sangat efektif. Contoh latihan terstruktur dengan SELECT, agregat, dan JOIN juga bisa kamu lihat di roadmap SQL berbasis SQLite.

Cara membuat proyek latihan SQLite yang tidak membosankan

Belajar query dari tabel kosong cepat terasa hambar. Pilih masalah yang dekat dengan aktivitas sehari-hari agar pertanyaan untuk datanya muncul dengan natural.

Kamu bisa membuat salah satu project kecil berikut:

• Catatan pemasukan dan pengeluaran pribadi
• Inventaris barang untuk usaha kecil
• Koleksi buku, film, atau game
• Daftar pelanggan dan transaksi sederhana
• Catatan kebiasaan harian
• Sistem presensi untuk tim kecil
• Database resep dan bahan masakan

Berikut alur yang bisa kamu pakai untuk proyek catatan keuangan.

1. Tentukan pertanyaan yang ingin dijawab Misalnya, “Berapa total pengeluaran makan bulan ini?” atau “Kategori apa yang paling besar menyerap biaya?”

2. Rancang tabel inti Gunakan tabel kategori dan transaksi terlebih dahulu. Jangan membuat sepuluh tabel jika dua tabel sudah cukup.

3. Masukkan data contoh Isi setidaknya 20 sampai 50 baris agar query agregat dan filter terasa bermakna.

4. Tulis query laporan Buat laporan per bulan, kategori, dan jenis transaksi.

5. Tambahkan constraint Pastikan nilai nominal tidak negatif dan kategori transaksi valid.

6. Uji perubahan dengan transaksi Coba masukkan beberapa data, lalu batalkan salah satunya memakai ROLLBACK.

7. Buat backup sebelum eksperimen besar Salin file database atau pakai perintah .backup.

Struktur sederhana untuk catatan keuangan bisa seperti ini:

CREATE TABLE kategori_transaksi (
 id INTEGER PRIMARY KEY,
 nama TEXT NOT NULL UNIQUE,
 jenis TEXT NOT NULL CHECK (jenis IN ('masuk', 'keluar'))
);

CREATE TABLE transaksi (
 id INTEGER PRIMARY KEY,
 kategori_id INTEGER NOT NULL,
 tanggal TEXT NOT NULL,
 nominal INTEGER NOT NULL CHECK (nominal > 0),
 catatan TEXT,
 FOREIGN KEY (kategori_id) REFERENCES kategori_transaksi(id)
);

Lalu, buat laporan bulanan:

SELECT
 k.nama AS kategori,
 SUM(t.nominal) AS total
FROM transaksi AS t
JOIN kategori_transaksi AS k ON k.id = t.kategori_id
WHERE t.tanggal >= '2026-08-01'
 AND t.tanggal < '2026-09-01'
 AND k.jenis = 'keluar'
GROUP BY k.id, k.nama
ORDER BY total DESC;

Transaksi: pagar pengaman saat data berubah

Transaksi menjaga serangkaian operasi agar dianggap sebagai satu paket. Jika semuanya berhasil, gunakan COMMIT. Jika ada masalah, gunakan ROLLBACK.

Contoh paling mudah adalah membuat pesanan dan mengurangi stok produk. Kedua langkah harus berhasil bersama-sama. Jangan sampai pesanan tercatat, tetapi stok gagal diperbarui.

BEGIN TRANSACTION;

INSERT INTO transaksi (kategori_id, tanggal, nominal, catatan)
VALUES (1, '2026-08-04', 25000, 'Belanja bahan');

UPDATE produk
SET stok = stok - 1
WHERE id = 1
 AND stok > 0;

COMMIT;

Pada aplikasi sungguhan, kamu perlu memeriksa apakah UPDATE memang mengubah baris yang diharapkan. Jika stok kosong, jangan lanjut menyimpan transaksi pembelian seolah semuanya berhasil.

flowchart TD
	A["Mulai transaksi"] --> B["Tambah data"]
	B --> C["Ubah data terkait"]
	C --> D{"Semua berhasil?"}
	D -->|"Ya"| E["COMMIT"]
	D -->|"Tidak"| F["ROLLBACK"]
	E --> G["Data tersimpan"]
	F --> H["Perubahan dibatalkan"]

Tip: Untuk input banyak data, bungkus beberapa INSERT dalam satu transaksi. Prosesnya biasanya lebih efisien dibanding menyimpan setiap baris satu per satu.

SQLite dari Python: aman dan praktis

Python punya modul sqlite3 bawaan, jadi kamu tidak perlu memasang driver tambahan hanya untuk memulai. Ini alasan lain SQLite sering dipakai pada script otomasi, aplikasi desktop kecil, atau prototype backend.

import sqlite3

with sqlite3.connect("toko.db") as koneksi:
 koneksi.execute("PRAGMA foreign_keys = ON")

 koneksi.execute("""
 CREATE TABLE IF NOT EXISTS pelanggan (
 id INTEGER PRIMARY KEY,
 nama TEXT NOT NULL,
 email TEXT UNIQUE
 )
 """)

 koneksi.execute(
 "INSERT INTO pelanggan (nama, email) VALUES (?,?)",
 ("Siti Aminah", "[email protected]")
 )

 hasil = koneksi.execute(
 "SELECT id, nama, email FROM pelanggan"
 ).fetchall

for pelanggan in hasil:
 print(pelanggan)

Ada dua kebiasaan yang perlu kamu pegang sejak awal.

Pertama, gunakan placeholder ? untuk nilai dari pengguna. Jangan menggabungkan input ke string SQL dengan f-string atau concatenation biasa. Parameterized query membantu menghindari SQL injection dan membuat kode lebih mudah dirawat.

# Benar
koneksi.execute(
 "SELECT * FROM pelanggan WHERE email =?",
 (email_pengguna,)
)

# Hindari
query = f"SELECT * FROM pelanggan WHERE email = '{email_pengguna}'"

Kedua, tutup koneksi atau gunakan context manager seperti contoh sebelumnya. Blok with membantu melakukan commit saat proses berhasil dan rollback jika terjadi exception. Untuk opsi koneksi, row factory, backup, serta penggunaan API yang lebih dalam, baca dokumentasi modul sqlite3 di Python.

Index: percepat query, jangan asal tambah

Index membantu SQLite menemukan data tanpa memeriksa semua baris satu per satu. Anggap saja seperti indeks pada buku. Kalau kamu sering mencari produk berdasarkan nama, index pada kolom nama dapat membantu.

Baca juga Panduan 9Router: Bikin AI Gateway Lokal Anti Rate Limit (2026)

CREATE INDEX idx_produk_nama
ON produk(nama);

Index biasanya berguna pada kolom yang sering dipakai dalam:

• WHERE
• JOIN
• ORDER BY
• Foreign key
• Pencarian dengan nilai yang cukup beragam

Namun, index bukan obat untuk semua masalah. Setiap index juga menambah pekerjaan saat data ditambah, diubah, atau dihapus. Terlalu banyak index dapat memperlambat operasi tulis dan membuat ukuran database membengkak.

Gunakan EXPLAIN QUERY PLAN untuk melihat pendekatan SQLite saat menjalankan query.

EXPLAIN QUERY PLAN
SELECT id, nama, harga
FROM produk
WHERE nama = 'Kopi Sachet';

Jika query yang sering dijalankan terlihat melakukan pemindaian tabel penuh pada data besar, barulah pertimbangkan index. Jangan membuat index hanya karena ada saran umum tanpa melihat pola query aplikasi kamu.

Peringatan: Index di kolom tabel kecil hampir tidak memberi manfaat. Fokus dulu pada query yang benar-benar lambat dan sering dipakai.

WAL, backup, dan file database yang sehat

SQLite bekerja dengan file. Ini membuat backup mudah, tetapi juga menuntut kebiasaan yang disiplin. Jangan sekadar menyalin file database ketika aplikasi masih aktif menulis data. Gunakan mekanisme backup yang aman.

Di SQLite shell, kamu dapat membuat salinan database dengan:

.backup backup_toko.db

Untuk membuat dump SQL:

.output backup_toko.sql
.dump
.output stdout

File dump berguna ketika kamu ingin melihat struktur dan data dalam bentuk SQL. Sementara itu, backup database cocok jika kamu ingin memperoleh salinan file yang siap dipakai kembali.

Untuk aplikasi yang memiliki pembacaan cukup sering sambil sesekali menulis data, mode Write-Ahead Logging atau WAL dapat membantu.

PRAGMA journal_mode = WAL;

WAL memungkinkan pembaca dan penulis bekerja lebih baik secara bersamaan dibanding mode jurnal klasik. Namun, WAL bukan sihir yang mengubah SQLite menjadi database server untuk ratusan penulis paralel. SQLite tetap mengizinkan satu writer pada satu waktu.

Jika file database membesar setelah banyak operasi hapus, kamu dapat memakai:

VACUUM;

Perintah ini merapikan file, tetapi bisa membutuhkan ruang tambahan saat berjalan. Jangan menjalankannya sembarangan di tengah workload penting tanpa memahami dampaknya.

Kelebihan & Kekurangan

Kelebihan

• Tidak butuh server terpisah, sehingga setup awal cepat dan sederhana.
• Database tersimpan dalam satu file, praktis untuk backup, distribusi, dan development lokal.
• Mendukung SQL relasional, termasuk transaksi, index, view, trigger, dan foreign key.
• Cocok untuk aplikasi offline, mobile, desktop, prototype, serta tools internal.
• Ekosistemnya luas, dengan dukungan bawaan atau library matang di banyak bahasa pemrograman.

Kekurangan

• Penulisan paralel terbatas, terutama jika banyak proses mengubah data pada waktu bersamaan.
• Tidak dirancang sebagai database jaringan, jadi kurang cocok untuk banyak server aplikasi.
• Fitur operasional enterprise lebih terbatas, seperti replikasi dan clustering bawaan.
• File database tidak terenkripsi secara default, sehingga data sensitif butuh perlindungan tambahan.
• Tipe data fleksibel perlu disiplin, karena data yang tidak konsisten lebih mudah lolos jika schema longgar.

Fitur lanjutan yang layak dicoba

Setelah CRUD, JOIN, dan transaksi terasa nyaman, SQLite masih punya beberapa fitur yang sangat berguna.

View untuk query yang dipakai berulang

View menyimpan query sebagai objek yang dapat dipanggil ulang seperti tabel virtual.

CREATE VIEW ringkasan_stok AS
SELECT
 k.nama AS kategori,
 COUNT(p.id) AS jumlah_produk,
 SUM(p.stok) AS total_stok
FROM kategori AS k
LEFT JOIN produk AS p ON p.kategori_id = k.id
GROUP BY k.id, k.nama;

Setelah itu, kamu bisa memakai:

SELECT *
FROM ringkasan_stok
WHERE total_stok < 50;

View membantu menjaga query laporan tetap konsisten. Namun, jangan lupa bahwa view bukan salinan data. Saat tabel sumber berubah, hasil view juga ikut berubah.

Trigger untuk mencatat perubahan

Trigger dapat menjalankan SQL otomatis saat ada perubahan pada tabel. Misalnya, kamu ingin menyimpan riwayat harga produk.

CREATE TABLE riwayat_harga (
 id INTEGER PRIMARY KEY,
 produk_id INTEGER NOT NULL,
 harga_lama INTEGER NOT NULL,
 harga_baru INTEGER NOT NULL,
 diubah_pada TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE TRIGGER catat_harga_produk
AFTER UPDATE OF harga ON produk
FOR EACH ROW
WHEN OLD.harga <> NEW.harga
BEGIN
 INSERT INTO riwayat_harga (
 produk_id, harga_lama, harga_baru
 ) VALUES (
 OLD.id, OLD.harga, NEW.harga
 );
END;

Trigger bermanfaat, tetapi jangan sampai menyembunyikan terlalu banyak logika bisnis. Kalau trigger terlalu rumit, developer berikutnya bisa kesulitan mencari asal sebuah perubahan data.

FTS5 untuk pencarian teks

Untuk pencarian artikel, catatan, atau dokumen pendek, SQLite punya FTS5. Ini lebih sesuai daripada memaksa LIKE '%kata%' pada tabel besar.

CREATE VIRTUAL TABLE catatan_fts
USING fts5(judul, isi);

INSERT INTO catatan_fts (judul, isi)
VALUES (
 'Belajar SQLite',
 'SQLite menyimpan database dalam satu file tanpa server terpisah.'
);

SELECT judul
FROM catatan_fts
WHERE catatan_fts MATCH 'database';

FTS5 cocok untuk aplikasi catatan, katalog artikel lokal, dokumentasi internal, atau pencarian offline. Untuk kebutuhan mesin pencari skala besar dengan ranking kompleks, kamu tetap memerlukan sistem pencarian khusus.

Baca juga Apa Itu Senior Backend Developer? Ini Tugas & Gajinya

Kapan SQLite mulai tidak cukup?

SQLite tidak gagal hanya karena database sudah berukuran besar. Batas sebenarnya biasanya muncul dari pola aplikasi: banyak proses menulis data secara bersamaan, kebutuhan akses dari banyak server, atau tuntutan high availability.

Beberapa tanda yang perlu kamu perhatikan:

• Error database is locked muncul berulang saat aplikasi ramai menulis.
• Aplikasi berjalan di beberapa server dan semuanya perlu mengakses database yang sama.
• Kamu membutuhkan replikasi otomatis, failover, atau read replica.
• Banyak user membuat perubahan data penting dalam waktu bersamaan.
• Infrastruktur sudah membutuhkan monitoring database server yang lebih lengkap.
• Tim perlu membagi akses database dengan kontrol user dan jaringan yang lebih rinci.

Migrasi bukan tanda bahwa SQLite pilihan awalmu salah. Justru SQLite dapat membantu kamu memulai dengan cepat dan memahami model data lebih dulu. Saat kebutuhan nyata berubah, kamu bisa memindahkan schema serta data ke database server dengan rencana yang jelas.

Mulai dari export data, periksa perbedaan sintaks SQL, sesuaikan tipe data, lalu uji aplikasi di staging. Jangan memindahkan database hanya karena takut dianggap memakai tool yang “terlalu sederhana”. Pindah ketika beban kerja memang membutuhkannya.

Satu File, Banyak Peluang

• Mulai tanpa server: SQLite menyimpan data dalam satu file sehingga kamu bisa langsung fokus belajar SQL dan struktur tabel.
• Fondasi SQL tetap kepakai: SELECT, JOIN, GROUP BY, transaksi, dan index tetap relevan saat kamu memakai database lain.
• Schema menentukan kualitas data: Gunakan primary key, foreign key, NOT NULL, UNIQUE, dan CHECK sejak awal agar data tidak cepat berantakan.
• Transaksi melindungi perubahan: Gabungkan operasi yang saling bergantung dalam BEGIN, COMMIT, dan ROLLBACK agar data tetap konsisten.
• Index perlu alasan jelas: Tambahkan index pada query yang sering dipakai dan terbukti lambat, bukan pada semua kolom.
• Kenali batas SQLite: Database ini kuat untuk penyimpanan lokal dan writer terbatas, tetapi bukan pilihan utama untuk banyak penulis bersamaan.

SQLite adalah tempat yang pas untuk membangun kebiasaan database yang benar tanpa beban setup server. Mulai dari project kecil, rawat schema dan backup-nya, lalu pindah ke database server saat kebutuhan aplikasimu memang berubah.

Checklist

• Baca juga referensi otoritatif: Manipulasi SQLite Dari Python.
• Setup: Pasang SQLite lalu buat file database baru di folder project.
• Schema: Buat tabel inti dengan primary key, foreign key, dan constraint yang jelas.
• Isi Data: Masukkan data contoh secukupnya agar query laporan bisa diuji.
• Query: Latih SELECT, WHERE, JOIN, GROUP BY, dan HAVING dengan kasus nyata.
• Aman: Aktifkan foreign key dan gunakan parameterized query saat menerima input pengguna.
• Transaksi: Bungkus perubahan data yang saling terkait dalam transaksi yang bisa di-rollback.
• Performa: Cek query yang sering dipakai sebelum menambahkan index pada kolom tertentu.
• Backup: Buat salinan database sebelum eksperimen besar atau perubahan struktur tabel.
• Referensi resmi: MAHIR PYTHON SQLITE.