struct_parser.go

package ddl

import (
	"bytes"
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"io/fs"
	"reflect"
	"strconv"
	"strings"
	"unicode"

	"golang.org/x/tools/go/analysis"
	"golang.org/x/tools/go/analysis/passes/inspect"
	"golang.org/x/tools/go/ast/inspector"
)

// StructParser is used to parse Go source code into TableStructs.
type StructParser struct {
	TableStructs       TableStructs
	parserDiagnostics  *parserDiagnostics
	dialect            string
	locations          map[[2]string]location
	columnExplicitType map[[3]string]struct{}
	cache              *CatalogCache
}

// NewStructParser creates a new StructParser. An existing token.Fileset can be
// passed in. If not, passing in nil is fine and a new token.FileSet will be
// instantiated.
func NewStructParser(fset *token.FileSet) *StructParser {
	if fset == nil {
		fset = token.NewFileSet()
	}
	return &StructParser{parserDiagnostics: &parserDiagnostics{
		fset: fset,
	}}
}

// VisitNode is a callback function that populates the TableStructs when passed
// to ast.Inspect().
func (p *StructParser) VisitNode(node ast.Node) bool {
	switch node.(type) {
	case *ast.File, *ast.GenDecl:
		return true
	}
	p.VisitStruct(node)
	return false
}

// VisitStruct is a callback function that populates the TableStructs when
// passed to inspect.Inspector.Preorder(). It expects the node to be of type
// *ast.TypeSpec.
func (p *StructParser) VisitStruct(node ast.Node) {
	// Is it a type declaration?
	typeSpec, ok := node.(*ast.TypeSpec)
	if !ok {
		return
	}
	// Is it a type declaration for a struct?
	structType, ok := typeSpec.Type.(*ast.StructType)
	if !ok {
		return
	}
	// Does the struct have fields?
	if structType.Fields == nil {
		return
	}
	tableStruct := TableStruct{
		Name:   typeSpec.Name.Name,
		Fields: make([]StructField, 0, len(structType.Fields.List)),
	}
	for i, astField := range structType.Fields.List {
		var structField StructField
		// Name
		if len(astField.Names) > 0 && astField.Names[0] != nil {
			structField.Name = astField.Names[0].Name
		}
		// Type
		if typ, ok := astField.Type.(*ast.SelectorExpr); ok {
			if x, ok := typ.X.(*ast.Ident); ok {
				structField.Type = x.Name + "." + typ.Sel.Name
			}
		} else if typ, ok := astField.Type.(*ast.Ident); ok {
			structField.Type = typ.Name
		}
		// Tag
		if astField.Tag != nil {
			structField.tagPos = astField.Tag.Pos()
			if tag, err := strconv.Unquote(astField.Tag.Value); err == nil {
				structField.NameTag = reflect.StructTag(tag).Get("sq")
				structField.Modifiers, err = NewModifiers(reflect.StructTag(tag).Get("ddl"))
				if err != nil {
					loc := location{
						pos:        structField.tagPos,
						structName: tableStruct.Name,
						fieldName:  structField.Name,
					}
					p.report(loc, err.Error())
					continue
				}
			}
		}
		// If the first field is not sq.TableStruct, skip this struct entirely.
		if i == 0 {
			if structField.Name != "" || structField.Type != "sq.TableStruct" {
				structNameIsUppercase := true
				for _, char := range tableStruct.Name {
					if !unicode.IsUpper(char) {
						structNameIsUppercase = false
						break
					}
				}
				if structNameIsUppercase && structField.Type != "sq.TableStruct" {
					loc := location{pos: structField.tagPos}
					p.report(loc, "struct "+tableStruct.Name+" is all uppercase but no sq.TableStruct field was found")
				}
				return
			}
		}
		tableStruct.Fields = append(tableStruct.Fields, structField)
	}
	p.TableStructs = append(p.TableStructs, tableStruct)
}

// ParseFile parses an fs.File containing Go source code and populates the
// TableStructs.
func (p *StructParser) ParseFile(f fs.File) error {
	fileinfo, err := f.Stat()
	if err != nil {
		return err
	}
	file, err := parser.ParseFile(p.parserDiagnostics.fset, fileinfo.Name(), f, 0)
	if err != nil {
		return err
	}
	ast.Inspect(file, p.VisitNode)
	return p.Error()
}

