1package documentdb 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// SQLResourcesClient is the azure Cosmos DB Database Service Resource Provider REST API 19type SQLResourcesClient struct { 20 BaseClient 21} 22 23// NewSQLResourcesClient creates an instance of the SQLResourcesClient client. 24func NewSQLResourcesClient(subscriptionID string) SQLResourcesClient { 25 return NewSQLResourcesClientWithBaseURI(DefaultBaseURI, subscriptionID) 26} 27 28// NewSQLResourcesClientWithBaseURI creates an instance of the SQLResourcesClient client using a custom endpoint. Use 29// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 30func NewSQLResourcesClientWithBaseURI(baseURI string, subscriptionID string) SQLResourcesClient { 31 return SQLResourcesClient{NewWithBaseURI(baseURI, subscriptionID)} 32} 33 34// CreateUpdateSQLContainer create or update an Azure Cosmos DB SQL container 35// Parameters: 36// resourceGroupName - the name of the resource group. The name is case insensitive. 37// accountName - cosmos DB database account name. 38// databaseName - cosmos DB database name. 39// containerName - cosmos DB container name. 40// createUpdateSQLContainerParameters - the parameters to provide for the current SQL container. 41func (client SQLResourcesClient) CreateUpdateSQLContainer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, createUpdateSQLContainerParameters SQLContainerCreateUpdateParameters) (result SQLResourcesCreateUpdateSQLContainerFuture, err error) { 42 if tracing.IsEnabled() { 43 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.CreateUpdateSQLContainer") 44 defer func() { 45 sc := -1 46 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 47 sc = result.FutureAPI.Response().StatusCode 48 } 49 tracing.EndSpan(ctx, sc, err) 50 }() 51 } 52 if err := validation.Validate([]validation.Validation{ 53 {TargetValue: client.SubscriptionID, 54 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 55 {TargetValue: resourceGroupName, 56 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 57 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 58 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 59 {TargetValue: accountName, 60 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 61 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 62 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}, 63 {TargetValue: createUpdateSQLContainerParameters, 64 Constraints: []validation.Constraint{{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties", Name: validation.Null, Rule: true, 65 Chain: []validation.Constraint{{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Resource", Name: validation.Null, Rule: true, 66 Chain: []validation.Constraint{{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}, 67 {Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Resource.PartitionKey", Name: validation.Null, Rule: false, 68 Chain: []validation.Constraint{{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Resource.PartitionKey.Version", Name: validation.Null, Rule: false, 69 Chain: []validation.Constraint{{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Resource.PartitionKey.Version", Name: validation.InclusiveMaximum, Rule: int64(2), Chain: nil}, 70 {Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Resource.PartitionKey.Version", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}, 71 }}, 72 }}, 73 }}, 74 {Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil}, 75 }}}}}); err != nil { 76 return result, validation.NewError("documentdb.SQLResourcesClient", "CreateUpdateSQLContainer", err.Error()) 77 } 78 79 req, err := client.CreateUpdateSQLContainerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, createUpdateSQLContainerParameters) 80 if err != nil { 81 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLContainer", nil, "Failure preparing request") 82 return 83 } 84 85 result, err = client.CreateUpdateSQLContainerSender(req) 86 if err != nil { 87 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLContainer", nil, "Failure sending request") 88 return 89 } 90 91 return 92} 93 94// CreateUpdateSQLContainerPreparer prepares the CreateUpdateSQLContainer request. 95func (client SQLResourcesClient) CreateUpdateSQLContainerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, createUpdateSQLContainerParameters SQLContainerCreateUpdateParameters) (*http.Request, error) { 96 pathParameters := map[string]interface{}{ 97 "accountName": autorest.Encode("path", accountName), 98 "containerName": autorest.Encode("path", containerName), 99 "databaseName": autorest.Encode("path", databaseName), 100 "resourceGroupName": autorest.Encode("path", resourceGroupName), 101 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 102 } 103 104 const APIVersion = "2020-04-01" 105 queryParameters := map[string]interface{}{ 106 "api-version": APIVersion, 107 } 108 109 preparer := autorest.CreatePreparer( 110 autorest.AsContentType("application/json; charset=utf-8"), 111 autorest.AsPut(), 112 autorest.WithBaseURL(client.BaseURI), 113 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}", pathParameters), 114 autorest.WithJSON(createUpdateSQLContainerParameters), 115 autorest.WithQueryParameters(queryParameters)) 116 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 117} 118 119// CreateUpdateSQLContainerSender sends the CreateUpdateSQLContainer request. The method will close the 120// http.Response Body if it receives an error. 121func (client SQLResourcesClient) CreateUpdateSQLContainerSender(req *http.Request) (future SQLResourcesCreateUpdateSQLContainerFuture, err error) { 122 var resp *http.Response 123 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 124 if err != nil { 125 return 126 } 127 var azf azure.Future 128 azf, err = azure.NewFutureFromResponse(resp) 129 future.FutureAPI = &azf 130 future.Result = future.result 131 return 132} 133 134// CreateUpdateSQLContainerResponder handles the response to the CreateUpdateSQLContainer request. The method always 135// closes the http.Response Body. 136func (client SQLResourcesClient) CreateUpdateSQLContainerResponder(resp *http.Response) (result SQLContainerGetResults, err error) { 137 err = autorest.Respond( 138 resp, 139 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 140 autorest.ByUnmarshallingJSON(&result), 141 autorest.ByClosing()) 142 result.Response = autorest.Response{Response: resp} 143 return 144} 145 146// CreateUpdateSQLDatabase create or update an Azure Cosmos DB SQL database 147// Parameters: 148// resourceGroupName - the name of the resource group. The name is case insensitive. 149// accountName - cosmos DB database account name. 150// databaseName - cosmos DB database name. 151// createUpdateSQLDatabaseParameters - the parameters to provide for the current SQL database. 152func (client SQLResourcesClient) CreateUpdateSQLDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string, createUpdateSQLDatabaseParameters SQLDatabaseCreateUpdateParameters) (result SQLResourcesCreateUpdateSQLDatabaseFuture, err error) { 153 if tracing.IsEnabled() { 154 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.CreateUpdateSQLDatabase") 155 defer func() { 156 sc := -1 157 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 158 sc = result.FutureAPI.Response().StatusCode 159 } 160 tracing.EndSpan(ctx, sc, err) 161 }() 162 } 163 if err := validation.Validate([]validation.Validation{ 164 {TargetValue: client.SubscriptionID, 165 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 166 {TargetValue: resourceGroupName, 167 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 168 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 169 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 170 {TargetValue: accountName, 171 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 172 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 173 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}, 174 {TargetValue: createUpdateSQLDatabaseParameters, 175 Constraints: []validation.Constraint{{Target: "createUpdateSQLDatabaseParameters.SQLDatabaseCreateUpdateProperties", Name: validation.Null, Rule: true, 176 Chain: []validation.Constraint{{Target: "createUpdateSQLDatabaseParameters.SQLDatabaseCreateUpdateProperties.Resource", Name: validation.Null, Rule: true, 177 Chain: []validation.Constraint{{Target: "createUpdateSQLDatabaseParameters.SQLDatabaseCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}}, 178 {Target: "createUpdateSQLDatabaseParameters.SQLDatabaseCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil}, 179 }}}}}); err != nil { 180 return result, validation.NewError("documentdb.SQLResourcesClient", "CreateUpdateSQLDatabase", err.Error()) 181 } 182 183 req, err := client.CreateUpdateSQLDatabasePreparer(ctx, resourceGroupName, accountName, databaseName, createUpdateSQLDatabaseParameters) 184 if err != nil { 185 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLDatabase", nil, "Failure preparing request") 186 return 187 } 188 189 result, err = client.CreateUpdateSQLDatabaseSender(req) 190 if err != nil { 191 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLDatabase", nil, "Failure sending request") 192 return 193 } 194 195 return 196} 197 198// CreateUpdateSQLDatabasePreparer prepares the CreateUpdateSQLDatabase request. 199func (client SQLResourcesClient) CreateUpdateSQLDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, createUpdateSQLDatabaseParameters SQLDatabaseCreateUpdateParameters) (*http.Request, error) { 200 pathParameters := map[string]interface{}{ 201 "accountName": autorest.Encode("path", accountName), 202 "databaseName": autorest.Encode("path", databaseName), 203 "resourceGroupName": autorest.Encode("path", resourceGroupName), 204 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 205 } 206 207 const APIVersion = "2020-04-01" 208 queryParameters := map[string]interface{}{ 209 "api-version": APIVersion, 210 } 211 212 preparer := autorest.CreatePreparer( 213 autorest.AsContentType("application/json; charset=utf-8"), 214 autorest.AsPut(), 215 autorest.WithBaseURL(client.BaseURI), 216 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}", pathParameters), 217 autorest.WithJSON(createUpdateSQLDatabaseParameters), 218 autorest.WithQueryParameters(queryParameters)) 219 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 220} 221 222// CreateUpdateSQLDatabaseSender sends the CreateUpdateSQLDatabase request. The method will close the 223// http.Response Body if it receives an error. 224func (client SQLResourcesClient) CreateUpdateSQLDatabaseSender(req *http.Request) (future SQLResourcesCreateUpdateSQLDatabaseFuture, err error) { 225 var resp *http.Response 226 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 227 if err != nil { 228 return 229 } 230 var azf azure.Future 231 azf, err = azure.NewFutureFromResponse(resp) 232 future.FutureAPI = &azf 233 future.Result = future.result 234 return 235} 236 237// CreateUpdateSQLDatabaseResponder handles the response to the CreateUpdateSQLDatabase request. The method always 238// closes the http.Response Body. 239func (client SQLResourcesClient) CreateUpdateSQLDatabaseResponder(resp *http.Response) (result SQLDatabaseGetResults, err error) { 240 err = autorest.Respond( 241 resp, 242 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 243 autorest.ByUnmarshallingJSON(&result), 244 autorest.ByClosing()) 245 result.Response = autorest.Response{Response: resp} 246 return 247} 248 249// CreateUpdateSQLStoredProcedure create or update an Azure Cosmos DB SQL storedProcedure 250// Parameters: 251// resourceGroupName - the name of the resource group. The name is case insensitive. 252// accountName - cosmos DB database account name. 253// databaseName - cosmos DB database name. 254// containerName - cosmos DB container name. 255// storedProcedureName - cosmos DB storedProcedure name. 256// createUpdateSQLStoredProcedureParameters - the parameters to provide for the current SQL storedProcedure. 257func (client SQLResourcesClient) CreateUpdateSQLStoredProcedure(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, storedProcedureName string, createUpdateSQLStoredProcedureParameters SQLStoredProcedureCreateUpdateParameters) (result SQLResourcesCreateUpdateSQLStoredProcedureFuture, err error) { 258 if tracing.IsEnabled() { 259 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.CreateUpdateSQLStoredProcedure") 260 defer func() { 261 sc := -1 262 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 263 sc = result.FutureAPI.Response().StatusCode 264 } 265 tracing.EndSpan(ctx, sc, err) 266 }() 267 } 268 if err := validation.Validate([]validation.Validation{ 269 {TargetValue: client.SubscriptionID, 270 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 271 {TargetValue: resourceGroupName, 272 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 273 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 274 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 275 {TargetValue: accountName, 276 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 277 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 278 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}, 279 {TargetValue: createUpdateSQLStoredProcedureParameters, 280 Constraints: []validation.Constraint{{Target: "createUpdateSQLStoredProcedureParameters.SQLStoredProcedureCreateUpdateProperties", Name: validation.Null, Rule: true, 281 Chain: []validation.Constraint{{Target: "createUpdateSQLStoredProcedureParameters.SQLStoredProcedureCreateUpdateProperties.Resource", Name: validation.Null, Rule: true, 282 Chain: []validation.Constraint{{Target: "createUpdateSQLStoredProcedureParameters.SQLStoredProcedureCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}}, 283 {Target: "createUpdateSQLStoredProcedureParameters.SQLStoredProcedureCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil}, 284 }}}}}); err != nil { 285 return result, validation.NewError("documentdb.SQLResourcesClient", "CreateUpdateSQLStoredProcedure", err.Error()) 286 } 287 288 req, err := client.CreateUpdateSQLStoredProcedurePreparer(ctx, resourceGroupName, accountName, databaseName, containerName, storedProcedureName, createUpdateSQLStoredProcedureParameters) 289 if err != nil { 290 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLStoredProcedure", nil, "Failure preparing request") 291 return 292 } 293 294 result, err = client.CreateUpdateSQLStoredProcedureSender(req) 295 if err != nil { 296 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLStoredProcedure", nil, "Failure sending request") 297 return 298 } 299 300 return 301} 302 303// CreateUpdateSQLStoredProcedurePreparer prepares the CreateUpdateSQLStoredProcedure request. 304func (client SQLResourcesClient) CreateUpdateSQLStoredProcedurePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, storedProcedureName string, createUpdateSQLStoredProcedureParameters SQLStoredProcedureCreateUpdateParameters) (*http.Request, error) { 305 pathParameters := map[string]interface{}{ 306 "accountName": autorest.Encode("path", accountName), 307 "containerName": autorest.Encode("path", containerName), 308 "databaseName": autorest.Encode("path", databaseName), 309 "resourceGroupName": autorest.Encode("path", resourceGroupName), 310 "storedProcedureName": autorest.Encode("path", storedProcedureName), 311 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 312 } 313 314 const APIVersion = "2020-04-01" 315 queryParameters := map[string]interface{}{ 316 "api-version": APIVersion, 317 } 318 319 preparer := autorest.CreatePreparer( 320 autorest.AsContentType("application/json; charset=utf-8"), 321 autorest.AsPut(), 322 autorest.WithBaseURL(client.BaseURI), 323 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/storedProcedures/{storedProcedureName}", pathParameters), 324 autorest.WithJSON(createUpdateSQLStoredProcedureParameters), 325 autorest.WithQueryParameters(queryParameters)) 326 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 327} 328 329// CreateUpdateSQLStoredProcedureSender sends the CreateUpdateSQLStoredProcedure request. The method will close the 330// http.Response Body if it receives an error. 331func (client SQLResourcesClient) CreateUpdateSQLStoredProcedureSender(req *http.Request) (future SQLResourcesCreateUpdateSQLStoredProcedureFuture, err error) { 332 var resp *http.Response 333 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 334 if err != nil { 335 return 336 } 337 var azf azure.Future 338 azf, err = azure.NewFutureFromResponse(resp) 339 future.FutureAPI = &azf 340 future.Result = future.result 341 return 342} 343 344// CreateUpdateSQLStoredProcedureResponder handles the response to the CreateUpdateSQLStoredProcedure request. The method always 345// closes the http.Response Body. 346func (client SQLResourcesClient) CreateUpdateSQLStoredProcedureResponder(resp *http.Response) (result SQLStoredProcedureGetResults, err error) { 347 err = autorest.Respond( 348 resp, 349 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 350 autorest.ByUnmarshallingJSON(&result), 351 autorest.ByClosing()) 352 result.Response = autorest.Response{Response: resp} 353 return 354} 355 356// CreateUpdateSQLTrigger create or update an Azure Cosmos DB SQL trigger 357// Parameters: 358// resourceGroupName - the name of the resource group. The name is case insensitive. 359// accountName - cosmos DB database account name. 360// databaseName - cosmos DB database name. 361// containerName - cosmos DB container name. 362// triggerName - cosmos DB trigger name. 363// createUpdateSQLTriggerParameters - the parameters to provide for the current SQL trigger. 364func (client SQLResourcesClient) CreateUpdateSQLTrigger(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, triggerName string, createUpdateSQLTriggerParameters SQLTriggerCreateUpdateParameters) (result SQLResourcesCreateUpdateSQLTriggerFuture, err error) { 365 if tracing.IsEnabled() { 366 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.CreateUpdateSQLTrigger") 367 defer func() { 368 sc := -1 369 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 370 sc = result.FutureAPI.Response().StatusCode 371 } 372 tracing.EndSpan(ctx, sc, err) 373 }() 374 } 375 if err := validation.Validate([]validation.Validation{ 376 {TargetValue: client.SubscriptionID, 377 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 378 {TargetValue: resourceGroupName, 379 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 380 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 381 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 382 {TargetValue: accountName, 383 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 384 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 385 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}, 386 {TargetValue: createUpdateSQLTriggerParameters, 387 Constraints: []validation.Constraint{{Target: "createUpdateSQLTriggerParameters.SQLTriggerCreateUpdateProperties", Name: validation.Null, Rule: true, 388 Chain: []validation.Constraint{{Target: "createUpdateSQLTriggerParameters.SQLTriggerCreateUpdateProperties.Resource", Name: validation.Null, Rule: true, 389 Chain: []validation.Constraint{{Target: "createUpdateSQLTriggerParameters.SQLTriggerCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}}, 390 {Target: "createUpdateSQLTriggerParameters.SQLTriggerCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil}, 391 }}}}}); err != nil { 392 return result, validation.NewError("documentdb.SQLResourcesClient", "CreateUpdateSQLTrigger", err.Error()) 393 } 394 395 req, err := client.CreateUpdateSQLTriggerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, triggerName, createUpdateSQLTriggerParameters) 396 if err != nil { 397 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLTrigger", nil, "Failure preparing request") 398 return 399 } 400 401 result, err = client.CreateUpdateSQLTriggerSender(req) 402 if err != nil { 403 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLTrigger", nil, "Failure sending request") 404 return 405 } 406 407 return 408} 409 410// CreateUpdateSQLTriggerPreparer prepares the CreateUpdateSQLTrigger request. 411func (client SQLResourcesClient) CreateUpdateSQLTriggerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, triggerName string, createUpdateSQLTriggerParameters SQLTriggerCreateUpdateParameters) (*http.Request, error) { 412 pathParameters := map[string]interface{}{ 413 "accountName": autorest.Encode("path", accountName), 414 "containerName": autorest.Encode("path", containerName), 415 "databaseName": autorest.Encode("path", databaseName), 416 "resourceGroupName": autorest.Encode("path", resourceGroupName), 417 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 418 "triggerName": autorest.Encode("path", triggerName), 419 } 420 421 const APIVersion = "2020-04-01" 422 queryParameters := map[string]interface{}{ 423 "api-version": APIVersion, 424 } 425 426 preparer := autorest.CreatePreparer( 427 autorest.AsContentType("application/json; charset=utf-8"), 428 autorest.AsPut(), 429 autorest.WithBaseURL(client.BaseURI), 430 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/triggers/{triggerName}", pathParameters), 431 autorest.WithJSON(createUpdateSQLTriggerParameters), 432 autorest.WithQueryParameters(queryParameters)) 433 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 434} 435 436// CreateUpdateSQLTriggerSender sends the CreateUpdateSQLTrigger request. The method will close the 437// http.Response Body if it receives an error. 438func (client SQLResourcesClient) CreateUpdateSQLTriggerSender(req *http.Request) (future SQLResourcesCreateUpdateSQLTriggerFuture, err error) { 439 var resp *http.Response 440 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 441 if err != nil { 442 return 443 } 444 var azf azure.Future 445 azf, err = azure.NewFutureFromResponse(resp) 446 future.FutureAPI = &azf 447 future.Result = future.result 448 return 449} 450 451// CreateUpdateSQLTriggerResponder handles the response to the CreateUpdateSQLTrigger request. The method always 452// closes the http.Response Body. 453func (client SQLResourcesClient) CreateUpdateSQLTriggerResponder(resp *http.Response) (result SQLTriggerGetResults, err error) { 454 err = autorest.Respond( 455 resp, 456 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 457 autorest.ByUnmarshallingJSON(&result), 458 autorest.ByClosing()) 459 result.Response = autorest.Response{Response: resp} 460 return 461} 462 463// CreateUpdateSQLUserDefinedFunction create or update an Azure Cosmos DB SQL userDefinedFunction 464// Parameters: 465// resourceGroupName - the name of the resource group. The name is case insensitive. 466// accountName - cosmos DB database account name. 467// databaseName - cosmos DB database name. 468// containerName - cosmos DB container name. 469// userDefinedFunctionName - cosmos DB userDefinedFunction name. 470// createUpdateSQLUserDefinedFunctionParameters - the parameters to provide for the current SQL 471// userDefinedFunction. 472func (client SQLResourcesClient) CreateUpdateSQLUserDefinedFunction(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, userDefinedFunctionName string, createUpdateSQLUserDefinedFunctionParameters SQLUserDefinedFunctionCreateUpdateParameters) (result SQLResourcesCreateUpdateSQLUserDefinedFunctionFuture, err error) { 473 if tracing.IsEnabled() { 474 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.CreateUpdateSQLUserDefinedFunction") 475 defer func() { 476 sc := -1 477 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 478 sc = result.FutureAPI.Response().StatusCode 479 } 480 tracing.EndSpan(ctx, sc, err) 481 }() 482 } 483 if err := validation.Validate([]validation.Validation{ 484 {TargetValue: client.SubscriptionID, 485 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 486 {TargetValue: resourceGroupName, 487 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 488 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 489 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 490 {TargetValue: accountName, 491 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 492 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 493 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}, 494 {TargetValue: createUpdateSQLUserDefinedFunctionParameters, 495 Constraints: []validation.Constraint{{Target: "createUpdateSQLUserDefinedFunctionParameters.SQLUserDefinedFunctionCreateUpdateProperties", Name: validation.Null, Rule: true, 496 Chain: []validation.Constraint{{Target: "createUpdateSQLUserDefinedFunctionParameters.SQLUserDefinedFunctionCreateUpdateProperties.Resource", Name: validation.Null, Rule: true, 497 Chain: []validation.Constraint{{Target: "createUpdateSQLUserDefinedFunctionParameters.SQLUserDefinedFunctionCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}}, 498 {Target: "createUpdateSQLUserDefinedFunctionParameters.SQLUserDefinedFunctionCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil}, 499 }}}}}); err != nil { 500 return result, validation.NewError("documentdb.SQLResourcesClient", "CreateUpdateSQLUserDefinedFunction", err.Error()) 501 } 502 503 req, err := client.CreateUpdateSQLUserDefinedFunctionPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, userDefinedFunctionName, createUpdateSQLUserDefinedFunctionParameters) 504 if err != nil { 505 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLUserDefinedFunction", nil, "Failure preparing request") 506 return 507 } 508 509 result, err = client.CreateUpdateSQLUserDefinedFunctionSender(req) 510 if err != nil { 511 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "CreateUpdateSQLUserDefinedFunction", nil, "Failure sending request") 512 return 513 } 514 515 return 516} 517 518// CreateUpdateSQLUserDefinedFunctionPreparer prepares the CreateUpdateSQLUserDefinedFunction request. 519func (client SQLResourcesClient) CreateUpdateSQLUserDefinedFunctionPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, userDefinedFunctionName string, createUpdateSQLUserDefinedFunctionParameters SQLUserDefinedFunctionCreateUpdateParameters) (*http.Request, error) { 520 pathParameters := map[string]interface{}{ 521 "accountName": autorest.Encode("path", accountName), 522 "containerName": autorest.Encode("path", containerName), 523 "databaseName": autorest.Encode("path", databaseName), 524 "resourceGroupName": autorest.Encode("path", resourceGroupName), 525 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 526 "userDefinedFunctionName": autorest.Encode("path", userDefinedFunctionName), 527 } 528 529 const APIVersion = "2020-04-01" 530 queryParameters := map[string]interface{}{ 531 "api-version": APIVersion, 532 } 533 534 preparer := autorest.CreatePreparer( 535 autorest.AsContentType("application/json; charset=utf-8"), 536 autorest.AsPut(), 537 autorest.WithBaseURL(client.BaseURI), 538 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/userDefinedFunctions/{userDefinedFunctionName}", pathParameters), 539 autorest.WithJSON(createUpdateSQLUserDefinedFunctionParameters), 540 autorest.WithQueryParameters(queryParameters)) 541 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 542} 543 544// CreateUpdateSQLUserDefinedFunctionSender sends the CreateUpdateSQLUserDefinedFunction request. The method will close the 545// http.Response Body if it receives an error. 546func (client SQLResourcesClient) CreateUpdateSQLUserDefinedFunctionSender(req *http.Request) (future SQLResourcesCreateUpdateSQLUserDefinedFunctionFuture, err error) { 547 var resp *http.Response 548 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 549 if err != nil { 550 return 551 } 552 var azf azure.Future 553 azf, err = azure.NewFutureFromResponse(resp) 554 future.FutureAPI = &azf 555 future.Result = future.result 556 return 557} 558 559// CreateUpdateSQLUserDefinedFunctionResponder handles the response to the CreateUpdateSQLUserDefinedFunction request. The method always 560// closes the http.Response Body. 561func (client SQLResourcesClient) CreateUpdateSQLUserDefinedFunctionResponder(resp *http.Response) (result SQLUserDefinedFunctionGetResults, err error) { 562 err = autorest.Respond( 563 resp, 564 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 565 autorest.ByUnmarshallingJSON(&result), 566 autorest.ByClosing()) 567 result.Response = autorest.Response{Response: resp} 568 return 569} 570 571// DeleteSQLContainer deletes an existing Azure Cosmos DB SQL container. 572// Parameters: 573// resourceGroupName - the name of the resource group. The name is case insensitive. 574// accountName - cosmos DB database account name. 575// databaseName - cosmos DB database name. 576// containerName - cosmos DB container name. 577func (client SQLResourcesClient) DeleteSQLContainer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result SQLResourcesDeleteSQLContainerFuture, err error) { 578 if tracing.IsEnabled() { 579 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.DeleteSQLContainer") 580 defer func() { 581 sc := -1 582 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 583 sc = result.FutureAPI.Response().StatusCode 584 } 585 tracing.EndSpan(ctx, sc, err) 586 }() 587 } 588 if err := validation.Validate([]validation.Validation{ 589 {TargetValue: client.SubscriptionID, 590 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 591 {TargetValue: resourceGroupName, 592 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 593 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 594 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 595 {TargetValue: accountName, 596 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 597 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 598 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 599 return result, validation.NewError("documentdb.SQLResourcesClient", "DeleteSQLContainer", err.Error()) 600 } 601 602 req, err := client.DeleteSQLContainerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName) 603 if err != nil { 604 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLContainer", nil, "Failure preparing request") 605 return 606 } 607 608 result, err = client.DeleteSQLContainerSender(req) 609 if err != nil { 610 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLContainer", nil, "Failure sending request") 611 return 612 } 613 614 return 615} 616 617// DeleteSQLContainerPreparer prepares the DeleteSQLContainer request. 618func (client SQLResourcesClient) DeleteSQLContainerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) { 619 pathParameters := map[string]interface{}{ 620 "accountName": autorest.Encode("path", accountName), 621 "containerName": autorest.Encode("path", containerName), 622 "databaseName": autorest.Encode("path", databaseName), 623 "resourceGroupName": autorest.Encode("path", resourceGroupName), 624 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 625 } 626 627 const APIVersion = "2020-04-01" 628 queryParameters := map[string]interface{}{ 629 "api-version": APIVersion, 630 } 631 632 preparer := autorest.CreatePreparer( 633 autorest.AsDelete(), 634 autorest.WithBaseURL(client.BaseURI), 635 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}", pathParameters), 636 autorest.WithQueryParameters(queryParameters)) 637 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 638} 639 640// DeleteSQLContainerSender sends the DeleteSQLContainer request. The method will close the 641// http.Response Body if it receives an error. 642func (client SQLResourcesClient) DeleteSQLContainerSender(req *http.Request) (future SQLResourcesDeleteSQLContainerFuture, err error) { 643 var resp *http.Response 644 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 645 if err != nil { 646 return 647 } 648 var azf azure.Future 649 azf, err = azure.NewFutureFromResponse(resp) 650 future.FutureAPI = &azf 651 future.Result = future.result 652 return 653} 654 655// DeleteSQLContainerResponder handles the response to the DeleteSQLContainer request. The method always 656// closes the http.Response Body. 657func (client SQLResourcesClient) DeleteSQLContainerResponder(resp *http.Response) (result autorest.Response, err error) { 658 err = autorest.Respond( 659 resp, 660 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 661 autorest.ByClosing()) 662 result.Response = resp 663 return 664} 665 666// DeleteSQLDatabase deletes an existing Azure Cosmos DB SQL database. 667// Parameters: 668// resourceGroupName - the name of the resource group. The name is case insensitive. 669// accountName - cosmos DB database account name. 670// databaseName - cosmos DB database name. 671func (client SQLResourcesClient) DeleteSQLDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result SQLResourcesDeleteSQLDatabaseFuture, err error) { 672 if tracing.IsEnabled() { 673 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.DeleteSQLDatabase") 674 defer func() { 675 sc := -1 676 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 677 sc = result.FutureAPI.Response().StatusCode 678 } 679 tracing.EndSpan(ctx, sc, err) 680 }() 681 } 682 if err := validation.Validate([]validation.Validation{ 683 {TargetValue: client.SubscriptionID, 684 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 685 {TargetValue: resourceGroupName, 686 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 687 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 688 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 689 {TargetValue: accountName, 690 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 691 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 692 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 693 return result, validation.NewError("documentdb.SQLResourcesClient", "DeleteSQLDatabase", err.Error()) 694 } 695 696 req, err := client.DeleteSQLDatabasePreparer(ctx, resourceGroupName, accountName, databaseName) 697 if err != nil { 698 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLDatabase", nil, "Failure preparing request") 699 return 700 } 701 702 result, err = client.DeleteSQLDatabaseSender(req) 703 if err != nil { 704 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLDatabase", nil, "Failure sending request") 705 return 706 } 707 708 return 709} 710 711// DeleteSQLDatabasePreparer prepares the DeleteSQLDatabase request. 712func (client SQLResourcesClient) DeleteSQLDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) { 713 pathParameters := map[string]interface{}{ 714 "accountName": autorest.Encode("path", accountName), 715 "databaseName": autorest.Encode("path", databaseName), 716 "resourceGroupName": autorest.Encode("path", resourceGroupName), 717 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 718 } 719 720 const APIVersion = "2020-04-01" 721 queryParameters := map[string]interface{}{ 722 "api-version": APIVersion, 723 } 724 725 preparer := autorest.CreatePreparer( 726 autorest.AsDelete(), 727 autorest.WithBaseURL(client.BaseURI), 728 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}", pathParameters), 729 autorest.WithQueryParameters(queryParameters)) 730 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 731} 732 733// DeleteSQLDatabaseSender sends the DeleteSQLDatabase request. The method will close the 734// http.Response Body if it receives an error. 735func (client SQLResourcesClient) DeleteSQLDatabaseSender(req *http.Request) (future SQLResourcesDeleteSQLDatabaseFuture, err error) { 736 var resp *http.Response 737 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 738 if err != nil { 739 return 740 } 741 var azf azure.Future 742 azf, err = azure.NewFutureFromResponse(resp) 743 future.FutureAPI = &azf 744 future.Result = future.result 745 return 746} 747 748// DeleteSQLDatabaseResponder handles the response to the DeleteSQLDatabase request. The method always 749// closes the http.Response Body. 750func (client SQLResourcesClient) DeleteSQLDatabaseResponder(resp *http.Response) (result autorest.Response, err error) { 751 err = autorest.Respond( 752 resp, 753 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 754 autorest.ByClosing()) 755 result.Response = resp 756 return 757} 758 759// DeleteSQLStoredProcedure deletes an existing Azure Cosmos DB SQL storedProcedure. 760// Parameters: 761// resourceGroupName - the name of the resource group. The name is case insensitive. 762// accountName - cosmos DB database account name. 763// databaseName - cosmos DB database name. 764// containerName - cosmos DB container name. 765// storedProcedureName - cosmos DB storedProcedure name. 766func (client SQLResourcesClient) DeleteSQLStoredProcedure(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, storedProcedureName string) (result SQLResourcesDeleteSQLStoredProcedureFuture, err error) { 767 if tracing.IsEnabled() { 768 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.DeleteSQLStoredProcedure") 769 defer func() { 770 sc := -1 771 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 772 sc = result.FutureAPI.Response().StatusCode 773 } 774 tracing.EndSpan(ctx, sc, err) 775 }() 776 } 777 if err := validation.Validate([]validation.Validation{ 778 {TargetValue: client.SubscriptionID, 779 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 780 {TargetValue: resourceGroupName, 781 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 782 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 783 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 784 {TargetValue: accountName, 785 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 786 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 787 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 788 return result, validation.NewError("documentdb.SQLResourcesClient", "DeleteSQLStoredProcedure", err.Error()) 789 } 790 791 req, err := client.DeleteSQLStoredProcedurePreparer(ctx, resourceGroupName, accountName, databaseName, containerName, storedProcedureName) 792 if err != nil { 793 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLStoredProcedure", nil, "Failure preparing request") 794 return 795 } 796 797 result, err = client.DeleteSQLStoredProcedureSender(req) 798 if err != nil { 799 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLStoredProcedure", nil, "Failure sending request") 800 return 801 } 802 803 return 804} 805 806// DeleteSQLStoredProcedurePreparer prepares the DeleteSQLStoredProcedure request. 807func (client SQLResourcesClient) DeleteSQLStoredProcedurePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, storedProcedureName string) (*http.Request, error) { 808 pathParameters := map[string]interface{}{ 809 "accountName": autorest.Encode("path", accountName), 810 "containerName": autorest.Encode("path", containerName), 811 "databaseName": autorest.Encode("path", databaseName), 812 "resourceGroupName": autorest.Encode("path", resourceGroupName), 813 "storedProcedureName": autorest.Encode("path", storedProcedureName), 814 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 815 } 816 817 const APIVersion = "2020-04-01" 818 queryParameters := map[string]interface{}{ 819 "api-version": APIVersion, 820 } 821 822 preparer := autorest.CreatePreparer( 823 autorest.AsDelete(), 824 autorest.WithBaseURL(client.BaseURI), 825 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/storedProcedures/{storedProcedureName}", pathParameters), 826 autorest.WithQueryParameters(queryParameters)) 827 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 828} 829 830// DeleteSQLStoredProcedureSender sends the DeleteSQLStoredProcedure request. The method will close the 831// http.Response Body if it receives an error. 832func (client SQLResourcesClient) DeleteSQLStoredProcedureSender(req *http.Request) (future SQLResourcesDeleteSQLStoredProcedureFuture, err error) { 833 var resp *http.Response 834 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 835 if err != nil { 836 return 837 } 838 var azf azure.Future 839 azf, err = azure.NewFutureFromResponse(resp) 840 future.FutureAPI = &azf 841 future.Result = future.result 842 return 843} 844 845// DeleteSQLStoredProcedureResponder handles the response to the DeleteSQLStoredProcedure request. The method always 846// closes the http.Response Body. 847func (client SQLResourcesClient) DeleteSQLStoredProcedureResponder(resp *http.Response) (result autorest.Response, err error) { 848 err = autorest.Respond( 849 resp, 850 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 851 autorest.ByClosing()) 852 result.Response = resp 853 return 854} 855 856// DeleteSQLTrigger deletes an existing Azure Cosmos DB SQL trigger. 857// Parameters: 858// resourceGroupName - the name of the resource group. The name is case insensitive. 859// accountName - cosmos DB database account name. 860// databaseName - cosmos DB database name. 861// containerName - cosmos DB container name. 862// triggerName - cosmos DB trigger name. 863func (client SQLResourcesClient) DeleteSQLTrigger(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, triggerName string) (result SQLResourcesDeleteSQLTriggerFuture, err error) { 864 if tracing.IsEnabled() { 865 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.DeleteSQLTrigger") 866 defer func() { 867 sc := -1 868 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 869 sc = result.FutureAPI.Response().StatusCode 870 } 871 tracing.EndSpan(ctx, sc, err) 872 }() 873 } 874 if err := validation.Validate([]validation.Validation{ 875 {TargetValue: client.SubscriptionID, 876 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 877 {TargetValue: resourceGroupName, 878 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 879 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 880 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 881 {TargetValue: accountName, 882 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 883 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 884 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 885 return result, validation.NewError("documentdb.SQLResourcesClient", "DeleteSQLTrigger", err.Error()) 886 } 887 888 req, err := client.DeleteSQLTriggerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, triggerName) 889 if err != nil { 890 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLTrigger", nil, "Failure preparing request") 891 return 892 } 893 894 result, err = client.DeleteSQLTriggerSender(req) 895 if err != nil { 896 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLTrigger", nil, "Failure sending request") 897 return 898 } 899 900 return 901} 902 903// DeleteSQLTriggerPreparer prepares the DeleteSQLTrigger request. 904func (client SQLResourcesClient) DeleteSQLTriggerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, triggerName string) (*http.Request, error) { 905 pathParameters := map[string]interface{}{ 906 "accountName": autorest.Encode("path", accountName), 907 "containerName": autorest.Encode("path", containerName), 908 "databaseName": autorest.Encode("path", databaseName), 909 "resourceGroupName": autorest.Encode("path", resourceGroupName), 910 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 911 "triggerName": autorest.Encode("path", triggerName), 912 } 913 914 const APIVersion = "2020-04-01" 915 queryParameters := map[string]interface{}{ 916 "api-version": APIVersion, 917 } 918 919 preparer := autorest.CreatePreparer( 920 autorest.AsDelete(), 921 autorest.WithBaseURL(client.BaseURI), 922 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/triggers/{triggerName}", pathParameters), 923 autorest.WithQueryParameters(queryParameters)) 924 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 925} 926 927// DeleteSQLTriggerSender sends the DeleteSQLTrigger request. The method will close the 928// http.Response Body if it receives an error. 929func (client SQLResourcesClient) DeleteSQLTriggerSender(req *http.Request) (future SQLResourcesDeleteSQLTriggerFuture, err error) { 930 var resp *http.Response 931 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 932 if err != nil { 933 return 934 } 935 var azf azure.Future 936 azf, err = azure.NewFutureFromResponse(resp) 937 future.FutureAPI = &azf 938 future.Result = future.result 939 return 940} 941 942// DeleteSQLTriggerResponder handles the response to the DeleteSQLTrigger request. The method always 943// closes the http.Response Body. 944func (client SQLResourcesClient) DeleteSQLTriggerResponder(resp *http.Response) (result autorest.Response, err error) { 945 err = autorest.Respond( 946 resp, 947 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 948 autorest.ByClosing()) 949 result.Response = resp 950 return 951} 952 953// DeleteSQLUserDefinedFunction deletes an existing Azure Cosmos DB SQL userDefinedFunction. 954// Parameters: 955// resourceGroupName - the name of the resource group. The name is case insensitive. 956// accountName - cosmos DB database account name. 957// databaseName - cosmos DB database name. 958// containerName - cosmos DB container name. 959// userDefinedFunctionName - cosmos DB userDefinedFunction name. 960func (client SQLResourcesClient) DeleteSQLUserDefinedFunction(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, userDefinedFunctionName string) (result SQLResourcesDeleteSQLUserDefinedFunctionFuture, err error) { 961 if tracing.IsEnabled() { 962 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.DeleteSQLUserDefinedFunction") 963 defer func() { 964 sc := -1 965 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 966 sc = result.FutureAPI.Response().StatusCode 967 } 968 tracing.EndSpan(ctx, sc, err) 969 }() 970 } 971 if err := validation.Validate([]validation.Validation{ 972 {TargetValue: client.SubscriptionID, 973 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 974 {TargetValue: resourceGroupName, 975 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 976 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 977 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 978 {TargetValue: accountName, 979 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 980 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 981 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 982 return result, validation.NewError("documentdb.SQLResourcesClient", "DeleteSQLUserDefinedFunction", err.Error()) 983 } 984 985 req, err := client.DeleteSQLUserDefinedFunctionPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, userDefinedFunctionName) 986 if err != nil { 987 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLUserDefinedFunction", nil, "Failure preparing request") 988 return 989 } 990 991 result, err = client.DeleteSQLUserDefinedFunctionSender(req) 992 if err != nil { 993 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "DeleteSQLUserDefinedFunction", nil, "Failure sending request") 994 return 995 } 996 997 return 998} 999 1000// DeleteSQLUserDefinedFunctionPreparer prepares the DeleteSQLUserDefinedFunction request. 1001func (client SQLResourcesClient) DeleteSQLUserDefinedFunctionPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, userDefinedFunctionName string) (*http.Request, error) { 1002 pathParameters := map[string]interface{}{ 1003 "accountName": autorest.Encode("path", accountName), 1004 "containerName": autorest.Encode("path", containerName), 1005 "databaseName": autorest.Encode("path", databaseName), 1006 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1007 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1008 "userDefinedFunctionName": autorest.Encode("path", userDefinedFunctionName), 1009 } 1010 1011 const APIVersion = "2020-04-01" 1012 queryParameters := map[string]interface{}{ 1013 "api-version": APIVersion, 1014 } 1015 1016 preparer := autorest.CreatePreparer( 1017 autorest.AsDelete(), 1018 autorest.WithBaseURL(client.BaseURI), 1019 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/userDefinedFunctions/{userDefinedFunctionName}", pathParameters), 1020 autorest.WithQueryParameters(queryParameters)) 1021 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1022} 1023 1024// DeleteSQLUserDefinedFunctionSender sends the DeleteSQLUserDefinedFunction request. The method will close the 1025// http.Response Body if it receives an error. 1026func (client SQLResourcesClient) DeleteSQLUserDefinedFunctionSender(req *http.Request) (future SQLResourcesDeleteSQLUserDefinedFunctionFuture, err error) { 1027 var resp *http.Response 1028 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1029 if err != nil { 1030 return 1031 } 1032 var azf azure.Future 1033 azf, err = azure.NewFutureFromResponse(resp) 1034 future.FutureAPI = &azf 1035 future.Result = future.result 1036 return 1037} 1038 1039// DeleteSQLUserDefinedFunctionResponder handles the response to the DeleteSQLUserDefinedFunction request. The method always 1040// closes the http.Response Body. 1041func (client SQLResourcesClient) DeleteSQLUserDefinedFunctionResponder(resp *http.Response) (result autorest.Response, err error) { 1042 err = autorest.Respond( 1043 resp, 1044 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 1045 autorest.ByClosing()) 1046 result.Response = resp 1047 return 1048} 1049 1050// GetSQLContainer gets the SQL container under an existing Azure Cosmos DB database account. 1051// Parameters: 1052// resourceGroupName - the name of the resource group. The name is case insensitive. 1053// accountName - cosmos DB database account name. 1054// databaseName - cosmos DB database name. 1055// containerName - cosmos DB container name. 1056func (client SQLResourcesClient) GetSQLContainer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result SQLContainerGetResults, err error) { 1057 if tracing.IsEnabled() { 1058 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.GetSQLContainer") 1059 defer func() { 1060 sc := -1 1061 if result.Response.Response != nil { 1062 sc = result.Response.Response.StatusCode 1063 } 1064 tracing.EndSpan(ctx, sc, err) 1065 }() 1066 } 1067 if err := validation.Validate([]validation.Validation{ 1068 {TargetValue: client.SubscriptionID, 1069 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1070 {TargetValue: resourceGroupName, 1071 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1072 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1073 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1074 {TargetValue: accountName, 1075 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1076 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1077 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1078 return result, validation.NewError("documentdb.SQLResourcesClient", "GetSQLContainer", err.Error()) 1079 } 1080 1081 req, err := client.GetSQLContainerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName) 1082 if err != nil { 1083 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLContainer", nil, "Failure preparing request") 1084 return 1085 } 1086 1087 resp, err := client.GetSQLContainerSender(req) 1088 if err != nil { 1089 result.Response = autorest.Response{Response: resp} 1090 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLContainer", resp, "Failure sending request") 1091 return 1092 } 1093 1094 result, err = client.GetSQLContainerResponder(resp) 1095 if err != nil { 1096 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLContainer", resp, "Failure responding to request") 1097 return 1098 } 1099 1100 return 1101} 1102 1103// GetSQLContainerPreparer prepares the GetSQLContainer request. 1104func (client SQLResourcesClient) GetSQLContainerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) { 1105 pathParameters := map[string]interface{}{ 1106 "accountName": autorest.Encode("path", accountName), 1107 "containerName": autorest.Encode("path", containerName), 1108 "databaseName": autorest.Encode("path", databaseName), 1109 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1110 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1111 } 1112 1113 const APIVersion = "2020-04-01" 1114 queryParameters := map[string]interface{}{ 1115 "api-version": APIVersion, 1116 } 1117 1118 preparer := autorest.CreatePreparer( 1119 autorest.AsGet(), 1120 autorest.WithBaseURL(client.BaseURI), 1121 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}", pathParameters), 1122 autorest.WithQueryParameters(queryParameters)) 1123 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1124} 1125 1126// GetSQLContainerSender sends the GetSQLContainer request. The method will close the 1127// http.Response Body if it receives an error. 1128func (client SQLResourcesClient) GetSQLContainerSender(req *http.Request) (*http.Response, error) { 1129 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1130} 1131 1132// GetSQLContainerResponder handles the response to the GetSQLContainer request. The method always 1133// closes the http.Response Body. 1134func (client SQLResourcesClient) GetSQLContainerResponder(resp *http.Response) (result SQLContainerGetResults, err error) { 1135 err = autorest.Respond( 1136 resp, 1137 azure.WithErrorUnlessStatusCode(http.StatusOK), 1138 autorest.ByUnmarshallingJSON(&result), 1139 autorest.ByClosing()) 1140 result.Response = autorest.Response{Response: resp} 1141 return 1142} 1143 1144// GetSQLContainerThroughput gets the RUs per second of the SQL container under an existing Azure Cosmos DB database 1145// account. 1146// Parameters: 1147// resourceGroupName - the name of the resource group. The name is case insensitive. 1148// accountName - cosmos DB database account name. 1149// databaseName - cosmos DB database name. 1150// containerName - cosmos DB container name. 1151func (client SQLResourcesClient) GetSQLContainerThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result ThroughputSettingsGetResults, err error) { 1152 if tracing.IsEnabled() { 1153 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.GetSQLContainerThroughput") 1154 defer func() { 1155 sc := -1 1156 if result.Response.Response != nil { 1157 sc = result.Response.Response.StatusCode 1158 } 1159 tracing.EndSpan(ctx, sc, err) 1160 }() 1161 } 1162 if err := validation.Validate([]validation.Validation{ 1163 {TargetValue: client.SubscriptionID, 1164 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1165 {TargetValue: resourceGroupName, 1166 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1167 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1168 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1169 {TargetValue: accountName, 1170 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1171 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1172 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1173 return result, validation.NewError("documentdb.SQLResourcesClient", "GetSQLContainerThroughput", err.Error()) 1174 } 1175 1176 req, err := client.GetSQLContainerThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, containerName) 1177 if err != nil { 1178 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLContainerThroughput", nil, "Failure preparing request") 1179 return 1180 } 1181 1182 resp, err := client.GetSQLContainerThroughputSender(req) 1183 if err != nil { 1184 result.Response = autorest.Response{Response: resp} 1185 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLContainerThroughput", resp, "Failure sending request") 1186 return 1187 } 1188 1189 result, err = client.GetSQLContainerThroughputResponder(resp) 1190 if err != nil { 1191 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLContainerThroughput", resp, "Failure responding to request") 1192 return 1193 } 1194 1195 return 1196} 1197 1198// GetSQLContainerThroughputPreparer prepares the GetSQLContainerThroughput request. 1199func (client SQLResourcesClient) GetSQLContainerThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) { 1200 pathParameters := map[string]interface{}{ 1201 "accountName": autorest.Encode("path", accountName), 1202 "containerName": autorest.Encode("path", containerName), 1203 "databaseName": autorest.Encode("path", databaseName), 1204 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1205 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1206 } 1207 1208 const APIVersion = "2020-04-01" 1209 queryParameters := map[string]interface{}{ 1210 "api-version": APIVersion, 1211 } 1212 1213 preparer := autorest.CreatePreparer( 1214 autorest.AsGet(), 1215 autorest.WithBaseURL(client.BaseURI), 1216 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/throughputSettings/default", pathParameters), 1217 autorest.WithQueryParameters(queryParameters)) 1218 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1219} 1220 1221// GetSQLContainerThroughputSender sends the GetSQLContainerThroughput request. The method will close the 1222// http.Response Body if it receives an error. 1223func (client SQLResourcesClient) GetSQLContainerThroughputSender(req *http.Request) (*http.Response, error) { 1224 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1225} 1226 1227// GetSQLContainerThroughputResponder handles the response to the GetSQLContainerThroughput request. The method always 1228// closes the http.Response Body. 1229func (client SQLResourcesClient) GetSQLContainerThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) { 1230 err = autorest.Respond( 1231 resp, 1232 azure.WithErrorUnlessStatusCode(http.StatusOK), 1233 autorest.ByUnmarshallingJSON(&result), 1234 autorest.ByClosing()) 1235 result.Response = autorest.Response{Response: resp} 1236 return 1237} 1238 1239// GetSQLDatabase gets the SQL database under an existing Azure Cosmos DB database account with the provided name. 1240// Parameters: 1241// resourceGroupName - the name of the resource group. The name is case insensitive. 1242// accountName - cosmos DB database account name. 1243// databaseName - cosmos DB database name. 1244func (client SQLResourcesClient) GetSQLDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result SQLDatabaseGetResults, err error) { 1245 if tracing.IsEnabled() { 1246 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.GetSQLDatabase") 1247 defer func() { 1248 sc := -1 1249 if result.Response.Response != nil { 1250 sc = result.Response.Response.StatusCode 1251 } 1252 tracing.EndSpan(ctx, sc, err) 1253 }() 1254 } 1255 if err := validation.Validate([]validation.Validation{ 1256 {TargetValue: client.SubscriptionID, 1257 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1258 {TargetValue: resourceGroupName, 1259 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1260 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1261 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1262 {TargetValue: accountName, 1263 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1264 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1265 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1266 return result, validation.NewError("documentdb.SQLResourcesClient", "GetSQLDatabase", err.Error()) 1267 } 1268 1269 req, err := client.GetSQLDatabasePreparer(ctx, resourceGroupName, accountName, databaseName) 1270 if err != nil { 1271 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLDatabase", nil, "Failure preparing request") 1272 return 1273 } 1274 1275 resp, err := client.GetSQLDatabaseSender(req) 1276 if err != nil { 1277 result.Response = autorest.Response{Response: resp} 1278 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLDatabase", resp, "Failure sending request") 1279 return 1280 } 1281 1282 result, err = client.GetSQLDatabaseResponder(resp) 1283 if err != nil { 1284 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLDatabase", resp, "Failure responding to request") 1285 return 1286 } 1287 1288 return 1289} 1290 1291// GetSQLDatabasePreparer prepares the GetSQLDatabase request. 1292func (client SQLResourcesClient) GetSQLDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) { 1293 pathParameters := map[string]interface{}{ 1294 "accountName": autorest.Encode("path", accountName), 1295 "databaseName": autorest.Encode("path", databaseName), 1296 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1297 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1298 } 1299 1300 const APIVersion = "2020-04-01" 1301 queryParameters := map[string]interface{}{ 1302 "api-version": APIVersion, 1303 } 1304 1305 preparer := autorest.CreatePreparer( 1306 autorest.AsGet(), 1307 autorest.WithBaseURL(client.BaseURI), 1308 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}", pathParameters), 1309 autorest.WithQueryParameters(queryParameters)) 1310 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1311} 1312 1313// GetSQLDatabaseSender sends the GetSQLDatabase request. The method will close the 1314// http.Response Body if it receives an error. 1315func (client SQLResourcesClient) GetSQLDatabaseSender(req *http.Request) (*http.Response, error) { 1316 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1317} 1318 1319// GetSQLDatabaseResponder handles the response to the GetSQLDatabase request. The method always 1320// closes the http.Response Body. 1321func (client SQLResourcesClient) GetSQLDatabaseResponder(resp *http.Response) (result SQLDatabaseGetResults, err error) { 1322 err = autorest.Respond( 1323 resp, 1324 azure.WithErrorUnlessStatusCode(http.StatusOK), 1325 autorest.ByUnmarshallingJSON(&result), 1326 autorest.ByClosing()) 1327 result.Response = autorest.Response{Response: resp} 1328 return 1329} 1330 1331// GetSQLDatabaseThroughput gets the RUs per second of the SQL database under an existing Azure Cosmos DB database 1332// account with the provided name. 1333// Parameters: 1334// resourceGroupName - the name of the resource group. The name is case insensitive. 1335// accountName - cosmos DB database account name. 1336// databaseName - cosmos DB database name. 1337func (client SQLResourcesClient) GetSQLDatabaseThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result ThroughputSettingsGetResults, err error) { 1338 if tracing.IsEnabled() { 1339 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.GetSQLDatabaseThroughput") 1340 defer func() { 1341 sc := -1 1342 if result.Response.Response != nil { 1343 sc = result.Response.Response.StatusCode 1344 } 1345 tracing.EndSpan(ctx, sc, err) 1346 }() 1347 } 1348 if err := validation.Validate([]validation.Validation{ 1349 {TargetValue: client.SubscriptionID, 1350 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1351 {TargetValue: resourceGroupName, 1352 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1353 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1354 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1355 {TargetValue: accountName, 1356 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1357 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1358 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1359 return result, validation.NewError("documentdb.SQLResourcesClient", "GetSQLDatabaseThroughput", err.Error()) 1360 } 1361 1362 req, err := client.GetSQLDatabaseThroughputPreparer(ctx, resourceGroupName, accountName, databaseName) 1363 if err != nil { 1364 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLDatabaseThroughput", nil, "Failure preparing request") 1365 return 1366 } 1367 1368 resp, err := client.GetSQLDatabaseThroughputSender(req) 1369 if err != nil { 1370 result.Response = autorest.Response{Response: resp} 1371 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLDatabaseThroughput", resp, "Failure sending request") 1372 return 1373 } 1374 1375 result, err = client.GetSQLDatabaseThroughputResponder(resp) 1376 if err != nil { 1377 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLDatabaseThroughput", resp, "Failure responding to request") 1378 return 1379 } 1380 1381 return 1382} 1383 1384// GetSQLDatabaseThroughputPreparer prepares the GetSQLDatabaseThroughput request. 1385func (client SQLResourcesClient) GetSQLDatabaseThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) { 1386 pathParameters := map[string]interface{}{ 1387 "accountName": autorest.Encode("path", accountName), 1388 "databaseName": autorest.Encode("path", databaseName), 1389 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1390 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1391 } 1392 1393 const APIVersion = "2020-04-01" 1394 queryParameters := map[string]interface{}{ 1395 "api-version": APIVersion, 1396 } 1397 1398 preparer := autorest.CreatePreparer( 1399 autorest.AsGet(), 1400 autorest.WithBaseURL(client.BaseURI), 1401 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/throughputSettings/default", pathParameters), 1402 autorest.WithQueryParameters(queryParameters)) 1403 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1404} 1405 1406// GetSQLDatabaseThroughputSender sends the GetSQLDatabaseThroughput request. The method will close the 1407// http.Response Body if it receives an error. 1408func (client SQLResourcesClient) GetSQLDatabaseThroughputSender(req *http.Request) (*http.Response, error) { 1409 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1410} 1411 1412// GetSQLDatabaseThroughputResponder handles the response to the GetSQLDatabaseThroughput request. The method always 1413// closes the http.Response Body. 1414func (client SQLResourcesClient) GetSQLDatabaseThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) { 1415 err = autorest.Respond( 1416 resp, 1417 azure.WithErrorUnlessStatusCode(http.StatusOK), 1418 autorest.ByUnmarshallingJSON(&result), 1419 autorest.ByClosing()) 1420 result.Response = autorest.Response{Response: resp} 1421 return 1422} 1423 1424// GetSQLStoredProcedure gets the SQL storedProcedure under an existing Azure Cosmos DB database account. 1425// Parameters: 1426// resourceGroupName - the name of the resource group. The name is case insensitive. 1427// accountName - cosmos DB database account name. 1428// databaseName - cosmos DB database name. 1429// containerName - cosmos DB container name. 1430// storedProcedureName - cosmos DB storedProcedure name. 1431func (client SQLResourcesClient) GetSQLStoredProcedure(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, storedProcedureName string) (result SQLStoredProcedureGetResults, err error) { 1432 if tracing.IsEnabled() { 1433 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.GetSQLStoredProcedure") 1434 defer func() { 1435 sc := -1 1436 if result.Response.Response != nil { 1437 sc = result.Response.Response.StatusCode 1438 } 1439 tracing.EndSpan(ctx, sc, err) 1440 }() 1441 } 1442 if err := validation.Validate([]validation.Validation{ 1443 {TargetValue: client.SubscriptionID, 1444 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1445 {TargetValue: resourceGroupName, 1446 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1447 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1448 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1449 {TargetValue: accountName, 1450 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1451 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1452 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1453 return result, validation.NewError("documentdb.SQLResourcesClient", "GetSQLStoredProcedure", err.Error()) 1454 } 1455 1456 req, err := client.GetSQLStoredProcedurePreparer(ctx, resourceGroupName, accountName, databaseName, containerName, storedProcedureName) 1457 if err != nil { 1458 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLStoredProcedure", nil, "Failure preparing request") 1459 return 1460 } 1461 1462 resp, err := client.GetSQLStoredProcedureSender(req) 1463 if err != nil { 1464 result.Response = autorest.Response{Response: resp} 1465 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLStoredProcedure", resp, "Failure sending request") 1466 return 1467 } 1468 1469 result, err = client.GetSQLStoredProcedureResponder(resp) 1470 if err != nil { 1471 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLStoredProcedure", resp, "Failure responding to request") 1472 return 1473 } 1474 1475 return 1476} 1477 1478// GetSQLStoredProcedurePreparer prepares the GetSQLStoredProcedure request. 1479func (client SQLResourcesClient) GetSQLStoredProcedurePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, storedProcedureName string) (*http.Request, error) { 1480 pathParameters := map[string]interface{}{ 1481 "accountName": autorest.Encode("path", accountName), 1482 "containerName": autorest.Encode("path", containerName), 1483 "databaseName": autorest.Encode("path", databaseName), 1484 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1485 "storedProcedureName": autorest.Encode("path", storedProcedureName), 1486 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1487 } 1488 1489 const APIVersion = "2020-04-01" 1490 queryParameters := map[string]interface{}{ 1491 "api-version": APIVersion, 1492 } 1493 1494 preparer := autorest.CreatePreparer( 1495 autorest.AsGet(), 1496 autorest.WithBaseURL(client.BaseURI), 1497 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/storedProcedures/{storedProcedureName}", pathParameters), 1498 autorest.WithQueryParameters(queryParameters)) 1499 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1500} 1501 1502// GetSQLStoredProcedureSender sends the GetSQLStoredProcedure request. The method will close the 1503// http.Response Body if it receives an error. 1504func (client SQLResourcesClient) GetSQLStoredProcedureSender(req *http.Request) (*http.Response, error) { 1505 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1506} 1507 1508// GetSQLStoredProcedureResponder handles the response to the GetSQLStoredProcedure request. The method always 1509// closes the http.Response Body. 1510func (client SQLResourcesClient) GetSQLStoredProcedureResponder(resp *http.Response) (result SQLStoredProcedureGetResults, err error) { 1511 err = autorest.Respond( 1512 resp, 1513 azure.WithErrorUnlessStatusCode(http.StatusOK), 1514 autorest.ByUnmarshallingJSON(&result), 1515 autorest.ByClosing()) 1516 result.Response = autorest.Response{Response: resp} 1517 return 1518} 1519 1520// GetSQLTrigger gets the SQL trigger under an existing Azure Cosmos DB database account. 1521// Parameters: 1522// resourceGroupName - the name of the resource group. The name is case insensitive. 1523// accountName - cosmos DB database account name. 1524// databaseName - cosmos DB database name. 1525// containerName - cosmos DB container name. 1526// triggerName - cosmos DB trigger name. 1527func (client SQLResourcesClient) GetSQLTrigger(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, triggerName string) (result SQLTriggerGetResults, err error) { 1528 if tracing.IsEnabled() { 1529 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.GetSQLTrigger") 1530 defer func() { 1531 sc := -1 1532 if result.Response.Response != nil { 1533 sc = result.Response.Response.StatusCode 1534 } 1535 tracing.EndSpan(ctx, sc, err) 1536 }() 1537 } 1538 if err := validation.Validate([]validation.Validation{ 1539 {TargetValue: client.SubscriptionID, 1540 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1541 {TargetValue: resourceGroupName, 1542 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1543 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1544 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1545 {TargetValue: accountName, 1546 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1547 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1548 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1549 return result, validation.NewError("documentdb.SQLResourcesClient", "GetSQLTrigger", err.Error()) 1550 } 1551 1552 req, err := client.GetSQLTriggerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, triggerName) 1553 if err != nil { 1554 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLTrigger", nil, "Failure preparing request") 1555 return 1556 } 1557 1558 resp, err := client.GetSQLTriggerSender(req) 1559 if err != nil { 1560 result.Response = autorest.Response{Response: resp} 1561 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLTrigger", resp, "Failure sending request") 1562 return 1563 } 1564 1565 result, err = client.GetSQLTriggerResponder(resp) 1566 if err != nil { 1567 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLTrigger", resp, "Failure responding to request") 1568 return 1569 } 1570 1571 return 1572} 1573 1574// GetSQLTriggerPreparer prepares the GetSQLTrigger request. 1575func (client SQLResourcesClient) GetSQLTriggerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, triggerName string) (*http.Request, error) { 1576 pathParameters := map[string]interface{}{ 1577 "accountName": autorest.Encode("path", accountName), 1578 "containerName": autorest.Encode("path", containerName), 1579 "databaseName": autorest.Encode("path", databaseName), 1580 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1581 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1582 "triggerName": autorest.Encode("path", triggerName), 1583 } 1584 1585 const APIVersion = "2020-04-01" 1586 queryParameters := map[string]interface{}{ 1587 "api-version": APIVersion, 1588 } 1589 1590 preparer := autorest.CreatePreparer( 1591 autorest.AsGet(), 1592 autorest.WithBaseURL(client.BaseURI), 1593 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/triggers/{triggerName}", pathParameters), 1594 autorest.WithQueryParameters(queryParameters)) 1595 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1596} 1597 1598// GetSQLTriggerSender sends the GetSQLTrigger request. The method will close the 1599// http.Response Body if it receives an error. 1600func (client SQLResourcesClient) GetSQLTriggerSender(req *http.Request) (*http.Response, error) { 1601 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1602} 1603 1604// GetSQLTriggerResponder handles the response to the GetSQLTrigger request. The method always 1605// closes the http.Response Body. 1606func (client SQLResourcesClient) GetSQLTriggerResponder(resp *http.Response) (result SQLTriggerGetResults, err error) { 1607 err = autorest.Respond( 1608 resp, 1609 azure.WithErrorUnlessStatusCode(http.StatusOK), 1610 autorest.ByUnmarshallingJSON(&result), 1611 autorest.ByClosing()) 1612 result.Response = autorest.Response{Response: resp} 1613 return 1614} 1615 1616// GetSQLUserDefinedFunction gets the SQL userDefinedFunction under an existing Azure Cosmos DB database account. 1617// Parameters: 1618// resourceGroupName - the name of the resource group. The name is case insensitive. 1619// accountName - cosmos DB database account name. 1620// databaseName - cosmos DB database name. 1621// containerName - cosmos DB container name. 1622// userDefinedFunctionName - cosmos DB userDefinedFunction name. 1623func (client SQLResourcesClient) GetSQLUserDefinedFunction(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, userDefinedFunctionName string) (result SQLUserDefinedFunctionGetResults, err error) { 1624 if tracing.IsEnabled() { 1625 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.GetSQLUserDefinedFunction") 1626 defer func() { 1627 sc := -1 1628 if result.Response.Response != nil { 1629 sc = result.Response.Response.StatusCode 1630 } 1631 tracing.EndSpan(ctx, sc, err) 1632 }() 1633 } 1634 if err := validation.Validate([]validation.Validation{ 1635 {TargetValue: client.SubscriptionID, 1636 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1637 {TargetValue: resourceGroupName, 1638 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1639 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1640 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1641 {TargetValue: accountName, 1642 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1643 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1644 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1645 return result, validation.NewError("documentdb.SQLResourcesClient", "GetSQLUserDefinedFunction", err.Error()) 1646 } 1647 1648 req, err := client.GetSQLUserDefinedFunctionPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, userDefinedFunctionName) 1649 if err != nil { 1650 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLUserDefinedFunction", nil, "Failure preparing request") 1651 return 1652 } 1653 1654 resp, err := client.GetSQLUserDefinedFunctionSender(req) 1655 if err != nil { 1656 result.Response = autorest.Response{Response: resp} 1657 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLUserDefinedFunction", resp, "Failure sending request") 1658 return 1659 } 1660 1661 result, err = client.GetSQLUserDefinedFunctionResponder(resp) 1662 if err != nil { 1663 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "GetSQLUserDefinedFunction", resp, "Failure responding to request") 1664 return 1665 } 1666 1667 return 1668} 1669 1670// GetSQLUserDefinedFunctionPreparer prepares the GetSQLUserDefinedFunction request. 1671func (client SQLResourcesClient) GetSQLUserDefinedFunctionPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, userDefinedFunctionName string) (*http.Request, error) { 1672 pathParameters := map[string]interface{}{ 1673 "accountName": autorest.Encode("path", accountName), 1674 "containerName": autorest.Encode("path", containerName), 1675 "databaseName": autorest.Encode("path", databaseName), 1676 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1677 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1678 "userDefinedFunctionName": autorest.Encode("path", userDefinedFunctionName), 1679 } 1680 1681 const APIVersion = "2020-04-01" 1682 queryParameters := map[string]interface{}{ 1683 "api-version": APIVersion, 1684 } 1685 1686 preparer := autorest.CreatePreparer( 1687 autorest.AsGet(), 1688 autorest.WithBaseURL(client.BaseURI), 1689 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/userDefinedFunctions/{userDefinedFunctionName}", pathParameters), 1690 autorest.WithQueryParameters(queryParameters)) 1691 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1692} 1693 1694// GetSQLUserDefinedFunctionSender sends the GetSQLUserDefinedFunction request. The method will close the 1695// http.Response Body if it receives an error. 1696func (client SQLResourcesClient) GetSQLUserDefinedFunctionSender(req *http.Request) (*http.Response, error) { 1697 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1698} 1699 1700// GetSQLUserDefinedFunctionResponder handles the response to the GetSQLUserDefinedFunction request. The method always 1701// closes the http.Response Body. 1702func (client SQLResourcesClient) GetSQLUserDefinedFunctionResponder(resp *http.Response) (result SQLUserDefinedFunctionGetResults, err error) { 1703 err = autorest.Respond( 1704 resp, 1705 azure.WithErrorUnlessStatusCode(http.StatusOK), 1706 autorest.ByUnmarshallingJSON(&result), 1707 autorest.ByClosing()) 1708 result.Response = autorest.Response{Response: resp} 1709 return 1710} 1711 1712// ListSQLContainers lists the SQL container under an existing Azure Cosmos DB database account. 1713// Parameters: 1714// resourceGroupName - the name of the resource group. The name is case insensitive. 1715// accountName - cosmos DB database account name. 1716// databaseName - cosmos DB database name. 1717func (client SQLResourcesClient) ListSQLContainers(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result SQLContainerListResult, err error) { 1718 if tracing.IsEnabled() { 1719 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.ListSQLContainers") 1720 defer func() { 1721 sc := -1 1722 if result.Response.Response != nil { 1723 sc = result.Response.Response.StatusCode 1724 } 1725 tracing.EndSpan(ctx, sc, err) 1726 }() 1727 } 1728 if err := validation.Validate([]validation.Validation{ 1729 {TargetValue: client.SubscriptionID, 1730 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1731 {TargetValue: resourceGroupName, 1732 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1733 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1734 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1735 {TargetValue: accountName, 1736 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1737 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1738 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1739 return result, validation.NewError("documentdb.SQLResourcesClient", "ListSQLContainers", err.Error()) 1740 } 1741 1742 req, err := client.ListSQLContainersPreparer(ctx, resourceGroupName, accountName, databaseName) 1743 if err != nil { 1744 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLContainers", nil, "Failure preparing request") 1745 return 1746 } 1747 1748 resp, err := client.ListSQLContainersSender(req) 1749 if err != nil { 1750 result.Response = autorest.Response{Response: resp} 1751 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLContainers", resp, "Failure sending request") 1752 return 1753 } 1754 1755 result, err = client.ListSQLContainersResponder(resp) 1756 if err != nil { 1757 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLContainers", resp, "Failure responding to request") 1758 return 1759 } 1760 1761 return 1762} 1763 1764// ListSQLContainersPreparer prepares the ListSQLContainers request. 1765func (client SQLResourcesClient) ListSQLContainersPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) { 1766 pathParameters := map[string]interface{}{ 1767 "accountName": autorest.Encode("path", accountName), 1768 "databaseName": autorest.Encode("path", databaseName), 1769 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1770 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1771 } 1772 1773 const APIVersion = "2020-04-01" 1774 queryParameters := map[string]interface{}{ 1775 "api-version": APIVersion, 1776 } 1777 1778 preparer := autorest.CreatePreparer( 1779 autorest.AsGet(), 1780 autorest.WithBaseURL(client.BaseURI), 1781 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers", pathParameters), 1782 autorest.WithQueryParameters(queryParameters)) 1783 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1784} 1785 1786// ListSQLContainersSender sends the ListSQLContainers request. The method will close the 1787// http.Response Body if it receives an error. 1788func (client SQLResourcesClient) ListSQLContainersSender(req *http.Request) (*http.Response, error) { 1789 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1790} 1791 1792// ListSQLContainersResponder handles the response to the ListSQLContainers request. The method always 1793// closes the http.Response Body. 1794func (client SQLResourcesClient) ListSQLContainersResponder(resp *http.Response) (result SQLContainerListResult, err error) { 1795 err = autorest.Respond( 1796 resp, 1797 azure.WithErrorUnlessStatusCode(http.StatusOK), 1798 autorest.ByUnmarshallingJSON(&result), 1799 autorest.ByClosing()) 1800 result.Response = autorest.Response{Response: resp} 1801 return 1802} 1803 1804// ListSQLDatabases lists the SQL databases under an existing Azure Cosmos DB database account. 1805// Parameters: 1806// resourceGroupName - the name of the resource group. The name is case insensitive. 1807// accountName - cosmos DB database account name. 1808func (client SQLResourcesClient) ListSQLDatabases(ctx context.Context, resourceGroupName string, accountName string) (result SQLDatabaseListResult, err error) { 1809 if tracing.IsEnabled() { 1810 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.ListSQLDatabases") 1811 defer func() { 1812 sc := -1 1813 if result.Response.Response != nil { 1814 sc = result.Response.Response.StatusCode 1815 } 1816 tracing.EndSpan(ctx, sc, err) 1817 }() 1818 } 1819 if err := validation.Validate([]validation.Validation{ 1820 {TargetValue: client.SubscriptionID, 1821 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1822 {TargetValue: resourceGroupName, 1823 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1824 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1825 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1826 {TargetValue: accountName, 1827 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1828 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1829 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1830 return result, validation.NewError("documentdb.SQLResourcesClient", "ListSQLDatabases", err.Error()) 1831 } 1832 1833 req, err := client.ListSQLDatabasesPreparer(ctx, resourceGroupName, accountName) 1834 if err != nil { 1835 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLDatabases", nil, "Failure preparing request") 1836 return 1837 } 1838 1839 resp, err := client.ListSQLDatabasesSender(req) 1840 if err != nil { 1841 result.Response = autorest.Response{Response: resp} 1842 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLDatabases", resp, "Failure sending request") 1843 return 1844 } 1845 1846 result, err = client.ListSQLDatabasesResponder(resp) 1847 if err != nil { 1848 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLDatabases", resp, "Failure responding to request") 1849 return 1850 } 1851 1852 return 1853} 1854 1855// ListSQLDatabasesPreparer prepares the ListSQLDatabases request. 1856func (client SQLResourcesClient) ListSQLDatabasesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) { 1857 pathParameters := map[string]interface{}{ 1858 "accountName": autorest.Encode("path", accountName), 1859 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1860 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1861 } 1862 1863 const APIVersion = "2020-04-01" 1864 queryParameters := map[string]interface{}{ 1865 "api-version": APIVersion, 1866 } 1867 1868 preparer := autorest.CreatePreparer( 1869 autorest.AsGet(), 1870 autorest.WithBaseURL(client.BaseURI), 1871 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases", pathParameters), 1872 autorest.WithQueryParameters(queryParameters)) 1873 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1874} 1875 1876// ListSQLDatabasesSender sends the ListSQLDatabases request. The method will close the 1877// http.Response Body if it receives an error. 1878func (client SQLResourcesClient) ListSQLDatabasesSender(req *http.Request) (*http.Response, error) { 1879 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1880} 1881 1882// ListSQLDatabasesResponder handles the response to the ListSQLDatabases request. The method always 1883// closes the http.Response Body. 1884func (client SQLResourcesClient) ListSQLDatabasesResponder(resp *http.Response) (result SQLDatabaseListResult, err error) { 1885 err = autorest.Respond( 1886 resp, 1887 azure.WithErrorUnlessStatusCode(http.StatusOK), 1888 autorest.ByUnmarshallingJSON(&result), 1889 autorest.ByClosing()) 1890 result.Response = autorest.Response{Response: resp} 1891 return 1892} 1893 1894// ListSQLStoredProcedures lists the SQL storedProcedure under an existing Azure Cosmos DB database account. 1895// Parameters: 1896// resourceGroupName - the name of the resource group. The name is case insensitive. 1897// accountName - cosmos DB database account name. 1898// databaseName - cosmos DB database name. 1899// containerName - cosmos DB container name. 1900func (client SQLResourcesClient) ListSQLStoredProcedures(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result SQLStoredProcedureListResult, err error) { 1901 if tracing.IsEnabled() { 1902 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.ListSQLStoredProcedures") 1903 defer func() { 1904 sc := -1 1905 if result.Response.Response != nil { 1906 sc = result.Response.Response.StatusCode 1907 } 1908 tracing.EndSpan(ctx, sc, err) 1909 }() 1910 } 1911 if err := validation.Validate([]validation.Validation{ 1912 {TargetValue: client.SubscriptionID, 1913 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1914 {TargetValue: resourceGroupName, 1915 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1916 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1917 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 1918 {TargetValue: accountName, 1919 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1920 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 1921 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 1922 return result, validation.NewError("documentdb.SQLResourcesClient", "ListSQLStoredProcedures", err.Error()) 1923 } 1924 1925 req, err := client.ListSQLStoredProceduresPreparer(ctx, resourceGroupName, accountName, databaseName, containerName) 1926 if err != nil { 1927 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLStoredProcedures", nil, "Failure preparing request") 1928 return 1929 } 1930 1931 resp, err := client.ListSQLStoredProceduresSender(req) 1932 if err != nil { 1933 result.Response = autorest.Response{Response: resp} 1934 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLStoredProcedures", resp, "Failure sending request") 1935 return 1936 } 1937 1938 result, err = client.ListSQLStoredProceduresResponder(resp) 1939 if err != nil { 1940 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLStoredProcedures", resp, "Failure responding to request") 1941 return 1942 } 1943 1944 return 1945} 1946 1947// ListSQLStoredProceduresPreparer prepares the ListSQLStoredProcedures request. 1948func (client SQLResourcesClient) ListSQLStoredProceduresPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) { 1949 pathParameters := map[string]interface{}{ 1950 "accountName": autorest.Encode("path", accountName), 1951 "containerName": autorest.Encode("path", containerName), 1952 "databaseName": autorest.Encode("path", databaseName), 1953 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1954 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1955 } 1956 1957 const APIVersion = "2020-04-01" 1958 queryParameters := map[string]interface{}{ 1959 "api-version": APIVersion, 1960 } 1961 1962 preparer := autorest.CreatePreparer( 1963 autorest.AsGet(), 1964 autorest.WithBaseURL(client.BaseURI), 1965 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/storedProcedures", pathParameters), 1966 autorest.WithQueryParameters(queryParameters)) 1967 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1968} 1969 1970// ListSQLStoredProceduresSender sends the ListSQLStoredProcedures request. The method will close the 1971// http.Response Body if it receives an error. 1972func (client SQLResourcesClient) ListSQLStoredProceduresSender(req *http.Request) (*http.Response, error) { 1973 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1974} 1975 1976// ListSQLStoredProceduresResponder handles the response to the ListSQLStoredProcedures request. The method always 1977// closes the http.Response Body. 1978func (client SQLResourcesClient) ListSQLStoredProceduresResponder(resp *http.Response) (result SQLStoredProcedureListResult, err error) { 1979 err = autorest.Respond( 1980 resp, 1981 azure.WithErrorUnlessStatusCode(http.StatusOK), 1982 autorest.ByUnmarshallingJSON(&result), 1983 autorest.ByClosing()) 1984 result.Response = autorest.Response{Response: resp} 1985 return 1986} 1987 1988// ListSQLTriggers lists the SQL trigger under an existing Azure Cosmos DB database account. 1989// Parameters: 1990// resourceGroupName - the name of the resource group. The name is case insensitive. 1991// accountName - cosmos DB database account name. 1992// databaseName - cosmos DB database name. 1993// containerName - cosmos DB container name. 1994func (client SQLResourcesClient) ListSQLTriggers(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result SQLTriggerListResult, err error) { 1995 if tracing.IsEnabled() { 1996 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.ListSQLTriggers") 1997 defer func() { 1998 sc := -1 1999 if result.Response.Response != nil { 2000 sc = result.Response.Response.StatusCode 2001 } 2002 tracing.EndSpan(ctx, sc, err) 2003 }() 2004 } 2005 if err := validation.Validate([]validation.Validation{ 2006 {TargetValue: client.SubscriptionID, 2007 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 2008 {TargetValue: resourceGroupName, 2009 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2010 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2011 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 2012 {TargetValue: accountName, 2013 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 2014 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 2015 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 2016 return result, validation.NewError("documentdb.SQLResourcesClient", "ListSQLTriggers", err.Error()) 2017 } 2018 2019 req, err := client.ListSQLTriggersPreparer(ctx, resourceGroupName, accountName, databaseName, containerName) 2020 if err != nil { 2021 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLTriggers", nil, "Failure preparing request") 2022 return 2023 } 2024 2025 resp, err := client.ListSQLTriggersSender(req) 2026 if err != nil { 2027 result.Response = autorest.Response{Response: resp} 2028 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLTriggers", resp, "Failure sending request") 2029 return 2030 } 2031 2032 result, err = client.ListSQLTriggersResponder(resp) 2033 if err != nil { 2034 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLTriggers", resp, "Failure responding to request") 2035 return 2036 } 2037 2038 return 2039} 2040 2041// ListSQLTriggersPreparer prepares the ListSQLTriggers request. 2042func (client SQLResourcesClient) ListSQLTriggersPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) { 2043 pathParameters := map[string]interface{}{ 2044 "accountName": autorest.Encode("path", accountName), 2045 "containerName": autorest.Encode("path", containerName), 2046 "databaseName": autorest.Encode("path", databaseName), 2047 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2048 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2049 } 2050 2051 const APIVersion = "2020-04-01" 2052 queryParameters := map[string]interface{}{ 2053 "api-version": APIVersion, 2054 } 2055 2056 preparer := autorest.CreatePreparer( 2057 autorest.AsGet(), 2058 autorest.WithBaseURL(client.BaseURI), 2059 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/triggers", pathParameters), 2060 autorest.WithQueryParameters(queryParameters)) 2061 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2062} 2063 2064// ListSQLTriggersSender sends the ListSQLTriggers request. The method will close the 2065// http.Response Body if it receives an error. 2066func (client SQLResourcesClient) ListSQLTriggersSender(req *http.Request) (*http.Response, error) { 2067 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2068} 2069 2070// ListSQLTriggersResponder handles the response to the ListSQLTriggers request. The method always 2071// closes the http.Response Body. 2072func (client SQLResourcesClient) ListSQLTriggersResponder(resp *http.Response) (result SQLTriggerListResult, err error) { 2073 err = autorest.Respond( 2074 resp, 2075 azure.WithErrorUnlessStatusCode(http.StatusOK), 2076 autorest.ByUnmarshallingJSON(&result), 2077 autorest.ByClosing()) 2078 result.Response = autorest.Response{Response: resp} 2079 return 2080} 2081 2082// ListSQLUserDefinedFunctions lists the SQL userDefinedFunction under an existing Azure Cosmos DB database account. 2083// Parameters: 2084// resourceGroupName - the name of the resource group. The name is case insensitive. 2085// accountName - cosmos DB database account name. 2086// databaseName - cosmos DB database name. 2087// containerName - cosmos DB container name. 2088func (client SQLResourcesClient) ListSQLUserDefinedFunctions(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result SQLUserDefinedFunctionListResult, err error) { 2089 if tracing.IsEnabled() { 2090 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.ListSQLUserDefinedFunctions") 2091 defer func() { 2092 sc := -1 2093 if result.Response.Response != nil { 2094 sc = result.Response.Response.StatusCode 2095 } 2096 tracing.EndSpan(ctx, sc, err) 2097 }() 2098 } 2099 if err := validation.Validate([]validation.Validation{ 2100 {TargetValue: client.SubscriptionID, 2101 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 2102 {TargetValue: resourceGroupName, 2103 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2104 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2105 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 2106 {TargetValue: accountName, 2107 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 2108 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 2109 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 2110 return result, validation.NewError("documentdb.SQLResourcesClient", "ListSQLUserDefinedFunctions", err.Error()) 2111 } 2112 2113 req, err := client.ListSQLUserDefinedFunctionsPreparer(ctx, resourceGroupName, accountName, databaseName, containerName) 2114 if err != nil { 2115 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLUserDefinedFunctions", nil, "Failure preparing request") 2116 return 2117 } 2118 2119 resp, err := client.ListSQLUserDefinedFunctionsSender(req) 2120 if err != nil { 2121 result.Response = autorest.Response{Response: resp} 2122 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLUserDefinedFunctions", resp, "Failure sending request") 2123 return 2124 } 2125 2126 result, err = client.ListSQLUserDefinedFunctionsResponder(resp) 2127 if err != nil { 2128 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "ListSQLUserDefinedFunctions", resp, "Failure responding to request") 2129 return 2130 } 2131 2132 return 2133} 2134 2135// ListSQLUserDefinedFunctionsPreparer prepares the ListSQLUserDefinedFunctions request. 2136func (client SQLResourcesClient) ListSQLUserDefinedFunctionsPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) { 2137 pathParameters := map[string]interface{}{ 2138 "accountName": autorest.Encode("path", accountName), 2139 "containerName": autorest.Encode("path", containerName), 2140 "databaseName": autorest.Encode("path", databaseName), 2141 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2142 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2143 } 2144 2145 const APIVersion = "2020-04-01" 2146 queryParameters := map[string]interface{}{ 2147 "api-version": APIVersion, 2148 } 2149 2150 preparer := autorest.CreatePreparer( 2151 autorest.AsGet(), 2152 autorest.WithBaseURL(client.BaseURI), 2153 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/userDefinedFunctions", pathParameters), 2154 autorest.WithQueryParameters(queryParameters)) 2155 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2156} 2157 2158// ListSQLUserDefinedFunctionsSender sends the ListSQLUserDefinedFunctions request. The method will close the 2159// http.Response Body if it receives an error. 2160func (client SQLResourcesClient) ListSQLUserDefinedFunctionsSender(req *http.Request) (*http.Response, error) { 2161 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2162} 2163 2164// ListSQLUserDefinedFunctionsResponder handles the response to the ListSQLUserDefinedFunctions request. The method always 2165// closes the http.Response Body. 2166func (client SQLResourcesClient) ListSQLUserDefinedFunctionsResponder(resp *http.Response) (result SQLUserDefinedFunctionListResult, err error) { 2167 err = autorest.Respond( 2168 resp, 2169 azure.WithErrorUnlessStatusCode(http.StatusOK), 2170 autorest.ByUnmarshallingJSON(&result), 2171 autorest.ByClosing()) 2172 result.Response = autorest.Response{Response: resp} 2173 return 2174} 2175 2176// MigrateSQLContainerToAutoscale migrate an Azure Cosmos DB SQL container from manual throughput to autoscale 2177// Parameters: 2178// resourceGroupName - the name of the resource group. The name is case insensitive. 2179// accountName - cosmos DB database account name. 2180// databaseName - cosmos DB database name. 2181// containerName - cosmos DB container name. 2182func (client SQLResourcesClient) MigrateSQLContainerToAutoscale(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result SQLResourcesMigrateSQLContainerToAutoscaleFuture, err error) { 2183 if tracing.IsEnabled() { 2184 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.MigrateSQLContainerToAutoscale") 2185 defer func() { 2186 sc := -1 2187 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 2188 sc = result.FutureAPI.Response().StatusCode 2189 } 2190 tracing.EndSpan(ctx, sc, err) 2191 }() 2192 } 2193 if err := validation.Validate([]validation.Validation{ 2194 {TargetValue: client.SubscriptionID, 2195 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 2196 {TargetValue: resourceGroupName, 2197 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2198 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2199 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 2200 {TargetValue: accountName, 2201 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 2202 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 2203 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 2204 return result, validation.NewError("documentdb.SQLResourcesClient", "MigrateSQLContainerToAutoscale", err.Error()) 2205 } 2206 2207 req, err := client.MigrateSQLContainerToAutoscalePreparer(ctx, resourceGroupName, accountName, databaseName, containerName) 2208 if err != nil { 2209 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "MigrateSQLContainerToAutoscale", nil, "Failure preparing request") 2210 return 2211 } 2212 2213 result, err = client.MigrateSQLContainerToAutoscaleSender(req) 2214 if err != nil { 2215 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "MigrateSQLContainerToAutoscale", nil, "Failure sending request") 2216 return 2217 } 2218 2219 return 2220} 2221 2222// MigrateSQLContainerToAutoscalePreparer prepares the MigrateSQLContainerToAutoscale request. 2223func (client SQLResourcesClient) MigrateSQLContainerToAutoscalePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) { 2224 pathParameters := map[string]interface{}{ 2225 "accountName": autorest.Encode("path", accountName), 2226 "containerName": autorest.Encode("path", containerName), 2227 "databaseName": autorest.Encode("path", databaseName), 2228 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2229 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2230 } 2231 2232 const APIVersion = "2020-04-01" 2233 queryParameters := map[string]interface{}{ 2234 "api-version": APIVersion, 2235 } 2236 2237 preparer := autorest.CreatePreparer( 2238 autorest.AsPost(), 2239 autorest.WithBaseURL(client.BaseURI), 2240 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/throughputSettings/default/migrateToAutoscale", pathParameters), 2241 autorest.WithQueryParameters(queryParameters)) 2242 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2243} 2244 2245// MigrateSQLContainerToAutoscaleSender sends the MigrateSQLContainerToAutoscale request. The method will close the 2246// http.Response Body if it receives an error. 2247func (client SQLResourcesClient) MigrateSQLContainerToAutoscaleSender(req *http.Request) (future SQLResourcesMigrateSQLContainerToAutoscaleFuture, err error) { 2248 var resp *http.Response 2249 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2250 if err != nil { 2251 return 2252 } 2253 var azf azure.Future 2254 azf, err = azure.NewFutureFromResponse(resp) 2255 future.FutureAPI = &azf 2256 future.Result = future.result 2257 return 2258} 2259 2260// MigrateSQLContainerToAutoscaleResponder handles the response to the MigrateSQLContainerToAutoscale request. The method always 2261// closes the http.Response Body. 2262func (client SQLResourcesClient) MigrateSQLContainerToAutoscaleResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) { 2263 err = autorest.Respond( 2264 resp, 2265 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 2266 autorest.ByUnmarshallingJSON(&result), 2267 autorest.ByClosing()) 2268 result.Response = autorest.Response{Response: resp} 2269 return 2270} 2271 2272// MigrateSQLContainerToManualThroughput migrate an Azure Cosmos DB SQL container from autoscale to manual throughput 2273// Parameters: 2274// resourceGroupName - the name of the resource group. The name is case insensitive. 2275// accountName - cosmos DB database account name. 2276// databaseName - cosmos DB database name. 2277// containerName - cosmos DB container name. 2278func (client SQLResourcesClient) MigrateSQLContainerToManualThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result SQLResourcesMigrateSQLContainerToManualThroughputFuture, err error) { 2279 if tracing.IsEnabled() { 2280 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.MigrateSQLContainerToManualThroughput") 2281 defer func() { 2282 sc := -1 2283 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 2284 sc = result.FutureAPI.Response().StatusCode 2285 } 2286 tracing.EndSpan(ctx, sc, err) 2287 }() 2288 } 2289 if err := validation.Validate([]validation.Validation{ 2290 {TargetValue: client.SubscriptionID, 2291 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 2292 {TargetValue: resourceGroupName, 2293 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2294 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2295 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 2296 {TargetValue: accountName, 2297 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 2298 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 2299 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 2300 return result, validation.NewError("documentdb.SQLResourcesClient", "MigrateSQLContainerToManualThroughput", err.Error()) 2301 } 2302 2303 req, err := client.MigrateSQLContainerToManualThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, containerName) 2304 if err != nil { 2305 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "MigrateSQLContainerToManualThroughput", nil, "Failure preparing request") 2306 return 2307 } 2308 2309 result, err = client.MigrateSQLContainerToManualThroughputSender(req) 2310 if err != nil { 2311 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "MigrateSQLContainerToManualThroughput", nil, "Failure sending request") 2312 return 2313 } 2314 2315 return 2316} 2317 2318// MigrateSQLContainerToManualThroughputPreparer prepares the MigrateSQLContainerToManualThroughput request. 2319func (client SQLResourcesClient) MigrateSQLContainerToManualThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) { 2320 pathParameters := map[string]interface{}{ 2321 "accountName": autorest.Encode("path", accountName), 2322 "containerName": autorest.Encode("path", containerName), 2323 "databaseName": autorest.Encode("path", databaseName), 2324 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2325 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2326 } 2327 2328 const APIVersion = "2020-04-01" 2329 queryParameters := map[string]interface{}{ 2330 "api-version": APIVersion, 2331 } 2332 2333 preparer := autorest.CreatePreparer( 2334 autorest.AsPost(), 2335 autorest.WithBaseURL(client.BaseURI), 2336 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/throughputSettings/default/migrateToManualThroughput", pathParameters), 2337 autorest.WithQueryParameters(queryParameters)) 2338 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2339} 2340 2341// MigrateSQLContainerToManualThroughputSender sends the MigrateSQLContainerToManualThroughput request. The method will close the 2342// http.Response Body if it receives an error. 2343func (client SQLResourcesClient) MigrateSQLContainerToManualThroughputSender(req *http.Request) (future SQLResourcesMigrateSQLContainerToManualThroughputFuture, err error) { 2344 var resp *http.Response 2345 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2346 if err != nil { 2347 return 2348 } 2349 var azf azure.Future 2350 azf, err = azure.NewFutureFromResponse(resp) 2351 future.FutureAPI = &azf 2352 future.Result = future.result 2353 return 2354} 2355 2356// MigrateSQLContainerToManualThroughputResponder handles the response to the MigrateSQLContainerToManualThroughput request. The method always 2357// closes the http.Response Body. 2358func (client SQLResourcesClient) MigrateSQLContainerToManualThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) { 2359 err = autorest.Respond( 2360 resp, 2361 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 2362 autorest.ByUnmarshallingJSON(&result), 2363 autorest.ByClosing()) 2364 result.Response = autorest.Response{Response: resp} 2365 return 2366} 2367 2368// MigrateSQLDatabaseToAutoscale migrate an Azure Cosmos DB SQL database from manual throughput to autoscale 2369// Parameters: 2370// resourceGroupName - the name of the resource group. The name is case insensitive. 2371// accountName - cosmos DB database account name. 2372// databaseName - cosmos DB database name. 2373func (client SQLResourcesClient) MigrateSQLDatabaseToAutoscale(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result SQLResourcesMigrateSQLDatabaseToAutoscaleFuture, err error) { 2374 if tracing.IsEnabled() { 2375 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.MigrateSQLDatabaseToAutoscale") 2376 defer func() { 2377 sc := -1 2378 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 2379 sc = result.FutureAPI.Response().StatusCode 2380 } 2381 tracing.EndSpan(ctx, sc, err) 2382 }() 2383 } 2384 if err := validation.Validate([]validation.Validation{ 2385 {TargetValue: client.SubscriptionID, 2386 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 2387 {TargetValue: resourceGroupName, 2388 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2389 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2390 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 2391 {TargetValue: accountName, 2392 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 2393 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 2394 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 2395 return result, validation.NewError("documentdb.SQLResourcesClient", "MigrateSQLDatabaseToAutoscale", err.Error()) 2396 } 2397 2398 req, err := client.MigrateSQLDatabaseToAutoscalePreparer(ctx, resourceGroupName, accountName, databaseName) 2399 if err != nil { 2400 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "MigrateSQLDatabaseToAutoscale", nil, "Failure preparing request") 2401 return 2402 } 2403 2404 result, err = client.MigrateSQLDatabaseToAutoscaleSender(req) 2405 if err != nil { 2406 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "MigrateSQLDatabaseToAutoscale", nil, "Failure sending request") 2407 return 2408 } 2409 2410 return 2411} 2412 2413// MigrateSQLDatabaseToAutoscalePreparer prepares the MigrateSQLDatabaseToAutoscale request. 2414func (client SQLResourcesClient) MigrateSQLDatabaseToAutoscalePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) { 2415 pathParameters := map[string]interface{}{ 2416 "accountName": autorest.Encode("path", accountName), 2417 "databaseName": autorest.Encode("path", databaseName), 2418 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2419 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2420 } 2421 2422 const APIVersion = "2020-04-01" 2423 queryParameters := map[string]interface{}{ 2424 "api-version": APIVersion, 2425 } 2426 2427 preparer := autorest.CreatePreparer( 2428 autorest.AsPost(), 2429 autorest.WithBaseURL(client.BaseURI), 2430 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/throughputSettings/default/migrateToAutoscale", pathParameters), 2431 autorest.WithQueryParameters(queryParameters)) 2432 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2433} 2434 2435// MigrateSQLDatabaseToAutoscaleSender sends the MigrateSQLDatabaseToAutoscale request. The method will close the 2436// http.Response Body if it receives an error. 2437func (client SQLResourcesClient) MigrateSQLDatabaseToAutoscaleSender(req *http.Request) (future SQLResourcesMigrateSQLDatabaseToAutoscaleFuture, err error) { 2438 var resp *http.Response 2439 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2440 if err != nil { 2441 return 2442 } 2443 var azf azure.Future 2444 azf, err = azure.NewFutureFromResponse(resp) 2445 future.FutureAPI = &azf 2446 future.Result = future.result 2447 return 2448} 2449 2450// MigrateSQLDatabaseToAutoscaleResponder handles the response to the MigrateSQLDatabaseToAutoscale request. The method always 2451// closes the http.Response Body. 2452func (client SQLResourcesClient) MigrateSQLDatabaseToAutoscaleResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) { 2453 err = autorest.Respond( 2454 resp, 2455 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 2456 autorest.ByUnmarshallingJSON(&result), 2457 autorest.ByClosing()) 2458 result.Response = autorest.Response{Response: resp} 2459 return 2460} 2461 2462// MigrateSQLDatabaseToManualThroughput migrate an Azure Cosmos DB SQL database from autoscale to manual throughput 2463// Parameters: 2464// resourceGroupName - the name of the resource group. The name is case insensitive. 2465// accountName - cosmos DB database account name. 2466// databaseName - cosmos DB database name. 2467func (client SQLResourcesClient) MigrateSQLDatabaseToManualThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result SQLResourcesMigrateSQLDatabaseToManualThroughputFuture, err error) { 2468 if tracing.IsEnabled() { 2469 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.MigrateSQLDatabaseToManualThroughput") 2470 defer func() { 2471 sc := -1 2472 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 2473 sc = result.FutureAPI.Response().StatusCode 2474 } 2475 tracing.EndSpan(ctx, sc, err) 2476 }() 2477 } 2478 if err := validation.Validate([]validation.Validation{ 2479 {TargetValue: client.SubscriptionID, 2480 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 2481 {TargetValue: resourceGroupName, 2482 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2483 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2484 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 2485 {TargetValue: accountName, 2486 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 2487 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 2488 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil { 2489 return result, validation.NewError("documentdb.SQLResourcesClient", "MigrateSQLDatabaseToManualThroughput", err.Error()) 2490 } 2491 2492 req, err := client.MigrateSQLDatabaseToManualThroughputPreparer(ctx, resourceGroupName, accountName, databaseName) 2493 if err != nil { 2494 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "MigrateSQLDatabaseToManualThroughput", nil, "Failure preparing request") 2495 return 2496 } 2497 2498 result, err = client.MigrateSQLDatabaseToManualThroughputSender(req) 2499 if err != nil { 2500 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "MigrateSQLDatabaseToManualThroughput", nil, "Failure sending request") 2501 return 2502 } 2503 2504 return 2505} 2506 2507// MigrateSQLDatabaseToManualThroughputPreparer prepares the MigrateSQLDatabaseToManualThroughput request. 2508func (client SQLResourcesClient) MigrateSQLDatabaseToManualThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) { 2509 pathParameters := map[string]interface{}{ 2510 "accountName": autorest.Encode("path", accountName), 2511 "databaseName": autorest.Encode("path", databaseName), 2512 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2513 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2514 } 2515 2516 const APIVersion = "2020-04-01" 2517 queryParameters := map[string]interface{}{ 2518 "api-version": APIVersion, 2519 } 2520 2521 preparer := autorest.CreatePreparer( 2522 autorest.AsPost(), 2523 autorest.WithBaseURL(client.BaseURI), 2524 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/throughputSettings/default/migrateToManualThroughput", pathParameters), 2525 autorest.WithQueryParameters(queryParameters)) 2526 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2527} 2528 2529// MigrateSQLDatabaseToManualThroughputSender sends the MigrateSQLDatabaseToManualThroughput request. The method will close the 2530// http.Response Body if it receives an error. 2531func (client SQLResourcesClient) MigrateSQLDatabaseToManualThroughputSender(req *http.Request) (future SQLResourcesMigrateSQLDatabaseToManualThroughputFuture, err error) { 2532 var resp *http.Response 2533 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2534 if err != nil { 2535 return 2536 } 2537 var azf azure.Future 2538 azf, err = azure.NewFutureFromResponse(resp) 2539 future.FutureAPI = &azf 2540 future.Result = future.result 2541 return 2542} 2543 2544// MigrateSQLDatabaseToManualThroughputResponder handles the response to the MigrateSQLDatabaseToManualThroughput request. The method always 2545// closes the http.Response Body. 2546func (client SQLResourcesClient) MigrateSQLDatabaseToManualThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) { 2547 err = autorest.Respond( 2548 resp, 2549 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 2550 autorest.ByUnmarshallingJSON(&result), 2551 autorest.ByClosing()) 2552 result.Response = autorest.Response{Response: resp} 2553 return 2554} 2555 2556// UpdateSQLContainerThroughput update RUs per second of an Azure Cosmos DB SQL container 2557// Parameters: 2558// resourceGroupName - the name of the resource group. The name is case insensitive. 2559// accountName - cosmos DB database account name. 2560// databaseName - cosmos DB database name. 2561// containerName - cosmos DB container name. 2562// updateThroughputParameters - the parameters to provide for the RUs per second of the current SQL container. 2563func (client SQLResourcesClient) UpdateSQLContainerThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, updateThroughputParameters ThroughputSettingsUpdateParameters) (result SQLResourcesUpdateSQLContainerThroughputFuture, err error) { 2564 if tracing.IsEnabled() { 2565 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.UpdateSQLContainerThroughput") 2566 defer func() { 2567 sc := -1 2568 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 2569 sc = result.FutureAPI.Response().StatusCode 2570 } 2571 tracing.EndSpan(ctx, sc, err) 2572 }() 2573 } 2574 if err := validation.Validate([]validation.Validation{ 2575 {TargetValue: client.SubscriptionID, 2576 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 2577 {TargetValue: resourceGroupName, 2578 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2579 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2580 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 2581 {TargetValue: accountName, 2582 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 2583 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 2584 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}, 2585 {TargetValue: updateThroughputParameters, 2586 Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties", Name: validation.Null, Rule: true, 2587 Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource", Name: validation.Null, Rule: true, 2588 Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource.AutoscaleSettings", Name: validation.Null, Rule: false, 2589 Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource.AutoscaleSettings.MaxThroughput", Name: validation.Null, Rule: true, Chain: nil}}}, 2590 }}, 2591 }}}}}); err != nil { 2592 return result, validation.NewError("documentdb.SQLResourcesClient", "UpdateSQLContainerThroughput", err.Error()) 2593 } 2594 2595 req, err := client.UpdateSQLContainerThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, updateThroughputParameters) 2596 if err != nil { 2597 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "UpdateSQLContainerThroughput", nil, "Failure preparing request") 2598 return 2599 } 2600 2601 result, err = client.UpdateSQLContainerThroughputSender(req) 2602 if err != nil { 2603 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "UpdateSQLContainerThroughput", nil, "Failure sending request") 2604 return 2605 } 2606 2607 return 2608} 2609 2610// UpdateSQLContainerThroughputPreparer prepares the UpdateSQLContainerThroughput request. 2611func (client SQLResourcesClient) UpdateSQLContainerThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, updateThroughputParameters ThroughputSettingsUpdateParameters) (*http.Request, error) { 2612 pathParameters := map[string]interface{}{ 2613 "accountName": autorest.Encode("path", accountName), 2614 "containerName": autorest.Encode("path", containerName), 2615 "databaseName": autorest.Encode("path", databaseName), 2616 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2617 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2618 } 2619 2620 const APIVersion = "2020-04-01" 2621 queryParameters := map[string]interface{}{ 2622 "api-version": APIVersion, 2623 } 2624 2625 preparer := autorest.CreatePreparer( 2626 autorest.AsContentType("application/json; charset=utf-8"), 2627 autorest.AsPut(), 2628 autorest.WithBaseURL(client.BaseURI), 2629 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/containers/{containerName}/throughputSettings/default", pathParameters), 2630 autorest.WithJSON(updateThroughputParameters), 2631 autorest.WithQueryParameters(queryParameters)) 2632 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2633} 2634 2635// UpdateSQLContainerThroughputSender sends the UpdateSQLContainerThroughput request. The method will close the 2636// http.Response Body if it receives an error. 2637func (client SQLResourcesClient) UpdateSQLContainerThroughputSender(req *http.Request) (future SQLResourcesUpdateSQLContainerThroughputFuture, err error) { 2638 var resp *http.Response 2639 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2640 if err != nil { 2641 return 2642 } 2643 var azf azure.Future 2644 azf, err = azure.NewFutureFromResponse(resp) 2645 future.FutureAPI = &azf 2646 future.Result = future.result 2647 return 2648} 2649 2650// UpdateSQLContainerThroughputResponder handles the response to the UpdateSQLContainerThroughput request. The method always 2651// closes the http.Response Body. 2652func (client SQLResourcesClient) UpdateSQLContainerThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) { 2653 err = autorest.Respond( 2654 resp, 2655 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 2656 autorest.ByUnmarshallingJSON(&result), 2657 autorest.ByClosing()) 2658 result.Response = autorest.Response{Response: resp} 2659 return 2660} 2661 2662// UpdateSQLDatabaseThroughput update RUs per second of an Azure Cosmos DB SQL database 2663// Parameters: 2664// resourceGroupName - the name of the resource group. The name is case insensitive. 2665// accountName - cosmos DB database account name. 2666// databaseName - cosmos DB database name. 2667// updateThroughputParameters - the parameters to provide for the RUs per second of the current SQL database. 2668func (client SQLResourcesClient) UpdateSQLDatabaseThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, updateThroughputParameters ThroughputSettingsUpdateParameters) (result SQLResourcesUpdateSQLDatabaseThroughputFuture, err error) { 2669 if tracing.IsEnabled() { 2670 ctx = tracing.StartSpan(ctx, fqdn+"/SQLResourcesClient.UpdateSQLDatabaseThroughput") 2671 defer func() { 2672 sc := -1 2673 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 2674 sc = result.FutureAPI.Response().StatusCode 2675 } 2676 tracing.EndSpan(ctx, sc, err) 2677 }() 2678 } 2679 if err := validation.Validate([]validation.Validation{ 2680 {TargetValue: client.SubscriptionID, 2681 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 2682 {TargetValue: resourceGroupName, 2683 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2684 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2685 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 2686 {TargetValue: accountName, 2687 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 2688 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 2689 {Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}, 2690 {TargetValue: updateThroughputParameters, 2691 Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties", Name: validation.Null, Rule: true, 2692 Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource", Name: validation.Null, Rule: true, 2693 Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource.AutoscaleSettings", Name: validation.Null, Rule: false, 2694 Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource.AutoscaleSettings.MaxThroughput", Name: validation.Null, Rule: true, Chain: nil}}}, 2695 }}, 2696 }}}}}); err != nil { 2697 return result, validation.NewError("documentdb.SQLResourcesClient", "UpdateSQLDatabaseThroughput", err.Error()) 2698 } 2699 2700 req, err := client.UpdateSQLDatabaseThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, updateThroughputParameters) 2701 if err != nil { 2702 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "UpdateSQLDatabaseThroughput", nil, "Failure preparing request") 2703 return 2704 } 2705 2706 result, err = client.UpdateSQLDatabaseThroughputSender(req) 2707 if err != nil { 2708 err = autorest.NewErrorWithError(err, "documentdb.SQLResourcesClient", "UpdateSQLDatabaseThroughput", nil, "Failure sending request") 2709 return 2710 } 2711 2712 return 2713} 2714 2715// UpdateSQLDatabaseThroughputPreparer prepares the UpdateSQLDatabaseThroughput request. 2716func (client SQLResourcesClient) UpdateSQLDatabaseThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, updateThroughputParameters ThroughputSettingsUpdateParameters) (*http.Request, error) { 2717 pathParameters := map[string]interface{}{ 2718 "accountName": autorest.Encode("path", accountName), 2719 "databaseName": autorest.Encode("path", databaseName), 2720 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2721 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2722 } 2723 2724 const APIVersion = "2020-04-01" 2725 queryParameters := map[string]interface{}{ 2726 "api-version": APIVersion, 2727 } 2728 2729 preparer := autorest.CreatePreparer( 2730 autorest.AsContentType("application/json; charset=utf-8"), 2731 autorest.AsPut(), 2732 autorest.WithBaseURL(client.BaseURI), 2733 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/sqlDatabases/{databaseName}/throughputSettings/default", pathParameters), 2734 autorest.WithJSON(updateThroughputParameters), 2735 autorest.WithQueryParameters(queryParameters)) 2736 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2737} 2738 2739// UpdateSQLDatabaseThroughputSender sends the UpdateSQLDatabaseThroughput request. The method will close the 2740// http.Response Body if it receives an error. 2741func (client SQLResourcesClient) UpdateSQLDatabaseThroughputSender(req *http.Request) (future SQLResourcesUpdateSQLDatabaseThroughputFuture, err error) { 2742 var resp *http.Response 2743 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2744 if err != nil { 2745 return 2746 } 2747 var azf azure.Future 2748 azf, err = azure.NewFutureFromResponse(resp) 2749 future.FutureAPI = &azf 2750 future.Result = future.result 2751 return 2752} 2753 2754// UpdateSQLDatabaseThroughputResponder handles the response to the UpdateSQLDatabaseThroughput request. The method always 2755// closes the http.Response Body. 2756func (client SQLResourcesClient) UpdateSQLDatabaseThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) { 2757 err = autorest.Respond( 2758 resp, 2759 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 2760 autorest.ByUnmarshallingJSON(&result), 2761 autorest.ByClosing()) 2762 result.Response = autorest.Response{Response: resp} 2763 return 2764} 2765