你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站,请访问 https://docs.azure.cn

CosmosAsyncDatabase 类

  • java.lang.Object
    • com.azure.cosmos.CosmosAsyncDatabase

public class CosmosAsyncDatabase

执行读取和删除数据库、更新数据库吞吐量,以及对子资源执行操作

方法摘要

修饰符和类型 方法和描述
Mono<CosmosClientEncryptionKeyResponse> createClientEncryptionKey(CosmosClientEncryptionKeyProperties keyProperties)

在订阅后创建客户端加密密钥,该操作将执行。

Mono<CosmosContainerResponse> createContainer(CosmosContainerProperties containerProperties)

创建 Cosmos 容器。

Mono<CosmosContainerResponse> createContainer(CosmosContainerProperties containerProperties, CosmosContainerRequestOptions options)

创建 Cosmos 容器。

Mono<CosmosContainerResponse> createContainer(CosmosContainerProperties containerProperties, ThroughputProperties throughputProperties)

使用自定义吞吐量属性创建 Cosmos 容器。

Mono<CosmosContainerResponse> createContainer(CosmosContainerProperties containerProperties, ThroughputProperties throughputProperties, CosmosContainerRequestOptions options)

创建容器。

Mono<CosmosContainerResponse> createContainer(String id, String partitionKeyPath)

创建 Cosmos 容器。

Mono<CosmosContainerResponse> createContainer(String id, String partitionKeyPath, ThroughputProperties throughputProperties)

创建 Cosmos 容器。

Mono<CosmosContainerResponse> createContainerIfNotExists(CosmosContainerProperties containerProperties)

如果服务中不存在 Cosmos 容器,则创建该容器。

Mono<CosmosContainerResponse> createContainerIfNotExists(CosmosContainerProperties containerProperties, ThroughputProperties throughputProperties)

如果服务中不存在 Cosmos 容器,则创建该容器。

Mono<CosmosContainerResponse> createContainerIfNotExists(String id, String partitionKeyPath)

如果服务中不存在 Cosmos 容器,则创建该容器。

Mono<CosmosContainerResponse> createContainerIfNotExists(String id, String partitionKeyPath, ThroughputProperties throughputProperties)

如果服务中不存在 Cosmos 容器,则创建该容器。

Mono<CosmosUserResponse> createUser(CosmosUserProperties userProperties)

创建用户 订阅后将执行操作。

Mono<CosmosDatabaseResponse> delete()

删除当前 Cosmos 数据库。

Mono<CosmosDatabaseResponse> delete(CosmosDatabaseRequestOptions options)

删除当前 Cosmos 数据库,同时指定其他请求选项。

CosmosAsyncClientEncryptionKey getClientEncryptionKey(String id)

在不调用服务的情况下获取 Cosmos异步客户端加密密钥对象

CosmosAsyncContainer getContainer(String id)

在不调用服务的情况下获取 Cosmos异步容器对象

String getId()

获取 Cosmos异步数据库的 ID。

CosmosAsyncUser getUser(String id)

获取用户。

CosmosPagedFlux<CosmosClientEncryptionKeyProperties> queryClientEncryptionKeys(SqlQuerySpec querySpec)

查询数据库中的 cosmos 客户端加密密钥。

CosmosPagedFlux<CosmosClientEncryptionKeyProperties> queryClientEncryptionKeys(SqlQuerySpec querySpec, CosmosQueryRequestOptions options)

查询数据库中的 cosmos 客户端加密密钥。

CosmosPagedFlux<CosmosClientEncryptionKeyProperties> queryClientEncryptionKeys(String query)

查询数据库中的 cosmos 客户端加密密钥。

CosmosPagedFlux<CosmosClientEncryptionKeyProperties> queryClientEncryptionKeys(String query, CosmosQueryRequestOptions options)

查询数据库中的 cosmos 客户端加密密钥。

CosmosPagedFlux<CosmosContainerProperties> queryContainers(SqlQuerySpec querySpec)

查询 cosmos 数据库中的 cosmos 容器。

CosmosPagedFlux<CosmosContainerProperties> queryContainers(SqlQuerySpec querySpec, CosmosQueryRequestOptions options)

