Function parseTable

schema/parser.go:373–737

(mode GeneratorMode, stmt *parser.DDL, defaultSchema string, rawDDL string)

}

func parseTable(mode GeneratorMode, stmt *parser.DDL, defaultSchema string, rawDDL string) (Table, error) {
	var columns = map[string]*Column{}
	var indexes []Index
	var checks []CheckDefinition
	var foreignKeys []ForeignKey
	var exclusions []Exclusion

	columnComments := extractColumnComments(rawDDL, mode)
	indexComments := extractIndexComments(rawDDL, mode)

	for i, parsedCol := range stmt.TableSpec.Columns {
		// Normalize PostgreSQL type aliases from generic parser
		typeName := parsedCol.Type.Type
		typeIdent := parsedCol.Type.TypeIdent
		timezone := castBool(parsedCol.Type.Timezone)
		// references is used for:
		// 1. Schema-qualified type names (e.g., "public." for public.mytype) - stored with trailing dot
		// 2. Simple REFERENCES clause without column names (e.g., "REFERENCES table_name")
		var references Ident

		// For simple REFERENCES (without column names), store the table name in references
		// This is separate from the ForeignKey logic which handles REFERENCES with explicit columns
		if !parsedCol.Type.References.Name.IsEmpty() && len(parsedCol.Type.ReferenceNames) == 0 {
			references = parsedCol.Type.References.Name
		}

		if mode == GeneratorModePostgres {
			// Handle short timezone forms: timestamptz -> timestamp, timetz -> time
			// The generic parser parses these as custom identifiers without setting Timezone flag.
			// Clear typeIdent so the quote-aware comparison path doesn't see a stale name.
			switch strings.ToLower(typeName) {
			case "timestamptz":
				typeName = "timestamp"
				typeIdent = Ident{}
				timezone = true
			case "timetz":
				typeName = "time"
				typeIdent = Ident{}
				timezone = true
			}

			// Handle schema-qualified types from generic parser
			// Generic parser stores "schema.type" in typeName field
			// pgquery parser stores "schema." in references and "type" in typeName
			// Normalize to the pgquery format for consistent comparison
			if strings.Contains(typeName, ".") && references.IsEmpty() {
				parts := strings.SplitN(typeName, ".", 2)
				if len(parts) == 2 {
					// Store schema with trailing dot to match pgquery format
					references = Ident{Name: parts[0] + "."}
					typeName = parts[1]
				}
			}
		}

		column := Column{
			name:                       parsedCol.Name,
			position:                   i,