📊 Tipe Data & Penggunaannya

Referensi detail untuk Programmer dan DBA — diperkaya dengan pola penggunaan nyata, studi kasus industri, dan penjelasan mendalam kapan dan mengapa setiap tipe dipilih.

🔢 1. Tipe Data Primitif (Skalar) — Detail & Praktik Terbaik

Tipe primitif adalah atom penyusun aplikasi. Setiap sub-bagian kini dilengkapi dengan **konteks penggunaan sehari-hari** dan **pertimbangan desain yang sering muncul di production**.

1.1 Integer — Kapan Memilih Ukuran Tertentu?

Java / Go / SQL// Java: Entity ID standar
        public class User {
        private Long id;       // BIGINT di DB
        private Short age;     // SMALLINT
        private Byte status;   // TINYINT
        }

        -- MySQL: DDL efisien
        CREATE TABLE orders (
        order_id BIGINT AUTO_INCREMENT PRIMARY KEY,
        user_id  INT NOT NULL,                -- asumsi user < 2M
        quantity SMALLINT NOT NULL DEFAULT 1
        );

1.2 Floating Point & Decimal — Studi Kasus Keuangan

Detail: FLOAT/DOUBLE menggunakan basis 2, sehingga pecahan desimal seperti 0.1 tidak dapat direpresentasikan secara eksak. Dalam aplikasi fintech, sekali transaksi mungkin aman, tetapi akumulasi jutaan transaksi menyebabkan selisih (drift) yang tidak dapat ditoleransi.

Python & SQL# Python: JANGAN
        saldo = 1000.50 + 2000.30   # float, berisiko

        # LAKUKAN
        from decimal import Decimal
        saldo = Decimal('1000.50') + Decimal('2000.30')

        -- PostgreSQL: tipe uang khusus
        CREATE TABLE dompet (
        user_id INT,
        balance NUMERIC(18, 2) NOT NULL CHECK (balance >= 0)
        );

1.3 Boolean — Penggunaan di API dan Database

Pola sering dipakai: Flag seperti is_active, is_verified, is_deleted. Di REST API, boolean direpresentasikan sebagai true/false JSON. Di database, gunakan BOOLEAN (PostgreSQL) atau TINYINT(1) (MySQL). Jangan gunakan CHAR(1) 'Y'/'N' kecuali Anda di Oracle.

1.4 String & Teks — Panduan Ukuran dan Encoding

Detail penting: VARCHAR(255) sering dipakai karena dulu batas maksimum indeks MySQL, namun kini tidak relevan. Selalu pilih ukuran berdasarkan domain data:

Encoding: Gunakan UTF-8 (utf8mb4 di MySQL) untuk mendukung emoji dan karakter internasional. Perhatikan bahwa CHAR(10) dengan utf8mb4 bisa memakan 40 byte! Di PostgreSQL, cukup gunakan VARCHAR atau TEXT (encoding UTF-8 otomatis).

