TimescaleDB vs ClickHouse: การเปรียบเทียบประสิทธิภาพการจัดเก็บ Tick ระดับสำหรับระบบเทรด HFT แบบครบวงจร

ผมเคยทำงานเป็นวิศวกร backend ให้กับโบรกเกอร์รายหนึ่งในฮ่องกง และเจอปัญหาคลาสสิกอย่างหนึ่งคือ "เก็บ tick data ของ BTCUSDT เข้า TimescaleDB แล้วถาม VWAP ย้อนหลัง 1 ชั่วโมง บนข้อมูล 2 พันล้านแถว ใช้เวลา 8 วินาที" ตอนนั้นผมย้ายไปลอง ClickHouse แล้วเวลาหดเหลือ 180 ms ซึ่งเปลี่ยนเกมไปเลย บทความนี้เลยอยากมาแชร์ผลการทดสอบอย่างเป็นระบบ พร้อมโค้ด copy-paste รันได้จริง และส่วนท้ายจะพาไปดูว่า สมัครที่นี่ แล้วใช้ LLM ราคาถูกช่วยวิเคราะห์ผล benchmark ได้อย่างไร

ตารางเปรียบเทียบบริการ LLM API สำหรับงานวิเคราะห์ข้อมูล

ทำไมต้องทดสอบ TimescaleDB vs ClickHouse สำหรับ Tick Data

• Tick data ของคริปโต 1 คู่เงิน เช่น BTCUSDT บน Binance สร้างแถวใหม่ประมาณ 50-200 แถวต่อวินาที หรือประมาณ 5-10 พันล้านแถวต่อปี
• PostgreSQL ล้วนเก็บได้แต่ query ช้ามากเมื่อเกิน 100 ล้านแถว เพราะไม่มี columnar engine
• TimescaleDB เพิ่ม hypertable + compression เข้ามาแก้ปัญหานี้ แต่ยังคงใช้ row-based storage
• ClickHouse ใช้ columnar + MergeTree + vectorized execution ซึ่งออกแบบมาเพื่องาน analytical โดยเฉพาะ
• คำถามสำคัญคือ "ความเร็วต่างกันเท่าไร และคุ้มกับความซับซ้อนที่เพิ่มขึ้นหรือไม่"

สถาปัตยกรรมของทั้งสองระบบ

TimescaleDB

• ส่วนขยายของ PostgreSQL เก็บข้อมูลเป็น row-based
• แบ่งข้อมูลเป็น chunk ตามเวลา (hypertable)
• Compression ใช้ algorithm แบบ gorillas + delta-of-delta ลดขนาดได้ประมาณ 90-95%
• Query planner ใช้ของ PostgreSQL ไม่มี vectorized execution

ClickHouse

• Columnar database เก็บข้อมูลแยกตามคอลัมน์
• MergeTree engine แบ่งเป็น part และ merge background
• Compression ใช้ codec ต่อคอลัมน์ (DoubleDelta, Gorilla, ZSTD) ลดขนาดได้ 10-20 เท่า
• มี vectorized query engine ที่ประมวลผลทีละ batch ของคอลัมน์

โค้ดตั้งค่า TimescaleDB และทดสอบ Ingest

# timescaledb_setup.py
ทดสอบ: Python 3.11, psycopg2-binary 2.9, TimescaleDB 2.14
import psycopg2
from psycopg2.extras import execute_values
import time, random
from datetime import datetime, timedelta

conn = psycopg2.connect(
    host="localhost", port=5432,
    dbname="market_data", user="trader", password="secret"
)
cur = conn.cursor()

1) สร้างตารางและ hypertable
cur.execute("""
CREATE TABLE IF NOT EXISTS ticks_btcusdt (
    ts     TIMESTAMPTZ NOT NULL,
    price  DOUBLE PRECISION NOT NULL,
    volume DOUBLE PRECISION NOT NULL,
    side   SMALLINT
);
""")
cur.execute("""
SELECT create_hypertable('ticks_btcusdt', 'ts',
    chunk_time_interval => INTERVAL '1 hour',
    if_not_exists => TRUE);
""")

2) เปิด compression หลังจากข้อมูลเก่าเกิน 7 วัน
cur.execute("""
ALTER TABLE ticks_btcusdt SET (
    timescaledb.compress,
    timescaledb.compress_segmentby = 'side',
    timescaledb.compress_orderby   = 'ts DESC'
);
""")
cur.execute("SELECT add_compression_policy('ticks_btcusdt', INTERVAL '7 days');")
conn.commit()

3) ฟังก์ชันสร้างข้อมูล tick จำลอง
def gen(n=100_000):
    base = datetime.now()
    price = 50000.0
    out = []
    for i in range(n):
        price += random.uniform(-10, 10)
        out.append((
            base + timedelta(microseconds=i*100),
            price,
            random.uniform(0.001, 1.0),
            random.choice([0, 1])
        ))
    return out

4) วัด throughput ของ bulk insert
N = 500_000
rows = gen(N)
t0 = time.time()
execute_values(cur,
    "INSERT INTO ticks_btcusdt (ts, price, volume, side) VALUES %s",
    rows, page_size=10_000)
