Add REMOTE_DATA_ARCHIVE database option parsing

Implements parsing for ALTER DATABASE ... SET REMOTE_DATA_ARCHIVE with:
- ON/OFF state and optional settings
- SERVER, CREDENTIAL, and FEDERATED_SERVICE_ACCOUNT settings

Author: claude

ast/alter_database_set_statement.go

@@ -192,3 +192,46 @@ type DatabaseConfigurationClearOption struct {
 }
 
 func (d *DatabaseConfigurationClearOption) node() {}
+
+// RemoteDataArchiveDatabaseOption represents REMOTE_DATA_ARCHIVE database option
+type RemoteDataArchiveDatabaseOption struct {
+	OptionKind  string                       // "RemoteDataArchive"
+	OptionState string                       // "On", "Off", "NotSet"
+	Settings    []RemoteDataArchiveDbSetting // Settings like SERVER, CREDENTIAL, FEDERATED_SERVICE_ACCOUNT
+}
+
+func (r *RemoteDataArchiveDatabaseOption) node()           {}
+func (r *RemoteDataArchiveDatabaseOption) databaseOption() {}
+
+// RemoteDataArchiveDbSetting is an interface for Remote Data Archive settings
+type RemoteDataArchiveDbSetting interface {
+	Node
+	remoteDataArchiveDbSetting()
+}
+
+// RemoteDataArchiveDbServerSetting represents the SERVER setting
+type RemoteDataArchiveDbServerSetting struct {
+	SettingKind string           // "Server"
+	Server      ScalarExpression // The server string literal
+}
+
+func (r *RemoteDataArchiveDbServerSetting) node()                      {}
+func (r *RemoteDataArchiveDbServerSetting) remoteDataArchiveDbSetting() {}
+
+// RemoteDataArchiveDbCredentialSetting represents the CREDENTIAL setting
+type RemoteDataArchiveDbCredentialSetting struct {
+	SettingKind string      // "Credential"
+	Credential  *Identifier // The credential name
+}
+
+func (r *RemoteDataArchiveDbCredentialSetting) node()                      {}
+func (r *RemoteDataArchiveDbCredentialSetting) remoteDataArchiveDbSetting() {}
+
+// RemoteDataArchiveDbFederatedServiceAccountSetting represents the FEDERATED_SERVICE_ACCOUNT setting
+type RemoteDataArchiveDbFederatedServiceAccountSetting struct {
+	SettingKind string // "FederatedServiceAccount"
+	IsOn        bool   // true for ON, false for OFF
+}
+
+func (r *RemoteDataArchiveDbFederatedServiceAccountSetting) node()                      {}
+func (r *RemoteDataArchiveDbFederatedServiceAccountSetting) remoteDataArchiveDbSetting() {}

parser/marshal.go

@@ -987,11 +987,56 @@ func databaseOptionToJSON(opt ast.DatabaseOption) jsonNode {
 			node["OptionKind"] = o.OptionKind
 		}
 		return node
+	case *ast.RemoteDataArchiveDatabaseOption:
+		node := jsonNode{
+			"$type":       "RemoteDataArchiveDatabaseOption",
+			"OptionState": o.OptionState,
+			"OptionKind":  o.OptionKind,
+		}
+		if len(o.Settings) > 0 {
+			settings := make([]jsonNode, len(o.Settings))
+			for i, setting := range o.Settings {
+				settings[i] = remoteDataArchiveDbSettingToJSON(setting)
+			}
+			node["Settings"] = settings
+		}
+		return node
 	default:
 		return jsonNode{"$type": "UnknownDatabaseOption"}
 	}
 }
 
