1package sql 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// 6// Code generated by Microsoft (R) AutoRest Code Generator. 7// Changes may cause incorrect behavior and will be lost if the code is regenerated. 8 9import ( 10 "context" 11 "github.com/Azure/go-autorest/autorest" 12 "github.com/Azure/go-autorest/autorest/azure" 13 "github.com/Azure/go-autorest/autorest/validation" 14 "github.com/Azure/go-autorest/tracing" 15 "net/http" 16) 17 18// SyncGroupsClient is the the Azure SQL Database management API provides a RESTful set of web services that interact 19// with Azure SQL Database services to manage your databases. The API enables you to create, retrieve, update, and 20// delete databases. 21type SyncGroupsClient struct { 22 BaseClient 23} 24 25// NewSyncGroupsClient creates an instance of the SyncGroupsClient client. 26func NewSyncGroupsClient(subscriptionID string) SyncGroupsClient { 27 return NewSyncGroupsClientWithBaseURI(DefaultBaseURI, subscriptionID) 28} 29 30// NewSyncGroupsClientWithBaseURI creates an instance of the SyncGroupsClient client using a custom endpoint. Use this 31// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 32func NewSyncGroupsClientWithBaseURI(baseURI string, subscriptionID string) SyncGroupsClient { 33 return SyncGroupsClient{NewWithBaseURI(baseURI, subscriptionID)} 34} 35 36// CancelSync cancels a sync group synchronization. 37// Parameters: 38// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 39// from the Azure Resource Manager API or the portal. 40// serverName - the name of the server. 41// databaseName - the name of the database on which the sync group is hosted. 42// syncGroupName - the name of the sync group. 43func (client SyncGroupsClient) CancelSync(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result autorest.Response, err error) { 44 if tracing.IsEnabled() { 45 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.CancelSync") 46 defer func() { 47 sc := -1 48 if result.Response != nil { 49 sc = result.Response.StatusCode 50 } 51 tracing.EndSpan(ctx, sc, err) 52 }() 53 } 54 req, err := client.CancelSyncPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 55 if err != nil { 56 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CancelSync", nil, "Failure preparing request") 57 return 58 } 59 60 resp, err := client.CancelSyncSender(req) 61 if err != nil { 62 result.Response = resp 63 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CancelSync", resp, "Failure sending request") 64 return 65 } 66 67 result, err = client.CancelSyncResponder(resp) 68 if err != nil { 69 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CancelSync", resp, "Failure responding to request") 70 return 71 } 72 73 return 74} 75 76// CancelSyncPreparer prepares the CancelSync request. 77func (client SyncGroupsClient) CancelSyncPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 78 pathParameters := map[string]interface{}{ 79 "databaseName": autorest.Encode("path", databaseName), 80 "resourceGroupName": autorest.Encode("path", resourceGroupName), 81 "serverName": autorest.Encode("path", serverName), 82 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 83 "syncGroupName": autorest.Encode("path", syncGroupName), 84 } 85 86 const APIVersion = "2020-11-01-preview" 87 queryParameters := map[string]interface{}{ 88 "api-version": APIVersion, 89 } 90 91 preparer := autorest.CreatePreparer( 92 autorest.AsPost(), 93 autorest.WithBaseURL(client.BaseURI), 94 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/cancelSync", pathParameters), 95 autorest.WithQueryParameters(queryParameters)) 96 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 97} 98 99// CancelSyncSender sends the CancelSync request. The method will close the 100// http.Response Body if it receives an error. 101func (client SyncGroupsClient) CancelSyncSender(req *http.Request) (*http.Response, error) { 102 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 103} 104 105// CancelSyncResponder handles the response to the CancelSync request. The method always 106// closes the http.Response Body. 107func (client SyncGroupsClient) CancelSyncResponder(resp *http.Response) (result autorest.Response, err error) { 108 err = autorest.Respond( 109 resp, 110 azure.WithErrorUnlessStatusCode(http.StatusOK), 111 autorest.ByClosing()) 112 result.Response = resp 113 return 114} 115 116// CreateOrUpdate creates or updates a sync group. 117// Parameters: 118// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 119// from the Azure Resource Manager API or the portal. 120// serverName - the name of the server. 121// databaseName - the name of the database on which the sync group is hosted. 122// syncGroupName - the name of the sync group. 123// parameters - the requested sync group resource state. 124func (client SyncGroupsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, parameters SyncGroup) (result SyncGroupsCreateOrUpdateFuture, err error) { 125 if tracing.IsEnabled() { 126 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.CreateOrUpdate") 127 defer func() { 128 sc := -1 129 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 130 sc = result.FutureAPI.Response().StatusCode 131 } 132 tracing.EndSpan(ctx, sc, err) 133 }() 134 } 135 if err := validation.Validate([]validation.Validation{ 136 {TargetValue: parameters, 137 Constraints: []validation.Constraint{{Target: "parameters.Sku", Name: validation.Null, Rule: false, 138 Chain: []validation.Constraint{{Target: "parameters.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { 139 return result, validation.NewError("sql.SyncGroupsClient", "CreateOrUpdate", err.Error()) 140 } 141 142 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName, parameters) 143 if err != nil { 144 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CreateOrUpdate", nil, "Failure preparing request") 145 return 146 } 147 148 result, err = client.CreateOrUpdateSender(req) 149 if err != nil { 150 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CreateOrUpdate", nil, "Failure sending request") 151 return 152 } 153 154 return 155} 156 157// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 158func (client SyncGroupsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, parameters SyncGroup) (*http.Request, error) { 159 pathParameters := map[string]interface{}{ 160 "databaseName": autorest.Encode("path", databaseName), 161 "resourceGroupName": autorest.Encode("path", resourceGroupName), 162 "serverName": autorest.Encode("path", serverName), 163 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 164 "syncGroupName": autorest.Encode("path", syncGroupName), 165 } 166 167 const APIVersion = "2020-11-01-preview" 168 queryParameters := map[string]interface{}{ 169 "api-version": APIVersion, 170 } 171 172 preparer := autorest.CreatePreparer( 173 autorest.AsContentType("application/json; charset=utf-8"), 174 autorest.AsPut(), 175 autorest.WithBaseURL(client.BaseURI), 176 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}", pathParameters), 177 autorest.WithJSON(parameters), 178 autorest.WithQueryParameters(queryParameters)) 179 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 180} 181 182// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 183// http.Response Body if it receives an error. 184func (client SyncGroupsClient) CreateOrUpdateSender(req *http.Request) (future SyncGroupsCreateOrUpdateFuture, err error) { 185 var resp *http.Response 186 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 187 if err != nil { 188 return 189 } 190 var azf azure.Future 191 azf, err = azure.NewFutureFromResponse(resp) 192 future.FutureAPI = &azf 193 future.Result = future.result 194 return 195} 196 197// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 198// closes the http.Response Body. 199func (client SyncGroupsClient) CreateOrUpdateResponder(resp *http.Response) (result SyncGroup, err error) { 200 err = autorest.Respond( 201 resp, 202 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted), 203 autorest.ByUnmarshallingJSON(&result), 204 autorest.ByClosing()) 205 result.Response = autorest.Response{Response: resp} 206 return 207} 208 209// Delete deletes a sync group. 210// Parameters: 211// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 212// from the Azure Resource Manager API or the portal. 213// serverName - the name of the server. 214// databaseName - the name of the database on which the sync group is hosted. 215// syncGroupName - the name of the sync group. 216func (client SyncGroupsClient) Delete(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncGroupsDeleteFuture, err error) { 217 if tracing.IsEnabled() { 218 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.Delete") 219 defer func() { 220 sc := -1 221 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 222 sc = result.FutureAPI.Response().StatusCode 223 } 224 tracing.EndSpan(ctx, sc, err) 225 }() 226 } 227 req, err := client.DeletePreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 228 if err != nil { 229 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Delete", nil, "Failure preparing request") 230 return 231 } 232 233 result, err = client.DeleteSender(req) 234 if err != nil { 235 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Delete", nil, "Failure sending request") 236 return 237 } 238 239 return 240} 241 242// DeletePreparer prepares the Delete request. 243func (client SyncGroupsClient) DeletePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 244 pathParameters := map[string]interface{}{ 245 "databaseName": autorest.Encode("path", databaseName), 246 "resourceGroupName": autorest.Encode("path", resourceGroupName), 247 "serverName": autorest.Encode("path", serverName), 248 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 249 "syncGroupName": autorest.Encode("path", syncGroupName), 250 } 251 252 const APIVersion = "2020-11-01-preview" 253 queryParameters := map[string]interface{}{ 254 "api-version": APIVersion, 255 } 256 257 preparer := autorest.CreatePreparer( 258 autorest.AsDelete(), 259 autorest.WithBaseURL(client.BaseURI), 260 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}", pathParameters), 261 autorest.WithQueryParameters(queryParameters)) 262 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 263} 264 265// DeleteSender sends the Delete request. The method will close the 266// http.Response Body if it receives an error. 267func (client SyncGroupsClient) DeleteSender(req *http.Request) (future SyncGroupsDeleteFuture, err error) { 268 var resp *http.Response 269 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 270 if err != nil { 271 return 272 } 273 var azf azure.Future 274 azf, err = azure.NewFutureFromResponse(resp) 275 future.FutureAPI = &azf 276 future.Result = future.result 277 return 278} 279 280// DeleteResponder handles the response to the Delete request. The method always 281// closes the http.Response Body. 282func (client SyncGroupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 283 err = autorest.Respond( 284 resp, 285 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 286 autorest.ByClosing()) 287 result.Response = resp 288 return 289} 290 291// Get gets a sync group. 292// Parameters: 293// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 294// from the Azure Resource Manager API or the portal. 295// serverName - the name of the server. 296// databaseName - the name of the database on which the sync group is hosted. 297// syncGroupName - the name of the sync group. 298func (client SyncGroupsClient) Get(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncGroup, err error) { 299 if tracing.IsEnabled() { 300 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.Get") 301 defer func() { 302 sc := -1 303 if result.Response.Response != nil { 304 sc = result.Response.Response.StatusCode 305 } 306 tracing.EndSpan(ctx, sc, err) 307 }() 308 } 309 req, err := client.GetPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 310 if err != nil { 311 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Get", nil, "Failure preparing request") 312 return 313 } 314 315 resp, err := client.GetSender(req) 316 if err != nil { 317 result.Response = autorest.Response{Response: resp} 318 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Get", resp, "Failure sending request") 319 return 320 } 321 322 result, err = client.GetResponder(resp) 323 if err != nil { 324 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Get", resp, "Failure responding to request") 325 return 326 } 327 328 return 329} 330 331// GetPreparer prepares the Get request. 332func (client SyncGroupsClient) GetPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 333 pathParameters := map[string]interface{}{ 334 "databaseName": autorest.Encode("path", databaseName), 335 "resourceGroupName": autorest.Encode("path", resourceGroupName), 336 "serverName": autorest.Encode("path", serverName), 337 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 338 "syncGroupName": autorest.Encode("path", syncGroupName), 339 } 340 341 const APIVersion = "2020-11-01-preview" 342 queryParameters := map[string]interface{}{ 343 "api-version": APIVersion, 344 } 345 346 preparer := autorest.CreatePreparer( 347 autorest.AsGet(), 348 autorest.WithBaseURL(client.BaseURI), 349 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}", pathParameters), 350 autorest.WithQueryParameters(queryParameters)) 351 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 352} 353 354// GetSender sends the Get request. The method will close the 355// http.Response Body if it receives an error. 356func (client SyncGroupsClient) GetSender(req *http.Request) (*http.Response, error) { 357 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 358} 359 360// GetResponder handles the response to the Get request. The method always 361// closes the http.Response Body. 362func (client SyncGroupsClient) GetResponder(resp *http.Response) (result SyncGroup, err error) { 363 err = autorest.Respond( 364 resp, 365 azure.WithErrorUnlessStatusCode(http.StatusOK), 366 autorest.ByUnmarshallingJSON(&result), 367 autorest.ByClosing()) 368 result.Response = autorest.Response{Response: resp} 369 return 370} 371 372// ListByDatabase lists sync groups under a hub database. 373// Parameters: 374// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 375// from the Azure Resource Manager API or the portal. 376// serverName - the name of the server. 377// databaseName - the name of the database on which the sync group is hosted. 378func (client SyncGroupsClient) ListByDatabase(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (result SyncGroupListResultPage, err error) { 379 if tracing.IsEnabled() { 380 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListByDatabase") 381 defer func() { 382 sc := -1 383 if result.sglr.Response.Response != nil { 384 sc = result.sglr.Response.Response.StatusCode 385 } 386 tracing.EndSpan(ctx, sc, err) 387 }() 388 } 389 result.fn = client.listByDatabaseNextResults 390 req, err := client.ListByDatabasePreparer(ctx, resourceGroupName, serverName, databaseName) 391 if err != nil { 392 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListByDatabase", nil, "Failure preparing request") 393 return 394 } 395 396 resp, err := client.ListByDatabaseSender(req) 397 if err != nil { 398 result.sglr.Response = autorest.Response{Response: resp} 399 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListByDatabase", resp, "Failure sending request") 400 return 401 } 402 403 result.sglr, err = client.ListByDatabaseResponder(resp) 404 if err != nil { 405 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListByDatabase", resp, "Failure responding to request") 406 return 407 } 408 if result.sglr.hasNextLink() && result.sglr.IsEmpty() { 409 err = result.NextWithContext(ctx) 410 return 411 } 412 413 return 414} 415 416// ListByDatabasePreparer prepares the ListByDatabase request. 417func (client SyncGroupsClient) ListByDatabasePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (*http.Request, error) { 418 pathParameters := map[string]interface{}{ 419 "databaseName": autorest.Encode("path", databaseName), 420 "resourceGroupName": autorest.Encode("path", resourceGroupName), 421 "serverName": autorest.Encode("path", serverName), 422 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 423 } 424 425 const APIVersion = "2020-11-01-preview" 426 queryParameters := map[string]interface{}{ 427 "api-version": APIVersion, 428 } 429 430 preparer := autorest.CreatePreparer( 431 autorest.AsGet(), 432 autorest.WithBaseURL(client.BaseURI), 433 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups", pathParameters), 434 autorest.WithQueryParameters(queryParameters)) 435 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 436} 437 438// ListByDatabaseSender sends the ListByDatabase request. The method will close the 439// http.Response Body if it receives an error. 440func (client SyncGroupsClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { 441 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 442} 443 444// ListByDatabaseResponder handles the response to the ListByDatabase request. The method always 445// closes the http.Response Body. 446func (client SyncGroupsClient) ListByDatabaseResponder(resp *http.Response) (result SyncGroupListResult, err error) { 447 err = autorest.Respond( 448 resp, 449 azure.WithErrorUnlessStatusCode(http.StatusOK), 450 autorest.ByUnmarshallingJSON(&result), 451 autorest.ByClosing()) 452 result.Response = autorest.Response{Response: resp} 453 return 454} 455 456// listByDatabaseNextResults retrieves the next set of results, if any. 457func (client SyncGroupsClient) listByDatabaseNextResults(ctx context.Context, lastResults SyncGroupListResult) (result SyncGroupListResult, err error) { 458 req, err := lastResults.syncGroupListResultPreparer(ctx) 459 if err != nil { 460 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listByDatabaseNextResults", nil, "Failure preparing next results request") 461 } 462 if req == nil { 463 return 464 } 465 resp, err := client.ListByDatabaseSender(req) 466 if err != nil { 467 result.Response = autorest.Response{Response: resp} 468 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listByDatabaseNextResults", resp, "Failure sending next results request") 469 } 470 result, err = client.ListByDatabaseResponder(resp) 471 if err != nil { 472 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listByDatabaseNextResults", resp, "Failure responding to next results request") 473 } 474 return 475} 476 477// ListByDatabaseComplete enumerates all values, automatically crossing page boundaries as required. 478func (client SyncGroupsClient) ListByDatabaseComplete(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (result SyncGroupListResultIterator, err error) { 479 if tracing.IsEnabled() { 480 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListByDatabase") 481 defer func() { 482 sc := -1 483 if result.Response().Response.Response != nil { 484 sc = result.page.Response().Response.Response.StatusCode 485 } 486 tracing.EndSpan(ctx, sc, err) 487 }() 488 } 489 result.page, err = client.ListByDatabase(ctx, resourceGroupName, serverName, databaseName) 490 return 491} 492 493// ListHubSchemas gets a collection of hub database schemas. 494// Parameters: 495// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 496// from the Azure Resource Manager API or the portal. 497// serverName - the name of the server. 498// databaseName - the name of the database on which the sync group is hosted. 499// syncGroupName - the name of the sync group. 500func (client SyncGroupsClient) ListHubSchemas(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncFullSchemaPropertiesListResultPage, err error) { 501 if tracing.IsEnabled() { 502 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListHubSchemas") 503 defer func() { 504 sc := -1 505 if result.sfsplr.Response.Response != nil { 506 sc = result.sfsplr.Response.Response.StatusCode 507 } 508 tracing.EndSpan(ctx, sc, err) 509 }() 510 } 511 result.fn = client.listHubSchemasNextResults 512 req, err := client.ListHubSchemasPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 513 if err != nil { 514 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListHubSchemas", nil, "Failure preparing request") 515 return 516 } 517 518 resp, err := client.ListHubSchemasSender(req) 519 if err != nil { 520 result.sfsplr.Response = autorest.Response{Response: resp} 521 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListHubSchemas", resp, "Failure sending request") 522 return 523 } 524 525 result.sfsplr, err = client.ListHubSchemasResponder(resp) 526 if err != nil { 527 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListHubSchemas", resp, "Failure responding to request") 528 return 529 } 530 if result.sfsplr.hasNextLink() && result.sfsplr.IsEmpty() { 531 err = result.NextWithContext(ctx) 532 return 533 } 534 535 return 536} 537 538// ListHubSchemasPreparer prepares the ListHubSchemas request. 539func (client SyncGroupsClient) ListHubSchemasPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 540 pathParameters := map[string]interface{}{ 541 "databaseName": autorest.Encode("path", databaseName), 542 "resourceGroupName": autorest.Encode("path", resourceGroupName), 543 "serverName": autorest.Encode("path", serverName), 544 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 545 "syncGroupName": autorest.Encode("path", syncGroupName), 546 } 547 548 const APIVersion = "2020-11-01-preview" 549 queryParameters := map[string]interface{}{ 550 "api-version": APIVersion, 551 } 552 553 preparer := autorest.CreatePreparer( 554 autorest.AsGet(), 555 autorest.WithBaseURL(client.BaseURI), 556 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/hubSchemas", pathParameters), 557 autorest.WithQueryParameters(queryParameters)) 558 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 559} 560 561// ListHubSchemasSender sends the ListHubSchemas request. The method will close the 562// http.Response Body if it receives an error. 563func (client SyncGroupsClient) ListHubSchemasSender(req *http.Request) (*http.Response, error) { 564 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 565} 566 567// ListHubSchemasResponder handles the response to the ListHubSchemas request. The method always 568// closes the http.Response Body. 569func (client SyncGroupsClient) ListHubSchemasResponder(resp *http.Response) (result SyncFullSchemaPropertiesListResult, err error) { 570 err = autorest.Respond( 571 resp, 572 azure.WithErrorUnlessStatusCode(http.StatusOK), 573 autorest.ByUnmarshallingJSON(&result), 574 autorest.ByClosing()) 575 result.Response = autorest.Response{Response: resp} 576 return 577} 578 579// listHubSchemasNextResults retrieves the next set of results, if any. 580func (client SyncGroupsClient) listHubSchemasNextResults(ctx context.Context, lastResults SyncFullSchemaPropertiesListResult) (result SyncFullSchemaPropertiesListResult, err error) { 581 req, err := lastResults.syncFullSchemaPropertiesListResultPreparer(ctx) 582 if err != nil { 583 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listHubSchemasNextResults", nil, "Failure preparing next results request") 584 } 585 if req == nil { 586 return 587 } 588 resp, err := client.ListHubSchemasSender(req) 589 if err != nil { 590 result.Response = autorest.Response{Response: resp} 591 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listHubSchemasNextResults", resp, "Failure sending next results request") 592 } 593 result, err = client.ListHubSchemasResponder(resp) 594 if err != nil { 595 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listHubSchemasNextResults", resp, "Failure responding to next results request") 596 } 597 return 598} 599 600// ListHubSchemasComplete enumerates all values, automatically crossing page boundaries as required. 601func (client SyncGroupsClient) ListHubSchemasComplete(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncFullSchemaPropertiesListResultIterator, err error) { 602 if tracing.IsEnabled() { 603 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListHubSchemas") 604 defer func() { 605 sc := -1 606 if result.Response().Response.Response != nil { 607 sc = result.page.Response().Response.Response.StatusCode 608 } 609 tracing.EndSpan(ctx, sc, err) 610 }() 611 } 612 result.page, err = client.ListHubSchemas(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 613 return 614} 615 616// ListLogs gets a collection of sync group logs. 617// Parameters: 618// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 619// from the Azure Resource Manager API or the portal. 620// serverName - the name of the server. 621// databaseName - the name of the database on which the sync group is hosted. 622// syncGroupName - the name of the sync group. 623// startTime - get logs generated after this time. 624// endTime - get logs generated before this time. 625// typeParameter - the types of logs to retrieve. 626// continuationToken - the continuation token for this operation. 627func (client SyncGroupsClient) ListLogs(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, startTime string, endTime string, typeParameter string, continuationToken string) (result SyncGroupLogListResultPage, err error) { 628 if tracing.IsEnabled() { 629 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListLogs") 630 defer func() { 631 sc := -1 632 if result.sgllr.Response.Response != nil { 633 sc = result.sgllr.Response.Response.StatusCode 634 } 635 tracing.EndSpan(ctx, sc, err) 636 }() 637 } 638 result.fn = client.listLogsNextResults 639 req, err := client.ListLogsPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName, startTime, endTime, typeParameter, continuationToken) 640 if err != nil { 641 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListLogs", nil, "Failure preparing request") 642 return 643 } 644 645 resp, err := client.ListLogsSender(req) 646 if err != nil { 647 result.sgllr.Response = autorest.Response{Response: resp} 648 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListLogs", resp, "Failure sending request") 649 return 650 } 651 652 result.sgllr, err = client.ListLogsResponder(resp) 653 if err != nil { 654 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListLogs", resp, "Failure responding to request") 655 return 656 } 657 if result.sgllr.hasNextLink() && result.sgllr.IsEmpty() { 658 err = result.NextWithContext(ctx) 659 return 660 } 661 662 return 663} 664 665// ListLogsPreparer prepares the ListLogs request. 666func (client SyncGroupsClient) ListLogsPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, startTime string, endTime string, typeParameter string, continuationToken string) (*http.Request, error) { 667 pathParameters := map[string]interface{}{ 668 "databaseName": autorest.Encode("path", databaseName), 669 "resourceGroupName": autorest.Encode("path", resourceGroupName), 670 "serverName": autorest.Encode("path", serverName), 671 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 672 "syncGroupName": autorest.Encode("path", syncGroupName), 673 } 674 675 const APIVersion = "2020-11-01-preview" 676 queryParameters := map[string]interface{}{ 677 "api-version": APIVersion, 678 "endTime": autorest.Encode("query", endTime), 679 "startTime": autorest.Encode("query", startTime), 680 "type": autorest.Encode("query", typeParameter), 681 } 682 if len(continuationToken) > 0 { 683 queryParameters["continuationToken"] = autorest.Encode("query", continuationToken) 684 } 685 686 preparer := autorest.CreatePreparer( 687 autorest.AsGet(), 688 autorest.WithBaseURL(client.BaseURI), 689 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/logs", pathParameters), 690 autorest.WithQueryParameters(queryParameters)) 691 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 692} 693 694// ListLogsSender sends the ListLogs request. The method will close the 695// http.Response Body if it receives an error. 696func (client SyncGroupsClient) ListLogsSender(req *http.Request) (*http.Response, error) { 697 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 698} 699 700// ListLogsResponder handles the response to the ListLogs request. The method always 701// closes the http.Response Body. 702func (client SyncGroupsClient) ListLogsResponder(resp *http.Response) (result SyncGroupLogListResult, err error) { 703 err = autorest.Respond( 704 resp, 705 azure.WithErrorUnlessStatusCode(http.StatusOK), 706 autorest.ByUnmarshallingJSON(&result), 707 autorest.ByClosing()) 708 result.Response = autorest.Response{Response: resp} 709 return 710} 711 712// listLogsNextResults retrieves the next set of results, if any. 713func (client SyncGroupsClient) listLogsNextResults(ctx context.Context, lastResults SyncGroupLogListResult) (result SyncGroupLogListResult, err error) { 714 req, err := lastResults.syncGroupLogListResultPreparer(ctx) 715 if err != nil { 716 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listLogsNextResults", nil, "Failure preparing next results request") 717 } 718 if req == nil { 719 return 720 } 721 resp, err := client.ListLogsSender(req) 722 if err != nil { 723 result.Response = autorest.Response{Response: resp} 724 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listLogsNextResults", resp, "Failure sending next results request") 725 } 726 result, err = client.ListLogsResponder(resp) 727 if err != nil { 728 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listLogsNextResults", resp, "Failure responding to next results request") 729 } 730 return 731} 732 733// ListLogsComplete enumerates all values, automatically crossing page boundaries as required. 734func (client SyncGroupsClient) ListLogsComplete(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, startTime string, endTime string, typeParameter string, continuationToken string) (result SyncGroupLogListResultIterator, err error) { 735 if tracing.IsEnabled() { 736 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListLogs") 737 defer func() { 738 sc := -1 739 if result.Response().Response.Response != nil { 740 sc = result.page.Response().Response.Response.StatusCode 741 } 742 tracing.EndSpan(ctx, sc, err) 743 }() 744 } 745 result.page, err = client.ListLogs(ctx, resourceGroupName, serverName, databaseName, syncGroupName, startTime, endTime, typeParameter, continuationToken) 746 return 747} 748 749// ListSyncDatabaseIds gets a collection of sync database ids. 750// Parameters: 751// locationName - the name of the region where the resource is located. 752func (client SyncGroupsClient) ListSyncDatabaseIds(ctx context.Context, locationName string) (result SyncDatabaseIDListResultPage, err error) { 753 if tracing.IsEnabled() { 754 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListSyncDatabaseIds") 755 defer func() { 756 sc := -1 757 if result.sdilr.Response.Response != nil { 758 sc = result.sdilr.Response.Response.StatusCode 759 } 760 tracing.EndSpan(ctx, sc, err) 761 }() 762 } 763 result.fn = client.listSyncDatabaseIdsNextResults 764 req, err := client.ListSyncDatabaseIdsPreparer(ctx, locationName) 765 if err != nil { 766 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListSyncDatabaseIds", nil, "Failure preparing request") 767 return 768 } 769 770 resp, err := client.ListSyncDatabaseIdsSender(req) 771 if err != nil { 772 result.sdilr.Response = autorest.Response{Response: resp} 773 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListSyncDatabaseIds", resp, "Failure sending request") 774 return 775 } 776 777 result.sdilr, err = client.ListSyncDatabaseIdsResponder(resp) 778 if err != nil { 779 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListSyncDatabaseIds", resp, "Failure responding to request") 780 return 781 } 782 if result.sdilr.hasNextLink() && result.sdilr.IsEmpty() { 783 err = result.NextWithContext(ctx) 784 return 785 } 786 787 return 788} 789 790// ListSyncDatabaseIdsPreparer prepares the ListSyncDatabaseIds request. 791func (client SyncGroupsClient) ListSyncDatabaseIdsPreparer(ctx context.Context, locationName string) (*http.Request, error) { 792 pathParameters := map[string]interface{}{ 793 "locationName": autorest.Encode("path", locationName), 794 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 795 } 796 797 const APIVersion = "2020-11-01-preview" 798 queryParameters := map[string]interface{}{ 799 "api-version": APIVersion, 800 } 801 802 preparer := autorest.CreatePreparer( 803 autorest.AsGet(), 804 autorest.WithBaseURL(client.BaseURI), 805 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Sql/locations/{locationName}/syncDatabaseIds", pathParameters), 806 autorest.WithQueryParameters(queryParameters)) 807 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 808} 809 810// ListSyncDatabaseIdsSender sends the ListSyncDatabaseIds request. The method will close the 811// http.Response Body if it receives an error. 812func (client SyncGroupsClient) ListSyncDatabaseIdsSender(req *http.Request) (*http.Response, error) { 813 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 814} 815 816// ListSyncDatabaseIdsResponder handles the response to the ListSyncDatabaseIds request. The method always 817// closes the http.Response Body. 818func (client SyncGroupsClient) ListSyncDatabaseIdsResponder(resp *http.Response) (result SyncDatabaseIDListResult, err error) { 819 err = autorest.Respond( 820 resp, 821 azure.WithErrorUnlessStatusCode(http.StatusOK), 822 autorest.ByUnmarshallingJSON(&result), 823 autorest.ByClosing()) 824 result.Response = autorest.Response{Response: resp} 825 return 826} 827 828// listSyncDatabaseIdsNextResults retrieves the next set of results, if any. 829func (client SyncGroupsClient) listSyncDatabaseIdsNextResults(ctx context.Context, lastResults SyncDatabaseIDListResult) (result SyncDatabaseIDListResult, err error) { 830 req, err := lastResults.syncDatabaseIDListResultPreparer(ctx) 831 if err != nil { 832 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listSyncDatabaseIdsNextResults", nil, "Failure preparing next results request") 833 } 834 if req == nil { 835 return 836 } 837 resp, err := client.ListSyncDatabaseIdsSender(req) 838 if err != nil { 839 result.Response = autorest.Response{Response: resp} 840 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listSyncDatabaseIdsNextResults", resp, "Failure sending next results request") 841 } 842 result, err = client.ListSyncDatabaseIdsResponder(resp) 843 if err != nil { 844 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listSyncDatabaseIdsNextResults", resp, "Failure responding to next results request") 845 } 846 return 847} 848 849// ListSyncDatabaseIdsComplete enumerates all values, automatically crossing page boundaries as required. 850func (client SyncGroupsClient) ListSyncDatabaseIdsComplete(ctx context.Context, locationName string) (result SyncDatabaseIDListResultIterator, err error) { 851 if tracing.IsEnabled() { 852 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListSyncDatabaseIds") 853 defer func() { 854 sc := -1 855 if result.Response().Response.Response != nil { 856 sc = result.page.Response().Response.Response.StatusCode 857 } 858 tracing.EndSpan(ctx, sc, err) 859 }() 860 } 861 result.page, err = client.ListSyncDatabaseIds(ctx, locationName) 862 return 863} 864 865// RefreshHubSchema refreshes a hub database schema. 866// Parameters: 867// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 868// from the Azure Resource Manager API or the portal. 869// serverName - the name of the server. 870// databaseName - the name of the database on which the sync group is hosted. 871// syncGroupName - the name of the sync group. 872func (client SyncGroupsClient) RefreshHubSchema(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncGroupsRefreshHubSchemaFuture, err error) { 873 if tracing.IsEnabled() { 874 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.RefreshHubSchema") 875 defer func() { 876 sc := -1 877 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 878 sc = result.FutureAPI.Response().StatusCode 879 } 880 tracing.EndSpan(ctx, sc, err) 881 }() 882 } 883 req, err := client.RefreshHubSchemaPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 884 if err != nil { 885 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "RefreshHubSchema", nil, "Failure preparing request") 886 return 887 } 888 889 result, err = client.RefreshHubSchemaSender(req) 890 if err != nil { 891 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "RefreshHubSchema", nil, "Failure sending request") 892 return 893 } 894 895 return 896} 897 898// RefreshHubSchemaPreparer prepares the RefreshHubSchema request. 899func (client SyncGroupsClient) RefreshHubSchemaPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 900 pathParameters := map[string]interface{}{ 901 "databaseName": autorest.Encode("path", databaseName), 902 "resourceGroupName": autorest.Encode("path", resourceGroupName), 903 "serverName": autorest.Encode("path", serverName), 904 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 905 "syncGroupName": autorest.Encode("path", syncGroupName), 906 } 907 908 const APIVersion = "2020-11-01-preview" 909 queryParameters := map[string]interface{}{ 910 "api-version": APIVersion, 911 } 912 913 preparer := autorest.CreatePreparer( 914 autorest.AsPost(), 915 autorest.WithBaseURL(client.BaseURI), 916 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/refreshHubSchema", pathParameters), 917 autorest.WithQueryParameters(queryParameters)) 918 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 919} 920 921// RefreshHubSchemaSender sends the RefreshHubSchema request. The method will close the 922// http.Response Body if it receives an error. 923func (client SyncGroupsClient) RefreshHubSchemaSender(req *http.Request) (future SyncGroupsRefreshHubSchemaFuture, err error) { 924 var resp *http.Response 925 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 926 if err != nil { 927 return 928 } 929 var azf azure.Future 930 azf, err = azure.NewFutureFromResponse(resp) 931 future.FutureAPI = &azf 932 future.Result = future.result 933 return 934} 935 936// RefreshHubSchemaResponder handles the response to the RefreshHubSchema request. The method always 937// closes the http.Response Body. 938func (client SyncGroupsClient) RefreshHubSchemaResponder(resp *http.Response) (result autorest.Response, err error) { 939 err = autorest.Respond( 940 resp, 941 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 942 autorest.ByClosing()) 943 result.Response = resp 944 return 945} 946 947// TriggerSync triggers a sync group synchronization. 948// Parameters: 949// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 950// from the Azure Resource Manager API or the portal. 951// serverName - the name of the server. 952// databaseName - the name of the database on which the sync group is hosted. 953// syncGroupName - the name of the sync group. 954func (client SyncGroupsClient) TriggerSync(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result autorest.Response, err error) { 955 if tracing.IsEnabled() { 956 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.TriggerSync") 957 defer func() { 958 sc := -1 959 if result.Response != nil { 960 sc = result.Response.StatusCode 961 } 962 tracing.EndSpan(ctx, sc, err) 963 }() 964 } 965 req, err := client.TriggerSyncPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 966 if err != nil { 967 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "TriggerSync", nil, "Failure preparing request") 968 return 969 } 970 971 resp, err := client.TriggerSyncSender(req) 972 if err != nil { 973 result.Response = resp 974 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "TriggerSync", resp, "Failure sending request") 975 return 976 } 977 978 result, err = client.TriggerSyncResponder(resp) 979 if err != nil { 980 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "TriggerSync", resp, "Failure responding to request") 981 return 982 } 983 984 return 985} 986 987// TriggerSyncPreparer prepares the TriggerSync request. 988func (client SyncGroupsClient) TriggerSyncPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 989 pathParameters := map[string]interface{}{ 990 "databaseName": autorest.Encode("path", databaseName), 991 "resourceGroupName": autorest.Encode("path", resourceGroupName), 992 "serverName": autorest.Encode("path", serverName), 993 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 994 "syncGroupName": autorest.Encode("path", syncGroupName), 995 } 996 997 const APIVersion = "2020-11-01-preview" 998 queryParameters := map[string]interface{}{ 999 "api-version": APIVersion, 1000 } 1001 1002 preparer := autorest.CreatePreparer( 1003 autorest.AsPost(), 1004 autorest.WithBaseURL(client.BaseURI), 1005 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/triggerSync", pathParameters), 1006 autorest.WithQueryParameters(queryParameters)) 1007 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1008} 1009 1010// TriggerSyncSender sends the TriggerSync request. The method will close the 1011// http.Response Body if it receives an error. 1012func (client SyncGroupsClient) TriggerSyncSender(req *http.Request) (*http.Response, error) { 1013 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1014} 1015 1016// TriggerSyncResponder handles the response to the TriggerSync request. The method always 1017// closes the http.Response Body. 1018func (client SyncGroupsClient) TriggerSyncResponder(resp *http.Response) (result autorest.Response, err error) { 1019 err = autorest.Respond( 1020 resp, 1021 azure.WithErrorUnlessStatusCode(http.StatusOK), 1022 autorest.ByClosing()) 1023 result.Response = resp 1024 return 1025} 1026 1027// Update updates a sync group. 1028// Parameters: 1029// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 1030// from the Azure Resource Manager API or the portal. 1031// serverName - the name of the server. 1032// databaseName - the name of the database on which the sync group is hosted. 1033// syncGroupName - the name of the sync group. 1034// parameters - the requested sync group resource state. 1035func (client SyncGroupsClient) Update(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, parameters SyncGroup) (result SyncGroupsUpdateFuture, err error) { 1036 if tracing.IsEnabled() { 1037 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.Update") 1038 defer func() { 1039 sc := -1 1040 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1041 sc = result.FutureAPI.Response().StatusCode 1042 } 1043 tracing.EndSpan(ctx, sc, err) 1044 }() 1045 } 1046 req, err := client.UpdatePreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName, parameters) 1047 if err != nil { 1048 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Update", nil, "Failure preparing request") 1049 return 1050 } 1051 1052 result, err = client.UpdateSender(req) 1053 if err != nil { 1054 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Update", nil, "Failure sending request") 1055 return 1056 } 1057 1058 return 1059} 1060 1061// UpdatePreparer prepares the Update request. 1062func (client SyncGroupsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, parameters SyncGroup) (*http.Request, error) { 1063 pathParameters := map[string]interface{}{ 1064 "databaseName": autorest.Encode("path", databaseName), 1065 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1066 "serverName": autorest.Encode("path", serverName), 1067 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1068 "syncGroupName": autorest.Encode("path", syncGroupName), 1069 } 1070 1071 const APIVersion = "2020-11-01-preview" 1072 queryParameters := map[string]interface{}{ 1073 "api-version": APIVersion, 1074 } 1075 1076 preparer := autorest.CreatePreparer( 1077 autorest.AsContentType("application/json; charset=utf-8"), 1078 autorest.AsPatch(), 1079 autorest.WithBaseURL(client.BaseURI), 1080 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}", pathParameters), 1081 autorest.WithJSON(parameters), 1082 autorest.WithQueryParameters(queryParameters)) 1083 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1084} 1085 1086// UpdateSender sends the Update request. The method will close the 1087// http.Response Body if it receives an error. 1088func (client SyncGroupsClient) UpdateSender(req *http.Request) (future SyncGroupsUpdateFuture, err error) { 1089 var resp *http.Response 1090 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1091 if err != nil { 1092 return 1093 } 1094 var azf azure.Future 1095 azf, err = azure.NewFutureFromResponse(resp) 1096 future.FutureAPI = &azf 1097 future.Result = future.result 1098 return 1099} 1100 1101// UpdateResponder handles the response to the Update request. The method always 1102// closes the http.Response Body. 1103func (client SyncGroupsClient) UpdateResponder(resp *http.Response) (result SyncGroup, err error) { 1104 err = autorest.Respond( 1105 resp, 1106 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1107 autorest.ByUnmarshallingJSON(&result), 1108 autorest.ByClosing()) 1109 result.Response = autorest.Response{Response: resp} 1110 return 1111} 1112