Package org.odpi.openmetadata.accessservices.assetmanager.server.spring

Class SchemaExchangeResource

  • @RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/asset-manager/users/{userId}")
public class SchemaExchangeResource
extends Object
    SchemaExchangeResource is the server-side implementation of the Asset Manager OMAS's support for schemas. It matches the SchemaExchangeClientBase.

    • Constructor Detail

      • SchemaExchangeResource

        public SchemaExchangeResource()
        Default constructor

    • Method Detail

      • createSchemaType

        @PostMapping(path="/schema-types")
public GUIDResponse createSchemaType​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @RequestParam
                                     boolean assetManagerIsHome,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     SchemaTypeRequestBody requestBody)
        Create a new metadata element to represent a schema type.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the asset manager can update this schema element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties about the schema type to store
        Returns:
        unique identifier of the new schema type InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • createSchemaTypeFromTemplate

        @PostMapping(path="/schema-types/from-template/{templateGUID}")
public GUIDResponse createSchemaTypeFromTemplate​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String templateGUID,
                                                 @RequestParam
                                                 boolean assetManagerIsHome,
                                                 @RequestBody
                                                 TemplateRequestBody requestBody)
        Create a new metadata element to represent a schema type using an existing metadata element as a template.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        templateGUID - unique identifier of the metadata element to copy
        assetManagerIsHome - ensure that only the asset manager can update this schema element
        requestBody - properties that override the template
        Returns:
        unique identifier of the new schema type InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • updateSchemaType

        @PostMapping(path="/schema-types/{schemaTypeGUID}")
public VoidResponse updateSchemaType​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String schemaTypeGUID,
                                     @RequestParam
                                     boolean isMergeUpdate,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     SchemaTypeRequestBody requestBody)
        Update the metadata element representing a schema type.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaTypeGUID - unique identifier of the metadata element to update
        isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - new properties for the metadata element
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • setupSchemaTypeParent

        @PostMapping(path="/parents/{parentElementGUID}/{parentElementTypeName}/schema-types/{schemaTypeGUID}")
public VoidResponse setupSchemaTypeParent​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String parentElementGUID,
                                          @PathVariable
                                          String parentElementTypeName,
                                          @PathVariable
                                          String schemaTypeGUID,
                                          @RequestParam
                                          boolean assetManagerIsHome,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forLineage,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forDuplicateProcessing,
                                          @RequestBody
                                          RelationshipRequestBody requestBody)
        Connect a schema type to a data asset, process or port.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaTypeGUID - unique identifier of the schema type to connect
        parentElementGUID - unique identifier of the open metadata element that this schema type is to be connected to
        parentElementTypeName - unique type name of the open metadata element that this schema type is to be connected to
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • clearSchemaTypeParent

        @PostMapping(path="/parents/{parentElementGUID}/{parentElementTypeName}/schema-types/{schemaTypeGUID}/remove")
public VoidResponse clearSchemaTypeParent​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String parentElementGUID,
                                          @PathVariable
                                          String parentElementTypeName,
                                          @PathVariable
                                          String schemaTypeGUID,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forLineage,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forDuplicateProcessing,
                                          @RequestBody
                                          EffectiveTimeQueryRequestBody requestBody)
        Remove the relationship between a schema type and its parent data asset, process or port.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaTypeGUID - unique identifier of the schema type to connect
        parentElementGUID - unique identifier of the open metadata element that this schema type is to be connected to
        parentElementTypeName - unique type name of the open metadata element that this schema type is to be connected to
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • setupSchemaElementRelationship

        @PostMapping(path="/schema-elements/{endOneGUID}/relationships/{relationshipTypeName}/schema-elements/{endTwoGUID}")
public VoidResponse setupSchemaElementRelationship​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String endOneGUID,
                                                   @PathVariable
                                                   String relationshipTypeName,
                                                   @PathVariable
                                                   String endTwoGUID,
                                                   @RequestParam
                                                   boolean assetManagerIsHome,
                                                   @RequestParam(required=false,defaultValue="false")
                                                   boolean forLineage,
                                                   @RequestParam(required=false,defaultValue="false")
                                                   boolean forDuplicateProcessing,
                                                   @RequestBody
                                                   RelationshipRequestBody requestBody)
        Create a relationship between two schema elements. The name of the desired relationship, and any properties (including effectivity dates) are passed on the API.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        endOneGUID - unique identifier of the schema element at end one of the relationship
        endTwoGUID - unique identifier of the schema element at end two of the relationship
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        relationshipTypeName - type of the relationship to create
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - relationship properties
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • clearSchemaElementRelationship

        @PostMapping(path="/schema-elements/{endOneGUID}/relationships/{relationshipTypeName}/schema-elements/{endTwoGUID}/remove")
