cosmosdb

package
v0.20230518.1152641 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 18, 2023 License: MPL-2.0 Imports: 14 Imported by: 0

README ¶

github.com/hashicorp/go-azure-sdk/resource-manager/cosmosdb/2021-10-15/cosmosdb Documentation

The cosmosdb SDK allows for interaction with the Azure Resource Manager Service cosmosdb (API Version 2021-10-15).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-sdk/resource-manager/cosmosdb/2021-10-15/cosmosdb"

Client Initialization

client := cosmosdb.NewCosmosDBClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: CosmosDBClient.CassandraResourcesCreateUpdateCassandraKeyspace

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue")

payload := cosmosdb.CassandraKeyspaceCreateUpdateParameters{
	// ...
}


if err := client.CassandraResourcesCreateUpdateCassandraKeyspaceThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesCreateUpdateCassandraTable

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue", "tableValue")

payload := cosmosdb.CassandraTableCreateUpdateParameters{
	// ...
}


if err := client.CassandraResourcesCreateUpdateCassandraTableThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesDeleteCassandraKeyspace

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue")

if err := client.CassandraResourcesDeleteCassandraKeyspaceThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesDeleteCassandraTable

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue", "tableValue")

if err := client.CassandraResourcesDeleteCassandraTableThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesGetCassandraKeyspace

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue")