// WriteCatalog populates the Catalog using the StructParser's TableStructs.
func (p *StructParser) WriteCatalog(catalog *Catalog) error {
	p.dialect = catalog.Dialect
	p.locations = make(map[[2]string]location)
	p.columnExplicitType = make(map[[3]string]struct{})
	p.cache = NewCatalogCache(catalog)

	for _, tableStruct := range p.TableStructs {
		if len(tableStruct.Fields) == 0 {
			continue
		}
		var tableSchema string
		tableName := strings.ToLower(tableStruct.Name)
		if tableStruct.Fields[0].NameTag != "" {
			tableName = tableStruct.Fields[0].NameTag
		}
		if i := strings.IndexByte(tableName, '.'); i >= 0 {
			tableSchema, tableName = tableName[:i], tableName[i+1:]
		}
		if tableSchema == "" && catalog.CurrentSchema != "" {
			tableSchema = catalog.CurrentSchema
		}

		schema := p.cache.GetOrCreateSchema(catalog, tableSchema)
		table := p.cache.GetOrCreateTable(schema, tableName)

		// The main loop.
		for _, structField := range tableStruct.Fields {
			loc := location{
				pos:        structField.tagPos,
				structName: tableStruct.Name,
				fieldName:  structField.Name,
			}
			if (structField.Name == "" && structField.Type == "sq.TableStruct") || (structField.Name == "_" && structField.Type == "struct{}") {
				p.parseTableModifiers(table, loc, structField.Modifiers)
				continue
			}
			columnName := strings.ToLower(structField.Name)
			if structField.NameTag != "" {
				columnName = structField.NameTag
			}
			var columnType, characterLength string
			switch structField.Type {
			case "sq.AnyField":
			case "sq.ArrayField":
				switch p.dialect {
				case DialectSQLite, DialectMySQL:
					columnType = "JSON"
				case DialectPostgres:
					columnType = "TEXT[]"
				case DialectSQLServer:
					columnType, characterLength = "NVARCHAR(MAX)", "MAX"
				default:
					columnType, characterLength = "VARCHAR(255)", "255"
				}
			case "sq.BinaryField":
				switch p.dialect {
				case DialectSQLite:
					columnType = "BLOB"
				case DialectPostgres:
					columnType = "BYTEA"
				case DialectMySQL:
					columnType = "MEDIUMBLOB"
				case DialectSQLServer:
					columnType, characterLength = "VARBINARY(MAX)", "MAX"
				default:
					columnType = "BINARY"
				}
			case "sq.BooleanField":
				switch p.dialect {
				case DialectSQLServer:
					columnType = "BIT"
				default:
					columnType = "BOOLEAN"
				}
			case "sq.EnumField":
				switch p.dialect {
				case DialectSQLite, DialectPostgres:
					columnType = "TEXT"
				case DialectSQLServer:
					columnType, characterLength = "NVARCHAR(255)", "255"
				default:
					columnType, characterLength = "VARCHAR(255)", "255"
				}
			case "sq.JSONField":
				switch p.dialect {
				case DialectSQLite, DialectMySQL:
					columnType = "JSON"
				case DialectPostgres:
					columnType = "JSONB"
				case DialectSQLServer:
					columnType, characterLength = "NVARCHAR(MAX)", "MAX"
				default:
					columnType = "VARCHAR(255)"
				}
			case "sq.NumberField":
				columnType = "INT"
			case "sq.StringField":
				switch p.dialect {
				case DialectSQLite, DialectPostgres:
					columnType = "TEXT"
				case DialectSQLServer:
					columnType, characterLength = "NVARCHAR(255)", "255"
				default:
					columnType, characterLength = "VARCHAR(255)", "255"
				}
			case "sq.TimeField":
				switch p.dialect {
				case DialectPostgres:
					columnType = "TIMESTAMPTZ"
				case DialectSQLServer:
					columnType = "DATETIMEOFFSET"
				default:
					columnType = "DATETIME"
				}
			case "sq.UUIDField":
				switch p.dialect {
				case DialectSQLite, DialectPostgres:
					columnType = "UUID"
				default:
					columnType = "BINARY(16)"
				}
			default:
				continue
			}
			if characterLength != "" {
				column := p.cache.GetOrCreateColumn(table, columnName, columnType)
				column.CharacterLength = characterLength
			}
			p.parseColumnModifiers(table, columnName, columnType, loc, structField.Modifiers)
		}

		// Validate column existence for PRIMARY KEY and UNIQUE constraints.
		for _, constraint := range table.Constraints {
			if constraint.Ignore {
				continue
			}
			hasInvalidColumn := false
			for _, columnName := range constraint.Columns {
				column := p.cache.GetColumn(table, columnName)
				if column == nil {
					hasInvalidColumn = true
					loc := p.locations[[2]string{table.TableSchema, constraint.ConstraintName}]
					p.report(loc, strings.Join(constraint.Columns, ",")+": "+columnName+" does not exist in the table")
				}
			}
			if hasInvalidColumn {
				continue
			}
			// set IsUnique and IsPrimaryKey for the corresponding columns
			if len(constraint.Columns) != 1 || (constraint.ConstraintType != PRIMARY_KEY && constraint.ConstraintType != UNIQUE && constraint.ConstraintType != FOREIGN_KEY) {
				continue
			}
			columnName := constraint.Columns[0]
			column := p.cache.GetColumn(table, columnName)
			switch constraint.ConstraintType {
			case PRIMARY_KEY:
				column.IsPrimaryKey = true
				if catalog.Dialect == DialectSQLite && strings.EqualFold(column.ColumnType, "INT") {
					if _, ok := p.columnExplicitType[[3]string{table.TableSchema, table.TableName, columnName}]; !ok {
						column.ColumnType = "INTEGER"
					}
				}
			case UNIQUE:
				column.IsUnique = true
			case FOREIGN_KEY:
				column.ReferencesSchema = constraint.ReferencesSchema
				column.ReferencesTable = constraint.ReferencesTable
				column.ReferencesColumn = constraint.ReferencesColumns[0]
				column.UpdateRule = constraint.UpdateRule
				column.DeleteRule = constraint.DeleteRule
				column.IsDeferrable = constraint.IsDeferrable
				column.IsInitiallyDeferred = constraint.IsInitiallyDeferred
			}
		}

		// Validate column existence for indexes.
		for _, index := range table.Indexes {
			if index.Ignore {
				continue
			}
			for _, columnName := range index.Columns {
				column := p.cache.GetColumn(table, columnName)
				if column == nil {
					loc := p.locations[[2]string{table.TableSchema, index.IndexName}]
					p.report(loc, strings.Join(index.Columns, ",")+": "+columnName+" does not exist in the table")
				}
			}
		}

		// Set PRIMARY KEY columns to NOT NULL.
		pkey := p.cache.GetPrimaryKey(table)
		if pkey != nil && !pkey.Ignore {
			for _, columnName := range pkey.Columns {
				column := p.cache.GetColumn(table, columnName)
				if column == nil {
					continue
				}
				if catalog.Dialect == DialectSQLite && column.ColumnType == "INTEGER" && column.IsPrimaryKey {
					// SQLite forbids INTEGER PRIMARY KEY (alias for ROWID) columns
					// from being marked as NOT NULL (since they can never be NULL).
					continue
				}
				column.IsNotNull = true
			}
		}
	}

	// Validate column existence for FOREIGN KEY constraints.
	for _, schema := range catalog.Schemas {
		for _, table := range schema.Tables {
			for _, constraint := range table.Constraints {
				if constraint.Ignore || constraint.ConstraintType != FOREIGN_KEY {
					continue
				}
				// We need the location of the failing constraint so that we
				// can inform the user where it is. If we can't find it,
				// continue.
				loc, ok := p.locations[[2]string{table.TableSchema, constraint.ConstraintName}]
				if !ok {
					continue
				}
				schemaName := constraint.ReferencesSchema
				if schemaName == "" {
					schemaName = catalog.CurrentSchema
				}
				refschema := p.cache.GetSchema(catalog, schemaName)
				if refschema == nil {
					p.report(loc, fmt.Sprintf("schema %s does not exist", schemaName))
					continue
				}
				reftable := p.cache.GetTable(refschema, constraint.ReferencesTable)
				tableName := constraint.ReferencesTable
				if reftable == nil {
					if schemaName != "" {
						tableName = schemaName + "." + tableName
					}
					p.report(loc, fmt.Sprintf("table %s does not exist", tableName))
					continue
				}
				for _, columnName := range constraint.ReferencesColumns {
					refcolumn := p.cache.GetColumn(reftable, columnName)
					if refcolumn == nil {
						columnName = tableName + "." + columnName
						p.report(loc, fmt.Sprintf("column %s does not exist", columnName))
						continue
					}
				}
			}
		}
	}
	return p.Error()
}