public VoidResponse clearSchemaElementRelationship​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String endOneGUID,
                                                   @PathVariable
                                                   String relationshipTypeName,
                                                   @PathVariable
                                                   String endTwoGUID,
                                                   @RequestParam(required=false,defaultValue="false")
                                                   boolean forLineage,
                                                   @RequestParam(required=false,defaultValue="false")
                                                   boolean forDuplicateProcessing,
                                                   @RequestBody
                                                   EffectiveTimeQueryRequestBody requestBody)
        Remove a relationship between two schema elements. The name of the desired relationship is passed on the API.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        endOneGUID - unique identifier of the schema element at end one of the relationship
        endTwoGUID - unique identifier of the schema element at end two of the relationship
        relationshipTypeName - type of the relationship to delete
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • removeSchemaType

        @PostMapping(path="/schema-types/{schemaTypeGUID}/remove")
public VoidResponse removeSchemaType​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String schemaTypeGUID,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     UpdateRequestBody requestBody)
        Remove the metadata element representing a schema type.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaTypeGUID - unique identifier of the metadata element to remove
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller and external identifier of element
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • findSchemaType

        @PostMapping(path="/schema-types/by-search-string")
public SchemaTypeElementsResponse findSchemaType​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forLineage,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forDuplicateProcessing,
                                                 @RequestBody
                                                 SearchStringRequestBody requestBody)
        Retrieve the list of schema type metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - string to find in the properties plus external identifiers
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • getSchemaTypeForElement

        @PostMapping(path="/parents/{parentElementTypeName}/{parentElementGUID}/schema-types/retrieve")
public SchemaTypeElementResponse getSchemaTypeForElement​(@PathVariable
                                                         String serverName,
                                                         @PathVariable
                                                         String userId,
                                                         @PathVariable
                                                         String parentElementGUID,
                                                         @PathVariable
                                                         String parentElementTypeName,
                                                         @RequestParam(required=false,defaultValue="false")
                                                         boolean forLineage,
                                                         @RequestParam(required=false,defaultValue="false")
                                                         boolean forDuplicateProcessing,
                                                         @RequestBody
                                                         EffectiveTimeQueryRequestBody requestBody)
        Return the schema type associated with a specific open metadata element (data asset, process or port).
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        parentElementGUID - unique identifier of the open metadata element that this schema type is to be connected to
        parentElementTypeName - unique type name of the open metadata element that this schema type is to be connected to
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        metadata element describing the schema type associated with the requested parent element or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • getSchemaTypeByName

        @PostMapping(path="/schema-types/by-name")
public SchemaTypeElementsResponse getSchemaTypeByName​(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize,
                                                      @RequestParam(required=false,defaultValue="false")
                                                      boolean forLineage,
                                                      @RequestParam(required=false,defaultValue="false")
                                                      boolean forDuplicateProcessing,
                                                      @RequestBody
                                                      NameRequestBody requestBody)
        Retrieve the list of schema type metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - name to search for plus identifiers
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • getSchemaTypeByGUID

        @PostMapping(path="/schema-types/{schemaTypeGUID}/retrieve")
public SchemaTypeElementResponse getSchemaTypeByGUID​(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String schemaTypeGUID,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forLineage,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forDuplicateProcessing,
                                                     @RequestBody
                                                     EffectiveTimeQueryRequestBody requestBody)
        Retrieve the schema type metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaTypeGUID - unique identifier of the requested metadata element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        requested metadata element or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • getSchemaTypeParent

        @PostMapping(path="/parents/schema-types/{schemaTypeGUID}/retrieve")
public ElementHeaderResponse getSchemaTypeParent​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String schemaTypeGUID,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forLineage,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forDuplicateProcessing,
                                                 @RequestBody
                                                 EffectiveTimeQueryRequestBody requestBody)
        Retrieve the header of the metadata element connected to a schema type.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaTypeGUID - unique identifier of the requested metadata element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        header for parent element (data asset, process, port) or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • createSchemaAttribute

        @PostMapping(path="/schema-elements/{schemaElementGUID}/schema-attributes")
public GUIDResponse createSchemaAttribute​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String schemaElementGUID,
                                          @RequestParam
                                          boolean assetManagerIsHome,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forLineage,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forDuplicateProcessing,
                                          @RequestBody
                                          SchemaAttributeRequestBody requestBody)
        Create a new metadata element to represent a schema attribute.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the asset manager can update this schema attribute
        schemaElementGUID - unique identifier of the schemaType or Schema Attribute where the schema attribute is connected to
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for the schema attribute
        Returns:
        unique identifier of the new metadata element for the schema attribute or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • createSchemaAttributeFromTemplate

        @PostMapping(path="/schema-elements/{schemaElementGUID}/schema-attributes/from-template/{templateGUID}")