查询 cosmos 数据库中的 cosmos 容器。

CosmosPagedFlux<CosmosContainerProperties> queryContainers(String query)

查询 cosmos 数据库中的 cosmos 容器。

CosmosPagedFlux<CosmosContainerProperties> queryContainers(String query, CosmosQueryRequestOptions options)

查询 cosmos 数据库中的 cosmos 容器。

CosmosPagedFlux<CosmosUserProperties> queryUsers(SqlQuerySpec querySpec)

查询数据库中的 cosmos 用户。

CosmosPagedFlux<CosmosUserProperties> queryUsers(SqlQuerySpec querySpec, CosmosQueryRequestOptions options)

查询数据库中的 cosmos 用户。

CosmosPagedFlux<CosmosUserProperties> queryUsers(String query)

查询数据库中的 cosmos 用户。

CosmosPagedFlux<CosmosUserProperties> queryUsers(String query, CosmosQueryRequestOptions options)

查询数据库中的 cosmos 用户。

Mono<CosmosDatabaseResponse> read()

读取数据库。

Mono<CosmosDatabaseResponse> read(CosmosDatabaseRequestOptions options)

读取数据库。

CosmosPagedFlux<CosmosClientEncryptionKeyProperties> readAllClientEncryptionKeys()

读取数据库中的所有 cosmos 客户端加密密钥。

CosmosPagedFlux<CosmosClientEncryptionKeyProperties> readAllClientEncryptionKeys(CosmosQueryRequestOptions options)

读取数据库中的所有 cosmos 客户端加密密钥。

CosmosPagedFlux<CosmosContainerProperties> readAllContainers()

读取所有 cosmos 容器。

CosmosPagedFlux<CosmosContainerProperties> readAllContainers(CosmosQueryRequestOptions options)

读取所有 cosmos 容器。

CosmosPagedFlux<CosmosUserProperties> readAllUsers()

读取数据库中的所有 cosmos 用户。

Mono<ThroughputResponse> readThroughput()

获取数据库的吞吐量。

Mono<ThroughputResponse> replaceThroughput(ThroughputProperties throughputProperties)

设置为容器预配的吞吐量,以度量 Azure Cosmos 服务中每单位的请求数。

Mono<CosmosUserResponse> upsertUser(CosmosUserProperties userProperties)

更新插入用户。

方法继承自 java.lang.Object

方法详细信息

createClientEncryptionKey

public Mono createClientEncryptionKey(CosmosClientEncryptionKeyProperties keyProperties)

在订阅后创建客户端加密密钥,该操作将执行。 成功完成后, Mono 将包含单个资源响应,其中包含创建的客户端加密密钥。 如果失败, Mono 将出错。

参数:

keyProperties - cosmos 客户端加密密钥属性

返回:

一个 , Mono 包含单个资源响应,其中包含创建的 cosmos 客户端加密密钥或错误。

createContainer

public Mono createContainer(CosmosContainerProperties containerProperties)

创建 Cosmos 容器。

CosmosContainerProperties containerProperties =
     new CosmosContainerProperties(containerId, partitionKeyDefinition);
 cosmosAsyncDatabase.createContainer(containerProperties)
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

订阅后将执行该操作。 成功完成后, Mono 将包含具有所创建容器的 cosmos 容器响应。 如果失败, Mono 将出错。

参数:

containerProperties - 容器属性。

返回:

一个 , Mono 其中包含单个 cosmos 容器响应,其中包含已创建的容器或错误。

createContainer

public Mono createContainer(CosmosContainerProperties containerProperties, CosmosContainerRequestOptions options)

创建 Cosmos 容器。

CosmosContainerProperties containerProperties =
     new CosmosContainerProperties(containerId, partitionKeyDefinition);
 cosmosAsyncDatabase.createContainer(containerProperties)
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

订阅后将执行该操作。 成功完成后, Mono 将包含具有所创建容器的 cosmos 容器响应。 如果失败,将 Mono 出错。

参数:

containerProperties - containerProperties。
options - cosmos 容器请求选项。

返回:

