KUID: Pengidentifikasi Unik Universal Terkompresi – Beragampengetahuan

KUID adalah Pengidentifikasi Unik Universal, yang pada dasarnya merupakan versi lebih pendek dari UUID, yang biasa digunakan untuk mengidentifikasi catatan dalam berbagai aplikasi.

Apa itu UUID?

UUID (Pengidentifikasi Unik Universal) ​​adalah pengidentifikasi unik yang banyak digunakan dalam berbagai aplikasi dan sistem untuk mengidentifikasi catatan. Ini adalah angka 128-bit, biasanya direpresentasikan sebagai urutan 32 digit heksadesimal, dibagi menjadi 5 bagian, dipisahkan oleh tanda hubung, dalam format berikut: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.

UUID dirancang untuk unik secara global, yang berarti sangat tidak mungkin dua UUID akan sama, bahkan jika dihasilkan secara independen oleh sistem yang berbeda. Ini membuat UUID berguna untuk mengidentifikasi dan melacak catatan dalam sistem terdistribusi, basis data, dan lingkungan lain yang memerlukan identifikasi unik.

Ada berbagai varian dan versi UUID, masing-masing dengan caranya sendiri untuk menghasilkan pengidentifikasi unik. Beberapa varian yang umum digunakan antara lain UUIDv1, UUIDv4, dan UUIDv5. Varian dan versi tertentu dari UUID dapat diidentifikasi berdasarkan format dan konten pengidentifikasi.

KUID dihasilkan dalam dua langkah

• Hasilkan UUID (gunakan algoritma apa pun seperti V1, V2, V3, V4, dll.)
• Mengkodekan angka 128-bit

KUID = Menghasilkan UUID dan menyandikannya ke basis yang lebih tinggi, seperti basis 32, 36, atau 62 atau lebih tinggi.

func encoder
   input: number # 128 bit number 
   output: encoded string 
   

func KUID:
  input UUID, encoder
  output KUID 
  return encode.encode( UUID )

Panjang KUID tergantung pada skema pengkodean yang digunakan. Jika skema pengkodean base62 ([0–9A-Za-z]), KUID dapat dikodekan sebagai 22 byte.Namun, jika Anda ingin menyimpan KUID dalam huruf besar, enkode menggunakan skema pengkodean base36 menggunakan karakter [0–9A-Z], akan menghasilkan representasi yang disandikan yang dapat disimpan dalam 26 byte. Untuk artikel ini, kami akan menggunakan pengkodean basis 62.

Mengapa kami menggunakan KUID?

KUID menghasilkan string yang lebih kecil, mengurangi ruang penyimpanan, dan mempercepat banyak operasi.

Catatan: Pernyataan berikut hanya berfungsi jika KUID diperlakukan sebagai string dan bukan angka 128-bit.

• hash: Menggunakan KUID 22 byte yang lebih pendek mengurangi jumlah data yang perlu di-hash. Ini menghasilkan lebih sedikit instruksi yang diperlukan untuk melakukan operasi hash daripada UUID, yang memerlukan hash 36 byte.
• Membandingkan: Karena panjang KUID yang lebih pendek, hanya 22 byte yang perlu dibandingkan, bukan 36 byte, sehingga mengurangi jumlah instruksi yang diperlukan untuk perbandingan.
• Baca tulis: Menggunakan KUID yang dapat dikodekan dalam 22 byte mengurangi memori dan ruang disk yang diperlukan untuk operasi baca dan tulis. Ini berbeda dengan UUID, yang membutuhkan 36 byte untuk melakukan operasi yang sama. Dengan KUID, lebih sedikit instruksi yang diperlukan untuk membaca atau menulis data karena ukurannya yang lebih kecil.
• panggilan IO: Mengirim UUID melalui jaringan menghabiskan 36 byte data (tidak memperhitungkan kompresi), sedangkan KUID hanya membutuhkan 22 byte. Oleh karena itu, KUID berukuran lebih kecil dan merupakan pilihan yang lebih efisien untuk transmisi jaringan.
• indeks basis data: Karena ukuran KUID yang kecil, ukuran indeks basis data berkurang. Selain itu, menggabungkan KUID dengan kolom lain untuk indeks sekunder mungkin bermanfaat, karena database memiliki lebar indeks terbatas (misalnya, 767 byte di MySQL), bergantung pada pengkodean yang digunakan untuk kolom atau tabel. Misalnya, pengkodean UTF8 MySQL dapat membatasi lebar indeks hingga 255 byte.
• keamanan URL: Seperti UUID, KUID adalah URL yang aman karena hanya menggunakan [0–9A-Za-z] karakter untuk mewakili data. KUID sering digunakan sebagai kolom unik, artinya URL yang berisi KUID dapat digunakan untuk merujuk ke sumber tertentu, seperti /api/v1/products/:productId. Karena KUID disertakan dalam URL, URL harus aman untuk menghindari masalah seperti kesalahan penyandian atau interpretasi tak terduga oleh server web atau browser.
• penggunaan memori/disk yang lebih kecil: Menggunakan KUID akan mengurangi penggunaan memori/disk dibandingkan dengan UUID. Karena KUID hanya membutuhkan 22 byte, KUID menggunakan lebih sedikit ruang penyimpanan daripada UUID yang menggunakan 36 byte. Ini dapat bermanfaat untuk sistem yang sering membutuhkan operasi baca/tulis atau memiliki kapasitas penyimpanan terbatas. Misalnya, jika kami mempertimbangkan penyimpanan 200 juta rekaman, dengan asumsi setiap KUID disimpan sebagai string 22 byte, ruang yang digunakan oleh KUID adalah sekitar 4,4 GB. Sebagai perbandingan, ruang yang dibutuhkan untuk UUID adalah sekitar 7,2 GB. Oleh karena itu, penggunaan KUID dapat menghemat sekitar 39% ruang penyimpanan.

