Bagaimana cara melakukan bulk-load data secara efisien dengan COPY?

Question

Accepted Answer

**`COPY`** adalah perintah PostgreSQL berkinerja tinggi untuk **bulk loading dan exporting** data — memindahkan jumlah data besar antara file (atau stream) dan tabel jauh lebih cepat daripada pernyataan `INSERT` individual. Ini adalah alat standar untuk mengimpor/mengekspor dataset besar.

## COPY untuk bulk loading cepat

```sql
-- load data from a CSV file into a table (server-side; needs file access + privileges)
COPY users (name, email, age) FROM '/path/data.csv' WITH (FORMAT csv, HEADER true);

-- export a table to a CSV file
COPY users TO '/path/export.csv' WITH (FORMAT csv, HEADER true);

-- from psql (client-side — works without server file access): use \copy
\copy users FROM 'data.csv' WITH (FORMAT csv, HEADER true)
```

`COPY` membaca/menulis seluruh file dalam satu operasi — jauh lebih cepat daripada menjalankan ribuan INSERTs individual.

## Mengapa COPY jauh lebih cepat daripada INSERT

```text
❌ thousands of individual INSERTs:
   each is a separate statement → per-statement overhead, possibly per-row transactions,
   network round-trips → SLOW for large data (can be 10-100x slower)

✅ COPY:
   one bulk operation, minimal overhead, optimized data path → FAST
→ For loading large datasets, COPY is the go-to; INSERTs are for small/individual rows.
```

## COPY vs \copy (server-side vs client-side)

```text
COPY (SQL command) → reads/writes files on the SERVER, needs superuser/file privileges
\copy (psql command) → reads/writes files on the CLIENT, no special privileges
→ Use \copy when running from your machine against a remote database.
```

## Tips untuk bulk loading dataset besar

```text
✓ Use COPY (not INSERTs) for large data
✓ Consider dropping/disabling indexes and constraints during a huge load, then
  recreating them after (building an index once is faster than maintaining it per-row)
✓ Load within a single transaction; increase maintenance_work_mem for index rebuilds
✓ For programmatic bulk inserts, use multi-row INSERT or the driver's COPY support
```

## Mengapa ini penting

`COPY` adalah alat PostgreSQL penting untuk **bulk data loading dan exporting yang efisien**, dan memahaminya berharga untuk skenario apa pun yang melibatkan dataset besar — migrasi data, ETL, impor/ekspor, seeding, dan analytics, yang merupakan kebutuhan dunia nyata umum.

Nilai kunci adalah **performa**: memuat jumlah data besar dengan pernyataan `INSERT` individual sangat lambat (overhead per-statement, round-trips — berpotensi 10-100x lebih lambat), sementara `COPY` melakukan load sebagai satu operasi bulk yang dioptimalkan, menjadikannya pilihan utama untuk mengimpor atau mengekspor dataset besar (ribuan hingga jutaan baris).

Memahami *mengapa* COPY jauh lebih cepat (operasi bulk vs overhead per-row) memperjelas kapan harus menggunakannya (data besar) versus INSERTs (baris kecil/individual).

Mengetahui perbedaan praktis antara **`COPY`** (perintah SQL server-side, membutuhkan akses file/privilege) dan **`\"])}`copy`** (perintah client-side psql, tidak memerlukan privilege khusus — bekerja melawan database remote dari mesin Anda) penting untuk benar-benar menggunakannya dalam konteks berbeda.

**Tips bulk-loading** (menggunakan COPY dibanding INSERTs, menghapus/membuat ulang indexes seputar load besar karena membangun index sekali lebih baik daripada memeliharanya per-row, loading dalam transaksi) adalah pengetahuan optimasi berharga untuk impor besar.

Karena operasi data bulk (migrasi, impor, ekspor, ETL) umum, dan karena COPY adalah cara standar berkinerja tinggi untuk menanganinya di PostgreSQL (jauh melampaui performa INSERTs untuk data besar), memahami COPY — manfaat performanya, perbedaan COPY vs \copy, dan best practices bulk-loading — adalah pengetahuan berharga dan relevan secara praktis untuk secara efisien memindahkan dataset besar ke dan dari Postgres, kebutuhan operasional yang sering terjadi di mana menggunakan alat yang tepat (COPY) membuat perbedaan besar.