Source file src/github.com/Azure/azure-sdk-for-go/services/cosmos-db/mgmt/2019-08-01/documentdb/sqlresources.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cosmos-db/mgmt/2019-08-01/documentdb

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

View as plain text