func (p *StructParser) parseIndexModifier(table *Table, columnNames []string, loc location, m *Modifier) {
	err := m.ParseRawValue()
	if err != nil {
		p.report(loc, err.Error())
		return
	}
	if m.Value != "" && m.Value != "." {
		columnNames = strings.Split(m.Value, ",")
	}
	if len(columnNames) == 0 {
		p.report(loc, "no column provided")
	}
	indexName := GenerateName(INDEX, table.TableName, columnNames)
	p.locations[[2]string{table.TableSchema, indexName}] = loc
	index := p.cache.GetOrCreateIndex(table, indexName, columnNames)
	index.TableSchema = table.TableSchema
	index.TableName = table.TableName
	index.Ignore = m.ExcludesDialect(p.dialect)
	for i := range m.Submodifiers {
		submodifier := &m.Submodifiers[i]
		if submodifier.ExcludesDialect(p.dialect) {
			continue
		}
		switch submodifier.Name {
		case "unique":
			index.IsUnique = true
		case "using":
			if p.dialect != DialectPostgres && p.dialect != DialectMySQL {
				continue
			}
			index.IndexType = submodifier.RawValue
		default:
			p.report(loc, "unknown modifier "+strconv.Quote(submodifier.Name))
		}
	}
}

func (p *StructParser) parsePrimaryKeyUniqueModifier(table *Table, columnNames []string, loc location, m *Modifier) {
	err := m.ParseRawValue()
	if err != nil {
		p.report(loc, err.Error())
		return
	}
	constraintType := PRIMARY_KEY
	if strings.EqualFold(UNIQUE, m.Name) {
		constraintType = UNIQUE
	}
	if m.Value != "" && m.Value != "." {
		columnNames = strings.Split(m.Value, ",")
	}
	if len(columnNames) == 0 {
		p.report(loc, "no column provided")
	}
	constraintName := GenerateName(constraintType, table.TableName, columnNames)
	if p.dialect == DialectMySQL && constraintType == PRIMARY_KEY {
		constraintName = "PRIMARY"
	}
	p.locations[[2]string{table.TableSchema, constraintName}] = loc
	constraint := p.cache.GetOrCreateConstraint(table, constraintName, constraintType, columnNames)
	constraint.TableSchema = table.TableSchema
	constraint.TableName = table.TableName
	constraint.Ignore = m.ExcludesDialect(p.dialect)
	for i := range m.Submodifiers {
		submodifier := &m.Submodifiers[i]
		if submodifier.ExcludesDialect(p.dialect) {
			continue
		}
		switch submodifier.Name {
		case "deferrable":
			if p.dialect != DialectSQLite && p.dialect != DialectPostgres {
				continue
			}
			constraint.IsDeferrable = true
		case "deferred":
			if p.dialect != DialectSQLite && p.dialect != DialectPostgres {
				continue
			}
			constraint.IsDeferrable = true
			constraint.IsInitiallyDeferred = true
		default:
			p.report(loc, "unknown modifier "+strconv.Quote(submodifier.Name))
		}
	}
}