一个包含 Mono 创建容器或错误的 cosmos 容器响应的 。

createContainer

public Mono createContainer(CosmosContainerProperties containerProperties, ThroughputProperties throughputProperties)

使用自定义吞吐量属性创建 Cosmos 容器。

CosmosContainerProperties containerProperties =
     new CosmosContainerProperties(containerId, partitionKeyDefinition);
 ThroughputProperties throughputProperties =
     ThroughputProperties.createAutoscaledThroughput(autoScaleMaxThroughput);
 cosmosAsyncDatabase.createContainer(containerProperties, throughputProperties)
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

订阅后,将执行该操作。 成功完成时, Mono 将包含具有所创建容器的 cosmos 容器响应。 如果失败,将 Mono 出错。

参数:

containerProperties - 容器属性。
throughputProperties - 容器的吞吐量属性。

返回:

Mono 包含单个 cosmos 容器响应,其中包含创建的容器或错误。

createContainer

public Mono createContainer(CosmosContainerProperties containerProperties, ThroughputProperties throughputProperties, CosmosContainerRequestOptions options)

创建容器。

CosmosContainerProperties containerProperties =
     new CosmosContainerProperties(containerId, partitionKeyDefinition);

 cosmosAsyncDatabase.createContainer(
         containerProperties,
         throughput,
         options
     )
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

参数:

containerProperties - 容器属性。
throughputProperties - 吞吐量属性。
options - 请求选项。

返回:

单声道。

createContainer

public Mono createContainer(String id, String partitionKeyPath)

创建 Cosmos 容器。

ThroughputProperties throughputProperties =
     ThroughputProperties.createAutoscaledThroughput(autoscaledThroughput);
 cosmosAsyncDatabase.createContainer(
         containerId,
         partitionKeyPath,
         throughputProperties
     )
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

订阅后,将执行该操作。 成功完成时, Mono 将包含具有所创建容器的 cosmos 容器响应。 如果失败,将 Mono 出错。

参数:

id - cosmos 容器 ID。
partitionKeyPath - 分区键路径。

返回:

一个包含 Mono 创建容器或错误的 cosmos 容器响应的 。

createContainer

public Mono createContainer(String id, String partitionKeyPath, ThroughputProperties throughputProperties)

创建 Cosmos 容器。

ThroughputProperties throughputProperties =
     ThroughputProperties.createAutoscaledThroughput(autoscaledThroughput);
 cosmosAsyncDatabase.createContainer(
         containerId,
         partitionKeyPath,
         throughputProperties
     )
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

订阅后,将执行该操作。 成功完成时, Mono 将包含具有所创建容器的 cosmos 容器响应。 如果失败,将 Mono 出错。

参数:

id - cosmos 容器 ID。
partitionKeyPath - 分区键路径。
throughputProperties - 容器的吞吐量属性。

返回:

一个包含 Mono 创建容器或错误的 cosmos 容器响应的 。

createContainerIfNotExists

public Mono createContainerIfNotExists(CosmosContainerProperties containerProperties)

如果服务中不存在 Cosmos 容器,则创建该容器。

CosmosContainerProperties containerProperties =
     new CosmosContainerProperties(containerId, partitionKeyDefinition);
 cosmosAsyncDatabase.createContainerIfNotExists(containerProperties)
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

订阅后,将执行该操作。 成功完成后, Mono 将包含具有创建或现有容器的 cosmos 容器响应。 如果失败,将 Mono 出错。

参数:

containerProperties - 容器属性

返回:

Mono 包含包含创建或现有容器或错误的 cosmos 容器响应。

createContainerIfNotExists

public Mono createContainerIfNotExists(CosmosContainerProperties containerProperties, ThroughputProperties throughputProperties)

如果服务中不存在 Cosmos 容器,则创建该容器。

CosmosContainerProperties containerProperties =
     new CosmosContainerProperties(containerId, partitionKeyDefinition);
 cosmosAsyncDatabase.createContainerIfNotExists(containerProperties, throughputProperties)
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

仅当指定的容器不存在并且将创建新容器时,才会使用吞吐量属性。

