services

type BenchmarkConfig ¶

type BenchmarkConfig struct {
	TraceCount  int
	Concurrency int
	Timeout     time.Duration
}

type BenchmarkResult ¶

type BenchmarkResult struct {
	ModelName       string
	Throughput      float64 // traces/sec
	AvgLatency      float64 // ms
	P95Latency      float64
	P99Latency      float64
	MemoryUsageMB   float64
	CPUUsagePercent float64
	ValidationScore float64 // 0-1
	ErrorRate       float64 // 0-1
}

type BenchmarkRunner ¶

type BenchmarkRunner struct {
	Models   []TraceGeneratorModel
	Analyzer *PerformanceAnalyzer
}

func NewBenchmarkRunner(models []TraceGeneratorModel) *BenchmarkRunner

func (r *BenchmarkRunner) Run(
	ctx context.Context,
	config BenchmarkConfig,
) ([]BenchmarkResult, error)

type BoundUniformSampler ¶

type BoundUniformSampler struct {
	// contains filtered or unexported fields
}

BoundUniformSampler adapts a uniform sampling strategy.

func (s *BoundUniformSampler) Sample() (interface{}, error)

type BoundWeightedSampler ¶

type BoundWeightedSampler struct {
	// contains filtered or unexported fields
}

BoundWeightedSampler adapts the generic WeightedRandomSampler to the ModelSampler interface.

func (s *BoundWeightedSampler) Sample() (interface{}, error)

type BoundZipfSampler ¶

type BoundZipfSampler struct {
	// contains filtered or unexported fields
}

BoundZipfSampler adapts the generic ZipfSampler to the ModelSampler interface by binding it to a specific ParameterModel.

func (s *BoundZipfSampler) Sample() (interface{}, error)

type ExecutionService ¶

type ExecutionService struct {
	// contains filtered or unexported fields
}

ExecutionService is responsible for running a benchmark workload and collecting performance metrics.

func NewExecutionService(rc RateController, slowThreshold time.Duration) *ExecutionService

func (s *ExecutionService) Reset()

func (s *ExecutionService) RunBench(ctx context.Context, wl *models.BenchmarkWorkload) (*models.PerformanceMetrics, error)

type GenerationConfig ¶

type GenerationConfig struct {
	TotalQueries int
	ScaleFactor  float64
}

GenerationConfig holds configuration for workload generation.

type HotspotDetector ¶

type HotspotDetector struct {
	Threshold float64 // e.g. 0.05 for Top 5%
}

func NewHotspotDetector() *HotspotDetector

func (d *HotspotDetector) DetectDistribution(stats *ParameterStats) *models.ParameterModel

type MetricsRecorder ¶

type MetricsRecorder struct {
	// contains filtered or unexported fields
}

MetricsRecorder is responsible for recording performance metrics during a benchmark run. It is designed to be thread-safe.

func NewMetricsRecorder(slowThreshold time.Duration) *MetricsRecorder

func (r *MetricsRecorder) Finalize(totalDuration time.Duration) *models.PerformanceMetrics

func (r *MetricsRecorder) Record(latency time.Duration, err error)

type ModelSampler ¶

type ModelSampler interface {
	Sample() (interface{}, error)
}

ModelSampler defines the interface for a sampler bound to a specific parameter model.

type ParamType ¶

type ParamType int

const (
	ParamTypeUnknown ParamType = iota
	ParamTypeInt
	ParamTypeString
	ParamTypeDatetime
)

type ParameterAnalyzer ¶

type ParameterAnalyzer struct {
	MaxCardinality int // Max unique values to track per parameter
	// contains filtered or unexported fields
}

func NewParameterAnalyzer() *ParameterAnalyzer

func (a *ParameterAnalyzer) Analyze(traces []models.SQLTrace) map[string]*models.ParameterModel

type ParameterExtractor ¶

type ParameterExtractor interface {
	Extract(sql string, template *models.SQLTemplate) (map[string]interface{}, error)
}

ParameterExtractor defines the interface for extracting parameters from SQL queries.

type ParameterService ¶

type ParameterService struct {
	// contains filtered or unexported fields
}