func (p *StructParser) parseForeignKeyModifier(table *Table, loc location, m *Modifier) {
	err := m.ParseRawValue()
	if err != nil {
		p.report(loc, err.Error())
		return
	}
	if m.Value == "" || m.Value == "." {
		p.report(loc, "no column(s) provided")
		return
	}
	if len(m.Submodifiers) == 0 {
		p.report(loc, "no referenced column(s) provided")
		return
	}
	columnNames := strings.Split(m.Value, ",")
	constraintName := GenerateName(FOREIGN_KEY, table.TableName, columnNames)
	p.locations[[2]string{table.TableSchema, constraintName}] = loc
	constraint := p.cache.GetOrCreateConstraint(table, constraintName, FOREIGN_KEY, columnNames)
	constraint.TableSchema = table.TableSchema
	constraint.TableName = table.TableName
	constraint.Ignore = m.ExcludesDialect(p.dialect)
	for i := range m.Submodifiers {
		submodifier := &m.Submodifiers[i]
		if submodifier.ExcludesDialect(p.dialect) {
			continue
		}
		switch submodifier.Name {
		case "references":
			switch parts := strings.SplitN(submodifier.RawValue, ".", 3); len(parts) {
			case 1:
				constraint.ReferencesTable = parts[0]
				constraint.ReferencesColumns = columnNames
			case 2:
				constraint.ReferencesTable = parts[0]
				constraint.ReferencesColumns = strings.Split(parts[1], ",")
			case 3:
				constraint.ReferencesSchema = parts[0]
				constraint.ReferencesTable = parts[1]
				constraint.ReferencesColumns = strings.Split(parts[2], ",")
			}
		case "onupdate":
			switch submodifier.RawValue {
			case "cascade":
				constraint.UpdateRule = CASCADE
			case "restrict":
				if p.dialect == DialectSQLServer {
					constraint.UpdateRule = NO_ACTION
				} else {
					constraint.UpdateRule = RESTRICT
				}
			case "noaction":
				constraint.UpdateRule = NO_ACTION
			case "setnull":
				constraint.UpdateRule = SET_NULL
			case "setdefault":
				constraint.UpdateRule = SET_DEFAULT
			case "":
				constraint.UpdateRule = ""
			default:
				loc.keys = append(loc.keys, submodifier.Name)
				p.report(loc, "unknown value "+strconv.Quote(submodifier.RawValue))
			}
		case "ondelete":
			switch submodifier.RawValue {
			case "cascade":
				constraint.DeleteRule = CASCADE
			case "restrict":
				if p.dialect == DialectSQLServer {
					constraint.DeleteRule = NO_ACTION
				} else {
					constraint.DeleteRule = RESTRICT
				}
			case "noaction":
				constraint.DeleteRule = NO_ACTION
			case "setnull":
				constraint.DeleteRule = SET_NULL
			case "setdefault":
				constraint.DeleteRule = SET_DEFAULT
			case "":
				constraint.DeleteRule = ""
			default:
				loc.keys = append(loc.keys, submodifier.Name)
				p.report(loc, "unknown value "+strconv.Quote(submodifier.RawValue))
			}
		case "deferrable":
			if p.dialect != DialectSQLite && p.dialect != DialectPostgres {
				continue
			}
			constraint.IsDeferrable = true
		case "deferred":
			if p.dialect != DialectSQLite && p.dialect != DialectPostgres {
				continue
			}
			constraint.IsDeferrable = true
			constraint.IsInitiallyDeferred = true
		case "index":
			loc.keys = append(loc.keys, submodifier.Name)
			p.parseIndexModifier(table, columnNames, loc, submodifier)
		default:
			p.report(loc, "unknown modifier "+strconv.Quote(submodifier.Name))
		}
	}
}

