-- Simple Query: 정상 차단
INSERT INTO orders VALUES (1, 'test');
→ "cannot execute write query: pgmux is in read-only mode"

-- 1단계: Parse (read-only 전환 전)
Parse("INSERT INTO orders VALUES ($1, $2)")
Bind(params...)
Execute
Sync
→ 성공

-- 2단계: admin에서 read-only 모드 활성화

-- 3단계: 같은 prepared statement 재사용 (Parse 없이)
Bind(params...)     ← Parse가 없으므로 extIsWrite 미설정
Execute
Sync
→ 성공!? ← read-only 우회

// query.go — Parse 때만 설정
case protocol.MsgParse:
    if s.classifyQuery(query) == router.QueryWrite {
        extIsWrite = true   // ← Parse가 있을 때만 실행
    }

// Sync 때 체크
case protocol.MsgSync:
    if s.InReadOnly() && extIsWrite {  // extIsWrite가 false → 통과
        // reject...
    }
    // 배치 끝에서 리셋
    extIsWrite = false

// router.go
type Session struct {
    stmtRoutes map[string]Route
    stmtWrite  map[string]bool  // 추가: statement별 write 분류
}

func (s *Session) RegisterStatement(name, query string) Route {
    route := s.routeLocked(query)
    s.stmtRoutes[name] = route
    // write 분류도 함께 저장
    if s.astParser {
        s.stmtWrite[name] = ClassifyAST(query) == QueryWrite
    } else {
        s.stmtWrite[name] = Classify(query) == QueryWrite
    }
    return route
}

func (s *Session) StatementIsWrite(name string) bool {
    if isWrite, ok := s.stmtWrite[name]; ok {
        return isWrite
    }
    return true  // 모르면 write로 간주 (safe default)
}

case protocol.MsgBind:
    route := session.StatementRoute(stmtName)
    if route == router.RouteWriter {
        extRoute = router.RouteWriter
    }
    // 추가: write 분류 복원
    if session.StatementIsWrite(stmtName) {
        extIsWrite = true
    }

-- 행 잠금 획득 (reader에서 실행 불가)
SELECT * FROM orders WHERE id = 1 FOR UPDATE;

-- 시퀀스 값 증가 (writer에서만 실행해야 함)
SELECT nextval('order_id_seq');

-- 세션 파라미터 변경
SELECT set_config('statement_timeout', '5000', false);

-- Advisory lock 획득
SELECT pg_advisory_lock(12345);

// parser.go
var lockingClauses = []string{
    "FOR UPDATE", "FOR NO KEY UPDATE",
    "FOR SHARE", "FOR KEY SHARE",
}

var sideEffectFuncs = []string{
    "NEXTVAL(", "SETVAL(", "CURRVAL(",
    "SET_CONFIG(", "PG_ADVISORY_LOCK(",
    "PG_ADVISORY_XACT_LOCK(", "PG_ADVISORY_UNLOCK(",
    "PG_TRY_ADVISORY_LOCK(", "PG_NOTIFY(",
    "LO_CREATE(", "LO_UNLINK(",
}

func isSideEffectfulSelect(query string) bool {
    stripped := stripStringLiterals(query)
    upper := strings.ToUpper(stripped)
    for _, lc := range lockingClauses {
        if strings.Contains(upper, lc) { return true }
    }
    return hasSideEffectFunc(upper)
}

if kw == "SELECT" {
    upper := strings.ToUpper(query)
    if strings.Contains(upper, "FOR UPDATE") || ... || hasSideEffectFunc(upper) {
        return 0, false  // full parser로 위임
    }
    return QueryRead, true
}

// parser_ast.go
case *pg_query.Node_SelectStmt:
    s := n.SelectStmt
    // CTE 체크 (기존)
    // ...
    // Locking clause: FOR UPDATE, FOR SHARE 등
    if len(s.GetLockingClause()) > 0 {
        return true
    }
    // 부작용 함수 호출
    return hasSideEffectFuncCalls(node)

/* timeout:5s */ SELECT * FROM large_table;

// query.go — Sync 핸들러
extQueryTimeout := s.getConfig().Pool.QueryTimeout  // global만!

// executeSynthesizedQuery — timer 없이 relay
if err := protocol.WriteMessage(wConn, protocol.MsgQuery, queryPayload); err != nil { ... }
if err := s.relayUntilReady(clientConn, wConn); err != nil { ... }
// ← timeout 없이 무한 대기 가능

var extQueryText string  // 최신 Parse의 query 텍스트

case protocol.MsgParse:
    extQueryText = query  // 저장

case protocol.MsgSync:
    extQueryTimeout := s.resolveQueryTimeout(extQueryText, s.getConfig())

func (s *Server) executeSynthesizedQuery(ctx context.Context, ..., queryTimeout time.Duration, ...) error {
    ct.setFromConn(dbg.writerAddr, wConn)
    stopTimer := s.startQueryTimer(queryTimeout, ct, "writer")
    // ... relay ...
    if stopTimer != nil { stopTimer() }
    ct.clear()
}

// main.go
apiSrv := dataapi.New(..., srv.DefaultDBName(), ...)
//                         ^^^^^^^^^^^^^^^^^ 문자열 한 번 평가

// handler.go
type Server struct {
    defaultDB string  // 정적 필드
}

// handler.go
type Server struct {
    defaultDBFn func() string  // 동적 조회
}

func (s *Server) handleQuery(...) {
    dbName := r.URL.Query().Get("database")
    if dbName == "" {
        dbName = s.defaultDBFn()  // 매 요청마다 최신값
    }
}

// main.go
dataapi.New(..., srv.DefaultDBName, ...)  // 메서드 참조 (호출이 아님)

if c.Pool.MaxConnections < 1 {
    return fmt.Errorf("pool.max_connections must be >= 1")
}

databases:
  mydb:
    pool:
      max_connections: -5   # ← 검증 없이 통과
      idle_timeout: -1s     # ← 검증 없이 통과

for name, db := range c.Databases {
    // 기존: host/port 검증
    // 추가: pool 설정 검증
    if db.Pool.MaxConnections < 1 {
        return fmt.Errorf("databases.%s.pool.max_connections must be >= 1, got %d",
            name, db.Pool.MaxConnections)
    }
    if db.Pool.MinConnections < 0 { ... }
    if db.Pool.MinConnections > db.Pool.MaxConnections { ... }
    if db.Pool.IdleTimeout < 0 { ... }
    if db.Pool.MaxLifetime < 0 { ... }
    if db.Pool.ConnectionTimeout < 0 { ... }
    if db.Pool.QueryTimeout < 0 { ... }
}

// 변경 전
type Server struct {
    defaultDB string
}

// 변경 후
type Server struct {
    defaultDBFn func() string
}

func New(..., defaultDBFn func() string, ...) *Server

// handler_test.go — proxySrv.DefaultDBName()는 string을 반환
srv := New(..., proxySrv.DefaultDBName(), ...)
//                ^^^^^^^^^^^^^^^^^^^^^^ string, not func() string

