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

Class SchemaManagerResource

  • @RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/data-manager/users/{userId}")
public class SchemaManagerResource
extends Object
    SchemaManagerResource is the server-side implementation of the Data Manager OMAS's support for relational topics. It matches the SchemaManagerClient.

    • Constructor Detail

      • SchemaManagerResource

        public SchemaManagerResource()
        Default constructor

    • Method Detail

      • createPrimitiveSchemaType

        @PostMapping(path="/schema-types/primitives")
public GUIDResponse createPrimitiveSchemaType​(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @RequestBody
                                              PrimitiveSchemaTypeRequestBody requestBody)
        Create a new metadata element to represent a primitive schema type such as a string, integer or character.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - properties about the schema type to store
        Returns:
        unique identifier of the new schema type 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)

      • createLiteralSchemaType

        @PostMapping(path="/schema-types/literals")
public GUIDResponse createLiteralSchemaType​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @RequestBody
                                            LiteralSchemaTypeRequestBody requestBody)
        Create a new metadata element to represent a schema type that has a fixed value.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - properties about the schema type to store
        Returns:
        unique identifier of the new schema type 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)

      • createEnumSchemaType

        @PostMapping(path="/schema-types/enums/valid-values/{validValuesSetGUID}")
public GUIDResponse createEnumSchemaType​(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String validValuesSetGUID,
                                         @RequestBody
                                         EnumSchemaTypeRequestBody requestBody)
        Create a new metadata element to represent a schema type that has a fixed set of values that are described by a valid value set.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        validValuesSetGUID - unique identifier of the valid values set to used
        requestBody - properties about the schema type to store
        Returns:
        unique identifier of the new schema type 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)

      • getValidValueSetByName

        @PostMapping(path="/valid-value-sets/by-name}")
public ValidValueSetsResponse getValidValueSetByName​(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @RequestBody
                                                     NameRequestBody requestBody,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize)
        Retrieve the list of valid value set metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - name to search for
        startFrom - paging start point
        pageSize - maximum results that can be returned
        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)

      • findValidValueSet

        @PostMapping(path="/valid-value-sets/by-search-string")
public ValidValueSetsResponse findValidValueSet​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @RequestBody
                                                SearchStringRequestBody requestBody,
                                                @RequestParam
                                                int startFrom,
                                                @RequestParam
                                                int pageSize)
        Retrieve the list of valid value set metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - string to find in the properties
        startFrom - paging start point
        pageSize - maximum results that can be returned
        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)

      • createStructSchemaType

        @PostMapping(path="/schema-types/structs")
public GUIDResponse createStructSchemaType​(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @RequestBody
                                           StructSchemaTypeRequestBody requestBody)
        Create a new metadata element to represent a schema type.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - properties about the schema type to store
        Returns:
        unique identifier of the new schema type 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)

      • createSchemaTypeChoice

        @PostMapping(path="/schema-types/choices")
public GUIDResponse createSchemaTypeChoice​(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @RequestBody
                                           SchemaTypeChoiceRequestBody requestBody)
        Create a new metadata element to represent a list of possible schema types that can be used for the attached schema attribute.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - properties about the schema type to store
        Returns:
        unique identifier of the new schema type 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)

      • createMapSchemaType

        @PostMapping(path="/schema-types/maps/from/{mapFromSchemaTypeGUID}/to/{mapToSchemaTypeGUID}")
public GUIDResponse createMapSchemaType​(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String mapFromSchemaTypeGUID,
                                        @PathVariable
                                        String mapToSchemaTypeGUID,
                                        @RequestBody
                                        MapSchemaTypeRequestBody requestBody)
        Create a new metadata element to represent a schema type.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        mapFromSchemaTypeGUID - unique identifier of the the domain of the map
        mapToSchemaTypeGUID - unique identifier of the the range of the map
        requestBody - properties about the schema type to store
        Returns:
        unique identifier of the new schema type 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)

      • createSchemaTypeFromTemplate

        @PostMapping(path="/schema-types/from-template/{templateGUID}")
public GUIDResponse createSchemaTypeFromTemplate​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String templateGUID,
                                                 @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 service to route the request to.
        userId - calling user
        templateGUID - unique identifier of the metadata element to copy
        requestBody - properties that override the template
        Returns:
        unique identifier of the new schema type 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)

      • updateSchemaType

        @PostMapping(path="/schema-types/{schemaTypeGUID}")
public VoidResponse updateSchemaType​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String schemaTypeGUID,
                                     @RequestParam
                                     boolean isMergeUpdate,
                                     @RequestBody
                                     SchemaTypeRequestBody requestBody)
        Update the metadata element representing a schema type. It is possible to use the subtype property classes or set up specialized properties in extended properties.
        Parameters:
        serverName - name of the service 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)?
        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)

      • removeSchemaType

        @PostMapping(path="/schema-types/{schemaTypeGUID}/delete")