func (p *StructParser) parseReferencesModifier(table *Table, columnName string, loc location, m *Modifier) {
	err := m.ParseRawValue()
	if err != nil {
		p.report(loc, err.Error())
		return
	}
	if columnName == "" {
		p.report(loc, "no column provided")
	}
	constraintName := GenerateName(FOREIGN_KEY, table.TableName, []string{columnName})
	p.locations[[2]string{table.TableSchema, constraintName}] = loc

	constraint := p.cache.GetOrCreateConstraint(table, constraintName, FOREIGN_KEY, []string{columnName})
	constraint.TableSchema = table.TableSchema
	constraint.TableName = table.TableName
	constraint.Ignore = m.ExcludesDialect(p.dialect)
	switch parts := strings.SplitN(m.Value, ".", 3); len(parts) {
	case 1:
		constraint.ReferencesTable = parts[0]
		constraint.ReferencesColumns = []string{columnName}
	case 2:
		constraint.ReferencesTable = parts[0]
		constraint.ReferencesColumns = strings.Split(parts[1], ",")
	case 3:
		constraint.ReferencesSchema = parts[0]
		constraint.ReferencesTable = parts[1]
		constraint.ReferencesColumns = strings.Split(parts[2], ",")
	}

	for i, submodifier := range m.Submodifiers {
		if submodifier.ExcludesDialect(p.dialect) {
			continue
		}
		switch submodifier.Name {
		case "onupdate":
			switch submodifier.RawValue {
			case "cascade":
				constraint.UpdateRule = CASCADE
			case "restrict":
				if p.dialect == DialectSQLServer {
					constraint.UpdateRule = NO_ACTION
				} else {
					constraint.UpdateRule = RESTRICT
				}
			case "noaction":
				constraint.UpdateRule = NO_ACTION
			case "setnull":
				constraint.UpdateRule = SET_NULL
			case "setdefault":
				constraint.UpdateRule = SET_DEFAULT
			case "":
				constraint.UpdateRule = ""
			default:
				loc.keys = append(loc.keys, submodifier.Name)
				p.report(loc, "unknown value "+strconv.Quote(submodifier.RawValue))
			}
		case "ondelete":
			switch submodifier.RawValue {
			case "cascade":
				constraint.DeleteRule = CASCADE
			case "restrict":
				if p.dialect == DialectSQLServer {
					constraint.DeleteRule = NO_ACTION
				} else {
					constraint.DeleteRule = RESTRICT
				}
			case "noaction":
				constraint.DeleteRule = NO_ACTION
			case "setnull":
				constraint.DeleteRule = SET_NULL
			case "setdefault":
				constraint.DeleteRule = SET_DEFAULT
			case "":
				constraint.DeleteRule = ""
			default:
				loc.keys = append(loc.keys, submodifier.Name)
				p.report(loc, "unknown value "+strconv.Quote(submodifier.RawValue))
			}
		case "deferrable":
			if p.dialect == DialectSQLite || p.dialect == DialectPostgres {
				constraint.IsDeferrable = true
			}
		case "deferred":
			if p.dialect == DialectSQLite || p.dialect == DialectPostgres {
				constraint.IsDeferrable = true
				constraint.IsInitiallyDeferred = true
			}
		case "index":
			loc.keys = append(loc.keys, submodifier.Name)
			p.parseIndexModifier(table, []string{columnName}, loc, &m.Submodifiers[i])
		default:
			p.report(loc, "unknown modifier "+strconv.Quote(submodifier.Name))
		}
	}
}

func (p *StructParser) parseColumnModifiers(table *Table, columnName, columnType string, loc location, modifiers []Modifier) {
	column := p.cache.GetOrCreateColumn(table, columnName, columnType)
	column.TableSchema = table.TableSchema
	column.TableName = table.TableName
	column.IsEnum = columnType == "sq.EnumField"

	var dialects []string
	for i := range modifiers {
		modifier := &modifiers[i]
		if len(modifier.Dialects) == 0 {
			modifier.Dialects = dialects
		}
		if modifier.ExcludesDialect(p.dialect) {
			continue
		}
		switch modifier.Name {
		case "type":
			p.columnExplicitType[[3]string{table.TableSchema, table.TableName, columnName}] = struct{}{}
			column.ColumnType = modifier.RawValue
			normalizedType, arg1, arg2 := normalizeColumnType(p.dialect, column.ColumnType)
			switch normalizedType {
			case "VARBINARY", "BINARY", "NVARCHAR", "VARCHAR", "CHAR":
				if arg1 != "" {
					column.CharacterLength = arg1
				} else if column.CharacterLength != "" {
					column.ColumnType = column.ColumnType + "(" + column.CharacterLength + ")"
				}
				column.NumericPrecision, column.NumericScale = "", ""
			case "NUMERIC":
				if arg1 != "" {
					column.NumericPrecision = arg1
				}
				if arg2 != "" {
					column.NumericScale = arg2
				}
				column.CharacterLength = ""
			default:
				column.CharacterLength, column.NumericPrecision, column.NumericScale = "", "", ""
			}
		case "len":
			column.CharacterLength = modifier.RawValue
			if column.CharacterLength != "" {
				switch p.dialect {
				case DialectPostgres, DialectMySQL:
					column.ColumnType = "VARCHAR(" + column.CharacterLength + ")"
				case DialectSQLServer:
					column.ColumnType = "NVARCHAR(" + column.CharacterLength + ")"
				}
			}
		case "auto_increment":
			if p.dialect != DialectMySQL {
				continue
			}
			column.IsAutoincrement = true
		case "autoincrement":
			if p.dialect != DialectSQLite {
				continue
			}
			column.ColumnType = "INTEGER"
			column.IsAutoincrement = true
		case "identity":
			switch p.dialect {
			case DialectPostgres:
				column.ColumnIdentity = DEFAULT_IDENTITY
			case DialectSQLServer:
				column.ColumnIdentity = IDENTITY
			}
		case "alwaysidentity":
			switch p.dialect {
			case DialectPostgres:
				column.ColumnIdentity = ALWAYS_IDENTITY
			case DialectSQLServer:
				column.ColumnIdentity = IDENTITY
			}
		case "notnull":
			column.IsNotNull = true
		case "onupdatecurrenttimestamp":
			if p.dialect != DialectMySQL {
				continue
			}
			column.OnUpdateCurrentTimestamp = true
		case "collate":
			column.CollationName = modifier.RawValue
		case "default":
			if p.dialect != DialectPostgres && !isLiteral(modifier.RawValue) {
				column.ColumnDefault = wrapBrackets(modifier.RawValue)
				continue
			}
			column.ColumnDefault = modifier.RawValue
			if p.dialect == DialectSQLServer {
				if strings.EqualFold(column.ColumnDefault, "TRUE") {
					column.ColumnDefault = "1"
				} else if strings.EqualFold(column.ColumnDefault, "FALSE") {
					column.ColumnDefault = "0"
				}
			}
		case "generated":
			column.IsGenerated = true
		case "dialect":
			if modifier.RawValue == "" {
				loc.keys = []string{modifier.Name}
				p.report(loc, "dialect value cannot be blank")
				continue
			}
			column.Ignore = true
			dialects = strings.Split(modifier.RawValue, ",")
			for _, dialect := range dialects {
				if p.dialect == dialect {
					column.Ignore = false
					break
				}
			}
		case "index":
			loc.keys = []string{modifier.Name}
			p.parseIndexModifier(table, []string{columnName}, loc, modifier)
		case "primarykey", "unique":
			loc.keys = []string{modifier.Name}
			p.parsePrimaryKeyUniqueModifier(table, []string{columnName}, loc, modifier)
		case "foreignkey":
			loc.keys = []string{modifier.Name}
			p.parseForeignKeyModifier(table, loc, modifier)
		case "references":
			loc.keys = []string{modifier.Name}
			p.parseReferencesModifier(table, columnName, loc, modifier)
		default:
			p.report(loc, "unknown modifier "+strconv.Quote(modifier.Name))
		}
	}
}