+func remoteDataArchiveDbSettingToJSON(setting ast.RemoteDataArchiveDbSetting) jsonNode {
+	switch s := setting.(type) {
+	case *ast.RemoteDataArchiveDbServerSetting:
+		node := jsonNode{
+			"$type":       "RemoteDataArchiveDbServerSetting",
+			"SettingKind": s.SettingKind,
+		}
+		if s.Server != nil {
+			node["Server"] = scalarExpressionToJSON(s.Server)
+		}
+		return node
+	case *ast.RemoteDataArchiveDbCredentialSetting:
+		node := jsonNode{
+			"$type":       "RemoteDataArchiveDbCredentialSetting",
+			"SettingKind": s.SettingKind,
+		}
+		if s.Credential != nil {
+			node["Credential"] = identifierToJSON(s.Credential)
+		}
+		return node
+	case *ast.RemoteDataArchiveDbFederatedServiceAccountSetting:
+		return jsonNode{
+			"$type":       "RemoteDataArchiveDbFederatedServiceAccountSetting",
+			"IsOn":        s.IsOn,
+			"SettingKind": s.SettingKind,
+		}
+	default:
+		return jsonNode{"$type": "UnknownRemoteDataArchiveDbSetting"}
+	}
+}
+
 func indexDefinitionToJSON(idx *ast.IndexDefinition) jsonNode {
 	node := jsonNode{
 		"$type":  "IndexDefinition",

parser/parse_ddl.go

@@ -1885,6 +1885,12 @@ func (p *Parser) parseAlterDatabaseSetStatement(dbName *ast.Identifier) (*ast.Al
 				}
 			}
 			stmt.Options = append(stmt.Options, opt)
+		case "REMOTE_DATA_ARCHIVE":
+			rdaOpt, err := p.parseRemoteDataArchiveOption()
+			if err != nil {
+				return nil, err
+			}
+			stmt.Options = append(stmt.Options, rdaOpt)
 		default:
 			// Handle generic options with = syntax (e.g., OPTIMIZED_LOCKING = ON)
 			if p.curTok.Type == TokenEquals {
@@ -1933,6 +1939,86 @@ func (p *Parser) parseAlterDatabaseSetStatement(dbName *ast.Identifier) (*ast.Al
 	return stmt, nil
 }
 
+// parseRemoteDataArchiveOption parses REMOTE_DATA_ARCHIVE option
+// Forms:
+//   - REMOTE_DATA_ARCHIVE = ON (options...)
+//   - REMOTE_DATA_ARCHIVE = OFF
+//   - REMOTE_DATA_ARCHIVE (options...) -- OptionState is "NotSet"
+func (p *Parser) parseRemoteDataArchiveOption() (*ast.RemoteDataArchiveDatabaseOption, error) {
+	opt := &ast.RemoteDataArchiveDatabaseOption{
+		OptionKind:  "RemoteDataArchive",
+		OptionState: "NotSet",
+	}
+
+	// Check for = ON/OFF or just (
+	if p.curTok.Type == TokenEquals {
+		p.nextToken() // consume =
+		stateVal := strings.ToUpper(p.curTok.Literal)
+		opt.OptionState = capitalizeFirst(stateVal)
+		p.nextToken() // consume ON/OFF
+	}
+
+	// Parse settings if we have (
+	if p.curTok.Type == TokenLParen {
+		p.nextToken() // consume (
+		for {
+			settingName := strings.ToUpper(p.curTok.Literal)
+			p.nextToken() // consume setting name
+
+			if p.curTok.Type != TokenEquals {
+				return nil, fmt.Errorf("expected = after %s, got %s", settingName, p.curTok.Literal)
+			}
+			p.nextToken() // consume =
+
+			switch settingName {
+			case "SERVER":
+				// Parse string literal
+				server, err := p.parseScalarExpression()
+				if err != nil {
+					return nil, err
+				}
+				setting := &ast.RemoteDataArchiveDbServerSetting{
+					SettingKind: "Server",
+					Server:      server,
+				}
+				opt.Settings = append(opt.Settings, setting)
+			case "CREDENTIAL":
+				// Parse identifier (may be bracketed)
+				cred := p.parseIdentifier()
+				setting := &ast.RemoteDataArchiveDbCredentialSetting{
+					SettingKind: "Credential",
+					Credential:  cred,
+				}
+				opt.Settings = append(opt.Settings, setting)
+			case "FEDERATED_SERVICE_ACCOUNT":
+				// Parse ON/OFF
+				isOn := strings.ToUpper(p.curTok.Literal) == "ON"
+				p.nextToken()
+				setting := &ast.RemoteDataArchiveDbFederatedServiceAccountSetting{
+					SettingKind: "FederatedServiceAccount",
+					IsOn:        isOn,
+				}
+				opt.Settings = append(opt.Settings, setting)
+			default:
+				return nil, fmt.Errorf("unknown REMOTE_DATA_ARCHIVE setting: %s", settingName)
+			}
+
+			if p.curTok.Type == TokenComma {
+				p.nextToken()
+			} else {
+				break
+			}
+		}
+
+		if p.curTok.Type != TokenRParen {
+			return nil, fmt.Errorf("expected ) after REMOTE_DATA_ARCHIVE settings, got %s", p.curTok.Literal)
+		}
+		p.nextToken() // consume )
+	}
+
+	return opt, nil
+}
+
 func (p *Parser) parseAlterDatabaseAddStatement(dbName *ast.Identifier) (ast.Statement, error) {
 	// Consume ADD
 	p.nextToken()

parser/testdata/Baselines130_RemoteDataArchiveDatabaseTests130/metadata.json

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

parser/testdata/RemoteDataArchiveDatabaseTests130/metadata.json

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