ParameterService is responsible for building a statistical model of parameters from SQL traces.

func NewParameterService() *ParameterService

func (s *ParameterService) BuildModel(tc models.TraceCollection, templates []models.SQLTemplate) *models.WorkloadParameterModel

type ParameterStats ¶

type ParameterStats struct {
	ParamName   string
	Type        ParamType
	ValueCounts map[interface{}]int
	TotalCount  int
}

type Parser ¶

type Parser interface {
	// ListTables extracts the table names from a given SQL query.
	ListTables(sql string) ([]string, error)
}

Parser is the interface for a SQL parser. It defines the contract for any parser implementation, whether it's regex-based or a full-fledged AST parser.

type PerformanceAnalyzer ¶

type PerformanceAnalyzer struct{}

func (a *PerformanceAnalyzer) CalculateAverage(values []float64) float64

func (a *PerformanceAnalyzer) CalculatePercentile(values []float64, percentile float64) float64

func (a *PerformanceAnalyzer) CalculateValidationScore(
	original, generated []models.SQLTrace,
	validator *StatisticalValidator,
) float64

func (a *PerformanceAnalyzer) GetResourceUsage() (memoryMB float64, cpuPercent float64)

type RateController ¶

type RateController interface {
	Start(ctx context.Context)
	Acquire(ctx context.Context) error
	Stop()
	MaxConcurrency() int
}

RateController defines the interface for controlling the rate and concurrency of execution.

type RegexParameterExtractor ¶

type RegexParameterExtractor struct {
	// contains filtered or unexported fields
}

RegexParameterExtractor extracts parameter values using regex matching against the template.

func (r *RegexParameterExtractor) Extract(sql string, template *models.SQLTemplate) (map[string]interface{}, error)

type ReportGenerator ¶

type ReportGenerator struct{}

ReportGenerator generates validation reports from test results.

func NewReportGenerator() *ReportGenerator

func (g *ReportGenerator) Generate(
	distResults, temporalResults, queryResults []ValidationResult,
) *ValidationReport

type Sampler ¶

type Sampler interface {
	// Sample selects a value from the distribution based on the sampling strategy.
	Sample(dist *models.ParameterModel) (interface{}, error)
}

Sampler is the interface for parameter value samplers.

type SchemaExtractor ¶

type SchemaExtractor interface {
	// ExtractSchema connects to a database and extracts its schema.
	ExtractSchema(ctx context.Context) (*models.DatabaseSchema, error)
}

SchemaExtractor defines the interface for extracting a database schema.

type SchemaLoader ¶

type SchemaLoader interface {
	// LoadSchema connects to a database and applies the given schema.
	LoadSchema(ctx context.Context, schema *models.DatabaseSchema) error
}

SchemaLoader defines the interface for loading a database schema.

type SchemaService ¶

type SchemaService struct {
	// contains filtered or unexported fields
}

SchemaService is responsible for schema-related operations, such as conversion.

func NewSchemaService() *SchemaService

func (s *SchemaService) ConvertTo(sourceSchema *models.DatabaseSchema, targetDialect string) (*models.DatabaseSchema, error)

func (s *SchemaService) RegisterTypeMapper(dialect string, mapper TypeMapper)

type StatisticalValidator ¶

type StatisticalValidator struct {
	KSThreshold        float64
	ChiSquareThreshold float64
}

StatisticalValidator performs statistical tests on datasets.

func NewStatisticalValidator(ksThreshold, chiSquareThreshold float64) *StatisticalValidator

func (v *StatisticalValidator) ChiSquareTest(observedFreq, expectedFreq []int) *ValidationResult

func (v *StatisticalValidator) JensenShannonDivergence(p, q []float64) float64

func (v *StatisticalValidator) KolmogorovSmirnovTest(observed, expected []float64) *ValidationResult

type Synthesizer ¶

type Synthesizer struct {
	// contains filtered or unexported fields
}

Synthesizer is responsible for filling SQL templates with synthetic data based on statistical parameter models.

func NewSynthesizer(workloadModel *models.WorkloadParameterModel) *Synthesizer

