Day 13: High-Performance Data Ingestion & Validation Engine

Section 0: The "Why" & Core Vocabulary

ในการประมวลผลธุรกรรมทางการเงินระดับ 100,000 TPS (Transactions Per Second) หรือการรับสัญญาณอ่านชิป RFID ในงานมาราธอนขนาดใหญ่ที่มีนักวิ่งเหยียบพรมจับเวลาพร้อมกันหลายพันคนในเสี้ยววินาที สถาปัตยกรรมแบบดั้งเดิมของ Spring Boot จะเผชิญปัญหาคอขวด 3 ด้าน:

Go ใช้แนวทาง Bare-Metal Stream Parsing: อ่านข้อมูลดิบเป็น []byte, ค้นหาตัวคั่น (Delimiter) ด้วยการสแกน Pointer, สกัดค่าตัวเลขด้วย strconv.ParseInt, และบันทึกผลการตรวจสอบด้วย Bitmask Error Flags ภายใน CPU Register ตัวเดียว!

Section 1: Go Syntax & Command Blueprint

การสร้าง Ingestion Engine ใน Go ต้องพึ่งพาฟังก์ชัน Standard Library ในแพ็กเกจ bytes และ strconv เพื่อหลีกเลี่ยงการจัดสรรหน่วยความจำบน Heap:

1.1 เครื่องมือสำคัญใน Standard Library

• bytes.IndexByte(b []byte, c byte) int: ค้นหาตำแหน่งของตัวอักษร 1 ไบต์แรกที่พบ (เช่น เครื่องหมายคอมมา ',' หรือไปป์ '|') ฟังก์ชันนี้เขียนด้วยคำสั่ง AVX2 / SSE SIMD Assembly ซึ่งค้นหาได้เร็วระดับ Hardware Instruction
• strconv.ParseInt(s string, base int, bitSize int) (int64, error): แปลงข้อความเป็นตัวเลข แต่ระวัง: ฟังก์ชันนี้ต้องการ string หากส่งผ่านบ่อยๆ จะเกิด Escape to Heap
• strconv.AppendInt(dst []byte, i int64, base int) []byte: แปลงตัวเลขกลับเป็น ASCII ไบต์โดยเขียนต่อท้าย Buffer เดิมแบบ Zero-Allocation

1.2 Zero-Allocation Delimiter Tokenizer Blueprint

แทนที่จะใช้ strings.Split หรือ bytes.Split ซึ่งสร้าง Slice ของชิ้นส่วนใหม่ ให้ใช้การสแกนแบบ Single-Pass Pointer:

package main

import (
    "bytes"
    "fmt"
)

// Zero-allocation field extractor
func NextField(data []byte, delim byte) (field []byte, remainder []byte) {
    idx := bytes.IndexByte(data, delim)
    if idx == -1 {
        return data, nil // ฟิลด์สุดท้ายของบรรทัด
    }
    return data[:idx], data[idx+1:]
}

func ProcessCSVLine(line []byte) {
    // สมมติ Record: "TX10928,50000,THB"
    remainder := line
    
    var txID, amountRaw, currency []byte
    txID, remainder = NextField(remainder, ',')
    amountRaw, remainder = NextField(remainder, ',')
    currency, _ = NextField(remainder, ',')

    // txID, amountRaw, currency เป็นเพียง Slice Headers ที่ชี้ไปยัง line เดิม!
    // มี Heap Allocation = 0 ไบต์ถ้วน!
    fmt.Printf("Parsed: ID=%s, Amount=%s, Cur=%s\n", txID, amountRaw, currency)
}

1.3 Custom Fast Integer Parser (Ascii-to-Int)

ฟังก์ชันแปลง ASCII Bytes เป็นตัวเลขทางการเงิน (เช่น สตางค์/เซนต์) โดยตรงจาก []byte ไม่ต้องผ่านการแปลงเป็น string:

// ParseIntFast แปลง ASCII []byte เป็น int64 แบบ zero-allocation
func ParseIntFast(b []byte) (int64, bool) {
    if len(b) == 0 {
        return 0, false
    }
    var n int64 = 0
    for _, c := range b {
        if c < '0' || c > '9' {
            return 0, false // ไม่ใช่ตัวเลข
        }
        n = n*10 + int64(c-'0')
    }
    return n, true
}

1.4 Bitmask Validation Rules Pattern

ในระบบธนาคาร แทนที่จะเก็บ []error ซึ่งสร้าง Pointer หลากหลายตัวบน Heap เราจะนิยาม Error ด้วย Bit Constants ภายในตัวแปร uint16:

type ValidationBitmask uint16

const (
    Valid                ValidationBitmask = 0
    ErrEmptyTxID         ValidationBitmask = 1 << 0 // 00000001
    ErrInvalidAmount     ValidationBitmask = 1 << 1 // 00000010
    ErrUnsupportedCur    ValidationBitmask = 1 << 2 // 00000100
    ErrNegativeTimestamp ValidationBitmask = 1 << 3 // 00001000
)