订阅后,将执行该操作。 成功完成后, Mono 将包含具有创建或现有容器的 cosmos 容器响应。 如果失败,将 Mono 出错。

参数:

containerProperties - 容器属性。
throughputProperties - 容器的吞吐量属性。

返回:

Mono 包含包含创建或现有容器或错误的 cosmos 容器响应。

createContainerIfNotExists

public Mono createContainerIfNotExists(String id, String partitionKeyPath)

如果服务中不存在 Cosmos 容器,则创建该容器。

CosmosContainerProperties containerProperties =
     new CosmosContainerProperties(containerId, partitionKeyDefinition);
 cosmosAsyncDatabase.createContainerIfNotExists(containerProperties)
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

订阅后,将执行该操作。 成功完成时, Mono 将包含具有所创建容器的 cosmos 容器响应。 如果失败,将 Mono 出错。

参数:

id - cosmos 容器 ID。
partitionKeyPath - 分区键路径。

返回:

一个包含 Mono 创建容器或错误的 cosmos 容器响应的 。

createContainerIfNotExists

public Mono createContainerIfNotExists(String id, String partitionKeyPath, ThroughputProperties throughputProperties)

如果服务中不存在 Cosmos 容器,则创建该容器。

CosmosContainerProperties containerProperties =
     new CosmosContainerProperties(containerId, partitionKeyDefinition);
 cosmosAsyncDatabase.createContainerIfNotExists(containerProperties, throughputProperties)
     .subscribe(
         cosmosContainerResponse -> System.out.println(cosmosContainerResponse),
         throwable -> System.out.println("Failed to create container: " + throwable)
     );

仅当指定的容器不存在并且将创建新容器时,才会使用吞吐量属性。

订阅后,将执行该操作。 成功完成时, Mono 将包含具有所创建容器的 cosmos 容器响应。 如果失败,将 Mono 出错。

参数:

id - cosmos 容器 ID。
partitionKeyPath - 分区键路径。
throughputProperties - 容器的吞吐量属性。

返回:

一个包含 Mono 创建容器或错误的 cosmos 容器响应的 。

createUser

public Mono createUser(CosmosUserProperties userProperties)

创建用户 订阅后将执行操作。 成功完成后, Mono 将包含创建用户的单个资源响应。 如果失败,将 Mono 出错。

String userId = "userId";
 CosmosUserProperties userProperties = new CosmosUserProperties();
 userProperties.setId(userId);
 cosmosAsyncDatabase.createUser(userProperties)
     .subscribe(
         userResponse -> System.out.println(userResponse),
         throwable -> System.out.println("Failed to create user: " + throwable)
     );

参数:

userProperties - cosmos 用户属性

返回:

Mono 包含单个资源响应,其中包含创建的 cosmos 用户或错误。

delete

public Mono delete()

删除当前 Cosmos 数据库。

CosmosAsyncDatabase database = cosmosAsyncClient
     .getDatabase("<YOUR DATABASE NAME>");
 database.delete().subscribe(databaseResponse -> {
         System.out.println(databaseResponse);
     },
     throwable -> {
         throwable.printStackTrace();
     });

订阅后,将执行该操作。 成功完成后, Mono 将包含包含已删除数据库的 cosmos 数据库响应。 如果失败,将 Mono 出错。

返回:

包含 Mono 单个 cosmos 数据库响应的 。

delete

public Mono delete(CosmosDatabaseRequestOptions options)

删除当前 Cosmos 数据库,同时指定其他请求选项。

CosmosAsyncDatabase database = cosmosAsyncClient
     .getDatabase("<YOUR DATABASE NAME>");
 database.delete().subscribe(databaseResponse -> {
         System.out.println(databaseResponse);
     },
     throwable -> {
         throwable.printStackTrace();
     });

订阅后,将执行该操作。 成功完成后, Mono 将包含包含已删除数据库的 cosmos 数据库响应。 如果失败,将 Mono 出错。

参数:

options - 请求选项。

返回:

包含 Mono 单个 cosmos 数据库响应的 。

getClientEncryptionKey

public CosmosAsyncClientEncryptionKey getClientEncryptionKey(String id)

在不进行服务调用的情况下获取 CosmosAsyncClientEncryptionKey 对象

