Add ENABLE/DISABLE TRIGGER statement parsing and enable 2 tests

Implement EnableDisableTriggerStatement AST type with parsing for:
- ENABLE/DISABLE TRIGGER ALL ON table_name
- ENABLE/DISABLE TRIGGER name1, name2 ON table_name
- ENABLE/DISABLE TRIGGER name ON ALL SERVER
- ENABLE/DISABLE TRIGGER name ON DATABASE

Enable EnableDisableTriggerStatementTests and Baselines90_EnableDisableTriggerStatementTests.

Author: claude

ast/enable_disable_trigger_statement.go

@@ -0,0 +1,12 @@
+package ast
+
+// EnableDisableTriggerStatement represents ENABLE/DISABLE TRIGGER statements
+type EnableDisableTriggerStatement struct {
+	TriggerEnforcement string            // "Enable" or "Disable"
+	All                bool              // true if ENABLE/DISABLE TRIGGER ALL
+	TriggerNames       []*SchemaObjectName
+	TriggerObject      *TriggerObject
+}
+
+func (s *EnableDisableTriggerStatement) statement() {}
+func (s *EnableDisableTriggerStatement) node()      {}

parser/marshal.go

@@ -324,6 +324,8 @@ func statementToJSON(stmt ast.Statement) jsonNode {
 		return alterTriggerStatementToJSON(s)
 	case *ast.CreateTriggerStatement:
 		return createTriggerStatementToJSON(s)
+	case *ast.EnableDisableTriggerStatement:
+		return enableDisableTriggerStatementToJSON(s)
 	case *ast.CreateDatabaseStatement:
 		return createDatabaseStatementToJSON(s)
 	case *ast.CreateLoginStatement:
@@ -5113,6 +5115,25 @@ func triggerActionToJSON(a *ast.TriggerAction) jsonNode {
 	return node
 }
 
+func enableDisableTriggerStatementToJSON(s *ast.EnableDisableTriggerStatement) jsonNode {
+	node := jsonNode{
+		"$type":              "EnableDisableTriggerStatement",
+		"TriggerEnforcement": s.TriggerEnforcement,
+		"All":                s.All,
+	}
+	if len(s.TriggerNames) > 0 {
+		names := make([]jsonNode, len(s.TriggerNames))
+		for i, n := range s.TriggerNames {
+			names[i] = schemaObjectNameToJSON(n)
+		}
+		node["TriggerNames"] = names
+	}
+	if s.TriggerObject != nil {
+		node["TriggerObject"] = triggerObjectToJSON(s.TriggerObject)
+	}
+	return node
+}
+
 func alterIndexStatementToJSON(s *ast.AlterIndexStatement) jsonNode {
 	node := jsonNode{
 		"$type":          "AlterIndexStatement",

parser/parse_statements.go

@@ -5229,3 +5229,77 @@ func toTitleCase(s string) string {
 	}
 	return strings.Join(parts, "")
 }
+
+// parseEnableDisableTriggerStatement parses ENABLE/DISABLE TRIGGER statements
+func (p *Parser) parseEnableDisableTriggerStatement(enforcement string) (*ast.EnableDisableTriggerStatement, error) {
+	// Consume ENABLE or DISABLE
+	p.nextToken()
+
+	// Expect TRIGGER
+	if strings.ToUpper(p.curTok.Literal) != "TRIGGER" {
+		return nil, fmt.Errorf("expected TRIGGER after %s, got %s", enforcement, p.curTok.Literal)
+	}
+	p.nextToken()
+
+	stmt := &ast.EnableDisableTriggerStatement{
+		TriggerEnforcement: enforcement,
+	}
+
+	// Check for ALL
+	if strings.ToUpper(p.curTok.Literal) == "ALL" {
+		stmt.All = true
+		p.nextToken()
+	} else {
+		stmt.All = false
+		// Parse trigger names (comma-separated)
+		for {
+			name, err := p.parseSchemaObjectName()
+			if err != nil {
+				return nil, err
+			}
+			stmt.TriggerNames = append(stmt.TriggerNames, name)
+
+			if p.curTok.Type != TokenComma {
+				break
+			}
+			p.nextToken() // consume comma
+		}
+	}
+
+	// Expect ON
+	if p.curTok.Type != TokenOn {
+		return nil, fmt.Errorf("expected ON after trigger names, got %s", p.curTok.Literal)
+	}
+	p.nextToken()
+
+	// Check for ALL SERVER or DATABASE or table name
+	stmt.TriggerObject = &ast.TriggerObject{}
+
+	if strings.ToUpper(p.curTok.Literal) == "ALL" {
+		p.nextToken()
+		if strings.ToUpper(p.curTok.Literal) == "SERVER" {
+			stmt.TriggerObject.TriggerScope = "AllServer"
+			p.nextToken()
+		} else {
+			return nil, fmt.Errorf("expected SERVER after ALL, got %s", p.curTok.Literal)
+		}
+	} else if strings.ToUpper(p.curTok.Literal) == "DATABASE" {
+		stmt.TriggerObject.TriggerScope = "Database"
+		p.nextToken()
+	} else {
+		// Parse table name
+		tableName, err := p.parseSchemaObjectName()
+		if err != nil {
+			return nil, err
+		}
+		stmt.TriggerObject.Name = tableName
+		stmt.TriggerObject.TriggerScope = "Normal"
+	}
+
+	// Skip optional semicolon
+	if p.curTok.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return stmt, nil
+}

parser/parser.go

@@ -198,6 +198,14 @@ func (p *Parser) parseStatement() (ast.Statement, error) {
 		if strings.ToUpper(p.curTok.Literal) == "DEALLOCATE" {
 			return p.parseDeallocateCursorStatement()
 		}
+		// Check for ENABLE TRIGGER
+		if strings.ToUpper(p.curTok.Literal) == "ENABLE" {
+			return p.parseEnableDisableTriggerStatement("Enable")
+		}
+		// Check for DISABLE TRIGGER
+		if strings.ToUpper(p.curTok.Literal) == "DISABLE" {
+			return p.parseEnableDisableTriggerStatement("Disable")
+		}
 		// Check for label (identifier followed by colon)
 		return p.parseLabelOrError()
 	default:

parser/testdata/Baselines90_EnableDisableTriggerStatementTests/metadata.json

@@ -1 +1 @@
-{"skip": true}
+{"skip": false}

parser/testdata/EnableDisableTriggerStatementTests/metadata.json

@@ -1 +1 @@
-{"skip": true}
+{"skip": false}