conn.commit()
elapsed = time.time() - t0
print(f"TimescaleDB ingest: {N:,} rows in {elapsed:.2f}s -> {N/elapsed:,.0f} rows/s")

cur.close(); conn.close()

โค้ดตั้งค่า ClickHouse และทดสอบ Ingest

# clickhouse_setup.py
ทดสอบ: clickhouse-driver 0.2.7, ClickHouse 24.3
import clickhouse_driver, time, random
from datetime import datetime, timedelta

ch = clickhouse_driver.Client(host="localhost", port=9000, database="market")

1) สร้างตาราง MergeTree พร้อม codec บีบอัดต่อคอลัมน์
ch.execute("""
CREATE TABLE IF NOT EXISTS ticks_btcusdt (
    ts     DateTime64(6) CODEC(DoubleDelta, ZSTD(3)),
    price  Float64       CODEC(Gorilla, ZSTD(3)),
    volume Float64       CODEC(Gorilla, ZSTD(3)),
    side   UInt8         CODEC(ZSTD(1))
) ENGINE = MergeTree()
PARTITION BY toYYYYMMDD(ts)
ORDER BY (ts)
TTL ts + INTERVAL 90 DAY
SETTINGS index_granularity = 8192;
""")

def gen(n=100_000):
    base = datetime.now()
    price = 50000.0
    out = []
    for i in range(n):
        price += random.uniform(-10, 10)
        out.append((
            base + timedelta(microseconds=i*100),
            price,
            random.uniform(0.001, 1.0),
            random.choice([0, 1])
        ))
    return out

2) วัด throughput ของ bulk insert
N = 1_000_000
rows = gen(N)
t0 = time.time()
ch.execute("INSERT INTO ticks_btcusdt VALUES", rows)
elapsed = time.time() - t0
print(f"ClickHouse ingest:  {N:,} rows in {elapsed:.2f}s -> {N/elapsed:,.0f} rows/s")

โค้ดเปรียบเทียบ Query Latency (VWAP 1 นาที)

# benchmark_query.py
import psycopg2, clickhouse_driver, time, statistics

pg = psycopg2.connect(host="localhost", dbname="market_data",
                     user="trader", password="secret").cursor()
ch = clickhouse_driver.Client(host="localhost", port=9000)

PG_SQL = """
SELECT time_bucket('1 minute', ts) AS bucket,
       sum(price*volume)/sum(volume) AS vwap,
       count(*) AS ticks
FROM ticks_btcusdt
WHERE ts >= NOW() - INTERVAL '1 hour'
GROUP BY bucket ORDER BY bucket DESC;
"""

CH_SQL = """
SELECT toStartOfMinute(ts) AS bucket,
       sum(price*volume)/sum(volume) AS vwap,
       count() AS ticks
FROM ticks_btcusdt
WHERE ts >= now() - INTERVAL 1 HOUR
GROUP BY bucket ORDER BY bucket DESC;
"""

def bench(cur, sql, label, runs=20):
    times = []
    for _ in range(runs):
        t0 = time.perf_counter()
        cur.execute(sql); cur.fetchall() if hasattr(cur, "fetchall") else None
        times.append((time.perf_counter() - t0) * 1000)
    p50 = statistics.median(times)
    p95 = sorted(times)[int(len(times)*0.95) - 1]
    print(f"{label:>12}  p50={p50:7.1f} ms  p95={p95:7.1f} ms")
    return p50, p95

รัน 20 รอบเพื่อให้ได้ค่า p50 และ p95 ที่น่าเชื่อถือ
bench(pg, PG_SQL, "TimescaleDB")
bench(ch, CH_SQL, "ClickHouse")

โค้ดเรียก HolySheep API เพื่อสรุปผล Benchmark อัตโนมัติ

# summarize_with_holysheep.py
import requests, json

ส่งผล benchmark ให้ LLM ช่วยวิเคราะห์
payload = {
    "model": "deepseek-chat",
    "messages": [
        {"role": "system", "content": "คุณคือวิศวกรฐานข้อมูลอาวุโส ตอบเป็นภาษาไทยเท่านั้น"},
        {"role": "user", "content":
         "ผล benchmark:\n- TimescaleDB ingest 95,000 rows/s, query p50 4,200 ms\n"
         "- ClickHouse ingest 410,000 rows/s, query p50 180 ms\n"
         "ช่วยสรุปเป็น bullet 3 ข้อ พร้อมแนะนำว่าควรเลือกตัวไหนสำหรับงาน HFT"}
    ],
    "temperature": 0.2,
    "max_tokens": 500
}

r = requests.post(
    "https://api.holysheep.ai/v1/chat/completions",
    headers={
        "Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY",
        "Content-Type": "application/json"
    },
    json=payload, timeout=10
)
print(json.dumps(r.json(), indent=2, ensure_ascii=False))

ผลลัพธ์ Benchmark จริง (Hardware: AWS c6i.4xlarge, 16 vCPU

แหล่งข้อมูลที่เกี่ยวข้อง

• 📚 บทช่วยสอน AI API
• 💰 ดูราคา
• 📖 เอกสารสำหรับนักพัฒนา
• 🚀 สมัครฟรี

บทความที่เกี่ยวข้อง

• tardis binance okx bybit tick sync for crypto arbi