azurerm_mssql_server and azurerm_mssql_database - upgrade from v5.0/sql to 2023-02-01-preview

internal/services/mssql/custompollers/mssql_deleteserverazureadonlyauthentication_poller.go

@@ -0,0 +1,59 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package custompollers
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/sql/2023-02-01-preview/serverazureadonlyauthentications"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+)
+
+var _ pollers.PollerType = &MsSqlServerDeleteServerAzureADOnlyAuthenticationPoller{}
+
+func NewMsSqlServerDeleteServerAzureADOnlyAuthenticationPoller(client *serverazureadonlyauthentications.ServerAzureADOnlyAuthenticationsClient, serverId commonids.SqlServerId) *MsSqlServerDeleteServerAzureADOnlyAuthenticationPoller {
+	return &MsSqlServerDeleteServerAzureADOnlyAuthenticationPoller{
+		client:   client,
+		serverId: serverId,
+	}
+}
+
+type MsSqlServerDeleteServerAzureADOnlyAuthenticationPoller struct {
+	client   *serverazureadonlyauthentications.ServerAzureADOnlyAuthenticationsClient
+	serverId commonids.SqlServerId
+}
+
+func (p *MsSqlServerDeleteServerAzureADOnlyAuthenticationPoller) Poll(ctx context.Context) (*pollers.PollResult, error) {
+	resp, err := p.client.Get(ctx, p.serverId)
+	if err != nil {
+		return nil, fmt.Errorf("retrieving %s: %+v", p.serverId, err)
+	}
+
+	if resp.Model == nil {
+		return nil, fmt.Errorf("retrieving %s: `model` was nil", p.serverId)
+	}
+
+	name := pointer.From(resp.Model.Name)
+	azureAdOnlyAuthentication := true
+	if props := resp.Model.Properties; props != nil {
+		azureAdOnlyAuthentication = props.AzureADOnlyAuthentication
+	}
+
+	if !azureAdOnlyAuthentication && strings.EqualFold(name, "Default") {
+		return &pollers.PollResult{
+			Status:       pollers.PollingStatusSucceeded,
+			PollInterval: 5 * time.Second,
+		}, nil
+	}
+
+	return &pollers.PollResult{
+		Status:       pollers.PollingStatusInProgress,
+		PollInterval: 5 * time.Second,
+	}, nil
+}

internal/services/mssql/helper/elasticpool.go

@@ -269,14 +269,14 @@ func MSSQLElasticPoolValidateSKU(diff *pluginsdk.ResourceDiff) error {
 
 	// Universal check for both DTU and vCore based SKUs
 	if !nameTierIsValid(s) {
-		return fmt.Errorf("Mismatch between SKU name '%s' and tier '%s', expected 'tier' to be '%s'", s.Name, s.Tier, getTierFromName[strings.ToLower(s.Name)])
+		return fmt.Errorf("mismatch between SKU name '%s' and tier '%s', expected 'tier' to be '%s'", s.Name, s.Tier, getTierFromName[strings.ToLower(s.Name)])
 	}
 
 	// Verify that Family is valid
 	if s.SkuType == DTU && s.Family != "" {
-		return fmt.Errorf("Invalid attribute 'family'(%s) for service tier '%s', remove the 'family' attribute from the configuration file", s.Family, s.Tier)
+		return fmt.Errorf("invalid attribute 'family'(%s) for service tier '%s', remove the 'family' attribute from the configuration file", s.Family, s.Tier)
 	} else if s.SkuType == VCore && !nameContainsFamily(s) {
-		return fmt.Errorf("Mismatch between SKU name '%s' and family '%s', expected '%s'", s.Name, s.Family, getFamilyFromName(s))
+		return fmt.Errorf("mismatch between SKU name '%s' and family '%s', expected '%s'", s.Name, s.Family, getFamilyFromName(s))
 	}
 
 	// get max GB and do validation based on SKU type

internal/services/mssql/helper/sql_retention_policies.go

@@ -7,11 +7,12 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/Azure/azure-sdk-for-go/services/preview/sql/mgmt/v5.0/sql" // nolint: staticcheck
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/sql/2023-02-01-preview/backupshorttermretentionpolicies"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/sql/2023-02-01-preview/longtermretentionpolicies"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
 )
 
 func LongTermRetentionPolicySchema() *pluginsdk.Schema {
@@ -98,62 +99,62 @@ func ShortTermRetentionPolicySchema() *pluginsdk.Schema {
 	}
 }
 