func (p *StructParser) parseTableModifiers(table *Table, loc location, modifiers []Modifier) {
	var dialects []string
	for i := range modifiers {
		modifier := &modifiers[i]
		if len(modifier.Dialects) == 0 {
			modifier.Dialects = dialects
		}
		switch modifier.Name {
		case "dialect":
			if modifier.RawValue == "" {
				loc.keys = []string{modifier.Name}
				p.report(loc, "dialect value cannot be blank")
				continue
			}
			table.Ignore = true
			dialects = strings.Split(modifier.RawValue, ",")
			for _, dialect := range dialects {
				if p.dialect == dialect {
					table.Ignore = false
					break
				}
			}
		case "index":
			loc.keys = []string{modifier.Name}
			p.parseIndexModifier(table, nil, loc, modifier)
		case "primarykey", "unique":
			loc.keys = []string{modifier.Name}
			p.parsePrimaryKeyUniqueModifier(table, nil, loc, modifier)
		case "foreignkey":
			loc.keys = []string{modifier.Name}
			p.parseForeignKeyModifier(table, loc, modifier)
		case "virtual":
			if p.dialect != DialectSQLite {
				continue
			}
			table.IsVirtual = true
		default:
			p.report(loc, "unknown modifier "+strconv.Quote(modifier.Name))
		}
	}
}