public VoidResponse removeSchemaType​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String schemaTypeGUID,
                                     @RequestBody
                                     MetadataSourceRequestBody requestBody)
        Remove the metadata element representing a schema type.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        schemaTypeGUID - unique identifier of the metadata element to remove
        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)

      • findSchemaType

        @PostMapping(path="/schema-types/types/{typeName}/by-search-string")
public SchemaTypesResponse findSchemaType​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String typeName,
                                          @RequestBody
                                          SearchStringRequestBody requestBody,
                                          @RequestParam
                                          int startFrom,
                                          @RequestParam
                                          int pageSize)
        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 service to route the request to.
        userId - calling user
        requestBody - string to find in the properties
        typeName - optional type name for the schema type - used to restrict the search results
        startFrom - paging start point
        pageSize - maximum results that can be returned
        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

        @GetMapping(path="/schema-types/types/{parentElementTypeName}/by-parent-element/{parentElementGUID}")
public SchemaTypeResponse getSchemaTypeForElement​(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @PathVariable
                                                  String parentElementGUID,
                                                  @PathVariable
                                                  String parentElementTypeName)
        Return the schema type associated with a specific open metadata element (data asset, process or port).
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        parentElementGUID - unique identifier of the open metadata element that this schema type is connected to
        parentElementTypeName - unique type name of the open metadata element that this schema type is connected to
        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/types/{typeName}/by-name")
public SchemaTypesResponse getSchemaTypeByName​(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String typeName,
                                               @RequestBody
                                               NameRequestBody requestBody,
                                               @RequestParam
                                               int startFrom,
                                               @RequestParam
                                               int pageSize)
        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 service to route the request to.
        userId - calling user
        requestBody - name to search for
        typeName - optional type name for the schema type - used to restrict the search results
        startFrom - paging start point
        pageSize - maximum results that can be returned
        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

        @GetMapping(path="/schema-types/{schemaTypeGUID}")
public SchemaTypeResponse getSchemaTypeByGUID​(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @PathVariable
                                              String schemaTypeGUID)
        Retrieve the schema type metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        schemaTypeGUID - unique identifier of the requested metadata element
        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

        @GetMapping(path="/schema-types/{schemaTypeGUID}/parent")
public ElementStubResponse getSchemaTypeParent​(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String schemaTypeGUID)
        Retrieve the header of the metadata element connected to a schema type.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        schemaTypeGUID - unique identifier of the requested metadata element
        Returns:
        header for parent element (data asset, process, port) plus qualified name 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-attributes/attached-to/{schemaElementGUID}")
public GUIDResponse createSchemaAttribute​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String schemaElementGUID,
                                          @RequestBody
                                          SchemaAttributeRequestBody requestBody)
        Create a new metadata element to represent a schema attribute.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        schemaElementGUID - unique identifier of the schemaType or Schema Attribute where the schema attribute is nested underneath
        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-attributes/from-template/{templateGUID}/attached-to/{schemaElementGUID}")
public GUIDResponse createSchemaAttributeFromTemplate​(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String schemaElementGUID,
                                                      @PathVariable
                                                      String templateGUID,
                                                      @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 service 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
        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)

      • setupSchemaType

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}/schema-types/{schemaTypeGUID}/relationship-type-name/{relationshipTypeName}")
public VoidResponse setupSchemaType​(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String relationshipTypeName,
                                    @PathVariable
                                    String schemaAttributeGUID,
                                    @PathVariable
                                    String schemaTypeGUID,
                                    @RequestBody
                                    MetadataSourceRequestBody requestBody)
        Connect a schema type to a schema attribute.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        relationshipTypeName - name of relationship to create
        schemaAttributeGUID - unique identifier of the schema attribute
        schemaTypeGUID - unique identifier of the schema type to connect
        requestBody - unique identifier 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)

      • clearSchemaTypes

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}/schema-types/delete")
public VoidResponse clearSchemaTypes​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String schemaAttributeGUID,
                                     @RequestBody
                                     MetadataSourceRequestBody requestBody)
        Remove the linked schema types from a schema attribute.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        schemaAttributeGUID - unique identifier of the schema attribute
        requestBody - unique identifier 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)

      • updateSchemaAttribute

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}")
public VoidResponse updateSchemaAttribute​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String schemaAttributeGUID,
                                          @RequestParam
                                          boolean isMergeUpdate,
                                          @RequestBody
                                          SchemaAttributeRequestBody requestBody)
        Update the properties of the metadata element representing a schema attribute.
        Parameters:
        serverName - name of the service 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)?
        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)

      • removeSchemaAttribute

        @PostMapping(path="/schema-attributes/{schemaAttributeGUID}/delete")
public VoidResponse removeSchemaAttribute​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String schemaAttributeGUID,
                                          @RequestBody
                                          MetadataSourceRequestBody requestBody)
        Remove the metadata element representing a schema attribute.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - unique identifier of software server capability representing the caller
        schemaAttributeGUID - unique identifier of the metadata element to remove
        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/types/{typeName}/by-search-string")