-func ExpandLongTermRetentionPolicy(input []interface{}) *sql.BaseLongTermRetentionPolicyProperties {
+func ExpandLongTermRetentionPolicy(input []interface{}) *longtermretentionpolicies.LongTermRetentionPolicyProperties {
 	if len(input) == 0 || input[0] == nil {
 		return nil
 	}
 
-	longTermRetentionPolicy := input[0].(map[string]interface{})
+	policy := input[0].(map[string]interface{})
 
-	longTermPolicyProperties := sql.BaseLongTermRetentionPolicyProperties{
-		WeeklyRetention:  utils.String("PT0S"),
-		MonthlyRetention: utils.String("PT0S"),
-		YearlyRetention:  utils.String("PT0S"),
-		WeekOfYear:       utils.Int32(1),
+	output := longtermretentionpolicies.LongTermRetentionPolicyProperties{
+		WeeklyRetention:  pointer.To("PT0S"),
+		MonthlyRetention: pointer.To("PT0S"),
+		YearlyRetention:  pointer.To("PT0S"),
+		WeekOfYear:       pointer.To(int64(1)),
 	}
 
-	if v, ok := longTermRetentionPolicy["weekly_retention"]; ok {
-		longTermPolicyProperties.WeeklyRetention = utils.String(v.(string))
+	if v, ok := policy["weekly_retention"]; ok {
+		output.WeeklyRetention = pointer.To(v.(string))
 	}
 
-	if v, ok := longTermRetentionPolicy["monthly_retention"]; ok {
-		longTermPolicyProperties.MonthlyRetention = utils.String(v.(string))
+	if v, ok := policy["monthly_retention"]; ok {
+		output.MonthlyRetention = pointer.To(v.(string))
 	}
 
-	if v, ok := longTermRetentionPolicy["yearly_retention"]; ok {
-		longTermPolicyProperties.YearlyRetention = utils.String(v.(string))
+	if v, ok := policy["yearly_retention"]; ok {
+		output.YearlyRetention = pointer.To(v.(string))
 	}
 
-	if v, ok := longTermRetentionPolicy["week_of_year"]; ok {
-		longTermPolicyProperties.WeekOfYear = utils.Int32(int32(v.(int)))
+	if v, ok := policy["week_of_year"]; ok {
+		output.WeekOfYear = pointer.To(int64(v.(int)))
 	}
 
-	return &longTermPolicyProperties
+	return pointer.To(output)
 }
 
-func FlattenLongTermRetentionPolicy(longTermRetentionPolicy *sql.LongTermRetentionPolicy, d *pluginsdk.ResourceData) []interface{} {
-	if longTermRetentionPolicy == nil {
+func FlattenLongTermRetentionPolicy(input *longtermretentionpolicies.LongTermRetentionPolicy) []interface{} {
+	if input == nil {
 		return []interface{}{}
 	}
 
 	monthlyRetention := "PT0S"
-	if longTermRetentionPolicy.MonthlyRetention != nil {
-		monthlyRetention = *longTermRetentionPolicy.MonthlyRetention
+	if input.Properties.MonthlyRetention != nil {
+		monthlyRetention = pointer.From(input.Properties.MonthlyRetention)
 	}
 
 	weeklyRetention := "PT0S"
-	if longTermRetentionPolicy.WeeklyRetention != nil {
-		weeklyRetention = *longTermRetentionPolicy.WeeklyRetention
+	if input.Properties.WeeklyRetention != nil {
+		weeklyRetention = pointer.From(input.Properties.WeeklyRetention)
 	}
 
-	weekOfYear := int32(1)
-	if longTermRetentionPolicy.WeekOfYear != nil && *longTermRetentionPolicy.WeekOfYear != 0 {
-		weekOfYear = *longTermRetentionPolicy.WeekOfYear
+	weekOfYear := int64(1)
+	if input.Properties.WeekOfYear != nil && pointer.From(input.Properties.WeekOfYear) != 0 {
+		weekOfYear = pointer.From(input.Properties.WeekOfYear)
 	}
 
 	yearlyRetention := "PT0S"
-	if longTermRetentionPolicy.YearlyRetention != nil {
-		yearlyRetention = *longTermRetentionPolicy.YearlyRetention
+	if input.Properties.YearlyRetention != nil {
+		yearlyRetention = *input.Properties.YearlyRetention
 	}
 
 	return []interface{}{
@@ -166,45 +167,47 @@ func FlattenLongTermRetentionPolicy(longTermRetentionPolicy *sql.LongTermRetenti
 	}
 }
 
-func ExpandShortTermRetentionPolicy(input []interface{}) *sql.BackupShortTermRetentionPolicyProperties {
+func ExpandShortTermRetentionPolicy(input []interface{}) *backupshorttermretentionpolicies.BackupShortTermRetentionPolicyProperties {
 	if len(input) == 0 || input[0] == nil {
 		return nil
 	}
 
-	shortTermRetentionPolicy := input[0].(map[string]interface{})
+	policy := input[0].(map[string]interface{})
 
-	shortTermPolicyProperties := sql.BackupShortTermRetentionPolicyProperties{
-		RetentionDays: utils.Int32(7),
+	props := backupshorttermretentionpolicies.BackupShortTermRetentionPolicyProperties{
+		RetentionDays: pointer.To(int64(7)),
 	}
 
-	if v, ok := shortTermRetentionPolicy["retention_days"]; ok {
-		shortTermPolicyProperties.RetentionDays = utils.Int32(int32(v.(int)))
+	if v, ok := policy["retention_days"]; ok {
+		props.RetentionDays = pointer.To(int64(v.(int)))
 	}
 
-	if v, ok := shortTermRetentionPolicy["backup_interval_in_hours"]; ok {
-		shortTermPolicyProperties.DiffBackupIntervalInHours = utils.Int32(int32(v.(int)))
+	if v, ok := policy["backup_interval_in_hours"]; ok {
+		props.DiffBackupIntervalInHours = pointer.To(backupshorttermretentionpolicies.DiffBackupIntervalInHours(int64(v.(int))))
 	}
 
-	return &shortTermPolicyProperties
+	return &props
 }
 
-func FlattenShortTermRetentionPolicy(shortTermRetentionPolicy *sql.BackupShortTermRetentionPolicy, d *pluginsdk.ResourceData) []interface{} {
+func FlattenShortTermRetentionPolicy(input *backupshorttermretentionpolicies.BackupShortTermRetentionPolicy) []interface{} {
 	result := make([]interface{}, 0)
 
-	if shortTermRetentionPolicy == nil {
+	if input == nil {
 		return result
 	}
 
-	flattenShortTermRetentionPolicy := map[string]interface{}{}
+	output := map[string]interface{}{}
 
-	flattenShortTermRetentionPolicy["retention_days"] = int32(7)
-	if shortTermRetentionPolicy.RetentionDays != nil {
-		flattenShortTermRetentionPolicy["retention_days"] = *shortTermRetentionPolicy.RetentionDays
+	output["retention_days"] = int64(7)
+	if input.Properties.RetentionDays != nil {
+		output["retention_days"] = pointer.From(input.Properties.RetentionDays)
 	}
 
-	if shortTermRetentionPolicy.DiffBackupIntervalInHours != nil {
-		flattenShortTermRetentionPolicy["backup_interval_in_hours"] = *shortTermRetentionPolicy.DiffBackupIntervalInHours
+	if input.Properties.DiffBackupIntervalInHours != nil {
+		output["backup_interval_in_hours"] = pointer.From(input.Properties.DiffBackupIntervalInHours)
 	}
-	result = append(result, flattenShortTermRetentionPolicy)
+
+	result = append(result, output)
+
 	return result
 }

internal/services/mssql/mssql_database_data_source.go

@@ -7,14 +7,16 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/Azure/azure-sdk-for-go/services/preview/sql/mgmt/v5.0/sql" // nolint: staticcheck
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/tags"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/sql/2023-02-01-preview/databases"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/mssql/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/mssql/validate"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/tags"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
 )
 
 func dataSourceMsSqlDatabase() *pluginsdk.Resource {
@@ -83,7 +85,7 @@ func dataSourceMsSqlDatabase() *pluginsdk.Resource {
 				Computed: true,
 			},
 
-			"tags": tags.SchemaDataSource(),
+			"tags": commonschema.TagsDataSource(),
 		},
 	}
 }
@@ -95,41 +97,58 @@ func dataSourceMsSqlDatabaseRead(d *pluginsdk.ResourceData, meta interface{}) er
 
 	name := d.Get("name").(string)
 	mssqlServerId := d.Get("server_id").(string)
-	serverId, err := parse.ServerID(mssqlServerId)
+	serverId, err := commonids.ParseSqlServerID(mssqlServerId)
 	if err != nil {
 		return err
 	}
 
-	resp, err := client.Get(ctx, serverId.ResourceGroup, serverId.Name, name)
+	databaseId := commonids.NewSqlDatabaseID(serverId.SubscriptionId, serverId.ResourceGroupName, serverId.ServerName, name)
+
+	resp, err := client.Get(ctx, databaseId, databases.DefaultGetOperationOptions())
 	if err != nil {
-		if utils.ResponseWasNotFound(resp.Response) {
-			return fmt.Errorf("Database %q (Resource Group %q, SQL Server %q) was not found", name, serverId.ResourceGroup, serverId.Name)
+		if response.WasNotFound(resp.HttpResponse) {
+			return fmt.Errorf("%s was not found", databaseId)
 		}
 
-		return fmt.Errorf("making Read request on AzureRM Database %s (Resource Group %q, SQL Server %q): %+v", name, serverId.ResourceGroup, serverId.Name, err)
+		return fmt.Errorf("making Read request on AzureRM %s: %+v", databaseId, err)
 	}
 
-	d.SetId(parse.NewDatabaseID(serverId.SubscriptionId, serverId.ResourceGroup, serverId.Name, name).ID())
+	d.SetId(databaseId.ID())
 	d.Set("name", name)
 	d.Set("server_id", mssqlServerId)
 
-	if props := resp.DatabaseProperties; props != nil {
-		d.Set("collation", props.Collation)
-		d.Set("elastic_pool_id", props.ElasticPoolID)
-		d.Set("license_type", props.LicenseType)
-		if props.MaxSizeBytes != nil {
-			d.Set("max_size_gb", int32((*props.MaxSizeBytes)/int64(1073741824)))
+	if model := resp.Model; model != nil {
+		if props := model.Properties; props != nil {
+			d.Set("collation", props.Collation)
+			d.Set("elastic_pool_id", props.ElasticPoolId)
+			d.Set("license_type", string(pointer.From(props.LicenseType)))
+			d.Set("read_replica_count", props.HighAvailabilityReplicaCount)
+			d.Set("sku_name", props.CurrentServiceObjectiveName)
+			d.Set("zone_redundant", props.ZoneRedundant)
+
+			maxSizeGb := int64(0)
+			if props.MaxSizeBytes != nil {
+				maxSizeGb = (pointer.From(props.MaxSizeBytes)) / int64(1073741824)
+			}
+			d.Set("max_size_gb", maxSizeGb)
+
+			readScale := databases.DatabaseReadScaleDisabled
+			if props.ReadScale != nil {
+				readScale = pointer.From(props.ReadScale)
+			}
+			d.Set("read_scale", readScale == databases.DatabaseReadScaleEnabled)
+
+			storageAccountType := string(databases.BackupStorageRedundancyGeo)
+			if props.CurrentBackupStorageRedundancy != nil {
+				storageAccountType = string(pointer.From(props.CurrentBackupStorageRedundancy))
+			}
+			d.Set("storage_account_type", storageAccountType)
 		}
-		d.Set("read_replica_count", props.HighAvailabilityReplicaCount)
-		if props.ReadScale == sql.DatabaseReadScaleEnabled {
-			d.Set("read_scale", true)
-		} else if props.ReadScale == sql.DatabaseReadScaleDisabled {
-			d.Set("read_scale", false)
+
+		if err := tags.FlattenAndSet(d, model.Tags); err != nil {
+			return err
 		}
-		d.Set("sku_name", props.CurrentServiceObjectiveName)
-		d.Set("storage_account_type", sql.RequestedBackupStorageRedundancy(props.CurrentBackupStorageRedundancy))
-		d.Set("zone_redundant", props.ZoneRedundant)
 	}
 
-	return tags.FlattenAndSet(d, resp.Tags)
+	return nil
 }