Add CREATE/ALTER USER WITH options parsing support

- Add PasswordAlterPrincipalOption type for ALTER USER WITH PASSWORD/OLD_PASSWORD
- Update AlterUserStatement to use UserOptions field
- Fix convertUserOptionKind mapping for DEFAULT_SCHEMA and DEFAULT_LANGUAGE
- Implement parseAlterUserStatement WITH options parsing
- Add JSON marshalling for PasswordAlterPrincipalOption

Enables tests:
- Baselines110_CreateAlterUserStatementTests110
- CreateAlterUserStatementTests110

Author: claude

ast/alter_user_statement.go

@@ -2,8 +2,8 @@ package ast
 
 // AlterUserStatement represents an ALTER USER statement.
 type AlterUserStatement struct {
-	Name    *Identifier  `json:"Name,omitempty"`
-	Options []UserOption `json:"Options,omitempty"`
+	Name        *Identifier  `json:"Name,omitempty"`
+	UserOptions []UserOption `json:"UserOptions,omitempty"`
 }
 
 func (s *AlterUserStatement) node()      {}

ast/create_user_statement.go

@@ -44,3 +44,15 @@ type DefaultSchemaPrincipalOption struct {
 }
 
 func (o *DefaultSchemaPrincipalOption) userOptionNode() {}
+
+// PasswordAlterPrincipalOption represents a password option for ALTER USER
+type PasswordAlterPrincipalOption struct {
+	Password    *StringLiteral
+	OldPassword *StringLiteral
+	MustChange  bool
+	Unlock      bool
+	Hashed      bool
+	OptionKind  string
+}
+
+func (o *PasswordAlterPrincipalOption) userOptionNode() {}

parser/marshal.go

@@ -7178,6 +7178,21 @@ func userOptionToJSON(o ast.UserOption) jsonNode {
 			node["Identifier"] = identifierToJSON(opt.Identifier)
 		}
 		return node
+	case *ast.PasswordAlterPrincipalOption:
+		node := jsonNode{
+			"$type":      "PasswordAlterPrincipalOption",
+			"OptionKind": opt.OptionKind,
+			"MustChange": opt.MustChange,
+			"Unlock":     opt.Unlock,
+			"Hashed":     opt.Hashed,
+		}
+		if opt.Password != nil {
+			node["Password"] = stringLiteralToJSON(opt.Password)
+		}
+		if opt.OldPassword != nil {
+			node["OldPassword"] = stringLiteralToJSON(opt.OldPassword)
+		}
+		return node
 	default:
 		return jsonNode{"$type": "UnknownUserOption"}
 	}
@@ -7689,12 +7704,13 @@ func indexOptionToJSON(opt ast.IndexOption) jsonNode {
 func convertUserOptionKind(name string) string {
 	// Convert option names to the expected format
 	optionMap := map[string]string{
-		"OBJECT_ID":      "Object_ID",
-		"DEFAULT_SCHEMA": "Default_Schema",
-		"SID":            "Sid",
-		"PASSWORD":       "Password",
-		"NAME":           "Name",
-		"LOGIN":          "Login",
+		"OBJECT_ID":        "Object_ID",
+		"DEFAULT_SCHEMA":   "DefaultSchema",
+		"DEFAULT_LANGUAGE": "DefaultLanguage",
+		"SID":              "Sid",
+		"PASSWORD":         "Password",
+		"NAME":             "Name",
+		"LOGIN":            "Login",
 	}
 	upper := strings.ToUpper(name)
 	if mapped, ok := optionMap[upper]; ok {
@@ -8784,6 +8800,13 @@ func alterUserStatementToJSON(s *ast.AlterUserStatement) jsonNode {
 	if s.Name != nil {
 		node["Name"] = identifierToJSON(s.Name)
 	}
+	if len(s.UserOptions) > 0 {
+		options := make([]jsonNode, len(s.UserOptions))
+		for i, o := range s.UserOptions {
+			options[i] = userOptionToJSON(o)
+		}
+		node["UserOptions"] = options
+	}
 	return node
 }
 

parser/parse_ddl.go

@@ -3754,8 +3754,71 @@ func (p *Parser) parseAlterUserStatement() (*ast.AlterUserStatement, error) {
 	// Parse user name
 	stmt.Name = p.parseIdentifier()
 
-	// Skip rest of statement
-	p.skipToEndOfStatement()
+	// Parse WITH options
+	if p.curTok.Type == TokenWith {
+		p.nextToken()
+
+		for {
+			optionName := strings.ToUpper(p.curTok.Literal)
+			p.nextToken()
+
+			// Handle PASSWORD specially for ALTER USER (can have OLD_PASSWORD)
+			if optionName == "PASSWORD" {
+				if p.curTok.Type == TokenEquals {
+					p.nextToken()
+				}
+				passwordOpt := &ast.PasswordAlterPrincipalOption{
+					OptionKind: "Password",
+				}
+				if p.curTok.Type == TokenString {
+					passwordOpt.Password = p.parseStringLiteralValue()
+					p.nextToken()
+				}
+				// Check for OLD_PASSWORD
+				if strings.ToUpper(p.curTok.Literal) == "OLD_PASSWORD" {
+					p.nextToken() // consume OLD_PASSWORD
+					if p.curTok.Type == TokenEquals {
+						p.nextToken()
+					}
+					if p.curTok.Type == TokenString {
+						passwordOpt.OldPassword = p.parseStringLiteralValue()
+						p.nextToken()
+					}
+				}
+				stmt.UserOptions = append(stmt.UserOptions, passwordOpt)
+			} else {
+				if p.curTok.Type == TokenEquals {
+					p.nextToken()
+				}
+
+				value, err := p.parseScalarExpression()
+				if err != nil {
+					break
+				}
+
+				// Check if value is a simple identifier
+				var opt ast.UserOption
+				if colRef, ok := value.(*ast.ColumnReferenceExpression); ok && colRef.MultiPartIdentifier != nil && len(colRef.MultiPartIdentifier.Identifiers) == 1 {
+					opt = &ast.IdentifierPrincipalOption{
+						OptionKind: convertUserOptionKind(optionName),
+						Identifier: colRef.MultiPartIdentifier.Identifiers[0],
+					}
+				} else {
+					opt = &ast.LiteralPrincipalOption{
+						OptionKind: convertUserOptionKind(optionName),
+						Value:      value,
+					}
+				}
+				stmt.UserOptions = append(stmt.UserOptions, opt)
+			}
+
+			if p.curTok.Type == TokenComma {
+				p.nextToken()
+			} else {
+				break
+			}
+		}
+	}
 
 	return stmt, nil
 }

parser/testdata/Baselines110_CreateAlterUserStatementTests110/metadata.json

@@ -1 +1 @@
-{"todo": true}
+{}

parser/testdata/CreateAlterUserStatementTests110/metadata.json

@@ -1 +1 @@
-{"todo": true}
+{}