public GUIDResponse createSchemaAttributeFromTemplate​(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String schemaElementGUID,
                                                      @PathVariable
                                                      String templateGUID,
                                                      @RequestParam
                                                      boolean assetManagerIsHome,
                                                      @RequestParam(required=false,defaultValue="false")
                                                      boolean forLineage,
                                                      @RequestParam(required=false,defaultValue="false")
                                                      boolean forDuplicateProcessing,
                                                      @RequestBody
                                                      TemplateRequestBody requestBody)
        Create a new metadata element to represent a schema attribute using an existing metadata element as a template.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaElementGUID - unique identifier of the schemaType or Schema Attribute where the schema attribute is connected to
        templateGUID - unique identifier of the metadata element to copy
        assetManagerIsHome - ensure that only the asset manager can update this schema element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties that override the template
        Returns:
        unique identifier of the new metadata element for the schema attribute or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • updateSchemaAttribute

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}")
public VoidResponse updateSchemaAttribute​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String schemaAttributeGUID,
                                          @RequestParam
                                          boolean isMergeUpdate,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forLineage,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forDuplicateProcessing,
                                          @RequestBody
                                          SchemaAttributeRequestBody requestBody)
        Update the properties of the metadata element representing a schema attribute.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaAttributeGUID - unique identifier of the schema attribute to update
        isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - new properties for the schema attribute
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • setSchemaElementAsCalculatedValue

        @PostMapping(path="/schema-elements/{schemaElementGUID}/is-calculated-value")
public VoidResponse setSchemaElementAsCalculatedValue​(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String schemaElementGUID,
                                                      @RequestParam
                                                      boolean assetManagerIsHome,
                                                      @RequestParam(required=false,defaultValue="false")
                                                      boolean forLineage,
                                                      @RequestParam(required=false,defaultValue="false")
                                                      boolean forDuplicateProcessing,
                                                      @RequestBody
                                                      UpdateRequestBody requestBody)
        Classify the schema type (or attribute if type is embedded) to indicate that it is a calculated value.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaElementGUID - unique identifier of the metadata element to update
        assetManagerIsHome - ensure that only the asset manager can update this classification
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller and external identifier of element
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • clearSchemaElementAsCalculatedValue

        @PostMapping(path="/schema-elements/{schemaElementGUID}/is-calculated-value/remove")
public VoidResponse clearSchemaElementAsCalculatedValue​(@PathVariable
                                                        String serverName,
                                                        @PathVariable
                                                        String userId,
                                                        @PathVariable
                                                        String schemaElementGUID,
                                                        @RequestParam(required=false,defaultValue="false")
                                                        boolean forLineage,
                                                        @RequestParam(required=false,defaultValue="false")
                                                        boolean forDuplicateProcessing,
                                                        @RequestBody
                                                        UpdateRequestBody requestBody)
        Remove the calculated value designation from the schema element.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaElementGUID - unique identifier of the metadata element to update
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller and external identifier of element
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • setupColumnAsPrimaryKey

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}/is-primary-key")
public VoidResponse setupColumnAsPrimaryKey​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String schemaAttributeGUID,
                                            @RequestParam
                                            boolean assetManagerIsHome,
                                            @RequestParam(required=false,defaultValue="false")
                                            boolean forLineage,
                                            @RequestParam(required=false,defaultValue="false")
                                            boolean forDuplicateProcessing,
                                            @RequestBody
                                            PrimaryKeyClassificationRequestBody requestBody)
        Classify the column schema attribute to indicate that it describes a primary key.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the asset manager can update this classification
        schemaAttributeGUID - unique identifier of the metadata element to update
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - details of the primary key plus external identifiers
        Returns:
        null or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • clearColumnAsPrimaryKey

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}/is-primary-key/remove")
public VoidResponse clearColumnAsPrimaryKey​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String schemaAttributeGUID,
                                            @RequestParam(required=false,defaultValue="false")
                                            boolean forLineage,
                                            @RequestParam(required=false,defaultValue="false")
                                            boolean forDuplicateProcessing,
                                            @RequestBody
                                            UpdateRequestBody requestBody)
        Remove the primary key designation from the schema attribute.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaAttributeGUID - unique identifier of the metadata element to update
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller and external identifier of element
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • setupForeignKeyRelationship

        @PostMapping(path="/schema-attributes/{primaryKeyGUID}/relationships/foreign-keys/{foreignKeyGUID}")
public VoidResponse setupForeignKeyRelationship​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @PathVariable
                                                String primaryKeyGUID,
                                                @PathVariable
                                                String foreignKeyGUID,
                                                @RequestParam
                                                boolean assetManagerIsHome,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forLineage,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forDuplicateProcessing,
                                                @RequestBody
                                                ForeignKeyRequestBody requestBody)
        Link two schema attributes together to show a foreign key relationship.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        primaryKeyGUID - unique identifier of the derived schema element
        foreignKeyGUID - unique identifier of the query target schema element
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for the foreign key relationship
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • updateForeignKeyRelationship

        @PostMapping(path="/schema-attributes/{primaryKeyGUID}/relationships/foreign-keys/{foreignKeyGUID}/update")
