Interface DataCatalogAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    DataCatalogAsyncClient

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20190325")
    public interface DataCatalogAsync
    extends AutoCloseable
    Use the Data Catalog APIs to collect, organize, find, access, understand, enrich, and activate technical, business, and operational metadata.

    For more information, see Data Catalog.

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

        void setEndpoint​(String endpoint)
        Sets the endpoint to call (ex, https://www.example.com).
        Parameters:
        endpoint - The endpoint of the serice.
      • getEndpoint

        String getEndpoint()
        Gets the set endpoint for REST call (ex, https://www.example.com)
      • setRegion

        void setRegion​(Region region)
        Sets the region to call (ex, Region.US_PHOENIX_1).

        Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.

        Parameters:
        region - The region of the service.
      • setRegion

        void setRegion​(String regionId)
        Sets the region to call (ex, ‘us-phoenix-1’).

        Note, this will first try to map the region ID to a known Region and call setRegion.

        If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.

        Parameters:
        regionId - The public region ID.
      • useRealmSpecificEndpointTemplate

        void useRealmSpecificEndpointTemplate​(boolean realmSpecificEndpointTemplateEnabled)
        Determines whether realm specific endpoint should be used or not.

        Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”

        Parameters:
        realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template
      • addCatalogLock

        Future<AddCatalogLockResponse> addCatalogLock​(AddCatalogLockRequest request,
                                                      AsyncHandler<AddCatalogLockRequest,​AddCatalogLockResponse> handler)
        Adds a lock to a Catalog resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • addDataSelectorPatterns

        Future<AddDataSelectorPatternsResponse> addDataSelectorPatterns​(AddDataSelectorPatternsRequest request,
                                                                        AsyncHandler<AddDataSelectorPatternsRequest,​AddDataSelectorPatternsResponse> handler)
        Add data selector pattern to the data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • addMetastoreLock

        Future<AddMetastoreLockResponse> addMetastoreLock​(AddMetastoreLockRequest request,
                                                          AsyncHandler<AddMetastoreLockRequest,​AddMetastoreLockResponse> handler)
        Adds a lock to a Metastore resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • associateCustomProperty

        Future<AssociateCustomPropertyResponse> associateCustomProperty​(AssociateCustomPropertyRequest request,
                                                                        AsyncHandler<AssociateCustomPropertyRequest,​AssociateCustomPropertyResponse> handler)
        Associate the custom property for the given type
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • asynchronousExportDataAsset

        Future<AsynchronousExportDataAssetResponse> asynchronousExportDataAsset​(AsynchronousExportDataAssetRequest request,
                                                                                AsyncHandler<AsynchronousExportDataAssetRequest,​AsynchronousExportDataAssetResponse> handler)
        Export technical objects from a Data Asset in Excel format.

        Returns details about the job which actually performs the export.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • asynchronousExportGlossary

        Future<AsynchronousExportGlossaryResponse> asynchronousExportGlossary​(AsynchronousExportGlossaryRequest request,
                                                                              AsyncHandler<AsynchronousExportGlossaryRequest,​AsynchronousExportGlossaryResponse> handler)
        Exports the contents of a glossary in Excel format.

        Returns details about the job which actually performs the export.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • attachCatalogPrivateEndpoint

        Future<AttachCatalogPrivateEndpointResponse> attachCatalogPrivateEndpoint​(AttachCatalogPrivateEndpointRequest request,
                                                                                  AsyncHandler<AttachCatalogPrivateEndpointRequest,​AttachCatalogPrivateEndpointResponse> handler)
        Attaches a private reverse connection endpoint resource to a data catalog resource.

        When provided, ‘If-Match’ is checked against ‘ETag’ values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • changeCatalogCompartment

        Future<ChangeCatalogCompartmentResponse> changeCatalogCompartment​(ChangeCatalogCompartmentRequest request,
                                                                          AsyncHandler<ChangeCatalogCompartmentRequest,​ChangeCatalogCompartmentResponse> handler)
        Moves a resource into a different compartment.

        When provided, ‘If-Match’ is checked against ‘ETag’ values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • changeMetastoreCompartment

        Future<ChangeMetastoreCompartmentResponse> changeMetastoreCompartment​(ChangeMetastoreCompartmentRequest request,
                                                                              AsyncHandler<ChangeMetastoreCompartmentRequest,​ChangeMetastoreCompartmentResponse> handler)
        Moves a resource into a different compartment.

        When provided, ‘If-Match’ is checked against ‘ETag’ values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createAttribute

        Future<CreateAttributeResponse> createAttribute​(CreateAttributeRequest request,
                                                        AsyncHandler<CreateAttributeRequest,​CreateAttributeResponse> handler)
        Creates a new entity attribute.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createAttributeTag

        Future<CreateAttributeTagResponse> createAttributeTag​(CreateAttributeTagRequest request,
                                                              AsyncHandler<CreateAttributeTagRequest,​CreateAttributeTagResponse> handler)
        Creates a new entity attribute tag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createCatalog

        Future<CreateCatalogResponse> createCatalog​(CreateCatalogRequest request,
                                                    AsyncHandler<CreateCatalogRequest,​CreateCatalogResponse> handler)
        Creates a new data catalog instance that includes a console and an API URL for managing metadata operations.

        For more information, please see the documentation.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createConnection

        Future<CreateConnectionResponse> createConnection​(CreateConnectionRequest request,
                                                          AsyncHandler<CreateConnectionRequest,​CreateConnectionResponse> handler)
        Creates a new connection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createCustomProperty

        Future<CreateCustomPropertyResponse> createCustomProperty​(CreateCustomPropertyRequest request,
                                                                  AsyncHandler<CreateCustomPropertyRequest,​CreateCustomPropertyResponse> handler)
        Create a new Custom Property
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createDataAsset

        Future<CreateDataAssetResponse> createDataAsset​(CreateDataAssetRequest request,
                                                        AsyncHandler<CreateDataAssetRequest,​CreateDataAssetResponse> handler)
        Create a new data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createDataAssetTag

        Future<CreateDataAssetTagResponse> createDataAssetTag​(CreateDataAssetTagRequest request,
                                                              AsyncHandler<CreateDataAssetTagRequest,​CreateDataAssetTagResponse> handler)
        Creates a new data asset tag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createEntity

        Future<CreateEntityResponse> createEntity​(CreateEntityRequest request,
                                                  AsyncHandler<CreateEntityRequest,​CreateEntityResponse> handler)
        Creates a new data entity.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createEntityTag

        Future<CreateEntityTagResponse> createEntityTag​(CreateEntityTagRequest request,
                                                        AsyncHandler<CreateEntityTagRequest,​CreateEntityTagResponse> handler)
        Creates a new entity tag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createFolder

        Future<CreateFolderResponse> createFolder​(CreateFolderRequest request,
                                                  AsyncHandler<CreateFolderRequest,​CreateFolderResponse> handler)
        Creates a new folder.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createFolderTag

        Future<CreateFolderTagResponse> createFolderTag​(CreateFolderTagRequest request,
                                                        AsyncHandler<CreateFolderTagRequest,​CreateFolderTagResponse> handler)
        Creates a new folder tag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createGlossary

        Future<CreateGlossaryResponse> createGlossary​(CreateGlossaryRequest request,
                                                      AsyncHandler<CreateGlossaryRequest,​CreateGlossaryResponse> handler)
        Creates a new glossary.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createJob

        Future<CreateJobResponse> createJob​(CreateJobRequest request,
                                            AsyncHandler<CreateJobRequest,​CreateJobResponse> handler)
        Creates a new job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createJobDefinition

        Future<CreateJobDefinitionResponse> createJobDefinition​(CreateJobDefinitionRequest request,
                                                                AsyncHandler<CreateJobDefinitionRequest,​CreateJobDefinitionResponse> handler)
        Creates a new job definition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createJobExecution

        Future<CreateJobExecutionResponse> createJobExecution​(CreateJobExecutionRequest request,
                                                              AsyncHandler<CreateJobExecutionRequest,​CreateJobExecutionResponse> handler)
        Creates a new job execution.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createMetastore

        Future<CreateMetastoreResponse> createMetastore​(CreateMetastoreRequest request,
                                                        AsyncHandler<CreateMetastoreRequest,​CreateMetastoreResponse> handler)
        Creates a new metastore.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createNamespace

        Future<CreateNamespaceResponse> createNamespace​(CreateNamespaceRequest request,
                                                        AsyncHandler<CreateNamespaceRequest,​CreateNamespaceResponse> handler)
        Create a new Namespace to be used by a custom property
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createPattern

        Future<CreatePatternResponse> createPattern​(CreatePatternRequest request,
                                                    AsyncHandler<CreatePatternRequest,​CreatePatternResponse> handler)
        Create a new pattern.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createTerm

        Future<CreateTermResponse> createTerm​(CreateTermRequest request,
                                              AsyncHandler<CreateTermRequest,​CreateTermResponse> handler)
        Create a new term within a glossary.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createTermRelationship

        Future<CreateTermRelationshipResponse> createTermRelationship​(CreateTermRelationshipRequest request,
                                                                      AsyncHandler<CreateTermRelationshipRequest,​CreateTermRelationshipResponse> handler)
        Creates a new term relationship for this term within a glossary.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteAttribute

        Future<DeleteAttributeResponse> deleteAttribute​(DeleteAttributeRequest request,
                                                        AsyncHandler<DeleteAttributeRequest,​DeleteAttributeResponse> handler)
        Deletes a specific entity attribute.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteAttributeTag

        Future<DeleteAttributeTagResponse> deleteAttributeTag​(DeleteAttributeTagRequest request,
                                                              AsyncHandler<DeleteAttributeTagRequest,​DeleteAttributeTagResponse> handler)
        Deletes a specific entity attribute tag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteCatalog

        Future<DeleteCatalogResponse> deleteCatalog​(DeleteCatalogRequest request,
                                                    AsyncHandler<DeleteCatalogRequest,​DeleteCatalogResponse> handler)
        Deletes a data catalog resource by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteConnection

        Future<DeleteConnectionResponse> deleteConnection​(DeleteConnectionRequest request,
                                                          AsyncHandler<DeleteConnectionRequest,​DeleteConnectionResponse> handler)
        Deletes a specific connection of a data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteCustomProperty

        Future<DeleteCustomPropertyResponse> deleteCustomProperty​(DeleteCustomPropertyRequest request,
                                                                  AsyncHandler<DeleteCustomPropertyRequest,​DeleteCustomPropertyResponse> handler)
        Deletes a specific custom property identified by it’s key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteDataAsset

        Future<DeleteDataAssetResponse> deleteDataAsset​(DeleteDataAssetRequest request,
                                                        AsyncHandler<DeleteDataAssetRequest,​DeleteDataAssetResponse> handler)
        Deletes a specific data asset identified by it’s key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteDataAssetTag

        Future<DeleteDataAssetTagResponse> deleteDataAssetTag​(DeleteDataAssetTagRequest request,
                                                              AsyncHandler<DeleteDataAssetTagRequest,​DeleteDataAssetTagResponse> handler)
        Deletes a specific data asset tag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteEntity

        Future<DeleteEntityResponse> deleteEntity​(DeleteEntityRequest request,
                                                  AsyncHandler<DeleteEntityRequest,​DeleteEntityResponse> handler)
        Deletes a specific data entity.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteEntityTag

        Future<DeleteEntityTagResponse> deleteEntityTag​(DeleteEntityTagRequest request,
                                                        AsyncHandler<DeleteEntityTagRequest,​DeleteEntityTagResponse> handler)
        Deletes a specific entity tag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteFolder

        Future<DeleteFolderResponse> deleteFolder​(DeleteFolderRequest request,
                                                  AsyncHandler<DeleteFolderRequest,​DeleteFolderResponse> handler)
        Deletes a specific folder of a data asset identified by it’s key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteFolderTag

        Future<DeleteFolderTagResponse> deleteFolderTag​(DeleteFolderTagRequest request,
                                                        AsyncHandler<DeleteFolderTagRequest,​DeleteFolderTagResponse> handler)
        Deletes a specific folder tag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteGlossary

        Future<DeleteGlossaryResponse> deleteGlossary​(DeleteGlossaryRequest request,
                                                      AsyncHandler<DeleteGlossaryRequest,​DeleteGlossaryResponse> handler)
        Deletes a specific glossary identified by it’s key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteJob

        Future<DeleteJobResponse> deleteJob​(DeleteJobRequest request,
                                            AsyncHandler<DeleteJobRequest,​DeleteJobResponse> handler)
        Deletes a specific job identified by it’s key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteJobDefinition

        Future<DeleteJobDefinitionResponse> deleteJobDefinition​(DeleteJobDefinitionRequest request,
                                                                AsyncHandler<DeleteJobDefinitionRequest,​DeleteJobDefinitionResponse> handler)
        Deletes a specific job definition identified by it’s key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteMetastore

        Future<DeleteMetastoreResponse> deleteMetastore​(DeleteMetastoreRequest request,
                                                        AsyncHandler<DeleteMetastoreRequest,​DeleteMetastoreResponse> handler)
        Deletes a metastore resource by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteNamespace

        Future<DeleteNamespaceResponse> deleteNamespace​(DeleteNamespaceRequest request,
                                                        AsyncHandler<DeleteNamespaceRequest,​DeleteNamespaceResponse> handler)
        Deletes a specific Namespace identified by it’s key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deletePattern

        Future<DeletePatternResponse> deletePattern​(DeletePatternRequest request,
                                                    AsyncHandler<DeletePatternRequest,​DeletePatternResponse> handler)
        Deletes a specific pattern identified by it’s key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteTerm

        Future<DeleteTermResponse> deleteTerm​(DeleteTermRequest request,
                                              AsyncHandler<DeleteTermRequest,​DeleteTermResponse> handler)
        Deletes a specific glossary term.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteTermRelationship

        Future<DeleteTermRelationshipResponse> deleteTermRelationship​(DeleteTermRelationshipRequest request,
                                                                      AsyncHandler<DeleteTermRelationshipRequest,​DeleteTermRelationshipResponse> handler)
        Deletes a specific glossary term relationship.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • detachCatalogPrivateEndpoint

        Future<DetachCatalogPrivateEndpointResponse> detachCatalogPrivateEndpoint​(DetachCatalogPrivateEndpointRequest request,
                                                                                  AsyncHandler<DetachCatalogPrivateEndpointRequest,​DetachCatalogPrivateEndpointResponse> handler)
        Detaches a private reverse connection endpoint resource to a data catalog resource.

        When provided, ‘If-Match’ is checked against ‘ETag’ values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • expandTreeForGlossary

        Future<ExpandTreeForGlossaryResponse> expandTreeForGlossary​(ExpandTreeForGlossaryRequest request,
                                                                    AsyncHandler<ExpandTreeForGlossaryRequest,​ExpandTreeForGlossaryResponse> handler)
        Returns the fully expanded tree hierarchy of parent and child terms in this glossary.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • exportGlossary

        Future<ExportGlossaryResponse> exportGlossary​(ExportGlossaryRequest request,
                                                      AsyncHandler<ExportGlossaryRequest,​ExportGlossaryResponse> handler)
        Export the glossary and the terms and return the exported glossary as csv or json.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • fetchEntityLineage

        Future<FetchEntityLineageResponse> fetchEntityLineage​(FetchEntityLineageRequest request,
                                                              AsyncHandler<FetchEntityLineageRequest,​FetchEntityLineageResponse> handler)
        Returns lineage for a given entity object.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getAttribute

        Future<GetAttributeResponse> getAttribute​(GetAttributeRequest request,
                                                  AsyncHandler<GetAttributeRequest,​GetAttributeResponse> handler)
        Gets a specific entity attribute by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getAttributeTag

        Future<GetAttributeTagResponse> getAttributeTag​(GetAttributeTagRequest request,
                                                        AsyncHandler<GetAttributeTagRequest,​GetAttributeTagResponse> handler)
        Gets a specific entity attribute tag by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getCatalog

        Future<GetCatalogResponse> getCatalog​(GetCatalogRequest request,
                                              AsyncHandler<GetCatalogRequest,​GetCatalogResponse> handler)
        Gets a data catalog by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getConnection

        Future<GetConnectionResponse> getConnection​(GetConnectionRequest request,
                                                    AsyncHandler<GetConnectionRequest,​GetConnectionResponse> handler)
        Gets a specific data asset connection by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getCustomProperty

        Future<GetCustomPropertyResponse> getCustomProperty​(GetCustomPropertyRequest request,
                                                            AsyncHandler<GetCustomPropertyRequest,​GetCustomPropertyResponse> handler)
        Gets a specific custom property for the given key within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getDataAsset

        Future<GetDataAssetResponse> getDataAsset​(GetDataAssetRequest request,
                                                  AsyncHandler<GetDataAssetRequest,​GetDataAssetResponse> handler)
        Gets a specific data asset for the given key within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getDataAssetTag

        Future<GetDataAssetTagResponse> getDataAssetTag​(GetDataAssetTagRequest request,
                                                        AsyncHandler<GetDataAssetTagRequest,​GetDataAssetTagResponse> handler)
        Gets a specific data asset tag by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getEntity

        Future<GetEntityResponse> getEntity​(GetEntityRequest request,
                                            AsyncHandler<GetEntityRequest,​GetEntityResponse> handler)
        Gets a specific data entity by key for a data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getEntityTag

        Future<GetEntityTagResponse> getEntityTag​(GetEntityTagRequest request,
                                                  AsyncHandler<GetEntityTagRequest,​GetEntityTagResponse> handler)
        Gets a specific entity tag by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getFolder

        Future<GetFolderResponse> getFolder​(GetFolderRequest request,
                                            AsyncHandler<GetFolderRequest,​GetFolderResponse> handler)
        Gets a specific data asset folder by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getFolderTag

        Future<GetFolderTagResponse> getFolderTag​(GetFolderTagRequest request,
                                                  AsyncHandler<GetFolderTagRequest,​GetFolderTagResponse> handler)
        Gets a specific folder tag by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getGlossary

        Future<GetGlossaryResponse> getGlossary​(GetGlossaryRequest request,
                                                AsyncHandler<GetGlossaryRequest,​GetGlossaryResponse> handler)
        Gets a specific glossary by key within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getJob

        Future<GetJobResponse> getJob​(GetJobRequest request,
                                      AsyncHandler<GetJobRequest,​GetJobResponse> handler)
        Gets a specific job by key within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getJobDefinition

        Future<GetJobDefinitionResponse> getJobDefinition​(GetJobDefinitionRequest request,
                                                          AsyncHandler<GetJobDefinitionRequest,​GetJobDefinitionResponse> handler)
        Gets a specific job definition by key within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getJobExecution

        Future<GetJobExecutionResponse> getJobExecution​(GetJobExecutionRequest request,
                                                        AsyncHandler<GetJobExecutionRequest,​GetJobExecutionResponse> handler)
        Gets a specific job execution by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getJobLog

        Future<GetJobLogResponse> getJobLog​(GetJobLogRequest request,
                                            AsyncHandler<GetJobLogRequest,​GetJobLogResponse> handler)
        Gets a specific job log by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getJobMetrics

        Future<GetJobMetricsResponse> getJobMetrics​(GetJobMetricsRequest request,
                                                    AsyncHandler<GetJobMetricsRequest,​GetJobMetricsResponse> handler)
        Gets a specific job metric by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMetastore

        Future<GetMetastoreResponse> getMetastore​(GetMetastoreRequest request,
                                                  AsyncHandler<GetMetastoreRequest,​GetMetastoreResponse> handler)
        Gets a metastore by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getNamespace

        Future<GetNamespaceResponse> getNamespace​(GetNamespaceRequest request,
                                                  AsyncHandler<GetNamespaceRequest,​GetNamespaceResponse> handler)
        Gets a specific namespace for the given key within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getPattern

        Future<GetPatternResponse> getPattern​(GetPatternRequest request,
                                              AsyncHandler<GetPatternRequest,​GetPatternResponse> handler)
        Gets a specific pattern for the given key within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getTerm

        Future<GetTermResponse> getTerm​(GetTermRequest request,
                                        AsyncHandler<GetTermRequest,​GetTermResponse> handler)
        Gets a specific glossary term by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getTermRelationship

        Future<GetTermRelationshipResponse> getTermRelationship​(GetTermRelationshipRequest request,
                                                                AsyncHandler<GetTermRelationshipRequest,​GetTermRelationshipResponse> handler)
        Gets a specific glossary term relationship by key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getType

        Future<GetTypeResponse> getType​(GetTypeRequest request,
                                        AsyncHandler<GetTypeRequest,​GetTypeResponse> handler)
        Gets a specific type by key within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                                      AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the status of the work request with the given OCID.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • importConnection

        Future<ImportConnectionResponse> importConnection​(ImportConnectionRequest request,
                                                          AsyncHandler<ImportConnectionRequest,​ImportConnectionResponse> handler)
        Import new connection for this data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • importDataAsset

        Future<ImportDataAssetResponse> importDataAsset​(ImportDataAssetRequest request,
                                                        AsyncHandler<ImportDataAssetRequest,​ImportDataAssetResponse> handler)
        Import technical objects to a Data Asset
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • importGlossary

        Future<ImportGlossaryResponse> importGlossary​(ImportGlossaryRequest request,
                                                      AsyncHandler<ImportGlossaryRequest,​ImportGlossaryResponse> handler)
        Import the glossary and the terms from csv or json files and return the imported glossary resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • importLineage

        Future<ImportLineageResponse> importLineage​(ImportLineageRequest request,
                                                    AsyncHandler<ImportLineageRequest,​ImportLineageResponse> handler)
        Imports lineage metadata.

        Returns details about the job that performs the import.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listAttributeTags

        Future<ListAttributeTagsResponse> listAttributeTags​(ListAttributeTagsRequest request,
                                                            AsyncHandler<ListAttributeTagsRequest,​ListAttributeTagsResponse> handler)
        Returns a list of all tags for an entity attribute.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listAttributes

        Future<ListAttributesResponse> listAttributes​(ListAttributesRequest request,
                                                      AsyncHandler<ListAttributesRequest,​ListAttributesResponse> handler)
        Returns a list of all attributes of an data entity.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listCatalogs

        Future<ListCatalogsResponse> listCatalogs​(ListCatalogsRequest request,
                                                  AsyncHandler<ListCatalogsRequest,​ListCatalogsResponse> handler)
        Returns a list of all the data catalogs in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listConnections

        Future<ListConnectionsResponse> listConnections​(ListConnectionsRequest request,
                                                        AsyncHandler<ListConnectionsRequest,​ListConnectionsResponse> handler)
        Returns a list of all Connections for a data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listCustomProperties

        Future<ListCustomPropertiesResponse> listCustomProperties​(ListCustomPropertiesRequest request,
                                                                  AsyncHandler<ListCustomPropertiesRequest,​ListCustomPropertiesResponse> handler)
        Returns a list of custom properties within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listDataAssetTags

        Future<ListDataAssetTagsResponse> listDataAssetTags​(ListDataAssetTagsRequest request,
                                                            AsyncHandler<ListDataAssetTagsRequest,​ListDataAssetTagsResponse> handler)
        Returns a list of all tags for a data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listDataAssets

        Future<ListDataAssetsResponse> listDataAssets​(ListDataAssetsRequest request,
                                                      AsyncHandler<ListDataAssetsRequest,​ListDataAssetsResponse> handler)
        Returns a list of data assets within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listEntities

        Future<ListEntitiesResponse> listEntities​(ListEntitiesRequest request,
                                                  AsyncHandler<ListEntitiesRequest,​ListEntitiesResponse> handler)
        Returns a list of all entities of a data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listEntityTags

        Future<ListEntityTagsResponse> listEntityTags​(ListEntityTagsRequest request,
                                                      AsyncHandler<ListEntityTagsRequest,​ListEntityTagsResponse> handler)
        Returns a list of all tags for a data entity.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listFolderTags

        Future<ListFolderTagsResponse> listFolderTags​(ListFolderTagsRequest request,
                                                      AsyncHandler<ListFolderTagsRequest,​ListFolderTagsResponse> handler)
        Returns a list of all tags for a folder.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listFolders

        Future<ListFoldersResponse> listFolders​(ListFoldersRequest request,
                                                AsyncHandler<ListFoldersRequest,​ListFoldersResponse> handler)
        Returns a list of all folders.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listGlossaries

        Future<ListGlossariesResponse> listGlossaries​(ListGlossariesRequest request,
                                                      AsyncHandler<ListGlossariesRequest,​ListGlossariesResponse> handler)
        Returns a list of all glossaries within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listJobDefinitions

        Future<ListJobDefinitionsResponse> listJobDefinitions​(ListJobDefinitionsRequest request,
                                                              AsyncHandler<ListJobDefinitionsRequest,​ListJobDefinitionsResponse> handler)
        Returns a list of job definitions within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listJobExecutions

        Future<ListJobExecutionsResponse> listJobExecutions​(ListJobExecutionsRequest request,
                                                            AsyncHandler<ListJobExecutionsRequest,​ListJobExecutionsResponse> handler)
        Returns a list of job executions for a job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listJobLogs

        Future<ListJobLogsResponse> listJobLogs​(ListJobLogsRequest request,
                                                AsyncHandler<ListJobLogsRequest,​ListJobLogsResponse> handler)
        Returns a list of job logs.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listJobMetrics

        Future<ListJobMetricsResponse> listJobMetrics​(ListJobMetricsRequest request,
                                                      AsyncHandler<ListJobMetricsRequest,​ListJobMetricsResponse> handler)
        Returns a list of job metrics.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listJobs

        Future<ListJobsResponse> listJobs​(ListJobsRequest request,
                                          AsyncHandler<ListJobsRequest,​ListJobsResponse> handler)
        Returns a list of jobs within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMetastores

        Future<ListMetastoresResponse> listMetastores​(ListMetastoresRequest request,
                                                      AsyncHandler<ListMetastoresRequest,​ListMetastoresResponse> handler)
        Returns a list of all metastores in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listNamespaces

        Future<ListNamespacesResponse> listNamespaces​(ListNamespacesRequest request,
                                                      AsyncHandler<ListNamespacesRequest,​ListNamespacesResponse> handler)
        Returns a list of namespaces within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listPatterns

        Future<ListPatternsResponse> listPatterns​(ListPatternsRequest request,
                                                  AsyncHandler<ListPatternsRequest,​ListPatternsResponse> handler)
        Returns a list of patterns within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listRules

        Future<ListRulesResponse> listRules​(ListRulesRequest request,
                                            AsyncHandler<ListRulesRequest,​ListRulesResponse> handler)
        Returns a list of all rules of a data entity.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listTags

        Future<ListTagsResponse> listTags​(ListTagsRequest request,
                                          AsyncHandler<ListTagsRequest,​ListTagsResponse> handler)
        Returns a list of all user created tags in the system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listTermRelationships

        Future<ListTermRelationshipsResponse> listTermRelationships​(ListTermRelationshipsRequest request,
                                                                    AsyncHandler<ListTermRelationshipsRequest,​ListTermRelationshipsResponse> handler)
        Returns a list of all term relationships within a glossary.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listTerms

        Future<ListTermsResponse> listTerms​(ListTermsRequest request,
                                            AsyncHandler<ListTermsRequest,​ListTermsResponse> handler)
        Returns a list of all terms within a glossary.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listTypes

        Future<ListTypesResponse> listTypes​(ListTypesRequest request,
                                            AsyncHandler<ListTypesRequest,​ListTypesResponse> handler)
        Returns a list of all types within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                                    AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Returns a (paginated) list of errors for a given work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequestLogs

        Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                                AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Returns a (paginated) list of logs for a given work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequests

        Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                          AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        Lists the work requests in a compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • objectStats

        Future<ObjectStatsResponse> objectStats​(ObjectStatsRequest request,
                                                AsyncHandler<ObjectStatsRequest,​ObjectStatsResponse> handler)
        Returns stats on objects by type in the repository.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • parseConnection

        Future<ParseConnectionResponse> parseConnection​(ParseConnectionRequest request,
                                                        AsyncHandler<ParseConnectionRequest,​ParseConnectionResponse> handler)
        Parse data asset references through connections from this data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • processRecommendation

        Future<ProcessRecommendationResponse> processRecommendation​(ProcessRecommendationRequest request,
                                                                    AsyncHandler<ProcessRecommendationRequest,​ProcessRecommendationResponse> handler)
        Act on a recommendation.

        A recommendation can be accepted or rejected. For example, if a recommendation of type LINK_GLOSSARY_TERM is accepted, the system will link the source object (e.g. an attribute) to a target glossary term.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • recommendations

        Future<RecommendationsResponse> recommendations​(RecommendationsRequest request,
                                                        AsyncHandler<RecommendationsRequest,​RecommendationsResponse> handler)
        Returns a list of recommendations for the given object and recommendation type.

        By default, it will return inferred recommendations for review. The optional query param ‘RecommendationStatus’ can be set, to return only recommendations having that status.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • removeCatalogLock

        Future<RemoveCatalogLockResponse> removeCatalogLock​(RemoveCatalogLockRequest request,
                                                            AsyncHandler<RemoveCatalogLockRequest,​RemoveCatalogLockResponse> handler)
        Removes a lock from a Catalog resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • removeMetastoreLock

        Future<RemoveMetastoreLockResponse> removeMetastoreLock​(RemoveMetastoreLockRequest request,
                                                                AsyncHandler<RemoveMetastoreLockRequest,​RemoveMetastoreLockResponse> handler)
        Removes a lock from a Metastore resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • searchCriteria

        Future<SearchCriteriaResponse> searchCriteria​(SearchCriteriaRequest request,
                                                      AsyncHandler<SearchCriteriaRequest,​SearchCriteriaResponse> handler)
        Returns a list of search results within a data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • suggestMatches

        Future<SuggestMatchesResponse> suggestMatches​(SuggestMatchesRequest request,
                                                      AsyncHandler<SuggestMatchesRequest,​SuggestMatchesResponse> handler)
        Returns a list of potential string matches for a given input string.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • testConnection

        Future<TestConnectionResponse> testConnection​(TestConnectionRequest request,
                                                      AsyncHandler<TestConnectionRequest,​TestConnectionResponse> handler)
        Test the connection by connecting to the data asset using credentials in the metadata.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateAttribute

        Future<UpdateAttributeResponse> updateAttribute​(UpdateAttributeRequest request,
                                                        AsyncHandler<UpdateAttributeRequest,​UpdateAttributeResponse> handler)
        Updates a specific data asset attribute.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateCatalog

        Future<UpdateCatalogResponse> updateCatalog​(UpdateCatalogRequest request,
                                                    AsyncHandler<UpdateCatalogRequest,​UpdateCatalogResponse> handler)
        Updates the data catalog.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateConnection

        Future<UpdateConnectionResponse> updateConnection​(UpdateConnectionRequest request,
                                                          AsyncHandler<UpdateConnectionRequest,​UpdateConnectionResponse> handler)
        Updates a specific connection of a data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateCustomProperty

        Future<UpdateCustomPropertyResponse> updateCustomProperty​(UpdateCustomPropertyRequest request,
                                                                  AsyncHandler<UpdateCustomPropertyRequest,​UpdateCustomPropertyResponse> handler)
        Updates a specific custom property identified by the given key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateDataAsset

        Future<UpdateDataAssetResponse> updateDataAsset​(UpdateDataAssetRequest request,
                                                        AsyncHandler<UpdateDataAssetRequest,​UpdateDataAssetResponse> handler)
        Updates a specific data asset identified by the given key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateEntity

        Future<UpdateEntityResponse> updateEntity​(UpdateEntityRequest request,
                                                  AsyncHandler<UpdateEntityRequest,​UpdateEntityResponse> handler)
        Updates a specific data entity.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateFolder

        Future<UpdateFolderResponse> updateFolder​(UpdateFolderRequest request,
                                                  AsyncHandler<UpdateFolderRequest,​UpdateFolderResponse> handler)
        Updates a specific folder of a data asset.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateGlossary

        Future<UpdateGlossaryResponse> updateGlossary​(UpdateGlossaryRequest request,
                                                      AsyncHandler<UpdateGlossaryRequest,​UpdateGlossaryResponse> handler)
        Updates a specific glossary identified by the given key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateJob

        Future<UpdateJobResponse> updateJob​(UpdateJobRequest request,
                                            AsyncHandler<UpdateJobRequest,​UpdateJobResponse> handler)
        Updates a specific job identified by the given key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateJobDefinition

        Future<UpdateJobDefinitionResponse> updateJobDefinition​(UpdateJobDefinitionRequest request,
                                                                AsyncHandler<UpdateJobDefinitionRequest,​UpdateJobDefinitionResponse> handler)
        Update a specific job definition identified by the given key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateMetastore

        Future<UpdateMetastoreResponse> updateMetastore​(UpdateMetastoreRequest request,
                                                        AsyncHandler<UpdateMetastoreRequest,​UpdateMetastoreResponse> handler)
        Updates a metastore resource by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateNamespace

        Future<UpdateNamespaceResponse> updateNamespace​(UpdateNamespaceRequest request,
                                                        AsyncHandler<UpdateNamespaceRequest,​UpdateNamespaceResponse> handler)
        Updates a specific namespace identified by the given key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updatePattern

        Future<UpdatePatternResponse> updatePattern​(UpdatePatternRequest request,
                                                    AsyncHandler<UpdatePatternRequest,​UpdatePatternResponse> handler)
        Updates a specific pattern identified by the given key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateTerm

        Future<UpdateTermResponse> updateTerm​(UpdateTermRequest request,
                                              AsyncHandler<UpdateTermRequest,​UpdateTermResponse> handler)
        Updates a specific glossary term.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateTermRelationship

        Future<UpdateTermRelationshipResponse> updateTermRelationship​(UpdateTermRelationshipRequest request,
                                                                      AsyncHandler<UpdateTermRelationshipRequest,​UpdateTermRelationshipResponse> handler)
        Updates a specific glossary term relationship.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • uploadCredentials

        Future<UploadCredentialsResponse> uploadCredentials​(UploadCredentialsRequest request,
                                                            AsyncHandler<UploadCredentialsRequest,​UploadCredentialsResponse> handler)
        Upload connection credentails and metadata for this connection.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • users

        Future<UsersResponse> users​(UsersRequest request,
                                    AsyncHandler<UsersRequest,​UsersResponse> handler)
        Returns active users in the system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • validateConnection

        Future<ValidateConnectionResponse> validateConnection​(ValidateConnectionRequest request,
                                                              AsyncHandler<ValidateConnectionRequest,​ValidateConnectionResponse> handler)
        Validate connection by connecting to the data asset using credentials in metadata.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • validatePattern

        Future<ValidatePatternResponse> validatePattern​(ValidatePatternRequest request,
                                                        AsyncHandler<ValidatePatternRequest,​ValidatePatternResponse> handler)
        Validate pattern by deriving file groups representing logical entities using the expression
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.