// cancel_leak_test.go — 빈 문자열 리터럴
srv := New(..., "", ...)
//              ^^ string, not func() string

// handler_test.go — 4곳 수정
srv := New(
    func() *config.Config { return cfg },
    proxySrv.DBGroups,
    func() string { return proxySrv.DefaultDBName() }, // 함수 래퍼
    nilCache,
    nil,
    nilRateLimiter,
    nil,
)

// cancel_leak_test.go — 3곳 수정
srv := New(
    func() *config.Config { return cfg },
    nil,
    func() string { return "" }, // 빈 문자열 반환 함수
    nil, nil, nil, nil,
)

func (fw *FileWatcher) Start(ctx context.Context) error {
    dir := filepath.Dir(fw.path)
    if err := fw.watcher.Add(dir); err != nil {
        return fmt.Errorf("watch directory %s: %w", dir, err)
    }
    close(fw.readyCh)  // ← 감시 등록 완료 신호
    // event loop 진입...
}

func (fw *FileWatcher) Ready() <-chan struct{} {
    return fw.readyCh
}

go func() {
    fw.Start(ctx)
}()

time.Sleep(100 * time.Millisecond)  // watcher 초기화 "기다림"

os.WriteFile(cfgFile, []byte("modified"), 0644)

go func() {
    fw.Start(ctx)
}()

<-fw.Ready()  // 디렉토리 감시 등록이 완료될 때까지 대기

os.WriteFile(cfgFile, []byte("modified"), 0644)

$ go test -race ./internal/config/ -run TestFileWatcher -count=5
--- PASS: TestFileWatcher_Modification (1.50s)
--- PASS: TestFileWatcher_Debounce (2.01s)
--- PASS: TestFileWatcher_SymlinkSwap (1.51s)
--- PASS: TestFileWatcher_Stop (1.50s)
(x5, 20/20 PASS)