Deklarasi Tepat-- MySQL / MariaDB
        CREATE TABLE users (
        email     VARCHAR(254) NOT NULL UNIQUE,
        phone     VARCHAR(20) NULL,
        otp_code  CHAR(6) NULL,
        bio       TEXT NULL        -- tidak diindeks langsung
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

1.5 Tanggal & Waktu — Zona Waktu, Epoch, dan Query Rentang

Penggunaan paling sering: created_at, updated_at, deleted_at, birth_date. Dua pola utama:

• Timestamp UTC: Simpan semua waktu dalam UTC, konversi di frontend. Gunakan TIMESTAMPTZ (PG) atau DATETIME dengan kesadaran UTC.
• Event lokal: Janji temu dokter pukul 09:00 WIB harus tetap 09:00 meskipun zona berubah. Gunakan TIME + kolom zona terpisah.

🧩 2. Tipe Data Komposit — Struktur Data dalam Aplikasi Modern

Setiap tipe komposit memiliki peran spesifik. Berikut penjelasan berdasarkan kapan mereka muncul di kode produksi.

Go & PostgreSQL Composite// Go struct untuk request API
        type CreateOrderReq struct {
        UserID  int64   `json:"user_id"`
        Items   []string `json:"items"`
        Total   float64 `json:"total"`  // seharusnya pakai decimal
        }

        -- PostgreSQL composite type
        CREATE TYPE alamat AS (
        jalan VARCHAR(100),
        kota  VARCHAR(50),
        kode_pos VARCHAR(5)
        );

        CREATE TABLE kantor (
        id INT,
        lokasi alamat
        );

2.1 Array — Lebih dari Sekadar Daftar

Array adalah struktur data paling fundamental untuk menyimpan koleksi elemen bertipe sama. Penggunaannya sangat luas mulai dari logika bisnis hingga komunikasi API. Pemahaman mendalam tentang array di berbagai bahasa dan database akan menghindari jebakan desain.

📋 Array di Bahasa Pemrograman — Perbandingan Fitur

Penggunaan nyata:

• Python: Membaca file CSV menjadi list of dict, kemudian diproses dengan list comprehension.
• Go: Slice digunakan sebagai buffer untuk membaca data dari stream atau sebagai koleksi hasil query database (dengan sqlx).
• Java: API response sering dikembalikan sebagai List<UserDTO> dari controller.

🗄️ Array di PostgreSQL — Query dan Manipulasi

PostgreSQL menyediakan tipe data array native. Ini sangat berguna untuk menyimpan data yang jarang di-relasikan secara penuh, misalnya tag produk, daftar permission, atau koordinat.

PostgreSQL ArrayCREATE TABLE artikel (
        id SERIAL PRIMARY KEY,
        judul VARCHAR(200),
        tags TEXT[]   -- array of text
        );
        INSERT INTO artikel (judul, tags) VALUES
        ('Belajar SQL', ARRAY['sql','database','pemula']);

        -- Query: cari artikel yang punya tag 'database'
        SELECT * FROM artikel WHERE 'database' = ANY(tags);

        -- Menambah tag baru
        UPDATE artikel SET tags = array_append(tags, 'latihan') WHERE id = 1;

        -- Indeks GIN untuk pencarian array
        CREATE INDEX idx_tags ON artikel USING GIN (tags);

🧩 Array di Bahasa Modern — Studi Kasus: Transformasi Data

Dalam microservices, data sering dikirim sebagai array JSON. Di backend, kita melakukan transformasi: filter, map, reduce. Contoh di Python:

Python List Manipulation# Data dari API eksternal
        orders = [
        {"product": "Buku", "price": 15000},
        {"product": "Pulpen", "price": 3000},
        {"product": "Buku", "price": 20000}
        ]

        # Total pendapatan dari buku saja
        buku_revenue = sum(o['price'] for o in orders if o['product'] == 'Buku')
        

Di Go, dengan slice dan struct:

Go Slicetype Order struct { Product string; Price int }
        orders := []Order{{"Buku", 15000}, {"Pulpen", 3000}, {"Buku", 20000}}
        var total int
        for _, o := range orders {
        if o.Product == "Buku" { total += o.Price }
        }

🗄️ 3. Tipe Data Database — Panduan DBA dengan Contoh Nyata

Tambahan penting: bagaimana tipe data dipilih dalam siklus desain database, beserta dampaknya pada storage engine.

3.1 Memilih Auto-Increment vs UUID sebagai Primary Key

PostgreSQL ULID vs UUIDCREATE EXTENSION IF NOT EXISTS "uuid-ossp";
        CREATE TABLE orders (
        id       UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
        -- atau ULID (sebagai CHAR(26))
        ulid     CHAR(26) PRIMARY KEY
        );

3.2 JSONB di PostgreSQL — Kapan dan Bagaimana

Studi kasus umum: Marketplace menyimpan spesifikasi produk yang berbeda per kategori (baju: ukuran, warna; laptop: RAM, CPU). Daripada membuat puluhan tabel, simpan atribut dalam JSONB dengan indeks GIN. Query: "cari laptop dengan RAM 16GB" tetap cepat.

Index GIN untuk JSONBCREATE INDEX idx_produk_spec ON produk USING GIN (data jsonb_path_ops);
        SELECT * FROM produk
        WHERE data @> '{"spesifikasi": {"ram": 16}}';

3.3 Tipe Data Spesial: ENUM, BIT, dan Domain

Penggunaan: ENUM di MySQL/PostgreSQL untuk status yang terdefinisi jelas (misal: ENUM('pending','shipped','delivered')). Keuntungan: penyimpanan efisien (1-2 byte), validasi otomatis. Kerugian: sulit diubah jika perlu menambah status baru tanpa ALTER TABLE.

Alternatif modern: Gunakan SMALLINT dengan tabel referensi (lookup table) untuk fleksibilitas lebih, atau CHECK constraint di PostgreSQL.

3.4 AUTO_INCREMENT / SERIAL / IDENTITY — Jantung Surrogate Key

Auto-increment adalah mekanisme database untuk menghasilkan nilai integer unik secara otomatis, biasanya digunakan sebagai primary key pengganti (surrogate key). Setiap RDBMS memiliki sintaks berbeda, namun prinsipnya sama: nilai bertambah secara atomik setiap kali baris baru dimasukkan.

📐 Memilih Tipe Data untuk Auto-Increment

• TINYINT (max 127 signed) — hanya untuk tabel referensi kecil (misal: kategori < 100).
• SMALLINT (32.767) — masih berisiko untuk tabel transaksi yang cepat membesar.
• INT (2,1 milyar) — cukup untuk banyak aplikasi menengah. Namun, jika sehari ada 1 juta transaksi, habis dalam 5-6 tahun.
• BIGINT (9,2 × 10¹⁸) — standar emas untuk sistem modern.

Contoh Auto-Increment di Berbagai DB-- MySQL
        CREATE TABLE transactions (
        id BIGINT AUTO_INCREMENT PRIMARY KEY,
        amount DECIMAL(12,2)
        );

        -- PostgreSQL
        CREATE TABLE transactions (
        id BIGSERIAL PRIMARY KEY,
        amount NUMERIC(12,2)
        );

        -- SQL Server
        CREATE TABLE transactions (
        id BIGINT IDENTITY(1,1) PRIMARY KEY,
        amount DECIMAL(12,2)
        );

3.5 JOIN — Fondasi Query Relasional yang Kuat

JOIN adalah operasi fundamental yang menggabungkan baris dari dua atau lebih tabel berdasarkan kondisi relasi. Pemahaman yang mendalam tentang berbagai tipe JOIN, dampak tipe data, dan strategi optimasi sangat penting untuk performa database.

🔗 Jenis-Jenis JOIN dan Kapan Menggunakannya

📌 Penggunaan JOIN dalam Praktik — Multi-Table, Self-Join, Non-Equal

1. Multi-Table JOIN: Menggabungkan lebih dari dua tabel untuk laporan kompleks.

Multi-Table JOINSELECT u.name, o.order_date, p.product_name
        FROM users u
        INNER JOIN orders o ON u.id = o.user_id
        INNER JOIN order_items oi ON o.id = oi.order_id
        INNER JOIN products p ON oi.product_id = p.id
        WHERE o.order_date >= CURRENT_DATE - 7;

2. Self-Join: Menghubungkan tabel dengan dirinya sendiri, misal untuk hierarki karyawan-manajer.

Self-JoinSELECT e.name AS employee, m.name AS manager
        FROM employees e
        LEFT JOIN employees m ON e.manager_id = m.id;

3. Non-Equi JOIN: Kondisi selain kesamaan (=), misal rentang atau <.

Non-Equi JOINSELECT a.name, b.name
        FROM products a
        JOIN products b ON a.price < b.price AND a.category_id = b.category_id;

💣 Masalah Klasik: Tipe Data Kolom JOIN Tidak Cocok

Bayangkan users.id bertipe BIGINT, sedangkan orders.user_id bertipe INT. Saat Anda melakukan JOIN, database mungkin harus mengonversi tipe secara implisit. Akibatnya:

• Indeks tidak digunakan — database melakukan full table scan.
• CPU overhead — konversi tipe per baris sangat mahal.
• Hasil tidak konsisten — bisa terjadi pemotongan nilai atau error overflow.

Contoh Masalah JOIN karena Tipe Tidak Cocok-- Tabel users (id BIGINT)
        CREATE TABLE users (
        id BIGINT PRIMARY KEY,
        name VARCHAR(100)
        );
        -- Tabel orders (user_id INT) ❌
        CREATE TABLE orders (
        order_id INT PRIMARY KEY,
        user_id  INT,   -- harusnya BIGINT
        amount   DECIMAL(10,2)
        );
        -- Query JOIN — lambat!
        EXPLAIN SELECT u.name, o.amount
        FROM users u
        JOIN orders o ON u.id = o.user_id;
        -- MySQL akan menunjukkan 'Using where; Using index' atau full scan.

✅ Aturan Emas JOIN dan Tipe Data

Praktik Benar: JOIN dengan Tipe Cocok-- Perbaikan: orders.user_id BIGINT
        CREATE TABLE orders_new (
        order_id BIGINT PRIMARY KEY,
        user_id  BIGINT NOT NULL,
        amount   DECIMAL(10,2),
        INDEX idx_user (user_id),   -- indeks foreign key
        FOREIGN KEY (user_id) REFERENCES users(id)
        );

        SELECT u.name, o.amount
        FROM users u
        JOIN orders_new o ON u.id = o.user_id;  -- menggunakan indeks

📊 Visualisasi: Performa JOIN dengan Tipe Cocok vs Tidak Cocok

Pada tabel users 10 juta baris dan orders 50 juta baris, JOIN dengan tipe BIGINT cocok membutuhkan ~2 detik menggunakan indeks. Jika tidak cocok (konversi implisit), query bisa memakan waktu > 2 menit dan membebani CPU.

🔄 JOIN dengan JSON dan Array di PostgreSQL

Anda bisa melakukan JOIN antara kolom array dengan tabel lain menggunakan UNNEST atau antara data JSONB dengan kolom biasa.

JOIN Array dengan UNNEST-- Tabel produk dengan array kategori
        CREATE TABLE products (
        id SERIAL PRIMARY KEY,
        name VARCHAR(50),
        category_ids INT[]
        );
        SELECT p.name, c.category_name
        FROM products p
        CROSS JOIN UNNEST(p.category_ids) AS cat_id
        JOIN categories c ON c.id = cat_id;

🔄 4. Konversi Tipe Data & Bahaya Implicit Coercion

Detail skenario yang sering menyebabkan bug di production:

Solusi: Selalu eksplisit. Di JavaScript gunakan Number(), parseInt() dengan radix. Di SQL, gunakan CAST atau ::. Di bahasa strongly-typed, percayakan compiler.

🏆 5. Best Practice — Dari Pengalaman Industri

Berikut adalah kumpulan aturan yang sudah teruji di berbagai sistem production skala besar.

📋 Cheat Sheet Praktis: Tipe Data untuk Kebutuhan Umum