read, err := client.CassandraResourcesGetCassandraKeyspace(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CassandraResourcesGetCassandraKeyspaceThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue")

read, err := client.CassandraResourcesGetCassandraKeyspaceThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CassandraResourcesGetCassandraTable

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue", "tableValue")

read, err := client.CassandraResourcesGetCassandraTable(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CassandraResourcesGetCassandraTableThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue", "tableValue")

read, err := client.CassandraResourcesGetCassandraTableThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CassandraResourcesListCassandraKeyspaces

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.CassandraResourcesListCassandraKeyspaces(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CassandraResourcesListCassandraTables

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue")

read, err := client.CassandraResourcesListCassandraTables(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CassandraResourcesMigrateCassandraKeyspaceToAutoscale

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue")

if err := client.CassandraResourcesMigrateCassandraKeyspaceToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesMigrateCassandraKeyspaceToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue")

if err := client.CassandraResourcesMigrateCassandraKeyspaceToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesMigrateCassandraTableToAutoscale

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue", "tableValue")

if err := client.CassandraResourcesMigrateCassandraTableToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesMigrateCassandraTableToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue", "tableValue")

if err := client.CassandraResourcesMigrateCassandraTableToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesUpdateCassandraKeyspaceThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.CassandraResourcesUpdateCassandraKeyspaceThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesUpdateCassandraTableThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "cassandraKeyspaceValue", "tableValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.CassandraResourcesUpdateCassandraTableThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CollectionListMetricDefinitions

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue", "collectionValue")

read, err := client.CollectionListMetricDefinitions(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CollectionListMetrics

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue", "collectionValue")

read, err := client.CollectionListMetrics(ctx, id, cosmosdb.DefaultCollectionListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CollectionListUsages

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue", "collectionValue")

read, err := client.CollectionListUsages(ctx, id, cosmosdb.DefaultCollectionListUsagesOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CollectionPartitionListMetrics

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue", "collectionValue")

read, err := client.CollectionPartitionListMetrics(ctx, id, cosmosdb.DefaultCollectionPartitionListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CollectionPartitionListUsages

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue", "collectionValue")

read, err := client.CollectionPartitionListUsages(ctx, id, cosmosdb.DefaultCollectionPartitionListUsagesOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CollectionPartitionRegionListMetrics

ctx := context.TODO()
id := cosmosdb.NewDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "regionValue", "databaseValue", "collectionValue")

read, err := client.CollectionPartitionRegionListMetrics(ctx, id, cosmosdb.DefaultCollectionPartitionRegionListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.CollectionRegionListMetrics

ctx := context.TODO()
id := cosmosdb.NewDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "regionValue", "databaseValue", "collectionValue")

read, err := client.CollectionRegionListMetrics(ctx, id, cosmosdb.DefaultCollectionRegionListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountRegionListMetrics

ctx := context.TODO()
id := cosmosdb.NewRegionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "regionValue")

read, err := client.DatabaseAccountRegionListMetrics(ctx, id, cosmosdb.DefaultDatabaseAccountRegionListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsCheckNameExists

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountNameID("databaseAccountValue")

read, err := client.DatabaseAccountsCheckNameExists(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsCreateOrUpdate

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

payload := cosmosdb.DatabaseAccountCreateUpdateParameters{
	// ...
}


if err := client.DatabaseAccountsCreateOrUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsDelete

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

if err := client.DatabaseAccountsDeleteThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsFailoverPriorityChange

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

payload := cosmosdb.FailoverPolicies{
	// ...
}


if err := client.DatabaseAccountsFailoverPriorityChangeThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsGet

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.DatabaseAccountsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsGetReadOnlyKeys

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.DatabaseAccountsGetReadOnlyKeys(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsList

ctx := context.TODO()
id := cosmosdb.NewSubscriptionID("12345678-1234-9876-4563-123456789012")

read, err := client.DatabaseAccountsList(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsListByResourceGroup

ctx := context.TODO()
id := cosmosdb.NewResourceGroupID("12345678-1234-9876-4563-123456789012", "example-resource-group")

read, err := client.DatabaseAccountsListByResourceGroup(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsListConnectionStrings

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.DatabaseAccountsListConnectionStrings(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsListKeys

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.DatabaseAccountsListKeys(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsListMetricDefinitions

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.DatabaseAccountsListMetricDefinitions(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsListMetrics

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.DatabaseAccountsListMetrics(ctx, id, cosmosdb.DefaultDatabaseAccountsListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsListReadOnlyKeys

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.DatabaseAccountsListReadOnlyKeys(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsListUsages

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.DatabaseAccountsListUsages(ctx, id, cosmosdb.DefaultDatabaseAccountsListUsagesOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseAccountsOfflineRegion

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

payload := cosmosdb.RegionForOnlineOffline{
	// ...
}


if err := client.DatabaseAccountsOfflineRegionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsOnlineRegion

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

payload := cosmosdb.RegionForOnlineOffline{
	// ...
}


if err := client.DatabaseAccountsOnlineRegionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsRegenerateKey

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

payload := cosmosdb.DatabaseAccountRegenerateKeyParameters{
	// ...
}


if err := client.DatabaseAccountsRegenerateKeyThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsUpdate

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

payload := cosmosdb.DatabaseAccountUpdateParameters{
	// ...
}


if err := client.DatabaseAccountsUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseListMetricDefinitions

ctx := context.TODO()
id := cosmosdb.NewDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue")

read, err := client.DatabaseListMetricDefinitions(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseListMetrics

ctx := context.TODO()
id := cosmosdb.NewDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue")

read, err := client.DatabaseListMetrics(ctx, id, cosmosdb.DefaultDatabaseListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.DatabaseListUsages

ctx := context.TODO()
id := cosmosdb.NewDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue")

read, err := client.DatabaseListUsages(ctx, id, cosmosdb.DefaultDatabaseListUsagesOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.GremlinResourcesCreateUpdateGremlinDatabase

ctx := context.TODO()
id := cosmosdb.NewGremlinDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue")

payload := cosmosdb.GremlinDatabaseCreateUpdateParameters{
	// ...
}


if err := client.GremlinResourcesCreateUpdateGremlinDatabaseThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesCreateUpdateGremlinGraph

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue", "graphValue")

payload := cosmosdb.GremlinGraphCreateUpdateParameters{
	// ...
}


if err := client.GremlinResourcesCreateUpdateGremlinGraphThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesDeleteGremlinDatabase

ctx := context.TODO()
id := cosmosdb.NewGremlinDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue")

if err := client.GremlinResourcesDeleteGremlinDatabaseThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesDeleteGremlinGraph

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue", "graphValue")

if err := client.GremlinResourcesDeleteGremlinGraphThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesGetGremlinDatabase

ctx := context.TODO()
id := cosmosdb.NewGremlinDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue")

read, err := client.GremlinResourcesGetGremlinDatabase(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.GremlinResourcesGetGremlinDatabaseThroughput

ctx := context.TODO()
id := cosmosdb.NewGremlinDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue")

read, err := client.GremlinResourcesGetGremlinDatabaseThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.GremlinResourcesGetGremlinGraph

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue", "graphValue")

read, err := client.GremlinResourcesGetGremlinGraph(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.GremlinResourcesGetGremlinGraphThroughput

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue", "graphValue")

read, err := client.GremlinResourcesGetGremlinGraphThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.GremlinResourcesListGremlinDatabases

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.GremlinResourcesListGremlinDatabases(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.GremlinResourcesListGremlinGraphs

ctx := context.TODO()
id := cosmosdb.NewGremlinDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue")

read, err := client.GremlinResourcesListGremlinGraphs(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.GremlinResourcesMigrateGremlinDatabaseToAutoscale

ctx := context.TODO()
id := cosmosdb.NewGremlinDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue")

if err := client.GremlinResourcesMigrateGremlinDatabaseToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesMigrateGremlinDatabaseToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewGremlinDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue")

if err := client.GremlinResourcesMigrateGremlinDatabaseToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesMigrateGremlinGraphToAutoscale

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue", "graphValue")

if err := client.GremlinResourcesMigrateGremlinGraphToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesMigrateGremlinGraphToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue", "graphValue")

if err := client.GremlinResourcesMigrateGremlinGraphToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesUpdateGremlinDatabaseThroughput

ctx := context.TODO()
id := cosmosdb.NewGremlinDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.GremlinResourcesUpdateGremlinDatabaseThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesUpdateGremlinGraphThroughput

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "gremlinDatabaseValue", "graphValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.GremlinResourcesUpdateGremlinGraphThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.LocationsGet

ctx := context.TODO()
id := cosmosdb.NewLocationID("12345678-1234-9876-4563-123456789012", "locationValue")

read, err := client.LocationsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.LocationsList

ctx := context.TODO()
id := cosmosdb.NewSubscriptionID("12345678-1234-9876-4563-123456789012")

read, err := client.LocationsList(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.MongoDBResourcesCreateUpdateMongoDBCollection

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue", "collectionValue")

payload := cosmosdb.MongoDBCollectionCreateUpdateParameters{
	// ...
}


if err := client.MongoDBResourcesCreateUpdateMongoDBCollectionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesCreateUpdateMongoDBDatabase

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue")

payload := cosmosdb.MongoDBDatabaseCreateUpdateParameters{
	// ...
}


if err := client.MongoDBResourcesCreateUpdateMongoDBDatabaseThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesDeleteMongoDBCollection

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue", "collectionValue")

if err := client.MongoDBResourcesDeleteMongoDBCollectionThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesDeleteMongoDBDatabase

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue")

if err := client.MongoDBResourcesDeleteMongoDBDatabaseThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesGetMongoDBCollection

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue", "collectionValue")

read, err := client.MongoDBResourcesGetMongoDBCollection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.MongoDBResourcesGetMongoDBCollectionThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue", "collectionValue")

read, err := client.MongoDBResourcesGetMongoDBCollectionThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.MongoDBResourcesGetMongoDBDatabase

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue")

read, err := client.MongoDBResourcesGetMongoDBDatabase(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.MongoDBResourcesGetMongoDBDatabaseThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue")

read, err := client.MongoDBResourcesGetMongoDBDatabaseThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.MongoDBResourcesListMongoDBCollections

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue")

read, err := client.MongoDBResourcesListMongoDBCollections(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.MongoDBResourcesListMongoDBDatabases

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.MongoDBResourcesListMongoDBDatabases(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.MongoDBResourcesMigrateMongoDBCollectionToAutoscale

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue", "collectionValue")

if err := client.MongoDBResourcesMigrateMongoDBCollectionToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesMigrateMongoDBCollectionToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue", "collectionValue")

if err := client.MongoDBResourcesMigrateMongoDBCollectionToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesMigrateMongoDBDatabaseToAutoscale

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue")

if err := client.MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue")

if err := client.MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesUpdateMongoDBCollectionThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue", "collectionValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.MongoDBResourcesUpdateMongoDBCollectionThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesUpdateMongoDBDatabaseThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "mongodbDatabaseValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.MongoDBResourcesUpdateMongoDBDatabaseThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.PartitionKeyRangeIdListMetrics

ctx := context.TODO()
id := cosmosdb.NewPartitionKeyRangeIdID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "databaseValue", "collectionValue", "partitionKeyRangeIdValue")

read, err := client.PartitionKeyRangeIdListMetrics(ctx, id, cosmosdb.DefaultPartitionKeyRangeIdListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.PartitionKeyRangeIdRegionListMetrics

ctx := context.TODO()
id := cosmosdb.NewCollectionPartitionKeyRangeIdID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "regionValue", "databaseValue", "collectionValue", "partitionKeyRangeIdValue")

read, err := client.PartitionKeyRangeIdRegionListMetrics(ctx, id, cosmosdb.DefaultPartitionKeyRangeIdRegionListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.PercentileListMetrics

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.PercentileListMetrics(ctx, id, cosmosdb.DefaultPercentileListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.PercentileSourceTargetListMetrics

ctx := context.TODO()
id := cosmosdb.NewSourceRegionTargetRegionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sourceRegionValue", "targetRegionValue")

read, err := client.PercentileSourceTargetListMetrics(ctx, id, cosmosdb.DefaultPercentileSourceTargetListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.PercentileTargetListMetrics

ctx := context.TODO()
id := cosmosdb.NewTargetRegionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "targetRegionValue")

read, err := client.PercentileTargetListMetrics(ctx, id, cosmosdb.DefaultPercentileTargetListMetricsOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlContainer

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

payload := cosmosdb.SqlContainerCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlContainerThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlDatabase

ctx := context.TODO()
id := cosmosdb.NewSqlDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue")

payload := cosmosdb.SqlDatabaseCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlDatabaseThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlStoredProcedure

ctx := context.TODO()
id := cosmosdb.NewStoredProcedureID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "storedProcedureValue")

payload := cosmosdb.SqlStoredProcedureCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlStoredProcedureThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlTrigger

ctx := context.TODO()
id := cosmosdb.NewTriggerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "triggerValue")

payload := cosmosdb.SqlTriggerCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlTriggerThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlUserDefinedFunction

ctx := context.TODO()
id := cosmosdb.NewUserDefinedFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "userDefinedFunctionValue")

payload := cosmosdb.SqlUserDefinedFunctionCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlUserDefinedFunctionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlContainer

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

if err := client.SqlResourcesDeleteSqlContainerThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlDatabase

ctx := context.TODO()
id := cosmosdb.NewSqlDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue")

if err := client.SqlResourcesDeleteSqlDatabaseThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlStoredProcedure

ctx := context.TODO()
id := cosmosdb.NewStoredProcedureID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "storedProcedureValue")

if err := client.SqlResourcesDeleteSqlStoredProcedureThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlTrigger

ctx := context.TODO()
id := cosmosdb.NewTriggerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "triggerValue")

if err := client.SqlResourcesDeleteSqlTriggerThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlUserDefinedFunction

ctx := context.TODO()
id := cosmosdb.NewUserDefinedFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "userDefinedFunctionValue")

if err := client.SqlResourcesDeleteSqlUserDefinedFunctionThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesGetSqlContainer

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

read, err := client.SqlResourcesGetSqlContainer(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesGetSqlContainerThroughput

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

read, err := client.SqlResourcesGetSqlContainerThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesGetSqlDatabase

ctx := context.TODO()
id := cosmosdb.NewSqlDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue")

read, err := client.SqlResourcesGetSqlDatabase(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesGetSqlDatabaseThroughput

ctx := context.TODO()
id := cosmosdb.NewSqlDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue")

read, err := client.SqlResourcesGetSqlDatabaseThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesGetSqlStoredProcedure

ctx := context.TODO()
id := cosmosdb.NewStoredProcedureID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "storedProcedureValue")

read, err := client.SqlResourcesGetSqlStoredProcedure(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesGetSqlTrigger

ctx := context.TODO()
id := cosmosdb.NewTriggerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "triggerValue")

read, err := client.SqlResourcesGetSqlTrigger(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesGetSqlUserDefinedFunction

ctx := context.TODO()
id := cosmosdb.NewUserDefinedFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue", "userDefinedFunctionValue")

read, err := client.SqlResourcesGetSqlUserDefinedFunction(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesListSqlContainers

ctx := context.TODO()
id := cosmosdb.NewSqlDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue")

read, err := client.SqlResourcesListSqlContainers(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesListSqlDatabases

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.SqlResourcesListSqlDatabases(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesListSqlStoredProcedures

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

read, err := client.SqlResourcesListSqlStoredProcedures(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesListSqlTriggers

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

read, err := client.SqlResourcesListSqlTriggers(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesListSqlUserDefinedFunctions

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

read, err := client.SqlResourcesListSqlUserDefinedFunctions(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.SqlResourcesMigrateSqlContainerToAutoscale

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

if err := client.SqlResourcesMigrateSqlContainerToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesMigrateSqlContainerToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

if err := client.SqlResourcesMigrateSqlContainerToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesMigrateSqlDatabaseToAutoscale

ctx := context.TODO()
id := cosmosdb.NewSqlDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue")

if err := client.SqlResourcesMigrateSqlDatabaseToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesMigrateSqlDatabaseToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewSqlDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue")

if err := client.SqlResourcesMigrateSqlDatabaseToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesUpdateSqlContainerThroughput

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue", "containerValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.SqlResourcesUpdateSqlContainerThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesUpdateSqlDatabaseThroughput

ctx := context.TODO()
id := cosmosdb.NewSqlDatabaseID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "sqlDatabaseValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.SqlResourcesUpdateSqlDatabaseThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesCreateUpdateTable

ctx := context.TODO()
id := cosmosdb.NewTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "tableValue")

payload := cosmosdb.TableCreateUpdateParameters{
	// ...
}


if err := client.TableResourcesCreateUpdateTableThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesDeleteTable

ctx := context.TODO()
id := cosmosdb.NewTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "tableValue")

if err := client.TableResourcesDeleteTableThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesGetTable

ctx := context.TODO()
id := cosmosdb.NewTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "tableValue")

read, err := client.TableResourcesGetTable(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.TableResourcesGetTableThroughput

ctx := context.TODO()
id := cosmosdb.NewTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "tableValue")

read, err := client.TableResourcesGetTableThroughput(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.TableResourcesListTables

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue")

read, err := client.TableResourcesListTables(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: CosmosDBClient.TableResourcesMigrateTableToAutoscale

ctx := context.TODO()
id := cosmosdb.NewTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "tableValue")

if err := client.TableResourcesMigrateTableToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesMigrateTableToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "tableValue")

if err := client.TableResourcesMigrateTableToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesUpdateTableThroughput

ctx := context.TODO()
id := cosmosdb.NewTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "databaseAccountValue", "tableValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.TableResourcesUpdateTableThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func PossibleValuesForAnalyticalStorageSchemaType ¶

func PossibleValuesForAnalyticalStorageSchemaType() []string

func PossibleValuesForBackupPolicyMigrationStatus ¶

func PossibleValuesForBackupPolicyMigrationStatus() []string

func PossibleValuesForBackupPolicyType ¶

func PossibleValuesForBackupPolicyType() []string

func PossibleValuesForBackupStorageRedundancy ¶

func PossibleValuesForBackupStorageRedundancy() []string

func PossibleValuesForCompositePathSortOrder ¶

func PossibleValuesForCompositePathSortOrder() []string

func PossibleValuesForConflictResolutionMode ¶

func PossibleValuesForConflictResolutionMode() []string

func PossibleValuesForConnectorOffer ¶

func PossibleValuesForConnectorOffer() []string

func PossibleValuesForCreateMode ¶

func PossibleValuesForCreateMode() []string

func PossibleValuesForDataType ¶

func PossibleValuesForDataType() []string

func PossibleValuesForDatabaseAccountKind ¶

func PossibleValuesForDatabaseAccountKind() []string

func PossibleValuesForDatabaseAccountOfferType ¶

func PossibleValuesForDatabaseAccountOfferType() []string

func PossibleValuesForDefaultConsistencyLevel ¶

func PossibleValuesForDefaultConsistencyLevel() []string

func PossibleValuesForIndexKind ¶

func PossibleValuesForIndexKind() []string

func PossibleValuesForIndexingMode ¶

func PossibleValuesForIndexingMode() []string

func PossibleValuesForKeyKind ¶

func PossibleValuesForKeyKind() []string

func PossibleValuesForNetworkAclBypass ¶

func PossibleValuesForNetworkAclBypass() []string

func PossibleValuesForPartitionKind ¶

func PossibleValuesForPartitionKind() []string

func PossibleValuesForPrimaryAggregationType ¶

func PossibleValuesForPrimaryAggregationType() []string

func PossibleValuesForPublicNetworkAccess ¶

func PossibleValuesForPublicNetworkAccess() []string

func PossibleValuesForRestoreMode ¶

func PossibleValuesForRestoreMode() []string

func PossibleValuesForServerVersion ¶

func PossibleValuesForServerVersion() []string

func PossibleValuesForSpatialType ¶

func PossibleValuesForSpatialType() []string

func PossibleValuesForTriggerOperation ¶

func PossibleValuesForTriggerOperation() []string

func PossibleValuesForTriggerType ¶

func PossibleValuesForTriggerType() []string

func PossibleValuesForUnitType ¶

func PossibleValuesForUnitType() []string

func ValidateCassandraKeyspaceID ¶

func ValidateCassandraKeyspaceID(input interface{}, key string) (warnings []string, errors []error)

ValidateCassandraKeyspaceID checks that 'input' can be parsed as a Cassandra Keyspace ID

func ValidateCassandraKeyspaceTableID ¶

func ValidateCassandraKeyspaceTableID(input interface{}, key string) (warnings []string, errors []error)

ValidateCassandraKeyspaceTableID checks that 'input' can be parsed as a Cassandra Keyspace Table ID

func ValidateCollectionID ¶

func ValidateCollectionID(input interface{}, key string) (warnings []string, errors []error)

ValidateCollectionID checks that 'input' can be parsed as a Collection ID

func ValidateCollectionPartitionKeyRangeIdID ¶

func ValidateCollectionPartitionKeyRangeIdID(input interface{}, key string) (warnings []string, errors []error)

ValidateCollectionPartitionKeyRangeIdID checks that 'input' can be parsed as a Collection Partition Key Range Id ID

func ValidateContainerID ¶

func ValidateContainerID(input interface{}, key string) (warnings []string, errors []error)

ValidateContainerID checks that 'input' can be parsed as a Container ID

func ValidateDatabaseAccountID ¶

func ValidateDatabaseAccountID(input interface{}, key string) (warnings []string, errors []error)

ValidateDatabaseAccountID checks that 'input' can be parsed as a Database Account ID

func ValidateDatabaseAccountNameID ¶

func ValidateDatabaseAccountNameID(input interface{}, key string) (warnings []string, errors []error)

ValidateDatabaseAccountNameID checks that 'input' can be parsed as a Database Account Name ID

func ValidateDatabaseCollectionID ¶

func ValidateDatabaseCollectionID(input interface{}, key string) (warnings []string, errors []error)

ValidateDatabaseCollectionID checks that 'input' can be parsed as a Database Collection ID

func ValidateDatabaseID ¶

func ValidateDatabaseID(input interface{}, key string) (warnings []string, errors []error)

ValidateDatabaseID checks that 'input' can be parsed as a Database ID

func ValidateGraphID ¶

func ValidateGraphID(input interface{}, key string) (warnings []string, errors []error)

ValidateGraphID checks that 'input' can be parsed as a Graph ID

func ValidateGremlinDatabaseID ¶

func ValidateGremlinDatabaseID(input interface{}, key string) (warnings []string, errors []error)

ValidateGremlinDatabaseID checks that 'input' can be parsed as a Gremlin Database ID

func ValidateLocationID ¶

func ValidateLocationID(input interface{}, key string) (warnings []string, errors []error)

ValidateLocationID checks that 'input' can be parsed as a Location ID

func ValidateMongodbDatabaseCollectionID ¶

func ValidateMongodbDatabaseCollectionID(input interface{}, key string) (warnings []string, errors []error)

ValidateMongodbDatabaseCollectionID checks that 'input' can be parsed as a Mongodb Database Collection ID

func ValidateMongodbDatabaseID ¶

func ValidateMongodbDatabaseID(input interface{}, key string) (warnings []string, errors []error)

ValidateMongodbDatabaseID checks that 'input' can be parsed as a Mongodb Database ID

func ValidatePartitionKeyRangeIdID ¶

func ValidatePartitionKeyRangeIdID(input interface{}, key string) (warnings []string, errors []error)

ValidatePartitionKeyRangeIdID checks that 'input' can be parsed as a Partition Key Range Id ID

func ValidateRegionID ¶

func ValidateRegionID(input interface{}, key string) (warnings []string, errors []error)

ValidateRegionID checks that 'input' can be parsed as a Region ID

func ValidateSourceRegionTargetRegionID ¶

func ValidateSourceRegionTargetRegionID(input interface{}, key string) (warnings []string, errors []error)

ValidateSourceRegionTargetRegionID checks that 'input' can be parsed as a Source Region Target Region ID

func ValidateSqlDatabaseID ¶

func ValidateSqlDatabaseID(input interface{}, key string) (warnings []string, errors []error)

ValidateSqlDatabaseID checks that 'input' can be parsed as a Sql Database ID

func ValidateStoredProcedureID ¶

func ValidateStoredProcedureID(input interface{}, key string) (warnings []string, errors []error)

ValidateStoredProcedureID checks that 'input' can be parsed as a Stored Procedure ID

func ValidateTableID ¶

func ValidateTableID(input interface{}, key string) (warnings []string, errors []error)

ValidateTableID checks that 'input' can be parsed as a Table ID

func ValidateTargetRegionID ¶

func ValidateTargetRegionID(input interface{}, key string) (warnings []string, errors []error)

ValidateTargetRegionID checks that 'input' can be parsed as a Target Region ID

func ValidateTriggerID ¶

func ValidateTriggerID(input interface{}, key string) (warnings []string, errors []error)

ValidateTriggerID checks that 'input' can be parsed as a Trigger ID

func ValidateUserDefinedFunctionID ¶

func ValidateUserDefinedFunctionID(input interface{}, key string) (warnings []string, errors []error)

ValidateUserDefinedFunctionID checks that 'input' can be parsed as a User Defined Function ID

Types ¶

type AnalyticalStorageConfiguration ¶

type AnalyticalStorageConfiguration struct {
	SchemaType *AnalyticalStorageSchemaType `json:"schemaType,omitempty"`
}

type AnalyticalStorageSchemaType ¶

type AnalyticalStorageSchemaType string
const (
	AnalyticalStorageSchemaTypeFullFidelity AnalyticalStorageSchemaType = "FullFidelity"
	AnalyticalStorageSchemaTypeWellDefined  AnalyticalStorageSchemaType = "WellDefined"
)

type ApiProperties ¶

type ApiProperties struct {
	ServerVersion *ServerVersion `json:"serverVersion,omitempty"`
}

type AutoScaleSettings ¶

type AutoScaleSettings struct {
	MaxThroughput *int64 `json:"maxThroughput,omitempty"`
}

type AutoUpgradePolicyResource ¶

type AutoUpgradePolicyResource struct {
	ThroughputPolicy *ThroughputPolicyResource `json:"throughputPolicy,omitempty"`
}

type AutoscaleSettingsResource ¶

type AutoscaleSettingsResource struct {
	AutoUpgradePolicy   *AutoUpgradePolicyResource `json:"autoUpgradePolicy,omitempty"`
	MaxThroughput       int64                      `json:"maxThroughput"`
	TargetMaxThroughput *int64                     `json:"targetMaxThroughput,omitempty"`
}

type BackupPolicy ¶

type BackupPolicy interface {
}

type BackupPolicyMigrationState ¶

type BackupPolicyMigrationState struct {
	StartTime  *string                      `json:"startTime,omitempty"`
	Status     *BackupPolicyMigrationStatus `json:"status,omitempty"`
	TargetType *BackupPolicyType            `json:"targetType,omitempty"`
}

func (*BackupPolicyMigrationState) GetStartTimeAsTime ¶

func (o *BackupPolicyMigrationState) GetStartTimeAsTime() (*time.Time, error)

func (*BackupPolicyMigrationState) SetStartTimeAsTime ¶

func (o *BackupPolicyMigrationState) SetStartTimeAsTime(input time.Time)

type BackupPolicyMigrationStatus ¶

type BackupPolicyMigrationStatus string
const (
	BackupPolicyMigrationStatusCompleted  BackupPolicyMigrationStatus = "Completed"
	BackupPolicyMigrationStatusFailed     BackupPolicyMigrationStatus = "Failed"
	BackupPolicyMigrationStatusInProgress BackupPolicyMigrationStatus = "InProgress"
	BackupPolicyMigrationStatusInvalid    BackupPolicyMigrationStatus = "Invalid"
)

type BackupPolicyType ¶

type BackupPolicyType string
const (
	BackupPolicyTypeContinuous BackupPolicyType = "Continuous"
	BackupPolicyTypePeriodic   BackupPolicyType = "Periodic"
)

type BackupStorageRedundancy ¶

type BackupStorageRedundancy string
const (
	BackupStorageRedundancyGeo   BackupStorageRedundancy = "Geo"
	BackupStorageRedundancyLocal BackupStorageRedundancy = "Local"
	BackupStorageRedundancyZone  BackupStorageRedundancy = "Zone"
)

type Capability ¶

type Capability struct {
	Name *string `json:"name,omitempty"`
}

type Capacity ¶

type Capacity struct {
	TotalThroughputLimit *int64 `json:"totalThroughputLimit,omitempty"`
}

type CassandraKeyspaceCreateUpdateParameters ¶

type CassandraKeyspaceCreateUpdateParameters struct {
	Id         *string                                 `json:"id,omitempty"`
	Location   *string                                 `json:"location,omitempty"`
	Name       *string                                 `json:"name,omitempty"`
	Properties CassandraKeyspaceCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                      `json:"tags,omitempty"`
	Type       *string                                 `json:"type,omitempty"`
}

type CassandraKeyspaceCreateUpdateProperties ¶

type CassandraKeyspaceCreateUpdateProperties struct {
	Options  *CreateUpdateOptions      `json:"options,omitempty"`
	Resource CassandraKeyspaceResource `json:"resource"`
}

type CassandraKeyspaceGetProperties ¶

type CassandraKeyspaceGetProperties struct {
	Options  *OptionsResource                        `json:"options,omitempty"`
	Resource *CassandraKeyspaceGetPropertiesResource `json:"resource,omitempty"`
}

type CassandraKeyspaceGetPropertiesResource ¶ added in v0.20230503.1140953

type CassandraKeyspaceGetPropertiesResource struct {
	Etag *string  `json:"_etag,omitempty"`
	Id   *string  `json:"id,omitempty"`
	Rid  *string  `json:"_rid,omitempty"`
	Ts   *float64 `json:"_ts,omitempty"`
}

type CassandraKeyspaceGetResults ¶

type CassandraKeyspaceGetResults struct {
	Id         *string                         `json:"id,omitempty"`
	Location   *string                         `json:"location,omitempty"`
	Name       *string                         `json:"name,omitempty"`
	Properties *CassandraKeyspaceGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string              `json:"tags,omitempty"`
	Type       *string                         `json:"type,omitempty"`
}

type CassandraKeyspaceId ¶

type CassandraKeyspaceId struct {
	SubscriptionId        string
	ResourceGroupName     string
	DatabaseAccountName   string
	CassandraKeyspaceName string
}

CassandraKeyspaceId is a struct representing the Resource ID for a Cassandra Keyspace

func NewCassandraKeyspaceID ¶

func NewCassandraKeyspaceID(subscriptionId string, resourceGroupName string, databaseAccountName string, cassandraKeyspaceName string) CassandraKeyspaceId

NewCassandraKeyspaceID returns a new CassandraKeyspaceId struct

func ParseCassandraKeyspaceID ¶

func ParseCassandraKeyspaceID(input string) (*CassandraKeyspaceId, error)

ParseCassandraKeyspaceID parses 'input' into a CassandraKeyspaceId

func ParseCassandraKeyspaceIDInsensitively ¶

func ParseCassandraKeyspaceIDInsensitively(input string) (*CassandraKeyspaceId, error)

ParseCassandraKeyspaceIDInsensitively parses 'input' case-insensitively into a CassandraKeyspaceId note: this method should only be used for API response data and not user input

func (CassandraKeyspaceId) ID ¶

func (id CassandraKeyspaceId) ID() string

ID returns the formatted Cassandra Keyspace ID

func (CassandraKeyspaceId) Segments ¶

func (id CassandraKeyspaceId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Cassandra Keyspace ID

func (CassandraKeyspaceId) String ¶

func (id CassandraKeyspaceId) String() string

String returns a human-readable description of this Cassandra Keyspace ID

type CassandraKeyspaceListResult ¶

type CassandraKeyspaceListResult struct {
	Value *[]CassandraKeyspaceGetResults `json:"value,omitempty"`
}

type CassandraKeyspaceResource ¶

type CassandraKeyspaceResource struct {
	Id string `json:"id"`
}

type CassandraKeyspaceTableId ¶

type CassandraKeyspaceTableId struct {
	SubscriptionId        string
	ResourceGroupName     string
	DatabaseAccountName   string
	CassandraKeyspaceName string
	TableName             string
}

CassandraKeyspaceTableId is a struct representing the Resource ID for a Cassandra Keyspace Table

func NewCassandraKeyspaceTableID ¶

func NewCassandraKeyspaceTableID(subscriptionId string, resourceGroupName string, databaseAccountName string, cassandraKeyspaceName string, tableName string) CassandraKeyspaceTableId

NewCassandraKeyspaceTableID returns a new CassandraKeyspaceTableId struct

func ParseCassandraKeyspaceTableID ¶

func ParseCassandraKeyspaceTableID(input string) (*CassandraKeyspaceTableId, error)

ParseCassandraKeyspaceTableID parses 'input' into a CassandraKeyspaceTableId

func ParseCassandraKeyspaceTableIDInsensitively ¶

func ParseCassandraKeyspaceTableIDInsensitively(input string) (*CassandraKeyspaceTableId, error)

ParseCassandraKeyspaceTableIDInsensitively parses 'input' case-insensitively into a CassandraKeyspaceTableId note: this method should only be used for API response data and not user input

func (CassandraKeyspaceTableId) ID ¶

ID returns the formatted Cassandra Keyspace Table ID

func (CassandraKeyspaceTableId) Segments ¶

Segments returns a slice of Resource ID Segments which comprise this Cassandra Keyspace Table ID

func (CassandraKeyspaceTableId) String ¶

func (id CassandraKeyspaceTableId) String() string

String returns a human-readable description of this Cassandra Keyspace Table ID

type CassandraPartitionKey ¶

type CassandraPartitionKey struct {
	Name *string `json:"name,omitempty"`
}

type CassandraResourcesCreateUpdateCassandraKeyspaceOperationResponse ¶

type CassandraResourcesCreateUpdateCassandraKeyspaceOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesCreateUpdateCassandraTableOperationResponse ¶

type CassandraResourcesCreateUpdateCassandraTableOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesDeleteCassandraKeyspaceOperationResponse ¶

type CassandraResourcesDeleteCassandraKeyspaceOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesDeleteCassandraTableOperationResponse ¶

type CassandraResourcesDeleteCassandraTableOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesGetCassandraKeyspaceOperationResponse ¶

type CassandraResourcesGetCassandraKeyspaceOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraKeyspaceGetResults
}

type CassandraResourcesGetCassandraKeyspaceThroughputOperationResponse ¶

type CassandraResourcesGetCassandraKeyspaceThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type CassandraResourcesGetCassandraTableOperationResponse ¶

type CassandraResourcesGetCassandraTableOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraTableGetResults
}

type CassandraResourcesGetCassandraTableThroughputOperationResponse ¶

type CassandraResourcesGetCassandraTableThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type CassandraResourcesListCassandraKeyspacesOperationResponse ¶

type CassandraResourcesListCassandraKeyspacesOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraKeyspaceListResult
}

type CassandraResourcesListCassandraTablesOperationResponse ¶

type CassandraResourcesListCassandraTablesOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraTableListResult
}

type CassandraResourcesMigrateCassandraKeyspaceToAutoscaleOperationResponse ¶

type CassandraResourcesMigrateCassandraKeyspaceToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesMigrateCassandraKeyspaceToManualThroughputOperationResponse ¶

type CassandraResourcesMigrateCassandraKeyspaceToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesMigrateCassandraTableToAutoscaleOperationResponse ¶

type CassandraResourcesMigrateCassandraTableToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesMigrateCassandraTableToManualThroughputOperationResponse ¶

type CassandraResourcesMigrateCassandraTableToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesUpdateCassandraKeyspaceThroughputOperationResponse ¶

type CassandraResourcesUpdateCassandraKeyspaceThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesUpdateCassandraTableThroughputOperationResponse ¶

type CassandraResourcesUpdateCassandraTableThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraSchema ¶

type CassandraSchema struct {
	ClusterKeys   *[]ClusterKey            `json:"clusterKeys,omitempty"`
	Columns       *[]Column                `json:"columns,omitempty"`
	PartitionKeys *[]CassandraPartitionKey `json:"partitionKeys,omitempty"`
}

type CassandraTableCreateUpdateParameters ¶

type CassandraTableCreateUpdateParameters struct {
	Id         *string                              `json:"id,omitempty"`
	Location   *string                              `json:"location,omitempty"`
	Name       *string                              `json:"name,omitempty"`
	Properties CassandraTableCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                   `json:"tags,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type CassandraTableCreateUpdateProperties ¶

type CassandraTableCreateUpdateProperties struct {
	Options  *CreateUpdateOptions   `json:"options,omitempty"`
	Resource CassandraTableResource `json:"resource"`
}

type CassandraTableGetProperties ¶

type CassandraTableGetProperties struct {
	Options  *OptionsResource                     `json:"options,omitempty"`
	Resource *CassandraTableGetPropertiesResource `json:"resource,omitempty"`
}

type CassandraTableGetPropertiesResource ¶ added in v0.20230503.1140953

type CassandraTableGetPropertiesResource struct {
	AnalyticalStorageTtl *int64           `json:"analyticalStorageTtl,omitempty"`
	DefaultTtl           *int64           `json:"defaultTtl,omitempty"`
	Etag                 *string          `json:"_etag,omitempty"`
	Id                   *string          `json:"id,omitempty"`
	Rid                  *string          `json:"_rid,omitempty"`
	Schema               *CassandraSchema `json:"schema,omitempty"`
	Ts                   *float64         `json:"_ts,omitempty"`
}

type CassandraTableGetResults ¶

type CassandraTableGetResults struct {
	Id         *string                      `json:"id,omitempty"`
	Location   *string                      `json:"location,omitempty"`
	Name       *string                      `json:"name,omitempty"`
	Properties *CassandraTableGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string           `json:"tags,omitempty"`
	Type       *string                      `json:"type,omitempty"`
}

type CassandraTableListResult ¶

type CassandraTableListResult struct {
	Value *[]CassandraTableGetResults `json:"value,omitempty"`
}

type CassandraTableResource ¶

type CassandraTableResource struct {
	AnalyticalStorageTtl *int64           `json:"analyticalStorageTtl,omitempty"`
	DefaultTtl           *int64           `json:"defaultTtl,omitempty"`
	Id                   string           `json:"id"`
	Schema               *CassandraSchema `json:"schema,omitempty"`
}

type ClusterKey ¶

type ClusterKey struct {
	Name    *string `json:"name,omitempty"`
	OrderBy *string `json:"orderBy,omitempty"`
}

type CollectionId ¶

type CollectionId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	DatabaseName        string
	CollectionName      string
}

CollectionId is a struct representing the Resource ID for a Collection

func NewCollectionID ¶

func NewCollectionID(subscriptionId string, resourceGroupName string, databaseAccountName string, databaseName string, collectionName string) CollectionId

NewCollectionID returns a new CollectionId struct

func ParseCollectionID ¶

func ParseCollectionID(input string) (*CollectionId, error)

ParseCollectionID parses 'input' into a CollectionId

func ParseCollectionIDInsensitively ¶

func ParseCollectionIDInsensitively(input string) (*CollectionId, error)

ParseCollectionIDInsensitively parses 'input' case-insensitively into a CollectionId note: this method should only be used for API response data and not user input

func (CollectionId) ID ¶

func (id CollectionId) ID() string

ID returns the formatted Collection ID

func (CollectionId) Segments ¶

func (id CollectionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Collection ID

func (CollectionId) String ¶

func (id CollectionId) String() string

String returns a human-readable description of this Collection ID

type CollectionListMetricDefinitionsOperationResponse ¶

type CollectionListMetricDefinitionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricDefinitionsListResult
}

type CollectionListMetricsOperationOptions ¶

type CollectionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultCollectionListMetricsOperationOptions ¶

func DefaultCollectionListMetricsOperationOptions() CollectionListMetricsOperationOptions

type CollectionListMetricsOperationResponse ¶

type CollectionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type CollectionListUsagesOperationOptions ¶

type CollectionListUsagesOperationOptions struct {
	Filter *string
}

func DefaultCollectionListUsagesOperationOptions ¶

func DefaultCollectionListUsagesOperationOptions() CollectionListUsagesOperationOptions

type CollectionListUsagesOperationResponse ¶

type CollectionListUsagesOperationResponse struct {
	HttpResponse *http.Response
	Model        *UsagesResult
}

type CollectionPartitionKeyRangeIdId ¶

type CollectionPartitionKeyRangeIdId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	RegionName          string
	DatabaseName        string
	CollectionName      string
	PartitionKeyRangeId string
}

CollectionPartitionKeyRangeIdId is a struct representing the Resource ID for a Collection Partition Key Range Id

func NewCollectionPartitionKeyRangeIdID ¶

func NewCollectionPartitionKeyRangeIdID(subscriptionId string, resourceGroupName string, databaseAccountName string, regionName string, databaseName string, collectionName string, partitionKeyRangeId string) CollectionPartitionKeyRangeIdId

NewCollectionPartitionKeyRangeIdID returns a new CollectionPartitionKeyRangeIdId struct

func ParseCollectionPartitionKeyRangeIdID ¶

func ParseCollectionPartitionKeyRangeIdID(input string) (*CollectionPartitionKeyRangeIdId, error)

ParseCollectionPartitionKeyRangeIdID parses 'input' into a CollectionPartitionKeyRangeIdId

func ParseCollectionPartitionKeyRangeIdIDInsensitively ¶

func ParseCollectionPartitionKeyRangeIdIDInsensitively(input string) (*CollectionPartitionKeyRangeIdId, error)

ParseCollectionPartitionKeyRangeIdIDInsensitively parses 'input' case-insensitively into a CollectionPartitionKeyRangeIdId note: this method should only be used for API response data and not user input

func (CollectionPartitionKeyRangeIdId) ID ¶

ID returns the formatted Collection Partition Key Range Id ID

func (CollectionPartitionKeyRangeIdId) Segments ¶

Segments returns a slice of Resource ID Segments which comprise this Collection Partition Key Range Id ID

func (CollectionPartitionKeyRangeIdId) String ¶

String returns a human-readable description of this Collection Partition Key Range Id ID

type CollectionPartitionListMetricsOperationOptions ¶

type CollectionPartitionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultCollectionPartitionListMetricsOperationOptions ¶

func DefaultCollectionPartitionListMetricsOperationOptions() CollectionPartitionListMetricsOperationOptions

type CollectionPartitionListMetricsOperationResponse ¶

type CollectionPartitionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionMetricListResult
}

type CollectionPartitionListUsagesOperationOptions ¶

type CollectionPartitionListUsagesOperationOptions struct {
	Filter *string
}

func DefaultCollectionPartitionListUsagesOperationOptions ¶

func DefaultCollectionPartitionListUsagesOperationOptions() CollectionPartitionListUsagesOperationOptions

type CollectionPartitionListUsagesOperationResponse ¶

type CollectionPartitionListUsagesOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionUsagesResult
}

type CollectionPartitionRegionListMetricsOperationOptions ¶

type CollectionPartitionRegionListMetricsOperationOptions struct {
	Filter *string
}

type CollectionPartitionRegionListMetricsOperationResponse ¶

type CollectionPartitionRegionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionMetricListResult
}

type CollectionRegionListMetricsOperationOptions ¶

type CollectionRegionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultCollectionRegionListMetricsOperationOptions ¶

func DefaultCollectionRegionListMetricsOperationOptions() CollectionRegionListMetricsOperationOptions

type CollectionRegionListMetricsOperationResponse ¶

type CollectionRegionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type Column ¶

type Column struct {
	Name *string `json:"name,omitempty"`
	Type *string `json:"type,omitempty"`
}

type CompositePath ¶

type CompositePath struct {
	Order *CompositePathSortOrder `json:"order,omitempty"`
	Path  *string                 `json:"path,omitempty"`
}

type CompositePathSortOrder ¶

type CompositePathSortOrder string
const (
	CompositePathSortOrderAscending  CompositePathSortOrder = "ascending"
	CompositePathSortOrderDescending CompositePathSortOrder = "descending"
)

type ConflictResolutionMode ¶

type ConflictResolutionMode string
const (
	ConflictResolutionModeCustom         ConflictResolutionMode = "Custom"
	ConflictResolutionModeLastWriterWins ConflictResolutionMode = "LastWriterWins"
)

type ConflictResolutionPolicy ¶

type ConflictResolutionPolicy struct {
	ConflictResolutionPath      *string                 `json:"conflictResolutionPath,omitempty"`
	ConflictResolutionProcedure *string                 `json:"conflictResolutionProcedure,omitempty"`
	Mode                        *ConflictResolutionMode `json:"mode,omitempty"`
}

type ConnectorOffer ¶

type ConnectorOffer string
const (
	ConnectorOfferSmall ConnectorOffer = "Small"
)

type ConsistencyPolicy ¶

type ConsistencyPolicy struct {
	DefaultConsistencyLevel DefaultConsistencyLevel `json:"defaultConsistencyLevel"`
	MaxIntervalInSeconds    *int64                  `json:"maxIntervalInSeconds,omitempty"`
	MaxStalenessPrefix      *int64                  `json:"maxStalenessPrefix,omitempty"`
}

type ContainerId ¶

type ContainerId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	SqlDatabaseName     string
	ContainerName       string
}

ContainerId is a struct representing the Resource ID for a Container

func NewContainerID ¶

func NewContainerID(subscriptionId string, resourceGroupName string, databaseAccountName string, sqlDatabaseName string, containerName string) ContainerId

NewContainerID returns a new ContainerId struct

func ParseContainerID ¶

func ParseContainerID(input string) (*ContainerId, error)

ParseContainerID parses 'input' into a ContainerId

func ParseContainerIDInsensitively ¶

func ParseContainerIDInsensitively(input string) (*ContainerId, error)

ParseContainerIDInsensitively parses 'input' case-insensitively into a ContainerId note: this method should only be used for API response data and not user input

func (ContainerId) ID ¶

func (id ContainerId) ID() string

ID returns the formatted Container ID

func (ContainerId) Segments ¶

func (id ContainerId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Container ID

func (ContainerId) String ¶

func (id ContainerId) String() string

String returns a human-readable description of this Container ID

type ContainerPartitionKey ¶

type ContainerPartitionKey struct {
	Kind      *PartitionKind `json:"kind,omitempty"`
	Paths     *[]string      `json:"paths,omitempty"`
	SystemKey *bool          `json:"systemKey,omitempty"`
	Version   *int64         `json:"version,omitempty"`
}

type ContinuousModeBackupPolicy ¶

type ContinuousModeBackupPolicy struct {

	// Fields inherited from BackupPolicy
	MigrationState *BackupPolicyMigrationState `json:"migrationState,omitempty"`
}

func (ContinuousModeBackupPolicy) MarshalJSON ¶

func (s ContinuousModeBackupPolicy) MarshalJSON() ([]byte, error)

type CorsPolicy ¶

type CorsPolicy struct {
	AllowedHeaders  *string `json:"allowedHeaders,omitempty"`
	AllowedMethods  *string `json:"allowedMethods,omitempty"`
	AllowedOrigins  string  `json:"allowedOrigins"`
	ExposedHeaders  *string `json:"exposedHeaders,omitempty"`
	MaxAgeInSeconds *int64  `json:"maxAgeInSeconds,omitempty"`
}

type CosmosDBClient ¶

type CosmosDBClient struct {
	Client autorest.Client
	// contains filtered or unexported fields
}

func NewCosmosDBClientWithBaseURI ¶

func NewCosmosDBClientWithBaseURI(endpoint string) CosmosDBClient

func (CosmosDBClient) CassandraResourcesCreateUpdateCassandraKeyspace ¶

CassandraResourcesCreateUpdateCassandraKeyspace ...

func (CosmosDBClient) CassandraResourcesCreateUpdateCassandraKeyspaceThenPoll ¶

func (c CosmosDBClient) CassandraResourcesCreateUpdateCassandraKeyspaceThenPoll(ctx context.Context, id CassandraKeyspaceId, input CassandraKeyspaceCreateUpdateParameters) error

CassandraResourcesCreateUpdateCassandraKeyspaceThenPoll performs CassandraResourcesCreateUpdateCassandraKeyspace then polls until it's completed

func (CosmosDBClient) CassandraResourcesCreateUpdateCassandraTable ¶

CassandraResourcesCreateUpdateCassandraTable ...

func (CosmosDBClient) CassandraResourcesCreateUpdateCassandraTableThenPoll ¶

func (c CosmosDBClient) CassandraResourcesCreateUpdateCassandraTableThenPoll(ctx context.Context, id CassandraKeyspaceTableId, input CassandraTableCreateUpdateParameters) error

CassandraResourcesCreateUpdateCassandraTableThenPoll performs CassandraResourcesCreateUpdateCassandraTable then polls until it's completed

func (CosmosDBClient) CassandraResourcesDeleteCassandraKeyspace ¶

func (c CosmosDBClient) CassandraResourcesDeleteCassandraKeyspace(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesDeleteCassandraKeyspaceOperationResponse, err error)

CassandraResourcesDeleteCassandraKeyspace ...

func (CosmosDBClient) CassandraResourcesDeleteCassandraKeyspaceThenPoll ¶

func (c CosmosDBClient) CassandraResourcesDeleteCassandraKeyspaceThenPoll(ctx context.Context, id CassandraKeyspaceId) error

CassandraResourcesDeleteCassandraKeyspaceThenPoll performs CassandraResourcesDeleteCassandraKeyspace then polls until it's completed

func (CosmosDBClient) CassandraResourcesDeleteCassandraTable ¶

func (c CosmosDBClient) CassandraResourcesDeleteCassandraTable(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesDeleteCassandraTableOperationResponse, err error)

CassandraResourcesDeleteCassandraTable ...

func (CosmosDBClient) CassandraResourcesDeleteCassandraTableThenPoll ¶

func (c CosmosDBClient) CassandraResourcesDeleteCassandraTableThenPoll(ctx context.Context, id CassandraKeyspaceTableId) error

CassandraResourcesDeleteCassandraTableThenPoll performs CassandraResourcesDeleteCassandraTable then polls until it's completed

func (CosmosDBClient) CassandraResourcesGetCassandraKeyspace ¶

func (c CosmosDBClient) CassandraResourcesGetCassandraKeyspace(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesGetCassandraKeyspaceOperationResponse, err error)

CassandraResourcesGetCassandraKeyspace ...

func (CosmosDBClient) CassandraResourcesGetCassandraKeyspaceThroughput ¶

func (c CosmosDBClient) CassandraResourcesGetCassandraKeyspaceThroughput(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesGetCassandraKeyspaceThroughputOperationResponse, err error)

CassandraResourcesGetCassandraKeyspaceThroughput ...

func (CosmosDBClient) CassandraResourcesGetCassandraTable ¶

func (c CosmosDBClient) CassandraResourcesGetCassandraTable(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesGetCassandraTableOperationResponse, err error)

CassandraResourcesGetCassandraTable ...

func (CosmosDBClient) CassandraResourcesGetCassandraTableThroughput ¶

func (c CosmosDBClient) CassandraResourcesGetCassandraTableThroughput(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesGetCassandraTableThroughputOperationResponse, err error)

CassandraResourcesGetCassandraTableThroughput ...

func (CosmosDBClient) CassandraResourcesListCassandraKeyspaces ¶

func (c CosmosDBClient) CassandraResourcesListCassandraKeyspaces(ctx context.Context, id DatabaseAccountId) (result CassandraResourcesListCassandraKeyspacesOperationResponse, err error)

CassandraResourcesListCassandraKeyspaces ...

func (CosmosDBClient) CassandraResourcesListCassandraTables ¶

func (c CosmosDBClient) CassandraResourcesListCassandraTables(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesListCassandraTablesOperationResponse, err error)

CassandraResourcesListCassandraTables ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToAutoscale ¶

func (c CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToAutoscale(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesMigrateCassandraKeyspaceToAutoscaleOperationResponse, err error)

CassandraResourcesMigrateCassandraKeyspaceToAutoscale ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToAutoscaleThenPoll ¶

func (c CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToAutoscaleThenPoll(ctx context.Context, id CassandraKeyspaceId) error

CassandraResourcesMigrateCassandraKeyspaceToAutoscaleThenPoll performs CassandraResourcesMigrateCassandraKeyspaceToAutoscale then polls until it's completed

func (CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToManualThroughput ¶

func (c CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToManualThroughput(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesMigrateCassandraKeyspaceToManualThroughputOperationResponse, err error)

CassandraResourcesMigrateCassandraKeyspaceToManualThroughput ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToManualThroughputThenPoll ¶

func (c CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToManualThroughputThenPoll(ctx context.Context, id CassandraKeyspaceId) error

CassandraResourcesMigrateCassandraKeyspaceToManualThroughputThenPoll performs CassandraResourcesMigrateCassandraKeyspaceToManualThroughput then polls until it's completed

func (CosmosDBClient) CassandraResourcesMigrateCassandraTableToAutoscale ¶

func (c CosmosDBClient) CassandraResourcesMigrateCassandraTableToAutoscale(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesMigrateCassandraTableToAutoscaleOperationResponse, err error)

CassandraResourcesMigrateCassandraTableToAutoscale ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraTableToAutoscaleThenPoll ¶

func (c CosmosDBClient) CassandraResourcesMigrateCassandraTableToAutoscaleThenPoll(ctx context.Context, id CassandraKeyspaceTableId) error

CassandraResourcesMigrateCassandraTableToAutoscaleThenPoll performs CassandraResourcesMigrateCassandraTableToAutoscale then polls until it's completed

func (CosmosDBClient) CassandraResourcesMigrateCassandraTableToManualThroughput ¶

func (c CosmosDBClient) CassandraResourcesMigrateCassandraTableToManualThroughput(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesMigrateCassandraTableToManualThroughputOperationResponse, err error)

CassandraResourcesMigrateCassandraTableToManualThroughput ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraTableToManualThroughputThenPoll ¶

func (c CosmosDBClient) CassandraResourcesMigrateCassandraTableToManualThroughputThenPoll(ctx context.Context, id CassandraKeyspaceTableId) error

CassandraResourcesMigrateCassandraTableToManualThroughputThenPoll performs CassandraResourcesMigrateCassandraTableToManualThroughput then polls until it's completed

func (CosmosDBClient) CassandraResourcesUpdateCassandraKeyspaceThroughput ¶

CassandraResourcesUpdateCassandraKeyspaceThroughput ...

func (CosmosDBClient) CassandraResourcesUpdateCassandraKeyspaceThroughputThenPoll ¶

func (c CosmosDBClient) CassandraResourcesUpdateCassandraKeyspaceThroughputThenPoll(ctx context.Context, id CassandraKeyspaceId, input ThroughputSettingsUpdateParameters) error

CassandraResourcesUpdateCassandraKeyspaceThroughputThenPoll performs CassandraResourcesUpdateCassandraKeyspaceThroughput then polls until it's completed

func (CosmosDBClient) CassandraResourcesUpdateCassandraTableThroughput ¶

CassandraResourcesUpdateCassandraTableThroughput ...

func (CosmosDBClient) CassandraResourcesUpdateCassandraTableThroughputThenPoll ¶

func (c CosmosDBClient) CassandraResourcesUpdateCassandraTableThroughputThenPoll(ctx context.Context, id CassandraKeyspaceTableId, input ThroughputSettingsUpdateParameters) error

CassandraResourcesUpdateCassandraTableThroughputThenPoll performs CassandraResourcesUpdateCassandraTableThroughput then polls until it's completed

func (CosmosDBClient) CollectionListMetricDefinitions ¶

func (c CosmosDBClient) CollectionListMetricDefinitions(ctx context.Context, id CollectionId) (result CollectionListMetricDefinitionsOperationResponse, err error)

CollectionListMetricDefinitions ...

func (CosmosDBClient) CollectionListMetrics ¶

CollectionListMetrics ...

func (CosmosDBClient) CollectionListUsages ¶

CollectionListUsages ...

func (CosmosDBClient) CollectionPartitionListMetrics ¶

CollectionPartitionListMetrics ...

func (CosmosDBClient) CollectionPartitionListUsages ¶

CollectionPartitionListUsages ...

func (CosmosDBClient) CollectionPartitionRegionListMetrics ¶

CollectionPartitionRegionListMetrics ...

func (CosmosDBClient) CollectionRegionListMetrics ¶

CollectionRegionListMetrics ...

func (CosmosDBClient) DatabaseAccountRegionListMetrics ¶

DatabaseAccountRegionListMetrics ...

func (CosmosDBClient) DatabaseAccountsCheckNameExists ¶

func (c CosmosDBClient) DatabaseAccountsCheckNameExists(ctx context.Context, id DatabaseAccountNameId) (result DatabaseAccountsCheckNameExistsOperationResponse, err error)

DatabaseAccountsCheckNameExists ...

func (CosmosDBClient) DatabaseAccountsCreateOrUpdate ¶

DatabaseAccountsCreateOrUpdate ...

func (CosmosDBClient) DatabaseAccountsCreateOrUpdateThenPoll ¶

func (c CosmosDBClient) DatabaseAccountsCreateOrUpdateThenPoll(ctx context.Context, id DatabaseAccountId, input DatabaseAccountCreateUpdateParameters) error

DatabaseAccountsCreateOrUpdateThenPoll performs DatabaseAccountsCreateOrUpdate then polls until it's completed

func (CosmosDBClient) DatabaseAccountsDelete ¶

func (c CosmosDBClient) DatabaseAccountsDelete(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsDeleteOperationResponse, err error)

DatabaseAccountsDelete ...

func (CosmosDBClient) DatabaseAccountsDeleteThenPoll ¶

func (c CosmosDBClient) DatabaseAccountsDeleteThenPoll(ctx context.Context, id DatabaseAccountId) error

DatabaseAccountsDeleteThenPoll performs DatabaseAccountsDelete then polls until it's completed

func (CosmosDBClient) DatabaseAccountsFailoverPriorityChange ¶

func (c CosmosDBClient) DatabaseAccountsFailoverPriorityChange(ctx context.Context, id DatabaseAccountId, input FailoverPolicies) (result DatabaseAccountsFailoverPriorityChangeOperationResponse, err error)

DatabaseAccountsFailoverPriorityChange ...

func (CosmosDBClient) DatabaseAccountsFailoverPriorityChangeThenPoll ¶

func (c CosmosDBClient) DatabaseAccountsFailoverPriorityChangeThenPoll(ctx context.Context, id DatabaseAccountId, input FailoverPolicies) error

DatabaseAccountsFailoverPriorityChangeThenPoll performs DatabaseAccountsFailoverPriorityChange then polls until it's completed

func (CosmosDBClient) DatabaseAccountsGet ¶

func (c CosmosDBClient) DatabaseAccountsGet(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsGetOperationResponse, err error)

DatabaseAccountsGet ...

func (CosmosDBClient) DatabaseAccountsGetReadOnlyKeys ¶

func (c CosmosDBClient) DatabaseAccountsGetReadOnlyKeys(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsGetReadOnlyKeysOperationResponse, err error)

DatabaseAccountsGetReadOnlyKeys ...

func (CosmosDBClient) DatabaseAccountsList ¶

DatabaseAccountsList ...

func (CosmosDBClient) DatabaseAccountsListByResourceGroup ¶

func (c CosmosDBClient) DatabaseAccountsListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result DatabaseAccountsListByResourceGroupOperationResponse, err error)

DatabaseAccountsListByResourceGroup ...

func (CosmosDBClient) DatabaseAccountsListConnectionStrings ¶

func (c CosmosDBClient) DatabaseAccountsListConnectionStrings(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsListConnectionStringsOperationResponse, err error)

DatabaseAccountsListConnectionStrings ...

func (CosmosDBClient) DatabaseAccountsListKeys ¶

func (c CosmosDBClient) DatabaseAccountsListKeys(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsListKeysOperationResponse, err error)

DatabaseAccountsListKeys ...

func (CosmosDBClient) DatabaseAccountsListMetricDefinitions ¶

func (c CosmosDBClient) DatabaseAccountsListMetricDefinitions(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsListMetricDefinitionsOperationResponse, err error)

DatabaseAccountsListMetricDefinitions ...

func (CosmosDBClient) DatabaseAccountsListMetrics ¶

DatabaseAccountsListMetrics ...

func (CosmosDBClient) DatabaseAccountsListReadOnlyKeys ¶

func (c CosmosDBClient) DatabaseAccountsListReadOnlyKeys(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsListReadOnlyKeysOperationResponse, err error)

DatabaseAccountsListReadOnlyKeys ...

func (CosmosDBClient) DatabaseAccountsListUsages ¶

DatabaseAccountsListUsages ...

func (CosmosDBClient) DatabaseAccountsOfflineRegion ¶

DatabaseAccountsOfflineRegion ...

func (CosmosDBClient) DatabaseAccountsOfflineRegionThenPoll ¶

func (c CosmosDBClient) DatabaseAccountsOfflineRegionThenPoll(ctx context.Context, id DatabaseAccountId, input RegionForOnlineOffline) error

DatabaseAccountsOfflineRegionThenPoll performs DatabaseAccountsOfflineRegion then polls until it's completed

func (CosmosDBClient) DatabaseAccountsOnlineRegion ¶

DatabaseAccountsOnlineRegion ...

func (CosmosDBClient) DatabaseAccountsOnlineRegionThenPoll ¶

func (c CosmosDBClient) DatabaseAccountsOnlineRegionThenPoll(ctx context.Context, id DatabaseAccountId, input RegionForOnlineOffline) error

DatabaseAccountsOnlineRegionThenPoll performs DatabaseAccountsOnlineRegion then polls until it's completed

func (CosmosDBClient) DatabaseAccountsRegenerateKey ¶

DatabaseAccountsRegenerateKey ...

func (CosmosDBClient) DatabaseAccountsRegenerateKeyThenPoll ¶

func (c CosmosDBClient) DatabaseAccountsRegenerateKeyThenPoll(ctx context.Context, id DatabaseAccountId, input DatabaseAccountRegenerateKeyParameters) error

DatabaseAccountsRegenerateKeyThenPoll performs DatabaseAccountsRegenerateKey then polls until it's completed

func (CosmosDBClient) DatabaseAccountsUpdate ¶

DatabaseAccountsUpdate ...

func (CosmosDBClient) DatabaseAccountsUpdateThenPoll ¶

func (c CosmosDBClient) DatabaseAccountsUpdateThenPoll(ctx context.Context, id DatabaseAccountId, input DatabaseAccountUpdateParameters) error

DatabaseAccountsUpdateThenPoll performs DatabaseAccountsUpdate then polls until it's completed

func (CosmosDBClient) DatabaseListMetricDefinitions ¶

func (c CosmosDBClient) DatabaseListMetricDefinitions(ctx context.Context, id DatabaseId) (result DatabaseListMetricDefinitionsOperationResponse, err error)

DatabaseListMetricDefinitions ...

func (CosmosDBClient) DatabaseListMetrics ¶

DatabaseListMetrics ...

func (CosmosDBClient) DatabaseListUsages ¶

DatabaseListUsages ...

func (CosmosDBClient) GremlinResourcesCreateUpdateGremlinDatabase ¶

GremlinResourcesCreateUpdateGremlinDatabase ...

func (CosmosDBClient) GremlinResourcesCreateUpdateGremlinDatabaseThenPoll ¶

func (c CosmosDBClient) GremlinResourcesCreateUpdateGremlinDatabaseThenPoll(ctx context.Context, id GremlinDatabaseId, input GremlinDatabaseCreateUpdateParameters) error

GremlinResourcesCreateUpdateGremlinDatabaseThenPoll performs GremlinResourcesCreateUpdateGremlinDatabase then polls until it's completed

func (CosmosDBClient) GremlinResourcesCreateUpdateGremlinGraph ¶

func (c CosmosDBClient) GremlinResourcesCreateUpdateGremlinGraph(ctx context.Context, id GraphId, input GremlinGraphCreateUpdateParameters) (result GremlinResourcesCreateUpdateGremlinGraphOperationResponse, err error)

GremlinResourcesCreateUpdateGremlinGraph ...

func (CosmosDBClient) GremlinResourcesCreateUpdateGremlinGraphThenPoll ¶

func (c CosmosDBClient) GremlinResourcesCreateUpdateGremlinGraphThenPoll(ctx context.Context, id GraphId, input GremlinGraphCreateUpdateParameters) error

GremlinResourcesCreateUpdateGremlinGraphThenPoll performs GremlinResourcesCreateUpdateGremlinGraph then polls until it's completed

func (CosmosDBClient) GremlinResourcesDeleteGremlinDatabase ¶

func (c CosmosDBClient) GremlinResourcesDeleteGremlinDatabase(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesDeleteGremlinDatabaseOperationResponse, err error)

GremlinResourcesDeleteGremlinDatabase ...

func (CosmosDBClient) GremlinResourcesDeleteGremlinDatabaseThenPoll ¶

func (c CosmosDBClient) GremlinResourcesDeleteGremlinDatabaseThenPoll(ctx context.Context, id GremlinDatabaseId) error

GremlinResourcesDeleteGremlinDatabaseThenPoll performs GremlinResourcesDeleteGremlinDatabase then polls until it's completed

func (CosmosDBClient) GremlinResourcesDeleteGremlinGraph ¶

func (c CosmosDBClient) GremlinResourcesDeleteGremlinGraph(ctx context.Context, id GraphId) (result GremlinResourcesDeleteGremlinGraphOperationResponse, err error)

GremlinResourcesDeleteGremlinGraph ...

func (CosmosDBClient) GremlinResourcesDeleteGremlinGraphThenPoll ¶

func (c CosmosDBClient) GremlinResourcesDeleteGremlinGraphThenPoll(ctx context.Context, id GraphId) error

GremlinResourcesDeleteGremlinGraphThenPoll performs GremlinResourcesDeleteGremlinGraph then polls until it's completed

func (CosmosDBClient) GremlinResourcesGetGremlinDatabase ¶

func (c CosmosDBClient) GremlinResourcesGetGremlinDatabase(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesGetGremlinDatabaseOperationResponse, err error)

GremlinResourcesGetGremlinDatabase ...

func (CosmosDBClient) GremlinResourcesGetGremlinDatabaseThroughput ¶

func (c CosmosDBClient) GremlinResourcesGetGremlinDatabaseThroughput(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesGetGremlinDatabaseThroughputOperationResponse, err error)

GremlinResourcesGetGremlinDatabaseThroughput ...

func (CosmosDBClient) GremlinResourcesGetGremlinGraph ¶

func (c CosmosDBClient) GremlinResourcesGetGremlinGraph(ctx context.Context, id GraphId) (result GremlinResourcesGetGremlinGraphOperationResponse, err error)

GremlinResourcesGetGremlinGraph ...

func (CosmosDBClient) GremlinResourcesGetGremlinGraphThroughput ¶

func (c CosmosDBClient) GremlinResourcesGetGremlinGraphThroughput(ctx context.Context, id GraphId) (result GremlinResourcesGetGremlinGraphThroughputOperationResponse, err error)

GremlinResourcesGetGremlinGraphThroughput ...

func (CosmosDBClient) GremlinResourcesListGremlinDatabases ¶

func (c CosmosDBClient) GremlinResourcesListGremlinDatabases(ctx context.Context, id DatabaseAccountId) (result GremlinResourcesListGremlinDatabasesOperationResponse, err error)

GremlinResourcesListGremlinDatabases ...

func (CosmosDBClient) GremlinResourcesListGremlinGraphs ¶

func (c CosmosDBClient) GremlinResourcesListGremlinGraphs(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesListGremlinGraphsOperationResponse, err error)

GremlinResourcesListGremlinGraphs ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToAutoscale ¶

func (c CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToAutoscale(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesMigrateGremlinDatabaseToAutoscaleOperationResponse, err error)

GremlinResourcesMigrateGremlinDatabaseToAutoscale ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToAutoscaleThenPoll ¶

func (c CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToAutoscaleThenPoll(ctx context.Context, id GremlinDatabaseId) error

GremlinResourcesMigrateGremlinDatabaseToAutoscaleThenPoll performs GremlinResourcesMigrateGremlinDatabaseToAutoscale then polls until it's completed

func (CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToManualThroughput ¶

func (c CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToManualThroughput(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesMigrateGremlinDatabaseToManualThroughputOperationResponse, err error)

GremlinResourcesMigrateGremlinDatabaseToManualThroughput ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToManualThroughputThenPoll ¶

func (c CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToManualThroughputThenPoll(ctx context.Context, id GremlinDatabaseId) error

GremlinResourcesMigrateGremlinDatabaseToManualThroughputThenPoll performs GremlinResourcesMigrateGremlinDatabaseToManualThroughput then polls until it's completed

func (CosmosDBClient) GremlinResourcesMigrateGremlinGraphToAutoscale ¶

func (c CosmosDBClient) GremlinResourcesMigrateGremlinGraphToAutoscale(ctx context.Context, id GraphId) (result GremlinResourcesMigrateGremlinGraphToAutoscaleOperationResponse, err error)

GremlinResourcesMigrateGremlinGraphToAutoscale ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinGraphToAutoscaleThenPoll ¶

func (c CosmosDBClient) GremlinResourcesMigrateGremlinGraphToAutoscaleThenPoll(ctx context.Context, id GraphId) error

GremlinResourcesMigrateGremlinGraphToAutoscaleThenPoll performs GremlinResourcesMigrateGremlinGraphToAutoscale then polls until it's completed

func (CosmosDBClient) GremlinResourcesMigrateGremlinGraphToManualThroughput ¶

func (c CosmosDBClient) GremlinResourcesMigrateGremlinGraphToManualThroughput(ctx context.Context, id GraphId) (result GremlinResourcesMigrateGremlinGraphToManualThroughputOperationResponse, err error)

GremlinResourcesMigrateGremlinGraphToManualThroughput ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinGraphToManualThroughputThenPoll ¶

func (c CosmosDBClient) GremlinResourcesMigrateGremlinGraphToManualThroughputThenPoll(ctx context.Context, id GraphId) error

GremlinResourcesMigrateGremlinGraphToManualThroughputThenPoll performs GremlinResourcesMigrateGremlinGraphToManualThroughput then polls until it's completed

func (CosmosDBClient) GremlinResourcesUpdateGremlinDatabaseThroughput ¶

GremlinResourcesUpdateGremlinDatabaseThroughput ...

func (CosmosDBClient) GremlinResourcesUpdateGremlinDatabaseThroughputThenPoll ¶

func (c CosmosDBClient) GremlinResourcesUpdateGremlinDatabaseThroughputThenPoll(ctx context.Context, id GremlinDatabaseId, input ThroughputSettingsUpdateParameters) error

GremlinResourcesUpdateGremlinDatabaseThroughputThenPoll performs GremlinResourcesUpdateGremlinDatabaseThroughput then polls until it's completed

func (CosmosDBClient) GremlinResourcesUpdateGremlinGraphThroughput ¶

func (c CosmosDBClient) GremlinResourcesUpdateGremlinGraphThroughput(ctx context.Context, id GraphId, input ThroughputSettingsUpdateParameters) (result GremlinResourcesUpdateGremlinGraphThroughputOperationResponse, err error)

GremlinResourcesUpdateGremlinGraphThroughput ...

func (CosmosDBClient) GremlinResourcesUpdateGremlinGraphThroughputThenPoll ¶

func (c CosmosDBClient) GremlinResourcesUpdateGremlinGraphThroughputThenPoll(ctx context.Context, id GraphId, input ThroughputSettingsUpdateParameters) error

GremlinResourcesUpdateGremlinGraphThroughputThenPoll performs GremlinResourcesUpdateGremlinGraphThroughput then polls until it's completed

func (CosmosDBClient) LocationsGet ¶

func (c CosmosDBClient) LocationsGet(ctx context.Context, id LocationId) (result LocationsGetOperationResponse, err error)

LocationsGet ...

func (CosmosDBClient) LocationsList ¶

LocationsList ...

func (CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBCollection ¶

MongoDBResourcesCreateUpdateMongoDBCollection ...

func (CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBCollectionThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBCollectionThenPoll(ctx context.Context, id MongodbDatabaseCollectionId, input MongoDBCollectionCreateUpdateParameters) error

MongoDBResourcesCreateUpdateMongoDBCollectionThenPoll performs MongoDBResourcesCreateUpdateMongoDBCollection then polls until it's completed

func (CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBDatabase ¶

MongoDBResourcesCreateUpdateMongoDBDatabase ...

func (CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBDatabaseThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBDatabaseThenPoll(ctx context.Context, id MongodbDatabaseId, input MongoDBDatabaseCreateUpdateParameters) error

MongoDBResourcesCreateUpdateMongoDBDatabaseThenPoll performs MongoDBResourcesCreateUpdateMongoDBDatabase then polls until it's completed

func (CosmosDBClient) MongoDBResourcesDeleteMongoDBCollection ¶

func (c CosmosDBClient) MongoDBResourcesDeleteMongoDBCollection(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesDeleteMongoDBCollectionOperationResponse, err error)

MongoDBResourcesDeleteMongoDBCollection ...

func (CosmosDBClient) MongoDBResourcesDeleteMongoDBCollectionThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesDeleteMongoDBCollectionThenPoll(ctx context.Context, id MongodbDatabaseCollectionId) error

MongoDBResourcesDeleteMongoDBCollectionThenPoll performs MongoDBResourcesDeleteMongoDBCollection then polls until it's completed

func (CosmosDBClient) MongoDBResourcesDeleteMongoDBDatabase ¶

func (c CosmosDBClient) MongoDBResourcesDeleteMongoDBDatabase(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesDeleteMongoDBDatabaseOperationResponse, err error)

MongoDBResourcesDeleteMongoDBDatabase ...

func (CosmosDBClient) MongoDBResourcesDeleteMongoDBDatabaseThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesDeleteMongoDBDatabaseThenPoll(ctx context.Context, id MongodbDatabaseId) error

MongoDBResourcesDeleteMongoDBDatabaseThenPoll performs MongoDBResourcesDeleteMongoDBDatabase then polls until it's completed

func (CosmosDBClient) MongoDBResourcesGetMongoDBCollection ¶

func (c CosmosDBClient) MongoDBResourcesGetMongoDBCollection(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesGetMongoDBCollectionOperationResponse, err error)

MongoDBResourcesGetMongoDBCollection ...

func (CosmosDBClient) MongoDBResourcesGetMongoDBCollectionThroughput ¶

func (c CosmosDBClient) MongoDBResourcesGetMongoDBCollectionThroughput(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesGetMongoDBCollectionThroughputOperationResponse, err error)

MongoDBResourcesGetMongoDBCollectionThroughput ...

func (CosmosDBClient) MongoDBResourcesGetMongoDBDatabase ¶

func (c CosmosDBClient) MongoDBResourcesGetMongoDBDatabase(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesGetMongoDBDatabaseOperationResponse, err error)

MongoDBResourcesGetMongoDBDatabase ...

func (CosmosDBClient) MongoDBResourcesGetMongoDBDatabaseThroughput ¶

func (c CosmosDBClient) MongoDBResourcesGetMongoDBDatabaseThroughput(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesGetMongoDBDatabaseThroughputOperationResponse, err error)

MongoDBResourcesGetMongoDBDatabaseThroughput ...

func (CosmosDBClient) MongoDBResourcesListMongoDBCollections ¶

func (c CosmosDBClient) MongoDBResourcesListMongoDBCollections(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesListMongoDBCollectionsOperationResponse, err error)

MongoDBResourcesListMongoDBCollections ...

func (CosmosDBClient) MongoDBResourcesListMongoDBDatabases ¶

func (c CosmosDBClient) MongoDBResourcesListMongoDBDatabases(ctx context.Context, id DatabaseAccountId) (result MongoDBResourcesListMongoDBDatabasesOperationResponse, err error)

MongoDBResourcesListMongoDBDatabases ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToAutoscale ¶

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToAutoscale(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesMigrateMongoDBCollectionToAutoscaleOperationResponse, err error)

MongoDBResourcesMigrateMongoDBCollectionToAutoscale ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToAutoscaleThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToAutoscaleThenPoll(ctx context.Context, id MongodbDatabaseCollectionId) error

MongoDBResourcesMigrateMongoDBCollectionToAutoscaleThenPoll performs MongoDBResourcesMigrateMongoDBCollectionToAutoscale then polls until it's completed

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToManualThroughput ¶

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToManualThroughput(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesMigrateMongoDBCollectionToManualThroughputOperationResponse, err error)

MongoDBResourcesMigrateMongoDBCollectionToManualThroughput ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToManualThroughputThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToManualThroughputThenPoll(ctx context.Context, id MongodbDatabaseCollectionId) error

MongoDBResourcesMigrateMongoDBCollectionToManualThroughputThenPoll performs MongoDBResourcesMigrateMongoDBCollectionToManualThroughput then polls until it's completed

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToAutoscale ¶

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToAutoscale(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleOperationResponse, err error)

MongoDBResourcesMigrateMongoDBDatabaseToAutoscale ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleThenPoll(ctx context.Context, id MongodbDatabaseId) error

MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleThenPoll performs MongoDBResourcesMigrateMongoDBDatabaseToAutoscale then polls until it's completed

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput ¶

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputOperationResponse, err error)

MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputThenPoll(ctx context.Context, id MongodbDatabaseId) error

MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputThenPoll performs MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput then polls until it's completed

func (CosmosDBClient) MongoDBResourcesUpdateMongoDBCollectionThroughput ¶

MongoDBResourcesUpdateMongoDBCollectionThroughput ...

func (CosmosDBClient) MongoDBResourcesUpdateMongoDBCollectionThroughputThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesUpdateMongoDBCollectionThroughputThenPoll(ctx context.Context, id MongodbDatabaseCollectionId, input ThroughputSettingsUpdateParameters) error

MongoDBResourcesUpdateMongoDBCollectionThroughputThenPoll performs MongoDBResourcesUpdateMongoDBCollectionThroughput then polls until it's completed

func (CosmosDBClient) MongoDBResourcesUpdateMongoDBDatabaseThroughput ¶

MongoDBResourcesUpdateMongoDBDatabaseThroughput ...

func (CosmosDBClient) MongoDBResourcesUpdateMongoDBDatabaseThroughputThenPoll ¶

func (c CosmosDBClient) MongoDBResourcesUpdateMongoDBDatabaseThroughputThenPoll(ctx context.Context, id MongodbDatabaseId, input ThroughputSettingsUpdateParameters) error

MongoDBResourcesUpdateMongoDBDatabaseThroughputThenPoll performs MongoDBResourcesUpdateMongoDBDatabaseThroughput then polls until it's completed

func (CosmosDBClient) PartitionKeyRangeIdListMetrics ¶

PartitionKeyRangeIdListMetrics ...

func (CosmosDBClient) PartitionKeyRangeIdRegionListMetrics ¶

PartitionKeyRangeIdRegionListMetrics ...

func (CosmosDBClient) PercentileListMetrics ¶

PercentileListMetrics ...

func (CosmosDBClient) PercentileSourceTargetListMetrics ¶

PercentileSourceTargetListMetrics ...

func (CosmosDBClient) PercentileTargetListMetrics ¶

PercentileTargetListMetrics ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlContainer ¶

SqlResourcesCreateUpdateSqlContainer ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlContainerThenPoll ¶

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlContainerThenPoll(ctx context.Context, id ContainerId, input SqlContainerCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlContainerThenPoll performs SqlResourcesCreateUpdateSqlContainer then polls until it's completed

func (CosmosDBClient) SqlResourcesCreateUpdateSqlDatabase ¶

SqlResourcesCreateUpdateSqlDatabase ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlDatabaseThenPoll ¶

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlDatabaseThenPoll(ctx context.Context, id SqlDatabaseId, input SqlDatabaseCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlDatabaseThenPoll performs SqlResourcesCreateUpdateSqlDatabase then polls until it's completed

func (CosmosDBClient) SqlResourcesCreateUpdateSqlStoredProcedure ¶

SqlResourcesCreateUpdateSqlStoredProcedure ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlStoredProcedureThenPoll ¶

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlStoredProcedureThenPoll(ctx context.Context, id StoredProcedureId, input SqlStoredProcedureCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlStoredProcedureThenPoll performs SqlResourcesCreateUpdateSqlStoredProcedure then polls until it's completed

func (CosmosDBClient) SqlResourcesCreateUpdateSqlTrigger ¶

SqlResourcesCreateUpdateSqlTrigger ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlTriggerThenPoll ¶

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlTriggerThenPoll(ctx context.Context, id TriggerId, input SqlTriggerCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlTriggerThenPoll performs SqlResourcesCreateUpdateSqlTrigger then polls until it's completed

func (CosmosDBClient) SqlResourcesCreateUpdateSqlUserDefinedFunction ¶

SqlResourcesCreateUpdateSqlUserDefinedFunction ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlUserDefinedFunctionThenPoll ¶

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlUserDefinedFunctionThenPoll(ctx context.Context, id UserDefinedFunctionId, input SqlUserDefinedFunctionCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlUserDefinedFunctionThenPoll performs SqlResourcesCreateUpdateSqlUserDefinedFunction then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlContainer ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlContainer(ctx context.Context, id ContainerId) (result SqlResourcesDeleteSqlContainerOperationResponse, err error)

SqlResourcesDeleteSqlContainer ...

func (CosmosDBClient) SqlResourcesDeleteSqlContainerThenPoll ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlContainerThenPoll(ctx context.Context, id ContainerId) error

SqlResourcesDeleteSqlContainerThenPoll performs SqlResourcesDeleteSqlContainer then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlDatabase ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlDatabase(ctx context.Context, id SqlDatabaseId) (result SqlResourcesDeleteSqlDatabaseOperationResponse, err error)

SqlResourcesDeleteSqlDatabase ...

func (CosmosDBClient) SqlResourcesDeleteSqlDatabaseThenPoll ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlDatabaseThenPoll(ctx context.Context, id SqlDatabaseId) error

SqlResourcesDeleteSqlDatabaseThenPoll performs SqlResourcesDeleteSqlDatabase then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlStoredProcedure ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlStoredProcedure(ctx context.Context, id StoredProcedureId) (result SqlResourcesDeleteSqlStoredProcedureOperationResponse, err error)

SqlResourcesDeleteSqlStoredProcedure ...

func (CosmosDBClient) SqlResourcesDeleteSqlStoredProcedureThenPoll ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlStoredProcedureThenPoll(ctx context.Context, id StoredProcedureId) error

SqlResourcesDeleteSqlStoredProcedureThenPoll performs SqlResourcesDeleteSqlStoredProcedure then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlTrigger ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlTrigger(ctx context.Context, id TriggerId) (result SqlResourcesDeleteSqlTriggerOperationResponse, err error)

SqlResourcesDeleteSqlTrigger ...

func (CosmosDBClient) SqlResourcesDeleteSqlTriggerThenPoll ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlTriggerThenPoll(ctx context.Context, id TriggerId) error

SqlResourcesDeleteSqlTriggerThenPoll performs SqlResourcesDeleteSqlTrigger then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlUserDefinedFunction ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlUserDefinedFunction(ctx context.Context, id UserDefinedFunctionId) (result SqlResourcesDeleteSqlUserDefinedFunctionOperationResponse, err error)

SqlResourcesDeleteSqlUserDefinedFunction ...

func (CosmosDBClient) SqlResourcesDeleteSqlUserDefinedFunctionThenPoll ¶

func (c CosmosDBClient) SqlResourcesDeleteSqlUserDefinedFunctionThenPoll(ctx context.Context, id UserDefinedFunctionId) error

SqlResourcesDeleteSqlUserDefinedFunctionThenPoll performs SqlResourcesDeleteSqlUserDefinedFunction then polls until it's completed

func (CosmosDBClient) SqlResourcesGetSqlContainer ¶

func (c CosmosDBClient) SqlResourcesGetSqlContainer(ctx context.Context, id ContainerId) (result SqlResourcesGetSqlContainerOperationResponse, err error)

SqlResourcesGetSqlContainer ...

func (CosmosDBClient) SqlResourcesGetSqlContainerThroughput ¶

func (c CosmosDBClient) SqlResourcesGetSqlContainerThroughput(ctx context.Context, id ContainerId) (result SqlResourcesGetSqlContainerThroughputOperationResponse, err error)

SqlResourcesGetSqlContainerThroughput ...

func (CosmosDBClient) SqlResourcesGetSqlDatabase ¶

func (c CosmosDBClient) SqlResourcesGetSqlDatabase(ctx context.Context, id SqlDatabaseId) (result SqlResourcesGetSqlDatabaseOperationResponse, err error)

SqlResourcesGetSqlDatabase ...

func (CosmosDBClient) SqlResourcesGetSqlDatabaseThroughput ¶

func (c CosmosDBClient) SqlResourcesGetSqlDatabaseThroughput(ctx context.Context, id SqlDatabaseId) (result SqlResourcesGetSqlDatabaseThroughputOperationResponse, err error)

SqlResourcesGetSqlDatabaseThroughput ...

func (CosmosDBClient) SqlResourcesGetSqlStoredProcedure ¶

func (c CosmosDBClient) SqlResourcesGetSqlStoredProcedure(ctx context.Context, id StoredProcedureId) (result SqlResourcesGetSqlStoredProcedureOperationResponse, err error)

SqlResourcesGetSqlStoredProcedure ...

func (CosmosDBClient) SqlResourcesGetSqlTrigger ¶

func (c CosmosDBClient) SqlResourcesGetSqlTrigger(ctx context.Context, id TriggerId) (result SqlResourcesGetSqlTriggerOperationResponse, err error)

SqlResourcesGetSqlTrigger ...

func (CosmosDBClient) SqlResourcesGetSqlUserDefinedFunction ¶

func (c CosmosDBClient) SqlResourcesGetSqlUserDefinedFunction(ctx context.Context, id UserDefinedFunctionId) (result SqlResourcesGetSqlUserDefinedFunctionOperationResponse, err error)

SqlResourcesGetSqlUserDefinedFunction ...

func (CosmosDBClient) SqlResourcesListSqlContainers ¶

func (c CosmosDBClient) SqlResourcesListSqlContainers(ctx context.Context, id SqlDatabaseId) (result SqlResourcesListSqlContainersOperationResponse, err error)

SqlResourcesListSqlContainers ...

func (CosmosDBClient) SqlResourcesListSqlDatabases ¶

func (c CosmosDBClient) SqlResourcesListSqlDatabases(ctx context.Context, id DatabaseAccountId) (result SqlResourcesListSqlDatabasesOperationResponse, err error)

SqlResourcesListSqlDatabases ...

func (CosmosDBClient) SqlResourcesListSqlStoredProcedures ¶

func (c CosmosDBClient) SqlResourcesListSqlStoredProcedures(ctx context.Context, id ContainerId) (result SqlResourcesListSqlStoredProceduresOperationResponse, err error)

SqlResourcesListSqlStoredProcedures ...

func (CosmosDBClient) SqlResourcesListSqlTriggers ¶

func (c CosmosDBClient) SqlResourcesListSqlTriggers(ctx context.Context, id ContainerId) (result SqlResourcesListSqlTriggersOperationResponse, err error)

SqlResourcesListSqlTriggers ...

func (CosmosDBClient) SqlResourcesListSqlUserDefinedFunctions ¶

func (c CosmosDBClient) SqlResourcesListSqlUserDefinedFunctions(ctx context.Context, id ContainerId) (result SqlResourcesListSqlUserDefinedFunctionsOperationResponse, err error)

SqlResourcesListSqlUserDefinedFunctions ...

func (CosmosDBClient) SqlResourcesMigrateSqlContainerToAutoscale ¶

func (c CosmosDBClient) SqlResourcesMigrateSqlContainerToAutoscale(ctx context.Context, id ContainerId) (result SqlResourcesMigrateSqlContainerToAutoscaleOperationResponse, err error)

SqlResourcesMigrateSqlContainerToAutoscale ...

func (CosmosDBClient) SqlResourcesMigrateSqlContainerToAutoscaleThenPoll ¶

func (c CosmosDBClient) SqlResourcesMigrateSqlContainerToAutoscaleThenPoll(ctx context.Context, id ContainerId) error

SqlResourcesMigrateSqlContainerToAutoscaleThenPoll performs SqlResourcesMigrateSqlContainerToAutoscale then polls until it's completed

func (CosmosDBClient) SqlResourcesMigrateSqlContainerToManualThroughput ¶

func (c CosmosDBClient) SqlResourcesMigrateSqlContainerToManualThroughput(ctx context.Context, id ContainerId) (result SqlResourcesMigrateSqlContainerToManualThroughputOperationResponse, err error)

SqlResourcesMigrateSqlContainerToManualThroughput ...

func (CosmosDBClient) SqlResourcesMigrateSqlContainerToManualThroughputThenPoll ¶

func (c CosmosDBClient) SqlResourcesMigrateSqlContainerToManualThroughputThenPoll(ctx context.Context, id ContainerId) error

SqlResourcesMigrateSqlContainerToManualThroughputThenPoll performs SqlResourcesMigrateSqlContainerToManualThroughput then polls until it's completed

func (CosmosDBClient) SqlResourcesMigrateSqlDatabaseToAutoscale ¶

func (c CosmosDBClient) SqlResourcesMigrateSqlDatabaseToAutoscale(ctx context.Context, id SqlDatabaseId) (result SqlResourcesMigrateSqlDatabaseToAutoscaleOperationResponse, err error)

SqlResourcesMigrateSqlDatabaseToAutoscale ...

func (CosmosDBClient) SqlResourcesMigrateSqlDatabaseToAutoscaleThenPoll ¶

func (c CosmosDBClient) SqlResourcesMigrateSqlDatabaseToAutoscaleThenPoll(ctx context.Context, id SqlDatabaseId) error

SqlResourcesMigrateSqlDatabaseToAutoscaleThenPoll performs SqlResourcesMigrateSqlDatabaseToAutoscale then polls until it's completed

func (CosmosDBClient) SqlResourcesMigrateSqlDatabaseToManualThroughput ¶

func (c CosmosDBClient) SqlResourcesMigrateSqlDatabaseToManualThroughput(ctx context.Context, id SqlDatabaseId) (result SqlResourcesMigrateSqlDatabaseToManualThroughputOperationResponse, err error)

SqlResourcesMigrateSqlDatabaseToManualThroughput ...

func (CosmosDBClient) SqlResourcesMigrateSqlDatabaseToManualThroughputThenPoll ¶

func (c CosmosDBClient) SqlResourcesMigrateSqlDatabaseToManualThroughputThenPoll(ctx context.Context, id SqlDatabaseId) error

SqlResourcesMigrateSqlDatabaseToManualThroughputThenPoll performs SqlResourcesMigrateSqlDatabaseToManualThroughput then polls until it's completed

func (CosmosDBClient) SqlResourcesUpdateSqlContainerThroughput ¶

SqlResourcesUpdateSqlContainerThroughput ...

func (CosmosDBClient) SqlResourcesUpdateSqlContainerThroughputThenPoll ¶

func (c CosmosDBClient) SqlResourcesUpdateSqlContainerThroughputThenPoll(ctx context.Context, id ContainerId, input ThroughputSettingsUpdateParameters) error

SqlResourcesUpdateSqlContainerThroughputThenPoll performs SqlResourcesUpdateSqlContainerThroughput then polls until it's completed

func (CosmosDBClient) SqlResourcesUpdateSqlDatabaseThroughput ¶

SqlResourcesUpdateSqlDatabaseThroughput ...

func (CosmosDBClient) SqlResourcesUpdateSqlDatabaseThroughputThenPoll ¶

func (c CosmosDBClient) SqlResourcesUpdateSqlDatabaseThroughputThenPoll(ctx context.Context, id SqlDatabaseId, input ThroughputSettingsUpdateParameters) error

SqlResourcesUpdateSqlDatabaseThroughputThenPoll performs SqlResourcesUpdateSqlDatabaseThroughput then polls until it's completed

func (CosmosDBClient) TableResourcesCreateUpdateTable ¶

func (c CosmosDBClient) TableResourcesCreateUpdateTable(ctx context.Context, id TableId, input TableCreateUpdateParameters) (result TableResourcesCreateUpdateTableOperationResponse, err error)

TableResourcesCreateUpdateTable ...

func (CosmosDBClient) TableResourcesCreateUpdateTableThenPoll ¶

func (c CosmosDBClient) TableResourcesCreateUpdateTableThenPoll(ctx context.Context, id TableId, input TableCreateUpdateParameters) error

TableResourcesCreateUpdateTableThenPoll performs TableResourcesCreateUpdateTable then polls until it's completed

func (CosmosDBClient) TableResourcesDeleteTable ¶

func (c CosmosDBClient) TableResourcesDeleteTable(ctx context.Context, id TableId) (result TableResourcesDeleteTableOperationResponse, err error)

TableResourcesDeleteTable ...

func (CosmosDBClient) TableResourcesDeleteTableThenPoll ¶

func (c CosmosDBClient) TableResourcesDeleteTableThenPoll(ctx context.Context, id TableId) error

TableResourcesDeleteTableThenPoll performs TableResourcesDeleteTable then polls until it's completed

func (CosmosDBClient) TableResourcesGetTable ¶

func (c CosmosDBClient) TableResourcesGetTable(ctx context.Context, id TableId) (result TableResourcesGetTableOperationResponse, err error)

TableResourcesGetTable ...

func (CosmosDBClient) TableResourcesGetTableThroughput ¶

func (c CosmosDBClient) TableResourcesGetTableThroughput(ctx context.Context, id TableId) (result TableResourcesGetTableThroughputOperationResponse, err error)

TableResourcesGetTableThroughput ...

func (CosmosDBClient) TableResourcesListTables ¶

func (c CosmosDBClient) TableResourcesListTables(ctx context.Context, id DatabaseAccountId) (result TableResourcesListTablesOperationResponse, err error)

TableResourcesListTables ...

func (CosmosDBClient) TableResourcesMigrateTableToAutoscale ¶

func (c CosmosDBClient) TableResourcesMigrateTableToAutoscale(ctx context.Context, id TableId) (result TableResourcesMigrateTableToAutoscaleOperationResponse, err error)

TableResourcesMigrateTableToAutoscale ...

func (CosmosDBClient) TableResourcesMigrateTableToAutoscaleThenPoll ¶

func (c CosmosDBClient) TableResourcesMigrateTableToAutoscaleThenPoll(ctx context.Context, id TableId) error

TableResourcesMigrateTableToAutoscaleThenPoll performs TableResourcesMigrateTableToAutoscale then polls until it's completed

func (CosmosDBClient) TableResourcesMigrateTableToManualThroughput ¶

func (c CosmosDBClient) TableResourcesMigrateTableToManualThroughput(ctx context.Context, id TableId) (result TableResourcesMigrateTableToManualThroughputOperationResponse, err error)

TableResourcesMigrateTableToManualThroughput ...

func (CosmosDBClient) TableResourcesMigrateTableToManualThroughputThenPoll ¶

func (c CosmosDBClient) TableResourcesMigrateTableToManualThroughputThenPoll(ctx context.Context, id TableId) error

TableResourcesMigrateTableToManualThroughputThenPoll performs TableResourcesMigrateTableToManualThroughput then polls until it's completed

func (CosmosDBClient) TableResourcesUpdateTableThroughput ¶

TableResourcesUpdateTableThroughput ...

func (CosmosDBClient) TableResourcesUpdateTableThroughputThenPoll ¶

func (c CosmosDBClient) TableResourcesUpdateTableThroughputThenPoll(ctx context.Context, id TableId, input ThroughputSettingsUpdateParameters) error

TableResourcesUpdateTableThroughputThenPoll performs TableResourcesUpdateTableThroughput then polls until it's completed

type CreateMode ¶

type CreateMode string
const (
	CreateModeDefault CreateMode = "Default"
	CreateModeRestore CreateMode = "Restore"
)

type CreateUpdateOptions ¶

type CreateUpdateOptions struct {
	AutoScaleSettings *AutoScaleSettings `json:"autoscaleSettings,omitempty"`
	Throughput        *int64             `json:"throughput,omitempty"`
}

type DataType ¶

type DataType string
const (
	DataTypeLineString   DataType = "LineString"
	DataTypeMultiPolygon DataType = "MultiPolygon"
	DataTypeNumber       DataType = "Number"
	DataTypePoint        DataType = "Point"
	DataTypePolygon      DataType = "Polygon"
	DataTypeString       DataType = "String"
)

type DatabaseAccountConnectionString ¶

type DatabaseAccountConnectionString struct {
	ConnectionString *string `json:"connectionString,omitempty"`
	Description      *string `json:"description,omitempty"`
}

type DatabaseAccountCreateUpdateParameters ¶

type DatabaseAccountCreateUpdateParameters struct {
	Id         *string                                  `json:"id,omitempty"`
	Identity   *identity.LegacySystemAndUserAssignedMap `json:"identity,omitempty"`
	Kind       *DatabaseAccountKind                     `json:"kind,omitempty"`
	Location   *string                                  `json:"location,omitempty"`
	Name       *string                                  `json:"name,omitempty"`
	Properties DatabaseAccountCreateUpdateProperties    `json:"properties"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
	Type       *string                                  `json:"type,omitempty"`
}

type DatabaseAccountCreateUpdateProperties ¶

type DatabaseAccountCreateUpdateProperties struct {
	AnalyticalStorageConfiguration     *AnalyticalStorageConfiguration `json:"analyticalStorageConfiguration,omitempty"`
	ApiProperties                      *ApiProperties                  `json:"apiProperties,omitempty"`
	BackupPolicy                       BackupPolicy                    `json:"backupPolicy"`
	Capabilities                       *[]Capability                   `json:"capabilities,omitempty"`
	Capacity                           *Capacity                       `json:"capacity,omitempty"`
	ConnectorOffer                     *ConnectorOffer                 `json:"connectorOffer,omitempty"`
	ConsistencyPolicy                  *ConsistencyPolicy              `json:"consistencyPolicy,omitempty"`
	Cors                               *[]CorsPolicy                   `json:"cors,omitempty"`
	CreateMode                         *CreateMode                     `json:"createMode,omitempty"`
	DatabaseAccountOfferType           DatabaseAccountOfferType        `json:"databaseAccountOfferType"`
	DefaultIdentity                    *string                         `json:"defaultIdentity,omitempty"`
	DisableKeyBasedMetadataWriteAccess *bool                           `json:"disableKeyBasedMetadataWriteAccess,omitempty"`
	DisableLocalAuth                   *bool                           `json:"disableLocalAuth,omitempty"`
	EnableAnalyticalStorage            *bool                           `json:"enableAnalyticalStorage,omitempty"`
	EnableAutomaticFailover            *bool                           `json:"enableAutomaticFailover,omitempty"`
	EnableCassandraConnector           *bool                           `json:"enableCassandraConnector,omitempty"`
	EnableFreeTier                     *bool                           `json:"enableFreeTier,omitempty"`
	EnableMultipleWriteLocations       *bool                           `json:"enableMultipleWriteLocations,omitempty"`
	IPRules                            *[]IPAddressOrRange             `json:"ipRules,omitempty"`
	IsVirtualNetworkFilterEnabled      *bool                           `json:"isVirtualNetworkFilterEnabled,omitempty"`
	KeyVaultKeyUri                     *string                         `json:"keyVaultKeyUri,omitempty"`
	Locations                          []Location                      `json:"locations"`
	NetworkAclBypass                   *NetworkAclBypass               `json:"networkAclBypass,omitempty"`
	NetworkAclBypassResourceIds        *[]string                       `json:"networkAclBypassResourceIds,omitempty"`
	PublicNetworkAccess                *PublicNetworkAccess            `json:"publicNetworkAccess,omitempty"`
	RestoreParameters                  *RestoreParameters              `json:"restoreParameters,omitempty"`
	VirtualNetworkRules                *[]VirtualNetworkRule           `json:"virtualNetworkRules,omitempty"`
}

func (*DatabaseAccountCreateUpdateProperties) UnmarshalJSON ¶

func (s *DatabaseAccountCreateUpdateProperties) UnmarshalJSON(bytes []byte) error

type DatabaseAccountGetProperties ¶

type DatabaseAccountGetProperties struct {
	AnalyticalStorageConfiguration     *AnalyticalStorageConfiguration `json:"analyticalStorageConfiguration,omitempty"`
	ApiProperties                      *ApiProperties                  `json:"apiProperties,omitempty"`
	BackupPolicy                       BackupPolicy                    `json:"backupPolicy"`
	Capabilities                       *[]Capability                   `json:"capabilities,omitempty"`
	Capacity                           *Capacity                       `json:"capacity,omitempty"`
	ConnectorOffer                     *ConnectorOffer                 `json:"connectorOffer,omitempty"`
	ConsistencyPolicy                  *ConsistencyPolicy              `json:"consistencyPolicy,omitempty"`
	Cors                               *[]CorsPolicy                   `json:"cors,omitempty"`
	CreateMode                         *CreateMode                     `json:"createMode,omitempty"`
	DatabaseAccountOfferType           *DatabaseAccountOfferType       `json:"databaseAccountOfferType,omitempty"`
	DefaultIdentity                    *string                         `json:"defaultIdentity,omitempty"`
	DisableKeyBasedMetadataWriteAccess *bool                           `json:"disableKeyBasedMetadataWriteAccess,omitempty"`
	DisableLocalAuth                   *bool                           `json:"disableLocalAuth,omitempty"`
	DocumentEndpoint                   *string                         `json:"documentEndpoint,omitempty"`
	EnableAnalyticalStorage            *bool                           `json:"enableAnalyticalStorage,omitempty"`
	EnableAutomaticFailover            *bool                           `json:"enableAutomaticFailover,omitempty"`
	EnableCassandraConnector           *bool                           `json:"enableCassandraConnector,omitempty"`
	EnableFreeTier                     *bool                           `json:"enableFreeTier,omitempty"`
	EnableMultipleWriteLocations       *bool                           `json:"enableMultipleWriteLocations,omitempty"`
	FailoverPolicies                   *[]FailoverPolicy               `json:"failoverPolicies,omitempty"`
	IPRules                            *[]IPAddressOrRange             `json:"ipRules,omitempty"`
	InstanceId                         *string                         `json:"instanceId,omitempty"`
	IsVirtualNetworkFilterEnabled      *bool                           `json:"isVirtualNetworkFilterEnabled,omitempty"`
	KeyVaultKeyUri                     *string                         `json:"keyVaultKeyUri,omitempty"`
	Locations                          *[]Location                     `json:"locations,omitempty"`
	NetworkAclBypass                   *NetworkAclBypass               `json:"networkAclBypass,omitempty"`
	NetworkAclBypassResourceIds        *[]string                       `json:"networkAclBypassResourceIds,omitempty"`
	PrivateEndpointConnections         *[]PrivateEndpointConnection    `json:"privateEndpointConnections,omitempty"`
	ProvisioningState                  *string                         `json:"provisioningState,omitempty"`
	PublicNetworkAccess                *PublicNetworkAccess            `json:"publicNetworkAccess,omitempty"`
	ReadLocations                      *[]Location                     `json:"readLocations,omitempty"`
	RestoreParameters                  *RestoreParameters              `json:"restoreParameters,omitempty"`
	VirtualNetworkRules                *[]VirtualNetworkRule           `json:"virtualNetworkRules,omitempty"`
	WriteLocations                     *[]Location                     `json:"writeLocations,omitempty"`
}

func (*DatabaseAccountGetProperties) UnmarshalJSON ¶

func (s *DatabaseAccountGetProperties) UnmarshalJSON(bytes []byte) error

type DatabaseAccountGetResults ¶

type DatabaseAccountGetResults struct {
	Id         *string                                  `json:"id,omitempty"`
	Identity   *identity.LegacySystemAndUserAssignedMap `json:"identity,omitempty"`
	Kind       *DatabaseAccountKind                     `json:"kind,omitempty"`
	Location   *string                                  `json:"location,omitempty"`
	Name       *string                                  `json:"name,omitempty"`
	Properties *DatabaseAccountGetProperties            `json:"properties,omitempty"`
	SystemData *systemdata.SystemData                   `json:"systemData,omitempty"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
	Type       *string                                  `json:"type,omitempty"`
}

type DatabaseAccountId ¶

type DatabaseAccountId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
}

DatabaseAccountId is a struct representing the Resource ID for a Database Account

func NewDatabaseAccountID ¶

func NewDatabaseAccountID(subscriptionId string, resourceGroupName string, databaseAccountName string) DatabaseAccountId

NewDatabaseAccountID returns a new DatabaseAccountId struct

func ParseDatabaseAccountID ¶

func ParseDatabaseAccountID(input string) (*DatabaseAccountId, error)

ParseDatabaseAccountID parses 'input' into a DatabaseAccountId

func ParseDatabaseAccountIDInsensitively ¶

func ParseDatabaseAccountIDInsensitively(input string) (*DatabaseAccountId, error)

ParseDatabaseAccountIDInsensitively parses 'input' case-insensitively into a DatabaseAccountId note: this method should only be used for API response data and not user input

func (DatabaseAccountId) ID ¶

func (id DatabaseAccountId) ID() string

ID returns the formatted Database Account ID

func (DatabaseAccountId) Segments ¶

func (id DatabaseAccountId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Database Account ID

func (DatabaseAccountId) String ¶

func (id DatabaseAccountId) String() string

String returns a human-readable description of this Database Account ID

type DatabaseAccountKind ¶

type DatabaseAccountKind string
const (
	DatabaseAccountKindGlobalDocumentDB DatabaseAccountKind = "GlobalDocumentDB"
	DatabaseAccountKindMongoDB          DatabaseAccountKind = "MongoDB"
	DatabaseAccountKindParse            DatabaseAccountKind = "Parse"
)

type DatabaseAccountListConnectionStringsResult ¶

type DatabaseAccountListConnectionStringsResult struct {
	ConnectionStrings *[]DatabaseAccountConnectionString `json:"connectionStrings,omitempty"`
}

type DatabaseAccountListKeysResult ¶

type DatabaseAccountListKeysResult struct {
	PrimaryMasterKey           *string `json:"primaryMasterKey,omitempty"`
	PrimaryReadonlyMasterKey   *string `json:"primaryReadonlyMasterKey,omitempty"`
	SecondaryMasterKey         *string `json:"secondaryMasterKey,omitempty"`
	SecondaryReadonlyMasterKey *string `json:"secondaryReadonlyMasterKey,omitempty"`
}

type DatabaseAccountListReadOnlyKeysResult ¶

type DatabaseAccountListReadOnlyKeysResult struct {
	PrimaryReadonlyMasterKey   *string `json:"primaryReadonlyMasterKey,omitempty"`
	SecondaryReadonlyMasterKey *string `json:"secondaryReadonlyMasterKey,omitempty"`
}

type DatabaseAccountNameId ¶

type DatabaseAccountNameId struct {
	DatabaseAccountName string
}

DatabaseAccountNameId is a struct representing the Resource ID for a Database Account Name

func NewDatabaseAccountNameID ¶

func NewDatabaseAccountNameID(databaseAccountName string) DatabaseAccountNameId

NewDatabaseAccountNameID returns a new DatabaseAccountNameId struct

func ParseDatabaseAccountNameID ¶

func ParseDatabaseAccountNameID(input string) (*DatabaseAccountNameId, error)

ParseDatabaseAccountNameID parses 'input' into a DatabaseAccountNameId

func ParseDatabaseAccountNameIDInsensitively ¶

func ParseDatabaseAccountNameIDInsensitively(input string) (*DatabaseAccountNameId, error)

ParseDatabaseAccountNameIDInsensitively parses 'input' case-insensitively into a DatabaseAccountNameId note: this method should only be used for API response data and not user input

func (DatabaseAccountNameId) ID ¶

func (id DatabaseAccountNameId) ID() string

ID returns the formatted Database Account Name ID

func (DatabaseAccountNameId) Segments ¶

func (id DatabaseAccountNameId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Database Account Name ID

func (DatabaseAccountNameId) String ¶

func (id DatabaseAccountNameId) String() string

String returns a human-readable description of this Database Account Name ID

type DatabaseAccountOfferType ¶

type DatabaseAccountOfferType string
const (
	DatabaseAccountOfferTypeStandard DatabaseAccountOfferType = "Standard"
)

type DatabaseAccountRegenerateKeyParameters ¶

type DatabaseAccountRegenerateKeyParameters struct {
	KeyKind KeyKind `json:"keyKind"`
}

type DatabaseAccountRegionListMetricsOperationOptions ¶

type DatabaseAccountRegionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultDatabaseAccountRegionListMetricsOperationOptions ¶

func DefaultDatabaseAccountRegionListMetricsOperationOptions() DatabaseAccountRegionListMetricsOperationOptions

type DatabaseAccountRegionListMetricsOperationResponse ¶

type DatabaseAccountRegionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type DatabaseAccountUpdateParameters ¶

type DatabaseAccountUpdateParameters struct {
	Identity   *identity.LegacySystemAndUserAssignedMap `json:"identity,omitempty"`
	Location   *string                                  `json:"location,omitempty"`
	Properties *DatabaseAccountUpdateProperties         `json:"properties,omitempty"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
}

type DatabaseAccountUpdateProperties ¶

type DatabaseAccountUpdateProperties struct {
	AnalyticalStorageConfiguration     *AnalyticalStorageConfiguration `json:"analyticalStorageConfiguration,omitempty"`
	ApiProperties                      *ApiProperties                  `json:"apiProperties,omitempty"`
	BackupPolicy                       BackupPolicy                    `json:"backupPolicy"`
	Capabilities                       *[]Capability                   `json:"capabilities,omitempty"`
	Capacity                           *Capacity                       `json:"capacity,omitempty"`
	ConnectorOffer                     *ConnectorOffer                 `json:"connectorOffer,omitempty"`
	ConsistencyPolicy                  *ConsistencyPolicy              `json:"consistencyPolicy,omitempty"`
	Cors                               *[]CorsPolicy                   `json:"cors,omitempty"`
	DefaultIdentity                    *string                         `json:"defaultIdentity,omitempty"`
	DisableKeyBasedMetadataWriteAccess *bool                           `json:"disableKeyBasedMetadataWriteAccess,omitempty"`
	DisableLocalAuth                   *bool                           `json:"disableLocalAuth,omitempty"`
	EnableAnalyticalStorage            *bool                           `json:"enableAnalyticalStorage,omitempty"`
	EnableAutomaticFailover            *bool                           `json:"enableAutomaticFailover,omitempty"`
	EnableCassandraConnector           *bool                           `json:"enableCassandraConnector,omitempty"`
	EnableFreeTier                     *bool                           `json:"enableFreeTier,omitempty"`
	EnableMultipleWriteLocations       *bool                           `json:"enableMultipleWriteLocations,omitempty"`
	IPRules                            *[]IPAddressOrRange             `json:"ipRules,omitempty"`
	IsVirtualNetworkFilterEnabled      *bool                           `json:"isVirtualNetworkFilterEnabled,omitempty"`
	KeyVaultKeyUri                     *string                         `json:"keyVaultKeyUri,omitempty"`
	Locations                          *[]Location                     `json:"locations,omitempty"`
	NetworkAclBypass                   *NetworkAclBypass               `json:"networkAclBypass,omitempty"`
	NetworkAclBypassResourceIds        *[]string                       `json:"networkAclBypassResourceIds,omitempty"`
	PublicNetworkAccess                *PublicNetworkAccess            `json:"publicNetworkAccess,omitempty"`
	VirtualNetworkRules                *[]VirtualNetworkRule           `json:"virtualNetworkRules,omitempty"`
}

func (*DatabaseAccountUpdateProperties) UnmarshalJSON ¶

func (s *DatabaseAccountUpdateProperties) UnmarshalJSON(bytes []byte) error

type DatabaseAccountsCheckNameExistsOperationResponse ¶

type DatabaseAccountsCheckNameExistsOperationResponse struct {
	HttpResponse *http.Response
}

type DatabaseAccountsCreateOrUpdateOperationResponse ¶

type DatabaseAccountsCreateOrUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsDeleteOperationResponse ¶

type DatabaseAccountsDeleteOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsFailoverPriorityChangeOperationResponse ¶

type DatabaseAccountsFailoverPriorityChangeOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsGetOperationResponse ¶

type DatabaseAccountsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountGetResults
}

type DatabaseAccountsGetReadOnlyKeysOperationResponse ¶

type DatabaseAccountsGetReadOnlyKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountListReadOnlyKeysResult
}

type DatabaseAccountsListByResourceGroupOperationResponse ¶

type DatabaseAccountsListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountsListResult
}

type DatabaseAccountsListConnectionStringsOperationResponse ¶

type DatabaseAccountsListConnectionStringsOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountListConnectionStringsResult
}

type DatabaseAccountsListKeysOperationResponse ¶

type DatabaseAccountsListKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountListKeysResult
}

type DatabaseAccountsListMetricDefinitionsOperationResponse ¶

type DatabaseAccountsListMetricDefinitionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricDefinitionsListResult
}

type DatabaseAccountsListMetricsOperationOptions ¶

type DatabaseAccountsListMetricsOperationOptions struct {
	Filter *string
}

func DefaultDatabaseAccountsListMetricsOperationOptions ¶

func DefaultDatabaseAccountsListMetricsOperationOptions() DatabaseAccountsListMetricsOperationOptions

type DatabaseAccountsListMetricsOperationResponse ¶

type DatabaseAccountsListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type DatabaseAccountsListOperationResponse ¶

type DatabaseAccountsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountsListResult
}

type DatabaseAccountsListReadOnlyKeysOperationResponse ¶

type DatabaseAccountsListReadOnlyKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountListReadOnlyKeysResult
}

type DatabaseAccountsListResult ¶

type DatabaseAccountsListResult struct {
	Value *[]DatabaseAccountGetResults `json:"value,omitempty"`
}

type DatabaseAccountsListUsagesOperationOptions ¶

type DatabaseAccountsListUsagesOperationOptions struct {
	Filter *string
}

func DefaultDatabaseAccountsListUsagesOperationOptions ¶

func DefaultDatabaseAccountsListUsagesOperationOptions() DatabaseAccountsListUsagesOperationOptions

type DatabaseAccountsListUsagesOperationResponse ¶

type DatabaseAccountsListUsagesOperationResponse struct {
	HttpResponse *http.Response
	Model        *UsagesResult
}

type DatabaseAccountsOfflineRegionOperationResponse ¶

type DatabaseAccountsOfflineRegionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsOnlineRegionOperationResponse ¶

type DatabaseAccountsOnlineRegionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsRegenerateKeyOperationResponse ¶

type DatabaseAccountsRegenerateKeyOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsUpdateOperationResponse ¶

type DatabaseAccountsUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseCollectionId ¶

type DatabaseCollectionId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	RegionName          string
	DatabaseName        string
	CollectionName      string
}

DatabaseCollectionId is a struct representing the Resource ID for a Database Collection

func NewDatabaseCollectionID ¶

func NewDatabaseCollectionID(subscriptionId string, resourceGroupName string, databaseAccountName string, regionName string, databaseName string, collectionName string) DatabaseCollectionId

NewDatabaseCollectionID returns a new DatabaseCollectionId struct

func ParseDatabaseCollectionID ¶

func ParseDatabaseCollectionID(input string) (*DatabaseCollectionId, error)

ParseDatabaseCollectionID parses 'input' into a DatabaseCollectionId

func ParseDatabaseCollectionIDInsensitively ¶

func ParseDatabaseCollectionIDInsensitively(input string) (*DatabaseCollectionId, error)

ParseDatabaseCollectionIDInsensitively parses 'input' case-insensitively into a DatabaseCollectionId note: this method should only be used for API response data and not user input

func (DatabaseCollectionId) ID ¶

func (id DatabaseCollectionId) ID() string

ID returns the formatted Database Collection ID

func (DatabaseCollectionId) Segments ¶

func (id DatabaseCollectionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Database Collection ID

func (DatabaseCollectionId) String ¶

func (id DatabaseCollectionId) String() string

String returns a human-readable description of this Database Collection ID

type DatabaseId ¶

type DatabaseId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	DatabaseName        string
}

DatabaseId is a struct representing the Resource ID for a Database

func NewDatabaseID ¶

func NewDatabaseID(subscriptionId string, resourceGroupName string, databaseAccountName string, databaseName string) DatabaseId

NewDatabaseID returns a new DatabaseId struct

func ParseDatabaseID ¶

func ParseDatabaseID(input string) (*DatabaseId, error)

ParseDatabaseID parses 'input' into a DatabaseId

func ParseDatabaseIDInsensitively ¶

func ParseDatabaseIDInsensitively(input string) (*DatabaseId, error)

ParseDatabaseIDInsensitively parses 'input' case-insensitively into a DatabaseId note: this method should only be used for API response data and not user input

func (DatabaseId) ID ¶

func (id DatabaseId) ID() string

ID returns the formatted Database ID

func (DatabaseId) Segments ¶

func (id DatabaseId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Database ID

func (DatabaseId) String ¶

func (id DatabaseId) String() string

String returns a human-readable description of this Database ID

type DatabaseListMetricDefinitionsOperationResponse ¶

type DatabaseListMetricDefinitionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricDefinitionsListResult
}

type DatabaseListMetricsOperationOptions ¶

type DatabaseListMetricsOperationOptions struct {
	Filter *string
}

func DefaultDatabaseListMetricsOperationOptions ¶

func DefaultDatabaseListMetricsOperationOptions() DatabaseListMetricsOperationOptions

type DatabaseListMetricsOperationResponse ¶

type DatabaseListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type DatabaseListUsagesOperationOptions ¶

type DatabaseListUsagesOperationOptions struct {
	Filter *string
}

func DefaultDatabaseListUsagesOperationOptions ¶

func DefaultDatabaseListUsagesOperationOptions() DatabaseListUsagesOperationOptions

type DatabaseListUsagesOperationResponse ¶

type DatabaseListUsagesOperationResponse struct {
	HttpResponse *http.Response
	Model        *UsagesResult
}

type DatabaseRestoreResource ¶

type DatabaseRestoreResource struct {
	CollectionNames *[]string `json:"collectionNames,omitempty"`
	DatabaseName    *string   `json:"databaseName,omitempty"`
}

type DefaultConsistencyLevel ¶

type DefaultConsistencyLevel string
const (
	DefaultConsistencyLevelBoundedStaleness DefaultConsistencyLevel = "BoundedStaleness"
	DefaultConsistencyLevelConsistentPrefix DefaultConsistencyLevel = "ConsistentPrefix"
	DefaultConsistencyLevelEventual         DefaultConsistencyLevel = "Eventual"
	DefaultConsistencyLevelSession          DefaultConsistencyLevel = "Session"
	DefaultConsistencyLevelStrong           DefaultConsistencyLevel = "Strong"
)

type ExcludedPath ¶

type ExcludedPath struct {
	Path *string `json:"path,omitempty"`
}

type FailoverPolicies ¶

type FailoverPolicies struct {
	FailoverPolicies []FailoverPolicy `json:"failoverPolicies"`
}

type FailoverPolicy ¶

type FailoverPolicy struct {
	FailoverPriority *int64  `json:"failoverPriority,omitempty"`
	Id               *string `json:"id,omitempty"`
	LocationName     *string `json:"locationName,omitempty"`
}

type GraphId ¶

type GraphId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	GremlinDatabaseName string
	GraphName           string
}

GraphId is a struct representing the Resource ID for a Graph

func NewGraphID ¶

func NewGraphID(subscriptionId string, resourceGroupName string, databaseAccountName string, gremlinDatabaseName string, graphName string) GraphId

NewGraphID returns a new GraphId struct

func ParseGraphID ¶

func ParseGraphID(input string) (*GraphId, error)

ParseGraphID parses 'input' into a GraphId

func ParseGraphIDInsensitively ¶

func ParseGraphIDInsensitively(input string) (*GraphId, error)

ParseGraphIDInsensitively parses 'input' case-insensitively into a GraphId note: this method should only be used for API response data and not user input

func (GraphId) ID ¶

func (id GraphId) ID() string

ID returns the formatted Graph ID

func (GraphId) Segments ¶

func (id GraphId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Graph ID

func (GraphId) String ¶

func (id GraphId) String() string

String returns a human-readable description of this Graph ID

type GremlinDatabaseCreateUpdateParameters ¶

type GremlinDatabaseCreateUpdateParameters struct {
	Id         *string                               `json:"id,omitempty"`
	Location   *string                               `json:"location,omitempty"`
	Name       *string                               `json:"name,omitempty"`
	Properties GremlinDatabaseCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                    `json:"tags,omitempty"`
	Type       *string                               `json:"type,omitempty"`
}

type GremlinDatabaseCreateUpdateProperties ¶

type GremlinDatabaseCreateUpdateProperties struct {
	Options  *CreateUpdateOptions    `json:"options,omitempty"`
	Resource GremlinDatabaseResource `json:"resource"`
}

type GremlinDatabaseGetProperties ¶

type GremlinDatabaseGetProperties struct {
	Options  *OptionsResource                      `json:"options,omitempty"`
	Resource *GremlinDatabaseGetPropertiesResource `json:"resource,omitempty"`
}

type GremlinDatabaseGetPropertiesResource ¶ added in v0.20230503.1140953

type GremlinDatabaseGetPropertiesResource struct {
	Etag *string  `json:"_etag,omitempty"`
	Id   *string  `json:"id,omitempty"`
	Rid  *string  `json:"_rid,omitempty"`
	Ts   *float64 `json:"_ts,omitempty"`
}

type GremlinDatabaseGetResults ¶

type GremlinDatabaseGetResults struct {
	Id         *string                       `json:"id,omitempty"`
	Location   *string                       `json:"location,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *GremlinDatabaseGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string            `json:"tags,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type GremlinDatabaseId ¶

type GremlinDatabaseId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	GremlinDatabaseName string
}

GremlinDatabaseId is a struct representing the Resource ID for a Gremlin Database

func NewGremlinDatabaseID ¶

func NewGremlinDatabaseID(subscriptionId string, resourceGroupName string, databaseAccountName string, gremlinDatabaseName string) GremlinDatabaseId

NewGremlinDatabaseID returns a new GremlinDatabaseId struct

func ParseGremlinDatabaseID ¶

func ParseGremlinDatabaseID(input string) (*GremlinDatabaseId, error)

ParseGremlinDatabaseID parses 'input' into a GremlinDatabaseId

func ParseGremlinDatabaseIDInsensitively ¶

func ParseGremlinDatabaseIDInsensitively(input string) (*GremlinDatabaseId, error)

ParseGremlinDatabaseIDInsensitively parses 'input' case-insensitively into a GremlinDatabaseId note: this method should only be used for API response data and not user input

func (GremlinDatabaseId) ID ¶

func (id GremlinDatabaseId) ID() string

ID returns the formatted Gremlin Database ID

func (GremlinDatabaseId) Segments ¶

func (id GremlinDatabaseId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Gremlin Database ID

func (GremlinDatabaseId) String ¶

func (id GremlinDatabaseId) String() string

String returns a human-readable description of this Gremlin Database ID

type GremlinDatabaseListResult ¶

type GremlinDatabaseListResult struct {
	Value *[]GremlinDatabaseGetResults `json:"value,omitempty"`
}

type GremlinDatabaseResource ¶

type GremlinDatabaseResource struct {
	Id string `json:"id"`
}

type GremlinGraphCreateUpdateParameters ¶

type GremlinGraphCreateUpdateParameters struct {
	Id         *string                            `json:"id,omitempty"`
	Location   *string                            `json:"location,omitempty"`
	Name       *string                            `json:"name,omitempty"`
	Properties GremlinGraphCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Type       *string                            `json:"type,omitempty"`
}

type GremlinGraphCreateUpdateProperties ¶

type GremlinGraphCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource GremlinGraphResource `json:"resource"`
}

type GremlinGraphGetProperties ¶

type GremlinGraphGetProperties struct {
	Options  *OptionsResource                   `json:"options,omitempty"`
	Resource *GremlinGraphGetPropertiesResource `json:"resource,omitempty"`
}

type GremlinGraphGetPropertiesResource ¶ added in v0.20230503.1140953

type GremlinGraphGetPropertiesResource struct {
	ConflictResolutionPolicy *ConflictResolutionPolicy `json:"conflictResolutionPolicy,omitempty"`
	DefaultTtl               *int64                    `json:"defaultTtl,omitempty"`
	Etag                     *string                   `json:"_etag,omitempty"`
	Id                       *string                   `json:"id,omitempty"`
	IndexingPolicy           *IndexingPolicy           `json:"indexingPolicy,omitempty"`
	PartitionKey             *ContainerPartitionKey    `json:"partitionKey,omitempty"`
	Rid                      *string                   `json:"_rid,omitempty"`
	Ts                       *float64                  `json:"_ts,omitempty"`
	UniqueKeyPolicy          *UniqueKeyPolicy          `json:"uniqueKeyPolicy,omitempty"`
}

type GremlinGraphGetResults ¶

type GremlinGraphGetResults struct {
	Id         *string                    `json:"id,omitempty"`
	Location   *string                    `json:"location,omitempty"`
	Name       *string                    `json:"name,omitempty"`
	Properties *GremlinGraphGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string         `json:"tags,omitempty"`
	Type       *string                    `json:"type,omitempty"`
}

type GremlinGraphListResult ¶

type GremlinGraphListResult struct {
	Value *[]GremlinGraphGetResults `json:"value,omitempty"`
}

type GremlinGraphResource ¶

type GremlinGraphResource struct {
	ConflictResolutionPolicy *ConflictResolutionPolicy `json:"conflictResolutionPolicy,omitempty"`
	DefaultTtl               *int64                    `json:"defaultTtl,omitempty"`
	Id                       string                    `json:"id"`
	IndexingPolicy           *IndexingPolicy           `json:"indexingPolicy,omitempty"`
	PartitionKey             *ContainerPartitionKey    `json:"partitionKey,omitempty"`
	UniqueKeyPolicy          *UniqueKeyPolicy          `json:"uniqueKeyPolicy,omitempty"`
}

type GremlinResourcesCreateUpdateGremlinDatabaseOperationResponse ¶

type GremlinResourcesCreateUpdateGremlinDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesCreateUpdateGremlinGraphOperationResponse ¶

type GremlinResourcesCreateUpdateGremlinGraphOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesDeleteGremlinDatabaseOperationResponse ¶

type GremlinResourcesDeleteGremlinDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesDeleteGremlinGraphOperationResponse ¶

type GremlinResourcesDeleteGremlinGraphOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesGetGremlinDatabaseOperationResponse ¶

type GremlinResourcesGetGremlinDatabaseOperationResponse struct {
	HttpResponse *http.Response
	Model        *GremlinDatabaseGetResults
}

type GremlinResourcesGetGremlinDatabaseThroughputOperationResponse ¶

type GremlinResourcesGetGremlinDatabaseThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type GremlinResourcesGetGremlinGraphOperationResponse ¶

type GremlinResourcesGetGremlinGraphOperationResponse struct {
	HttpResponse *http.Response
	Model        *GremlinGraphGetResults
}

type GremlinResourcesGetGremlinGraphThroughputOperationResponse ¶

type GremlinResourcesGetGremlinGraphThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type GremlinResourcesListGremlinDatabasesOperationResponse ¶

type GremlinResourcesListGremlinDatabasesOperationResponse struct {
	HttpResponse *http.Response
	Model        *GremlinDatabaseListResult
}

type GremlinResourcesListGremlinGraphsOperationResponse ¶

type GremlinResourcesListGremlinGraphsOperationResponse struct {
	HttpResponse *http.Response
	Model        *GremlinGraphListResult
}

type GremlinResourcesMigrateGremlinDatabaseToAutoscaleOperationResponse ¶

type GremlinResourcesMigrateGremlinDatabaseToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesMigrateGremlinDatabaseToManualThroughputOperationResponse ¶

type GremlinResourcesMigrateGremlinDatabaseToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesMigrateGremlinGraphToAutoscaleOperationResponse ¶

type GremlinResourcesMigrateGremlinGraphToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesMigrateGremlinGraphToManualThroughputOperationResponse ¶

type GremlinResourcesMigrateGremlinGraphToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesUpdateGremlinDatabaseThroughputOperationResponse ¶

type GremlinResourcesUpdateGremlinDatabaseThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesUpdateGremlinGraphThroughputOperationResponse ¶

type GremlinResourcesUpdateGremlinGraphThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type IPAddressOrRange ¶

type IPAddressOrRange struct {
	IPAddressOrRange *string `json:"ipAddressOrRange,omitempty"`
}

type IncludedPath ¶

type IncludedPath struct {
	Indexes *[]Indexes `json:"indexes,omitempty"`
	Path    *string    `json:"path,omitempty"`
}

type IndexKind ¶

type IndexKind string
const (
	IndexKindHash    IndexKind = "Hash"
	IndexKindRange   IndexKind = "Range"
	IndexKindSpatial IndexKind = "Spatial"
)

type Indexes ¶

type Indexes struct {
	DataType  *DataType  `json:"dataType,omitempty"`
	Kind      *IndexKind `json:"kind,omitempty"`
	Precision *int64     `json:"precision,omitempty"`
}

type IndexingMode ¶

type IndexingMode string
const (
	IndexingModeConsistent IndexingMode = "consistent"
	IndexingModeLazy       IndexingMode = "lazy"
	IndexingModeNone       IndexingMode = "none"
)

type IndexingPolicy ¶

type IndexingPolicy struct {
	Automatic        *bool              `json:"automatic,omitempty"`
	CompositeIndexes *[][]CompositePath `json:"compositeIndexes,omitempty"`
	ExcludedPaths    *[]ExcludedPath    `json:"excludedPaths,omitempty"`
	IncludedPaths    *[]IncludedPath    `json:"includedPaths,omitempty"`
	IndexingMode     *IndexingMode      `json:"indexingMode,omitempty"`
	SpatialIndexes   *[]SpatialSpec     `json:"spatialIndexes,omitempty"`
}

type KeyKind ¶

type KeyKind string
const (
	KeyKindPrimary           KeyKind = "primary"
	KeyKindPrimaryReadonly   KeyKind = "primaryReadonly"
	KeyKindSecondary         KeyKind = "secondary"
	KeyKindSecondaryReadonly KeyKind = "secondaryReadonly"
)

type Location ¶

type Location struct {
	DocumentEndpoint  *string `json:"documentEndpoint,omitempty"`
	FailoverPriority  *int64  `json:"failoverPriority,omitempty"`
	Id                *string `json:"id,omitempty"`
	IsZoneRedundant   *bool   `json:"isZoneRedundant,omitempty"`
	LocationName      *string `json:"locationName,omitempty"`
	ProvisioningState *string `json:"provisioningState,omitempty"`
}

type LocationGetResult ¶

type LocationGetResult struct {
	Id         *string             `json:"id,omitempty"`
	Name       *string             `json:"name,omitempty"`
	Properties *LocationProperties `json:"properties,omitempty"`
	Type       *string             `json:"type,omitempty"`
}

type LocationId ¶

type LocationId struct {
	SubscriptionId string
	LocationName   string
}

LocationId is a struct representing the Resource ID for a Location

func NewLocationID ¶

func NewLocationID(subscriptionId string, locationName string) LocationId

NewLocationID returns a new LocationId struct

func ParseLocationID ¶

func ParseLocationID(input string) (*LocationId, error)

ParseLocationID parses 'input' into a LocationId

func ParseLocationIDInsensitively ¶

func ParseLocationIDInsensitively(input string) (*LocationId, error)

ParseLocationIDInsensitively parses 'input' case-insensitively into a LocationId note: this method should only be used for API response data and not user input

func (LocationId) ID ¶

func (id LocationId) ID() string

ID returns the formatted Location ID

func (LocationId) Segments ¶

func (id LocationId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Location ID

func (LocationId) String ¶

func (id LocationId) String() string

String returns a human-readable description of this Location ID

type LocationListResult ¶

type LocationListResult struct {
	Value *[]LocationGetResult `json:"value,omitempty"`
}

type LocationProperties ¶

type LocationProperties struct {
	BackupStorageRedundancies *[]BackupStorageRedundancy `json:"backupStorageRedundancies,omitempty"`
	IsResidencyRestricted     *bool                      `json:"isResidencyRestricted,omitempty"`
	SupportsAvailabilityZone  *bool                      `json:"supportsAvailabilityZone,omitempty"`
}

type LocationsGetOperationResponse ¶

type LocationsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *LocationGetResult
}

type LocationsListOperationResponse ¶

type LocationsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *LocationListResult
}

type Metric ¶

type Metric struct {
	EndTime      *string        `json:"endTime,omitempty"`
	MetricValues *[]MetricValue `json:"metricValues,omitempty"`
	Name         *MetricName    `json:"name,omitempty"`
	StartTime    *string        `json:"startTime,omitempty"`
	TimeGrain    *string        `json:"timeGrain,omitempty"`
	Unit         *UnitType      `json:"unit,omitempty"`
}

func (*Metric) GetEndTimeAsTime ¶

func (o *Metric) GetEndTimeAsTime() (*time.Time, error)

func (*Metric) GetStartTimeAsTime ¶

func (o *Metric) GetStartTimeAsTime() (*time.Time, error)

func (*Metric) SetEndTimeAsTime ¶

func (o *Metric) SetEndTimeAsTime(input time.Time)

func (*Metric) SetStartTimeAsTime ¶

func (o *Metric) SetStartTimeAsTime(input time.Time)

type MetricAvailability ¶

type MetricAvailability struct {
	Retention *string `json:"retention,omitempty"`
	TimeGrain *string `json:"timeGrain,omitempty"`
}

type MetricDefinition ¶

type MetricDefinition struct {
	MetricAvailabilities   *[]MetricAvailability   `json:"metricAvailabilities,omitempty"`
	Name                   *MetricName             `json:"name,omitempty"`
	PrimaryAggregationType *PrimaryAggregationType `json:"primaryAggregationType,omitempty"`
	ResourceUri            *string                 `json:"resourceUri,omitempty"`
	Unit                   *UnitType               `json:"unit,omitempty"`
}

type MetricDefinitionsListResult ¶

type MetricDefinitionsListResult struct {
	Value *[]MetricDefinition `json:"value,omitempty"`
}

type MetricListResult ¶

type MetricListResult struct {
	Value *[]Metric `json:"value,omitempty"`
}

type MetricName ¶

type MetricName struct {
	LocalizedValue *string `json:"localizedValue,omitempty"`
	Value          *string `json:"value,omitempty"`
}

type MetricValue ¶

type MetricValue struct {
	Average   *float64 `json:"average,omitempty"`
	Count     *float64 `json:"_count,omitempty"`
	Maximum   *float64 `json:"maximum,omitempty"`
	Minimum   *float64 `json:"minimum,omitempty"`
	Timestamp *string  `json:"timestamp,omitempty"`
	Total     *float64 `json:"total,omitempty"`
}

func (*MetricValue) GetTimestampAsTime ¶

func (o *MetricValue) GetTimestampAsTime() (*time.Time, error)

func (*MetricValue) SetTimestampAsTime ¶

func (o *MetricValue) SetTimestampAsTime(input time.Time)

type MongoDBCollectionCreateUpdateParameters ¶

type MongoDBCollectionCreateUpdateParameters struct {
	Id         *string                                 `json:"id,omitempty"`
	Location   *string                                 `json:"location,omitempty"`
	Name       *string                                 `json:"name,omitempty"`
	Properties MongoDBCollectionCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                      `json:"tags,omitempty"`
	Type       *string                                 `json:"type,omitempty"`
}

type MongoDBCollectionCreateUpdateProperties ¶

type MongoDBCollectionCreateUpdateProperties struct {
	Options  *CreateUpdateOptions      `json:"options,omitempty"`
	Resource MongoDBCollectionResource `json:"resource"`
}

type MongoDBCollectionGetProperties ¶

type MongoDBCollectionGetProperties struct {
	Options  *OptionsResource                        `json:"options,omitempty"`
	Resource *MongoDBCollectionGetPropertiesResource `json:"resource,omitempty"`
}

type MongoDBCollectionGetPropertiesResource ¶ added in v0.20230503.1140953

type MongoDBCollectionGetPropertiesResource struct {
	AnalyticalStorageTtl *int64             `json:"analyticalStorageTtl,omitempty"`
	Etag                 *string            `json:"_etag,omitempty"`
	Id                   *string            `json:"id,omitempty"`
	Indexes              *[]MongoIndex      `json:"indexes,omitempty"`
	Rid                  *string            `json:"_rid,omitempty"`
	ShardKey             *map[string]string `json:"shardKey,omitempty"`
	Ts                   *float64           `json:"_ts,omitempty"`
}

type MongoDBCollectionGetResults ¶

type MongoDBCollectionGetResults struct {
	Id         *string                         `json:"id,omitempty"`
	Location   *string                         `json:"location,omitempty"`
	Name       *string                         `json:"name,omitempty"`
	Properties *MongoDBCollectionGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string              `json:"tags,omitempty"`
	Type       *string                         `json:"type,omitempty"`
}

type MongoDBCollectionListResult ¶

type MongoDBCollectionListResult struct {
	Value *[]MongoDBCollectionGetResults `json:"value,omitempty"`
}

type MongoDBCollectionResource ¶

type MongoDBCollectionResource struct {
	AnalyticalStorageTtl *int64             `json:"analyticalStorageTtl,omitempty"`
	Id                   string             `json:"id"`
	Indexes              *[]MongoIndex      `json:"indexes,omitempty"`
	ShardKey             *map[string]string `json:"shardKey,omitempty"`
}

type MongoDBDatabaseCreateUpdateParameters ¶

type MongoDBDatabaseCreateUpdateParameters struct {
	Id         *string                               `json:"id,omitempty"`
	Location   *string                               `json:"location,omitempty"`
	Name       *string                               `json:"name,omitempty"`
	Properties MongoDBDatabaseCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                    `json:"tags,omitempty"`
	Type       *string                               `json:"type,omitempty"`
}

type MongoDBDatabaseCreateUpdateProperties ¶

type MongoDBDatabaseCreateUpdateProperties struct {
	Options  *CreateUpdateOptions    `json:"options,omitempty"`
	Resource MongoDBDatabaseResource `json:"resource"`
}

type MongoDBDatabaseGetProperties ¶

type MongoDBDatabaseGetProperties struct {
	Options  *OptionsResource                      `json:"options,omitempty"`
	Resource *MongoDBDatabaseGetPropertiesResource `json:"resource,omitempty"`
}

type MongoDBDatabaseGetPropertiesResource ¶ added in v0.20230503.1140953

type MongoDBDatabaseGetPropertiesResource struct {
	Etag *string  `json:"_etag,omitempty"`
	Id   *string  `json:"id,omitempty"`
	Rid  *string  `json:"_rid,omitempty"`
	Ts   *float64 `json:"_ts,omitempty"`
}

type MongoDBDatabaseGetResults ¶

type MongoDBDatabaseGetResults struct {
	Id         *string                       `json:"id,omitempty"`
	Location   *string                       `json:"location,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *MongoDBDatabaseGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string            `json:"tags,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type MongoDBDatabaseListResult ¶

type MongoDBDatabaseListResult struct {
	Value *[]MongoDBDatabaseGetResults `json:"value,omitempty"`
}

type MongoDBDatabaseResource ¶

type MongoDBDatabaseResource struct {
	Id string `json:"id"`
}

type MongoDBResourcesCreateUpdateMongoDBCollectionOperationResponse ¶

type MongoDBResourcesCreateUpdateMongoDBCollectionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesCreateUpdateMongoDBDatabaseOperationResponse ¶

type MongoDBResourcesCreateUpdateMongoDBDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesDeleteMongoDBCollectionOperationResponse ¶

type MongoDBResourcesDeleteMongoDBCollectionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesDeleteMongoDBDatabaseOperationResponse ¶

type MongoDBResourcesDeleteMongoDBDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesGetMongoDBCollectionOperationResponse ¶

type MongoDBResourcesGetMongoDBCollectionOperationResponse struct {
	HttpResponse *http.Response
	Model        *MongoDBCollectionGetResults
}

type MongoDBResourcesGetMongoDBCollectionThroughputOperationResponse ¶

type MongoDBResourcesGetMongoDBCollectionThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type MongoDBResourcesGetMongoDBDatabaseOperationResponse ¶

type MongoDBResourcesGetMongoDBDatabaseOperationResponse struct {
	HttpResponse *http.Response
	Model        *MongoDBDatabaseGetResults
}

type MongoDBResourcesGetMongoDBDatabaseThroughputOperationResponse ¶

type MongoDBResourcesGetMongoDBDatabaseThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type MongoDBResourcesListMongoDBCollectionsOperationResponse ¶

type MongoDBResourcesListMongoDBCollectionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MongoDBCollectionListResult
}

type MongoDBResourcesListMongoDBDatabasesOperationResponse ¶

type MongoDBResourcesListMongoDBDatabasesOperationResponse struct {
	HttpResponse *http.Response
	Model        *MongoDBDatabaseListResult
}

type MongoDBResourcesMigrateMongoDBCollectionToAutoscaleOperationResponse ¶

type MongoDBResourcesMigrateMongoDBCollectionToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesMigrateMongoDBCollectionToManualThroughputOperationResponse ¶

type MongoDBResourcesMigrateMongoDBCollectionToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleOperationResponse ¶

type MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputOperationResponse ¶

type MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesUpdateMongoDBCollectionThroughputOperationResponse ¶

type MongoDBResourcesUpdateMongoDBCollectionThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesUpdateMongoDBDatabaseThroughputOperationResponse ¶

type MongoDBResourcesUpdateMongoDBDatabaseThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoIndex ¶

type MongoIndex struct {
	Key     *MongoIndexKeys    `json:"key,omitempty"`
	Options *MongoIndexOptions `json:"options,omitempty"`
}

type MongoIndexKeys ¶

type MongoIndexKeys struct {
	Keys *[]string `json:"keys,omitempty"`
}

type MongoIndexOptions ¶

type MongoIndexOptions struct {
	ExpireAfterSeconds *int64 `json:"expireAfterSeconds,omitempty"`
	Unique             *bool  `json:"unique,omitempty"`
}

type MongodbDatabaseCollectionId ¶

type MongodbDatabaseCollectionId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	MongodbDatabaseName string
	CollectionName      string
}

MongodbDatabaseCollectionId is a struct representing the Resource ID for a Mongodb Database Collection

func NewMongodbDatabaseCollectionID ¶

func NewMongodbDatabaseCollectionID(subscriptionId string, resourceGroupName string, databaseAccountName string, mongodbDatabaseName string, collectionName string) MongodbDatabaseCollectionId

NewMongodbDatabaseCollectionID returns a new MongodbDatabaseCollectionId struct

func ParseMongodbDatabaseCollectionID ¶

func ParseMongodbDatabaseCollectionID(input string) (*MongodbDatabaseCollectionId, error)

ParseMongodbDatabaseCollectionID parses 'input' into a MongodbDatabaseCollectionId

func ParseMongodbDatabaseCollectionIDInsensitively ¶

func ParseMongodbDatabaseCollectionIDInsensitively(input string) (*MongodbDatabaseCollectionId, error)

ParseMongodbDatabaseCollectionIDInsensitively parses 'input' case-insensitively into a MongodbDatabaseCollectionId note: this method should only be used for API response data and not user input

func (MongodbDatabaseCollectionId) ID ¶

ID returns the formatted Mongodb Database Collection ID

func (MongodbDatabaseCollectionId) Segments ¶

Segments returns a slice of Resource ID Segments which comprise this Mongodb Database Collection ID

func (MongodbDatabaseCollectionId) String ¶

func (id MongodbDatabaseCollectionId) String() string

String returns a human-readable description of this Mongodb Database Collection ID

type MongodbDatabaseId ¶

type MongodbDatabaseId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	MongodbDatabaseName string
}

MongodbDatabaseId is a struct representing the Resource ID for a Mongodb Database

func NewMongodbDatabaseID ¶

func NewMongodbDatabaseID(subscriptionId string, resourceGroupName string, databaseAccountName string, mongodbDatabaseName string) MongodbDatabaseId

NewMongodbDatabaseID returns a new MongodbDatabaseId struct

func ParseMongodbDatabaseID ¶

func ParseMongodbDatabaseID(input string) (*MongodbDatabaseId, error)

ParseMongodbDatabaseID parses 'input' into a MongodbDatabaseId

func ParseMongodbDatabaseIDInsensitively ¶

func ParseMongodbDatabaseIDInsensitively(input string) (*MongodbDatabaseId, error)

ParseMongodbDatabaseIDInsensitively parses 'input' case-insensitively into a MongodbDatabaseId note: this method should only be used for API response data and not user input

func (MongodbDatabaseId) ID ¶

func (id MongodbDatabaseId) ID() string

ID returns the formatted Mongodb Database ID

func (MongodbDatabaseId) Segments ¶

func (id MongodbDatabaseId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Mongodb Database ID

func (MongodbDatabaseId) String ¶

func (id MongodbDatabaseId) String() string

String returns a human-readable description of this Mongodb Database ID

type NetworkAclBypass ¶

type NetworkAclBypass string
const (
	NetworkAclBypassAzureServices NetworkAclBypass = "AzureServices"
	NetworkAclBypassNone          NetworkAclBypass = "None"
)

type OptionsResource ¶

type OptionsResource struct {
	AutoScaleSettings *AutoScaleSettings `json:"autoscaleSettings,omitempty"`
	Throughput        *int64             `json:"throughput,omitempty"`
}

type PartitionKeyRangeIdId ¶

type PartitionKeyRangeIdId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	DatabaseName        string
	CollectionName      string
	PartitionKeyRangeId string
}

PartitionKeyRangeIdId is a struct representing the Resource ID for a Partition Key Range Id

func NewPartitionKeyRangeIdID ¶

func NewPartitionKeyRangeIdID(subscriptionId string, resourceGroupName string, databaseAccountName string, databaseName string, collectionName string, partitionKeyRangeId string) PartitionKeyRangeIdId

NewPartitionKeyRangeIdID returns a new PartitionKeyRangeIdId struct

func ParsePartitionKeyRangeIdID ¶

func ParsePartitionKeyRangeIdID(input string) (*PartitionKeyRangeIdId, error)

ParsePartitionKeyRangeIdID parses 'input' into a PartitionKeyRangeIdId

func ParsePartitionKeyRangeIdIDInsensitively ¶

func ParsePartitionKeyRangeIdIDInsensitively(input string) (*PartitionKeyRangeIdId, error)

ParsePartitionKeyRangeIdIDInsensitively parses 'input' case-insensitively into a PartitionKeyRangeIdId note: this method should only be used for API response data and not user input

func (PartitionKeyRangeIdId) ID ¶

func (id PartitionKeyRangeIdId) ID() string

ID returns the formatted Partition Key Range Id ID

func (PartitionKeyRangeIdId) Segments ¶

func (id PartitionKeyRangeIdId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Partition Key Range Id ID

func (PartitionKeyRangeIdId) String ¶

func (id PartitionKeyRangeIdId) String() string

String returns a human-readable description of this Partition Key Range Id ID

type PartitionKeyRangeIdListMetricsOperationOptions ¶

type PartitionKeyRangeIdListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPartitionKeyRangeIdListMetricsOperationOptions ¶

func DefaultPartitionKeyRangeIdListMetricsOperationOptions() PartitionKeyRangeIdListMetricsOperationOptions

type PartitionKeyRangeIdListMetricsOperationResponse ¶

type PartitionKeyRangeIdListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionMetricListResult
}

type PartitionKeyRangeIdRegionListMetricsOperationOptions ¶

type PartitionKeyRangeIdRegionListMetricsOperationOptions struct {
	Filter *string
}

type PartitionKeyRangeIdRegionListMetricsOperationResponse ¶

type PartitionKeyRangeIdRegionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionMetricListResult
}

type PartitionKind ¶

type PartitionKind string
const (
	PartitionKindHash      PartitionKind = "Hash"
	PartitionKindMultiHash PartitionKind = "MultiHash"
	PartitionKindRange     PartitionKind = "Range"
)

type PartitionMetric ¶

type PartitionMetric struct {
	EndTime             *string        `json:"endTime,omitempty"`
	MetricValues        *[]MetricValue `json:"metricValues,omitempty"`
	Name                *MetricName    `json:"name,omitempty"`
	PartitionId         *string        `json:"partitionId,omitempty"`
	PartitionKeyRangeId *string        `json:"partitionKeyRangeId,omitempty"`
	StartTime           *string        `json:"startTime,omitempty"`
	TimeGrain           *string        `json:"timeGrain,omitempty"`
	Unit                *UnitType      `json:"unit,omitempty"`
}

func (*PartitionMetric) GetEndTimeAsTime ¶

func (o *PartitionMetric) GetEndTimeAsTime() (*time.Time, error)

func (*PartitionMetric) GetStartTimeAsTime ¶

func (o *PartitionMetric) GetStartTimeAsTime() (*time.Time, error)

func (*PartitionMetric) SetEndTimeAsTime ¶

func (o *PartitionMetric) SetEndTimeAsTime(input time.Time)

func (*PartitionMetric) SetStartTimeAsTime ¶

func (o *PartitionMetric) SetStartTimeAsTime(input time.Time)

type PartitionMetricListResult ¶

type PartitionMetricListResult struct {
	Value *[]PartitionMetric `json:"value,omitempty"`
}

type PartitionUsage ¶

type PartitionUsage struct {
	CurrentValue        *int64      `json:"currentValue,omitempty"`
	Limit               *int64      `json:"limit,omitempty"`
	Name                *MetricName `json:"name,omitempty"`
	PartitionId         *string     `json:"partitionId,omitempty"`
	PartitionKeyRangeId *string     `json:"partitionKeyRangeId,omitempty"`
	QuotaPeriod         *string     `json:"quotaPeriod,omitempty"`
	Unit                *UnitType   `json:"unit,omitempty"`
}

type PartitionUsagesResult ¶

type PartitionUsagesResult struct {
	Value *[]PartitionUsage `json:"value,omitempty"`
}

type PercentileListMetricsOperationOptions ¶

type PercentileListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPercentileListMetricsOperationOptions ¶

func DefaultPercentileListMetricsOperationOptions() PercentileListMetricsOperationOptions

type PercentileListMetricsOperationResponse ¶

type PercentileListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PercentileMetricListResult
}

type PercentileMetric ¶

type PercentileMetric struct {
	EndTime      *string                  `json:"endTime,omitempty"`
	MetricValues *[]PercentileMetricValue `json:"metricValues,omitempty"`
	Name         *MetricName              `json:"name,omitempty"`
	StartTime    *string                  `json:"startTime,omitempty"`
	TimeGrain    *string                  `json:"timeGrain,omitempty"`
	Unit         *UnitType                `json:"unit,omitempty"`
}

func (*PercentileMetric) GetEndTimeAsTime ¶

func (o *PercentileMetric) GetEndTimeAsTime() (*time.Time, error)

func (*PercentileMetric) GetStartTimeAsTime ¶

func (o *PercentileMetric) GetStartTimeAsTime() (*time.Time, error)

func (*PercentileMetric) SetEndTimeAsTime ¶

func (o *PercentileMetric) SetEndTimeAsTime(input time.Time)

func (*PercentileMetric) SetStartTimeAsTime ¶

func (o *PercentileMetric) SetStartTimeAsTime(input time.Time)

type PercentileMetricListResult ¶

type PercentileMetricListResult struct {
	Value *[]PercentileMetric `json:"value,omitempty"`
}

type PercentileMetricValue ¶

type PercentileMetricValue struct {
	Average   *float64 `json:"average,omitempty"`
	Count     *float64 `json:"_count,omitempty"`
	Maximum   *float64 `json:"maximum,omitempty"`
	Minimum   *float64 `json:"minimum,omitempty"`
	P10       *float64 `json:"P10,omitempty"`
	P25       *float64 `json:"P25,omitempty"`
	P50       *float64 `json:"P50,omitempty"`
	P75       *float64 `json:"P75,omitempty"`
	P90       *float64 `json:"P90,omitempty"`
	P95       *float64 `json:"P95,omitempty"`
	P99       *float64 `json:"P99,omitempty"`
	Timestamp *string  `json:"timestamp,omitempty"`
	Total     *float64 `json:"total,omitempty"`
}

func (*PercentileMetricValue) GetTimestampAsTime ¶

func (o *PercentileMetricValue) GetTimestampAsTime() (*time.Time, error)

func (*PercentileMetricValue) SetTimestampAsTime ¶

func (o *PercentileMetricValue) SetTimestampAsTime(input time.Time)

type PercentileSourceTargetListMetricsOperationOptions ¶

type PercentileSourceTargetListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPercentileSourceTargetListMetricsOperationOptions ¶

func DefaultPercentileSourceTargetListMetricsOperationOptions() PercentileSourceTargetListMetricsOperationOptions

type PercentileSourceTargetListMetricsOperationResponse ¶

type PercentileSourceTargetListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PercentileMetricListResult
}

type PercentileTargetListMetricsOperationOptions ¶

type PercentileTargetListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPercentileTargetListMetricsOperationOptions ¶

func DefaultPercentileTargetListMetricsOperationOptions() PercentileTargetListMetricsOperationOptions

type PercentileTargetListMetricsOperationResponse ¶

type PercentileTargetListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PercentileMetricListResult
}

type PeriodicModeBackupPolicy ¶

type PeriodicModeBackupPolicy struct {
	PeriodicModeProperties *PeriodicModeProperties `json:"periodicModeProperties,omitempty"`

	// Fields inherited from BackupPolicy
	MigrationState *BackupPolicyMigrationState `json:"migrationState,omitempty"`
}

func (PeriodicModeBackupPolicy) MarshalJSON ¶

func (s PeriodicModeBackupPolicy) MarshalJSON() ([]byte, error)

type PeriodicModeProperties ¶

type PeriodicModeProperties struct {
	BackupIntervalInMinutes        *int64                   `json:"backupIntervalInMinutes,omitempty"`
	BackupRetentionIntervalInHours *int64                   `json:"backupRetentionIntervalInHours,omitempty"`
	BackupStorageRedundancy        *BackupStorageRedundancy `json:"backupStorageRedundancy,omitempty"`
}

type PrimaryAggregationType ¶

type PrimaryAggregationType string
const (
	PrimaryAggregationTypeAverage PrimaryAggregationType = "Average"
	PrimaryAggregationTypeLast    PrimaryAggregationType = "Last"
	PrimaryAggregationTypeMaximum PrimaryAggregationType = "Maximum"
	PrimaryAggregationTypeMinimum PrimaryAggregationType = "Minimum"
	PrimaryAggregationTypeNone    PrimaryAggregationType = "None"
	PrimaryAggregationTypeTotal   PrimaryAggregationType = "Total"
)

type PrivateEndpointConnection ¶

type PrivateEndpointConnection struct {
	Id         *string                              `json:"id,omitempty"`
	Name       *string                              `json:"name,omitempty"`
	Properties *PrivateEndpointConnectionProperties `json:"properties,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type PrivateEndpointConnectionProperties ¶

type PrivateEndpointConnectionProperties struct {
	GroupId                           *string                                    `json:"groupId,omitempty"`
	PrivateEndpoint                   *PrivateEndpointProperty                   `json:"privateEndpoint,omitempty"`
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionStateProperty `json:"privateLinkServiceConnectionState,omitempty"`
	ProvisioningState                 *string                                    `json:"provisioningState,omitempty"`
}

type PrivateEndpointProperty ¶

type PrivateEndpointProperty struct {
	Id *string `json:"id,omitempty"`
}

type PrivateLinkServiceConnectionStateProperty ¶

type PrivateLinkServiceConnectionStateProperty struct {
	ActionsRequired *string `json:"actionsRequired,omitempty"`
	Description     *string `json:"description,omitempty"`
	Status          *string `json:"status,omitempty"`
}

type PublicNetworkAccess ¶

type PublicNetworkAccess string
const (
	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
	PublicNetworkAccessEnabled  PublicNetworkAccess = "Enabled"
)

type RegionForOnlineOffline ¶

type RegionForOnlineOffline struct {
	Region string `json:"region"`
}

type RegionId ¶

type RegionId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	RegionName          string
}

RegionId is a struct representing the Resource ID for a Region

func NewRegionID ¶

func NewRegionID(subscriptionId string, resourceGroupName string, databaseAccountName string, regionName string) RegionId

NewRegionID returns a new RegionId struct

func ParseRegionID ¶

func ParseRegionID(input string) (*RegionId, error)

ParseRegionID parses 'input' into a RegionId

func ParseRegionIDInsensitively ¶

func ParseRegionIDInsensitively(input string) (*RegionId, error)

ParseRegionIDInsensitively parses 'input' case-insensitively into a RegionId note: this method should only be used for API response data and not user input

func (RegionId) ID ¶

func (id RegionId) ID() string

ID returns the formatted Region ID

func (RegionId) Segments ¶

func (id RegionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Region ID

func (RegionId) String ¶

func (id RegionId) String() string

String returns a human-readable description of this Region ID

type RestoreMode ¶

type RestoreMode string
const (
	RestoreModePointInTime RestoreMode = "PointInTime"
)

type RestoreParameters ¶

type RestoreParameters struct {
	DatabasesToRestore    *[]DatabaseRestoreResource `json:"databasesToRestore,omitempty"`
	RestoreMode           *RestoreMode               `json:"restoreMode,omitempty"`
	RestoreSource         *string                    `json:"restoreSource,omitempty"`
	RestoreTimestampInUtc *string                    `json:"restoreTimestampInUtc,omitempty"`
}

func (*RestoreParameters) GetRestoreTimestampInUtcAsTime ¶

func (o *RestoreParameters) GetRestoreTimestampInUtcAsTime() (*time.Time, error)

func (*RestoreParameters) SetRestoreTimestampInUtcAsTime ¶

func (o *RestoreParameters) SetRestoreTimestampInUtcAsTime(input time.Time)

type ServerVersion ¶

type ServerVersion string
const (
	ServerVersionFourPointTwo  ServerVersion = "4.2"
	ServerVersionFourPointZero ServerVersion = "4.0"
	ServerVersionThreePointSix ServerVersion = "3.6"
	ServerVersionThreePointTwo ServerVersion = "3.2"
)

type SourceRegionTargetRegionId ¶

type SourceRegionTargetRegionId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	SourceRegionName    string
	TargetRegionName    string
}

SourceRegionTargetRegionId is a struct representing the Resource ID for a Source Region Target Region

func NewSourceRegionTargetRegionID ¶

func NewSourceRegionTargetRegionID(subscriptionId string, resourceGroupName string, databaseAccountName string, sourceRegionName string, targetRegionName string) SourceRegionTargetRegionId

NewSourceRegionTargetRegionID returns a new SourceRegionTargetRegionId struct

func ParseSourceRegionTargetRegionID ¶

func ParseSourceRegionTargetRegionID(input string) (*SourceRegionTargetRegionId, error)

ParseSourceRegionTargetRegionID parses 'input' into a SourceRegionTargetRegionId

func ParseSourceRegionTargetRegionIDInsensitively ¶

func ParseSourceRegionTargetRegionIDInsensitively(input string) (*SourceRegionTargetRegionId, error)

ParseSourceRegionTargetRegionIDInsensitively parses 'input' case-insensitively into a SourceRegionTargetRegionId note: this method should only be used for API response data and not user input

func (SourceRegionTargetRegionId) ID ¶

ID returns the formatted Source Region Target Region ID

func (SourceRegionTargetRegionId) Segments ¶

Segments returns a slice of Resource ID Segments which comprise this Source Region Target Region ID

func (SourceRegionTargetRegionId) String ¶

func (id SourceRegionTargetRegionId) String() string

String returns a human-readable description of this Source Region Target Region ID

type SpatialSpec ¶

type SpatialSpec struct {
	Path  *string        `json:"path,omitempty"`
	Types *[]SpatialType `json:"types,omitempty"`
}

type SpatialType ¶

type SpatialType string
const (
	SpatialTypeLineString   SpatialType = "LineString"
	SpatialTypeMultiPolygon SpatialType = "MultiPolygon"
	SpatialTypePoint        SpatialType = "Point"
	SpatialTypePolygon      SpatialType = "Polygon"
)

type SqlContainerCreateUpdateParameters ¶

type SqlContainerCreateUpdateParameters struct {
	Id         *string                            `json:"id,omitempty"`
	Location   *string                            `json:"location,omitempty"`
	Name       *string                            `json:"name,omitempty"`
	Properties SqlContainerCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Type       *string                            `json:"type,omitempty"`
}

type SqlContainerCreateUpdateProperties ¶

type SqlContainerCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource SqlContainerResource `json:"resource"`
}

type SqlContainerGetProperties ¶

type SqlContainerGetProperties struct {
	Options  *OptionsResource                   `json:"options,omitempty"`
	Resource *SqlContainerGetPropertiesResource `json:"resource,omitempty"`
}

type SqlContainerGetPropertiesResource ¶ added in v0.20230503.1140953

type SqlContainerGetPropertiesResource struct {
	AnalyticalStorageTtl     *int64                    `json:"analyticalStorageTtl,omitempty"`
	ConflictResolutionPolicy *ConflictResolutionPolicy `json:"conflictResolutionPolicy,omitempty"`
	DefaultTtl               *int64                    `json:"defaultTtl,omitempty"`
	Etag                     *string                   `json:"_etag,omitempty"`
	Id                       *string                   `json:"id,omitempty"`
	IndexingPolicy           *IndexingPolicy           `json:"indexingPolicy,omitempty"`
	PartitionKey             *ContainerPartitionKey    `json:"partitionKey,omitempty"`
	Rid                      *string                   `json:"_rid,omitempty"`
	Ts                       *float64                  `json:"_ts,omitempty"`
	UniqueKeyPolicy          *UniqueKeyPolicy          `json:"uniqueKeyPolicy,omitempty"`
}

type SqlContainerGetResults ¶

type SqlContainerGetResults struct {
	Id         *string                    `json:"id,omitempty"`
	Location   *string                    `json:"location,omitempty"`
	Name       *string                    `json:"name,omitempty"`
	Properties *SqlContainerGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string         `json:"tags,omitempty"`
	Type       *string                    `json:"type,omitempty"`
}

type SqlContainerListResult ¶

type SqlContainerListResult struct {
	Value *[]SqlContainerGetResults `json:"value,omitempty"`
}

type SqlContainerResource ¶

type SqlContainerResource struct {
	AnalyticalStorageTtl     *int64                    `json:"analyticalStorageTtl,omitempty"`
	ConflictResolutionPolicy *ConflictResolutionPolicy `json:"conflictResolutionPolicy,omitempty"`
	DefaultTtl               *int64                    `json:"defaultTtl,omitempty"`
	Id                       string                    `json:"id"`
	IndexingPolicy           *IndexingPolicy           `json:"indexingPolicy,omitempty"`
	PartitionKey             *ContainerPartitionKey    `json:"partitionKey,omitempty"`
	UniqueKeyPolicy          *UniqueKeyPolicy          `json:"uniqueKeyPolicy,omitempty"`
}

type SqlDatabaseCreateUpdateParameters ¶

type SqlDatabaseCreateUpdateParameters struct {
	Id         *string                           `json:"id,omitempty"`
	Location   *string                           `json:"location,omitempty"`
	Name       *string                           `json:"name,omitempty"`
	Properties SqlDatabaseCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                `json:"tags,omitempty"`
	Type       *string                           `json:"type,omitempty"`
}

type SqlDatabaseCreateUpdateProperties ¶

type SqlDatabaseCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource SqlDatabaseResource  `json:"resource"`
}

type SqlDatabaseGetProperties ¶

type SqlDatabaseGetProperties struct {
	Options  *OptionsResource                  `json:"options,omitempty"`
	Resource *SqlDatabaseGetPropertiesResource `json:"resource,omitempty"`
}

type SqlDatabaseGetPropertiesResource ¶

type SqlDatabaseGetPropertiesResource struct {
	Colls *string  `json:"_colls,omitempty"`
	Etag  *string  `json:"_etag,omitempty"`
	Id    *string  `json:"id,omitempty"`
	Rid   *string  `json:"_rid,omitempty"`
	Ts    *float64 `json:"_ts,omitempty"`
	Users *string  `json:"_users,omitempty"`
}

type SqlDatabaseGetResults ¶

type SqlDatabaseGetResults struct {
	Id         *string                   `json:"id,omitempty"`
	Location   *string                   `json:"location,omitempty"`
	Name       *string                   `json:"name,omitempty"`
	Properties *SqlDatabaseGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string        `json:"tags,omitempty"`
	Type       *string                   `json:"type,omitempty"`
}

type SqlDatabaseId ¶

type SqlDatabaseId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	SqlDatabaseName     string
}

SqlDatabaseId is a struct representing the Resource ID for a Sql Database

func NewSqlDatabaseID ¶

func NewSqlDatabaseID(subscriptionId string, resourceGroupName string, databaseAccountName string, sqlDatabaseName string) SqlDatabaseId

NewSqlDatabaseID returns a new SqlDatabaseId struct

func ParseSqlDatabaseID ¶

func ParseSqlDatabaseID(input string) (*SqlDatabaseId, error)

ParseSqlDatabaseID parses 'input' into a SqlDatabaseId

func ParseSqlDatabaseIDInsensitively ¶

func ParseSqlDatabaseIDInsensitively(input string) (*SqlDatabaseId, error)

ParseSqlDatabaseIDInsensitively parses 'input' case-insensitively into a SqlDatabaseId note: this method should only be used for API response data and not user input

func (SqlDatabaseId) ID ¶

func (id SqlDatabaseId) ID() string

ID returns the formatted Sql Database ID

func (SqlDatabaseId) Segments ¶

func (id SqlDatabaseId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Sql Database ID

func (SqlDatabaseId) String ¶

func (id SqlDatabaseId) String() string

String returns a human-readable description of this Sql Database ID

type SqlDatabaseListResult ¶

type SqlDatabaseListResult struct {
	Value *[]SqlDatabaseGetResults `json:"value,omitempty"`
}

type SqlDatabaseResource ¶

type SqlDatabaseResource struct {
	Id string `json:"id"`
}

type SqlResourcesCreateUpdateSqlContainerOperationResponse ¶

type SqlResourcesCreateUpdateSqlContainerOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesCreateUpdateSqlDatabaseOperationResponse ¶

type SqlResourcesCreateUpdateSqlDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesCreateUpdateSqlStoredProcedureOperationResponse ¶

type SqlResourcesCreateUpdateSqlStoredProcedureOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesCreateUpdateSqlTriggerOperationResponse ¶

type SqlResourcesCreateUpdateSqlTriggerOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesCreateUpdateSqlUserDefinedFunctionOperationResponse ¶

type SqlResourcesCreateUpdateSqlUserDefinedFunctionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlContainerOperationResponse ¶

type SqlResourcesDeleteSqlContainerOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlDatabaseOperationResponse ¶

type SqlResourcesDeleteSqlDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlStoredProcedureOperationResponse ¶

type SqlResourcesDeleteSqlStoredProcedureOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlTriggerOperationResponse ¶

type SqlResourcesDeleteSqlTriggerOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlUserDefinedFunctionOperationResponse ¶

type SqlResourcesDeleteSqlUserDefinedFunctionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesGetSqlContainerOperationResponse ¶

type SqlResourcesGetSqlContainerOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlContainerGetResults
}

type SqlResourcesGetSqlContainerThroughputOperationResponse ¶

type SqlResourcesGetSqlContainerThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type SqlResourcesGetSqlDatabaseOperationResponse ¶

type SqlResourcesGetSqlDatabaseOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlDatabaseGetResults
}

type SqlResourcesGetSqlDatabaseThroughputOperationResponse ¶

type SqlResourcesGetSqlDatabaseThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type SqlResourcesGetSqlStoredProcedureOperationResponse ¶

type SqlResourcesGetSqlStoredProcedureOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlStoredProcedureGetResults
}

type SqlResourcesGetSqlTriggerOperationResponse ¶

type SqlResourcesGetSqlTriggerOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlTriggerGetResults
}

type SqlResourcesGetSqlUserDefinedFunctionOperationResponse ¶

type SqlResourcesGetSqlUserDefinedFunctionOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlUserDefinedFunctionGetResults
}

type SqlResourcesListSqlContainersOperationResponse ¶

type SqlResourcesListSqlContainersOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlContainerListResult
}

type SqlResourcesListSqlDatabasesOperationResponse ¶

type SqlResourcesListSqlDatabasesOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlDatabaseListResult
}

type SqlResourcesListSqlStoredProceduresOperationResponse ¶

type SqlResourcesListSqlStoredProceduresOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlStoredProcedureListResult
}

type SqlResourcesListSqlTriggersOperationResponse ¶

type SqlResourcesListSqlTriggersOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlTriggerListResult
}

type SqlResourcesListSqlUserDefinedFunctionsOperationResponse ¶

type SqlResourcesListSqlUserDefinedFunctionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlUserDefinedFunctionListResult
}

type SqlResourcesMigrateSqlContainerToAutoscaleOperationResponse ¶

type SqlResourcesMigrateSqlContainerToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesMigrateSqlContainerToManualThroughputOperationResponse ¶

type SqlResourcesMigrateSqlContainerToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesMigrateSqlDatabaseToAutoscaleOperationResponse ¶

type SqlResourcesMigrateSqlDatabaseToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesMigrateSqlDatabaseToManualThroughputOperationResponse ¶

type SqlResourcesMigrateSqlDatabaseToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesUpdateSqlContainerThroughputOperationResponse ¶

type SqlResourcesUpdateSqlContainerThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesUpdateSqlDatabaseThroughputOperationResponse ¶

type SqlResourcesUpdateSqlDatabaseThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlStoredProcedureCreateUpdateParameters ¶

type SqlStoredProcedureCreateUpdateParameters struct {
	Id         *string                                  `json:"id,omitempty"`
	Location   *string                                  `json:"location,omitempty"`
	Name       *string                                  `json:"name,omitempty"`
	Properties SqlStoredProcedureCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
	Type       *string                                  `json:"type,omitempty"`
}

type SqlStoredProcedureCreateUpdateProperties ¶

type SqlStoredProcedureCreateUpdateProperties struct {
	Options  *CreateUpdateOptions       `json:"options,omitempty"`
	Resource SqlStoredProcedureResource `json:"resource"`
}

type SqlStoredProcedureGetProperties ¶

type SqlStoredProcedureGetProperties struct {
	Resource *SqlStoredProcedureGetPropertiesResource `json:"resource,omitempty"`
}

type SqlStoredProcedureGetPropertiesResource ¶ added in v0.20230503.1140953

type SqlStoredProcedureGetPropertiesResource struct {
	Body *string  `json:"body,omitempty"`
	Etag *string  `json:"_etag,omitempty"`
	Id   *string  `json:"id,omitempty"`
	Rid  *string  `json:"_rid,omitempty"`
	Ts   *float64 `json:"_ts,omitempty"`
}

type SqlStoredProcedureGetResults ¶

type SqlStoredProcedureGetResults struct {
	Id         *string                          `json:"id,omitempty"`
	Location   *string                          `json:"location,omitempty"`
	Name       *string                          `json:"name,omitempty"`
	Properties *SqlStoredProcedureGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string               `json:"tags,omitempty"`
	Type       *string                          `json:"type,omitempty"`
}

type SqlStoredProcedureListResult ¶

type SqlStoredProcedureListResult struct {
	Value *[]SqlStoredProcedureGetResults `json:"value,omitempty"`
}

type SqlStoredProcedureResource ¶

type SqlStoredProcedureResource struct {
	Body *string `json:"body,omitempty"`
	Id   string  `json:"id"`
}

type SqlTriggerCreateUpdateParameters ¶

type SqlTriggerCreateUpdateParameters struct {
	Id         *string                          `json:"id,omitempty"`
	Location   *string                          `json:"location,omitempty"`
	Name       *string                          `json:"name,omitempty"`
	Properties SqlTriggerCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string               `json:"tags,omitempty"`
	Type       *string                          `json:"type,omitempty"`
}

type SqlTriggerCreateUpdateProperties ¶

type SqlTriggerCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource SqlTriggerResource   `json:"resource"`
}

type SqlTriggerGetProperties ¶

type SqlTriggerGetProperties struct {
	Resource *SqlTriggerGetPropertiesResource `json:"resource,omitempty"`
}

type SqlTriggerGetPropertiesResource ¶ added in v0.20230503.1140953

type SqlTriggerGetPropertiesResource struct {
	Body             *string           `json:"body,omitempty"`
	Etag             *string           `json:"_etag,omitempty"`
	Id               *string           `json:"id,omitempty"`
	Rid              *string           `json:"_rid,omitempty"`
	TriggerOperation *TriggerOperation `json:"triggerOperation,omitempty"`
	TriggerType      *TriggerType      `json:"triggerType,omitempty"`
	Ts               *float64          `json:"_ts,omitempty"`
}

type SqlTriggerGetResults ¶

type SqlTriggerGetResults struct {
	Id         *string                  `json:"id,omitempty"`
	Location   *string                  `json:"location,omitempty"`
	Name       *string                  `json:"name,omitempty"`
	Properties *SqlTriggerGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string       `json:"tags,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type SqlTriggerListResult ¶

type SqlTriggerListResult struct {
	Value *[]SqlTriggerGetResults `json:"value,omitempty"`
}

type SqlTriggerResource ¶

type SqlTriggerResource struct {
	Body             *string           `json:"body,omitempty"`
	Id               string            `json:"id"`
	TriggerOperation *TriggerOperation `json:"triggerOperation,omitempty"`
	TriggerType      *TriggerType      `json:"triggerType,omitempty"`
}

type SqlUserDefinedFunctionCreateUpdateParameters ¶

type SqlUserDefinedFunctionCreateUpdateParameters struct {
	Id         *string                                      `json:"id,omitempty"`
	Location   *string                                      `json:"location,omitempty"`
	Name       *string                                      `json:"name,omitempty"`
	Properties SqlUserDefinedFunctionCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                           `json:"tags,omitempty"`
	Type       *string                                      `json:"type,omitempty"`
}

type SqlUserDefinedFunctionCreateUpdateProperties ¶

type SqlUserDefinedFunctionCreateUpdateProperties struct {
	Options  *CreateUpdateOptions           `json:"options,omitempty"`
	Resource SqlUserDefinedFunctionResource `json:"resource"`
}

type SqlUserDefinedFunctionGetProperties ¶

type SqlUserDefinedFunctionGetProperties struct {
	Resource *SqlUserDefinedFunctionGetPropertiesResource `json:"resource,omitempty"`
}

type SqlUserDefinedFunctionGetPropertiesResource ¶ added in v0.20230503.1140953

type SqlUserDefinedFunctionGetPropertiesResource struct {
	Body *string  `json:"body,omitempty"`
	Etag *string  `json:"_etag,omitempty"`
	Id   *string  `json:"id,omitempty"`
	Rid  *string  `json:"_rid,omitempty"`
	Ts   *float64 `json:"_ts,omitempty"`
}

type SqlUserDefinedFunctionGetResults ¶

type SqlUserDefinedFunctionGetResults struct {
	Id         *string                              `json:"id,omitempty"`
	Location   *string                              `json:"location,omitempty"`
	Name       *string                              `json:"name,omitempty"`
	Properties *SqlUserDefinedFunctionGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string                   `json:"tags,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type SqlUserDefinedFunctionListResult ¶

type SqlUserDefinedFunctionListResult struct {
	Value *[]SqlUserDefinedFunctionGetResults `json:"value,omitempty"`
}

type SqlUserDefinedFunctionResource ¶

type SqlUserDefinedFunctionResource struct {
	Body *string `json:"body,omitempty"`
	Id   string  `json:"id"`
}

type StoredProcedureId ¶

type StoredProcedureId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	SqlDatabaseName     string
	ContainerName       string
	StoredProcedureName string
}

StoredProcedureId is a struct representing the Resource ID for a Stored Procedure

func NewStoredProcedureID ¶

func NewStoredProcedureID(subscriptionId string, resourceGroupName string, databaseAccountName string, sqlDatabaseName string, containerName string, storedProcedureName string) StoredProcedureId

NewStoredProcedureID returns a new StoredProcedureId struct

func ParseStoredProcedureID ¶

func ParseStoredProcedureID(input string) (*StoredProcedureId, error)

ParseStoredProcedureID parses 'input' into a StoredProcedureId

func ParseStoredProcedureIDInsensitively ¶

func ParseStoredProcedureIDInsensitively(input string) (*StoredProcedureId, error)

ParseStoredProcedureIDInsensitively parses 'input' case-insensitively into a StoredProcedureId note: this method should only be used for API response data and not user input

func (StoredProcedureId) ID ¶

func (id StoredProcedureId) ID() string

ID returns the formatted Stored Procedure ID

func (StoredProcedureId) Segments ¶

func (id StoredProcedureId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Stored Procedure ID

func (StoredProcedureId) String ¶

func (id StoredProcedureId) String() string

String returns a human-readable description of this Stored Procedure ID

type TableCreateUpdateParameters ¶

type TableCreateUpdateParameters struct {
	Id         *string                     `json:"id,omitempty"`
	Location   *string                     `json:"location,omitempty"`
	Name       *string                     `json:"name,omitempty"`
	Properties TableCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string          `json:"tags,omitempty"`
	Type       *string                     `json:"type,omitempty"`
}

type TableCreateUpdateProperties ¶

type TableCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource TableResource        `json:"resource"`
}

type TableGetProperties ¶

type TableGetProperties struct {
	Options  *OptionsResource            `json:"options,omitempty"`
	Resource *TableGetPropertiesResource `json:"resource,omitempty"`
}

type TableGetPropertiesResource ¶ added in v0.20230503.1140953

type TableGetPropertiesResource struct {
	Etag *string  `json:"_etag,omitempty"`
	Id   *string  `json:"id,omitempty"`
	Rid  *string  `json:"_rid,omitempty"`
	Ts   *float64 `json:"_ts,omitempty"`
}

type TableGetResults ¶

type TableGetResults struct {
	Id         *string             `json:"id,omitempty"`
	Location   *string             `json:"location,omitempty"`
	Name       *string             `json:"name,omitempty"`
	Properties *TableGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string  `json:"tags,omitempty"`
	Type       *string             `json:"type,omitempty"`
}

type TableId ¶

type TableId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	TableName           string
}

TableId is a struct representing the Resource ID for a Table

func NewTableID ¶

func NewTableID(subscriptionId string, resourceGroupName string, databaseAccountName string, tableName string) TableId

NewTableID returns a new TableId struct

func ParseTableID ¶

func ParseTableID(input string) (*TableId, error)

ParseTableID parses 'input' into a TableId

func ParseTableIDInsensitively ¶

func ParseTableIDInsensitively(input string) (*TableId, error)

ParseTableIDInsensitively parses 'input' case-insensitively into a TableId note: this method should only be used for API response data and not user input

func (TableId) ID ¶

func (id TableId) ID() string

ID returns the formatted Table ID

func (TableId) Segments ¶

func (id TableId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Table ID

func (TableId) String ¶

func (id TableId) String() string

String returns a human-readable description of this Table ID

type TableListResult ¶

type TableListResult struct {
	Value *[]TableGetResults `json:"value,omitempty"`
}

type TableResource ¶

type TableResource struct {
	Id string `json:"id"`
}

type TableResourcesCreateUpdateTableOperationResponse ¶

type TableResourcesCreateUpdateTableOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TableResourcesDeleteTableOperationResponse ¶

type TableResourcesDeleteTableOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TableResourcesGetTableOperationResponse ¶

type TableResourcesGetTableOperationResponse struct {
	HttpResponse *http.Response
	Model        *TableGetResults
}

type TableResourcesGetTableThroughputOperationResponse ¶

type TableResourcesGetTableThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type TableResourcesListTablesOperationResponse ¶

type TableResourcesListTablesOperationResponse struct {
	HttpResponse *http.Response
	Model        *TableListResult
}

type TableResourcesMigrateTableToAutoscaleOperationResponse ¶

type TableResourcesMigrateTableToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TableResourcesMigrateTableToManualThroughputOperationResponse ¶

type TableResourcesMigrateTableToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TableResourcesUpdateTableThroughputOperationResponse ¶

type TableResourcesUpdateTableThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TargetRegionId ¶

type TargetRegionId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	TargetRegionName    string
}

TargetRegionId is a struct representing the Resource ID for a Target Region

func NewTargetRegionID ¶

func NewTargetRegionID(subscriptionId string, resourceGroupName string, databaseAccountName string, targetRegionName string) TargetRegionId

NewTargetRegionID returns a new TargetRegionId struct

func ParseTargetRegionID ¶

func ParseTargetRegionID(input string) (*TargetRegionId, error)

ParseTargetRegionID parses 'input' into a TargetRegionId

func ParseTargetRegionIDInsensitively ¶

func ParseTargetRegionIDInsensitively(input string) (*TargetRegionId, error)

ParseTargetRegionIDInsensitively parses 'input' case-insensitively into a TargetRegionId note: this method should only be used for API response data and not user input

func (TargetRegionId) ID ¶

func (id TargetRegionId) ID() string

ID returns the formatted Target Region ID

func (TargetRegionId) Segments ¶

func (id TargetRegionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Target Region ID

func (TargetRegionId) String ¶

func (id TargetRegionId) String() string

String returns a human-readable description of this Target Region ID

type ThroughputPolicyResource ¶

type ThroughputPolicyResource struct {
	IncrementPercent *int64 `json:"incrementPercent,omitempty"`
	IsEnabled        *bool  `json:"isEnabled,omitempty"`
}

type ThroughputSettingsGetProperties ¶

type ThroughputSettingsGetProperties struct {
	Resource *ThroughputSettingsGetPropertiesResource `json:"resource,omitempty"`
}

type ThroughputSettingsGetPropertiesResource ¶ added in v0.20230503.1140953

type ThroughputSettingsGetPropertiesResource struct {
	AutoScaleSettings   *AutoscaleSettingsResource `json:"autoscaleSettings,omitempty"`
	Etag                *string                    `json:"_etag,omitempty"`
	MinimumThroughput   *string                    `json:"minimumThroughput,omitempty"`
	OfferReplacePending *string                    `json:"offerReplacePending,omitempty"`
	Rid                 *string                    `json:"_rid,omitempty"`
	Throughput          *int64                     `json:"throughput,omitempty"`
	Ts                  *float64                   `json:"_ts,omitempty"`
}

type ThroughputSettingsGetResults ¶

type ThroughputSettingsGetResults struct {
	Id         *string                          `json:"id,omitempty"`
	Location   *string                          `json:"location,omitempty"`
	Name       *string                          `json:"name,omitempty"`
	Properties *ThroughputSettingsGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string               `json:"tags,omitempty"`
	Type       *string                          `json:"type,omitempty"`
}

type ThroughputSettingsResource ¶

type ThroughputSettingsResource struct {
	AutoScaleSettings   *AutoscaleSettingsResource `json:"autoscaleSettings,omitempty"`
	MinimumThroughput   *string                    `json:"minimumThroughput,omitempty"`
	OfferReplacePending *string                    `json:"offerReplacePending,omitempty"`
	Throughput          *int64                     `json:"throughput,omitempty"`
}

type ThroughputSettingsUpdateParameters ¶

type ThroughputSettingsUpdateParameters struct {
	Id         *string                            `json:"id,omitempty"`
	Location   *string                            `json:"location,omitempty"`
	Name       *string                            `json:"name,omitempty"`
	Properties ThroughputSettingsUpdateProperties `json:"properties"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Type       *string                            `json:"type,omitempty"`
}

type ThroughputSettingsUpdateProperties ¶

type ThroughputSettingsUpdateProperties struct {
	Resource ThroughputSettingsResource `json:"resource"`
}

type TriggerId ¶

type TriggerId struct {
	SubscriptionId      string
	ResourceGroupName   string
	DatabaseAccountName string
	SqlDatabaseName     string
	ContainerName       string
	TriggerName         string
}

TriggerId is a struct representing the Resource ID for a Trigger

func NewTriggerID ¶

func NewTriggerID(subscriptionId string, resourceGroupName string, databaseAccountName string, sqlDatabaseName string, containerName string, triggerName string) TriggerId

NewTriggerID returns a new TriggerId struct

func ParseTriggerID ¶

func ParseTriggerID(input string) (*TriggerId, error)

ParseTriggerID parses 'input' into a TriggerId

func ParseTriggerIDInsensitively ¶

func ParseTriggerIDInsensitively(input string) (*TriggerId, error)

ParseTriggerIDInsensitively parses 'input' case-insensitively into a TriggerId note: this method should only be used for API response data and not user input

func (TriggerId) ID ¶

func (id TriggerId) ID() string

ID returns the formatted Trigger ID

func (TriggerId) Segments ¶

func (id TriggerId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Trigger ID

func (TriggerId) String ¶

func (id TriggerId) String() string

String returns a human-readable description of this Trigger ID

type TriggerOperation ¶

type TriggerOperation string
const (
	TriggerOperationAll     TriggerOperation = "All"
	TriggerOperationCreate  TriggerOperation = "Create"
	TriggerOperationDelete  TriggerOperation = "Delete"
	TriggerOperationReplace TriggerOperation = "Replace"
	TriggerOperationUpdate  TriggerOperation = "Update"
)

type TriggerType ¶

type TriggerType string
const (
	TriggerTypePost TriggerType = "Post"
	TriggerTypePre  TriggerType = "Pre"
)

type UniqueKey ¶

type UniqueKey struct {
	Paths *[]string `json:"paths,omitempty"`
}

type UniqueKeyPolicy ¶

type UniqueKeyPolicy struct {
	UniqueKeys *[]UniqueKey `json:"uniqueKeys,omitempty"`
}

type UnitType ¶

type UnitType string
const (
	UnitTypeBytes          UnitType = "Bytes"
	UnitTypeBytesPerSecond UnitType = "BytesPerSecond"
	UnitTypeCount          UnitType = "Count"
	UnitTypeCountPerSecond UnitType = "CountPerSecond"
	UnitTypeMilliseconds   UnitType = "Milliseconds"
	UnitTypePercent        UnitType = "Percent"
	UnitTypeSeconds        UnitType = "Seconds"
)

type Usage ¶

type Usage struct {
	CurrentValue *int64      `json:"currentValue,omitempty"`
	Limit        *int64      `json:"limit,omitempty"`
	Name         *MetricName `json:"name,omitempty"`
	QuotaPeriod  *string     `json:"quotaPeriod,omitempty"`
	Unit         *UnitType   `json:"unit,omitempty"`
}

type UsagesResult ¶

type UsagesResult struct {
	Value *[]Usage `json:"value,omitempty"`
}

type UserDefinedFunctionId ¶

type UserDefinedFunctionId struct {
	SubscriptionId          string
	ResourceGroupName       string
	DatabaseAccountName     string
	SqlDatabaseName         string
	ContainerName           string
	UserDefinedFunctionName string
}

UserDefinedFunctionId is a struct representing the Resource ID for a User Defined Function

func NewUserDefinedFunctionID ¶

func NewUserDefinedFunctionID(subscriptionId string, resourceGroupName string, databaseAccountName string, sqlDatabaseName string, containerName string, userDefinedFunctionName string) UserDefinedFunctionId

NewUserDefinedFunctionID returns a new UserDefinedFunctionId struct

func ParseUserDefinedFunctionID ¶

func ParseUserDefinedFunctionID(input string) (*UserDefinedFunctionId, error)

ParseUserDefinedFunctionID parses 'input' into a UserDefinedFunctionId

func ParseUserDefinedFunctionIDInsensitively ¶

func ParseUserDefinedFunctionIDInsensitively(input string) (*UserDefinedFunctionId, error)

ParseUserDefinedFunctionIDInsensitively parses 'input' case-insensitively into a UserDefinedFunctionId note: this method should only be used for API response data and not user input

func (UserDefinedFunctionId) ID ¶

func (id UserDefinedFunctionId) ID() string

ID returns the formatted User Defined Function ID

func (UserDefinedFunctionId) Segments ¶

func (id UserDefinedFunctionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this User Defined Function ID

func (UserDefinedFunctionId) String ¶

func (id UserDefinedFunctionId) String() string

String returns a human-readable description of this User Defined Function ID

type VirtualNetworkRule ¶

type VirtualNetworkRule struct {
	Id                               *string `json:"id,omitempty"`
	IgnoreMissingVNetServiceEndpoint *bool   `json:"ignoreMissingVNetServiceEndpoint,omitempty"`
}

Source Files ¶

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL