Add Event Session statement support

- Add ALTER EVENT SESSION parsing with ADD/DROP EVENT/TARGET, WITH, STATE options
- Add DROP EVENT SESSION statement parsing
- Add BooleanNotExpression for NOT predicate handling
- Add comparison operators (=, !=, <>, <, >, <=, >=) to event predicates
- Add EventDeclarationSetParameters to EventDeclaration
- Add DropEventDeclarations and DropTargetDeclarations to AlterEventSessionStatement
- Add memoryPartitionValue mapping for PER_CPU -> PerCpu
- Fix loop termination in ALTER EVENT SESSION to not exit on DROP/ADD tokens

This enables 4 tests:
- Baselines100_EventSessionStatementTests
- Baselines130_EventSessionDbScopeStatementTests
- EventSessionDbScopeStatementTests
- EventSessionStatementTests

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kyleconroy

ast/boolean_not_expression.go

@@ -0,0 +1,9 @@
+package ast
+
+// BooleanNotExpression represents a NOT expression
+type BooleanNotExpression struct {
+	Expression BooleanExpression
+}
+
+func (e *BooleanNotExpression) node()              {}
+func (e *BooleanNotExpression) booleanExpression() {}

ast/event_statements.go

@@ -12,9 +12,35 @@ type CreateEventSessionStatement struct {
 func (s *CreateEventSessionStatement) node()      {}
 func (s *CreateEventSessionStatement) statement() {}
 
+// AlterEventSessionStatement represents ALTER EVENT SESSION statement
+type AlterEventSessionStatement struct {
+	Name                   *Identifier
+	SessionScope           string // "Server" or "Database"
+	StatementType          string // "AddEventDeclarationOptionalSessionOptions", "DropEventSpecificationOptionalSessionOptions", "AddTargetDeclarationOptionalSessionOptions", "DropTargetSpecificationOptionalSessionOptions", "RequiredSessionOptions", "AlterStateIsStart", "AlterStateIsStop"
+	EventDeclarations      []*EventDeclaration
+	DropEventDeclarations  []*EventSessionObjectName
+	TargetDeclarations     []*TargetDeclaration
+	DropTargetDeclarations []*EventSessionObjectName
+	SessionOptions         []SessionOption
+}
+
+func (s *AlterEventSessionStatement) node()      {}
+func (s *AlterEventSessionStatement) statement() {}
+
+// DropEventSessionStatement represents DROP EVENT SESSION statement
+type DropEventSessionStatement struct {
+	Name         *Identifier
+	SessionScope string // "Server" or "Database"
+	IsIfExists   bool
+}
+
+func (s *DropEventSessionStatement) node()      {}
+func (s *DropEventSessionStatement) statement() {}
+
 // EventDeclaration represents an event in the event session
 type EventDeclaration struct {
 	ObjectName                         *EventSessionObjectName
+	EventDeclarationSetParameters      []*EventDeclarationSetParameter
 	EventDeclarationActionParameters   []*EventSessionObjectName
 	EventDeclarationPredicateParameter BooleanExpression
 }

parser/marshal.go

@@ -573,6 +573,8 @@ func statementToJSON(stmt ast.Statement) jsonNode {
 		return dropServiceStatementToJSON(s)
 	case *ast.DropEventNotificationStatement:
 		return dropEventNotificationStatementToJSON(s)
+	case *ast.DropEventSessionStatement:
+		return dropEventSessionStatementToJSON(s)
 	case *ast.AlterTableTriggerModificationStatement:
 		return alterTableTriggerModificationStatementToJSON(s)
 	case *ast.AlterTableFileTableNamespaceStatement:
@@ -601,6 +603,8 @@ func statementToJSON(stmt ast.Statement) jsonNode {
 		return alterAssemblyStatementToJSON(s)
 	case *ast.AlterEndpointStatement:
 		return alterEndpointStatementToJSON(s)
+	case *ast.AlterEventSessionStatement:
+		return alterEventSessionStatementToJSON(s)
 	case *ast.AlterServiceStatement:
 		return alterServiceStatementToJSON(s)
 	case *ast.AlterCertificateStatement:
@@ -3389,6 +3393,14 @@ func booleanExpressionToJSON(expr ast.BooleanExpression) jsonNode {
 			node["Expression"] = booleanExpressionToJSON(e.Expression)
 		}
 		return node
+	case *ast.BooleanNotExpression:
+		node := jsonNode{
+			"$type": "BooleanNotExpression",
+		}
+		if e.Expression != nil {
+			node["Expression"] = booleanExpressionToJSON(e.Expression)
+		}
+		return node
 	case *ast.BooleanIsNullExpression:
 		node := jsonNode{
 			"$type": "BooleanIsNullExpression",
@@ -15909,6 +15921,20 @@ func dropEventNotificationStatementToJSON(s *ast.DropEventNotificationStatement)
 	return node
 }
 
+func dropEventSessionStatementToJSON(s *ast.DropEventSessionStatement) jsonNode {
+	node := jsonNode{
+		"$type":      "DropEventSessionStatement",
+		"IsIfExists": s.IsIfExists,
+	}
+	if s.Name != nil {
+		node["Name"] = identifierToJSON(s.Name)
+	}
+	if s.SessionScope != "" {
+		node["SessionScope"] = s.SessionScope
+	}
+	return node
+}
+
 func dropSecurityPolicyStatementToJSON(s *ast.DropSecurityPolicyStatement) jsonNode {
 	node := jsonNode{
 		"$type":      "DropSecurityPolicyStatement",
@@ -16894,13 +16920,73 @@ func createEventSessionStatementToJSON(s *ast.CreateEventSessionStatement) jsonN
 	return node
 }
 
+func alterEventSessionStatementToJSON(s *ast.AlterEventSessionStatement) jsonNode {
+	node := jsonNode{
+		"$type": "AlterEventSessionStatement",
+	}
+	if s.StatementType != "" {
+		node["StatementType"] = s.StatementType
+	}
+	// DropEventDeclarations comes before Name in JSON
+	if len(s.DropEventDeclarations) > 0 {
+		events := make([]jsonNode, len(s.DropEventDeclarations))
+		for i, e := range s.DropEventDeclarations {
+			events[i] = eventSessionObjectNameToJSON(e)
+		}
+		node["DropEventDeclarations"] = events
+	}
+	// DropTargetDeclarations comes before Name in JSON
+	if len(s.DropTargetDeclarations) > 0 {
+		targets := make([]jsonNode, len(s.DropTargetDeclarations))
+		for i, t := range s.DropTargetDeclarations {
+			targets[i] = eventSessionObjectNameToJSON(t)
+		}
+		node["DropTargetDeclarations"] = targets
+	}
+	if s.Name != nil {
+		node["Name"] = identifierToJSON(s.Name)
+	}
+	if s.SessionScope != "" {
+		node["SessionScope"] = s.SessionScope
+	}
+	if len(s.EventDeclarations) > 0 {
+		events := make([]jsonNode, len(s.EventDeclarations))
+		for i, e := range s.EventDeclarations {
+			events[i] = eventDeclarationToJSON(e)
+		}
+		node["EventDeclarations"] = events
+	}
+	if len(s.TargetDeclarations) > 0 {
+		targets := make([]jsonNode, len(s.TargetDeclarations))
+		for i, t := range s.TargetDeclarations {
+			targets[i] = targetDeclarationToJSON(t)
+		}
+		node["TargetDeclarations"] = targets
+	}
+	if len(s.SessionOptions) > 0 {
+		opts := make([]jsonNode, len(s.SessionOptions))
+		for i, o := range s.SessionOptions {
+			opts[i] = sessionOptionToJSON(o)
+		}
+		node["SessionOptions"] = opts
+	}
+	return node
+}
+
 func eventDeclarationToJSON(e *ast.EventDeclaration) jsonNode {
 	node := jsonNode{
 		"$type": "EventDeclaration",
 	}
 	if e.ObjectName != nil {
 		node["ObjectName"] = eventSessionObjectNameToJSON(e.ObjectName)
 	}
+	if len(e.EventDeclarationSetParameters) > 0 {
+		params := make([]jsonNode, len(e.EventDeclarationSetParameters))
+		for i, p := range e.EventDeclarationSetParameters {
+			params[i] = eventDeclarationSetParameterToJSON(p)
+		}
+		node["EventDeclarationSetParameters"] = params
+	}
 	if len(e.EventDeclarationActionParameters) > 0 {
 		actions := make([]jsonNode, len(e.EventDeclarationActionParameters))
 		for i, a := range e.EventDeclarationActionParameters {

parser/parse_ddl.go

@@ -2056,9 +2056,13 @@ func (p *Parser) parseDropServiceStatement() (*ast.DropServiceStatement, error)
 	return stmt, nil
 }
 
-func (p *Parser) parseDropEventNotificationStatement() (*ast.DropEventNotificationStatement, error) {
+func (p *Parser) parseDropEventNotificationStatement() (ast.Statement, error) {
 	// Consume EVENT
 	p.nextToken()
+	// Check if this is DROP EVENT SESSION or DROP EVENT NOTIFICATION
+	if strings.ToUpper(p.curTok.Literal) == "SESSION" {
+		return p.parseDropEventSessionStatement()
+	}
 	// Consume NOTIFICATION
 	if strings.ToUpper(p.curTok.Literal) == "NOTIFICATION" {
 		p.nextToken()
@@ -2107,6 +2111,44 @@ func (p *Parser) parseDropEventNotificationStatement() (*ast.DropEventNotificati
 	return stmt, nil
 }
 
+func (p *Parser) parseDropEventSessionStatement() (*ast.DropEventSessionStatement, error) {
+	// Consume SESSION
+	p.nextToken()
+
+	stmt := &ast.DropEventSessionStatement{}
+
+	// Check for IF EXISTS
+	if strings.ToUpper(p.curTok.Literal) == "IF" {
+		p.nextToken()
+		if strings.ToUpper(p.curTok.Literal) == "EXISTS" {
+			stmt.IsIfExists = true
+			p.nextToken()
+		}
+	}
+
+	// Parse session name
+	stmt.Name = p.parseIdentifier()
+
+	// ON SERVER/DATABASE
+	if p.curTok.Type == TokenOn {
+		p.nextToken()
+		scopeUpper := strings.ToUpper(p.curTok.Literal)
+		if scopeUpper == "SERVER" {
+			stmt.SessionScope = "Server"
+			p.nextToken()
+		} else if scopeUpper == "DATABASE" {
+			stmt.SessionScope = "Database"
+			p.nextToken()
+		}
+	}
+
+	if p.curTok.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return stmt, nil
+}
+
 func (p *Parser) parseAlterStatement() (ast.Statement, error) {
 	// Consume ALTER
 	p.nextToken()
@@ -2204,6 +2246,8 @@ func (p *Parser) parseAlterStatement() (ast.Statement, error) {
 			return p.parseAlterAvailabilityGroupStatement()
 		case "MATERIALIZED":
 			return p.parseAlterMaterializedViewStatement()
+		case "EVENT":
+			return p.parseAlterEventSessionStatement()
 		}
 		return nil, fmt.Errorf("unexpected token after ALTER: %s", p.curTok.Literal)
 	default:
@@ -11575,3 +11619,128 @@ func (p *Parser) parseAvailabilityReplicasServerOnly() []*ast.AvailabilityReplic
 	}
 	return replicas
 }
+
+func (p *Parser) parseAlterEventSessionStatement() (*ast.AlterEventSessionStatement, error) {
+	p.nextToken() // consume EVENT
+	if strings.ToUpper(p.curTok.Literal) != "SESSION" {
+		return nil, fmt.Errorf("expected SESSION after EVENT, got %s", p.curTok.Literal)
+	}
+	p.nextToken() // consume SESSION
+
+	stmt := &ast.AlterEventSessionStatement{
+		Name: p.parseIdentifier(),
+	}
+
+	// ON SERVER/DATABASE
+	if p.curTok.Type == TokenOn {
+		p.nextToken()
+		scopeUpper := strings.ToUpper(p.curTok.Literal)
+		if scopeUpper == "SERVER" {
+			stmt.SessionScope = "Server"
+			p.nextToken()
+		} else if scopeUpper == "DATABASE" {
+			stmt.SessionScope = "Database"
+			p.nextToken()
+		}
+	}
+
+	// Parse action: ADD/DROP EVENT/TARGET, WITH, STATE
+	// Note: Don't use isStatementTerminator here because DROP is a statement terminator
+	// but we need to handle DROP EVENT/TARGET inside ALTER EVENT SESSION
+	for p.curTok.Type != TokenSemicolon && p.curTok.Type != TokenEOF {
+		// Check for GO batch separator
+		if p.curTok.Type == TokenIdent && strings.ToUpper(p.curTok.Literal) == "GO" {
+			break
+		}
+		// Check for other statement starters that would indicate end of this statement
+		switch p.curTok.Type {
+		case TokenSelect, TokenInsert, TokenUpdate, TokenDelete, TokenDeclare,
+			TokenIf, TokenWhile, TokenBegin, TokenEnd, TokenCreate, TokenAlter,
+			TokenExec, TokenExecute, TokenPrint, TokenThrow:
+			// These tokens indicate start of a new statement
+			goto done
+		}
+		upperLit := strings.ToUpper(p.curTok.Literal)
+
+		if upperLit == "ADD" || p.curTok.Type == TokenAdd {
+			p.nextToken()
+			addType := strings.ToUpper(p.curTok.Literal)
+			p.nextToken()
+
+			if addType == "EVENT" {
+				if stmt.StatementType == "" {
+					stmt.StatementType = "AddEventDeclarationOptionalSessionOptions"
+				}
+				event := p.parseEventDeclaration()
+				stmt.EventDeclarations = append(stmt.EventDeclarations, event)
+			} else if addType == "TARGET" {
+				if stmt.StatementType == "" {
+					stmt.StatementType = "AddTargetDeclarationOptionalSessionOptions"
+				}
+				target := p.parseTargetDeclaration()
+				stmt.TargetDeclarations = append(stmt.TargetDeclarations, target)
+			}
+		} else if upperLit == "DROP" || p.curTok.Type == TokenDrop {
+			p.nextToken()
+			dropType := strings.ToUpper(p.curTok.Literal)
+			p.nextToken()
+
+			if dropType == "EVENT" {
+				if stmt.StatementType == "" {
+					stmt.StatementType = "DropEventSpecificationOptionalSessionOptions"
+				}
+				objName := p.parseEventSessionObjectName()
+				stmt.DropEventDeclarations = append(stmt.DropEventDeclarations, objName)
+			} else if dropType == "TARGET" {
+				if stmt.StatementType == "" {
+					stmt.StatementType = "DropTargetSpecificationOptionalSessionOptions"
+				}
+				objName := p.parseEventSessionObjectName()
+				stmt.DropTargetDeclarations = append(stmt.DropTargetDeclarations, objName)
+			}
+		} else if upperLit == "WITH" || p.curTok.Type == TokenWith {
+			p.nextToken()
+			if p.curTok.Type == TokenLParen {
+				p.nextToken()
+				for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+					opt := p.parseSessionOption()
+					if opt != nil {
+						stmt.SessionOptions = append(stmt.SessionOptions, opt)
+					}
+					if p.curTok.Type == TokenComma {
+						p.nextToken()
+					} else {
+						break
+					}
+				}
+				if p.curTok.Type == TokenRParen {
+					p.nextToken()
+				}
+			}
+			if stmt.StatementType == "" {
+				stmt.StatementType = "RequiredSessionOptions"
+			}
+		} else if upperLit == "STATE" {
+			p.nextToken() // consume STATE
+			if p.curTok.Type == TokenEquals {
+				p.nextToken() // consume =
+			}
+			stateVal := strings.ToUpper(p.curTok.Literal)
+			if stateVal == "START" {
+				stmt.StatementType = "AlterStateIsStart"
+			} else if stateVal == "STOP" {
+				stmt.StatementType = "AlterStateIsStop"
+			}
+			p.nextToken()
+		} else if p.curTok.Type == TokenComma {
+			p.nextToken()
+		} else {
+			p.nextToken()
+		}
+	}
+done:
+	if p.curTok.Type == TokenSemicolon {
+		p.nextToken()
+	}
+	return stmt, nil
+}