func ValidateTransaction(txID []byte, amount int64, cur []byte) ValidationBitmask {
    var flags ValidationBitmask = Valid

    if len(txID) == 0 {
        flags |= ErrEmptyTxID
    }
    if amount <= 0 {
        flags |= ErrInvalidAmount
    }
    // สกุลเงินต้องเป็น 3 ไบต์ เช่น "THB" หรือ "USD"
    if len(cur) != 3 {
        flags |= ErrUnsupportedCur
    }

    return flags // ส่งกลับตัวเลขขนาด 2 ไบต์ใน CPU Register ไม่แตะต้อง Heap เลย!
}

Section 2: Memory Architecture & Full Struct Definitions

เพื่อรับประกันว่า Ingestion Engine จะทำงานได้เร็วที่สุดในระดับฮาร์ดแวร์ โครงสร้างข้อมูลที่เก็บผลลัพธ์ของ Transaction และ RFID Pass ต้องถูกจัดเรียง Memory Alignment อย่างรัดกุมที่สุด

2.1 โครงสร้าง ParsedTransaction (64-bit Aligned)

// โครงสร้างบันทึกธุรกรรมที่ผ่านการ Ingest และ Validate แล้ว
type ParsedTransaction struct {
    Amount    int64             // 8 Bytes: Offset 0x00
    Timestamp int64             // 8 Bytes: Offset 0x08
    Status    ValidationBitmask // 2 Bytes: Offset 0x10
    Currency  [3]byte           // 3 Bytes: Offset 0x12 (เก็บ Fixed Array 3 ไบต์ ไม่ใช้ String/Slice)
    _         [3]byte           // 3 Bytes: Padding เพื่อ Align ให้ครบ 8 Bytes Boundary
    TxID      [16]byte          // 16 Bytes: Offset 0x18 (UUID/ID ขนาดคงที่ 16 ตัวอักษร)
} // รวมทั้งสิ้น = 40 Bytes พอดี (หาร 8 ลงตัว ไม่มี Memory Hole รั่วไหล)

2.2 Pre-allocated Ring / Batch Buffer Architecture

เมื่อต้องรับข้อมูล 10,000 รายการต่อ Batch เราจะไม่ทยอย append() ทีละตัว แต่จะจอง Slice Buffer ขนาดใหญ่ไว้ล่วงหน้า (Pre-allocated Chunk):

Section 3: Visual Workflow & Ingestion Pipeline Mechanics

เปรียบเทียบ Flow ของการประมวลผลข้อมูลในระบบ Ingestion ระหว่าง JVM Pipeline แบบดั้งเดิม กับ Go Zero-Alloc Pipeline

3.1 การไหลของข้อมูลใน Pipeline

3.2 Latency Breakdown เปรียบเทียบระดับ Hardware

Section 4: Edge Cases, Hazards & Idiomatic Patterns

// หายนะ: ดึง Sub-slice ขนาดเล็กจาก Buffer ยักษ์ไปเก็บถาวร
var longLivedMap = make(map[string][]byte)

func IngestRecord(giantBuffer []byte) {
    txID := giantBuffer[0:16] // Slice ขนาด 16 ไบต์ แต่ชี้ Underlying Array 10MB!
    longLivedMap["latest"] = txID // Buffer 10MB ทั้งก้อนติดอยู่ใน RAM ถาวร!
}

// วิธีแก้ที่ถูกต้อง: Clone เฉพาะข้อมูลที่ต้องการออกมา
func IngestRecordSafe(giantBuffer []byte) {
    txID := make([]byte, 16)
    copy(txID, giantBuffer[0:16]) // ทำการ Copy ข้อมูล 16 ไบต์ออกมาเป็นของตัวเอง
    longLivedMap["latest"] = txID // giantBuffer สามารถถูก GC เก็บกวาดได้อย่างปลอดภัย
}

Idiomatic Validation Design:

• Separate Validation from Mutation: การตรวจสอบข้อมูล (Validation) ต้องเป็น Pure Function ที่ไม่มี Side-effect รับข้อมูลเข้ามาและคืนค่า Bitmask/Error ออกไปเท่านั้น ห้ามแก้ไขข้อมูลในจังหวะนี้
• Collect Multiple Errors without Slice Allocation: ใช้ Bitmask ช่วยให้ฟังก์ชันสามารถรายงานความผิดพลาดได้พร้อมกันหลายๆ ข้อ (เช่น ยอดเงินติดลบพร้อมกับสกุลเงินไม่ถูกต้อง) โดยไม่ต้องจอง []error บน Heap

Section 5: Knowledge Verification Quiz (16 Challenges)

ทดสอบความเข้าใจเชิงลึกระดับ Runtime & Ingestion Architecture ทุกข้อมีคะแนนสะสมและอธิบายเหตุผลอย่างละเอียด

Section 6: Hands-on Engineering Labs

ลงมือสร้าง Ingestion & Validation Engine ตามหลักการ Zero-Allocation ตรวจสอบผลผ่าน Verification Engine