public VoidResponse updateForeignKeyRelationship​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String primaryKeyGUID,
                                                 @PathVariable
                                                 String foreignKeyGUID,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forLineage,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forDuplicateProcessing,
                                                 @RequestBody
                                                 ForeignKeyRequestBody requestBody)
        Update the relationship properties for the query target.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        primaryKeyGUID - unique identifier of the derived schema element
        foreignKeyGUID - unique identifier of the query target schema element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for the foreign key relationship plus external identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • clearForeignKeyRelationship

        @PostMapping(path="/schema-attributes/{primaryKeyGUID}/relationships/foreign-keys/{foreignKeyGUID}/remove")
public VoidResponse clearForeignKeyRelationship​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @PathVariable
                                                String primaryKeyGUID,
                                                @PathVariable
                                                String foreignKeyGUID,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forLineage,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forDuplicateProcessing,
                                                @RequestBody
                                                EffectiveTimeQueryRequestBody requestBody)
        Remove the foreign key relationship between two schema elements.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        primaryKeyGUID - unique identifier of the derived schema element
        foreignKeyGUID - unique identifier of the query target schema element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • removeSchemaAttribute

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}/remove")
public VoidResponse removeSchemaAttribute​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String schemaAttributeGUID,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forLineage,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forDuplicateProcessing,
                                          @RequestBody
                                          UpdateRequestBody requestBody)
        Remove the metadata element representing a schema attribute.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaAttributeGUID - unique identifier of the metadata element to remove
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller and external identifier of element
        Returns:
        void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • findSchemaAttributes

        @PostMapping(path="/schema-attributes/by-search-string")
public SchemaAttributeElementsResponse findSchemaAttributes​(@PathVariable
                                                            String serverName,
                                                            @PathVariable
                                                            String userId,
                                                            @RequestParam
                                                            int startFrom,
                                                            @RequestParam
                                                            int pageSize,
                                                            @RequestParam(required=false,defaultValue="false")
                                                            boolean forLineage,
                                                            @RequestParam(required=false,defaultValue="false")
                                                            boolean forDuplicateProcessing,
                                                            @RequestBody
                                                            SearchStringRequestBody requestBody)
        Retrieve the list of schema attribute metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - string to find in the properties plus external identifiers
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • getNestedAttributes

        @PostMapping(path="/schema-elements/{parentSchemaElementGUID}/schema-attributes/retrieve")
public SchemaAttributeElementsResponse getNestedAttributes​(@PathVariable
                                                           String serverName,
                                                           @PathVariable
                                                           String userId,
                                                           @PathVariable
                                                           String parentSchemaElementGUID,
                                                           @RequestParam
                                                           int startFrom,
                                                           @RequestParam
                                                           int pageSize,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forLineage,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forDuplicateProcessing,
                                                           @RequestBody
                                                           EffectiveTimeQueryRequestBody requestBody)
        Retrieve the list of schema attributes associated with a schema element.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        parentSchemaElementGUID - unique identifier of the schema element of interest
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        list of associated metadata elements or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • getSchemaAttributesByName

        @PostMapping(path="/schema-attributes/by-name")
public SchemaAttributeElementsResponse getSchemaAttributesByName​(@PathVariable
                                                                 String serverName,
                                                                 @PathVariable
                                                                 String userId,
                                                                 @RequestParam
                                                                 int startFrom,
                                                                 @RequestParam
                                                                 int pageSize,
                                                                 @RequestParam(required=false,defaultValue="false")
                                                                 boolean forLineage,
                                                                 @RequestParam(required=false,defaultValue="false")
                                                                 boolean forDuplicateProcessing,
                                                                 @RequestBody
                                                                 NameRequestBody requestBody)
        Retrieve the list of schema attribute metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • getSchemaAttributeByGUID

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}/retrieve")
public SchemaAttributeElementResponse getSchemaAttributeByGUID​(@PathVariable
                                                               String serverName,
                                                               @PathVariable
                                                               String userId,
                                                               @PathVariable
                                                               String schemaAttributeGUID,
                                                               @RequestParam(required=false,defaultValue="false")
                                                               boolean forLineage,
                                                               @RequestParam(required=false,defaultValue="false")
                                                               boolean forDuplicateProcessing,
                                                               @RequestBody
                                                               EffectiveTimeQueryRequestBody requestBody)
        Retrieve the schema attribute metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        schemaAttributeGUID - unique identifier of the requested metadata element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier/name of software server capability representing the caller
        Returns:
        matching metadata element or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)