Add CREATE AVAILABILITY GROUP statement support

- Add CreateAvailabilityGroupStatement AST type with full replica parsing
- Support REQUIRED_COPIES_TO_COMMIT option
- Parse replica options: AVAILABILITY_MODE, FAILOVER_MODE, ENDPOINT_URL,
  SESSION_TIMEOUT, APPLY_DELAY
- Parse role-based options: PRIMARY_ROLE and SECONDARY_ROLE with ALLOW_CONNECTIONS
- Add marshaling functions for all new types
- Enable 2 passing tests

Author: claude

ast/create_availability_group_statement.go

@@ -0,0 +1,86 @@
+package ast
+
+// CreateAvailabilityGroupStatement represents a CREATE AVAILABILITY GROUP statement
+type CreateAvailabilityGroupStatement struct {
+	Name      *Identifier
+	Options   []AvailabilityGroupOption
+	Databases []*Identifier
+	Replicas  []*AvailabilityReplica
+}
+
+func (s *CreateAvailabilityGroupStatement) node()      {}
+func (s *CreateAvailabilityGroupStatement) statement() {}
+
+// AvailabilityGroupOption is an interface for availability group options
+type AvailabilityGroupOption interface {
+	node()
+	availabilityGroupOption()
+}
+
+// LiteralAvailabilityGroupOption represents an availability group option with a literal value
+type LiteralAvailabilityGroupOption struct {
+	OptionKind string           // e.g., "RequiredCopiesToCommit"
+	Value      ScalarExpression // The value for the option
+}
+
+func (o *LiteralAvailabilityGroupOption) node()                    {}
+func (o *LiteralAvailabilityGroupOption) availabilityGroupOption() {}
+
+// AvailabilityReplica represents a replica in an availability group
+type AvailabilityReplica struct {
+	ServerName *StringLiteral
+	Options    []AvailabilityReplicaOption
+}
+
+func (r *AvailabilityReplica) node() {}
+
+// AvailabilityReplicaOption is an interface for availability replica options
+type AvailabilityReplicaOption interface {
+	node()
+	availabilityReplicaOption()
+}
+
+// AvailabilityModeReplicaOption represents AVAILABILITY_MODE option
+type AvailabilityModeReplicaOption struct {
+	OptionKind string // "AvailabilityMode"
+	Value      string // "SynchronousCommit", "AsynchronousCommit"
+}
+
+func (o *AvailabilityModeReplicaOption) node()                      {}
+func (o *AvailabilityModeReplicaOption) availabilityReplicaOption() {}
+
+// FailoverModeReplicaOption represents FAILOVER_MODE option
+type FailoverModeReplicaOption struct {
+	OptionKind string // "FailoverMode"
+	Value      string // "Automatic", "Manual"
+}
+
+func (o *FailoverModeReplicaOption) node()                      {}
+func (o *FailoverModeReplicaOption) availabilityReplicaOption() {}
+
+// LiteralReplicaOption represents a replica option with a literal value
+type LiteralReplicaOption struct {
+	OptionKind string           // e.g., "EndpointUrl", "SessionTimeout", "ApplyDelay"
+	Value      ScalarExpression // The value for the option
+}
+
+func (o *LiteralReplicaOption) node()                      {}
+func (o *LiteralReplicaOption) availabilityReplicaOption() {}
+
+// PrimaryRoleReplicaOption represents PRIMARY_ROLE option
+type PrimaryRoleReplicaOption struct {
+	OptionKind       string // "PrimaryRole"
+	AllowConnections string // "All", "ReadWrite"
+}
+
+func (o *PrimaryRoleReplicaOption) node()                      {}
+func (o *PrimaryRoleReplicaOption) availabilityReplicaOption() {}
+
+// SecondaryRoleReplicaOption represents SECONDARY_ROLE option
+type SecondaryRoleReplicaOption struct {
+	OptionKind       string // "SecondaryRole"
+	AllowConnections string // "No", "ReadOnly", "All"
+}
+
+func (o *SecondaryRoleReplicaOption) node()                      {}
+func (o *SecondaryRoleReplicaOption) availabilityReplicaOption() {}

parser/marshal.go

