AmazonNeptunedataAsyncClient (AWS SDK for Java

java.lang.Object
- com.amazonaws.AmazonWebServiceClient
- - com.amazonaws.services.neptunedata.AmazonNeptunedataClient
  - - com.amazonaws.services.neptunedata.AmazonNeptunedataAsyncClient

All Implemented Interfaces:

AmazonNeptunedata, AmazonNeptunedataAsync
```
@ThreadSafe
 @Generated(value="com.amazonaws:aws-java-sdk-code-generator")
public class AmazonNeptunedataAsyncClient
extends AmazonNeptunedataClient
implements AmazonNeptunedataAsync
```
Client for accessing Amazon NeptuneData asynchronously. Each asynchronous method will return a Java Future object representing the asynchronous operation; overloads which accept an AsyncHandler can be used to receive notification when an asynchronous operation completes.

Neptune Data API
The Amazon Neptune data API provides SDK support for more than 40 of Neptune's data operations, including data loading, query execution, data inquiry, and machine learning. It supports the Gremlin and openCypher query languages, and is available in all SDK languages. It automatically signs API requests and greatly simplifies integrating Neptune into your applications.

Field Summary
- Fields inherited from class com.amazonaws.AmazonWebServiceClient
  LOGGING_AWS_REQUEST_METRIC
- Fields inherited from interface com.amazonaws.services.neptunedata.AmazonNeptunedata
  ENDPOINT_PREFIX

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static AmazonNeptunedataAsyncClientBuilder`	`asyncBuilder()`
`Future<CancelGremlinQueryResult>`	`cancelGremlinQueryAsync(CancelGremlinQueryRequest request)` Cancels a Gremlin query.
`Future<CancelGremlinQueryResult>`	`cancelGremlinQueryAsync(CancelGremlinQueryRequest request, AsyncHandler<CancelGremlinQueryRequest,CancelGremlinQueryResult> asyncHandler)` Cancels a Gremlin query.
`Future<CancelLoaderJobResult>`	`cancelLoaderJobAsync(CancelLoaderJobRequest request)` Cancels a specified load job.
`Future<CancelLoaderJobResult>`	`cancelLoaderJobAsync(CancelLoaderJobRequest request, AsyncHandler<CancelLoaderJobRequest,CancelLoaderJobResult> asyncHandler)` Cancels a specified load job.
`Future<CancelMLDataProcessingJobResult>`	`cancelMLDataProcessingJobAsync(CancelMLDataProcessingJobRequest request)` Cancels a Neptune ML data processing job.
`Future<CancelMLDataProcessingJobResult>`	`cancelMLDataProcessingJobAsync(CancelMLDataProcessingJobRequest request, AsyncHandler<CancelMLDataProcessingJobRequest,CancelMLDataProcessingJobResult> asyncHandler)` Cancels a Neptune ML data processing job.
`Future<CancelMLModelTrainingJobResult>`	`cancelMLModelTrainingJobAsync(CancelMLModelTrainingJobRequest request)` Cancels a Neptune ML model training job.
`Future<CancelMLModelTrainingJobResult>`	`cancelMLModelTrainingJobAsync(CancelMLModelTrainingJobRequest request, AsyncHandler<CancelMLModelTrainingJobRequest,CancelMLModelTrainingJobResult> asyncHandler)` Cancels a Neptune ML model training job.
`Future<CancelMLModelTransformJobResult>`	`cancelMLModelTransformJobAsync(CancelMLModelTransformJobRequest request)` Cancels a specified model transform job.
`Future<CancelMLModelTransformJobResult>`	`cancelMLModelTransformJobAsync(CancelMLModelTransformJobRequest request, AsyncHandler<CancelMLModelTransformJobRequest,CancelMLModelTransformJobResult> asyncHandler)` Cancels a specified model transform job.
`Future<CancelOpenCypherQueryResult>`	`cancelOpenCypherQueryAsync(CancelOpenCypherQueryRequest request)` Cancels a specified openCypher query.
`Future<CancelOpenCypherQueryResult>`	`cancelOpenCypherQueryAsync(CancelOpenCypherQueryRequest request, AsyncHandler<CancelOpenCypherQueryRequest,CancelOpenCypherQueryResult> asyncHandler)` Cancels a specified openCypher query.
`Future<CreateMLEndpointResult>`	`createMLEndpointAsync(CreateMLEndpointRequest request)` Creates a new Neptune ML inference endpoint that lets you query one specific model that the model-training process constructed.
`Future<CreateMLEndpointResult>`	`createMLEndpointAsync(CreateMLEndpointRequest request, AsyncHandler<CreateMLEndpointRequest,CreateMLEndpointResult> asyncHandler)` Creates a new Neptune ML inference endpoint that lets you query one specific model that the model-training process constructed.
`Future<DeleteMLEndpointResult>`	`deleteMLEndpointAsync(DeleteMLEndpointRequest request)` Cancels the creation of a Neptune ML inference endpoint.
`Future<DeleteMLEndpointResult>`	`deleteMLEndpointAsync(DeleteMLEndpointRequest request, AsyncHandler<DeleteMLEndpointRequest,DeleteMLEndpointResult> asyncHandler)` Cancels the creation of a Neptune ML inference endpoint.
`Future<DeletePropertygraphStatisticsResult>`	`deletePropertygraphStatisticsAsync(DeletePropertygraphStatisticsRequest request)` Deletes statistics for Gremlin and openCypher (property graph) data.
`Future<DeletePropertygraphStatisticsResult>`	`deletePropertygraphStatisticsAsync(DeletePropertygraphStatisticsRequest request, AsyncHandler<DeletePropertygraphStatisticsRequest,DeletePropertygraphStatisticsResult> asyncHandler)` Deletes statistics for Gremlin and openCypher (property graph) data.
`Future<DeleteSparqlStatisticsResult>`	`deleteSparqlStatisticsAsync(DeleteSparqlStatisticsRequest request)` Deletes SPARQL statistics
`Future<DeleteSparqlStatisticsResult>`	`deleteSparqlStatisticsAsync(DeleteSparqlStatisticsRequest request, AsyncHandler<DeleteSparqlStatisticsRequest,DeleteSparqlStatisticsResult> asyncHandler)` Deletes SPARQL statistics
`Future<ExecuteFastResetResult>`	`executeFastResetAsync(ExecuteFastResetRequest request)` The fast reset REST API lets you reset a Neptune graph quicky and easily, removing all of its data.
`Future<ExecuteFastResetResult>`	`executeFastResetAsync(ExecuteFastResetRequest request, AsyncHandler<ExecuteFastResetRequest,ExecuteFastResetResult> asyncHandler)` The fast reset REST API lets you reset a Neptune graph quicky and easily, removing all of its data.
`Future<ExecuteGremlinExplainQueryResult>`	`executeGremlinExplainQueryAsync(ExecuteGremlinExplainQueryRequest request)` Executes a Gremlin Explain query.
`Future<ExecuteGremlinExplainQueryResult>`	`executeGremlinExplainQueryAsync(ExecuteGremlinExplainQueryRequest request, AsyncHandler<ExecuteGremlinExplainQueryRequest,ExecuteGremlinExplainQueryResult> asyncHandler)` Executes a Gremlin Explain query.
`Future<ExecuteGremlinProfileQueryResult>`	`executeGremlinProfileQueryAsync(ExecuteGremlinProfileQueryRequest request)` Executes a Gremlin Profile query, which runs a specified traversal, collects various metrics about the run, and produces a profile report as output.
`Future<ExecuteGremlinProfileQueryResult>`	`executeGremlinProfileQueryAsync(ExecuteGremlinProfileQueryRequest request, AsyncHandler<ExecuteGremlinProfileQueryRequest,ExecuteGremlinProfileQueryResult> asyncHandler)` Executes a Gremlin Profile query, which runs a specified traversal, collects various metrics about the run, and produces a profile report as output.
`Future<ExecuteGremlinQueryResult>`	`executeGremlinQueryAsync(ExecuteGremlinQueryRequest request)` This commands executes a Gremlin query.
`Future<ExecuteGremlinQueryResult>`	`executeGremlinQueryAsync(ExecuteGremlinQueryRequest request, AsyncHandler<ExecuteGremlinQueryRequest,ExecuteGremlinQueryResult> asyncHandler)` This commands executes a Gremlin query.
`Future<ExecuteOpenCypherExplainQueryResult>`	`executeOpenCypherExplainQueryAsync(ExecuteOpenCypherExplainQueryRequest request)` Executes an openCypher `explain` request.
`Future<ExecuteOpenCypherExplainQueryResult>`	`executeOpenCypherExplainQueryAsync(ExecuteOpenCypherExplainQueryRequest request, AsyncHandler<ExecuteOpenCypherExplainQueryRequest,ExecuteOpenCypherExplainQueryResult> asyncHandler)` Executes an openCypher `explain` request.
`Future<GetEngineStatusResult>`	`getEngineStatusAsync(GetEngineStatusRequest request)` Retrieves the status of the graph database on the host.
`Future<GetEngineStatusResult>`	`getEngineStatusAsync(GetEngineStatusRequest request, AsyncHandler<GetEngineStatusRequest,GetEngineStatusResult> asyncHandler)` Retrieves the status of the graph database on the host.
`ExecutorService`	`getExecutorService()` Returns the executor service used by this client to execute async requests.
`Future<GetGremlinQueryStatusResult>`	`getGremlinQueryStatusAsync(GetGremlinQueryStatusRequest request)` Gets the status of a specified Gremlin query.
`Future<GetGremlinQueryStatusResult>`	`getGremlinQueryStatusAsync(GetGremlinQueryStatusRequest request, AsyncHandler<GetGremlinQueryStatusRequest,GetGremlinQueryStatusResult> asyncHandler)` Gets the status of a specified Gremlin query.
`Future<GetMLDataProcessingJobResult>`	`getMLDataProcessingJobAsync(GetMLDataProcessingJobRequest request)` Retrieves information about a specified data processing job.
`Future<GetMLDataProcessingJobResult>`	`getMLDataProcessingJobAsync(GetMLDataProcessingJobRequest request, AsyncHandler<GetMLDataProcessingJobRequest,GetMLDataProcessingJobResult> asyncHandler)` Retrieves information about a specified data processing job.
`Future<GetMLEndpointResult>`	`getMLEndpointAsync(GetMLEndpointRequest request)` Retrieves details about an inference endpoint.
`Future<GetMLEndpointResult>`	`getMLEndpointAsync(GetMLEndpointRequest request, AsyncHandler<GetMLEndpointRequest,GetMLEndpointResult> asyncHandler)` Retrieves details about an inference endpoint.
`Future<GetMLModelTrainingJobResult>`	`getMLModelTrainingJobAsync(GetMLModelTrainingJobRequest request)` Retrieves information about a Neptune ML model training job.
`Future<GetMLModelTrainingJobResult>`	`getMLModelTrainingJobAsync(GetMLModelTrainingJobRequest request, AsyncHandler<GetMLModelTrainingJobRequest,GetMLModelTrainingJobResult> asyncHandler)` Retrieves information about a Neptune ML model training job.
`Future<GetMLModelTransformJobResult>`	`getMLModelTransformJobAsync(GetMLModelTransformJobRequest request)` Gets information about a specified model transform job.
`Future<GetMLModelTransformJobResult>`	`getMLModelTransformJobAsync(GetMLModelTransformJobRequest request, AsyncHandler<GetMLModelTransformJobRequest,GetMLModelTransformJobResult> asyncHandler)` Gets information about a specified model transform job.
`Future<GetOpenCypherQueryStatusResult>`	`getOpenCypherQueryStatusAsync(GetOpenCypherQueryStatusRequest request)` Retrieves the status of a specified openCypher query.
`Future<GetOpenCypherQueryStatusResult>`	`getOpenCypherQueryStatusAsync(GetOpenCypherQueryStatusRequest request, AsyncHandler<GetOpenCypherQueryStatusRequest,GetOpenCypherQueryStatusResult> asyncHandler)` Retrieves the status of a specified openCypher query.
`Future<GetPropertygraphStatisticsResult>`	`getPropertygraphStatisticsAsync(GetPropertygraphStatisticsRequest request)` Gets property graph statistics (Gremlin and openCypher).
`Future<GetPropertygraphStatisticsResult>`	`getPropertygraphStatisticsAsync(GetPropertygraphStatisticsRequest request, AsyncHandler<GetPropertygraphStatisticsRequest,GetPropertygraphStatisticsResult> asyncHandler)` Gets property graph statistics (Gremlin and openCypher).
`Future<GetPropertygraphSummaryResult>`	`getPropertygraphSummaryAsync(GetPropertygraphSummaryRequest request)` Gets a graph summary for a property graph.
`Future<GetPropertygraphSummaryResult>`	`getPropertygraphSummaryAsync(GetPropertygraphSummaryRequest request, AsyncHandler<GetPropertygraphSummaryRequest,GetPropertygraphSummaryResult> asyncHandler)` Gets a graph summary for a property graph.
`Future<GetRDFGraphSummaryResult>`	`getRDFGraphSummaryAsync(GetRDFGraphSummaryRequest request)` Gets a graph summary for an RDF graph.
`Future<GetRDFGraphSummaryResult>`	`getRDFGraphSummaryAsync(GetRDFGraphSummaryRequest request, AsyncHandler<GetRDFGraphSummaryRequest,GetRDFGraphSummaryResult> asyncHandler)` Gets a graph summary for an RDF graph.
`Future<GetSparqlStatisticsResult>`	`getSparqlStatisticsAsync(GetSparqlStatisticsRequest request)` Gets RDF statistics (SPARQL).
`Future<GetSparqlStatisticsResult>`	`getSparqlStatisticsAsync(GetSparqlStatisticsRequest request, AsyncHandler<GetSparqlStatisticsRequest,GetSparqlStatisticsResult> asyncHandler)` Gets RDF statistics (SPARQL).
`Future<GetSparqlStreamResult>`	`getSparqlStreamAsync(GetSparqlStreamRequest request)` Gets a stream for an RDF graph.
`Future<GetSparqlStreamResult>`	`getSparqlStreamAsync(GetSparqlStreamRequest request, AsyncHandler<GetSparqlStreamRequest,GetSparqlStreamResult> asyncHandler)` Gets a stream for an RDF graph.
`Future<ListGremlinQueriesResult>`	`listGremlinQueriesAsync(ListGremlinQueriesRequest request)` Lists active Gremlin queries.
`Future<ListGremlinQueriesResult>`	`listGremlinQueriesAsync(ListGremlinQueriesRequest request, AsyncHandler<ListGremlinQueriesRequest,ListGremlinQueriesResult> asyncHandler)` Lists active Gremlin queries.
`Future<ListLoaderJobsResult>`	`listLoaderJobsAsync(ListLoaderJobsRequest request)` Retrieves a list of the `loadIds` for all active loader jobs.
`Future<ListLoaderJobsResult>`	`listLoaderJobsAsync(ListLoaderJobsRequest request, AsyncHandler<ListLoaderJobsRequest,ListLoaderJobsResult> asyncHandler)` Retrieves a list of the `loadIds` for all active loader jobs.
`Future<ListMLDataProcessingJobsResult>`	`listMLDataProcessingJobsAsync(ListMLDataProcessingJobsRequest request)` Returns a list of Neptune ML data processing jobs.
`Future<ListMLDataProcessingJobsResult>`	`listMLDataProcessingJobsAsync(ListMLDataProcessingJobsRequest request, AsyncHandler<ListMLDataProcessingJobsRequest,ListMLDataProcessingJobsResult> asyncHandler)` Returns a list of Neptune ML data processing jobs.
`Future<ListMLEndpointsResult>`	`listMLEndpointsAsync(ListMLEndpointsRequest request)` Lists existing inference endpoints.
`Future<ListMLEndpointsResult>`	`listMLEndpointsAsync(ListMLEndpointsRequest request, AsyncHandler<ListMLEndpointsRequest,ListMLEndpointsResult> asyncHandler)` Lists existing inference endpoints.
`Future<ListMLModelTrainingJobsResult>`	`listMLModelTrainingJobsAsync(ListMLModelTrainingJobsRequest request)` Lists Neptune ML model-training jobs.
`Future<ListMLModelTrainingJobsResult>`	`listMLModelTrainingJobsAsync(ListMLModelTrainingJobsRequest request, AsyncHandler<ListMLModelTrainingJobsRequest,ListMLModelTrainingJobsResult> asyncHandler)` Lists Neptune ML model-training jobs.
`Future<ListMLModelTransformJobsResult>`	`listMLModelTransformJobsAsync(ListMLModelTransformJobsRequest request)` Returns a list of model transform job IDs.
`Future<ListMLModelTransformJobsResult>`	`listMLModelTransformJobsAsync(ListMLModelTransformJobsRequest request, AsyncHandler<ListMLModelTransformJobsRequest,ListMLModelTransformJobsResult> asyncHandler)` Returns a list of model transform job IDs.
`Future<ListOpenCypherQueriesResult>`	`listOpenCypherQueriesAsync(ListOpenCypherQueriesRequest request)` Lists active openCypher queries.
`Future<ListOpenCypherQueriesResult>`	`listOpenCypherQueriesAsync(ListOpenCypherQueriesRequest request, AsyncHandler<ListOpenCypherQueriesRequest,ListOpenCypherQueriesResult> asyncHandler)` Lists active openCypher queries.
`Future<ManagePropertygraphStatisticsResult>`	`managePropertygraphStatisticsAsync(ManagePropertygraphStatisticsRequest request)` Manages the generation and use of property graph statistics.
`Future<ManagePropertygraphStatisticsResult>`	`managePropertygraphStatisticsAsync(ManagePropertygraphStatisticsRequest request, AsyncHandler<ManagePropertygraphStatisticsRequest,ManagePropertygraphStatisticsResult> asyncHandler)` Manages the generation and use of property graph statistics.
`Future<ManageSparqlStatisticsResult>`	`manageSparqlStatisticsAsync(ManageSparqlStatisticsRequest request)` Manages the generation and use of RDF graph statistics.
`Future<ManageSparqlStatisticsResult>`	`manageSparqlStatisticsAsync(ManageSparqlStatisticsRequest request, AsyncHandler<ManageSparqlStatisticsRequest,ManageSparqlStatisticsResult> asyncHandler)` Manages the generation and use of RDF graph statistics.
`void`	`shutdown()` Shuts down the client, releasing all managed resources.
`Future<StartLoaderJobResult>`	`startLoaderJobAsync(StartLoaderJobRequest request)` Starts a Neptune bulk loader job to load data from an Amazon S3 bucket into a Neptune DB instance.
`Future<StartLoaderJobResult>`	`startLoaderJobAsync(StartLoaderJobRequest request, AsyncHandler<StartLoaderJobRequest,StartLoaderJobResult> asyncHandler)` Starts a Neptune bulk loader job to load data from an Amazon S3 bucket into a Neptune DB instance.
`Future<StartMLDataProcessingJobResult>`	`startMLDataProcessingJobAsync(StartMLDataProcessingJobRequest request)` Creates a new Neptune ML data processing job for processing the graph data exported from Neptune for training.
`Future<StartMLDataProcessingJobResult>`	`startMLDataProcessingJobAsync(StartMLDataProcessingJobRequest request, AsyncHandler<StartMLDataProcessingJobRequest,StartMLDataProcessingJobResult> asyncHandler)` Creates a new Neptune ML data processing job for processing the graph data exported from Neptune for training.
`Future<StartMLModelTrainingJobResult>`	`startMLModelTrainingJobAsync(StartMLModelTrainingJobRequest request)` Creates a new Neptune ML model training job.
`Future<StartMLModelTrainingJobResult>`	`startMLModelTrainingJobAsync(StartMLModelTrainingJobRequest request, AsyncHandler<StartMLModelTrainingJobRequest,StartMLModelTrainingJobResult> asyncHandler)` Creates a new Neptune ML model training job.
`Future<StartMLModelTransformJobResult>`	`startMLModelTransformJobAsync(StartMLModelTransformJobRequest request)` Creates a new model transform job.
`Future<StartMLModelTransformJobResult>`	`startMLModelTransformJobAsync(StartMLModelTransformJobRequest request, AsyncHandler<StartMLModelTransformJobRequest,StartMLModelTransformJobResult> asyncHandler)` Creates a new model transform job.

Methods inherited from class com.amazonaws.services.neptunedata.AmazonNeptunedataClient
builder, cancelGremlinQuery, cancelLoaderJob, cancelMLDataProcessingJob, cancelMLModelTrainingJob, cancelMLModelTransformJob, cancelOpenCypherQuery, createMLEndpoint, deleteMLEndpoint, deletePropertygraphStatistics, deleteSparqlStatistics, executeFastReset, executeGremlinExplainQuery, executeGremlinProfileQuery, executeGremlinQuery, executeOpenCypherExplainQuery, getCachedResponseMetadata, getEngineStatus, getGremlinQueryStatus, getMLDataProcessingJob, getMLEndpoint, getMLModelTrainingJob, getMLModelTransformJob, getOpenCypherQueryStatus, getPropertygraphStatistics, getPropertygraphSummary, getRDFGraphSummary, getSparqlStatistics, getSparqlStream, listGremlinQueries, listLoaderJobs, listMLDataProcessingJobs, listMLEndpoints, listMLModelTrainingJobs, listMLModelTransformJobs, listOpenCypherQueries, managePropertygraphStatistics, manageSparqlStatistics, startLoaderJob, startMLDataProcessingJob, startMLModelTrainingJob, startMLModelTransformJob

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.amazonaws.services.neptunedata.AmazonNeptunedata
cancelGremlinQuery, cancelLoaderJob, cancelMLDataProcessingJob, cancelMLModelTrainingJob, cancelMLModelTransformJob, cancelOpenCypherQuery, createMLEndpoint, deleteMLEndpoint, deletePropertygraphStatistics, deleteSparqlStatistics, executeFastReset, executeGremlinExplainQuery, executeGremlinProfileQuery, executeGremlinQuery, executeOpenCypherExplainQuery, getCachedResponseMetadata, getEngineStatus, getGremlinQueryStatus, getMLDataProcessingJob, getMLEndpoint, getMLModelTrainingJob, getMLModelTransformJob, getOpenCypherQueryStatus, getPropertygraphStatistics, getPropertygraphSummary, getRDFGraphSummary, getSparqlStatistics, getSparqlStream, listGremlinQueries, listLoaderJobs, listMLDataProcessingJobs, listMLEndpoints, listMLModelTrainingJobs, listMLModelTransformJobs, listOpenCypherQueries, managePropertygraphStatistics, manageSparqlStatistics, startLoaderJob, startMLDataProcessingJob, startMLModelTrainingJob, startMLModelTransformJob

- Method Detail
  - asyncBuilder
```
public static AmazonNeptunedataAsyncClientBuilder asyncBuilder()
```
  - getExecutorService
```
public ExecutorService getExecutorService()
```
    Returns the executor service used by this client to execute async requests.
    
    Returns:
    
    The executor service used by this client to execute async requests.
  - cancelGremlinQueryAsync
```
public Future<CancelGremlinQueryResult> cancelGremlinQueryAsync(CancelGremlinQueryRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a Gremlin query. See Gremlin query cancellation for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelQuery IAM action in that cluster.
    
    Specified by:
    
    cancelGremlinQueryAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the CancelGremlinQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelGremlinQueryAsync
```
public Future<CancelGremlinQueryResult> cancelGremlinQueryAsync(CancelGremlinQueryRequest request,
                                                                AsyncHandler<CancelGremlinQueryRequest,CancelGremlinQueryResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a Gremlin query. See Gremlin query cancellation for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelQuery IAM action in that cluster.
    
    Specified by:
    
    cancelGremlinQueryAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the CancelGremlinQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelLoaderJobAsync
```
public Future<CancelLoaderJobResult> cancelLoaderJobAsync(CancelLoaderJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a specified load job. This is an HTTP DELETE request. See Neptune Loader Get-Status API for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelLoaderJob IAM action in that cluster..
    
    Specified by:
    
    cancelLoaderJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the CancelLoaderJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelLoaderJobAsync
```
public Future<CancelLoaderJobResult> cancelLoaderJobAsync(CancelLoaderJobRequest request,
                                                          AsyncHandler<CancelLoaderJobRequest,CancelLoaderJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a specified load job. This is an HTTP DELETE request. See Neptune Loader Get-Status API for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelLoaderJob IAM action in that cluster..
    
    Specified by:
    
    cancelLoaderJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the CancelLoaderJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelMLDataProcessingJobAsync
```
public Future<CancelMLDataProcessingJobResult> cancelMLDataProcessingJobAsync(CancelMLDataProcessingJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a Neptune ML data processing job. See The dataprocessing command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLDataProcessingJob IAM action in that cluster.
    
    Specified by:
    
    cancelMLDataProcessingJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the CancelMLDataProcessingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelMLDataProcessingJobAsync
```
public Future<CancelMLDataProcessingJobResult> cancelMLDataProcessingJobAsync(CancelMLDataProcessingJobRequest request,
                                                                              AsyncHandler<CancelMLDataProcessingJobRequest,CancelMLDataProcessingJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a Neptune ML data processing job. See The dataprocessing command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLDataProcessingJob IAM action in that cluster.
    
    Specified by:
    
    cancelMLDataProcessingJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the CancelMLDataProcessingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelMLModelTrainingJobAsync
```
public Future<CancelMLModelTrainingJobResult> cancelMLModelTrainingJobAsync(CancelMLModelTrainingJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a Neptune ML model training job. See Model training using the modeltraining command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLModelTrainingJob IAM action in that cluster.
    
    Specified by:
    
    cancelMLModelTrainingJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the CancelMLModelTrainingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelMLModelTrainingJobAsync
```
public Future<CancelMLModelTrainingJobResult> cancelMLModelTrainingJobAsync(CancelMLModelTrainingJobRequest request,
                                                                            AsyncHandler<CancelMLModelTrainingJobRequest,CancelMLModelTrainingJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a Neptune ML model training job. See Model training using the modeltraining command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLModelTrainingJob IAM action in that cluster.
    
    Specified by:
    
    cancelMLModelTrainingJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the CancelMLModelTrainingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelMLModelTransformJobAsync
```
public Future<CancelMLModelTransformJobResult> cancelMLModelTransformJobAsync(CancelMLModelTransformJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a specified model transform job. See Use a trained model to generate new model artifacts.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLModelTransformJob IAM action in that cluster.
    
    Specified by:
    
    cancelMLModelTransformJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the CancelMLModelTransformJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelMLModelTransformJobAsync
```
public Future<CancelMLModelTransformJobResult> cancelMLModelTransformJobAsync(CancelMLModelTransformJobRequest request,
                                                                              AsyncHandler<CancelMLModelTransformJobRequest,CancelMLModelTransformJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a specified model transform job. See Use a trained model to generate new model artifacts.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLModelTransformJob IAM action in that cluster.
    
    Specified by:
    
    cancelMLModelTransformJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the CancelMLModelTransformJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelOpenCypherQueryAsync
```
public Future<CancelOpenCypherQueryResult> cancelOpenCypherQueryAsync(CancelOpenCypherQueryRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a specified openCypher query. See Neptune openCypher status endpoint for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelQuery IAM action in that cluster.
    
    Specified by:
    
    cancelOpenCypherQueryAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the CancelOpenCypherQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - cancelOpenCypherQueryAsync
```
public Future<CancelOpenCypherQueryResult> cancelOpenCypherQueryAsync(CancelOpenCypherQueryRequest request,
                                                                      AsyncHandler<CancelOpenCypherQueryRequest,CancelOpenCypherQueryResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels a specified openCypher query. See Neptune openCypher status endpoint for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelQuery IAM action in that cluster.
    
    Specified by:
    
    cancelOpenCypherQueryAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the CancelOpenCypherQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - createMLEndpointAsync
```
public Future<CreateMLEndpointResult> createMLEndpointAsync(CreateMLEndpointRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Creates a new Neptune ML inference endpoint that lets you query one specific model that the model-training process constructed. See Managing inference endpoints using the endpoints command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CreateMLEndpoint IAM action in that cluster.
    
    Specified by:
    
    createMLEndpointAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the CreateMLEndpoint operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - createMLEndpointAsync
```
public Future<CreateMLEndpointResult> createMLEndpointAsync(CreateMLEndpointRequest request,
                                                            AsyncHandler<CreateMLEndpointRequest,CreateMLEndpointResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Creates a new Neptune ML inference endpoint that lets you query one specific model that the model-training process constructed. See Managing inference endpoints using the endpoints command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CreateMLEndpoint IAM action in that cluster.
    
    Specified by:
    
    createMLEndpointAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the CreateMLEndpoint operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - deleteMLEndpointAsync
```
public Future<DeleteMLEndpointResult> deleteMLEndpointAsync(DeleteMLEndpointRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels the creation of a Neptune ML inference endpoint. See Managing inference endpoints using the endpoints command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteMLEndpoint IAM action in that cluster.
    
    Specified by:
    
    deleteMLEndpointAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the DeleteMLEndpoint operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - deleteMLEndpointAsync
```
public Future<DeleteMLEndpointResult> deleteMLEndpointAsync(DeleteMLEndpointRequest request,
                                                            AsyncHandler<DeleteMLEndpointRequest,DeleteMLEndpointResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Cancels the creation of a Neptune ML inference endpoint. See Managing inference endpoints using the endpoints command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteMLEndpoint IAM action in that cluster.
    
    Specified by:
    
    deleteMLEndpointAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the DeleteMLEndpoint operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - deletePropertygraphStatisticsAsync
```
public Future<DeletePropertygraphStatisticsResult> deletePropertygraphStatisticsAsync(DeletePropertygraphStatisticsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Deletes statistics for Gremlin and openCypher (property graph) data.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteStatistics IAM action in that cluster.
    
    Specified by:
    
    deletePropertygraphStatisticsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the DeletePropertygraphStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - deletePropertygraphStatisticsAsync
```
public Future<DeletePropertygraphStatisticsResult> deletePropertygraphStatisticsAsync(DeletePropertygraphStatisticsRequest request,
                                                                                      AsyncHandler<DeletePropertygraphStatisticsRequest,DeletePropertygraphStatisticsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Deletes statistics for Gremlin and openCypher (property graph) data.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteStatistics IAM action in that cluster.
    
    Specified by:
    
    deletePropertygraphStatisticsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the DeletePropertygraphStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - deleteSparqlStatisticsAsync
```
public Future<DeleteSparqlStatisticsResult> deleteSparqlStatisticsAsync(DeleteSparqlStatisticsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Deletes SPARQL statistics
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteStatistics IAM action in that cluster.
    
    Specified by:
    
    deleteSparqlStatisticsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the DeleteSparqlStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - deleteSparqlStatisticsAsync
```
public Future<DeleteSparqlStatisticsResult> deleteSparqlStatisticsAsync(DeleteSparqlStatisticsRequest request,
                                                                        AsyncHandler<DeleteSparqlStatisticsRequest,DeleteSparqlStatisticsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Deletes SPARQL statistics
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteStatistics IAM action in that cluster.
    
    Specified by:
    
    deleteSparqlStatisticsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the DeleteSparqlStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeFastResetAsync
```
public Future<ExecuteFastResetResult> executeFastResetAsync(ExecuteFastResetRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    The fast reset REST API lets you reset a Neptune graph quicky and easily, removing all of its data.
    
    Neptune fast reset is a two-step process. First you call ExecuteFastReset with action set to initiateDatabaseReset. This returns a UUID token which you then include when calling ExecuteFastReset again with action set to performDatabaseReset. See Empty an Amazon Neptune DB cluster using the fast reset API.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ResetDatabase IAM action in that cluster.
    
    Specified by:
    
    executeFastResetAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ExecuteFastReset operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeFastResetAsync
```
public Future<ExecuteFastResetResult> executeFastResetAsync(ExecuteFastResetRequest request,
                                                            AsyncHandler<ExecuteFastResetRequest,ExecuteFastResetResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    The fast reset REST API lets you reset a Neptune graph quicky and easily, removing all of its data.
    
    Neptune fast reset is a two-step process. First you call ExecuteFastReset with action set to initiateDatabaseReset. This returns a UUID token which you then include when calling ExecuteFastReset again with action set to performDatabaseReset. See Empty an Amazon Neptune DB cluster using the fast reset API.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ResetDatabase IAM action in that cluster.
    
    Specified by:
    
    executeFastResetAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ExecuteFastReset operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeGremlinExplainQueryAsync
```
public Future<ExecuteGremlinExplainQueryResult> executeGremlinExplainQueryAsync(ExecuteGremlinExplainQueryRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    Executes a Gremlin Explain query.
    
    Amazon Neptune has added a Gremlin feature named explain that provides is a self-service tool for understanding the execution approach being taken by the Neptune engine for the query. You invoke it by adding an explain parameter to an HTTP call that submits a Gremlin query.
    
    The explain feature provides information about the logical structure of query execution plans. You can use this information to identify potential evaluation and execution bottlenecks and to tune your query, as explained in Tuning Gremlin queries. You can also use query hints to improve query execution plans.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, 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:
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    Specified by:
    
    executeGremlinExplainQueryAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ExecuteGremlinExplainQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeGremlinExplainQueryAsync
```
public Future<ExecuteGremlinExplainQueryResult> executeGremlinExplainQueryAsync(ExecuteGremlinExplainQueryRequest request,
                                                                                AsyncHandler<ExecuteGremlinExplainQueryRequest,ExecuteGremlinExplainQueryResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    Executes a Gremlin Explain query.
    
    Amazon Neptune has added a Gremlin feature named explain that provides is a self-service tool for understanding the execution approach being taken by the Neptune engine for the query. You invoke it by adding an explain parameter to an HTTP call that submits a Gremlin query.
    
    The explain feature provides information about the logical structure of query execution plans. You can use this information to identify potential evaluation and execution bottlenecks and to tune your query, as explained in Tuning Gremlin queries. You can also use query hints to improve query execution plans.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, 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:
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    Specified by:
    
    executeGremlinExplainQueryAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ExecuteGremlinExplainQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeGremlinProfileQueryAsync
```
public Future<ExecuteGremlinProfileQueryResult> executeGremlinProfileQueryAsync(ExecuteGremlinProfileQueryRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Executes a Gremlin Profile query, which runs a specified traversal, collects various metrics about the run, and produces a profile report as output. See Gremlin profile API in Neptune for details.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ReadDataViaQuery IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    executeGremlinProfileQueryAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ExecuteGremlinProfileQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeGremlinProfileQueryAsync
```
public Future<ExecuteGremlinProfileQueryResult> executeGremlinProfileQueryAsync(ExecuteGremlinProfileQueryRequest request,
                                                                                AsyncHandler<ExecuteGremlinProfileQueryRequest,ExecuteGremlinProfileQueryResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Executes a Gremlin Profile query, which runs a specified traversal, collects various metrics about the run, and produces a profile report as output. See Gremlin profile API in Neptune for details.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ReadDataViaQuery IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    executeGremlinProfileQueryAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ExecuteGremlinProfileQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeGremlinQueryAsync
```
public Future<ExecuteGremlinQueryResult> executeGremlinQueryAsync(ExecuteGremlinQueryRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    This commands executes a Gremlin query. Amazon Neptune is compatible with Apache TinkerPop3 and Gremlin, so you can use the Gremlin traversal language to query the graph, as described under The Graph in the Apache TinkerPop3 documentation. More details can also be found in Accessing a Neptune graph with Gremlin.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that enables one of the following IAM actions in that cluster, depending on the query:
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    Specified by:
    
    executeGremlinQueryAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ExecuteGremlinQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeGremlinQueryAsync
```
public Future<ExecuteGremlinQueryResult> executeGremlinQueryAsync(ExecuteGremlinQueryRequest request,
                                                                  AsyncHandler<ExecuteGremlinQueryRequest,ExecuteGremlinQueryResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    This commands executes a Gremlin query. Amazon Neptune is compatible with Apache TinkerPop3 and Gremlin, so you can use the Gremlin traversal language to query the graph, as described under The Graph in the Apache TinkerPop3 documentation. More details can also be found in Accessing a Neptune graph with Gremlin.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that enables one of the following IAM actions in that cluster, depending on the query:
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    Specified by:
    
    executeGremlinQueryAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ExecuteGremlinQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeOpenCypherExplainQueryAsync
```
public Future<ExecuteOpenCypherExplainQueryResult> executeOpenCypherExplainQueryAsync(ExecuteOpenCypherExplainQueryRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Executes an openCypher explain request. See The openCypher explain feature for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ReadDataViaQuery IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    executeOpenCypherExplainQueryAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ExecuteOpenCypherExplainQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - executeOpenCypherExplainQueryAsync
```
public Future<ExecuteOpenCypherExplainQueryResult> executeOpenCypherExplainQueryAsync(ExecuteOpenCypherExplainQueryRequest request,
                                                                                      AsyncHandler<ExecuteOpenCypherExplainQueryRequest,ExecuteOpenCypherExplainQueryResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Executes an openCypher explain request. See The openCypher explain feature for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ReadDataViaQuery IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    executeOpenCypherExplainQueryAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ExecuteOpenCypherExplainQuery operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getEngineStatusAsync
```
public Future<GetEngineStatusResult> getEngineStatusAsync(GetEngineStatusRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves the status of the graph database on the host.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetEngineStatus IAM action in that cluster.
    
    Specified by:
    
    getEngineStatusAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetEngineStatus operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getEngineStatusAsync
```
public Future<GetEngineStatusResult> getEngineStatusAsync(GetEngineStatusRequest request,
                                                          AsyncHandler<GetEngineStatusRequest,GetEngineStatusResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves the status of the graph database on the host.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetEngineStatus IAM action in that cluster.
    
    Specified by:
    
    getEngineStatusAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetEngineStatus operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getGremlinQueryStatusAsync
```
public Future<GetGremlinQueryStatusResult> getGremlinQueryStatusAsync(GetGremlinQueryStatusRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets the status of a specified Gremlin query.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    getGremlinQueryStatusAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetGremlinQueryStatus operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getGremlinQueryStatusAsync
```
public Future<GetGremlinQueryStatusResult> getGremlinQueryStatusAsync(GetGremlinQueryStatusRequest request,
                                                                      AsyncHandler<GetGremlinQueryStatusRequest,GetGremlinQueryStatusResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets the status of a specified Gremlin query.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    getGremlinQueryStatusAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetGremlinQueryStatus operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getMLDataProcessingJobAsync
```
public Future<GetMLDataProcessingJobResult> getMLDataProcessingJobAsync(GetMLDataProcessingJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves information about a specified data processing job. See The dataprocessing command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:neptune-db:GetMLDataProcessingJobStatus IAM action in that cluster.
    
    Specified by:
    
    getMLDataProcessingJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetMLDataProcessingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getMLDataProcessingJobAsync
```
public Future<GetMLDataProcessingJobResult> getMLDataProcessingJobAsync(GetMLDataProcessingJobRequest request,
                                                                        AsyncHandler<GetMLDataProcessingJobRequest,GetMLDataProcessingJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves information about a specified data processing job. See The dataprocessing command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:neptune-db:GetMLDataProcessingJobStatus IAM action in that cluster.
    
    Specified by:
    
    getMLDataProcessingJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetMLDataProcessingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getMLEndpointAsync
```
public Future<GetMLEndpointResult> getMLEndpointAsync(GetMLEndpointRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves details about an inference endpoint. See Managing inference endpoints using the endpoints command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLEndpointStatus IAM action in that cluster.
    
    Specified by:
    
    getMLEndpointAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetMLEndpoint operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getMLEndpointAsync
```
public Future<GetMLEndpointResult> getMLEndpointAsync(GetMLEndpointRequest request,
                                                      AsyncHandler<GetMLEndpointRequest,GetMLEndpointResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves details about an inference endpoint. See Managing inference endpoints using the endpoints command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLEndpointStatus IAM action in that cluster.
    
    Specified by:
    
    getMLEndpointAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetMLEndpoint operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getMLModelTrainingJobAsync
```
public Future<GetMLModelTrainingJobResult> getMLModelTrainingJobAsync(GetMLModelTrainingJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves information about a Neptune ML model training job. See Model training using the modeltraining command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLModelTrainingJobStatus IAM action in that cluster.
    
    Specified by:
    
    getMLModelTrainingJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetMLModelTrainingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getMLModelTrainingJobAsync
```
public Future<GetMLModelTrainingJobResult> getMLModelTrainingJobAsync(GetMLModelTrainingJobRequest request,
                                                                      AsyncHandler<GetMLModelTrainingJobRequest,GetMLModelTrainingJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves information about a Neptune ML model training job. See Model training using the modeltraining command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLModelTrainingJobStatus IAM action in that cluster.
    
    Specified by:
    
    getMLModelTrainingJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetMLModelTrainingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getMLModelTransformJobAsync
```
public Future<GetMLModelTransformJobResult> getMLModelTransformJobAsync(GetMLModelTransformJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets information about a specified model transform job. See Use a trained model to generate new model artifacts.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLModelTransformJobStatus IAM action in that cluster.
    
    Specified by:
    
    getMLModelTransformJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetMLModelTransformJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getMLModelTransformJobAsync
```
public Future<GetMLModelTransformJobResult> getMLModelTransformJobAsync(GetMLModelTransformJobRequest request,
                                                                        AsyncHandler<GetMLModelTransformJobRequest,GetMLModelTransformJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets information about a specified model transform job. See Use a trained model to generate new model artifacts.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLModelTransformJobStatus IAM action in that cluster.
    
    Specified by:
    
    getMLModelTransformJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetMLModelTransformJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getOpenCypherQueryStatusAsync
```
public Future<GetOpenCypherQueryStatusResult> getOpenCypherQueryStatusAsync(GetOpenCypherQueryStatusRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves the status of a specified openCypher query.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    getOpenCypherQueryStatusAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetOpenCypherQueryStatus operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getOpenCypherQueryStatusAsync
```
public Future<GetOpenCypherQueryStatusResult> getOpenCypherQueryStatusAsync(GetOpenCypherQueryStatusRequest request,
                                                                            AsyncHandler<GetOpenCypherQueryStatusRequest,GetOpenCypherQueryStatusResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves the status of a specified openCypher query.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    getOpenCypherQueryStatusAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetOpenCypherQueryStatus operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getPropertygraphStatisticsAsync
```
public Future<GetPropertygraphStatisticsResult> getPropertygraphStatisticsAsync(GetPropertygraphStatisticsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets property graph statistics (Gremlin and openCypher).
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetStatisticsStatus IAM action in that cluster.
    
    Specified by:
    
    getPropertygraphStatisticsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetPropertygraphStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getPropertygraphStatisticsAsync
```
public Future<GetPropertygraphStatisticsResult> getPropertygraphStatisticsAsync(GetPropertygraphStatisticsRequest request,
                                                                                AsyncHandler<GetPropertygraphStatisticsRequest,GetPropertygraphStatisticsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets property graph statistics (Gremlin and openCypher).
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetStatisticsStatus IAM action in that cluster.
    
    Specified by:
    
    getPropertygraphStatisticsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetPropertygraphStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getPropertygraphSummaryAsync
```
public Future<GetPropertygraphSummaryResult> getPropertygraphSummaryAsync(GetPropertygraphSummaryRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets a graph summary for a property graph.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetGraphSummary IAM action in that cluster.
    
    Specified by:
    
    getPropertygraphSummaryAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetPropertygraphSummary operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getPropertygraphSummaryAsync
```
public Future<GetPropertygraphSummaryResult> getPropertygraphSummaryAsync(GetPropertygraphSummaryRequest request,
                                                                          AsyncHandler<GetPropertygraphSummaryRequest,GetPropertygraphSummaryResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets a graph summary for a property graph.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetGraphSummary IAM action in that cluster.
    
    Specified by:
    
    getPropertygraphSummaryAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetPropertygraphSummary operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getRDFGraphSummaryAsync
```
public Future<GetRDFGraphSummaryResult> getRDFGraphSummaryAsync(GetRDFGraphSummaryRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets a graph summary for an RDF graph.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetGraphSummary IAM action in that cluster.
    
    Specified by:
    
    getRDFGraphSummaryAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetRDFGraphSummary operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getRDFGraphSummaryAsync
```
public Future<GetRDFGraphSummaryResult> getRDFGraphSummaryAsync(GetRDFGraphSummaryRequest request,
                                                                AsyncHandler<GetRDFGraphSummaryRequest,GetRDFGraphSummaryResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets a graph summary for an RDF graph.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetGraphSummary IAM action in that cluster.
    
    Specified by:
    
    getRDFGraphSummaryAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetRDFGraphSummary operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getSparqlStatisticsAsync
```
public Future<GetSparqlStatisticsResult> getSparqlStatisticsAsync(GetSparqlStatisticsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets RDF statistics (SPARQL).
    
    Specified by:
    
    getSparqlStatisticsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetSparqlStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getSparqlStatisticsAsync
```
public Future<GetSparqlStatisticsResult> getSparqlStatisticsAsync(GetSparqlStatisticsRequest request,
                                                                  AsyncHandler<GetSparqlStatisticsRequest,GetSparqlStatisticsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets RDF statistics (SPARQL).
    
    Specified by:
    
    getSparqlStatisticsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetSparqlStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getSparqlStreamAsync
```
public Future<GetSparqlStreamResult> getSparqlStreamAsync(GetSparqlStreamRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets a stream for an RDF graph.
    
    With the Neptune Streams feature, you can generate a complete sequence of change-log entries that record every change made to your graph data as it happens. GetSparqlStream lets you collect these change-log entries for an RDF graph.
    
    The Neptune streams feature needs to be enabled on your Neptune DBcluster. To enable streams, set the neptune_streams DB cluster parameter to 1.
    
    See Capturing graph changes in real time using Neptune streams.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetStreamRecords IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:Sparql IAM condition key can be used in the policy document to restrict the use of SPARQL queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    getSparqlStreamAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the GetSparqlStream operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - getSparqlStreamAsync
```
public Future<GetSparqlStreamResult> getSparqlStreamAsync(GetSparqlStreamRequest request,
                                                          AsyncHandler<GetSparqlStreamRequest,GetSparqlStreamResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Gets a stream for an RDF graph.
    
    With the Neptune Streams feature, you can generate a complete sequence of change-log entries that record every change made to your graph data as it happens. GetSparqlStream lets you collect these change-log entries for an RDF graph.
    
    The Neptune streams feature needs to be enabled on your Neptune DBcluster. To enable streams, set the neptune_streams DB cluster parameter to 1.
    
    See Capturing graph changes in real time using Neptune streams.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetStreamRecords IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:Sparql IAM condition key can be used in the policy document to restrict the use of SPARQL queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    getSparqlStreamAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the GetSparqlStream operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listGremlinQueriesAsync
```
public Future<ListGremlinQueriesResult> listGremlinQueriesAsync(ListGremlinQueriesRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Lists active Gremlin queries. See Gremlin query status API for details about the output.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    listGremlinQueriesAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ListGremlinQueries operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listGremlinQueriesAsync
```
public Future<ListGremlinQueriesResult> listGremlinQueriesAsync(ListGremlinQueriesRequest request,
                                                                AsyncHandler<ListGremlinQueriesRequest,ListGremlinQueriesResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Lists active Gremlin queries. See Gremlin query status API for details about the output.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    listGremlinQueriesAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ListGremlinQueries operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listLoaderJobsAsync
```
public Future<ListLoaderJobsResult> listLoaderJobsAsync(ListLoaderJobsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves a list of the loadIds for all active loader jobs.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListLoaderJobs IAM action in that cluster..
    
    Specified by:
    
    listLoaderJobsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ListLoaderJobs operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listLoaderJobsAsync
```
public Future<ListLoaderJobsResult> listLoaderJobsAsync(ListLoaderJobsRequest request,
                                                        AsyncHandler<ListLoaderJobsRequest,ListLoaderJobsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Retrieves a list of the loadIds for all active loader jobs.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListLoaderJobs IAM action in that cluster..
    
    Specified by:
    
    listLoaderJobsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ListLoaderJobs operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listMLDataProcessingJobsAsync
```
public Future<ListMLDataProcessingJobsResult> listMLDataProcessingJobsAsync(ListMLDataProcessingJobsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Returns a list of Neptune ML data processing jobs. See Listing active data-processing jobs using the Neptune ML dataprocessing command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLDataProcessingJobs IAM action in that cluster.
    
    Specified by:
    
    listMLDataProcessingJobsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ListMLDataProcessingJobs operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listMLDataProcessingJobsAsync
```
public Future<ListMLDataProcessingJobsResult> listMLDataProcessingJobsAsync(ListMLDataProcessingJobsRequest request,
                                                                            AsyncHandler<ListMLDataProcessingJobsRequest,ListMLDataProcessingJobsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Returns a list of Neptune ML data processing jobs. See Listing active data-processing jobs using the Neptune ML dataprocessing command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLDataProcessingJobs IAM action in that cluster.
    
    Specified by:
    
    listMLDataProcessingJobsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ListMLDataProcessingJobs operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listMLEndpointsAsync
```
public Future<ListMLEndpointsResult> listMLEndpointsAsync(ListMLEndpointsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Lists existing inference endpoints. See Managing inference endpoints using the endpoints command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLEndpoints IAM action in that cluster.
    
    Specified by:
    
    listMLEndpointsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ListMLEndpoints operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listMLEndpointsAsync
```
public Future<ListMLEndpointsResult> listMLEndpointsAsync(ListMLEndpointsRequest request,
                                                          AsyncHandler<ListMLEndpointsRequest,ListMLEndpointsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Lists existing inference endpoints. See Managing inference endpoints using the endpoints command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLEndpoints IAM action in that cluster.
    
    Specified by:
    
    listMLEndpointsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ListMLEndpoints operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listMLModelTrainingJobsAsync
```
public Future<ListMLModelTrainingJobsResult> listMLModelTrainingJobsAsync(ListMLModelTrainingJobsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Lists Neptune ML model-training jobs. See Model training using the modeltraining command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:neptune-db:ListMLModelTrainingJobs IAM action in that cluster.
    
    Specified by:
    
    listMLModelTrainingJobsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ListMLModelTrainingJobs operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listMLModelTrainingJobsAsync
```
public Future<ListMLModelTrainingJobsResult> listMLModelTrainingJobsAsync(ListMLModelTrainingJobsRequest request,
                                                                          AsyncHandler<ListMLModelTrainingJobsRequest,ListMLModelTrainingJobsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Lists Neptune ML model-training jobs. See Model training using the modeltraining command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:neptune-db:ListMLModelTrainingJobs IAM action in that cluster.
    
    Specified by:
    
    listMLModelTrainingJobsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ListMLModelTrainingJobs operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listMLModelTransformJobsAsync
```
public Future<ListMLModelTransformJobsResult> listMLModelTransformJobsAsync(ListMLModelTransformJobsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Returns a list of model transform job IDs. See Use a trained model to generate new model artifacts.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLModelTransformJobs IAM action in that cluster.
    
    Specified by:
    
    listMLModelTransformJobsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ListMLModelTransformJobs operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listMLModelTransformJobsAsync
```
public Future<ListMLModelTransformJobsResult> listMLModelTransformJobsAsync(ListMLModelTransformJobsRequest request,
                                                                            AsyncHandler<ListMLModelTransformJobsRequest,ListMLModelTransformJobsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Returns a list of model transform job IDs. See Use a trained model to generate new model artifacts.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLModelTransformJobs IAM action in that cluster.
    
    Specified by:
    
    listMLModelTransformJobsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ListMLModelTransformJobs operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listOpenCypherQueriesAsync
```
public Future<ListOpenCypherQueriesResult> listOpenCypherQueriesAsync(ListOpenCypherQueriesRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Lists active openCypher queries. See Neptune openCypher status endpoint for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    listOpenCypherQueriesAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ListOpenCypherQueries operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - listOpenCypherQueriesAsync
```
public Future<ListOpenCypherQueriesResult> listOpenCypherQueriesAsync(ListOpenCypherQueriesRequest request,
                                                                      AsyncHandler<ListOpenCypherQueriesRequest,ListOpenCypherQueriesResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Lists active openCypher queries. See Neptune openCypher status endpoint for more information.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
    
    Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
    
    Specified by:
    
    listOpenCypherQueriesAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ListOpenCypherQueries operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - managePropertygraphStatisticsAsync
```
public Future<ManagePropertygraphStatisticsResult> managePropertygraphStatisticsAsync(ManagePropertygraphStatisticsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Manages the generation and use of property graph statistics.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ManageStatistics IAM action in that cluster.
    
    Specified by:
    
    managePropertygraphStatisticsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ManagePropertygraphStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - managePropertygraphStatisticsAsync
```
public Future<ManagePropertygraphStatisticsResult> managePropertygraphStatisticsAsync(ManagePropertygraphStatisticsRequest request,
                                                                                      AsyncHandler<ManagePropertygraphStatisticsRequest,ManagePropertygraphStatisticsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Manages the generation and use of property graph statistics.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ManageStatistics IAM action in that cluster.
    
    Specified by:
    
    managePropertygraphStatisticsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ManagePropertygraphStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - manageSparqlStatisticsAsync
```
public Future<ManageSparqlStatisticsResult> manageSparqlStatisticsAsync(ManageSparqlStatisticsRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Manages the generation and use of RDF graph statistics.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ManageStatistics IAM action in that cluster.
    
    Specified by:
    
    manageSparqlStatisticsAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the ManageSparqlStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - manageSparqlStatisticsAsync
```
public Future<ManageSparqlStatisticsResult> manageSparqlStatisticsAsync(ManageSparqlStatisticsRequest request,
                                                                        AsyncHandler<ManageSparqlStatisticsRequest,ManageSparqlStatisticsResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Manages the generation and use of RDF graph statistics.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ManageStatistics IAM action in that cluster.
    
    Specified by:
    
    manageSparqlStatisticsAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the ManageSparqlStatistics operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - startLoaderJobAsync
```
public Future<StartLoaderJobResult> startLoaderJobAsync(StartLoaderJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Starts a Neptune bulk loader job to load data from an Amazon S3 bucket into a Neptune DB instance. See Using the Amazon Neptune Bulk Loader to Ingest Data.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartLoaderJob IAM action in that cluster.
    
    Specified by:
    
    startLoaderJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the StartLoaderJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - startLoaderJobAsync
```
public Future<StartLoaderJobResult> startLoaderJobAsync(StartLoaderJobRequest request,
                                                        AsyncHandler<StartLoaderJobRequest,StartLoaderJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Starts a Neptune bulk loader job to load data from an Amazon S3 bucket into a Neptune DB instance. See Using the Amazon Neptune Bulk Loader to Ingest Data.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartLoaderJob IAM action in that cluster.
    
    Specified by:
    
    startLoaderJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the StartLoaderJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - startMLDataProcessingJobAsync
```
public Future<StartMLDataProcessingJobResult> startMLDataProcessingJobAsync(StartMLDataProcessingJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Creates a new Neptune ML data processing job for processing the graph data exported from Neptune for training. See The dataprocessing command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelDataProcessingJob IAM action in that cluster.
    
    Specified by:
    
    startMLDataProcessingJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the StartMLDataProcessingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - startMLDataProcessingJobAsync
```
public Future<StartMLDataProcessingJobResult> startMLDataProcessingJobAsync(StartMLDataProcessingJobRequest request,
                                                                            AsyncHandler<StartMLDataProcessingJobRequest,StartMLDataProcessingJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Creates a new Neptune ML data processing job for processing the graph data exported from Neptune for training. See The dataprocessing command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelDataProcessingJob IAM action in that cluster.
    
    Specified by:
    
    startMLDataProcessingJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the StartMLDataProcessingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - startMLModelTrainingJobAsync
```
public Future<StartMLModelTrainingJobResult> startMLModelTrainingJobAsync(StartMLModelTrainingJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Creates a new Neptune ML model training job. See Model training using the modeltraining command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelTrainingJob IAM action in that cluster.
    
    Specified by:
    
    startMLModelTrainingJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the StartMLModelTrainingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - startMLModelTrainingJobAsync
```
public Future<StartMLModelTrainingJobResult> startMLModelTrainingJobAsync(StartMLModelTrainingJobRequest request,
                                                                          AsyncHandler<StartMLModelTrainingJobRequest,StartMLModelTrainingJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Creates a new Neptune ML model training job. See Model training using the modeltraining command.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelTrainingJob IAM action in that cluster.
    
    Specified by:
    
    startMLModelTrainingJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the StartMLModelTrainingJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - startMLModelTransformJobAsync
```
public Future<StartMLModelTransformJobResult> startMLModelTransformJobAsync(StartMLModelTransformJobRequest request)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Creates a new model transform job. See Use a trained model to generate new model artifacts.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelTransformJob IAM action in that cluster.
    
    Specified by:
    
    startMLModelTransformJobAsync in interface AmazonNeptunedataAsync
    
    Returns:
    
    A Java Future containing the result of the StartMLModelTransformJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - startMLModelTransformJobAsync
```
public Future<StartMLModelTransformJobResult> startMLModelTransformJobAsync(StartMLModelTransformJobRequest request,
                                                                            AsyncHandler<StartMLModelTransformJobRequest,StartMLModelTransformJobResult> asyncHandler)
```
    Description copied from interface: AmazonNeptunedataAsync
    
    Creates a new model transform job. See Use a trained model to generate new model artifacts.
    
    When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelTransformJob IAM action in that cluster.
    
    Specified by:
    
    startMLModelTransformJobAsync in interface AmazonNeptunedataAsync
    
    asyncHandler - Asynchronous callback handler for events in the lifecycle of the request. Users can provide an implementation of the callback methods in this interface to receive notification of successful or unsuccessful completion of the operation.
    
    Returns:
    
    A Java Future containing the result of the StartMLModelTransformJob operation returned by the service.
    
    See Also:
    
    AWS API Documentation
  - shutdown
```
public void shutdown()
```
    Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should call getExecutorService().shutdown() followed by getExecutorService().awaitTermination() prior to calling this method.
    
    Specified by:
    
    shutdown in interface AmazonNeptunedata
    
    Overrides:
    
    shutdown in class AmazonNeptunedataClient

AWS SDK for Java 1.x API Reference - 1.12.780

Class AmazonNeptunedataAsyncClient

Field Summary

Fields inherited from class com.amazonaws.AmazonWebServiceClient

Fields inherited from interface com.amazonaws.services.neptunedata.AmazonNeptunedata

Method Summary

Methods inherited from class com.amazonaws.services.neptunedata.AmazonNeptunedataClient

Methods inherited from class com.amazonaws.AmazonWebServiceClient

Methods inherited from class java.lang.Object

Methods inherited from interface com.amazonaws.services.neptunedata.AmazonNeptunedata

Method Detail

asyncBuilder

getExecutorService

cancelGremlinQueryAsync

cancelGremlinQueryAsync

cancelLoaderJobAsync

cancelLoaderJobAsync

cancelMLDataProcessingJobAsync

cancelMLDataProcessingJobAsync

cancelMLModelTrainingJobAsync

cancelMLModelTrainingJobAsync

cancelMLModelTransformJobAsync

cancelMLModelTransformJobAsync

cancelOpenCypherQueryAsync

cancelOpenCypherQueryAsync

createMLEndpointAsync

createMLEndpointAsync

deleteMLEndpointAsync

deleteMLEndpointAsync

deletePropertygraphStatisticsAsync

deletePropertygraphStatisticsAsync

deleteSparqlStatisticsAsync

deleteSparqlStatisticsAsync

executeFastResetAsync

executeFastResetAsync

executeGremlinExplainQueryAsync

executeGremlinExplainQueryAsync

executeGremlinProfileQueryAsync

executeGremlinProfileQueryAsync

executeGremlinQueryAsync

executeGremlinQueryAsync

executeOpenCypherExplainQueryAsync

executeOpenCypherExplainQueryAsync

getEngineStatusAsync

getEngineStatusAsync

getGremlinQueryStatusAsync

getGremlinQueryStatusAsync

getMLDataProcessingJobAsync

getMLDataProcessingJobAsync

getMLEndpointAsync

getMLEndpointAsync

getMLModelTrainingJobAsync

getMLModelTrainingJobAsync

getMLModelTransformJobAsync

getMLModelTransformJobAsync

getOpenCypherQueryStatusAsync

getOpenCypherQueryStatusAsync

getPropertygraphStatisticsAsync

getPropertygraphStatisticsAsync

getPropertygraphSummaryAsync

getPropertygraphSummaryAsync

getRDFGraphSummaryAsync

getRDFGraphSummaryAsync

getSparqlStatisticsAsync

getSparqlStatisticsAsync

getSparqlStreamAsync

getSparqlStreamAsync

listGremlinQueriesAsync

listGremlinQueriesAsync

listLoaderJobsAsync

listLoaderJobsAsync

listMLDataProcessingJobsAsync

listMLDataProcessingJobsAsync

listMLEndpointsAsync

listMLEndpointsAsync

listMLModelTrainingJobsAsync

listMLModelTrainingJobsAsync

listMLModelTransformJobsAsync

listMLModelTransformJobsAsync

listOpenCypherQueriesAsync