Interface NeptuneGraphAsyncClient

All Superinterfaces:
AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
@Generated("software.amazon.awssdk:codegen") @ThreadSafe public interface NeptuneGraphAsyncClient extends AwsClient
Service client for accessing Neptune Graph asynchronously. This can be created using the static builder() method.The asynchronous client performs non-blocking I/O when configured with any SdkAsyncHttpClient supported in the SDK. However, full non-blocking is not guaranteed as the async client may perform blocking calls in some cases such as credentials retrieval and endpoint discovery as part of the async API call.

Neptune Analytics is a new analytics database engine for Amazon Neptune that helps customers get to insights faster by quickly processing large amounts of graph data, invoking popular graph analytic algorithms in low-latency queries, and getting analytics results in seconds.

  • Field Details

  • Method Details

    • cancelExportTask

      default CompletableFuture<CancelExportTaskResponse> cancelExportTask(CancelExportTaskRequest cancelExportTaskRequest)

      Cancel the specified export task.

      Parameters:
      cancelExportTaskRequest -
      Returns:
      A Java Future containing the result of the CancelExportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • cancelExportTask

      default CompletableFuture<CancelExportTaskResponse> cancelExportTask(Consumer<CancelExportTaskRequest.Builder> cancelExportTaskRequest)

      Cancel the specified export task.


      This is a convenience which creates an instance of the CancelExportTaskRequest.Builder avoiding the need to create one manually via CancelExportTaskRequest.builder()

      Parameters:
      cancelExportTaskRequest - A Consumer that will call methods on CancelExportTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CancelExportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • cancelImportTask

      default CompletableFuture<CancelImportTaskResponse> cancelImportTask(CancelImportTaskRequest cancelImportTaskRequest)

      Deletes the specified import task.

      Parameters:
      cancelImportTaskRequest -
      Returns:
      A Java Future containing the result of the CancelImportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • cancelImportTask

      default CompletableFuture<CancelImportTaskResponse> cancelImportTask(Consumer<CancelImportTaskRequest.Builder> cancelImportTaskRequest)

      Deletes the specified import task.


      This is a convenience which creates an instance of the CancelImportTaskRequest.Builder avoiding the need to create one manually via CancelImportTaskRequest.builder()

      Parameters:
      cancelImportTaskRequest - A Consumer that will call methods on CancelImportTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CancelImportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • cancelQuery

      default CompletableFuture<CancelQueryResponse> cancelQuery(CancelQueryRequest cancelQueryRequest)

      Cancels a specified query.

      Parameters:
      cancelQueryRequest -
      Returns:
      A Java Future containing the result of the CancelQuery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • cancelQuery

      default CompletableFuture<CancelQueryResponse> cancelQuery(Consumer<CancelQueryRequest.Builder> cancelQueryRequest)

      Cancels a specified query.


      This is a convenience which creates an instance of the CancelQueryRequest.Builder avoiding the need to create one manually via CancelQueryRequest.builder()

      Parameters:
      cancelQueryRequest - A Consumer that will call methods on CancelQueryRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CancelQuery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createGraph

      default CompletableFuture<CreateGraphResponse> createGraph(CreateGraphRequest createGraphRequest)

      Creates a new Neptune Analytics graph.

      Parameters:
      createGraphRequest -
      Returns:
      A Java Future containing the result of the CreateGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createGraph

      default CompletableFuture<CreateGraphResponse> createGraph(Consumer<CreateGraphRequest.Builder> createGraphRequest)

      Creates a new Neptune Analytics graph.


      This is a convenience which creates an instance of the CreateGraphRequest.Builder avoiding the need to create one manually via CreateGraphRequest.builder()

      Parameters:
      createGraphRequest - A Consumer that will call methods on CreateGraphRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createGraphSnapshot

      default CompletableFuture<CreateGraphSnapshotResponse> createGraphSnapshot(CreateGraphSnapshotRequest createGraphSnapshotRequest)

      Creates a snapshot of the specific graph.

      Parameters:
      createGraphSnapshotRequest -
      Returns:
      A Java Future containing the result of the CreateGraphSnapshot operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createGraphSnapshot

      default CompletableFuture<CreateGraphSnapshotResponse> createGraphSnapshot(Consumer<CreateGraphSnapshotRequest.Builder> createGraphSnapshotRequest)

      Creates a snapshot of the specific graph.


      This is a convenience which creates an instance of the CreateGraphSnapshotRequest.Builder avoiding the need to create one manually via CreateGraphSnapshotRequest.builder()

      Parameters:
      createGraphSnapshotRequest - A Consumer that will call methods on CreateGraphSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateGraphSnapshot operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createGraphUsingImportTask

      default CompletableFuture<CreateGraphUsingImportTaskResponse> createGraphUsingImportTask(CreateGraphUsingImportTaskRequest createGraphUsingImportTaskRequest)

      Creates a new Neptune Analytics graph and imports data into it, either from Amazon Simple Storage Service (S3) or from a Neptune database or a Neptune database snapshot.

      The data can be loaded from files in S3 that in either the Gremlin CSV format or the openCypher load format.

      Parameters:
      createGraphUsingImportTaskRequest -
      Returns:
      A Java Future containing the result of the CreateGraphUsingImportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createGraphUsingImportTask

      default CompletableFuture<CreateGraphUsingImportTaskResponse> createGraphUsingImportTask(Consumer<CreateGraphUsingImportTaskRequest.Builder> createGraphUsingImportTaskRequest)

      Creates a new Neptune Analytics graph and imports data into it, either from Amazon Simple Storage Service (S3) or from a Neptune database or a Neptune database snapshot.

      The data can be loaded from files in S3 that in either the Gremlin CSV format or the openCypher load format.


      This is a convenience which creates an instance of the CreateGraphUsingImportTaskRequest.Builder avoiding the need to create one manually via CreateGraphUsingImportTaskRequest.builder()

      Parameters:
      createGraphUsingImportTaskRequest - A Consumer that will call methods on CreateGraphUsingImportTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateGraphUsingImportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createPrivateGraphEndpoint

      default CompletableFuture<CreatePrivateGraphEndpointResponse> createPrivateGraphEndpoint(CreatePrivateGraphEndpointRequest createPrivateGraphEndpointRequest)

      Create a private graph endpoint to allow private access from to the graph from within a VPC. You can attach security groups to the private graph endpoint.

      VPC endpoint charges apply.

      Parameters:
      createPrivateGraphEndpointRequest -
      Returns:
      A Java Future containing the result of the CreatePrivateGraphEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createPrivateGraphEndpoint

      default CompletableFuture<CreatePrivateGraphEndpointResponse> createPrivateGraphEndpoint(Consumer<CreatePrivateGraphEndpointRequest.Builder> createPrivateGraphEndpointRequest)

      Create a private graph endpoint to allow private access from to the graph from within a VPC. You can attach security groups to the private graph endpoint.

      VPC endpoint charges apply.


      This is a convenience which creates an instance of the CreatePrivateGraphEndpointRequest.Builder avoiding the need to create one manually via CreatePrivateGraphEndpointRequest.builder()

      Parameters:
      createPrivateGraphEndpointRequest - A Consumer that will call methods on CreatePrivateGraphEndpointRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreatePrivateGraphEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteGraph

      default CompletableFuture<DeleteGraphResponse> deleteGraph(DeleteGraphRequest deleteGraphRequest)

      Deletes the specified graph. Graphs cannot be deleted if delete-protection is enabled.

      Parameters:
      deleteGraphRequest -
      Returns:
      A Java Future containing the result of the DeleteGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteGraph

      default CompletableFuture<DeleteGraphResponse> deleteGraph(Consumer<DeleteGraphRequest.Builder> deleteGraphRequest)

      Deletes the specified graph. Graphs cannot be deleted if delete-protection is enabled.


      This is a convenience which creates an instance of the DeleteGraphRequest.Builder avoiding the need to create one manually via DeleteGraphRequest.builder()

      Parameters:
      deleteGraphRequest - A Consumer that will call methods on DeleteGraphRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteGraphSnapshot

      default CompletableFuture<DeleteGraphSnapshotResponse> deleteGraphSnapshot(DeleteGraphSnapshotRequest deleteGraphSnapshotRequest)

      Deletes the specifed graph snapshot.

      Parameters:
      deleteGraphSnapshotRequest -
      Returns:
      A Java Future containing the result of the DeleteGraphSnapshot operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteGraphSnapshot

      default CompletableFuture<DeleteGraphSnapshotResponse> deleteGraphSnapshot(Consumer<DeleteGraphSnapshotRequest.Builder> deleteGraphSnapshotRequest)

      Deletes the specifed graph snapshot.


      This is a convenience which creates an instance of the DeleteGraphSnapshotRequest.Builder avoiding the need to create one manually via DeleteGraphSnapshotRequest.builder()

      Parameters:
      deleteGraphSnapshotRequest - A Consumer that will call methods on DeleteGraphSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteGraphSnapshot operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deletePrivateGraphEndpoint

      default CompletableFuture<DeletePrivateGraphEndpointResponse> deletePrivateGraphEndpoint(DeletePrivateGraphEndpointRequest deletePrivateGraphEndpointRequest)

      Deletes a private graph endpoint.

      Parameters:
      deletePrivateGraphEndpointRequest -
      Returns:
      A Java Future containing the result of the DeletePrivateGraphEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deletePrivateGraphEndpoint

      default CompletableFuture<DeletePrivateGraphEndpointResponse> deletePrivateGraphEndpoint(Consumer<DeletePrivateGraphEndpointRequest.Builder> deletePrivateGraphEndpointRequest)

      Deletes a private graph endpoint.


      This is a convenience which creates an instance of the DeletePrivateGraphEndpointRequest.Builder avoiding the need to create one manually via DeletePrivateGraphEndpointRequest.builder()

      Parameters:
      deletePrivateGraphEndpointRequest - A Consumer that will call methods on DeletePrivateGraphEndpointRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeletePrivateGraphEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • executeQuery

      default <ReturnT> CompletableFuture<ReturnT> executeQuery(ExecuteQueryRequest executeQueryRequest, AsyncResponseTransformer<ExecuteQueryResponse,ReturnT> asyncResponseTransformer)

      Execute an openCypher query.

      When invoking this operation in a Neptune Analytics cluster, the IAM user or role making the request must have a policy attached that allows one of the following IAM actions in that cluster, depending on the query:

      • neptune-graph:ReadDataViaQuery

      • neptune-graph:WriteDataViaQuery

      • neptune-graph:DeleteDataViaQuery

      Parameters:
      executeQueryRequest -
      asyncResponseTransformer - The response transformer for processing the streaming response in a non-blocking manner. See AsyncResponseTransformer for details on how this callback should be implemented and for links to precanned implementations for common scenarios like downloading to a file. The service documentation for the response content is as follows '

      The query results.

      '.
      Returns:
      A future to the transformed result of the AsyncResponseTransformer.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • UnprocessableException Request cannot be processed due to known reasons. Eg. partition full.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • executeQuery

      default <ReturnT> CompletableFuture<ReturnT> executeQuery(Consumer<ExecuteQueryRequest.Builder> executeQueryRequest, AsyncResponseTransformer<ExecuteQueryResponse,ReturnT> asyncResponseTransformer)

      Execute an openCypher query.

      When invoking this operation in a Neptune Analytics cluster, the IAM user or role making the request must have a policy attached that allows one of the following IAM actions in that cluster, depending on the query:

      • neptune-graph:ReadDataViaQuery

      • neptune-graph:WriteDataViaQuery

      • neptune-graph:DeleteDataViaQuery


      This is a convenience which creates an instance of the ExecuteQueryRequest.Builder avoiding the need to create one manually via ExecuteQueryRequest.builder()

      Parameters:
      executeQueryRequest - A Consumer that will call methods on ExecuteQueryRequest.Builder to create a request.
      asyncResponseTransformer - The response transformer for processing the streaming response in a non-blocking manner. See AsyncResponseTransformer for details on how this callback should be implemented and for links to precanned implementations for common scenarios like downloading to a file. The service documentation for the response content is as follows '

      The query results.

      '.
      Returns:
      A future to the transformed result of the AsyncResponseTransformer.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • UnprocessableException Request cannot be processed due to known reasons. Eg. partition full.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • executeQuery

      default CompletableFuture<ExecuteQueryResponse> executeQuery(ExecuteQueryRequest executeQueryRequest, Path destinationPath)

      Execute an openCypher query.

      When invoking this operation in a Neptune Analytics cluster, the IAM user or role making the request must have a policy attached that allows one of the following IAM actions in that cluster, depending on the query:

      • neptune-graph:ReadDataViaQuery

      • neptune-graph:WriteDataViaQuery

      • neptune-graph:DeleteDataViaQuery

      Parameters:
      executeQueryRequest -
      destinationPath - Path to file that response contents will be written to. The file must not exist or this method will throw an exception. If the file is not writable by the current user then an exception will be thrown. The service documentation for the response content is as follows '

      The query results.

      '.
      Returns:
      A future to the transformed result of the AsyncResponseTransformer.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • UnprocessableException Request cannot be processed due to known reasons. Eg. partition full.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • executeQuery

      default CompletableFuture<ExecuteQueryResponse> executeQuery(Consumer<ExecuteQueryRequest.Builder> executeQueryRequest, Path destinationPath)

      Execute an openCypher query.

      When invoking this operation in a Neptune Analytics cluster, the IAM user or role making the request must have a policy attached that allows one of the following IAM actions in that cluster, depending on the query:

      • neptune-graph:ReadDataViaQuery

      • neptune-graph:WriteDataViaQuery

      • neptune-graph:DeleteDataViaQuery


      This is a convenience which creates an instance of the ExecuteQueryRequest.Builder avoiding the need to create one manually via ExecuteQueryRequest.builder()

      Parameters:
      executeQueryRequest - A Consumer that will call methods on ExecuteQueryRequest.Builder to create a request.
      destinationPath - Path to file that response contents will be written to. The file must not exist or this method will throw an exception. If the file is not writable by the current user then an exception will be thrown. The service documentation for the response content is as follows '

      The query results.

      '.
      Returns:
      A future to the transformed result of the AsyncResponseTransformer.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • UnprocessableException Request cannot be processed due to known reasons. Eg. partition full.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getExportTask

      default CompletableFuture<GetExportTaskResponse> getExportTask(GetExportTaskRequest getExportTaskRequest)

      Retrieves a specified export task.

      Parameters:
      getExportTaskRequest -
      Returns:
      A Java Future containing the result of the GetExportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getExportTask

      default CompletableFuture<GetExportTaskResponse> getExportTask(Consumer<GetExportTaskRequest.Builder> getExportTaskRequest)

      Retrieves a specified export task.


      This is a convenience which creates an instance of the GetExportTaskRequest.Builder avoiding the need to create one manually via GetExportTaskRequest.builder()

      Parameters:
      getExportTaskRequest - A Consumer that will call methods on GetExportTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetExportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getGraph

      default CompletableFuture<GetGraphResponse> getGraph(GetGraphRequest getGraphRequest)

      Gets information about a specified graph.

      Parameters:
      getGraphRequest -
      Returns:
      A Java Future containing the result of the GetGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getGraph

      default CompletableFuture<GetGraphResponse> getGraph(Consumer<GetGraphRequest.Builder> getGraphRequest)

      Gets information about a specified graph.


      This is a convenience which creates an instance of the GetGraphRequest.Builder avoiding the need to create one manually via GetGraphRequest.builder()

      Parameters:
      getGraphRequest - A Consumer that will call methods on GetGraphRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getGraphSnapshot

      default CompletableFuture<GetGraphSnapshotResponse> getGraphSnapshot(GetGraphSnapshotRequest getGraphSnapshotRequest)

      Retrieves a specified graph snapshot.

      Parameters:
      getGraphSnapshotRequest -
      Returns:
      A Java Future containing the result of the GetGraphSnapshot operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getGraphSnapshot

      default CompletableFuture<GetGraphSnapshotResponse> getGraphSnapshot(Consumer<GetGraphSnapshotRequest.Builder> getGraphSnapshotRequest)

      Retrieves a specified graph snapshot.


      This is a convenience which creates an instance of the GetGraphSnapshotRequest.Builder avoiding the need to create one manually via GetGraphSnapshotRequest.builder()

      Parameters:
      getGraphSnapshotRequest - A Consumer that will call methods on GetGraphSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetGraphSnapshot operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getGraphSummary

      default CompletableFuture<GetGraphSummaryResponse> getGraphSummary(GetGraphSummaryRequest getGraphSummaryRequest)

      Gets a graph summary for a property graph.

      Parameters:
      getGraphSummaryRequest -
      Returns:
      A Java Future containing the result of the GetGraphSummary operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getGraphSummary

      default CompletableFuture<GetGraphSummaryResponse> getGraphSummary(Consumer<GetGraphSummaryRequest.Builder> getGraphSummaryRequest)

      Gets a graph summary for a property graph.


      This is a convenience which creates an instance of the GetGraphSummaryRequest.Builder avoiding the need to create one manually via GetGraphSummaryRequest.builder()

      Parameters:
      getGraphSummaryRequest - A Consumer that will call methods on GetGraphSummaryRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetGraphSummary operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getImportTask

      default CompletableFuture<GetImportTaskResponse> getImportTask(GetImportTaskRequest getImportTaskRequest)

      Retrieves a specified import task.

      Parameters:
      getImportTaskRequest -
      Returns:
      A Java Future containing the result of the GetImportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getImportTask

      default CompletableFuture<GetImportTaskResponse> getImportTask(Consumer<GetImportTaskRequest.Builder> getImportTaskRequest)

      Retrieves a specified import task.


      This is a convenience which creates an instance of the GetImportTaskRequest.Builder avoiding the need to create one manually via GetImportTaskRequest.builder()

      Parameters:
      getImportTaskRequest - A Consumer that will call methods on GetImportTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetImportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getPrivateGraphEndpoint

      default CompletableFuture<GetPrivateGraphEndpointResponse> getPrivateGraphEndpoint(GetPrivateGraphEndpointRequest getPrivateGraphEndpointRequest)

      Retrieves information about a specified private endpoint.

      Parameters:
      getPrivateGraphEndpointRequest -
      Returns:
      A Java Future containing the result of the GetPrivateGraphEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getPrivateGraphEndpoint

      default CompletableFuture<GetPrivateGraphEndpointResponse> getPrivateGraphEndpoint(Consumer<GetPrivateGraphEndpointRequest.Builder> getPrivateGraphEndpointRequest)

      Retrieves information about a specified private endpoint.


      This is a convenience which creates an instance of the GetPrivateGraphEndpointRequest.Builder avoiding the need to create one manually via GetPrivateGraphEndpointRequest.builder()

      Parameters:
      getPrivateGraphEndpointRequest - A Consumer that will call methods on GetPrivateGraphEndpointRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetPrivateGraphEndpoint operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getQuery

      default CompletableFuture<GetQueryResponse> getQuery(GetQueryRequest getQueryRequest)

      Retrieves the status of a specified query.

      When invoking this operation in a Neptune Analytics cluster, the IAM user or role making the request must have the neptune-graph:GetQueryStatus IAM action attached.

      Parameters:
      getQueryRequest -
      Returns:
      A Java Future containing the result of the GetQuery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getQuery

      default CompletableFuture<GetQueryResponse> getQuery(Consumer<GetQueryRequest.Builder> getQueryRequest)

      Retrieves the status of a specified query.

      When invoking this operation in a Neptune Analytics cluster, the IAM user or role making the request must have the neptune-graph:GetQueryStatus IAM action attached.


      This is a convenience which creates an instance of the GetQueryRequest.Builder avoiding the need to create one manually via GetQueryRequest.builder()

      Parameters:
      getQueryRequest - A Consumer that will call methods on GetQueryRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetQuery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listExportTasks

      default CompletableFuture<ListExportTasksResponse> listExportTasks(ListExportTasksRequest listExportTasksRequest)

      Retrieves a list of export tasks.

      Parameters:
      listExportTasksRequest -
      Returns:
      A Java Future containing the result of the ListExportTasks operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listExportTasks

      default CompletableFuture<ListExportTasksResponse> listExportTasks(Consumer<ListExportTasksRequest.Builder> listExportTasksRequest)

      Retrieves a list of export tasks.


      This is a convenience which creates an instance of the ListExportTasksRequest.Builder avoiding the need to create one manually via ListExportTasksRequest.builder()

      Parameters:
      listExportTasksRequest - A Consumer that will call methods on ListExportTasksRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListExportTasks operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listExportTasksPaginator

      default ListExportTasksPublisher listExportTasksPaginator(ListExportTasksRequest listExportTasksRequest)

      This is a variant of listExportTasks(software.amazon.awssdk.services.neptunegraph.model.ListExportTasksRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListExportTasksPublisher publisher = client.listExportTasksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListExportTasksPublisher publisher = client.listExportTasksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListExportTasksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListExportTasksResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listExportTasks(software.amazon.awssdk.services.neptunegraph.model.ListExportTasksRequest) operation.

      Parameters:
      listExportTasksRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listExportTasksPaginator

      default ListExportTasksPublisher listExportTasksPaginator(Consumer<ListExportTasksRequest.Builder> listExportTasksRequest)

      This is a variant of listExportTasks(software.amazon.awssdk.services.neptunegraph.model.ListExportTasksRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListExportTasksPublisher publisher = client.listExportTasksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListExportTasksPublisher publisher = client.listExportTasksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListExportTasksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListExportTasksResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listExportTasks(software.amazon.awssdk.services.neptunegraph.model.ListExportTasksRequest) operation.


      This is a convenience which creates an instance of the ListExportTasksRequest.Builder avoiding the need to create one manually via ListExportTasksRequest.builder()

      Parameters:
      listExportTasksRequest - A Consumer that will call methods on ListExportTasksRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listGraphSnapshots

      default CompletableFuture<ListGraphSnapshotsResponse> listGraphSnapshots(ListGraphSnapshotsRequest listGraphSnapshotsRequest)

      Lists available snapshots of a specified Neptune Analytics graph.

      Parameters:
      listGraphSnapshotsRequest -
      Returns:
      A Java Future containing the result of the ListGraphSnapshots operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listGraphSnapshots

      default CompletableFuture<ListGraphSnapshotsResponse> listGraphSnapshots(Consumer<ListGraphSnapshotsRequest.Builder> listGraphSnapshotsRequest)

      Lists available snapshots of a specified Neptune Analytics graph.


      This is a convenience which creates an instance of the ListGraphSnapshotsRequest.Builder avoiding the need to create one manually via ListGraphSnapshotsRequest.builder()

      Parameters:
      listGraphSnapshotsRequest - A Consumer that will call methods on ListGraphSnapshotsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListGraphSnapshots operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listGraphSnapshotsPaginator

      default ListGraphSnapshotsPublisher listGraphSnapshotsPaginator(ListGraphSnapshotsRequest listGraphSnapshotsRequest)

      This is a variant of listGraphSnapshots(software.amazon.awssdk.services.neptunegraph.model.ListGraphSnapshotsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListGraphSnapshotsPublisher publisher = client.listGraphSnapshotsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListGraphSnapshotsPublisher publisher = client.listGraphSnapshotsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListGraphSnapshotsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListGraphSnapshotsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listGraphSnapshots(software.amazon.awssdk.services.neptunegraph.model.ListGraphSnapshotsRequest) operation.

      Parameters:
      listGraphSnapshotsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listGraphSnapshotsPaginator

      default ListGraphSnapshotsPublisher listGraphSnapshotsPaginator(Consumer<ListGraphSnapshotsRequest.Builder> listGraphSnapshotsRequest)

      This is a variant of listGraphSnapshots(software.amazon.awssdk.services.neptunegraph.model.ListGraphSnapshotsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListGraphSnapshotsPublisher publisher = client.listGraphSnapshotsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListGraphSnapshotsPublisher publisher = client.listGraphSnapshotsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListGraphSnapshotsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListGraphSnapshotsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listGraphSnapshots(software.amazon.awssdk.services.neptunegraph.model.ListGraphSnapshotsRequest) operation.


      This is a convenience which creates an instance of the ListGraphSnapshotsRequest.Builder avoiding the need to create one manually via ListGraphSnapshotsRequest.builder()

      Parameters:
      listGraphSnapshotsRequest - A Consumer that will call methods on ListGraphSnapshotsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listGraphs

      default CompletableFuture<ListGraphsResponse> listGraphs(ListGraphsRequest listGraphsRequest)

      Lists available Neptune Analytics graphs.

      Parameters:
      listGraphsRequest -
      Returns:
      A Java Future containing the result of the ListGraphs operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listGraphs

      default CompletableFuture<ListGraphsResponse> listGraphs(Consumer<ListGraphsRequest.Builder> listGraphsRequest)

      Lists available Neptune Analytics graphs.


      This is a convenience which creates an instance of the ListGraphsRequest.Builder avoiding the need to create one manually via ListGraphsRequest.builder()

      Parameters:
      listGraphsRequest - A Consumer that will call methods on ListGraphsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListGraphs operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listGraphsPaginator

      default ListGraphsPublisher listGraphsPaginator(ListGraphsRequest listGraphsRequest)

      This is a variant of listGraphs(software.amazon.awssdk.services.neptunegraph.model.ListGraphsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListGraphsPublisher publisher = client.listGraphsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListGraphsPublisher publisher = client.listGraphsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListGraphsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListGraphsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listGraphs(software.amazon.awssdk.services.neptunegraph.model.ListGraphsRequest) operation.

      Parameters:
      listGraphsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listGraphsPaginator

      default ListGraphsPublisher listGraphsPaginator(Consumer<ListGraphsRequest.Builder> listGraphsRequest)

      This is a variant of listGraphs(software.amazon.awssdk.services.neptunegraph.model.ListGraphsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListGraphsPublisher publisher = client.listGraphsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListGraphsPublisher publisher = client.listGraphsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListGraphsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListGraphsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listGraphs(software.amazon.awssdk.services.neptunegraph.model.ListGraphsRequest) operation.


      This is a convenience which creates an instance of the ListGraphsRequest.Builder avoiding the need to create one manually via ListGraphsRequest.builder()

      Parameters:
      listGraphsRequest - A Consumer that will call methods on ListGraphsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listImportTasks

      default CompletableFuture<ListImportTasksResponse> listImportTasks(ListImportTasksRequest listImportTasksRequest)

      Lists import tasks.

      Parameters:
      listImportTasksRequest -
      Returns:
      A Java Future containing the result of the ListImportTasks operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listImportTasks

      default CompletableFuture<ListImportTasksResponse> listImportTasks(Consumer<ListImportTasksRequest.Builder> listImportTasksRequest)

      Lists import tasks.


      This is a convenience which creates an instance of the ListImportTasksRequest.Builder avoiding the need to create one manually via ListImportTasksRequest.builder()

      Parameters:
      listImportTasksRequest - A Consumer that will call methods on ListImportTasksRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListImportTasks operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listImportTasksPaginator

      default ListImportTasksPublisher listImportTasksPaginator(ListImportTasksRequest listImportTasksRequest)

      This is a variant of listImportTasks(software.amazon.awssdk.services.neptunegraph.model.ListImportTasksRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListImportTasksPublisher publisher = client.listImportTasksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListImportTasksPublisher publisher = client.listImportTasksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListImportTasksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListImportTasksResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listImportTasks(software.amazon.awssdk.services.neptunegraph.model.ListImportTasksRequest) operation.

      Parameters:
      listImportTasksRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listImportTasksPaginator

      default ListImportTasksPublisher listImportTasksPaginator(Consumer<ListImportTasksRequest.Builder> listImportTasksRequest)

      This is a variant of listImportTasks(software.amazon.awssdk.services.neptunegraph.model.ListImportTasksRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListImportTasksPublisher publisher = client.listImportTasksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListImportTasksPublisher publisher = client.listImportTasksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListImportTasksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListImportTasksResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listImportTasks(software.amazon.awssdk.services.neptunegraph.model.ListImportTasksRequest) operation.


      This is a convenience which creates an instance of the ListImportTasksRequest.Builder avoiding the need to create one manually via ListImportTasksRequest.builder()

      Parameters:
      listImportTasksRequest - A Consumer that will call methods on ListImportTasksRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPrivateGraphEndpoints

      default CompletableFuture<ListPrivateGraphEndpointsResponse> listPrivateGraphEndpoints(ListPrivateGraphEndpointsRequest listPrivateGraphEndpointsRequest)

      Lists private endpoints for a specified Neptune Analytics graph.

      Parameters:
      listPrivateGraphEndpointsRequest -
      Returns:
      A Java Future containing the result of the ListPrivateGraphEndpoints operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPrivateGraphEndpoints

      default CompletableFuture<ListPrivateGraphEndpointsResponse> listPrivateGraphEndpoints(Consumer<ListPrivateGraphEndpointsRequest.Builder> listPrivateGraphEndpointsRequest)

      Lists private endpoints for a specified Neptune Analytics graph.


      This is a convenience which creates an instance of the ListPrivateGraphEndpointsRequest.Builder avoiding the need to create one manually via ListPrivateGraphEndpointsRequest.builder()

      Parameters:
      listPrivateGraphEndpointsRequest - A Consumer that will call methods on ListPrivateGraphEndpointsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListPrivateGraphEndpoints operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPrivateGraphEndpointsPaginator

      default ListPrivateGraphEndpointsPublisher listPrivateGraphEndpointsPaginator(ListPrivateGraphEndpointsRequest listPrivateGraphEndpointsRequest)

      This is a variant of listPrivateGraphEndpoints(software.amazon.awssdk.services.neptunegraph.model.ListPrivateGraphEndpointsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListPrivateGraphEndpointsPublisher publisher = client.listPrivateGraphEndpointsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListPrivateGraphEndpointsPublisher publisher = client.listPrivateGraphEndpointsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListPrivateGraphEndpointsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListPrivateGraphEndpointsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listPrivateGraphEndpoints(software.amazon.awssdk.services.neptunegraph.model.ListPrivateGraphEndpointsRequest) operation.

      Parameters:
      listPrivateGraphEndpointsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPrivateGraphEndpointsPaginator

      default ListPrivateGraphEndpointsPublisher listPrivateGraphEndpointsPaginator(Consumer<ListPrivateGraphEndpointsRequest.Builder> listPrivateGraphEndpointsRequest)

      This is a variant of listPrivateGraphEndpoints(software.amazon.awssdk.services.neptunegraph.model.ListPrivateGraphEndpointsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListPrivateGraphEndpointsPublisher publisher = client.listPrivateGraphEndpointsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.neptunegraph.paginators.ListPrivateGraphEndpointsPublisher publisher = client.listPrivateGraphEndpointsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.neptunegraph.model.ListPrivateGraphEndpointsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.neptunegraph.model.ListPrivateGraphEndpointsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listPrivateGraphEndpoints(software.amazon.awssdk.services.neptunegraph.model.ListPrivateGraphEndpointsRequest) operation.


      This is a convenience which creates an instance of the ListPrivateGraphEndpointsRequest.Builder avoiding the need to create one manually via ListPrivateGraphEndpointsRequest.builder()

      Parameters:
      listPrivateGraphEndpointsRequest - A Consumer that will call methods on ListPrivateGraphEndpointsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listQueries

      default CompletableFuture<ListQueriesResponse> listQueries(ListQueriesRequest listQueriesRequest)

      Lists active openCypher queries.

      Parameters:
      listQueriesRequest -
      Returns:
      A Java Future containing the result of the ListQueries operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listQueries

      default CompletableFuture<ListQueriesResponse> listQueries(Consumer<ListQueriesRequest.Builder> listQueriesRequest)

      Lists active openCypher queries.


      This is a convenience which creates an instance of the ListQueriesRequest.Builder avoiding the need to create one manually via ListQueriesRequest.builder()

      Parameters:
      listQueriesRequest - A Consumer that will call methods on ListQueriesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListQueries operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • AccessDeniedException Raised in case of an authentication or authorization failure.
      • InternalServerException A failure occurred on the server.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTagsForResource

      default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest)

      Lists tags associated with a specified resource.

      Parameters:
      listTagsForResourceRequest -
      Returns:
      A Java Future containing the result of the ListTagsForResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTagsForResource

      default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(Consumer<ListTagsForResourceRequest.Builder> listTagsForResourceRequest)

      Lists tags associated with a specified resource.


      This is a convenience which creates an instance of the ListTagsForResourceRequest.Builder avoiding the need to create one manually via ListTagsForResourceRequest.builder()

      Parameters:
      listTagsForResourceRequest - A Consumer that will call methods on ListTagsForResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTagsForResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • resetGraph

      default CompletableFuture<ResetGraphResponse> resetGraph(ResetGraphRequest resetGraphRequest)

      Empties the data from a specified Neptune Analytics graph.

      Parameters:
      resetGraphRequest -
      Returns:
      A Java Future containing the result of the ResetGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • resetGraph

      default CompletableFuture<ResetGraphResponse> resetGraph(Consumer<ResetGraphRequest.Builder> resetGraphRequest)

      Empties the data from a specified Neptune Analytics graph.


      This is a convenience which creates an instance of the ResetGraphRequest.Builder avoiding the need to create one manually via ResetGraphRequest.builder()

      Parameters:
      resetGraphRequest - A Consumer that will call methods on ResetGraphRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ResetGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreGraphFromSnapshot

      default CompletableFuture<RestoreGraphFromSnapshotResponse> restoreGraphFromSnapshot(RestoreGraphFromSnapshotRequest restoreGraphFromSnapshotRequest)

      Restores a graph from a snapshot.

      Parameters:
      restoreGraphFromSnapshotRequest -
      Returns:
      A Java Future containing the result of the RestoreGraphFromSnapshot operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreGraphFromSnapshot

      default CompletableFuture<RestoreGraphFromSnapshotResponse> restoreGraphFromSnapshot(Consumer<RestoreGraphFromSnapshotRequest.Builder> restoreGraphFromSnapshotRequest)

      Restores a graph from a snapshot.


      This is a convenience which creates an instance of the RestoreGraphFromSnapshotRequest.Builder avoiding the need to create one manually via RestoreGraphFromSnapshotRequest.builder()

      Parameters:
      restoreGraphFromSnapshotRequest - A Consumer that will call methods on RestoreGraphFromSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RestoreGraphFromSnapshot operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ServiceQuotaExceededException A service quota was exceeded.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startExportTask

      default CompletableFuture<StartExportTaskResponse> startExportTask(StartExportTaskRequest startExportTaskRequest)

      Export data from an existing Neptune Analytics graph to Amazon S3. The graph state should be AVAILABLE.

      Parameters:
      startExportTaskRequest -
      Returns:
      A Java Future containing the result of the StartExportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startExportTask

      default CompletableFuture<StartExportTaskResponse> startExportTask(Consumer<StartExportTaskRequest.Builder> startExportTaskRequest)

      Export data from an existing Neptune Analytics graph to Amazon S3. The graph state should be AVAILABLE.


      This is a convenience which creates an instance of the StartExportTaskRequest.Builder avoiding the need to create one manually via StartExportTaskRequest.builder()

      Parameters:
      startExportTaskRequest - A Consumer that will call methods on StartExportTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartExportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startGraph

      default CompletableFuture<StartGraphResponse> startGraph(StartGraphRequest startGraphRequest)

      Starts the specific graph.

      Parameters:
      startGraphRequest -
      Returns:
      A Java Future containing the result of the StartGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startGraph

      default CompletableFuture<StartGraphResponse> startGraph(Consumer<StartGraphRequest.Builder> startGraphRequest)

      Starts the specific graph.


      This is a convenience which creates an instance of the StartGraphRequest.Builder avoiding the need to create one manually via StartGraphRequest.builder()

      Parameters:
      startGraphRequest - A Consumer that will call methods on StartGraphRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startImportTask

      default CompletableFuture<StartImportTaskResponse> startImportTask(StartImportTaskRequest startImportTaskRequest)

      Import data into existing Neptune Analytics graph from Amazon Simple Storage Service (S3). The graph needs to be empty and in the AVAILABLE state.

      Parameters:
      startImportTaskRequest -
      Returns:
      A Java Future containing the result of the StartImportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startImportTask

      default CompletableFuture<StartImportTaskResponse> startImportTask(Consumer<StartImportTaskRequest.Builder> startImportTaskRequest)

      Import data into existing Neptune Analytics graph from Amazon Simple Storage Service (S3). The graph needs to be empty and in the AVAILABLE state.


      This is a convenience which creates an instance of the StartImportTaskRequest.Builder avoiding the need to create one manually via StartImportTaskRequest.builder()

      Parameters:
      startImportTaskRequest - A Consumer that will call methods on StartImportTaskRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartImportTask operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopGraph

      default CompletableFuture<StopGraphResponse> stopGraph(StopGraphRequest stopGraphRequest)

      Stops the specific graph.

      Parameters:
      stopGraphRequest -
      Returns:
      A Java Future containing the result of the StopGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopGraph

      default CompletableFuture<StopGraphResponse> stopGraph(Consumer<StopGraphRequest.Builder> stopGraphRequest)

      Stops the specific graph.


      This is a convenience which creates an instance of the StopGraphRequest.Builder avoiding the need to create one manually via StopGraphRequest.builder()

      Parameters:
      stopGraphRequest - A Consumer that will call methods on StopGraphRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StopGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • tagResource

      default CompletableFuture<TagResourceResponse> tagResource(TagResourceRequest tagResourceRequest)

      Adds tags to the specified resource.

      Parameters:
      tagResourceRequest -
      Returns:
      A Java Future containing the result of the TagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • tagResource

      default CompletableFuture<TagResourceResponse> tagResource(Consumer<TagResourceRequest.Builder> tagResourceRequest)

      Adds tags to the specified resource.


      This is a convenience which creates an instance of the TagResourceRequest.Builder avoiding the need to create one manually via TagResourceRequest.builder()

      Parameters:
      tagResourceRequest - A Consumer that will call methods on TagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • untagResource

      default CompletableFuture<UntagResourceResponse> untagResource(UntagResourceRequest untagResourceRequest)

      Removes the specified tags from the specified resource.

      Parameters:
      untagResourceRequest -
      Returns:
      A Java Future containing the result of the UntagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • untagResource

      default CompletableFuture<UntagResourceResponse> untagResource(Consumer<UntagResourceRequest.Builder> untagResourceRequest)

      Removes the specified tags from the specified resource.


      This is a convenience which creates an instance of the UntagResourceRequest.Builder avoiding the need to create one manually via UntagResourceRequest.builder()

      Parameters:
      untagResourceRequest - A Consumer that will call methods on UntagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UntagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateGraph

      default CompletableFuture<UpdateGraphResponse> updateGraph(UpdateGraphRequest updateGraphRequest)

      Updates the configuration of a specified Neptune Analytics graph

      Parameters:
      updateGraphRequest -
      Returns:
      A Java Future containing the result of the UpdateGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateGraph

      default CompletableFuture<UpdateGraphResponse> updateGraph(Consumer<UpdateGraphRequest.Builder> updateGraphRequest)

      Updates the configuration of a specified Neptune Analytics graph


      This is a convenience which creates an instance of the UpdateGraphRequest.Builder avoiding the need to create one manually via UpdateGraphRequest.builder()

      Parameters:
      updateGraphRequest - A Consumer that will call methods on UpdateGraphRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateGraph operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The exception was interrupted by throttling.
      • ValidationException A resource could not be validated.
      • ConflictException Raised when a conflict is encountered.
      • InternalServerException A failure occurred on the server.
      • ResourceNotFoundException A specified resource could not be located.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • NeptuneGraphException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • waiter

      default NeptuneGraphAsyncWaiter waiter()
      Create an instance of NeptuneGraphAsyncWaiter using this client.

      Waiters created via this method are managed by the SDK and resources will be released when the service client is closed.

      Returns:
      an instance of NeptuneGraphAsyncWaiter

    • serviceClientConfiguration

      default NeptuneGraphServiceClientConfiguration serviceClientConfiguration()
      Description copied from interface: SdkClient
      The SDK service client configuration exposes client settings to the user, e.g., ClientOverrideConfiguration
      Specified by:
      serviceClientConfiguration in interface AwsClient
      Specified by:
      serviceClientConfiguration in interface SdkClient
      Returns:
      SdkServiceClientConfiguration

    • create

      static NeptuneGraphAsyncClient create()
      Create a NeptuneGraphAsyncClient with the region loaded from the DefaultAwsRegionProviderChain and credentials loaded from the DefaultCredentialsProvider.

    • builder

      static NeptuneGraphAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a NeptuneGraphAsyncClient.