largedataset

type Aggregator interface {
	Consume(row *LogicalRow)
	Report(w io.Writer)
}

type AmountStats struct {
	Count int64
	Sum   float64
	Min   float64
	Max   float64
}

type CSVSchema struct {
	Columns       []ColumnDef
	MinColumns    int  // Minimum number of columns required
	StrictColumns bool // If true, reject rows with extra columns
}

type ColumnDef struct {
	Index       int        // Column index (0-based)
	Name        string     // Column name (for documentation/errors)
	Type        ColumnType // Expected data type
	Required    bool       // Whether the column must be non-empty
	MinLength   int        // Minimum string length (for TypeString)
	MaxLength   int        // Maximum string length (for TypeString)
	Min         *float64   // Minimum value (for TypeInt/TypeFloat)
	Max         *float64   // Maximum value (for TypeInt/TypeFloat)
	Pattern     string     // Regex pattern (for TypeRegex)
	DateFormat  string     // Date format (for TypeDate/TypeDateTime)
	AllowedVals []string   // Whitelist of allowed values
}

type ColumnStats struct {
	Index          int
	Name           string
	TotalValues    int
	EmptyValues    int
	UniqueValues   map[string]bool
	NumericValues  int
	IntegerValues  int
	FloatValues    int
	BoolValues     int
	DateValues     int
	DateTimeValues int
	EmailValues    int
	MinNumeric     float64
	MaxNumeric     float64
	MinLength      int
	MaxLength      int
	SampleValues   []string // Keep first few samples
}

type ColumnType int

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

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

type Filter struct {
	ColumnIndex int            // Column index to filter on
	ColumnName  string         // Column name (for display)
	Operator    FilterOperator // Comparison operator
	Value       string         // Value to compare against
	NumValue    float64        // Parsed numeric value (for numeric comparisons)
	IsNumeric   bool           // Whether this is a numeric comparison
	RegexPat    *regexp.Regexp // Compiled regex pattern (for regex operator)
}

type FilterCondition struct {
	Filter *Filter
}

type FilterExpression interface {
	Evaluate(record []string) (bool, error)
	String() string
}

type FilterGroup struct {
	Operator    LogicalOperator
	Expressions []FilterExpression
}

type FilterOperator int

type FilterSet struct {
	Filters []*Filter        // Deprecated: kept for backward compatibility
	Root    FilterExpression // Root of the expression tree
}

type GlobalAmountAggregator struct {
	Stats *AmountStats
}

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

type LogicalOperator int

type LogicalRow struct {
	RawRecord []string // keep the original record if needed
	Amount    float64  // parsed numeric column
	GroupKey  string   // optional group-by key
}

type SchemaInferenceConfig struct {
	SampleSize       int     // Number of rows to analyze (0 = all)
	MinConfidence    float64 // Minimum confidence to infer type (0.0-1.0)
	MaxUniqueForEnum int     // Max unique values to consider as enum
	SampleCount      int     // Number of sample values to keepz
}

type ValidationError struct {
	Column   int
	ColName  string
	Value    string
	Expected string
}