func (s *Synthesizer) FillParameters(tmpl *models.SQLTemplate) ([]interface{}, error)

type TemplateService ¶

type TemplateService struct{}

TemplateService is responsible for processing raw SQL traces and extracting SQL templates. It normalizes SQL queries to group them into templates and calculates the frequency of each template.

func NewTemplateService() *TemplateService

func (s *TemplateService) ExtractTemplates(tc models.TraceCollection) []models.SQLTemplate

type TemporalPattern ¶

type TemporalPattern struct {
	Window    time.Duration
	BinCounts map[int]int // key=time bin index, value=query count
}

type TemporalPatternExtractor ¶

type TemporalPatternExtractor struct {
	Window time.Duration
}

func (e *TemporalPatternExtractor) Extract(traces []models.SQLTrace) *TemporalPattern

type TokenBucketRateController ¶

type TokenBucketRateController struct {
	// contains filtered or unexported fields
}

TokenBucketRateController implements a rate controller using the token bucket algorithm combined with time.Sleep to ensure smooth distribution.

func NewTokenBucketRateController(targetQPS, maxConcurrency int) *TokenBucketRateController

func (c *TokenBucketRateController) Acquire(ctx context.Context) error

func (c *TokenBucketRateController) MaxConcurrency() int

func (c *TokenBucketRateController) Start(ctx context.Context)

func (c *TokenBucketRateController) Stop()

type TraceGeneratorModel ¶

type TraceGeneratorModel interface {
	Name() string
	// Generate generates a specific number of traces.
	Generate(ctx context.Context, count int) ([]models.SQLTrace, error)
}

TraceGeneratorModel defines the interface for workload generation models in benchmarking.

type TypeMapper ¶

type TypeMapper func(sourceType string) (string, error)

TypeMapper defines the interface for mapping data types between different database dialects.

type ValidationReport ¶

type ValidationReport struct {
	GeneratedAt       time.Time
	OverallScore      float64 // 0-100
	DistributionTests []ValidationResult
	TemporalTests     []ValidationResult
	QueryTypeTests    []ValidationResult
	Summary           string
}

ValidationReport contains the aggregated results of all validation tests.

type ValidationResult ¶

type ValidationResult struct {
	TestName string
	PValue   float64
	Passed   bool
	Details  map[string]interface{}
}

ValidationResult represents the result of a statistical test.

type ValidationService ¶

type ValidationService struct {
	// contains filtered or unexported fields
}

ValidationService is responsible for comparing benchmark runs and generating a structured report.

func NewValidationService() *ValidationService

func (s *ValidationService) ValidateAndReport(
	baseMetrics, candMetrics *models.PerformanceMetrics,
	metadata *models.ReportMetadata,
	outputPath string,
) (*models.Report, error)

type WeightedRandomSampler ¶

type WeightedRandomSampler struct {
	// contains filtered or unexported fields
}

WeightedRandomSampler selects a value from a distribution based on its observed frequency.

func NewSeededWeightedRandomSampler(seed int64) *WeightedRandomSampler

func NewWeightedRandomSampler() *WeightedRandomSampler

func (s *WeightedRandomSampler) Sample(dist *models.ParameterModel) (interface{}, error)

type WorkloadService ¶

type WorkloadService struct {
	// contains filtered or unexported fields
}

WorkloadService is responsible for generating a benchmark workload.

func NewWorkloadService(sampler Sampler) *WorkloadService

func (s *WorkloadService) GenerateWorkload(
	ctx context.Context,
	templates []models.SQLTemplate,
	pm *models.WorkloadParameterModel,
	config GenerationConfig,
) (*models.BenchmarkWorkload, error)

type ZipfSampler ¶

type ZipfSampler struct {
	// contains filtered or unexported fields
}

ZipfSampler selects a value from a distribution based on a Zipfian distribution. It prioritizes the stored ZipfS parameter if available.

func NewSeededZipfSampler(seed int64, s float64) *ZipfSampler

func NewZipfSampler(s float64) *ZipfSampler

func (z *ZipfSampler) Sample(dist *models.ParameterModel) (interface{}, error)