query

type AggregateResult struct {
	Count   int64
	Sum     float64
	Average float64
	Min     any
	Max     any
}

type BatchExecutor interface {
	QueryExecutor
	ExecuteBatchGet(input *CompiledBatchGet, dest any) error
	ExecuteBatchWrite(input *CompiledBatchWrite) error
}

type BatchGetResult struct {
	Responses       []map[string]types.AttributeValue
	UnprocessedKeys []map[string]types.AttributeValue
}

type BatchResult struct {
	Succeeded       int
	Failed          int
	UnprocessedKeys []any
	Errors          []error
}

type BatchUpdateOptions struct {
	// MaxBatchSize limits items per batch (max 25 for DynamoDB)
	MaxBatchSize int
	// Parallel enables parallel batch execution
	Parallel bool
	// MaxConcurrency limits concurrent batches
	MaxConcurrency int
	// ProgressCallback is called after each batch
	ProgressCallback func(processed, total int)
	// ErrorHandler handles individual item errors
	ErrorHandler func(item any, err error) error
	// RetryPolicy defines retry behavior
	RetryPolicy *RetryPolicy
}

type BatchWriteItemExecutor interface {
	QueryExecutor
	ExecuteBatchWriteItem(tableName string, writeRequests []types.WriteRequest) (*core.BatchWriteResult, error)
}

type CompiledBatchGet struct {
	TableName                string
	Keys                     []map[string]types.AttributeValue
	ProjectionExpression     string
	ExpressionAttributeNames map[string]string
	ConsistentRead           bool
}

type CompiledBatchWrite struct {
	TableName string
	Items     []map[string]types.AttributeValue
}

type CompiledScan struct {
	TableName                 string
	FilterExpression          string
	ProjectionExpression      string
	ExpressionAttributeNames  map[string]string
	ExpressionAttributeValues map[string]types.AttributeValue
	Limit                     *int32
	ExclusiveStartKey         map[string]types.AttributeValue
	ConsistentRead            bool
	Segment                   *int32
	TotalSegments             *int32
}

type Condition struct {
	Field    string
	Operator string
	Value    any
}

type CostEstimate struct {
	ReadCapacityUnits  float64
	WriteCapacityUnits float64
	EstimatedItemCount int64
	EstimatedScanCount int64
	EstimatedDuration  time.Duration
	ConfidenceLevel    float64 // 0.0 to 1.0
}

type Cursor struct {
	LastEvaluatedKey map[string]any `json:"lastKey"`
	IndexName        string         `json:"index,omitempty"`
	SortDirection    string         `json:"sort,omitempty"`
}

type DeleteItemExecutor interface {
	QueryExecutor
	ExecuteDeleteItem(input *core.CompiledQuery, key map[string]types.AttributeValue) error
}

type DynamoDBAPI interface {
	Query(ctx context.Context, params *dynamodb.QueryInput, optFns ...func(*dynamodb.Options)) (*dynamodb.QueryOutput, error)
	Scan(ctx context.Context, params *dynamodb.ScanInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error)
	GetItem(ctx context.Context, params *dynamodb.GetItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.GetItemOutput, error)
	PutItem(ctx context.Context, params *dynamodb.PutItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.PutItemOutput, error)
	UpdateItem(ctx context.Context, params *dynamodb.UpdateItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.UpdateItemOutput, error)
	DeleteItem(ctx context.Context, params *dynamodb.DeleteItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DeleteItemOutput, error)
	BatchGetItem(ctx context.Context, params *dynamodb.BatchGetItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.BatchGetItemOutput, error)
	BatchWriteItem(ctx context.Context, params *dynamodb.BatchWriteItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.BatchWriteItemOutput, error)
}

type Filter struct {
	Expression string
	Params     map[string]any
}

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

type GroupedResult struct {
	Key        any
	Count      int64
	Items      []any
	Aggregates map[string]*AggregateResult
}

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

type OptimizationOptions struct {
	EnableAdaptive bool
	EnableParallel bool
	MaxParallelism int
	PlanCacheTTL   time.Duration
	MaxCacheSize   int
}

type OptimizedQuery struct {
	*Query
	// contains filtered or unexported fields
}

type OrderBy struct {
	Field string
	Order string // "asc" or "desc"
}

type PaginatedQueryExecutor interface {
	QueryExecutor
	ExecuteQueryWithPagination(input *core.CompiledQuery, dest any) (*QueryResult, error)
	ExecuteScanWithPagination(input *core.CompiledQuery, dest any) (*ScanResult, error)
}

type PaginatedResult struct {
	Items        any    `json:"items"`
	NextCursor   string `json:"nextCursor,omitempty"`
	Count        int    `json:"count"`
	HasMore      bool   `json:"hasMore"`
	ScannedCount int    `json:"scannedCount,omitempty"`
}

type PutItemExecutor interface {
	QueryExecutor
	ExecutePutItem(input *core.CompiledQuery, item map[string]types.AttributeValue) error
}

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

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

type QueryExecutionResult struct {
	Duration      time.Duration
	ItemsReturned int64
	ItemsScanned  int64
	Error         error
}

type QueryExecutor interface {
	ExecuteQuery(input *core.CompiledQuery, dest any) error
	ExecuteScan(input *core.CompiledQuery, dest any) error
}

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

type QueryPlan struct {
	ID                string
	Operation         string   // Query, Scan, BatchGet
	IndexName         string   // Which index to use
	Projections       []string // Fields to project
	EstimatedCost     *CostEstimate
	OptimizationHints []string // Human-readable optimization suggestions
	ParallelSegments  int      // For parallel scans
	CachedAt          time.Time
	Statistics        *QueryStatistics
}

type QueryResult struct {
	Items            []map[string]types.AttributeValue
	Count            int64
	ScannedCount     int64
	LastEvaluatedKey map[string]types.AttributeValue
}

type QueryStatistics struct {
	ExecutionCount    int64
	ErrorCount        int64
	TotalDuration     time.Duration
	AverageDuration   time.Duration
	MinDuration       time.Duration
	MaxDuration       time.Duration
	TotalItemsRead    int64
	TotalItemsScanned int64
	LastExecuted      time.Time
	ErrorRate         float64
}

type RawFilter struct {
	Expression string
	Params     []core.Param
}

type RetryPolicy struct {
	MaxRetries    int
	InitialDelay  time.Duration
	MaxDelay      time.Duration
	BackoffFactor float64
}

type ScanResult struct {
	Items            []map[string]types.AttributeValue
	Count            int64
	ScannedCount     int64
	LastEvaluatedKey map[string]types.AttributeValue
}

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

type UpdateItemExecutor interface {
	QueryExecutor
	ExecuteUpdateItem(input *core.CompiledQuery, key map[string]types.AttributeValue) error
}

type UpdateItemWithResultExecutor interface {
	UpdateItemExecutor
	ExecuteUpdateItemWithResult(input *core.CompiledQuery, key map[string]types.AttributeValue) (*core.UpdateResult, error)
}