Constraint UNIQUE SQLite: Satu Kolom, Kunci Komposit, dan NULL

UNIQUE Berarti "Duplikat Tidak Diizinkan"

Constraint UNIQUE memberi tahu SQLite bahwa nilai dalam sebuah kolom (atau sekelompok kolom) tidak boleh berulang antarbaris. Dengan constraint inilah kamu menyatakan "dua user tidak boleh memakai email yang sama" atau "kode produk muncul paling banyak sekali."

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

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

SELECT * FROM users;

Insert ketiga gagal dengan UNIQUE constraint failed: users.email. SQLite memeriksa constraint pada setiap penulisan dan menolak apa pun yang akan menghasilkan duplikat. Dua baris pertama tersimpan; baris ketiga tidak pernah masuk.

Di balik layar, UNIQUE diimplementasikan sebagai unique index, struktur data yang sama yang dipakai SQLite untuk pencarian cepat, jadi pemeriksaannya murah dan kolomnya otomatis ter-index.

Sintaks Tingkat Kolom vs Tingkat Tabel

Ada dua cara menulis UNIQUE: langsung di samping kolom, atau sebagai klausa terpisah di akhir definisi tabel:

-- Column-level: simple, one column.
CREATE TABLE products (
    sku   TEXT UNIQUE,
    name  TEXT
);

-- Table-level: same effect, different placement.
CREATE TABLE products2 (
    sku   TEXT,
    name  TEXT,
    UNIQUE(sku)
);

Untuk satu kolom, keduanya setara, jadi pilih yang lebih enak dibaca. Bentuk tingkat tabel menjadi wajib begitu kamu butuh keunikan di lebih dari satu kolom.

UNIQUE Komposit: Beberapa Kolom Sekaligus

Kadang satu kolom tidak unik dengan sendirinya, tapi kombinasinya harus unik. Seorang user bisa mendaftar di banyak kursus, dan satu kursus bisa punya banyak user, tapi pasangan (user_id, course_id) yang sama tidak boleh muncul dua kali:

CREATE TABLE enrollments (
    id        INTEGER PRIMARY KEY,
    user_id   INTEGER NOT NULL,
    course_id INTEGER NOT NULL,
    UNIQUE(user_id, course_id)
);

INSERT INTO enrollments (user_id, course_id) VALUES (1, 100);
INSERT INTO enrollments (user_id, course_id) VALUES (1, 101);  -- fine, different course
INSERT INTO enrollments (user_id, course_id) VALUES (2, 100);  -- fine, different user
INSERT INTO enrollments (user_id, course_id) VALUES (1, 100);  -- fails: pair already exists

SELECT * FROM enrollments;

Constraint-nya berlaku pada pasangan, bukan pada salah satu kolom saja. User 1 bisa mendaftar di banyak kursus, kursus 100 bisa punya banyak user, tapi hanya sekali untuk setiap kombinasi.

Ini pola andalan untuk tabel penghubung pada relasi many-to-many.

UNIQUE vs PRIMARY KEY

Keduanya terdengar mirip dan memang berhubungan, tapi bukan hal yang sama:

• Sebuah tabel punya paling banyak satu PRIMARY KEY. Tabel itu bisa punya banyak constraint UNIQUE.
• PRIMARY KEY adalah identitas baris: yang dituju oleh foreign key, dan yang dialiaskan oleh rowid.
• UNIQUE hanya berarti "nilai (atau kombinasi) ini tidak berulang."
• Di tabel biasa, kolom UNIQUE bisa menampung nilai NULL; PRIMARY KEY tidak bisa (dengan satu pengecualian historis yang tidak kita bahas).

Bentuk yang umum:

CREATE TABLE accounts (
    id       INTEGER PRIMARY KEY,   -- internal identity, never changes
    email    TEXT NOT NULL UNIQUE,  -- user-facing identifier, must be unique
    username TEXT NOT NULL UNIQUE   -- another unique handle
);

id adalah yang dirujuk oleh bagian lain database. email dan username unik karena aplikasi mengharuskannya, bukan karena keduanya identitas. Jika user mengganti email-nya, id-nya tetap sama, dan itulah gunanya memisahkan keduanya.

Keanehan NULL

Hal ini menjebak hampir semua orang di kali pertama. Kolom UNIQUE di SQLite menerima nilai NULL sebanyak yang kamu mau:

CREATE TABLE invites (
    id    INTEGER PRIMARY KEY,
    email TEXT UNIQUE
);

INSERT INTO invites (email) VALUES (NULL);
INSERT INTO invites (email) VALUES (NULL);
INSERT INTO invites (email) VALUES (NULL);
INSERT INTO invites (email) VALUES ('ada@example.com');
INSERT INTO invites (email) VALUES ('ada@example.com');  -- this one fails

SELECT * FROM invites;

Tiga NULL, tidak masalah. Dua 'ada@example.com', itu konflik.

Alasannya: SQL memperlakukan NULL sebagai "tidak diketahui", dan dua hal yang tidak diketahui tidak dianggap sama, sehingga pemeriksaan keunikan tidak bisa menyatakan keduanya duplikat. Jika kamu butuh paling banyak satu NULL, solusi paling rapi adalah NOT NULL UNIQUE. Jika NULL boleh ada tapi hanya satu untuk setiap kombinasi kolom lain, pakai partial index (dibahas nanti di bab index).

Menangani Konflik: ON CONFLICT