参数:

id - clientEncryptionKey 的 ID

返回:

Cosmos ClientEncryptionKey

getContainer

public CosmosAsyncContainer getContainer(String id)

在不调用服务的情况下获取 CosmosAsyncContainer 对象

参数:

id - 容器的 ID

返回:

Cosmos 容器

getId

public String getId()

获取 CosmosAsyncDatabase 的 ID。

返回:

CosmosAsyncDatabase 的 ID。

getUser

public CosmosAsyncUser getUser(String id)

获取用户。

参数:

id - id

返回:

用户

queryClientEncryptionKeys

public CosmosPagedFlux queryClientEncryptionKeys(SqlQuerySpec querySpec)

查询数据库中的 cosmos 客户端加密密钥。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含获取的客户端加密密钥的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

querySpec - SQL 查询规范。

返回:

包含 CosmosPagedFlux<T> 获取的客户端加密密钥或错误的一个或多个源响应页。

queryClientEncryptionKeys

public CosmosPagedFlux queryClientEncryptionKeys(SqlQuerySpec querySpec, CosmosQueryRequestOptions options)

查询数据库中的 cosmos 客户端加密密钥。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含获取的客户端加密密钥的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

querySpec - SQL 查询规范。
options - 查询请求选项。

返回:

包含 CosmosPagedFlux<T> 获取的客户端加密密钥或错误的一个或多个源响应页。

queryClientEncryptionKeys

public CosmosPagedFlux queryClientEncryptionKeys(String query)

查询数据库中的 cosmos 客户端加密密钥。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含获取的客户端加密密钥的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

query - 查询为字符串。

返回:

包含 CosmosPagedFlux<T> 获取的客户端加密密钥或错误的一个或多个源响应页。

queryClientEncryptionKeys

public CosmosPagedFlux queryClientEncryptionKeys(String query, CosmosQueryRequestOptions options)

查询数据库中的 cosmos 客户端加密密钥。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含获取的客户端加密密钥的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

query - 查询为字符串。
options - 查询请求选项。

返回:

包含 CosmosPagedFlux<T> 获取的客户端加密密钥或错误的一个或多个源响应页。

queryContainers

public CosmosPagedFlux queryContainers(SqlQuerySpec querySpec)

查询 cosmos 数据库中的 cosmos 容器。

cosmosAsyncDatabase.queryContainers("SELECT * FROM DB_NAME")
     .byPage()
     .flatMap(containerPropertiesFeedResponse -> {
         for (CosmosContainerProperties properties : containerPropertiesFeedResponse.getResults()) {
             System.out.println(properties);
         }
         return Flux.empty();
     })
     .subscribe();

订阅后将执行该操作。 CosmosPagedFlux<T>将包含所获取容器的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

querySpec - SQL 查询规范。

返回:

包含 CosmosPagedFlux<T> 所获取容器的一个或多个源响应页或错误。

queryContainers

public CosmosPagedFlux queryContainers(SqlQuerySpec querySpec, CosmosQueryRequestOptions options)

查询 cosmos 数据库中的 cosmos 容器。

cosmosAsyncDatabase.queryContainers("SELECT * FROM DB_NAME")
     .byPage()
     .flatMap(containerPropertiesFeedResponse -> {
         for (CosmosContainerProperties properties : containerPropertiesFeedResponse.getResults()) {
             System.out.println(properties);
         }
         return Flux.empty();
     })
     .subscribe();

订阅后将执行该操作。 CosmosPagedFlux<T>将包含所获取容器的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

querySpec - SQL 查询规范。
options - 查询请求选项。

返回:

包含 CosmosPagedFlux<T> 所获取容器的一个或多个源响应页或错误。

queryContainers

public CosmosPagedFlux queryContainers(String query)

查询 cosmos 数据库中的 cosmos 容器。

cosmosAsyncDatabase.queryContainers("SELECT * FROM DB_NAME")
     .byPage()
     .flatMap(containerPropertiesFeedResponse -> {
         for (CosmosContainerProperties properties : containerPropertiesFeedResponse.getResults()) {
             System.out.println(properties);
         }
         return Flux.empty();
     })
     .subscribe();

