sql

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

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

type Config struct {
	// DSN is the data source name for database connection.
	// Format depends on the driver:
	// - PostgreSQL: "postgres://user:pass@host:port/dbname?sslmode=disable"
	// - SQLite: "file:./data.db?mode=rw" or ":memory:"
	DSN string `mapstructure:"dsn"`

	// Parameterized queries (SQL injection prevention)
	// Can be map[string]any for named params or []any for positional params
	Params any `mapstructure:"params"`

	// Execution settings
	Timeout        int    `mapstructure:"timeout"`         // Query timeout in seconds (default: 60)
	Transaction    bool   `mapstructure:"transaction"`     // Wrap execution in transaction
	IsolationLevel string `mapstructure:"isolation_level"` // Transaction isolation level

	// Locking
	AdvisoryLock string `mapstructure:"advisory_lock"` // Named advisory lock (PostgreSQL)
	FileLock     bool   `mapstructure:"file_lock"`     // Use file locking (SQLite)

	// SQLite-specific options
	SharedMemory bool `mapstructure:"shared_memory"` // Enable shared cache for :memory: databases (SQLite)

	// Output settings
	OutputFormat string `mapstructure:"output_format"` // jsonl (default), json, csv
	Headers      bool   `mapstructure:"headers"`       // Include headers in CSV output
	NullString   string `mapstructure:"null_string"`   // String representation for NULL values

	// Large result handling
	MaxRows    int    `mapstructure:"max_rows"`    // Maximum rows to return (0 = unlimited)
	Streaming  bool   `mapstructure:"streaming"`   // Stream results to file
	OutputFile string `mapstructure:"output_file"` // File path for streaming output

	// Import settings
	Import *ImportConfig `mapstructure:"import"` // Import data from file
}

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

type Driver interface {
	// Name returns the driver identifier (e.g., "postgres", "sqlite")
	Name() string

	// Connect establishes a connection to the database using the provided configuration.
	// Returns a *sql.DB instance and any error encountered.
	Connect(ctx context.Context, cfg *Config) (*sql.DB, func() error, error)

	// SupportsAdvisoryLock indicates if the driver supports advisory locking.
	SupportsAdvisoryLock() bool

	// AcquireAdvisoryLock acquires a named advisory lock (PostgreSQL-specific).
	// Returns a release function and any error.
	AcquireAdvisoryLock(ctx context.Context, db *sql.DB, lockName string) (func() error, error)

	// ConvertNamedParams converts named parameters (:param) to driver-specific format ($1, ?).
	// Returns the converted query and ordered parameter values.
	ConvertNamedParams(query string, params map[string]any) (string, []any, error)

	// PlaceholderFormat returns the placeholder format for the driver ("$" for PostgreSQL, "?" for SQLite).
	PlaceholderFormat() string

	// BuildInsertQuery generates a multi-row INSERT statement for batch imports.
	// table: target table name
	// columns: column names to insert
	// rowCount: number of rows in this batch
	// onConflict: conflict handling strategy ("error", "ignore", "replace")
	// conflictTarget: column(s) for conflict detection (required for PostgreSQL UPSERT with "replace")
	// updateColumns: columns to update on conflict (if empty, updates all non-key columns)
	// Returns the SQL query string with placeholders.
	BuildInsertQuery(table string, columns []string, rowCount int, onConflict, conflictTarget string, updateColumns []string) string

	// QuoteIdentifier quotes a table or column name to handle reserved words and special characters.
	// For PostgreSQL and SQLite, this wraps the identifier in double quotes.
	QuoteIdentifier(name string) string
}

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

type ExecutionMetrics struct {
	QueryHash    string    `json:"query_hash"`
	StartedAt    time.Time `json:"started_at"`
	FinishedAt   time.Time `json:"finished_at"`
	DurationMs   int64     `json:"duration_ms"`
	RowsAffected int64     `json:"rows_affected,omitempty"`
	RowsReturned int64     `json:"rows_returned,omitempty"`
	Status       string    `json:"status"`
	Error        string    `json:"error,omitempty"`
}

type GlobalPoolConfig struct {
	// MaxOpenConns is the maximum total open connections across all DSNs.
	MaxOpenConns int

	// MaxIdleConns is the maximum idle connections per DSN.
	MaxIdleConns int

	// ConnMaxLifetime is the maximum lifetime of a connection.
	ConnMaxLifetime time.Duration

	// ConnMaxIdleTime is the maximum idle time for a connection.
	ConnMaxIdleTime time.Duration
}

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

type ImportConfig struct {
	// Required fields
	InputFile string `mapstructure:"input_file"` // Path to input file
	Table     string `mapstructure:"table"`      // Target table name

	// Format options
	Format    string `mapstructure:"format"`     // csv, tsv, jsonl (auto-detect if empty)
	HasHeader *bool  `mapstructure:"has_header"` // Whether first row is header (default: true for csv/tsv)
	Delimiter string `mapstructure:"delimiter"`  // Field delimiter (default: "," for csv, "\t" for tsv)

	// Column mapping
	Columns []string `mapstructure:"columns"` // Explicit column names (overrides header)

	// NULL handling
	NullValues []string `mapstructure:"null_values"` // Values to treat as NULL

	// Batch settings
	BatchSize int `mapstructure:"batch_size"` // Rows per INSERT statement (default: 1000)

	// Conflict handling
	OnConflict     string   `mapstructure:"on_conflict"`     // error (default), ignore, replace
	ConflictTarget string   `mapstructure:"conflict_target"` // Column(s) for conflict detection (required for PostgreSQL UPSERT with "replace")
	UpdateColumns  []string `mapstructure:"update_columns"`  // Columns to update on conflict (driver support varies)

	// Row limits
	SkipRows int `mapstructure:"skip_rows"` // Skip first N data rows
	MaxRows  int `mapstructure:"max_rows"`  // Limit import (0 = unlimited)

	// Validation
	DryRun bool `mapstructure:"dry_run"` // Validate without importing
}

type ImportMetrics struct {
	StartedAt    time.Time `json:"started_at"`
	FinishedAt   time.Time `json:"finished_at"`
	DurationMs   int64     `json:"duration_ms"`
	RowsRead     int64     `json:"rows_read"`
	RowsImported int64     `json:"rows_imported"`
	RowsSkipped  int64     `json:"rows_skipped"`
	BatchCount   int       `json:"batch_count"`
	Status       string    `json:"status"`
	Error        string    `json:"error,omitempty"`
}

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

type InputOptions struct {
	HasHeader  bool     // Whether first row is header (CSV/TSV)
	Delimiter  rune     // Field delimiter (default: ',' for CSV, '\t' for TSV)
	NullValues []string // Values to treat as NULL
	Columns    []string // Expected column names (for JSONL)
}

type InputReader interface {
	// ReadHeader reads the column headers from the input.
	// Returns nil for formats without headers or when hasHeader is false.
	ReadHeader() ([]string, error)

	// ReadRow reads the next row of data.
	// Returns io.EOF when no more rows are available.
	ReadRow() ([]any, error)

	// Close releases any resources held by the reader.
	Close() error
}

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

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

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

type QueryExecutor interface {
	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
}

type ResultWriter interface {
	// WriteHeader writes the column headers (if applicable).
	WriteHeader(columns []string) error

	// WriteRow writes a single row of data.
	WriteRow(values []any) error

	// Flush ensures all buffered data is written.
	Flush() error

	// Close finalizes the writer.
	Close() error
}

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