engine

type ConnectionPoolConfig struct {
	// MaxOpenConns is the maximum number of open connections to the database.
	// A value of 0 means no limit.
	MaxOpenConns int

	// MaxIdleConns is the maximum number of connections in the idle connection pool.
	// A value of 0 means no idle connections are retained.
	MaxIdleConns int

	// ConnMaxLifetime is the maximum amount of time a connection may be reused.
	// Expired connections may be closed lazily before reuse.
	// A value of 0 means connections are not closed due to age.
	ConnMaxLifetime time.Duration

	// ConnMaxIdleTime is the maximum amount of time a connection may be idle
	// before being closed.
	// A value of 0 means connections are not closed due to inactivity.
	ConnMaxIdleTime time.Duration
}

type Diagnostic struct {
	Path     string
	Line     int
	Column   int
	Message  string
	Severity Severity
}

type Engine interface {
	// Name returns the engine identifier (e.g., "sqlite", "postgresql", "mysql").
	Name() string

	// TypeMapper returns the type mapper for SQL-to-language conversions.
	TypeMapper() TypeMapper

	// SchemaParser returns the DDL parser for this database dialect.
	SchemaParser() schemaparser.SchemaParser

	// SQLGenerator returns the SQL DDL generator for this dialect.
	SQLGenerator() SQLGenerator

	// DefaultDriver returns the default Go driver import path for this database.
	DefaultDriver() string

	// SupportsFeature reports whether this engine supports a specific feature.
	SupportsFeature(feature Feature) bool

	// ConnectionPool returns recommended connection pool settings.
	ConnectionPool() ConnectionPoolConfig

	// IsolationLevels returns supported isolation levels and default.
	IsolationLevels() (supported []IsolationLevel, defaultLevel IsolationLevel)

	// QueryHints returns available query hints for this database.
	QueryHints() []QueryHint
}

type Factory func(opts Options) (Engine, error)

type Feature int

type IndexSuggestion struct {
	Table   string
	Columns []string
	Reason  string
}

type IsolationLevel int

type Options struct {
	// EmitPointersForNull enables pointer types for nullable values.
	EmitPointersForNull bool

	// CustomTypes provides custom type mappings.
	CustomTypes []config.CustomTypeMapping
}

type QueryAnalyzer interface {
	// ValidateQuery checks if a query is valid for this dialect.
	// Returns a list of diagnostics for any issues found.
	ValidateQuery(query string) []Diagnostic

	// SuggestIndexes recommends indexes that could improve query performance.
	SuggestIndexes(query string, catalog *model.Catalog) []IndexSuggestion
}

type QueryHint struct {
	// Name is the identifier for this hint (e.g., "INDEX", "USE_INDEX").
	Name string

	// Description explains what this hint does and when to use it.
	Description string

	// Syntax shows the SQL syntax for this hint.
	// Example: "/*+ INDEX(table_name index_name) */" for Oracle-style hints.
	Syntax string
}

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

type SQLGenerator interface {
	// GenerateTable creates a CREATE TABLE statement for the given table.
	GenerateTable(table *model.Table) string

	// GenerateIndex creates a CREATE INDEX statement.
	GenerateIndex(index *model.Index, tableName string) string

	// GenerateColumnDef creates a column definition clause.
	GenerateColumnDef(column *model.Column) string

	// Dialect returns the target SQL dialect identifier.
	Dialect() string
}

type Severity int

type TypeInfo struct {
	// GoType is the Go type name (e.g., "string", "int64", "uuid.UUID").
	GoType string

	// UsesSQLNull indicates if this type uses database/sql null types
	// (e.g., sql.NullString, sql.NullInt64).
	UsesSQLNull bool

	// Import is the import path if an external package is needed.
	// Empty for standard library types.
	Import string

	// Package is the package name for the import (e.g., "uuid", "sql").
	// Empty for standard library types.
	Package string

	// IsPointer indicates if this type is naturally a pointer.
	IsPointer bool
}

type TypeMapper interface {
	// SQLToGo converts a SQL type to Go type information.
	// The nullable parameter indicates if the column allows NULL values.
	SQLToGo(sqlType string, nullable bool) TypeInfo

	// SQLToSemantic converts a SQL type to a semantic type category.
	// This is used for cross-language type mapping.
	SQLToSemantic(sqlType string, nullable bool) types.SemanticType

	// GetRequiredImports returns the imports needed for generated code.
	// The returned map is from import path to package alias.
	GetRequiredImports() map[string]string

	// SupportsPointersForNull reports whether this engine supports using
	// pointers for nullable types instead of sql.Null* types.
	SupportsPointersForNull() bool
}