订阅后将执行该操作。 CosmosPagedFlux<T>将包含所获取容器的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

query - 查询。

返回:

包含 CosmosPagedFlux<T> 所获取容器的一个或多个源响应页或错误。

queryContainers

public CosmosPagedFlux queryContainers(String query, CosmosQueryRequestOptions options)

查询 cosmos 数据库中的 cosmos 容器。

cosmosAsyncDatabase.queryContainers("SELECT * FROM DB_NAME")
     .byPage()
     .flatMap(containerPropertiesFeedResponse -> {
         for (CosmosContainerProperties properties : containerPropertiesFeedResponse.getResults()) {
             System.out.println(properties);
         }
         return Flux.empty();
     })
     .subscribe();

订阅后将执行该操作。 CosmosPagedFlux<T>将包含所获取容器的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

query - 查询。
options - 查询请求选项。

返回:

包含 CosmosPagedFlux<T> 所获取容器的一个或多个源响应页或错误。

queryUsers

public CosmosPagedFlux queryUsers(SqlQuerySpec querySpec)

查询数据库中的 cosmos 用户。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含已获取用户的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

querySpec - SQL 查询规范。

返回:

包含 CosmosPagedFlux<T> 已获取用户的一个或多个源响应页或错误。

queryUsers

public CosmosPagedFlux queryUsers(SqlQuerySpec querySpec, CosmosQueryRequestOptions options)

查询数据库中的 cosmos 用户。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含已获取用户的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

querySpec - SQL 查询规范。
options - 查询请求选项。

返回:

包含 CosmosPagedFlux<T> 已获取用户的一个或多个源响应页或错误。

queryUsers

public CosmosPagedFlux queryUsers(String query)

查询数据库中的 cosmos 用户。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含已获取用户的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

query - 查询为字符串。

返回:

包含 CosmosPagedFlux<T> 已获取用户的一个或多个源响应页或错误。

queryUsers

public CosmosPagedFlux queryUsers(String query, CosmosQueryRequestOptions options)

查询数据库中的 cosmos 用户。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含已获取用户的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

query - 查询为字符串。
options - 查询请求选项。

返回:

包含 CosmosPagedFlux<T> 已获取用户的一个或多个源响应页或错误。

read

public Mono read()

读取数据库。 根据数据库的唯一标识符提取数据库的详细信息和属性。

CosmosAsyncDatabase database = cosmosAsyncClient
     .getDatabase("<YOUR DATABASE NAME>");
 database.read().subscribe(databaseResponse -> {
         System.out.println(databaseResponse);
     },
     throwable -> {
         throwable.printStackTrace();
     });

订阅后将执行该操作。 Mono成功完成时的 将包含单个 cosmos 数据库响应和读取数据库。 如果失败, Mono 将出错。

返回:

包含 Mono 单个 cosmos 数据库 respone 的 ,其中包含读取数据库或错误。

read

public Mono read(CosmosDatabaseRequestOptions options)

读取数据库。 根据数据库的唯一标识符提取数据库的详细信息和属性。

CosmosAsyncDatabase database = cosmosAsyncClient
     .getDatabase("<YOUR DATABASE NAME>");
 database.read().subscribe(databaseResponse -> {
         System.out.println(databaseResponse);
     },
     throwable -> {
         throwable.printStackTrace();
     });

订阅后将执行该操作。 成功完成时, Mono 将包含具有读取数据库的 cosmos 数据库响应。 如果失败, Mono 将出错。

参数:

options - 请求选项。

返回:

一个 , Mono 包含单个 cosmos 数据库响应,其中包含读取数据库或错误。

readAllClientEncryptionKeys

public CosmosPagedFlux readAllClientEncryptionKeys()

读取数据库中的所有 cosmos 客户端加密密钥。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含读取 cosmos 客户端加密密钥的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

返回:

包含 CosmosPagedFlux<T> 读取 cosmos 客户端加密密钥或错误的一个或多个源响应页的 。

readAllClientEncryptionKeys

public CosmosPagedFlux readAllClientEncryptionKeys(CosmosQueryRequestOptions options)

