152 lines
4.1 KiB
Go
152 lines
4.1 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"next.orly.dev/pkg/database"
|
|
)
|
|
|
|
// RelySQLiteBenchmark wraps a Benchmark with rely-sqlite-specific setup
|
|
type RelySQLiteBenchmark struct {
|
|
config *BenchmarkConfig
|
|
database database.Database
|
|
bench *BenchmarkAdapter
|
|
dbPath string
|
|
}
|
|
|
|
// NewRelySQLiteBenchmark creates a new rely-sqlite benchmark instance
|
|
func NewRelySQLiteBenchmark(config *BenchmarkConfig) (*RelySQLiteBenchmark, error) {
|
|
// Create database path
|
|
dbPath := filepath.Join(config.DataDir, "relysqlite.db")
|
|
|
|
// Ensure parent directory exists
|
|
if err := os.MkdirAll(config.DataDir, 0755); err != nil {
|
|
return nil, fmt.Errorf("failed to create data directory: %w", err)
|
|
}
|
|
|
|
// Remove existing database file if it exists
|
|
if _, err := os.Stat(dbPath); err == nil {
|
|
if err := os.Remove(dbPath); err != nil {
|
|
return nil, fmt.Errorf("failed to remove existing database: %w", err)
|
|
}
|
|
}
|
|
|
|
// Create wrapper
|
|
wrapper, err := NewRelySQLiteWrapper(dbPath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create rely-sqlite wrapper: %w", err)
|
|
}
|
|
|
|
// Wait for database to be ready
|
|
fmt.Println("Waiting for rely-sqlite database to be ready...")
|
|
select {
|
|
case <-wrapper.Ready():
|
|
fmt.Println("Rely-sqlite database is ready")
|
|
case <-time.After(10 * time.Second):
|
|
wrapper.Close()
|
|
return nil, fmt.Errorf("rely-sqlite database failed to become ready")
|
|
}
|
|
|
|
// Create adapter to use Database interface with Benchmark
|
|
adapter := NewBenchmarkAdapter(config, wrapper)
|
|
|
|
relysqliteBench := &RelySQLiteBenchmark{
|
|
config: config,
|
|
database: wrapper,
|
|
bench: adapter,
|
|
dbPath: dbPath,
|
|
}
|
|
|
|
return relysqliteBench, nil
|
|
}
|
|
|
|
// Close closes the rely-sqlite benchmark
|
|
func (rsb *RelySQLiteBenchmark) Close() {
|
|
fmt.Println("Closing rely-sqlite benchmark...")
|
|
|
|
if rsb.database != nil {
|
|
rsb.database.Close()
|
|
}
|
|
|
|
// Clean up database file
|
|
if rsb.dbPath != "" {
|
|
os.Remove(rsb.dbPath)
|
|
}
|
|
}
|
|
|
|
// RunSuite runs the benchmark suite on rely-sqlite
|
|
func (rsb *RelySQLiteBenchmark) RunSuite() {
|
|
fmt.Println("\n╔════════════════════════════════════════════════════════╗")
|
|
fmt.Println("║ RELY-SQLITE BACKEND BENCHMARK SUITE ║")
|
|
fmt.Println("╚════════════════════════════════════════════════════════╝")
|
|
|
|
// Run benchmark tests
|
|
fmt.Printf("\n=== Starting Rely-SQLite benchmark ===\n")
|
|
|
|
fmt.Printf("RunPeakThroughputTest (Rely-SQLite)..\n")
|
|
rsb.bench.RunPeakThroughputTest()
|
|
fmt.Println("Wiping database between tests...")
|
|
rsb.wipeDatabase()
|
|
time.Sleep(5 * time.Second)
|
|
|
|
fmt.Printf("RunBurstPatternTest (Rely-SQLite)..\n")
|
|
rsb.bench.RunBurstPatternTest()
|
|
fmt.Println("Wiping database between tests...")
|
|
rsb.wipeDatabase()
|
|
time.Sleep(5 * time.Second)
|
|
|
|
fmt.Printf("RunMixedReadWriteTest (Rely-SQLite)..\n")
|
|
rsb.bench.RunMixedReadWriteTest()
|
|
fmt.Println("Wiping database between tests...")
|
|
rsb.wipeDatabase()
|
|
time.Sleep(5 * time.Second)
|
|
|
|
fmt.Printf("RunQueryTest (Rely-SQLite)..\n")
|
|
rsb.bench.RunQueryTest()
|
|
fmt.Println("Wiping database between tests...")
|
|
rsb.wipeDatabase()
|
|
time.Sleep(5 * time.Second)
|
|
|
|
fmt.Printf("RunConcurrentQueryStoreTest (Rely-SQLite)..\n")
|
|
rsb.bench.RunConcurrentQueryStoreTest()
|
|
|
|
fmt.Printf("\n=== Rely-SQLite benchmark completed ===\n\n")
|
|
}
|
|
|
|
// wipeDatabase recreates the database for a clean slate
|
|
func (rsb *RelySQLiteBenchmark) wipeDatabase() {
|
|
// Close existing database
|
|
if rsb.database != nil {
|
|
rsb.database.Close()
|
|
}
|
|
|
|
// Remove database file
|
|
if rsb.dbPath != "" {
|
|
os.Remove(rsb.dbPath)
|
|
}
|
|
|
|
// Recreate database
|
|
wrapper, err := NewRelySQLiteWrapper(rsb.dbPath)
|
|
if err != nil {
|
|
log.Printf("Failed to recreate database: %v", err)
|
|
return
|
|
}
|
|
|
|
rsb.database = wrapper
|
|
rsb.bench.db = wrapper
|
|
}
|
|
|
|
// GenerateReport generates the benchmark report
|
|
func (rsb *RelySQLiteBenchmark) GenerateReport() {
|
|
rsb.bench.GenerateReport()
|
|
}
|
|
|
|
// GenerateAsciidocReport generates asciidoc format report
|
|
func (rsb *RelySQLiteBenchmark) GenerateAsciidocReport() {
|
|
rsb.bench.GenerateAsciidocReport()
|
|
}
|