parser_test.go

package main

import (
	"regexp"
	"strconv"
	"strings"
	"testing"
)

const sampleWALLine = `rmgr: Heap        len (rec/tot):     54/    54, tx:       1234, lsn: 0/01531F38, prev 0/01531F00, desc: INSERT off 8 flags 0x00, blkref #0: rel 1663/12345/16384 blk 42`

// OldParser is the regex-based parser for benchmarking comparison
type OldParser struct {
	lsnPattern  *regexp.Regexp
	descPattern *regexp.Regexp
	relPattern  *regexp.Regexp
	blkPattern  *regexp.Regexp
}

func NewOldParser() *OldParser {
	return &OldParser{
		lsnPattern:  regexp.MustCompile(`rmgr:\s+(\S+)\s+len\s+\(rec/tot\):\s*(\d+)/\s*(\d+),\s+tx:\s*(\d+),\s+lsn:\s+([0-9A-F/]+),\s+prev\s+([0-9A-F/]+)`),
		descPattern: regexp.MustCompile(`desc:\s+(.+)`),
		relPattern:  regexp.MustCompile(`rel\s+(\d+)/(\d+)/(\d+)(?:\s+(\w+))?`),
		blkPattern:  regexp.MustCompile(`blk\s+(\d+)`),
	}
}

func (p *OldParser) ParseLine(line string) (*WALRecord, error) {
	if strings.TrimSpace(line) == "" {
		return nil, nil
	}

	matches := p.lsnPattern.FindStringSubmatch(line)
	if matches == nil {
		return nil, nil
	}

	recLen, _ := strconv.Atoi(matches[2])
	totLen, _ := strconv.Atoi(matches[3])
	xid, _ := strconv.ParseInt(matches[4], 10, 64)

	record := &WALRecord{
		ResourceMgr: matches[1],
		Length:      recLen,
		TotalLength: totLen,
		XID:         xid,
		LSN:         matches[5],
		PrevLSN:     matches[6],
	}

	descMatches := p.descPattern.FindStringSubmatch(line)
	if descMatches != nil {
		record.Description = descMatches[1]
		
		parts := strings.Fields(record.Description)
		if len(parts) > 0 {
			record.RecordType = parts[0]
		}
		
		relMatches := p.relPattern.FindStringSubmatch(record.Description)
		if relMatches != nil {
			if ts, err := strconv.Atoi(relMatches[1]); err == nil {
				record.Tablespace = &ts
			}
			if db, err := strconv.Atoi(relMatches[2]); err == nil {
				record.Database = &db
			}
			if rel, err := strconv.Atoi(relMatches[3]); err == nil {
				record.Relfilenode = &rel
			}
		}
		
		blkMatches := p.blkPattern.FindStringSubmatch(record.Description)
		if blkMatches != nil {
			if blk, err := strconv.Atoi(blkMatches[1]); err == nil {
				record.BlockNumber = &blk
			}
		}
	}

	return record, nil
}

func TestParser(t *testing.T) {
	parser := NewParser()
	record, err := parser.ParseLine(sampleWALLine)
	
	if err != nil {
		t.Fatalf("Failed to parse line: %v", err)
	}
	
	if record == nil {
		t.Fatal("Expected record, got nil")
	}
	
	// Verify parsed fields
	if record.ResourceMgr != "Heap" {
		t.Errorf("Expected ResourceMgr 'Heap', got '%s'", record.ResourceMgr)
	}
	
	if record.Length != 54 {
		t.Errorf("Expected Length 54, got %d", record.Length)
	}
	
	if record.TotalLength != 54 {
		t.Errorf("Expected TotalLength 54, got %d", record.TotalLength)
	}
	
	if record.XID != 1234 {
		t.Errorf("Expected XID 1234, got %d", record.XID)
	}
	
	if record.LSN != "0/01531F38" {
		t.Errorf("Expected LSN '0/01531F38', got '%s'", record.LSN)
	}
	
	if record.PrevLSN != "0/01531F00" {
		t.Errorf("Expected PrevLSN '0/01531F00', got '%s'", record.PrevLSN)
	}
	
	if record.RecordType != "INSERT" {
		t.Errorf("Expected RecordType 'INSERT', got '%s'", record.RecordType)
	}
	
	if record.Tablespace == nil || *record.Tablespace != 1663 {
		t.Error("Expected Tablespace 1663")
	}
	
	if record.Database == nil || *record.Database != 12345 {
		t.Error("Expected Database 12345")
	}
	
	if record.Relfilenode == nil || *record.Relfilenode != 16384 {
		t.Error("Expected Relfilenode 16384")
	}
	
	if record.BlockNumber == nil || *record.BlockNumber != 42 {
		t.Error("Expected BlockNumber 42")
	}
}

func BenchmarkStateMachineParser(b *testing.B) {
	parser := NewParser()
	b.ResetTimer()
	
	for i := 0; i < b.N; i++ {
		_, _ = parser.ParseLine(sampleWALLine)
	}
}

func BenchmarkRegexParser(b *testing.B) {
	parser := NewOldParser()
	b.ResetTimer()
	
	for i := 0; i < b.N; i++ {
		_, _ = parser.ParseLine(sampleWALLine)
	}
}

func BenchmarkStateMachineParserNoRelation(b *testing.B) {
	line := `rmgr: Heap        len (rec/tot):     54/    54, tx:       1234, lsn: 0/01531F38, prev 0/01531F00, desc: INSERT off 8 flags 0x00`
	parser := NewParser()
	b.ResetTimer()
	
	for i := 0; i < b.N; i++ {
		_, _ = parser.ParseLine(line)
	}
}

func BenchmarkRegexParserNoRelation(b *testing.B) {
	line := `rmgr: Heap        len (rec/tot):     54/    54, tx:       1234, lsn: 0/01531F38, prev 0/01531F00, desc: INSERT off 8 flags 0x00`
	parser := NewOldParser()
	b.ResetTimer()
	
	for i := 0; i < b.N; i++ {
		_, _ = parser.ParseLine(line)
	}
}