读取数据库中的所有 cosmos 客户端加密密钥。

订阅后将执行该操作。 CosmosPagedFlux<T>将包含读取 cosmos 客户端加密密钥的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

options - 查询请求选项。

返回:

包含 CosmosPagedFlux<T> 读取 cosmos 客户端加密密钥或错误的一个或多个源响应页的 。

readAllContainers

public CosmosPagedFlux readAllContainers()

读取所有 cosmos 容器。

cosmosAsyncDatabase.readAllContainers()
     .byPage()
     .flatMap(containerPropertiesFeedResponse -> {
         for (CosmosContainerProperties properties : containerPropertiesFeedResponse.getResults()) {
             System.out.println(properties);
         }
         return Flux.empty();
     })
     .subscribe();

订阅后将执行该操作。 CosmosPagedFlux<T>将包含读取容器的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

返回:

包含 CosmosPagedFlux<T> 读取容器的一个或多个源响应页或错误。

readAllContainers

public CosmosPagedFlux readAllContainers(CosmosQueryRequestOptions options)

读取所有 cosmos 容器。

cosmosAsyncDatabase.readAllContainers()
     .byPage()
     .flatMap(containerPropertiesFeedResponse -> {
         for (CosmosContainerProperties properties : containerPropertiesFeedResponse.getResults()) {
             System.out.println(properties);
         }
         return Flux.empty();
     })
     .subscribe();

订阅后将执行该操作。 CosmosPagedFlux<T>将包含读取容器的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

参数:

返回:

包含 CosmosPagedFlux<T> 读取容器的一个或多个源响应页或错误。

readAllUsers

public CosmosPagedFlux readAllUsers()

读取数据库中的所有 cosmos 用户。

cosmosAsyncDatabase.readAllUsers()
     .byPage()
     .flatMap(userPropertiesFeedResponse -> {
         for (CosmosUserProperties properties : userPropertiesFeedResponse.getResults()) {
             System.out.println(properties);
         }
         return Flux.empty();
     })
     .subscribe();

订阅后将执行该操作。 CosmosPagedFlux<T>将包含读取 cosmos 用户的一个或多个源响应。 如果失败, CosmosPagedFlux<T> 将出错。

返回:

包含 CosmosPagedFlux<T> 读取 cosmos 用户的一个或多个源响应页或错误。

readThroughput

public Mono readThroughput()

获取数据库的吞吐量。

cosmosAsyncDatabase.readThroughput()
     .subscribe(throughputResponse -> {
             System.out.println(throughputResponse);
         },
         throwable -> {
             throwable.printStackTrace();
         });

返回:

包含吞吐量响应的单声道。

replaceThroughput

public Mono replaceThroughput(ThroughputProperties throughputProperties)

设置为容器预配的吞吐量,以度量 Azure Cosmos 服务中每单位的请求数。

ThroughputProperties autoscaledThroughput = ThroughputProperties
     .createAutoscaledThroughput(autoScaleMaxThroughput);
 cosmosAsyncDatabase.replaceThroughput(autoscaledThroughput)
     .subscribe(throughputResponse -> {
             System.out.println(throughputResponse);
         },
         throwable -> {
             throwable.printStackTrace();
         });

参数:

throughputProperties - 吞吐量属性。

返回:

单声道。

upsertUser

public Mono upsertUser(CosmosUserProperties userProperties)

更新插入用户。 Upsert 将创建一个新用户(如果不存在),或者替换现有用户(如果存在)。 订阅后将执行该操作。 成功完成后, Mono 将包含创建用户的单个资源响应。 如果失败, Mono 将出错。

String userId = "userId";
 CosmosUserProperties userProperties = new CosmosUserProperties();
 userProperties.setId(userId);
 cosmosAsyncDatabase.upsertUser(userProperties)
     .subscribe(
         userResponse -> System.out.println(userResponse),
         throwable -> System.out.println("Failed to upsert user: " + throwable)
     );

参数:

userProperties - cosmos 用户属性

返回:

一个 , Mono 其中包含单个资源响应,其中包含已更新插入的用户或错误。

适用于