public SchemaAttributesResponse findSchemaAttributes​(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String typeName,
                                                     @RequestBody
                                                     SearchStringRequestBody requestBody,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize)
        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 service to route the request to.
        userId - calling user
        requestBody - string to find in the properties
        typeName - optional type name for the schema type - used to restrict the search results
        startFrom - paging start point
        pageSize - maximum results that can be returned
        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

        @GetMapping(path="/schema-attributes/{parentSchemaElementGUID}/nested-attributes")
public SchemaAttributesResponse getNestedAttributes​(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String parentSchemaElementGUID,
                                                    @RequestParam
                                                    int startFrom,
                                                    @RequestParam
                                                    int pageSize)
        Retrieve the list of schema attributes associated with a StructSchemaType or nested underneath a schema attribute.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        parentSchemaElementGUID - unique identifier of the schemaType of interest
        startFrom - paging start point
        pageSize - maximum results that can be returned
        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/types/{typeName}/by-name")
public SchemaAttributesResponse getSchemaAttributesByName​(@PathVariable
                                                          String serverName,
                                                          @PathVariable
                                                          String userId,
                                                          @PathVariable
                                                          String typeName,
                                                          @RequestBody
                                                          NameRequestBody requestBody,
                                                          @RequestParam
                                                          int startFrom,
                                                          @RequestParam
                                                          int pageSize)
        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 service to route the request to.
        userId - calling user
        requestBody - name to search for
        typeName - optional type name for the schema type - used to restrict the search results
        startFrom - paging start point
        pageSize - maximum results that can be returned
        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

        @GetMapping(path="/schema-attributes/{schemaAttributeGUID}")
public SchemaAttributeResponse getSchemaAttributeByGUID​(@PathVariable
                                                        String serverName,
                                                        @PathVariable
                                                        String userId,
                                                        @PathVariable
                                                        String schemaAttributeGUID)
        Retrieve the schema attribute metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        schemaAttributeGUID - unique identifier of the requested metadata element
        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)

      • setupCalculatedValue

        @PostMapping(path="/schema-elements/{schemaElementGUID}/calculated-value")
public VoidResponse setupCalculatedValue​(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String schemaElementGUID,
                                         @RequestBody
                                         FormulaRequestBody requestBody)
        Classify the schema element to indicate that it describes a calculated value.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        schemaElementGUID - unique identifier of the metadata element to update
        requestBody - requestBody for calculating the value - this may contain placeholders that are identified by the queryIds used in the queryTarget relationships
        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)

      • clearCalculatedValue

        @PostMapping(path="/schema-elements/{schemaElementGUID}/calculated-value/delete")
public VoidResponse clearCalculatedValue​(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String schemaElementGUID,
                                         @RequestBody
                                         MetadataSourceRequestBody requestBody)
        Remove the calculated value designation from the schema element.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        schemaElementGUID - unique identifier of the metadata element to update
        requestBody - unique identifier 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)

      • setupQueryTargetRelationship

        @PostMapping(path="/schema-elements/{derivedElementGUID}/query-targets/{queryTargetGUID}")
public VoidResponse setupQueryTargetRelationship​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String derivedElementGUID,
                                                 @PathVariable
                                                 String queryTargetGUID,
                                                 @RequestBody
                                                 DerivedSchemaTypeQueryTargetRequestBody requestBody)
        Link two schema elements together to show a query target relationship. The query target provides data values to calculate a derived value.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        derivedElementGUID - unique identifier of the derived schema element
        queryTargetGUID - unique identifier of the query target schema element
        requestBody - properties for the query target 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)

      • updateQueryTargetRelationship

        @PostMapping(path="/schema-elements/{derivedElementGUID}/query-targets/{queryTargetGUID}/update")
public VoidResponse updateQueryTargetRelationship​(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @PathVariable
                                                  String derivedElementGUID,
                                                  @PathVariable
                                                  String queryTargetGUID,
                                                  @RequestBody
                                                  DerivedSchemaTypeQueryTargetRequestBody requestBody)
        Update the relationship properties for the query target.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        derivedElementGUID - unique identifier of the derived schema element
        queryTargetGUID - unique identifier of the query target schema element
        requestBody - properties for the query target 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)

      • clearQueryTargetRelationship

        @PostMapping(path="/schema-elements/{derivedElementGUID}/query-targets/{queryTargetGUID}/delete")
public VoidResponse clearQueryTargetRelationship​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String derivedElementGUID,
                                                 @PathVariable
                                                 String queryTargetGUID,
                                                 @RequestBody
                                                 MetadataSourceRequestBody requestBody)
        Remove the query target relationship between two schema elements.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - unique identifier of software server capability representing the caller
        derivedElementGUID - unique identifier of the derived schema element
        queryTargetGUID - unique identifier of the query target schema 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)