sqlddl

type Dialect struct {
	// Name identifies the dialect (e.g. "postgresql", "mysql", "sqlserver").
	Name string

	// LineComments lists the line-comment prefixes this dialect recognizes
	// (e.g. {{"--", false}} for PostgreSQL/T-SQL, {{"--", true}, {"#", false}}
	// for MySQL). Block comments (/* ... */) are universal across dialects and
	// not a field.
	LineComments []LineComment

	// IdentQuotes lists the quoted-identifier delimiter pairs this dialect
	// recognizes (e.g. {{'"','"',true}} for PostgreSQL, {{'`','`',true}} for
	// MySQL, {{'[',']',true},{'"','"',true}} for T-SQL). Every quoted
	// identifier is re-emitted as a canonical ANSI "..." identifier
	// regardless of the source delimiter — the seam that keeps the reducer
	// dialect-free.
	IdentQuotes []QuotePair

	// DoubleQuoteIsString is true when this dialect treats a bare " as a
	// STRING literal delimiter rather than an identifier quote (MySQL's
	// default ANSI_QUOTES-off behavior). PostgreSQL and T-SQL: false.
	DoubleQuoteIsString bool

	// DollarQuoting enables PostgreSQL-style $tag$...$tag$ body delimiters
	// (PL/pgSQL DO/function bodies). MySQL and T-SQL: false.
	DollarQuoting bool

	// TypeMap maps a lowercased base type keyword (already stripped of
	// length/precision and array markers by typeBase) to the neutral
	// db.Type. An unmapped keyword falls back to db.TypeUnknown — the
	// honest fallback, never a crash or a silent drop.
	TypeMap map[string]db.Type

	// Modifiers is the set of UPPERCASE column-tail keywords that end the
	// type expression at splitTypeAndMods time — parsed and deliberately
	// ignored (e.g. UNSIGNED, AUTO_INCREMENT, IDENTITY), never corrupting
	// the mapped type.
	Modifiers map[string]bool

	// TriggerHasInlineBody is a per-dialect DATUM (Phase 2.2, Unit A2,
	// architecture/pg-trigger-body-link): does a CREATE TRIGGER statement in
	// this dialect carry its own logic inline, or is it only a WIRE to a
	// separately-defined function/procedure? PostgreSQL triggers are wires —
	// "CREATE TRIGGER x ... EXECUTE FUNCTION fn();" — false: there is no body
	// to capture, so the statement is always Complete and the logic is found
	// via Trigger.ExecutesFunction instead. MySQL and T-SQL triggers embed
	// their logic directly in the statement ("FOR EACH ROW SET ..." / "AS
	// BEGIN ... END") — true: reduce.go's routineBody derivation (the same
	// tokenizer-state formula routines use) still applies.
	//
	// reduce.go's triggerBody consults this DATUM instead of branching on
	// dialect.Name, keeping the one-shared-reducer/per-dialect-data
	// architecture ADR 0022 established — a new dialect only ever adds a
	// Dialect value, never a branch in split.go or reduce.go.
	TriggerHasInlineBody bool

	// RoutineBodyEndsAtBatchSeparator is a per-dialect DATUM (ADR 0027,
	// architecture/tsql-body-truncation-limit CLOSED): when true, a CREATE
	// FUNCTION/PROCEDURE/TRIGGER body is delimited by the GO batch separator
	// (or EOF), not by an internal ';'. split() consults this DATUM (via
	// isRoutineHead in reduce.go) to suspend ';'-flushing once it recognizes a
	// routine head, so the whole body is captured whole up to GO/EOF instead
	// of being cut at the body's first internal ';'.
	//
	// true ONLY for SQLServer: T-SQL has neither PostgreSQL's dollar-quoting
	// nor MySQL's DELIMITER directive to protect internal ';'s inside a
	// routine body, so without this DATUM every multi-statement T-SQL body
	// would truncate. PostgreSQL and MySQL set this explicitly false — their
	// existing dollar-quoting/DELIMITER mechanisms already capture the whole
	// body, and GO is not a batch separator in either dialect.
	RoutineBodyEndsAtBatchSeparator bool

	// PartitionSchemeOnClause is a per-dialect DATUM (partition-capture):
	// does this dialect declare TABLE PARTITIONING by naming a partition
	// SCHEME in a trailing "ON <scheme> (<column>)" clause, with the
	// strategy living in a separately declared CREATE PARTITION FUNCTION?
	//
	// true ONLY for SQLServer. PostgreSQL and MySQL both spell partitioning
	// inline as "PARTITION BY <strategy> (<key>)", which reduce.go reads on
	// every dialect without consulting this datum (the grammar is the same
	// word in both, and a dialect that does not have it simply never emits
	// it). T-SQL's form needs the datum because "ON <name>" is ALSO how
	// T-SQL names a FILEGROUP — the vendored AdventureWorksDW corpus ends
	// every CREATE TABLE with ") ON [PRIMARY];" — and only the parenthesized
	// column distinguishes the two. Gating on this datum keeps that read
	// from ever being attempted against a PostgreSQL/MySQL tail, where "ON"
	// belongs to a different grammar entirely (e.g. "ON COMMIT DROP").
	//
	// It also gates whether CREATE PARTITION FUNCTION / CREATE PARTITION
	// SCHEME statements are read at all: they exist only in this dialect.
	PartitionSchemeOnClause bool

	// HashPrefixedTempTables is a per-dialect DATUM (ADR 0043): does this
	// dialect mark a TEMPORARY table by a '#' NAME PREFIX instead of a
	// keyword?
	//
	// true ONLY for SQLServer. T-SQL has no TEMPORARY keyword at all: it
	// writes "CREATE TABLE #Scratch (...)" for a session-local temporary table
	// and "##Scratch" for a global one, so the TEMP/TEMPORARY keyword
	// recognition that covers PostgreSQL and MySQL does nothing for it and a
	// separate recognition is needed.
	//
	// It is a DATUM rather than an unconditional rule because '#' means
	// nothing of the sort in the other two dialects: MySQL treats a bare '#'
	// as a LINE COMMENT (see LineComments above), and a PostgreSQL table can
	// legitimately be named "#weird" with quoting. Withholding either as
	// "session-scoped" would be codefit deciding, on a lexical accident, that
	// a persistent table is not part of the schema — a silent deletion, the
	// exact failure this slice exists to end.
	HashPrefixedTempTables bool
}

type LineComment struct {
	// Prefix is the literal comment-opening text (e.g. "--", "#").
	Prefix string

	// RequireBoundaryAfter, when true, means Prefix opens a comment only if
	// the character immediately following it is a boundary (whitespace or a
	// control char) or there is no following character (end-of-line/EOF).
	// When false, Prefix is unconditional — matching as soon as it is found.
	RequireBoundaryAfter bool
}

type Option func(*Parser)

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

type QuotePair struct {
	Open, Close byte
	Doubling    bool
}