Secara default, pelanggaran UNIQUE membatalkan pernyataan. Tapi kadang kamu ingin perilaku lain: mengganti baris yang ada, mengabaikan baris baru, atau memperbarui kolom tertentu. SQLite memberimu dua cara untuk memintanya.

Cara pertama dipasang langsung pada constraint dengan ON CONFLICT:

CREATE TABLE settings (
    key   TEXT UNIQUE ON CONFLICT REPLACE,
    value TEXT
);

INSERT INTO settings (key, value) VALUES ('theme', 'light');
INSERT INTO settings (key, value) VALUES ('theme', 'dark');   -- replaces the first
INSERT INTO settings (key, value) VALUES ('lang', 'en');

SELECT * FROM settings;

Saat theme dimasukkan untuk kedua kalinya, baris yang ada dihapus dan baris baru menggantikannya. Pilihan lainnya adalah IGNORE (lewati diam-diam), ABORT (default), FAIL, dan ROLLBACK.

Cara kedua berlaku per pernyataan, dengan sintaks upsert. Cara ini biasanya lebih fleksibel karena bisa memperbarui kolom tertentu:

CREATE TABLE counters (
    name  TEXT UNIQUE,
    count INTEGER NOT NULL DEFAULT 0
);

INSERT INTO counters (name, count) VALUES ('hits', 1);
INSERT INTO counters (name, count) VALUES ('hits', 1)
    ON CONFLICT(name) DO UPDATE SET count = count + 1;
INSERT INTO counters (name, count) VALUES ('hits', 1)
    ON CONFLICT(name) DO UPDATE SET count = count + 1;

SELECT * FROM counters;

Insert pertama membuat barisnya. Dua insert berikutnya menabrak constraint UNIQUE dan jatuh ke cabang DO UPDATE, sehingga count bertambah. Inilah pola upsert INSERT ... ON CONFLICT, yang punya halaman khusus nanti.

Constraint UNIQUE vs Unique Index

CREATE UNIQUE INDEX mengerjakan tugas yang sama dengan constraint UNIQUE. Bahkan, constraint UNIQUE membuat unique index di balik layar: keduanya hampir merupakan mekanisme yang sama dengan nama yang berbeda.

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

CREATE UNIQUE INDEX idx_users_email ON users(email);

INSERT INTO users (email) VALUES ('ada@example.com');
INSERT INTO users (email) VALUES ('ada@example.com');  -- fails

Kapan memilih yang mana:

• Constraint saat keunikan adalah bagian dari definisi tabel. Aturannya terdokumentasi tepat di samping kolom-kolomnya.
• Unique index saat kamu ingin partial index (klausa WHERE), butuh nama tertentu, atau ingin menambahkannya ke tabel yang sudah ada tanpa menulis ulang tabel itu. ALTER TABLE di SQLite tidak bisa menambahkan constraint, tapi index selalu bisa ditambahkan.

Perilakunya saat penulisan sama persis. Pilihannya lebih tentang di mana kamu ingin aturan itu berada dalam skema.

Menambahkan UNIQUE ke Tabel yang Sudah Ada

ALTER TABLE di SQLite sengaja dibuat terbatas: tidak ada ALTER TABLE ... ADD CONSTRAINT. Dua pilihan praktisnya:

-- Option 1: add a unique index. Works on existing tables, same enforcement.
CREATE TABLE customers (
    id    INTEGER PRIMARY KEY,
    email TEXT
);

INSERT INTO customers (email) VALUES ('ada@example.com');
INSERT INTO customers (email) VALUES ('boris@example.com');

CREATE UNIQUE INDEX idx_customers_email ON customers(email);

INSERT INTO customers (email) VALUES ('ada@example.com');  -- now fails

Pilihan kedua, saat kamu benar-benar ingin klausa UNIQUE tertanam di definisi tabel, adalah ritual menulis ulang tabel: buat tabel baru dengan constraint itu, salin datanya, hapus tabel lama, lalu ganti namanya. Ini dibahas di halaman berikutnya.

Sebagai peringatan: jika kamu menambahkan keunikan ke kolom yang sudah berisi duplikat, CREATE UNIQUE INDEX akan gagal. Bersihkan dulu baris duplikatnya, baru tambahkan index-nya.

Saat UNIQUE Gagal: Membaca Error-nya

Pesan error memberi tahu dengan tepat constraint mana yang gagal:

Error: UNIQUE constraint failed: users.email
Error: UNIQUE constraint failed: enrollments.user_id, enrollments.course_id

Bentuk pertama adalah constraint satu kolom pada users.email. Yang kedua adalah komposit: kedua kolom dicantumkan karena kombinasinya sudah ada. Saat kamu melihat ini:

1. Temukan baris mana yang sudah punya nilai yang berkonflik (SELECT ... WHERE email = '...').
2. Putuskan apakah kamu ingin memperbarui baris itu, melewati insert, atau memakai nilai lain.
3. Jika duplikat memang diharapkan dan kamu ingin menggabungkannya, beralihlah ke INSERT ... ON CONFLICT DO UPDATE.

Error-nya lantang karena sebagian besar waktu kamu memang ingin tahu: duplikat yang diam-diam masuk lebih buruk daripada penulisan yang gagal.

Berikutnya: Menghapus dan Mengubah Tabel

Constraint UNIQUE tidak bisa ditambahkan ke tabel yang sudah ada dengan ALTER TABLE sederhana. Keterbatasan itulah alasan SQLite punya ritual khusus untuk perubahan skema, yaitu menulis ulang tabel, dan itu topik halaman berikutnya, bersama dasar-dasar menghapus tabel dengan bersih.