Add comprehensive SET statement parsing support

Adds parsing for:
- SetCommandStatement with SetFipsFlaggerCommand and GeneralSetCommand
- SET TRANSACTION ISOLATION LEVEL
- SET TEXTSIZE
- SET IDENTITY_INSERT
- SET ERRLVL
- Various SET commands: FIPS_FLAGGER, LANGUAGE, DATEFORMAT, DATEFIRST,
  DEADLOCK_PRIORITY, LOCK_TIMEOUT, CONTEXT_INFO, QUERY_GOVERNOR_COST_LIMIT

Author: claude

ast/set_command_statement.go

@@ -0,0 +1,65 @@
+package ast
+
+// SetCommandStatement represents a SET statement with commands (not variables)
+type SetCommandStatement struct {
+	Commands []SetCommand
+}
+
+func (s *SetCommandStatement) node()      {}
+func (s *SetCommandStatement) statement() {}
+
+// SetCommand is an interface for SET commands
+type SetCommand interface {
+	Node
+	setCommand()
+}
+
+// SetFipsFlaggerCommand represents SET FIPS_FLAGGER command
+type SetFipsFlaggerCommand struct {
+	ComplianceLevel string // "Off", "Entry", "Intermediate", "Full"
+}
+
+func (s *SetFipsFlaggerCommand) node()       {}
+func (s *SetFipsFlaggerCommand) setCommand() {}
+
+// GeneralSetCommand represents SET commands like LANGUAGE, DATEFORMAT, etc.
+type GeneralSetCommand struct {
+	CommandType string           // "Language", "DateFormat", "DateFirst", "DeadlockPriority", "LockTimeout", "ContextInfo", "QueryGovernorCostLimit"
+	Parameter   ScalarExpression // The parameter value
+}
+
+func (s *GeneralSetCommand) node()       {}
+func (s *GeneralSetCommand) setCommand() {}
+
+// SetTransactionIsolationLevelStatement represents SET TRANSACTION ISOLATION LEVEL statement
+type SetTransactionIsolationLevelStatement struct {
+	Level string // "ReadUncommitted", "ReadCommitted", "RepeatableRead", "Serializable", "Snapshot"
+}
+
+func (s *SetTransactionIsolationLevelStatement) node()      {}
+func (s *SetTransactionIsolationLevelStatement) statement() {}
+
+// SetTextSizeStatement represents SET TEXTSIZE statement
+type SetTextSizeStatement struct {
+	TextSize ScalarExpression
+}
+
+func (s *SetTextSizeStatement) node()      {}
+func (s *SetTextSizeStatement) statement() {}
+
+// SetIdentityInsertStatement represents SET IDENTITY_INSERT statement
+type SetIdentityInsertStatement struct {
+	Table *SchemaObjectName
+	IsOn  bool
+}
+
+func (s *SetIdentityInsertStatement) node()      {}
+func (s *SetIdentityInsertStatement) statement() {}
+
+// SetErrorLevelStatement represents SET ERRLVL statement
+type SetErrorLevelStatement struct {
+	Level ScalarExpression
+}
+
+func (s *SetErrorLevelStatement) node()      {}
+func (s *SetErrorLevelStatement) statement() {}

parser/marshal.go

@@ -248,6 +248,16 @@ func statementToJSON(stmt ast.Statement) jsonNode {
 		return setRowCountStatementToJSON(s)
 	case *ast.SetOffsetsStatement:
 		return setOffsetsStatementToJSON(s)
+	case *ast.SetCommandStatement:
+		return setCommandStatementToJSON(s)
+	case *ast.SetTransactionIsolationLevelStatement:
+		return setTransactionIsolationLevelStatementToJSON(s)
+	case *ast.SetTextSizeStatement:
+		return setTextSizeStatementToJSON(s)
+	case *ast.SetIdentityInsertStatement:
+		return setIdentityInsertStatementToJSON(s)
+	case *ast.SetErrorLevelStatement:
+		return setErrorLevelStatementToJSON(s)
 	case *ast.CommitTransactionStatement:
 		return commitTransactionStatementToJSON(s)
 	case *ast.RollbackTransactionStatement:
@@ -6226,6 +6236,79 @@ func setOffsetsStatementToJSON(s *ast.SetOffsetsStatement) jsonNode {
 	}
 }
 
+func setCommandStatementToJSON(s *ast.SetCommandStatement) jsonNode {
+	node := jsonNode{
+		"$type": "SetCommandStatement",
+	}
+	if len(s.Commands) > 0 {
+		cmds := make([]jsonNode, len(s.Commands))
+		for i, cmd := range s.Commands {
+			cmds[i] = setCommandToJSON(cmd)
+		}
+		node["Commands"] = cmds
+	}
+	return node
+}
+
+func setCommandToJSON(cmd ast.SetCommand) jsonNode {
+	switch c := cmd.(type) {
+	case *ast.SetFipsFlaggerCommand:
+		return jsonNode{
+			"$type":           "SetFipsFlaggerCommand",
+			"ComplianceLevel": c.ComplianceLevel,
+		}
+	case *ast.GeneralSetCommand:
+		node := jsonNode{
+			"$type":       "GeneralSetCommand",
+			"CommandType": c.CommandType,
+		}
+		if c.Parameter != nil {
+			node["Parameter"] = scalarExpressionToJSON(c.Parameter)
+		}
+		return node
+	default:
+		return jsonNode{"$type": "UnknownSetCommand"}
+	}
+}
+
+func setTransactionIsolationLevelStatementToJSON(s *ast.SetTransactionIsolationLevelStatement) jsonNode {
+	return jsonNode{
+		"$type": "SetTransactionIsolationLevelStatement",
+		"Level": s.Level,
+	}
+}
+
+func setTextSizeStatementToJSON(s *ast.SetTextSizeStatement) jsonNode {
+	node := jsonNode{
+		"$type": "SetTextSizeStatement",
+	}
+	if s.TextSize != nil {
+		node["TextSize"] = scalarExpressionToJSON(s.TextSize)
+	}
+	return node
+}
+
+func setIdentityInsertStatementToJSON(s *ast.SetIdentityInsertStatement) jsonNode {
+	node := jsonNode{
+		"$type": "SetIdentityInsertStatement",
+		"IsOn":  s.IsOn,
+	}
+	if s.Table != nil {
+		node["Table"] = schemaObjectNameToJSON(s.Table)
+	}
+	return node
+}
+
+func setErrorLevelStatementToJSON(s *ast.SetErrorLevelStatement) jsonNode {
+	node := jsonNode{
+		"$type": "SetErrorLevelStatement",
+	}
+	if s.Level != nil {
+		node["Level"] = scalarExpressionToJSON(s.Level)
+	}
+	return node
+}
+
 func commitTransactionStatementToJSON(s *ast.CommitTransactionStatement) jsonNode {
 	node := jsonNode{
 		"$type":                   "CommitTransactionStatement",