func (p *StructParser) report(loc location, msg string) {
	p.parserDiagnostics.locs = append(p.parserDiagnostics.locs, loc)
	p.parserDiagnostics.msgs = append(p.parserDiagnostics.msgs, msg)
}

type location struct {
	pos        token.Pos
	structName string
	fieldName  string
	keys       []string
}

type parserDiagnostics struct {
	fset *token.FileSet
	locs []location
	msgs []string
}

// Diagnostics returns the errors encountered after calling WriteCatalog in a
// structured format.
func (p *StructParser) Diagnostics() ([]token.Pos, []string) {
	positions := make([]token.Pos, 0, len(p.parserDiagnostics.msgs))
	msgs := make([]string, 0, len(p.parserDiagnostics.msgs))
	for i, msg := range p.parserDiagnostics.msgs {
		var loc location
		if i < len(p.parserDiagnostics.locs) {
			loc = p.parserDiagnostics.locs[i]
		}
		n := len(loc.structName) + len(".") + len(loc.fieldName) + len(": ")
		for _, key := range loc.keys {
			n += len(".") + len(key)
		}
		n += len(": ") + len(msg)
		var b strings.Builder
		b.Grow(n)
		if loc.structName != "" && loc.fieldName != "" {
			b.WriteString(loc.structName + "." + loc.fieldName + ": ")
		}
		for j, key := range loc.keys {
			if j > 0 {
				b.WriteString(".")
			}
			b.WriteString(key)
		}
		b.WriteString(": " + msg)
		positions = append(positions, loc.pos)
		msgs = append(msgs, b.String())
	}
	return positions, msgs
}

// Error returns the errors encountered after calling WriteCatalog.
func (p *StructParser) Error() error {
	if len(p.parserDiagnostics.msgs) > 0 {
		return p.parserDiagnostics
	}
	return nil
}

// Error implements the error interface.
func (d *parserDiagnostics) Error() string {
	buf := bufpool.Get().(*bytes.Buffer)
	buf.Reset()
	defer bufpool.Put(buf)
	for i, msg := range d.msgs {
		if i > 0 {
			buf.WriteString("\n")
		}
		if i >= len(d.locs) {
			buf.WriteString(msg)
			continue
		}
		loc := d.locs[i]
		if d.fset != nil {
			pos := d.fset.Position(loc.pos)
			if pos.IsValid() {
				buf.WriteString(pos.String() + ": ")
			}
		}
		if loc.structName != "" && loc.fieldName != "" {
			buf.WriteString(loc.structName + "." + loc.fieldName + ": ")
		}
		if len(loc.keys) > 0 {
			for j, key := range loc.keys {
				if j > 0 {
					buf.WriteByte('.')
				}
				buf.WriteString(key)
			}
			buf.WriteString(": ")
		}
		buf.WriteString(msg)
	}
	return buf.String()
}

// Analyzer is an &analysis.Analyzer which can be used in a custom linter.
var Analyzer = &analysis.Analyzer{
	Name:     "ddl",
	Doc:      "validates ddl structs",
	Requires: []*analysis.Analyzer{inspect.Analyzer},
	Run: func(pass *analysis.Pass) (any, error) {
		inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
		nodeFilter := []ast.Node{(*ast.TypeSpec)(nil)}
		p := NewStructParser(pass.Fset)
		inspect.Preorder(nodeFilter, p.VisitStruct)
		var catalog Catalog
		_ = p.WriteCatalog(&catalog)
		positions, msgs := p.Diagnostics()
		if len(msgs) == 0 {
			return nil, nil
		}
		for i, msg := range msgs {
			var pos token.Pos
			if i < len(positions) {
				pos = positions[i]
			}
			pass.Reportf(pos, msg)
		}
		return nil, nil
	},
}