parser

type Attribute struct {
	Name string
	Type string
}

type Column struct {
	Name       string
	Type       string
	Nullable   bool
	PrimaryKey bool
	Unique     bool
	// InlineUnique reports whether the column carries a UNIQUE constraint
	// declared inline at column definition time (e.g. `email text UNIQUE`),
	// as opposed to a table-level UNIQUE constraint that lives in
	// Table.Constraints. The DDL parsers set this alongside Unique at column
	// parse time; RecomputeColumnUnique consults it when re-deriving the
	// effective Unique flag after a table-level UNIQUE is dropped, so an
	// inline declaration still in force at the DB level is not silently
	// stripped from the column.
	InlineUnique     bool
	Default          string
	FKReference      *FKReference
	AutoIncrement    bool
	Comment          string
	GeneratedExpr    string // Generated column expression (SQLite 3.31+)
	GeneratedStorage string // "VIRTUAL" or "STORED" (default: "VIRTUAL")
	// GoTypeLiteral is set for view columns whose type was resolved to a Go type
	// by @type annotation or aggregate inference. When non-empty, the code generator
	// uses this directly instead of running the SQL-to-Go resolver.
	GoTypeLiteral string
	// GoTypeImport is the import path for an external Go type (from @type annotation).
	GoTypeImport string
	// Aggregate names the SQL aggregate function (uppercase, e.g. "SUM") when this
	// view column is an aggregate whose Go type flows through the SQL-to-Go
	// resolver rather than a Go-type literal. Empty for table columns and for
	// aggregates resolved to a literal. The generator consults it so the
	// resolver can model dialect-specific result widening (e.g. SUM(integer) →
	// bigint in PostgreSQL); see gotype.Resolver.ResolveAggregate.
	Aggregate string
}

type CompositeType struct {
	Name       string
	Schema     string
	Attributes []Attribute
	Comment    string
}

type Constraint struct {
	Name             string
	Type             ConstraintType
	Columns          []string
	ReferenceTable   string
	ReferenceSchema  string
	ReferenceColumns []string
	CheckExpression  string
	Method           string
	Where            string
}

type ConstraintType int

type DomainType struct {
	Name        string
	Schema      string
	BaseType    string
	Constraints []Constraint
	Comment     string
}

type Enum struct {
	Name    string
	Schema  string
	Values  []string
	Comment string
}

type FKReference struct {
	Table  string
	Schema string
	Column string
	// Synthetic marks a reference invented by a config-declared relationship
	// (gen.applyConfigDeclaredFKs) rather than read from a SQL REFERENCES
	// clause. The database does not enforce it, and it may name a column that
	// holds no foreign key at all, so any consumer deciding something about
	// the *referential contract* — as opposed to how a column is filtered or
	// typed — must exclude it. Column is empty for synthetic references, but
	// that is not a usable test: the MySQL and SQLite parsers also leave it
	// empty when a REFERENCES clause omits the referenced column list.
	Synthetic bool
}

type Parser interface {
	// Parse parses the SQL from the given file into the internal schema model.
	// It can be called multiple times with different files; results accumulate.
	Parse(filename string, sql []byte) error

	// Schema returns the accumulated schema model.
	Schema() *Schema
}

type Relationship struct {
	Name                string
	BaseName            string
	Type                RelationshipType
	Side                RelationshipSide
	SourceTable         string
	TargetTable         string
	FKColumn            string
	JunctionTable       string
	JunctionLocalFK     string
	JunctionReferenceFK string
	Filter              string
	Sort                []RelationshipSort
}

type RelationshipSide int

type RelationshipSort struct {
	Column    string
	Direction string
}

type RelationshipType int

type Schema struct {
	Tables         []Table
	Enums          []Enum
	Sets           []Set
	CompositeTypes []CompositeType
	DomainTypes    []DomainType
	Views          []View
	Relationships  []Relationship
	Warnings       []string
}

type Set struct {
	Name    string
	Schema  string
	Values  []string
	Comment string
}

type Table struct {
	Name         string
	Schema       string
	Columns      []Column
	Constraints  []Constraint
	Comment      string
	Strict       bool // SQLite STRICT table modifier (3.37+)
	WithoutRowID bool // SQLite WITHOUT ROWID table modifier (3.8.2+)
}

type View struct {
	Name    string
	Schema  string
	SQL     string
	Columns []Column

	// Materialized reports whether this is a PostgreSQL MATERIALIZED VIEW.
	// When true, the generator emits Refresh methods and the FROM clause still
	// targets the relation by name (reads are identical to a regular view).
	Materialized bool

	// ConcurrentlyRefreshable reports whether the matview carries at least one
	// UNIQUE index covering all rows — the prerequisite for
	// REFRESH MATERIALIZED VIEW CONCURRENTLY. Set during introspection; for
	// annotation-file matviews it follows from an @pk directive.
	// Always false for regular views (Materialized == false implies
	// ConcurrentlyRefreshable == false).
	ConcurrentlyRefreshable bool
}

type ViewAnnotations struct {
	PKColumns       []string
	TypeOverrides   map[string]ViewTypeAnnotation
	NullableColumns []string
}

type ViewSQL struct {
	Name         string
	Schema       string
	Columns      []ViewSelectColumn
	TableAliases map[string]string

	// Materialized reports whether the statement was CREATE MATERIALIZED VIEW
	// (PostgreSQL-only; the MySQL/SQLite parsers reject the syntax).
	Materialized bool
}

type ViewSelectColumn struct {
	Alias        string // output column name (alias or inferred from expression)
	SourceTable  string // table alias the column comes from (if qualified reference)
	SourceColumn string // column name in the source table
	Aggregate    string // aggregate function name (uppercase), empty if not aggregate
}

type ViewTypeAnnotation struct {
	GoType     string
	ImportPath string
}