func hasTxPrefix(query string) int {
    i := 0
    for i < len(query) && (query[i] == ' ' || query[i] == '\t' || ...) {
        i++  // 공백만 skip
    }
    rest := query[i:]
    ch := rest[0] | 0x20
    switch ch {
    case 'b': // BEGIN
    // ...

upper := strings.ToUpper(strings.TrimSpace(stmt))
if strings.HasPrefix(upper, "BEGIN") {  // "/*X*/ BEGIN"은 매칭 실패

func SkipLeadingNoise(query string) int {
    i := 0
    for i < len(query) {
        ch := query[i]
        if ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' {
            i++
            continue
        }
        if i+1 < len(query) && ch == '/' && query[i+1] == '*' {
            depth := 1
            i += 2
            for i < len(query) && depth > 0 {
                if i+1 < len(query) && query[i] == '/' && query[i+1] == '*' {
                    depth++; i += 2
                } else if i+1 < len(query) && query[i] == '*' && query[i+1] == '/' {
                    depth--; i += 2
                } else {
                    i++
                }
            }
            continue
        }
        if i+1 < len(query) && ch == '-' && query[i+1] == '-' {
            i += 2
            for i < len(query) && query[i] != '\n' { i++ }
            if i < len(query) { i++ }
            continue
        }
        break
    }
    return i
}

// 변경 전 (proxy/query.go, 2곳)
upper := strings.ToUpper(strings.TrimSpace(query))
if strings.HasPrefix(upper, "BEGIN") { extTxStart = true }
if strings.HasPrefix(upper, "COMMIT") { extTxEnd = true }

// 변경 후
if txStart, txEnd := router.IsTxControl(query); txStart {
    extTxStart = true
} else if txEnd {
    extTxEnd = true
}

func detectSingleStmtDependency(query string) SessionDependencyResult {
    i := 0
    for i < len(query) && (query[i] == ' ' || ...) { i++ } // 공백만
    rest := query[i:]
    ch := rest[0] | 0x20
    switch ch {
    case 's': // SET
    case 'l': // LISTEN

func isSessionModifying(query string) bool {
    i := 0
    for i < len(query) && (query[i] == ' ' || ...) { i++ } // 공백만

// session_compat.go
func detectSingleStmtDependency(query string) SessionDependencyResult {
    i := SkipLeadingNoise(query) // 주석도 skip
    // ...
}

// backend.go
func isSessionModifying(query string) bool {
    i := router.SkipLeadingNoise(query) // 주석도 skip
    // ...
}

var writeKeywords = map[string]bool{
    "INSERT": true, "UPDATE": true, "DELETE": true,
    "CREATE": true, "ALTER": true, "DROP": true,
    "TRUNCATE": true, "GRANT": true, "REVOKE": true,
}

var writeKeywords = map[string]bool{
    // ... 기존 9개 ...
    "MERGE": true,
    "COPY":  true,  // COPY TO도 write로 분류 (안전한 기본값)
    "CALL":  true,
}

case *pg_query.Node_MergeStmt:
    return true
case *pg_query.Node_CopyStmt:
    return n.CopyStmt.GetIsFrom()  // COPY FROM만 write, COPY TO는 read
case *pg_query.Node_CallStmt:
    return true
case *pg_query.Node_ExplainStmt:
    // EXPLAIN ANALYZE + write subquery만 write
    for _, opt := range n.ExplainStmt.GetOptions() {
        if de := opt.GetDefElem(); de != nil &&
           strings.ToLower(de.GetDefname()) == "analyze" {
            if n.ExplainStmt.GetQuery() != nil {
                return isWriteNode(n.ExplainStmt.GetQuery())
            }
        }
    }
    return false

func containsSessionAdvisoryLock(query string) bool {
    lower := strings.ToLower(query)
    return strings.Contains(lower, "advisory_lock") ||
           strings.Contains(lower, "advisory_unlock")
}

func containsSessionAdvisoryLock(query string) bool {
    lower := strings.ToLower(query)
    // Fast path: raw 쿼리에 "advisory"가 없으면 skip
    if !strings.Contains(lower, "advisory") {
        return false
    }
    // Slow path: 리터럴과 주석 제거 후 검사
    cleaned := strings.ToLower(stripComments(stripStringLiterals(query)))
    return strings.Contains(cleaned, "advisory_lock") ||
           strings.Contains(cleaned, "advisory_unlock")
}

func isSideEffectfulSelect(query string) bool {
    upper := strings.ToUpper(stripStringLiterals(query))
    // "FOR UPDATE", "nextval(" 등을 검색
}

func containsWriteKeyword(query string) bool {
    upper := strings.ToUpper(stripStringLiterals(query))
    // INSERT, UPDATE 등을 검색
}

func isSideEffectfulSelect(query string) bool {
    upper := strings.ToUpper(stripComments(stripStringLiterals(query)))
    // ...
}

func containsWriteKeyword(query string) bool {
    upper := strings.ToUpper(stripComments(stripStringLiterals(query)))
    // ...
}

// 변경 전
errCh := make(chan error, 2)
go func() { errCh <- relayCopyData(clientConn, backendConn) }()
go func() { errCh <- relayCopyData(backendConn, clientConn) }()
err := <-errCh  // 하나만 기다림
return err

err1 := <-errCh
err2 := <-errCh
if err1 != nil {
    return err1
}
return err2

elapsed := now.Sub(rl.lastTime)
rl.tokens += elapsed.Seconds() * rl.rate

if elapsed < 0 {
    elapsed = 0
}

writeError(w, http.StatusInternalServerError, err.Error())
// → {"error": "ERROR: relation \"users\" does not exist (SQLSTATE 42P01)"}

writeError(w, http.StatusInternalServerError, "query execution failed")

// 변경 전
if e, ok := c.items[key]; ok {
    e.result = result
    e.tables = tables  // 이전 tables의 tableIndex 참조가 남음
    // ...
}

func (c *Cache) removeTableIndex(key uint64, tables []string) {
    for _, table := range tables {
        if keys, ok := c.tableIndex[table]; ok {
            delete(keys, key)
            if len(keys) == 0 {
                delete(c.tableIndex, table)
            }
        }
    }
}

if payloadLen > protocol.MaxMessageSize {
    return fmt.Errorf("backend message too large: %d bytes (max %d)",
        payloadLen, protocol.MaxMessageSize)
}

const maxSynthStatements = 10000

func (s *StatementStore) RegisterStatement(name string, ...) {
    if len(s.statements) >= maxSynthStatements {
        oldest := s.order[0]
        s.order = s.order[1:]
        delete(s.statements, oldest)
    }
    s.statements[name] = stmt
    s.order = append(s.order, name)
}

select {
case <-fw.Ready():
case <-ctx.Done():
    return ctx.Err()
case <-time.After(5 * time.Second):
    slog.Warn("config file watcher did not become ready within 5s, continuing")
}

sqlUpper := strings.ToUpper(strings.TrimSpace(req.SQL))
if strings.HasPrefix(sqlUpper, "COPY ") || strings.HasPrefix(sqlUpper, "COPY\t") {
    writeError(w, http.StatusBadRequest, "COPY is not supported via Data API")
    return
}

$ go build ./...     ✓
$ go vet ./...       ✓
$ go test ./internal/...
ok  internal/admin       0.013s
ok  internal/audit       1.015s
ok  internal/cache       0.004s
ok  internal/config      7.535s
ok  internal/dataapi     0.012s
ok  internal/digest      0.007s
ok  internal/metrics     0.003s
ok  internal/mirror      0.008s
ok  internal/pool        3.013s
ok  internal/protocol    0.003s
ok  internal/proxy       0.004s
ok  internal/resilience  0.103s
ok  internal/router      0.009s
ok  internal/telemetry   0.003s
14/14 PASS

// pool.go — Close()
p.closed = true
p.numOpen = 0  // ← 리셋

// pool.go — Acquire() (다른 goroutine)
for {
    p.mu.Lock()
    // ← p.closed 체크 없음!
    if p.numOpen < p.cfg.MaxConnections {  // 0 < 10 → true
        p.numOpen++
        p.mu.Unlock()
        conn, _ := p.newConn()  // 닫힌 풀에 새 연결 생성
        return conn, nil
    }
}

var ErrPoolClosed = fmt.Errorf("connection pool: closed")

func (p *Pool) Acquire(ctx context.Context) (*Conn, error) {
    // ...
    for {
        p.mu.Lock()

        if p.closed {
            p.mu.Unlock()
            return nil, ErrPoolClosed
        }

        // 기존 idle/newConn 로직...
    }
}

// 생성 시점 — dbCfg.Backend.Password = "old-password"
wp, _ := pool.New(pool.Config{
    DialFunc: func() (net.Conn, error) {
        return pgConnect(addr, dbCfg.Backend.User, dbCfg.Backend.Password, ...)
        // ↑ 클로저가 "old-password"를 영구적으로 잡고 있음
    },
})

// Reload 후 — 새 config에 "new-password"가 들어와도
// 기존 pool의 DialFunc는 여전히 "old-password"로 연결

func (g *DatabaseGroup) Reload(dbCfg config.DatabaseConfig, cbCfg config.CircuitBreakerConfig) {
    g.mu.Lock()
    defer g.mu.Unlock()

    oldCfg := g.backendCfg
    credChanged := oldCfg.User != dbCfg.Backend.User ||
        oldCfg.Password != dbCfg.Backend.Password ||
        oldCfg.Database != dbCfg.Backend.Database

    // Writer pool 재생성 (credential 변경 또는 주소 변경 시)
    newWriterAddr := fmt.Sprintf("%s:%d", dbCfg.Writer.Host, dbCfg.Writer.Port)
    if credChanged || newWriterAddr != g.writerAddr {
        if g.writerPool != nil {
            g.writerPool.Close()
        }
        g.writerPool = createWriterPool(newWriterAddr, dbCfg)
        g.writerAddr = newWriterAddr
    }

    // Reader pools — credential 변경 시 전부 재생성
    if credChanged {
        for _, p := range g.readerPools {
            p.Close()
        }
        // 모든 reader pool을 새 credential로 생성
    }
    // ...
}

func extractClientIP(r *http.Request) string {
    if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
        parts := strings.SplitN(xff, ",", 2)
        return strings.TrimSpace(parts[0])  // 클라이언트가 임의 설정 가능
    }
    host, _, _ := net.SplitHostPort(r.RemoteAddr)
    return host
}

func extractClientIP(r *http.Request, trustedProxies []string) string {
    host, _, _ := net.SplitHostPort(r.RemoteAddr)

    // trusted proxy에서 온 요청만 XFF 신뢰
    if len(trustedProxies) > 0 && isTrustedProxy(host, trustedProxies) {
        if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
            parts := strings.SplitN(xff, ",", 2)
            return strings.TrimSpace(parts[0])
        }
    }

    return host
}

admin:
  auth:
    enabled: true
    trusted_proxies: ["10.0.0.0/8"]  # 내부 LB 대역만 신뢰
    ip_allowlist: ["192.168.1.0/24"]

// balancer.go — 정의만 존재
func (r *RoundRobin) MarkUnhealthy(addr string) { ... }

// query_read.go — 에러 시 CB만 기록, MarkUnhealthy 미호출
if err != nil {
    if cb, ok := dbg.ReaderCB(readerAddr); ok {
        cb.RecordFailure()  // CB가 disabled면 아무 효과 없음
    }
    return s.fallbackToWriter(...)
}

// query_read.go — 수정 후
rConn, err := rPool.Acquire(poolCtx)
if err != nil {
    dbg.balancer.MarkUnhealthy(readerAddr)  // ← 추가
    if cb, ok := dbg.ReaderCB(readerAddr); ok {
        cb.RecordFailure()
    }
    return s.fallbackToWriter(...)
}

// query_extended.go — Set은 있지만
key := cache.WithNamespace(s.cacheKey(query, dbg.name), cache.NSExtended)
s.queryCache.Set(key, collected, tables)

// Get은 없다! handleExtendedRead() 시작부에 캐시 조회 로직이 누락

func (s *Server) handleExtendedRead(ctx context.Context, clientConn net.Conn,
    buf []*protocol.Message, syncMsg *protocol.Message, ...) error {

    // 캐시 조회 (추가)
    if s.queryCache != nil && len(buf) > 0 && buf[0].Type == protocol.MsgParse {
        _, query := protocol.ParseParseMessage(buf[0].Payload)
        key := cache.WithNamespace(s.cacheKey(query, dbg.name), cache.NSExtended)
        if cached := s.queryCache.Get(key); cached != nil {
            if s.metrics != nil {
                s.metrics.CacheHits.Inc()
            }
            _, err := clientConn.Write(cached)
            return err
        }
        if s.metrics != nil {
            s.metrics.CacheMisses.Inc()
        }
    }

    // 기존 backend 실행 로직...
}

// config.go — applyDefaults()
if c.Telemetry.SampleRatio == 0 {
    c.Telemetry.SampleRatio = 1.0  // "미설정"으로 취급해 덮어씀
}

// telemetry.go — 이 분기에 도달 불가
} else if cfg.SampleRatio <= 0 {
    sampler = sdktrace.NeverSample()
}

type TelemetryConfig struct {
    Enabled     bool     `yaml:"enabled"`
    SampleRatio *float64 `yaml:"sample_ratio"`  // nil = 미설정, 0 = NeverSample
    // ...
}

// applyDefaults()
if c.Telemetry.SampleRatio == nil {
    defaultRatio := 1.0
    c.Telemetry.SampleRatio = &defaultRatio
}

// query.go — COMMIT 시 반환
boundWriter = nil
dbg.writerPool.Release(wConn)  // ← reload 후 dbg.writerPool은 새 pool

var boundWriter *pool.Conn
var boundWriterPool *pool.Pool  // ← Acquire 시점의 pool 참조

// Acquire 시점
acquiredPool := dbg.writerPool  // 현재 pool 캡처
wConn, acquired, err := s.acquireWriterConn(ctx, boundWriter, dbg)

// BEGIN — bind
boundWriter = wConn
boundWriterPool = acquiredPool

// COMMIT — release (항상 원본 pool로)
resetAndReleaseToPool(wConn, boundWriterPool)

func (s *Server) resetAndReleaseToPool(conn *pool.Conn, p *pool.Pool) {
    if err := s.resetConn(conn); err != nil {
        p.Discard(conn)
        return
    }
    p.Release(conn)
}

_, query := protocol.ParseParseMessage(buf[0].Payload)
key := cache.WithNamespace(s.cacheKey(query, dbg.name), cache.NSExtended)

func hasParameterPlaceholders(buf []*protocol.Message) bool {
    for _, m := range buf {
        if m.Type == protocol.MsgParse {
            _, query := protocol.ParseParseMessage(m.Payload)
            for i := 0; i < len(query)-1; i++ {
                if query[i] == '$' && query[i+1] >= '1' && query[i+1] <= '9' {
                    return true
                }
            }
        }
    }
    return false
}

// Cache lookup
canCache := !hasParameterPlaceholders(buf)
if s.queryCache != nil && canCache && len(buf) > 0 && buf[0].Type == protocol.MsgParse {
    // ... cache Get ...
}

// Cache store
if canCache && collected != nil && ... {
    // ... cache Set ...
}

func (p *Pool) Close() {
    // ...
    p.numOpen = 0  // ← outstanding borrow(5개 중 3개 idle, 2개 borrowed)를 무시
}

func (p *Pool) Close() {
    // ...
    idleCount := len(p.idle)
    for _, conn := range p.idle {
        conn.Close()
    }
    p.idle = nil
    p.numOpen -= idleCount  // outstanding borrow는 보존
}

func (p *Pool) Discard(conn *Conn) {
    conn.Close()
    p.mu.Lock()
    if p.numOpen > 0 {
        p.numOpen--
    }
    p.mu.Unlock()
    // ...
}

if cbCfg.Enabled {
    // reader CBs만 갱신
    newCBs := make(map[string]*resilience.CircuitBreaker)
    for _, addr := range newReaderAddrs { ... }
    g.readerCBs = newCBs
    // writerCB → 미갱신!
}
// CB disabled 시 clear하는 else 분기도 없음

if cbCfg.Enabled {
    brCfg := resilience.BreakerConfig{...}

    // Writer CB — 없으면 생성, 있으면 상태 보존을 위해 유지
    if g.writerCB == nil {
        g.writerCB = resilience.NewCircuitBreaker(brCfg)
        slog.Info("reload: writer circuit breaker enabled", "db", g.name)
    }

    // Reader CBs (기존 코드)
    // ...
} else {
    // CB 비활성 — 양쪽 모두 정리
    if g.writerCB != nil {
        g.writerCB = nil
        slog.Info("reload: writer circuit breaker disabled", "db", g.name)
    }
    g.readerCBs = nil
}

// main.go
go func() {
    fw.Start(ctx)  // ← watcher.Add(dir)이 여기서 실행
}()
// ← 여기로 바로 진행. watcher가 arm됐는지 보장 없음

type FileWatcher struct {
    // ...
    readyCh chan struct{}
}

func (fw *FileWatcher) Start(ctx context.Context) error {
    dir := filepath.Dir(fw.path)
    if err := fw.watcher.Add(dir); err != nil {
        return err
    }
    close(fw.readyCh)  // ← watch가 arm된 후 시그널
    // event loop...
}

func (fw *FileWatcher) Ready() <-chan struct{} {
    return fw.readyCh
}

// main.go
go func() {
    fw.Start(ctx)
}()
<-fw.Ready()  // ← watch가 arm될 때까지 대기

// handleExtendedRead — fallbackToWriter
wConn, err := dbg.writerPool.Acquire(ctx)  // ← reload 후 다른 pool
// ...
dbg.writerPool.Discard(wConn)              // ← 또 다른 pool일 수 있음

fallbackToWriter := func() error {
    wPool := dbg.writerPool // capture before acquire
    wConn, err := wPool.Acquire(ctx)
    // ...
    wPool.Discard(wConn)   // 원본 pool로 반환
    // ...
    s.resetAndReleaseToPool(wConn, wPool)
}

Client A: Parse("SELECT 1") → Bind(resultFormat=text)  → Execute(maxRows=0)
Client B: Parse("SELECT 1") → Bind(resultFormat=binary) → Execute(maxRows=0)

Execute(maxRows=1)  → DataRow 1건 + PortalSuspended
Execute(maxRows=0)  → DataRow 전체 + CommandComplete

func hasBinaryFormatOrPartialFetch(buf []*protocol.Message) bool {
    for _, m := range buf {
        switch m.Type {
        case protocol.MsgBind:
            detail, err := protocol.ParseBindMessageFull(m.Payload)
            if err != nil {
                return true // parse 실패 → 안전하게 캐시 제외
            }
            for _, fc := range detail.ResultFormatCodes {
                if fc != 0 { // 0 = text, 1 = binary
                    return true
                }
            }
        case protocol.MsgExecute:
            // Execute: portal_name\0 + int32(maxRows)
            idx := bytes.IndexByte(m.Payload, 0)
            if idx >= 0 && idx+5 <= len(m.Payload) {
                maxRows := binary.BigEndian.Uint32(m.Payload[idx+1 : idx+5])
                if maxRows != 0 {
                    return true
                }
            }
        }
    }
    return false
}

cacheable := !hasParameterPlaceholders(buf) &&
             !hasBinaryFormatOrPartialFetch(buf)

collected, err := s.relayAndCollect(clientConn, rConn)
// ...
rPool.Release(rConn)  // ← 에러 확인 전에 Release!
if err != nil {
    dbg.balancer.MarkUnhealthy(readerAddr)
    return fmt.Errorf(...)
}

// query_read.go — 올바른 패턴
if err != nil {
    rPool.Discard(rConn)  // ← 에러 시 Discard
    // ...
}
rPool.Release(rConn)      // ← 성공 시에만 Release

collected, err := s.relayAndCollect(clientConn, rConn)
// ...
if err != nil {
    rPool.Discard(rConn)  // 깨진 연결은 버린다
    dbg.balancer.MarkUnhealthy(readerAddr)
    return fmt.Errorf(...)
}
rPool.Release(rConn)      // 성공 시에만 pool 복귀

Goroutine A (Acquire)        Goroutine B (Close)
─────────────────────        ──────────────────
p.numOpen++ (10→11)
p.mu.Unlock()
                             p.mu.Lock()
                             p.closed = true
                             // idle conn 정리
                             p.mu.Unlock()
conn, _ := p.newConn()
return conn, nil             // ← 닫힌 pool에서 live conn 탈출!

if p.numOpen < p.cfg.MaxConnections {
    p.numOpen++
    p.mu.Unlock()

    conn, err := p.newConn()
    if err != nil {
        p.mu.Lock()
        p.numOpen--
        p.mu.Unlock()
        return nil, err
    }

    // Re-check: Close() may have run while we were dialing.
    p.mu.Lock()
    if p.closed {
        p.numOpen--
        p.mu.Unlock()
        conn.Close()
        return nil, ErrPoolClosed
    }
    p.mu.Unlock()

    return conn, nil
}

if err := protocol.WriteMessage(wConn, protocol.MsgQuery, queryPayload); err != nil {
    ct.clear()
    if acquired {
        discardToPool(wConn, acquiredPool)
    }
    // ← !acquired (boundWriter 사용 중) 경로: 아무것도 안 함!
    return fmt.Errorf("send synthesized query: %w", err)
}

if acquired {
    discardToPool(wConn, acquiredPool)
} else {
    discardToPool(wConn, *boundWriterPool)
    *boundWriter = nil
    *boundWriterPool = nil
}

// query_read.go — 정상
if cb, ok := dbg.ReaderCB(readerAddr); ok {
    if err := cb.Allow(); err != nil {
        return s.fallbackToWriter(...)
    }
}
// ...
cb.RecordSuccess()  // 성공
cb.RecordFailure()  // 실패

// handleExtendedRead — CB check 추가
if cb, ok := dbg.ReaderCB(readerAddr); ok {
    if err := cb.Allow(); err != nil {
        slog.Warn("reader circuit breaker open for extended query", "addr", readerAddr)
        return fallbackToWriter()
    }
}

// ... 성공 경로
if cb, ok := dbg.ReaderCB(readerAddr); ok {
    cb.RecordSuccess()
}

// ... 에러 경로마다
if cb, ok := dbg.ReaderCB(readerAddr); ok {
    cb.RecordFailure()
}

// internal/router/router.go — 수정 전
func (s *Session) Route(query string) Route {
    // ...
    qtype := Classify(query)  // 항상 문자열 기반
    // ...
}

type Session struct {
    inTransaction       bool
    readAfterWriteDelay time.Duration
    causalConsistency   bool
    lastWriteLSN        LSN
    stmtRoutes          map[string]Route
    // astParser 필드 없음!
}

// internal/router/router.go — 수정 후
type Session struct {
    // ...
    astParser bool
    stmtRoutes map[string]Route
}

func NewSession(readAfterWriteDelay time.Duration, causalConsistency bool, astParser bool) *Session {
    return &Session{
        readAfterWriteDelay: readAfterWriteDelay,
        causalConsistency:   causalConsistency,
        astParser:           astParser,
        stmtRoutes:          make(map[string]Route),
    }
}

func (s *Session) Route(query string) Route {
    // ...
    var qtype QueryType
    if s.astParser {
        qtype = ClassifyAST(query)
    } else {
        qtype = Classify(query)
    }
    // ...
}

session := router.NewSession(cfg.Routing.ReadAfterWriteDelay, cfg.Routing.CausalConsistency, cfg.Routing.ASTParser)

// internal/proxy/query_read.go:137 — handleReadQueryTraced
s.queryCache.Set(key, collected, nil)  // tables가 nil!

// internal/proxy/query_read.go:258 — handleReadQuery
s.queryCache.Set(key, collected, nil)  // 여기도 nil!

// internal/proxy/query_extended.go:109 — handleExtendedRead
s.queryCache.Set(key, collected, nil)  // 여기도 nil!

func (c *Cache) updateTableIndex(key uint64, tables []string) {
    for _, t := range tables {  // tables가 nil이면 루프 진입 안 함
        c.tableIndex[t] = append(c.tableIndex[t], key)
    }
}

func (c *Cache) InvalidateTable(table string) {
    keys, ok := c.tableIndex[table]  // 비어있으므로 ok=false
    if !ok {
        return  // 즉시 반환 — 무효화 안 됨
    }
    // ...
}

// internal/router/parser_ast.go — 새 함수
func ExtractReadTablesAST(query string) []string {
    tree, err := ParseSQL(query)
    if err != nil {
        return ExtractReadTables(query) // 문자열 fallback
    }
    seen := make(map[string]bool)
    var tables []string
    WalkNodes(tree, func(node *pg_query.Node) bool {
        if rv := node.GetRangeVar(); rv != nil {
            t := strings.ToLower(rv.GetRelname())
            if t != "" && !seen[t] {
                seen[t] = true
                tables = append(tables, t)
            }
        }
        return true
    })
    return tables
}

// internal/proxy/query_read.go — 수정 후
tables := s.extractReadQueryTables(query)
s.queryCache.Set(key, collected, tables)  // nil → 실제 테이블명

func TestCache_InvalidateTable_ReadCacheWithTables(t *testing.T) {
    c := New(Config{MaxEntries: 100, TTL: time.Minute, MaxSize: 1024})

    c.Set(CacheKey("SELECT * FROM users"), []byte("users-result"), []string{"users"})
    c.Set(CacheKey("SELECT * FROM orders"), []byte("orders-result"), []string{"orders"})
    c.Set(CacheKey("SELECT * FROM users JOIN orders ..."), []byte("join-result"), []string{"users", "orders"})

    c.InvalidateTable("users")

    // users, join 캐시 삭제됨, orders는 유지
    if c.Len() != 1 { t.Errorf("Len() = %d, want 1", c.Len()) }
}

// internal/router/parsed_query.go
type ParsedQuery struct {
    SQL  string
    Tree *pg_query.ParseResult
}

func NewParsedQuery(sql string) (*ParsedQuery, error) {
    tree, err := pg_query.Parse(sql)
    if err != nil {
        return nil, fmt.Errorf("parse SQL: %w", err)
    }
    return &ParsedQuery{SQL: sql, Tree: tree}, nil
}

func ClassifyASTWithTree(query string, pq *ParsedQuery) QueryType { ... }
func CheckFirewallWithTree(pq *ParsedQuery, cfg FirewallConfig) FirewallResult { ... }
func ExtractTablesASTWithTree(pq *ParsedQuery) []string { ... }
func SemanticCacheKeyWithTree(tree *pg_query.ParseResult, query string) uint64 { ... }

// internal/proxy/query.go — 쿼리 루프 내
var parsedQuery *router.ParsedQuery
if queryCfg.Routing.ASTParser {
    if pq, err := router.NewParsedQuery(query); err == nil {
        parsedQuery = pq
    }
}

// 이후 모든 호출에 parsedQuery 전달
fwResult = router.CheckFirewallWithTree(parsedQuery, fwCfg)
qtype = s.classifyQueryParsed(query, parsedQuery)
key = s.cacheKeyParsed(query, parsedQuery)
tables = s.extractQueryTablesParsed(query, parsedQuery)

BenchmarkQueryPipeline_WithoutParsedQuery   25,000 ns/op   6,552 B/op   135 allocs/op
BenchmarkQueryPipeline_WithParsedQuery       7,300 ns/op   2,280 B/op    46 allocs/op

// internal/admin/admin.go — 수정 전
func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
    writerHealthy := checkTCP(writerAddr)          // 죽으면 2초
    for _, r := range cfg.Readers {
        readers = append(readers, backendHealth{
            Healthy: checkTCP(addr),               // 각각 2초
        })
    }
}

func checkTCP(addr string) bool {
    conn, err := net.DialTimeout("tcp", addr, 2*1e9)  // 2초 타임아웃
    // ...
}

// internal/admin/admin.go — 수정 후
readers := make([]backendHealth, len(cfg.Readers))
for i, rd := range cfg.Readers {
    readers[i].Addr = fmt.Sprintf("%s:%d", rd.Host, rd.Port)
}

var wg sync.WaitGroup
var writerHealthy bool

wg.Add(1)
go func() {
    defer wg.Done()
    writerHealthy = checkTCP(writerAddr)
}()

for i := range readers {
    wg.Add(1)
    go func(idx int) {
        defer wg.Done()
        readers[idx].Healthy = checkTCP(readers[idx].Addr)
    }(i)
}

wg.Wait()

func TestHandleHealth_ParallelTiming(t *testing.T) {
    // RFC 5737 TEST-NET 주소 — 무조건 타임아웃
    cfg := &config.Config{
        Writer:  config.DBConfig{Host: "192.0.2.1", Port: 9999},
        Readers: []config.DBConfig{
            {Host: "192.0.2.1", Port: 9999},
            {Host: "192.0.2.1", Port: 9999},
        },
    }
    // ...
    start := time.Now()
    srv.handleHealth(w, req)
    elapsed := time.Since(start)

    // 순차 시 ~6초, 병렬이면 ~2초
    if elapsed > 4*time.Second {
        t.Errorf("took %v; expected < 4s", elapsed)
    }
}

// internal/router/router.go — 수정 전
func splitStatements(query string) []string {
    inSingleQuote := false
    inDoubleQuote := false
    for i := 0; i < len(query); i++ {
        ch := query[i]
        switch {
        case ch == '\'' && !inDoubleQuote:
            inSingleQuote = !inSingleQuote  // '' 이스케이프도 오동작
        case ch == '"' && !inSingleQuote:
            inDoubleQuote = !inDoubleQuote
        case ch == ';' && !inSingleQuote && !inDoubleQuote:
            // 분리!
        }
    }
}

CREATE FUNCTION f() AS $$ BEGIN SELECT 1; END; $$ LANGUAGE plpgsql

func splitStatements(query string) []string {
    for i := 0; i < len(query); i++ {
        ch := query[i]

        // Dollar quoting: $$ 또는 $tag$ 감지 → 닫는 태그까지 skip
        if ch == '$' && !inSingleQuote && !inDoubleQuote {
            tag, ok := parseDollarTag(query, i)
            if ok {
                // opening tag + body + closing tag를 통째로 current에 추가
                // i를 closing tag 끝으로 이동
                continue
            }
        }

        // Line comment: -- → 줄 끝까지 skip
        if ch == '-' && !inSingleQuote && !inDoubleQuote && i+1 < len(query) && query[i+1] == '-' {
            for i < len(query) && query[i] != '\n' { current.WriteByte(query[i]); i++ }
            continue
        }

        // Block comment: /* → */ (중첩 지원)
        if ch == '/' && !inSingleQuote && !inDoubleQuote && i+1 < len(query) && query[i+1] == '*' {
            depth := 1
            // depth == 0 될 때까지 skip
            continue
        }

        // Escaped quote: '' → skip (기존 토글 방식 수정)
        // ...
    }
}

{"dollar-quoted function body",
 "CREATE FUNCTION f() AS $$ BEGIN SELECT 1; END; $$ LANGUAGE plpgsql", 1},
{"tagged dollar quote",
 "SELECT $tag$hello;world$tag$", 1},
{"line comment with semicolon",
 "SELECT 1; -- comment; here\nSELECT 2", 2},
{"block comment with semicolon",
 "SELECT 1; /* comment; here */ SELECT 2", 2},
{"nested block comment",
 "SELECT 1; /* outer /* inner; */ still; */ SELECT 2", 2},
{"escaped single quotes",
 "SELECT 'it''s;fine'; SELECT 2", 2},
{"mixed function with comments",
 "CREATE FUNCTION f() AS $$ BEGIN\n-- a; comment\nSELECT 1; /* block; */ END; $$ LANGUAGE plpgsql; SELECT 2", 2},

시나리오:
1. Data API: SELECT * FROM users → 캐시에 JSON 저장 (key=0xABCD)
2. Proxy client: SELECT * FROM users → 같은 키로 캐시 HIT
3. clientConn.Write(cached) → JSON 바이트가 PG wire로 전송
4. PostgreSQL 클라이언트: 프로토콜 파싱 실패 → 연결 끊김

// query_read.go:33 — 포맷 검증 없이 raw write
if cached := s.queryCache.Get(key); cached != nil {
    _, err := clientConn.Write(cached)
    return err
}

// internal/cache/cache.go
const (
    NSProxyWire uint64 = 0                    // 기본값 (proxy simple query)
    NSDataAPI   uint64 = 0xa5a5a5a5a5a5a5a5  // Data API JSON
    NSExtended  uint64 = 0x5a5a5a5a5a5a5a5a  // extended query wire
)

func WithNamespace(key uint64, ns uint64) uint64 {
    return key ^ ns
}

// Data API (handler.go)
key := cache.WithNamespace(s.cacheKeyParsed(sql, pq), cache.NSDataAPI)

// Extended query (query_extended.go)
key := cache.WithNamespace(s.cacheKey(query), cache.NSExtended)

// Proxy simple read — NS=0이므로 기존 코드 변경 없음

// handler.go:283 — 수정 전
tables := s.extractTablesParsed(sql, pq)
// → ExtractTablesASTWithTree → extractTablesFromTree → extractWriteTables
// → INSERT/UPDATE/DELETE 대상 테이블만 수집

// handler.go — 수정 후
tables := s.extractReadTablesParsed(sql, pq)
// → ExtractReadTablesASTWithTree → extractReadTablesFromTree
// → WalkNodes로 모든 RangeVar (FROM/JOIN) 수집

// balancer.go:105 — 수정 전
func (r *RoundRobin) UpdateBackends(addrs []string) {
    backends := make([]*Backend, len(addrs))
    for i, addr := range addrs {
        b := &Backend{Addr: addr}
        b.healthy.Store(true)  // 죽어있던 reader도 healthy로 리셋
        backends[i] = b        // replayLSN = 0
    }
    r.mu.Lock()
    r.backends = backends
    r.mu.Unlock()
}

// balancer.go — 수정 후
func (r *RoundRobin) UpdateBackends(addrs []string) {
    r.mu.RLock()
    oldMap := make(map[string]*Backend, len(r.backends))
    for _, b := range r.backends {
        oldMap[b.Addr] = b
    }
    r.mu.RUnlock()

    backends := make([]*Backend, len(addrs))
    for i, addr := range addrs {
        if old, ok := oldMap[addr]; ok {
            backends[i] = old  // 기존 상태 보존
        } else {
            b := &Backend{Addr: addr}
            b.healthy.Store(true)
            backends[i] = b
        }
    }
    r.mu.Lock()
    r.backends = backends
    r.mu.Unlock()
}

// main.go — 수정 전
go func() {
    if err := http.ListenAndServe(addr, mux); err != nil && err != http.ErrServerClosed {
        slog.Error("server error", "error", err)  // 로그만 남기고 끝
    }
}()

// main.go — 수정 후 (핵심)
ln, err := net.Listen("tcp", cfg.Admin.Listen)
if err != nil {
    return fmt.Errorf("admin server bind %s: %w", cfg.Admin.Listen, err)
}
httpServers = append(httpServers, adminHTTP)
go func() {
    if err := adminHTTP.Serve(ln); err != nil && err != http.ErrServerClosed {
        httpErrCh <- fmt.Errorf("admin server: %w", err)
    }
}()

// Graceful shutdown
go func() {
    <-ctx.Done()
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    for _, s := range httpServers {
        s.Shutdown(shutdownCtx)
    }
}()

// query_read.go — 수정 전
key := s.cacheKeyParsed(query, pq)         // ✓ pq 재활용
tables := s.extractReadQueryTables(query)  // ✗ 내부에서 ParseSQL(query) 다시 호출

// helpers.go
func (s *Server) extractReadQueryTablesParsed(query string, pq *router.ParsedQuery) []string {
    if s.getConfig().Routing.ASTParser && pq != nil {
        return router.ExtractReadTablesASTWithTree(pq)
    }
    return s.extractReadQueryTables(query)
}

// query_read.go — 수정 후
tables := s.extractReadQueryTablesParsed(query, pq)  // ✓ pq 재활용

// 수정 전
func SemanticCacheKey(query string) uint64 {
    fp, _ := pg_query.FingerprintToUInt64(query)
    return fp  // 리터럴 값이 제거된 구조 해시
}

-- A 유저
SELECT * FROM payment_logs WHERE user_id = 1;
-- B 유저
SELECT * FROM payment_logs WHERE user_id = 2;

// 수정 후
func SemanticCacheKey(query string) uint64 {
    tree, err := pg_query.Parse(query)
    if err != nil {
        return CacheKey(query)
    }
    deparsed, err := pg_query.Deparse(tree)
    if err != nil {
        return CacheKey(query)
    }
    h := fnv.New64a()
    h.Write([]byte(deparsed))
    return h.Sum64()
}

func TestSemanticCacheCollision(t *testing.T) {
    key1 := SemanticCacheKey("SELECT * FROM users WHERE id = 1")
    key2 := SemanticCacheKey("SELECT * FROM users WHERE id = 2")
    if key1 == key2 {
        t.Error("different literals must produce different cache keys")
    }
}

func TestSemanticCacheEquivalence(t *testing.T) {
    key1 := SemanticCacheKey("SELECT * FROM users WHERE id = 1")
    key2 := SemanticCacheKey("select  *  from  users  where  id  =  1")
    if key1 != key2 {
        t.Error("equivalent queries should produce the same cache key")
    }
}

func (s *Server) cacheKey(query string) uint64 {
    if s.cfg.Routing.ASTParser {
        return cache.SemanticCacheKey(query)
    }
    return s.cacheKey(query) // 자기 자신을 호출!
}

func (s *Server) cacheKey(query string) uint64 {
    if s.cfg.Routing.ASTParser {
        return cache.SemanticCacheKey(query)
    }
    return cache.CacheKey(query) // 패키지 함수 호출
}

func checkNode(node *pg_query.Node, cfg FirewallConfig) FirewallResult {
    switch n := node.GetNode().(type) {
    case *pg_query.Node_DeleteStmt:
        // WHERE 없는 DELETE 차단
    case *pg_query.Node_UpdateStmt:
        // WHERE 없는 UPDATE 차단
    case *pg_query.Node_DropStmt:
        // DROP 차단
    case *pg_query.Node_TruncateStmt:
        // TRUNCATE 차단
    // SelectStmt는? → 검사 안 함!
    }
}

WITH bypass AS (DELETE FROM users) SELECT 1;

case *pg_query.Node_SelectStmt:
    if wc := n.SelectStmt.GetWithClause(); wc != nil {
        for _, cte := range wc.GetCtes() {
            if ce := cte.GetCommonTableExpr(); ce != nil {
                if q := ce.GetCtequery(); q != nil {
                    if result := checkNode(q, cfg); result.Blocked {
                        return result
                    }
                }
            }
        }
    }

func ClassifyAST(query string) QueryType {
    // AST 모드인데 문자열 파서의 extractHint를 사용!
    if hint := extractHint(query); hint != "" {
        // ...
    }
}

func extractHintAST(query string) string {
    result, err := pg_query.Scan(query)
    if err != nil {
        return extractHint(query) // fallback
    }
    for _, token := range result.GetTokens() {
        if token.GetToken() == pg_query.Token_C_COMMENT {
            comment := query[token.GetStart():token.GetEnd()]
            matches := hintRegex.FindStringSubmatch(comment)
            if len(matches) >= 2 {
                return matches[1]
            }
        }
    }
    return ""
}

func TestClassifyAST_DollarQuotingHintInjection(t *testing.T) {
    // Dollar-quoted 문자열 안의 힌트는 무시되어야 함
    query := `SELECT $$ /* route:writer */ $$ FROM readonly_table`
    result := ClassifyAST(query)
    if result != QueryRead {
        t.Error("hint inside dollar quote should not affect routing")
    }
}

// Before: 응답 크기에 관계없이 무한정 수집
buf = append(buf, msgBytes...)

if !oversize {
    buf = append(buf, msgBytes...)
    if maxSize > 0 && len(buf) > maxSize {
        buf = nil     // 메모리 즉시 해제
        oversize = true
    }
}

// healthCheck 내부: Close()로 numOpen=0이 된 상태에서
for p.numOpen < p.cfg.MinConnections {
    conn, _ := p.newConn()  // 새 DB 커넥션 생성!
    p.numOpen++
}

type Pool struct {
    // ...
    done chan struct{} // Close 시 닫힘
}

func (p *Pool) Close() {
    if p.closed { return }
    p.closed = true
    close(p.done) // 헬스체크 고루틴 종료 신호
    // ...
}

func (p *Pool) StartHealthCheck(ctx context.Context, interval time.Duration) {
    go func() {
        for {
            select {
            case <-ctx.Done(): return
            case <-p.done: return     // Close 시 즉시 종료
            case <-ticker.C: p.healthCheck()
            }
        }
    }()
}

func (p *Pool) healthCheck() {
    if p.closed { return }  // 이중 방어
    // ...
}

SELECT 1; COMMIT;

func splitStatements(query string) []string {
    // 세미콜론으로 분리, 단 따옴표 내부의 세미콜론은 무시
    // "INSERT INTO t VALUES ('a;b')" → 1개의 문장
}

func (s *Session) updateTransactionState(query string) {
    for _, stmt := range splitStatements(query) {
        upper := strings.ToUpper(strings.TrimSpace(stmt))
        if strings.HasPrefix(upper, "BEGIN") { s.inTransaction = true }
        if strings.HasPrefix(upper, "COMMIT") { s.inTransaction = false }
    }
}

WITH x AS (UPDATE users SET score=0)
UPDATE ranking SET total=0;

// "WITH x AS (UPDATE users ...) UPDATE ranking ..." → ["users", "ranking"]
func extractCTETables(query string) []string {
    // INSERT INTO, UPDATE, DELETE FROM 키워드를 모두 찾아서 테이블명 추출
}

Proxy A: SELECT * FROM users → 캐시 저장
Proxy B: UPDATE users SET ... → Proxy B 캐시만 무효화
Proxy A: SELECT * FROM users → stale 캐시 반환 ❌

┌─────────┐     ┌─────────┐     ┌─────────┐
│ Proxy A │     │ Proxy B │     │ Proxy C │
│         │     │  WRITE  │     │         │
│ Cache ✓ │     │ Cache ✓ │     │ Cache ✓ │
└────┬────┘     └────┬────┘     └────┬────┘
     │ subscribe     │ publish       │ subscribe
     └───────┐  ┌────┘  ┌───────────┘
             ▼  ▼       ▼
         ┌──────────────────┐
         │  Redis Pub/Sub   │
         │  channel:        │
         │  pgmux:invalidate
         └──────────────────┘

cache:
  enabled: true
  invalidation:
    mode: "pubsub"           # "local" or "pubsub"
    redis_addr: "redis:6379"
    channel: "pgmux:invalidate"

// Before: length에 상한 제한 없음
payload := make([]byte, length-4)

→ make([]byte, 1GB)
→ OS가 1GB 메모리 할당
→ OOM 패닉 → 프록시 크래시

const MaxMessageSize = 16 * 1024 * 1024 // 16MB

func ReadMessage(r io.Reader) (*Message, error) {
    // ... type, length 읽기 ...

    payloadLen := int(length - 4)
    if payloadLen > MaxMessageSize {
        return nil, fmt.Errorf("message too large: %d bytes (max %d)",
            payloadLen, MaxMessageSize)
    }

    payload := make([]byte, payloadLen)
    // ...
}

func ReadStartupMessage(r io.Reader) (*Message, error) {
    // ...
    if length < 4 || length > 10000 {  // ← 이미 10KB 제한
        return nil, fmt.Errorf("invalid startup message length: %d", length)
    }

SELECT * FROM users WHERE note = '/* route:writer */ trick'

func stripStringLiterals(query string) string {
    var result strings.Builder
    inSingle, inDouble := false, false

    for i := 0; i < len(query); i++ {
        ch := query[i]
        switch {
        case ch == '\'' && !inDouble:
            result.WriteByte(ch)
            if inSingle {
                if i+1 < len(query) && query[i+1] == '\'' {
                    result.WriteByte('\'')
                    i++ // escaped quote ('')
                } else {
                    inSingle = false
                }
            } else {
                inSingle = true
            }
        case ch == '"' && !inSingle:
            result.WriteByte(ch)
            inDouble = !inDouble
        case inSingle || inDouble:
            // 따옴표 내부 콘텐츠 스킵
        default:
            result.WriteByte(ch)
        }
    }
    return result.String()
}

입력: SELECT * FROM users WHERE note = '/* route:writer */ trick'
변환: SELECT * FROM users WHERE note = ''
→ 힌트 매칭 실패 → QueryRead ✓

입력: SELECT 'it''s fine'
변환: SELECT ''''

-- 1) false cache invalidation
SELECT * FROM logs WHERE action = 'INSERT INTO admin_table'
→ "admin_table" 캐시 무효화 (오탐)

-- 2) false table extraction
WITH x AS (SELECT * FROM a WHERE b = 'INSERT INTO oops') SELECT 1
→ "oops')" 테이블 추출 (오탐 + 파싱 깨짐)

func containsWriteKeyword(query string) bool {
    upper := strings.ToUpper(stripStringLiterals(query))
    // ... 기존 word boundary 검사 ...
}

func extractCTETables(query string) []string {
    sanitized := stripStringLiterals(query)
    upper := strings.ToUpper(sanitized)
    // ... 기존 keyword 스캔 ...
}

원본 쿼리
  ↓ stripStringLiterals()     ← 문자열 리터럴 제거
  ↓ extractHint() / containsWriteKeyword() / extractCTETables()
  ↓ 분석 결과