java.lang.Object
org.odpi.openmetadata.accessservices.assetmanager.server.spring.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 Details

    • SchemaExchangeResource

      public SchemaExchangeResource()
      Default constructor
  • Method Details

    • 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)