cassandraresources.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  // CassandraResourcesClient is the azure Cosmos DB Database Service Resource Provider REST API
    19  type CassandraResourcesClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewCassandraResourcesClient creates an instance of the CassandraResourcesClient client.
    24  func NewCassandraResourcesClient(subscriptionID string) CassandraResourcesClient {
    25  	return NewCassandraResourcesClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewCassandraResourcesClientWithBaseURI creates an instance of the CassandraResourcesClient client using a custom
    29  // endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
    30  // stack).
    31  func NewCassandraResourcesClientWithBaseURI(baseURI string, subscriptionID string) CassandraResourcesClient {
    32  	return CassandraResourcesClient{NewWithBaseURI(baseURI, subscriptionID)}
    33  }
    34  
    35  // CreateUpdateCassandraKeyspace create or update an Azure Cosmos DB Cassandra keyspace
    36  // Parameters:
    37  // resourceGroupName - name of an Azure resource group.
    38  // accountName - cosmos DB database account name.
    39  // keyspaceName - cosmos DB keyspace name.
    40  // createUpdateCassandraKeyspaceParameters - the parameters to provide for the current Cassandra keyspace.
    41  func (client CassandraResourcesClient) CreateUpdateCassandraKeyspace(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, createUpdateCassandraKeyspaceParameters CassandraKeyspaceCreateUpdateParameters) (result CassandraResourcesCreateUpdateCassandraKeyspaceFuture, err error) {
    42  	if tracing.IsEnabled() {
    43  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.CreateUpdateCassandraKeyspace")
    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: createUpdateCassandraKeyspaceParameters,
    64  			Constraints: []validation.Constraint{{Target: "createUpdateCassandraKeyspaceParameters.CassandraKeyspaceCreateUpdateProperties", Name: validation.Null, Rule: true,
    65  				Chain: []validation.Constraint{{Target: "createUpdateCassandraKeyspaceParameters.CassandraKeyspaceCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
    66  					Chain: []validation.Constraint{{Target: "createUpdateCassandraKeyspaceParameters.CassandraKeyspaceCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
    67  					{Target: "createUpdateCassandraKeyspaceParameters.CassandraKeyspaceCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
    68  				}}}}}); err != nil {
    69  		return result, validation.NewError("documentdb.CassandraResourcesClient", "CreateUpdateCassandraKeyspace", err.Error())
    70  	}
    71  
    72  	req, err := client.CreateUpdateCassandraKeyspacePreparer(ctx, resourceGroupName, accountName, keyspaceName, createUpdateCassandraKeyspaceParameters)
    73  	if err != nil {
    74  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "CreateUpdateCassandraKeyspace", nil, "Failure preparing request")
    75  		return
    76  	}
    77  
    78  	result, err = client.CreateUpdateCassandraKeyspaceSender(req)
    79  	if err != nil {
    80  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "CreateUpdateCassandraKeyspace", result.Response(), "Failure sending request")
    81  		return
    82  	}
    83  
    84  	return
    85  }
    86  
    87  // CreateUpdateCassandraKeyspacePreparer prepares the CreateUpdateCassandraKeyspace request.
    88  func (client CassandraResourcesClient) CreateUpdateCassandraKeyspacePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, createUpdateCassandraKeyspaceParameters CassandraKeyspaceCreateUpdateParameters) (*http.Request, error) {
    89  	pathParameters := map[string]interface{}{
    90  		"accountName":       autorest.Encode("path", accountName),
    91  		"keyspaceName":      autorest.Encode("path", keyspaceName),
    92  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    93  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    94  	}
    95  
    96  	const APIVersion = "2019-08-01"
    97  	queryParameters := map[string]interface{}{
    98  		"api-version": APIVersion,
    99  	}
   100  
   101  	preparer := autorest.CreatePreparer(
   102  		autorest.AsContentType("application/json; charset=utf-8"),
   103  		autorest.AsPut(),
   104  		autorest.WithBaseURL(client.BaseURI),
   105  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}", pathParameters),
   106  		autorest.WithJSON(createUpdateCassandraKeyspaceParameters),
   107  		autorest.WithQueryParameters(queryParameters))
   108  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   109  }
   110  
   111  // CreateUpdateCassandraKeyspaceSender sends the CreateUpdateCassandraKeyspace request. The method will close the
   112  // http.Response Body if it receives an error.
   113  func (client CassandraResourcesClient) CreateUpdateCassandraKeyspaceSender(req *http.Request) (future CassandraResourcesCreateUpdateCassandraKeyspaceFuture, err error) {
   114  	var resp *http.Response
   115  	future.FutureAPI = &azure.Future{}
   116  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   117  	if err != nil {
   118  		return
   119  	}
   120  	var azf azure.Future
   121  	azf, err = azure.NewFutureFromResponse(resp)
   122  	future.FutureAPI = &azf
   123  	future.Result = future.result
   124  	return
   125  }
   126  
   127  // CreateUpdateCassandraKeyspaceResponder handles the response to the CreateUpdateCassandraKeyspace request. The method always
   128  // closes the http.Response Body.
   129  func (client CassandraResourcesClient) CreateUpdateCassandraKeyspaceResponder(resp *http.Response) (result CassandraKeyspaceGetResults, err error) {
   130  	err = autorest.Respond(
   131  		resp,
   132  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   133  		autorest.ByUnmarshallingJSON(&result),
   134  		autorest.ByClosing())
   135  	result.Response = autorest.Response{Response: resp}
   136  	return
   137  }
   138  
   139  // CreateUpdateCassandraTable create or update an Azure Cosmos DB Cassandra Table
   140  // Parameters:
   141  // resourceGroupName - name of an Azure resource group.
   142  // accountName - cosmos DB database account name.
   143  // keyspaceName - cosmos DB keyspace name.
   144  // tableName - cosmos DB table name.
   145  // createUpdateCassandraTableParameters - the parameters to provide for the current Cassandra Table.
   146  func (client CassandraResourcesClient) CreateUpdateCassandraTable(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string, createUpdateCassandraTableParameters CassandraTableCreateUpdateParameters) (result CassandraResourcesCreateUpdateCassandraTableFuture, err error) {
   147  	if tracing.IsEnabled() {
   148  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.CreateUpdateCassandraTable")
   149  		defer func() {
   150  			sc := -1
   151  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   152  				sc = result.FutureAPI.Response().StatusCode
   153  			}
   154  			tracing.EndSpan(ctx, sc, err)
   155  		}()
   156  	}
   157  	if err := validation.Validate([]validation.Validation{
   158  		{TargetValue: client.SubscriptionID,
   159  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   160  		{TargetValue: resourceGroupName,
   161  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   162  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   163  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   164  		{TargetValue: accountName,
   165  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   166  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   167  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   168  		{TargetValue: createUpdateCassandraTableParameters,
   169  			Constraints: []validation.Constraint{{Target: "createUpdateCassandraTableParameters.CassandraTableCreateUpdateProperties", Name: validation.Null, Rule: true,
   170  				Chain: []validation.Constraint{{Target: "createUpdateCassandraTableParameters.CassandraTableCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   171  					Chain: []validation.Constraint{{Target: "createUpdateCassandraTableParameters.CassandraTableCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   172  					{Target: "createUpdateCassandraTableParameters.CassandraTableCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   173  				}}}}}); err != nil {
   174  		return result, validation.NewError("documentdb.CassandraResourcesClient", "CreateUpdateCassandraTable", err.Error())
   175  	}
   176  
   177  	req, err := client.CreateUpdateCassandraTablePreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName, createUpdateCassandraTableParameters)
   178  	if err != nil {
   179  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "CreateUpdateCassandraTable", nil, "Failure preparing request")
   180  		return
   181  	}
   182  
   183  	result, err = client.CreateUpdateCassandraTableSender(req)
   184  	if err != nil {
   185  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "CreateUpdateCassandraTable", result.Response(), "Failure sending request")
   186  		return
   187  	}
   188  
   189  	return
   190  }
   191  
   192  // CreateUpdateCassandraTablePreparer prepares the CreateUpdateCassandraTable request.
   193  func (client CassandraResourcesClient) CreateUpdateCassandraTablePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string, createUpdateCassandraTableParameters CassandraTableCreateUpdateParameters) (*http.Request, error) {
   194  	pathParameters := map[string]interface{}{
   195  		"accountName":       autorest.Encode("path", accountName),
   196  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   197  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   198  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   199  		"tableName":         autorest.Encode("path", tableName),
   200  	}
   201  
   202  	const APIVersion = "2019-08-01"
   203  	queryParameters := map[string]interface{}{
   204  		"api-version": APIVersion,
   205  	}
   206  
   207  	preparer := autorest.CreatePreparer(
   208  		autorest.AsContentType("application/json; charset=utf-8"),
   209  		autorest.AsPut(),
   210  		autorest.WithBaseURL(client.BaseURI),
   211  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}/tables/{tableName}", pathParameters),
   212  		autorest.WithJSON(createUpdateCassandraTableParameters),
   213  		autorest.WithQueryParameters(queryParameters))
   214  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   215  }
   216  
   217  // CreateUpdateCassandraTableSender sends the CreateUpdateCassandraTable request. The method will close the
   218  // http.Response Body if it receives an error.
   219  func (client CassandraResourcesClient) CreateUpdateCassandraTableSender(req *http.Request) (future CassandraResourcesCreateUpdateCassandraTableFuture, err error) {
   220  	var resp *http.Response
   221  	future.FutureAPI = &azure.Future{}
   222  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   223  	if err != nil {
   224  		return
   225  	}
   226  	var azf azure.Future
   227  	azf, err = azure.NewFutureFromResponse(resp)
   228  	future.FutureAPI = &azf
   229  	future.Result = future.result
   230  	return
   231  }
   232  
   233  // CreateUpdateCassandraTableResponder handles the response to the CreateUpdateCassandraTable request. The method always
   234  // closes the http.Response Body.
   235  func (client CassandraResourcesClient) CreateUpdateCassandraTableResponder(resp *http.Response) (result CassandraTableGetResults, err error) {
   236  	err = autorest.Respond(
   237  		resp,
   238  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   239  		autorest.ByUnmarshallingJSON(&result),
   240  		autorest.ByClosing())
   241  	result.Response = autorest.Response{Response: resp}
   242  	return
   243  }
   244  
   245  // DeleteCassandraKeyspace deletes an existing Azure Cosmos DB Cassandra keyspace.
   246  // Parameters:
   247  // resourceGroupName - name of an Azure resource group.
   248  // accountName - cosmos DB database account name.
   249  // keyspaceName - cosmos DB keyspace name.
   250  func (client CassandraResourcesClient) DeleteCassandraKeyspace(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (result CassandraResourcesDeleteCassandraKeyspaceFuture, err error) {
   251  	if tracing.IsEnabled() {
   252  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.DeleteCassandraKeyspace")
   253  		defer func() {
   254  			sc := -1
   255  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   256  				sc = result.FutureAPI.Response().StatusCode
   257  			}
   258  			tracing.EndSpan(ctx, sc, err)
   259  		}()
   260  	}
   261  	if err := validation.Validate([]validation.Validation{
   262  		{TargetValue: client.SubscriptionID,
   263  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   264  		{TargetValue: resourceGroupName,
   265  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   266  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   267  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   268  		{TargetValue: accountName,
   269  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   270  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   271  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   272  		return result, validation.NewError("documentdb.CassandraResourcesClient", "DeleteCassandraKeyspace", err.Error())
   273  	}
   274  
   275  	req, err := client.DeleteCassandraKeyspacePreparer(ctx, resourceGroupName, accountName, keyspaceName)
   276  	if err != nil {
   277  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "DeleteCassandraKeyspace", nil, "Failure preparing request")
   278  		return
   279  	}
   280  
   281  	result, err = client.DeleteCassandraKeyspaceSender(req)
   282  	if err != nil {
   283  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "DeleteCassandraKeyspace", result.Response(), "Failure sending request")
   284  		return
   285  	}
   286  
   287  	return
   288  }
   289  
   290  // DeleteCassandraKeyspacePreparer prepares the DeleteCassandraKeyspace request.
   291  func (client CassandraResourcesClient) DeleteCassandraKeyspacePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (*http.Request, error) {
   292  	pathParameters := map[string]interface{}{
   293  		"accountName":       autorest.Encode("path", accountName),
   294  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   295  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   296  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   297  	}
   298  
   299  	const APIVersion = "2019-08-01"
   300  	queryParameters := map[string]interface{}{
   301  		"api-version": APIVersion,
   302  	}
   303  
   304  	preparer := autorest.CreatePreparer(
   305  		autorest.AsDelete(),
   306  		autorest.WithBaseURL(client.BaseURI),
   307  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}", pathParameters),
   308  		autorest.WithQueryParameters(queryParameters))
   309  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   310  }
   311  
   312  // DeleteCassandraKeyspaceSender sends the DeleteCassandraKeyspace request. The method will close the
   313  // http.Response Body if it receives an error.
   314  func (client CassandraResourcesClient) DeleteCassandraKeyspaceSender(req *http.Request) (future CassandraResourcesDeleteCassandraKeyspaceFuture, err error) {
   315  	var resp *http.Response
   316  	future.FutureAPI = &azure.Future{}
   317  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   318  	if err != nil {
   319  		return
   320  	}
   321  	var azf azure.Future
   322  	azf, err = azure.NewFutureFromResponse(resp)
   323  	future.FutureAPI = &azf
   324  	future.Result = future.result
   325  	return
   326  }
   327  
   328  // DeleteCassandraKeyspaceResponder handles the response to the DeleteCassandraKeyspace request. The method always
   329  // closes the http.Response Body.
   330  func (client CassandraResourcesClient) DeleteCassandraKeyspaceResponder(resp *http.Response) (result autorest.Response, err error) {
   331  	err = autorest.Respond(
   332  		resp,
   333  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   334  		autorest.ByClosing())
   335  	result.Response = resp
   336  	return
   337  }
   338  
   339  // DeleteCassandraTable deletes an existing Azure Cosmos DB Cassandra table.
   340  // Parameters:
   341  // resourceGroupName - name of an Azure resource group.
   342  // accountName - cosmos DB database account name.
   343  // keyspaceName - cosmos DB keyspace name.
   344  // tableName - cosmos DB table name.
   345  func (client CassandraResourcesClient) DeleteCassandraTable(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (result CassandraResourcesDeleteCassandraTableFuture, err error) {
   346  	if tracing.IsEnabled() {
   347  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.DeleteCassandraTable")
   348  		defer func() {
   349  			sc := -1
   350  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   351  				sc = result.FutureAPI.Response().StatusCode
   352  			}
   353  			tracing.EndSpan(ctx, sc, err)
   354  		}()
   355  	}
   356  	if err := validation.Validate([]validation.Validation{
   357  		{TargetValue: client.SubscriptionID,
   358  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   359  		{TargetValue: resourceGroupName,
   360  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   361  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   362  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   363  		{TargetValue: accountName,
   364  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   365  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   366  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   367  		return result, validation.NewError("documentdb.CassandraResourcesClient", "DeleteCassandraTable", err.Error())
   368  	}
   369  
   370  	req, err := client.DeleteCassandraTablePreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName)
   371  	if err != nil {
   372  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "DeleteCassandraTable", nil, "Failure preparing request")
   373  		return
   374  	}
   375  
   376  	result, err = client.DeleteCassandraTableSender(req)
   377  	if err != nil {
   378  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "DeleteCassandraTable", result.Response(), "Failure sending request")
   379  		return
   380  	}
   381  
   382  	return
   383  }
   384  
   385  // DeleteCassandraTablePreparer prepares the DeleteCassandraTable request.
   386  func (client CassandraResourcesClient) DeleteCassandraTablePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (*http.Request, error) {
   387  	pathParameters := map[string]interface{}{
   388  		"accountName":       autorest.Encode("path", accountName),
   389  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   390  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   391  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   392  		"tableName":         autorest.Encode("path", tableName),
   393  	}
   394  
   395  	const APIVersion = "2019-08-01"
   396  	queryParameters := map[string]interface{}{
   397  		"api-version": APIVersion,
   398  	}
   399  
   400  	preparer := autorest.CreatePreparer(
   401  		autorest.AsDelete(),
   402  		autorest.WithBaseURL(client.BaseURI),
   403  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}/tables/{tableName}", pathParameters),
   404  		autorest.WithQueryParameters(queryParameters))
   405  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   406  }
   407  
   408  // DeleteCassandraTableSender sends the DeleteCassandraTable request. The method will close the
   409  // http.Response Body if it receives an error.
   410  func (client CassandraResourcesClient) DeleteCassandraTableSender(req *http.Request) (future CassandraResourcesDeleteCassandraTableFuture, err error) {
   411  	var resp *http.Response
   412  	future.FutureAPI = &azure.Future{}
   413  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   414  	if err != nil {
   415  		return
   416  	}
   417  	var azf azure.Future
   418  	azf, err = azure.NewFutureFromResponse(resp)
   419  	future.FutureAPI = &azf
   420  	future.Result = future.result
   421  	return
   422  }
   423  
   424  // DeleteCassandraTableResponder handles the response to the DeleteCassandraTable request. The method always
   425  // closes the http.Response Body.
   426  func (client CassandraResourcesClient) DeleteCassandraTableResponder(resp *http.Response) (result autorest.Response, err error) {
   427  	err = autorest.Respond(
   428  		resp,
   429  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   430  		autorest.ByClosing())
   431  	result.Response = resp
   432  	return
   433  }
   434  
   435  // GetCassandraKeyspace gets the Cassandra keyspaces under an existing Azure Cosmos DB database account with the
   436  // provided name.
   437  // Parameters:
   438  // resourceGroupName - name of an Azure resource group.
   439  // accountName - cosmos DB database account name.
   440  // keyspaceName - cosmos DB keyspace name.
   441  func (client CassandraResourcesClient) GetCassandraKeyspace(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (result CassandraKeyspaceGetResults, err error) {
   442  	if tracing.IsEnabled() {
   443  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.GetCassandraKeyspace")
   444  		defer func() {
   445  			sc := -1
   446  			if result.Response.Response != nil {
   447  				sc = result.Response.Response.StatusCode
   448  			}
   449  			tracing.EndSpan(ctx, sc, err)
   450  		}()
   451  	}
   452  	if err := validation.Validate([]validation.Validation{
   453  		{TargetValue: client.SubscriptionID,
   454  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   455  		{TargetValue: resourceGroupName,
   456  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   457  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   458  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   459  		{TargetValue: accountName,
   460  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   461  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   462  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   463  		return result, validation.NewError("documentdb.CassandraResourcesClient", "GetCassandraKeyspace", err.Error())
   464  	}
   465  
   466  	req, err := client.GetCassandraKeyspacePreparer(ctx, resourceGroupName, accountName, keyspaceName)
   467  	if err != nil {
   468  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraKeyspace", nil, "Failure preparing request")
   469  		return
   470  	}
   471  
   472  	resp, err := client.GetCassandraKeyspaceSender(req)
   473  	if err != nil {
   474  		result.Response = autorest.Response{Response: resp}
   475  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraKeyspace", resp, "Failure sending request")
   476  		return
   477  	}
   478  
   479  	result, err = client.GetCassandraKeyspaceResponder(resp)
   480  	if err != nil {
   481  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraKeyspace", resp, "Failure responding to request")
   482  		return
   483  	}
   484  
   485  	return
   486  }
   487  
   488  // GetCassandraKeyspacePreparer prepares the GetCassandraKeyspace request.
   489  func (client CassandraResourcesClient) GetCassandraKeyspacePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (*http.Request, error) {
   490  	pathParameters := map[string]interface{}{
   491  		"accountName":       autorest.Encode("path", accountName),
   492  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   493  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   494  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   495  	}
   496  
   497  	const APIVersion = "2019-08-01"
   498  	queryParameters := map[string]interface{}{
   499  		"api-version": APIVersion,
   500  	}
   501  
   502  	preparer := autorest.CreatePreparer(
   503  		autorest.AsGet(),
   504  		autorest.WithBaseURL(client.BaseURI),
   505  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}", pathParameters),
   506  		autorest.WithQueryParameters(queryParameters))
   507  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   508  }
   509  
   510  // GetCassandraKeyspaceSender sends the GetCassandraKeyspace request. The method will close the
   511  // http.Response Body if it receives an error.
   512  func (client CassandraResourcesClient) GetCassandraKeyspaceSender(req *http.Request) (*http.Response, error) {
   513  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   514  }
   515  
   516  // GetCassandraKeyspaceResponder handles the response to the GetCassandraKeyspace request. The method always
   517  // closes the http.Response Body.
   518  func (client CassandraResourcesClient) GetCassandraKeyspaceResponder(resp *http.Response) (result CassandraKeyspaceGetResults, err error) {
   519  	err = autorest.Respond(
   520  		resp,
   521  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   522  		autorest.ByUnmarshallingJSON(&result),
   523  		autorest.ByClosing())
   524  	result.Response = autorest.Response{Response: resp}
   525  	return
   526  }
   527  
   528  // GetCassandraKeyspaceThroughput gets the RUs per second of the Cassandra Keyspace under an existing Azure Cosmos DB
   529  // database account with the provided name.
   530  // Parameters:
   531  // resourceGroupName - name of an Azure resource group.
   532  // accountName - cosmos DB database account name.
   533  // keyspaceName - cosmos DB keyspace name.
   534  func (client CassandraResourcesClient) GetCassandraKeyspaceThroughput(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (result ThroughputSettingsGetResults, err error) {
   535  	if tracing.IsEnabled() {
   536  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.GetCassandraKeyspaceThroughput")
   537  		defer func() {
   538  			sc := -1
   539  			if result.Response.Response != nil {
   540  				sc = result.Response.Response.StatusCode
   541  			}
   542  			tracing.EndSpan(ctx, sc, err)
   543  		}()
   544  	}
   545  	if err := validation.Validate([]validation.Validation{
   546  		{TargetValue: client.SubscriptionID,
   547  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   548  		{TargetValue: resourceGroupName,
   549  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   550  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   551  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   552  		{TargetValue: accountName,
   553  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   554  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   555  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   556  		return result, validation.NewError("documentdb.CassandraResourcesClient", "GetCassandraKeyspaceThroughput", err.Error())
   557  	}
   558  
   559  	req, err := client.GetCassandraKeyspaceThroughputPreparer(ctx, resourceGroupName, accountName, keyspaceName)
   560  	if err != nil {
   561  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraKeyspaceThroughput", nil, "Failure preparing request")
   562  		return
   563  	}
   564  
   565  	resp, err := client.GetCassandraKeyspaceThroughputSender(req)
   566  	if err != nil {
   567  		result.Response = autorest.Response{Response: resp}
   568  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraKeyspaceThroughput", resp, "Failure sending request")
   569  		return
   570  	}
   571  
   572  	result, err = client.GetCassandraKeyspaceThroughputResponder(resp)
   573  	if err != nil {
   574  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraKeyspaceThroughput", resp, "Failure responding to request")
   575  		return
   576  	}
   577  
   578  	return
   579  }
   580  
   581  // GetCassandraKeyspaceThroughputPreparer prepares the GetCassandraKeyspaceThroughput request.
   582  func (client CassandraResourcesClient) GetCassandraKeyspaceThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (*http.Request, error) {
   583  	pathParameters := map[string]interface{}{
   584  		"accountName":       autorest.Encode("path", accountName),
   585  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   586  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   587  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   588  	}
   589  
   590  	const APIVersion = "2019-08-01"
   591  	queryParameters := map[string]interface{}{
   592  		"api-version": APIVersion,
   593  	}
   594  
   595  	preparer := autorest.CreatePreparer(
   596  		autorest.AsGet(),
   597  		autorest.WithBaseURL(client.BaseURI),
   598  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}/throughputSettings/default", pathParameters),
   599  		autorest.WithQueryParameters(queryParameters))
   600  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   601  }
   602  
   603  // GetCassandraKeyspaceThroughputSender sends the GetCassandraKeyspaceThroughput request. The method will close the
   604  // http.Response Body if it receives an error.
   605  func (client CassandraResourcesClient) GetCassandraKeyspaceThroughputSender(req *http.Request) (*http.Response, error) {
   606  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   607  }
   608  
   609  // GetCassandraKeyspaceThroughputResponder handles the response to the GetCassandraKeyspaceThroughput request. The method always
   610  // closes the http.Response Body.
   611  func (client CassandraResourcesClient) GetCassandraKeyspaceThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) {
   612  	err = autorest.Respond(
   613  		resp,
   614  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   615  		autorest.ByUnmarshallingJSON(&result),
   616  		autorest.ByClosing())
   617  	result.Response = autorest.Response{Response: resp}
   618  	return
   619  }
   620  
   621  // GetCassandraTable gets the Cassandra table under an existing Azure Cosmos DB database account.
   622  // Parameters:
   623  // resourceGroupName - name of an Azure resource group.
   624  // accountName - cosmos DB database account name.
   625  // keyspaceName - cosmos DB keyspace name.
   626  // tableName - cosmos DB table name.
   627  func (client CassandraResourcesClient) GetCassandraTable(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (result CassandraTableGetResults, err error) {
   628  	if tracing.IsEnabled() {
   629  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.GetCassandraTable")
   630  		defer func() {
   631  			sc := -1
   632  			if result.Response.Response != nil {
   633  				sc = result.Response.Response.StatusCode
   634  			}
   635  			tracing.EndSpan(ctx, sc, err)
   636  		}()
   637  	}
   638  	if err := validation.Validate([]validation.Validation{
   639  		{TargetValue: client.SubscriptionID,
   640  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   641  		{TargetValue: resourceGroupName,
   642  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   643  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   644  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   645  		{TargetValue: accountName,
   646  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   647  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   648  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   649  		return result, validation.NewError("documentdb.CassandraResourcesClient", "GetCassandraTable", err.Error())
   650  	}
   651  
   652  	req, err := client.GetCassandraTablePreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName)
   653  	if err != nil {
   654  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraTable", nil, "Failure preparing request")
   655  		return
   656  	}
   657  
   658  	resp, err := client.GetCassandraTableSender(req)
   659  	if err != nil {
   660  		result.Response = autorest.Response{Response: resp}
   661  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraTable", resp, "Failure sending request")
   662  		return
   663  	}
   664  
   665  	result, err = client.GetCassandraTableResponder(resp)
   666  	if err != nil {
   667  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraTable", resp, "Failure responding to request")
   668  		return
   669  	}
   670  
   671  	return
   672  }
   673  
   674  // GetCassandraTablePreparer prepares the GetCassandraTable request.
   675  func (client CassandraResourcesClient) GetCassandraTablePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (*http.Request, error) {
   676  	pathParameters := map[string]interface{}{
   677  		"accountName":       autorest.Encode("path", accountName),
   678  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   679  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   680  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   681  		"tableName":         autorest.Encode("path", tableName),
   682  	}
   683  
   684  	const APIVersion = "2019-08-01"
   685  	queryParameters := map[string]interface{}{
   686  		"api-version": APIVersion,
   687  	}
   688  
   689  	preparer := autorest.CreatePreparer(
   690  		autorest.AsGet(),
   691  		autorest.WithBaseURL(client.BaseURI),
   692  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}/tables/{tableName}", pathParameters),
   693  		autorest.WithQueryParameters(queryParameters))
   694  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   695  }
   696  
   697  // GetCassandraTableSender sends the GetCassandraTable request. The method will close the
   698  // http.Response Body if it receives an error.
   699  func (client CassandraResourcesClient) GetCassandraTableSender(req *http.Request) (*http.Response, error) {
   700  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   701  }
   702  
   703  // GetCassandraTableResponder handles the response to the GetCassandraTable request. The method always
   704  // closes the http.Response Body.
   705  func (client CassandraResourcesClient) GetCassandraTableResponder(resp *http.Response) (result CassandraTableGetResults, err error) {
   706  	err = autorest.Respond(
   707  		resp,
   708  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   709  		autorest.ByUnmarshallingJSON(&result),
   710  		autorest.ByClosing())
   711  	result.Response = autorest.Response{Response: resp}
   712  	return
   713  }
   714  
   715  // GetCassandraTableThroughput gets the RUs per second of the Cassandra table under an existing Azure Cosmos DB
   716  // database account with the provided name.
   717  // Parameters:
   718  // resourceGroupName - name of an Azure resource group.
   719  // accountName - cosmos DB database account name.
   720  // keyspaceName - cosmos DB keyspace name.
   721  // tableName - cosmos DB table name.
   722  func (client CassandraResourcesClient) GetCassandraTableThroughput(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (result ThroughputSettingsGetResults, err error) {
   723  	if tracing.IsEnabled() {
   724  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.GetCassandraTableThroughput")
   725  		defer func() {
   726  			sc := -1
   727  			if result.Response.Response != nil {
   728  				sc = result.Response.Response.StatusCode
   729  			}
   730  			tracing.EndSpan(ctx, sc, err)
   731  		}()
   732  	}
   733  	if err := validation.Validate([]validation.Validation{
   734  		{TargetValue: client.SubscriptionID,
   735  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   736  		{TargetValue: resourceGroupName,
   737  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   738  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   739  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   740  		{TargetValue: accountName,
   741  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   742  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   743  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   744  		return result, validation.NewError("documentdb.CassandraResourcesClient", "GetCassandraTableThroughput", err.Error())
   745  	}
   746  
   747  	req, err := client.GetCassandraTableThroughputPreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName)
   748  	if err != nil {
   749  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraTableThroughput", nil, "Failure preparing request")
   750  		return
   751  	}
   752  
   753  	resp, err := client.GetCassandraTableThroughputSender(req)
   754  	if err != nil {
   755  		result.Response = autorest.Response{Response: resp}
   756  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraTableThroughput", resp, "Failure sending request")
   757  		return
   758  	}
   759  
   760  	result, err = client.GetCassandraTableThroughputResponder(resp)
   761  	if err != nil {
   762  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "GetCassandraTableThroughput", resp, "Failure responding to request")
   763  		return
   764  	}
   765  
   766  	return
   767  }
   768  
   769  // GetCassandraTableThroughputPreparer prepares the GetCassandraTableThroughput request.
   770  func (client CassandraResourcesClient) GetCassandraTableThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (*http.Request, error) {
   771  	pathParameters := map[string]interface{}{
   772  		"accountName":       autorest.Encode("path", accountName),
   773  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   774  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   775  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   776  		"tableName":         autorest.Encode("path", tableName),
   777  	}
   778  
   779  	const APIVersion = "2019-08-01"
   780  	queryParameters := map[string]interface{}{
   781  		"api-version": APIVersion,
   782  	}
   783  
   784  	preparer := autorest.CreatePreparer(
   785  		autorest.AsGet(),
   786  		autorest.WithBaseURL(client.BaseURI),
   787  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}/tables/{tableName}/throughputSettings/default", pathParameters),
   788  		autorest.WithQueryParameters(queryParameters))
   789  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   790  }
   791  
   792  // GetCassandraTableThroughputSender sends the GetCassandraTableThroughput request. The method will close the
   793  // http.Response Body if it receives an error.
   794  func (client CassandraResourcesClient) GetCassandraTableThroughputSender(req *http.Request) (*http.Response, error) {
   795  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   796  }
   797  
   798  // GetCassandraTableThroughputResponder handles the response to the GetCassandraTableThroughput request. The method always
   799  // closes the http.Response Body.
   800  func (client CassandraResourcesClient) GetCassandraTableThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) {
   801  	err = autorest.Respond(
   802  		resp,
   803  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   804  		autorest.ByUnmarshallingJSON(&result),
   805  		autorest.ByClosing())
   806  	result.Response = autorest.Response{Response: resp}
   807  	return
   808  }
   809  
   810  // ListCassandraKeyspaces lists the Cassandra keyspaces under an existing Azure Cosmos DB database account.
   811  // Parameters:
   812  // resourceGroupName - name of an Azure resource group.
   813  // accountName - cosmos DB database account name.
   814  func (client CassandraResourcesClient) ListCassandraKeyspaces(ctx context.Context, resourceGroupName string, accountName string) (result CassandraKeyspaceListResult, err error) {
   815  	if tracing.IsEnabled() {
   816  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.ListCassandraKeyspaces")
   817  		defer func() {
   818  			sc := -1
   819  			if result.Response.Response != nil {
   820  				sc = result.Response.Response.StatusCode
   821  			}
   822  			tracing.EndSpan(ctx, sc, err)
   823  		}()
   824  	}
   825  	if err := validation.Validate([]validation.Validation{
   826  		{TargetValue: client.SubscriptionID,
   827  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   828  		{TargetValue: resourceGroupName,
   829  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   830  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   831  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   832  		{TargetValue: accountName,
   833  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   834  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   835  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   836  		return result, validation.NewError("documentdb.CassandraResourcesClient", "ListCassandraKeyspaces", err.Error())
   837  	}
   838  
   839  	req, err := client.ListCassandraKeyspacesPreparer(ctx, resourceGroupName, accountName)
   840  	if err != nil {
   841  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "ListCassandraKeyspaces", nil, "Failure preparing request")
   842  		return
   843  	}
   844  
   845  	resp, err := client.ListCassandraKeyspacesSender(req)
   846  	if err != nil {
   847  		result.Response = autorest.Response{Response: resp}
   848  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "ListCassandraKeyspaces", resp, "Failure sending request")
   849  		return
   850  	}
   851  
   852  	result, err = client.ListCassandraKeyspacesResponder(resp)
   853  	if err != nil {
   854  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "ListCassandraKeyspaces", resp, "Failure responding to request")
   855  		return
   856  	}
   857  
   858  	return
   859  }
   860  
   861  // ListCassandraKeyspacesPreparer prepares the ListCassandraKeyspaces request.
   862  func (client CassandraResourcesClient) ListCassandraKeyspacesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   863  	pathParameters := map[string]interface{}{
   864  		"accountName":       autorest.Encode("path", accountName),
   865  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   866  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   867  	}
   868  
   869  	const APIVersion = "2019-08-01"
   870  	queryParameters := map[string]interface{}{
   871  		"api-version": APIVersion,
   872  	}
   873  
   874  	preparer := autorest.CreatePreparer(
   875  		autorest.AsGet(),
   876  		autorest.WithBaseURL(client.BaseURI),
   877  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces", pathParameters),
   878  		autorest.WithQueryParameters(queryParameters))
   879  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   880  }
   881  
   882  // ListCassandraKeyspacesSender sends the ListCassandraKeyspaces request. The method will close the
   883  // http.Response Body if it receives an error.
   884  func (client CassandraResourcesClient) ListCassandraKeyspacesSender(req *http.Request) (*http.Response, error) {
   885  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   886  }
   887  
   888  // ListCassandraKeyspacesResponder handles the response to the ListCassandraKeyspaces request. The method always
   889  // closes the http.Response Body.
   890  func (client CassandraResourcesClient) ListCassandraKeyspacesResponder(resp *http.Response) (result CassandraKeyspaceListResult, err error) {
   891  	err = autorest.Respond(
   892  		resp,
   893  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   894  		autorest.ByUnmarshallingJSON(&result),
   895  		autorest.ByClosing())
   896  	result.Response = autorest.Response{Response: resp}
   897  	return
   898  }
   899  
   900  // ListCassandraTables lists the Cassandra table under an existing Azure Cosmos DB database account.
   901  // Parameters:
   902  // resourceGroupName - name of an Azure resource group.
   903  // accountName - cosmos DB database account name.
   904  // keyspaceName - cosmos DB keyspace name.
   905  func (client CassandraResourcesClient) ListCassandraTables(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (result CassandraTableListResult, err error) {
   906  	if tracing.IsEnabled() {
   907  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.ListCassandraTables")
   908  		defer func() {
   909  			sc := -1
   910  			if result.Response.Response != nil {
   911  				sc = result.Response.Response.StatusCode
   912  			}
   913  			tracing.EndSpan(ctx, sc, err)
   914  		}()
   915  	}
   916  	if err := validation.Validate([]validation.Validation{
   917  		{TargetValue: client.SubscriptionID,
   918  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   919  		{TargetValue: resourceGroupName,
   920  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   921  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   922  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   923  		{TargetValue: accountName,
   924  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   925  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   926  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   927  		return result, validation.NewError("documentdb.CassandraResourcesClient", "ListCassandraTables", err.Error())
   928  	}
   929  
   930  	req, err := client.ListCassandraTablesPreparer(ctx, resourceGroupName, accountName, keyspaceName)
   931  	if err != nil {
   932  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "ListCassandraTables", nil, "Failure preparing request")
   933  		return
   934  	}
   935  
   936  	resp, err := client.ListCassandraTablesSender(req)
   937  	if err != nil {
   938  		result.Response = autorest.Response{Response: resp}
   939  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "ListCassandraTables", resp, "Failure sending request")
   940  		return
   941  	}
   942  
   943  	result, err = client.ListCassandraTablesResponder(resp)
   944  	if err != nil {
   945  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "ListCassandraTables", resp, "Failure responding to request")
   946  		return
   947  	}
   948  
   949  	return
   950  }
   951  
   952  // ListCassandraTablesPreparer prepares the ListCassandraTables request.
   953  func (client CassandraResourcesClient) ListCassandraTablesPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (*http.Request, error) {
   954  	pathParameters := map[string]interface{}{
   955  		"accountName":       autorest.Encode("path", accountName),
   956  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   957  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   958  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   959  	}
   960  
   961  	const APIVersion = "2019-08-01"
   962  	queryParameters := map[string]interface{}{
   963  		"api-version": APIVersion,
   964  	}
   965  
   966  	preparer := autorest.CreatePreparer(
   967  		autorest.AsGet(),
   968  		autorest.WithBaseURL(client.BaseURI),
   969  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}/tables", pathParameters),
   970  		autorest.WithQueryParameters(queryParameters))
   971  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   972  }
   973  
   974  // ListCassandraTablesSender sends the ListCassandraTables request. The method will close the
   975  // http.Response Body if it receives an error.
   976  func (client CassandraResourcesClient) ListCassandraTablesSender(req *http.Request) (*http.Response, error) {
   977  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   978  }
   979  
   980  // ListCassandraTablesResponder handles the response to the ListCassandraTables request. The method always
   981  // closes the http.Response Body.
   982  func (client CassandraResourcesClient) ListCassandraTablesResponder(resp *http.Response) (result CassandraTableListResult, err error) {
   983  	err = autorest.Respond(
   984  		resp,
   985  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   986  		autorest.ByUnmarshallingJSON(&result),
   987  		autorest.ByClosing())
   988  	result.Response = autorest.Response{Response: resp}
   989  	return
   990  }
   991  
   992  // UpdateCassandraKeyspaceThroughput update RUs per second of an Azure Cosmos DB Cassandra Keyspace
   993  // Parameters:
   994  // resourceGroupName - name of an Azure resource group.
   995  // accountName - cosmos DB database account name.
   996  // keyspaceName - cosmos DB keyspace name.
   997  // updateThroughputParameters - the RUs per second of the parameters to provide for the current Cassandra
   998  // Keyspace.
   999  func (client CassandraResourcesClient) UpdateCassandraKeyspaceThroughput(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, updateThroughputParameters ThroughputSettingsUpdateParameters) (result CassandraResourcesUpdateCassandraKeyspaceThroughputFuture, err error) {
  1000  	if tracing.IsEnabled() {
  1001  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.UpdateCassandraKeyspaceThroughput")
  1002  		defer func() {
  1003  			sc := -1
  1004  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1005  				sc = result.FutureAPI.Response().StatusCode
  1006  			}
  1007  			tracing.EndSpan(ctx, sc, err)
  1008  		}()
  1009  	}
  1010  	if err := validation.Validate([]validation.Validation{
  1011  		{TargetValue: client.SubscriptionID,
  1012  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1013  		{TargetValue: resourceGroupName,
  1014  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1015  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1016  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1017  		{TargetValue: accountName,
  1018  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1019  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1020  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  1021  		{TargetValue: updateThroughputParameters,
  1022  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties", Name: validation.Null, Rule: true,
  1023  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource", Name: validation.Null, Rule: true,
  1024  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  1025  				}}}}}); err != nil {
  1026  		return result, validation.NewError("documentdb.CassandraResourcesClient", "UpdateCassandraKeyspaceThroughput", err.Error())
  1027  	}
  1028  
  1029  	req, err := client.UpdateCassandraKeyspaceThroughputPreparer(ctx, resourceGroupName, accountName, keyspaceName, updateThroughputParameters)
  1030  	if err != nil {
  1031  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "UpdateCassandraKeyspaceThroughput", nil, "Failure preparing request")
  1032  		return
  1033  	}
  1034  
  1035  	result, err = client.UpdateCassandraKeyspaceThroughputSender(req)
  1036  	if err != nil {
  1037  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "UpdateCassandraKeyspaceThroughput", result.Response(), "Failure sending request")
  1038  		return
  1039  	}
  1040  
  1041  	return
  1042  }
  1043  
  1044  // UpdateCassandraKeyspaceThroughputPreparer prepares the UpdateCassandraKeyspaceThroughput request.
  1045  func (client CassandraResourcesClient) UpdateCassandraKeyspaceThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, updateThroughputParameters ThroughputSettingsUpdateParameters) (*http.Request, error) {
  1046  	pathParameters := map[string]interface{}{
  1047  		"accountName":       autorest.Encode("path", accountName),
  1048  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  1049  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1050  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1051  	}
  1052  
  1053  	const APIVersion = "2019-08-01"
  1054  	queryParameters := map[string]interface{}{
  1055  		"api-version": APIVersion,
  1056  	}
  1057  
  1058  	preparer := autorest.CreatePreparer(
  1059  		autorest.AsContentType("application/json; charset=utf-8"),
  1060  		autorest.AsPut(),
  1061  		autorest.WithBaseURL(client.BaseURI),
  1062  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}/throughputSettings/default", pathParameters),
  1063  		autorest.WithJSON(updateThroughputParameters),
  1064  		autorest.WithQueryParameters(queryParameters))
  1065  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1066  }
  1067  
  1068  // UpdateCassandraKeyspaceThroughputSender sends the UpdateCassandraKeyspaceThroughput request. The method will close the
  1069  // http.Response Body if it receives an error.
  1070  func (client CassandraResourcesClient) UpdateCassandraKeyspaceThroughputSender(req *http.Request) (future CassandraResourcesUpdateCassandraKeyspaceThroughputFuture, err error) {
  1071  	var resp *http.Response
  1072  	future.FutureAPI = &azure.Future{}
  1073  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1074  	if err != nil {
  1075  		return
  1076  	}
  1077  	var azf azure.Future
  1078  	azf, err = azure.NewFutureFromResponse(resp)
  1079  	future.FutureAPI = &azf
  1080  	future.Result = future.result
  1081  	return
  1082  }
  1083  
  1084  // UpdateCassandraKeyspaceThroughputResponder handles the response to the UpdateCassandraKeyspaceThroughput request. The method always
  1085  // closes the http.Response Body.
  1086  func (client CassandraResourcesClient) UpdateCassandraKeyspaceThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) {
  1087  	err = autorest.Respond(
  1088  		resp,
  1089  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1090  		autorest.ByUnmarshallingJSON(&result),
  1091  		autorest.ByClosing())
  1092  	result.Response = autorest.Response{Response: resp}
  1093  	return
  1094  }
  1095  
  1096  // UpdateCassandraTableThroughput update RUs per second of an Azure Cosmos DB Cassandra table
  1097  // Parameters:
  1098  // resourceGroupName - name of an Azure resource group.
  1099  // accountName - cosmos DB database account name.
  1100  // keyspaceName - cosmos DB keyspace name.
  1101  // tableName - cosmos DB table name.
  1102  // updateThroughputParameters - the RUs per second of the parameters to provide for the current Cassandra
  1103  // table.
  1104  func (client CassandraResourcesClient) UpdateCassandraTableThroughput(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string, updateThroughputParameters ThroughputSettingsUpdateParameters) (result CassandraResourcesUpdateCassandraTableThroughputFuture, err error) {
  1105  	if tracing.IsEnabled() {
  1106  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraResourcesClient.UpdateCassandraTableThroughput")
  1107  		defer func() {
  1108  			sc := -1
  1109  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1110  				sc = result.FutureAPI.Response().StatusCode
  1111  			}
  1112  			tracing.EndSpan(ctx, sc, err)
  1113  		}()
  1114  	}
  1115  	if err := validation.Validate([]validation.Validation{
  1116  		{TargetValue: client.SubscriptionID,
  1117  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1118  		{TargetValue: resourceGroupName,
  1119  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1120  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1121  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1122  		{TargetValue: accountName,
  1123  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1124  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1125  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  1126  		{TargetValue: updateThroughputParameters,
  1127  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties", Name: validation.Null, Rule: true,
  1128  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource", Name: validation.Null, Rule: true,
  1129  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputSettingsUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  1130  				}}}}}); err != nil {
  1131  		return result, validation.NewError("documentdb.CassandraResourcesClient", "UpdateCassandraTableThroughput", err.Error())
  1132  	}
  1133  
  1134  	req, err := client.UpdateCassandraTableThroughputPreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName, updateThroughputParameters)
  1135  	if err != nil {
  1136  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "UpdateCassandraTableThroughput", nil, "Failure preparing request")
  1137  		return
  1138  	}
  1139  
  1140  	result, err = client.UpdateCassandraTableThroughputSender(req)
  1141  	if err != nil {
  1142  		err = autorest.NewErrorWithError(err, "documentdb.CassandraResourcesClient", "UpdateCassandraTableThroughput", result.Response(), "Failure sending request")
  1143  		return
  1144  	}
  1145  
  1146  	return
  1147  }
  1148  
  1149  // UpdateCassandraTableThroughputPreparer prepares the UpdateCassandraTableThroughput request.
  1150  func (client CassandraResourcesClient) UpdateCassandraTableThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string, updateThroughputParameters ThroughputSettingsUpdateParameters) (*http.Request, error) {
  1151  	pathParameters := map[string]interface{}{
  1152  		"accountName":       autorest.Encode("path", accountName),
  1153  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  1154  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1155  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1156  		"tableName":         autorest.Encode("path", tableName),
  1157  	}
  1158  
  1159  	const APIVersion = "2019-08-01"
  1160  	queryParameters := map[string]interface{}{
  1161  		"api-version": APIVersion,
  1162  	}
  1163  
  1164  	preparer := autorest.CreatePreparer(
  1165  		autorest.AsContentType("application/json; charset=utf-8"),
  1166  		autorest.AsPut(),
  1167  		autorest.WithBaseURL(client.BaseURI),
  1168  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/cassandraKeyspaces/{keyspaceName}/tables/{tableName}/throughputSettings/default", pathParameters),
  1169  		autorest.WithJSON(updateThroughputParameters),
  1170  		autorest.WithQueryParameters(queryParameters))
  1171  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1172  }
  1173  
  1174  // UpdateCassandraTableThroughputSender sends the UpdateCassandraTableThroughput request. The method will close the
  1175  // http.Response Body if it receives an error.
  1176  func (client CassandraResourcesClient) UpdateCassandraTableThroughputSender(req *http.Request) (future CassandraResourcesUpdateCassandraTableThroughputFuture, err error) {
  1177  	var resp *http.Response
  1178  	future.FutureAPI = &azure.Future{}
  1179  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1180  	if err != nil {
  1181  		return
  1182  	}
  1183  	var azf azure.Future
  1184  	azf, err = azure.NewFutureFromResponse(resp)
  1185  	future.FutureAPI = &azf
  1186  	future.Result = future.result
  1187  	return
  1188  }
  1189  
  1190  // UpdateCassandraTableThroughputResponder handles the response to the UpdateCassandraTableThroughput request. The method always
  1191  // closes the http.Response Body.
  1192  func (client CassandraResourcesClient) UpdateCassandraTableThroughputResponder(resp *http.Response) (result ThroughputSettingsGetResults, err error) {
  1193  	err = autorest.Respond(
  1194  		resp,
  1195  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1196  		autorest.ByUnmarshallingJSON(&result),
  1197  		autorest.ByClosing())
  1198  	result.Response = autorest.Response{Response: resp}
  1199  	return
  1200  }
  1201
View as plain text