implementasi Jawa:

/*
 * Copyright (c) 2023 Sonu Kumar, sonunitw12@gmail.com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and limitations under the License.
 *
 */
package sonus21.github.com;

import java.util.UUID;

/**
 * KUID, a universally unique identifier, is essentially a shorter version of a UUID due to BASE 62 encoding
 * <p>
 * This KUID implementation always generate 22 bytes string, but it can be further reduced.
 * <p>
 * For details read <a href=" Compressed Universally Unique Identifier</a>
 */

public class KUID implements java.io.Serializable, Comparable<KUID> {
    private static final long serialVersionUID = -485684636193249489L;

    private static final String BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    private static final int BASE = BASE62.length();
    private final long msb;
    private final long lsb;


    private KUID(long msb, long lsb) {
        this.msb = msb;
        this.lsb = lsb;
    }

    // A naive method to encode number to Base62
    private static String encodeLong(long value) {
        int size = 11;
        StringBuilder sb = new StringBuilder(size);
        while (value != 0) {
            int index = (int) (value % BASE);
            value = value / BASE;
            // for negative number flip the order instead of error it out as we need to encode all 64 bits
            if (index < 0) {
                index = BASE + index;
            }
            sb.insert(0, BASE62.charAt(index));
        }
        while (sb.length() < size) {
            sb.insert(0, BASE62.charAt(0));
        }
        return sb.toString();
    }


    /**
     * Static factory to retrieve a KUID from UUID
     *
     * @param uuid the UUID object
     * @return KUID object
     */
    public static KUID fromUUID(UUID uuid) {
        if (uuid == null) {
            throw new IllegalArgumentException("uuid can not be null");
        }
        return new KUID(uuid.getMostSignificantBits(), uuid.getMostSignificantBits());
    }

    /**
     * Static factory to retrieve a pseudo randomly generated KUID
     * <p>
     * The {@code KUID} is generated using a random UUID.
     *
     * @return A randomly generated {@code KUID}
     */
    public static KUID randomKUID() {
        return fromUUID(UUID.randomUUID());
    }

    @Override
    public int compareTo(KUID o) {
        return (msb < o.msb ? -1 :
                (msb > o.msb ? 1 :
                        (Long.compare(lsb, o.lsb))));
    }


    /**
     * Returns a {@code String} object representing this {@code KUID}.
     *
     * @return A string representation of this {@code KUID}
     */
    @Override
    public String toString() {
        return encodeLong(msb) + encodeLong(lsb);
    }

    /**
     * Returns a hash code for this {@code KUID}.
     *
     * @return A hash code value for this {@code KUID}
     */
    @Override
    public int hashCode() {
        long xor = msb ^ lsb;
        return ((int) (xor >> 32)) ^ (int) xor;
    }


    /**
     * Compares this object to the specified object.  The result is {@code
     * true} if and only if the argument is not {@code null}, is a {@code KUID}
     * object, and contains the same value.
     *
     * @param obj The object to be compared
     * @return {@code true} if the objects are the same; {@code false} otherwise
     */
    public boolean equals(Object obj) {
        if (!(obj instanceof KUID)) {
            return false;
        }
        KUID id = (KUID) obj;
        return msb == id.msb && lsb == id.lsb;
    }
}

penggunaan KUID:

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            KUID kuid = KUID.randomKUID();
            System.out.println(kuid.toString());
        }

    }
}

Ini akan menghasilkan sesuatu seperti ini:

LJVa90PC5N0LJVa90PC5N0
8SYCyPz9NXp8SYCyPz9NXp
8ucdhnCeYdk8ucdhnCeYdk
7QaHvqldPIL7QaHvqldPIL
8031jRPF3DS8031jRPF3DS
9oec5uzuIpg9oec5uzuIpg
4EAtrqG7CmF4EAtrqG7CmF
1vywu4ZzLz71vywu4ZzLz7
19YC4JE4W7619YC4JE4W76
8al7UWmt4Q28al7UWmt4Q2