@@ -344,6 +344,8 @@ func statementToJSON(stmt ast.Statement) jsonNode {
 		return createServerRoleStatementToJSON(s)
 	case *ast.AlterServerRoleStatement:
 		return alterServerRoleStatementToJSON(s)
+	case *ast.CreateAvailabilityGroupStatement:
+		return createAvailabilityGroupStatementToJSON(s)
 	case *ast.CreateServerAuditStatement:
 		return createServerAuditStatementToJSON(s)
 	case *ast.AlterServerAuditStatement:
@@ -8031,6 +8033,110 @@ func alterServerRoleStatementToJSON(s *ast.AlterServerRoleStatement) jsonNode {
 	return node
 }
 
+func createAvailabilityGroupStatementToJSON(s *ast.CreateAvailabilityGroupStatement) jsonNode {
+	node := jsonNode{
+		"$type": "CreateAvailabilityGroupStatement",
+	}
+	if s.Name != nil {
+		node["Name"] = identifierToJSON(s.Name)
+	}
+	if len(s.Options) > 0 {
+		opts := make([]jsonNode, len(s.Options))
+		for i, opt := range s.Options {
+			opts[i] = availabilityGroupOptionToJSON(opt)
+		}
+		node["Options"] = opts
+	}
+	if len(s.Databases) > 0 {
+		dbs := make([]jsonNode, len(s.Databases))
+		for i, db := range s.Databases {
+			dbs[i] = identifierToJSON(db)
+		}
+		node["Databases"] = dbs
+	}
+	if len(s.Replicas) > 0 {
+		reps := make([]jsonNode, len(s.Replicas))
+		for i, rep := range s.Replicas {
+			reps[i] = availabilityReplicaToJSON(rep)
+		}
+		node["Replicas"] = reps
+	}
+	return node
+}
+
+func availabilityGroupOptionToJSON(opt ast.AvailabilityGroupOption) jsonNode {
+	switch o := opt.(type) {
+	case *ast.LiteralAvailabilityGroupOption:
+		node := jsonNode{
+			"$type": "LiteralAvailabilityGroupOption",
+		}
+		if o.Value != nil {
+			node["Value"] = scalarExpressionToJSON(o.Value)
+		}
+		node["OptionKind"] = o.OptionKind
+		return node
+	default:
+		return jsonNode{"$type": "UnknownAvailabilityGroupOption"}
+	}
+}
+
+func availabilityReplicaToJSON(rep *ast.AvailabilityReplica) jsonNode {
+	node := jsonNode{
+		"$type": "AvailabilityReplica",
+	}
+	if rep.ServerName != nil {
+		node["ServerName"] = stringLiteralToJSON(rep.ServerName)
+	}
+	if len(rep.Options) > 0 {
+		opts := make([]jsonNode, len(rep.Options))
+		for i, opt := range rep.Options {
+			opts[i] = availabilityReplicaOptionToJSON(opt)
+		}
+		node["Options"] = opts
+	}
+	return node
+}
+
+func availabilityReplicaOptionToJSON(opt ast.AvailabilityReplicaOption) jsonNode {
+	switch o := opt.(type) {
+	case *ast.AvailabilityModeReplicaOption:
+		return jsonNode{
+			"$type":      "AvailabilityModeReplicaOption",
+			"Value":      o.Value,
+			"OptionKind": o.OptionKind,
+		}
+	case *ast.FailoverModeReplicaOption:
+		return jsonNode{
+			"$type":      "FailoverModeReplicaOption",
+			"Value":      o.Value,
+			"OptionKind": o.OptionKind,
+		}
+	case *ast.LiteralReplicaOption:
+		node := jsonNode{
+			"$type": "LiteralReplicaOption",
+		}
+		if o.Value != nil {
+			node["Value"] = scalarExpressionToJSON(o.Value)
+		}
+		node["OptionKind"] = o.OptionKind
+		return node
+	case *ast.PrimaryRoleReplicaOption:
+		return jsonNode{
+			"$type":            "PrimaryRoleReplicaOption",
+			"AllowConnections": o.AllowConnections,
+			"OptionKind":       o.OptionKind,
+		}
+	case *ast.SecondaryRoleReplicaOption:
+		return jsonNode{
+			"$type":            "SecondaryRoleReplicaOption",
+			"AllowConnections": o.AllowConnections,
+			"OptionKind":       o.OptionKind,
+		}
+	default:
+		return jsonNode{"$type": "UnknownReplicaOption"}
+	}
+}
+
 func createServerAuditStatementToJSON(s *ast.CreateServerAuditStatement) jsonNode {
 	node := jsonNode{
 		"$type": "CreateServerAuditStatement",