java.lang.Object
- org.odpi.openmetadata.accessservices.datamanager.server.spring.DatabaseManagerResource

@RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/data-manager/users/{userId}")
public class DatabaseManagerResource
extends Object

DatabaseManagerRESTServices is the server-side implementation of the Data Manager OMAS's support for relational databases. It matches the DatabaseManagerClient.

Constructor Summary

Constructors
Constructor Description

DatabaseManagerResource()
Default constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`VoidResponse`	`addForeignKeyRelationship(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String primaryKeyColumnGUID, String foreignKeyColumnGUID, DatabaseForeignKeyProperties databaseForeignKeyProperties)`	Create a foreign relationship between two columns.
`VoidResponse`	`attachSchemaTypeToDatabaseAsset(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseAssetGUID, String schemaTypeGUID, NullRequestBody requestBody)`	Link the schema type and asset.
`GUIDResponse`	`createDatabase(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, DatabaseProperties databaseProperties)`	Create a new metadata element to represent a database.
`GUIDResponse`	`createDatabaseColumn(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseTableGUID, DatabaseColumnProperties databaseColumnProperties)`	Create a new metadata element to represent a database column.
`GUIDResponse`	`createDatabaseColumnFromTemplate(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String templateGUID, String databaseTableGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent a database column using an existing metadata element as a template.
`GUIDResponse`	`createDatabaseFromTemplate(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String templateGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent a database using an existing metadata element as a template.
`GUIDResponse`	`createDatabaseSchema(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseGUID, DatabaseSchemaProperties databaseSchemaProperties)`	Create a new metadata element to represent a database schema.
`GUIDResponse`	`createDatabaseSchemaFromTemplate(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String templateGUID, String databaseGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent a database schema using an existing metadata element as a template.
`GUIDResponse`	`createDatabaseSchemaType(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, NameRequestBody requestBody)`	Create a database top-level schema type used to attach tables and views to the database/database schema.
`GUIDResponse`	`createDatabaseTable(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseAssetGUID, DatabaseTableProperties databaseTableProperties)`	Create a new metadata element to represent a database table.
`GUIDResponse`	`createDatabaseTableForSchemaType(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseSchemaTypeGUID, DatabaseTableProperties databaseTableProperties)`	Create a new metadata element to represent a database table.
`GUIDResponse`	`createDatabaseTableFromTemplate(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String templateGUID, String databaseAssetGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent a database table using an existing metadata element as a template.
`GUIDResponse`	`createDatabaseView(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseAssetGUID, DatabaseViewProperties databaseViewProperties)`	Create a new metadata element to represent a database view.
`GUIDResponse`	`createDatabaseViewForSchemaType(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseSchemaTypeGUID, DatabaseViewProperties databaseViewProperties)`	Create a new metadata element to represent a database view.
`GUIDResponse`	`createDatabaseViewFromTemplate(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String templateGUID, String databaseAssetGUID, TemplateProperties templateProperties)`	Create a new metadata element to represent a database view using an existing metadata element as a template.
`DatabaseColumnsResponse`	`findDatabaseColumns(String serverName, String userId, SearchStringRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database column metadata elements that contain the search string.
`DatabasesResponse`	`findDatabases(String serverName, String userId, SearchStringRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database metadata elements that contain the search string.
`DatabaseSchemasResponse`	`findDatabaseSchemas(String serverName, String userId, SearchStringRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database schema metadata elements that contain the search string.
`DatabaseTablesResponse`	`findDatabaseTables(String serverName, String userId, SearchStringRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database table metadata elements that contain the search string.
`DatabaseViewsResponse`	`findDatabaseViews(String serverName, String userId, SearchStringRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database view metadata elements that contain the search string.
`DatabaseColumnsResponse`	`getColumnsForDatabaseTable(String serverName, String userId, String databaseTableGUID, int startFrom, int pageSize)`	Retrieve the list of column for a database table (or view)
`DatabaseResponse`	`getDatabaseByGUID(String serverName, String userId, String guid)`	Retrieve the database metadata element with the supplied unique identifier.
`DatabaseColumnResponse`	`getDatabaseColumnByGUID(String serverName, String userId, String guid)`	Retrieve the database column metadata element with the supplied unique identifier.
`DatabaseColumnsResponse`	`getDatabaseColumnsByName(String serverName, String userId, NameRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database column metadata elements with a matching qualified or display name.
`DatabasesResponse`	`getDatabasesByName(String serverName, String userId, NameRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database metadata elements with a matching qualified or display name.
`DatabaseSchemaResponse`	`getDatabaseSchemaByGUID(String serverName, String userId, String guid)`	Retrieve the database schema metadata element with the supplied unique identifier.
`DatabaseSchemasResponse`	`getDatabaseSchemasByName(String serverName, String userId, NameRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database schema metadata elements with a matching qualified or display name.
`DatabasesResponse`	`getDatabasesForDatabaseManager(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, int startFrom, int pageSize)`	Retrieve the list of databases created by this database manager.
`DatabaseTableResponse`	`getDatabaseTableByGUID(String serverName, String userId, String guid)`	Retrieve the database table metadata element with the supplied unique identifier.
`DatabaseTablesResponse`	`getDatabaseTablesByName(String serverName, String userId, NameRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database table metadata elements with a matching qualified or display name.
`DatabaseViewResponse`	`getDatabaseViewByGUID(String serverName, String userId, String guid)`	Retrieve the database view metadata element with the supplied unique identifier.
`DatabaseViewsResponse`	`getDatabaseViewsByName(String serverName, String userId, NameRequestBody requestBody, int startFrom, int pageSize)`	Retrieve the list of database view metadata elements with a matching qualified or display name.
`DatabaseSchemasResponse`	`getSchemasForDatabase(String serverName, String userId, String databaseGUID, int startFrom, int pageSize)`	Return the list of schemas associated with a database.
`DatabaseTablesResponse`	`getTablesForDatabaseAsset(String serverName, String userId, String databaseAssetGUID, int startFrom, int pageSize)`	Retrieve the list of database tables associated with a database or database schema.
`DatabaseViewsResponse`	`getViewsForDatabaseAsset(String serverName, String userId, String databaseAssetGUID, int startFrom, int pageSize)`	Retrieve the list of database views associated with a database or database schema.
`VoidResponse`	`publishDatabase(String serverName, String userId, String databaseGUID, NullRequestBody nullRequestBody)`	Update the zones for the database asset so that it becomes visible to consumers.
`VoidResponse`	`publishDatabaseSchema(String serverName, String userId, String databaseSchemaGUID, NullRequestBody nullRequestBody)`	Update the zones for the database asset so that it becomes visible to consumers.
`VoidResponse`	`removeDatabase(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseGUID, String qualifiedName, NullRequestBody nullRequestBody)`	Remove the metadata element representing a database.
`VoidResponse`	`removeDatabaseColumn(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseColumnGUID, String qualifiedName, NullRequestBody nullRequestBody)`	Remove the metadata element representing a database column.
`VoidResponse`	`removeDatabaseSchema(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseSchemaGUID, String qualifiedName, NullRequestBody nullRequestBody)`	Remove the metadata element representing a database schema.
`VoidResponse`	`removeDatabaseTable(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseTableGUID, String qualifiedName, NullRequestBody nullRequestBody)`	Remove the metadata element representing a database table.
`VoidResponse`	`removeDatabaseView(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseViewGUID, String qualifiedName, NullRequestBody nullRequestBody)`	Remove the metadata element representing a database table.
`VoidResponse`	`removeForeignKeyRelationship(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String primaryKeyColumnGUID, String foreignKeyColumnGUID, NullRequestBody nullRequestBody)`	Remove the foreign key relationship for the requested columns.
`VoidResponse`	`removePrimaryKeyFromColumn(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseColumnGUID, NullRequestBody nullRequestBody)`	Remove the classification that this column is a primary key.
`VoidResponse`	`setPrimaryKeyOnColumn(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseColumnGUID, DatabasePrimaryKeyProperties databasePrimaryKeyProperties)`	Classify a column in a database table as the primary key.
`VoidResponse`	`updateDatabase(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseGUID, DatabaseProperties databaseProperties)`	Update the metadata element representing a database.
`VoidResponse`	`updateDatabaseColumn(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseColumnGUID, DatabaseColumnProperties databaseColumnProperties)`	Update the metadata element representing a database column.
`VoidResponse`	`updateDatabaseSchema(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseSchemaGUID, DatabaseSchemaProperties databaseSchemaProperties)`	Update the metadata element representing a database schema.
`VoidResponse`	`updateDatabaseTable(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseTableGUID, DatabaseTableProperties databaseTableProperties)`	Update the metadata element representing a database table.
`VoidResponse`	`updateDatabaseView(String serverName, String userId, String databaseManagerGUID, String databaseManagerName, String databaseViewGUID, DatabaseViewProperties databaseViewProperties)`	Update the metadata element representing a database table.
`VoidResponse`	`withdrawDatabase(String serverName, String userId, String databaseGUID, NullRequestBody nullRequestBody)`	Update the zones for the database asset so that it is no longer visible to consumers.
`VoidResponse`	`withdrawDatabaseSchema(String serverName, String userId, String databaseSchemaGUID, NullRequestBody nullRequestBody)`	Update the zones for the database asset so that it is no longer visible to consumers.

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

Constructor Detail
- DatabaseManagerResource
```
public DatabaseManagerResource()
```
  Default constructor

Method Detail

createDatabase

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases")
public GUIDResponse createDatabase(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String databaseManagerGUID,
                                   @PathVariable
                                   String databaseManagerName,
                                   @RequestBody
                                   DatabaseProperties databaseProperties)

Create a new metadata element to represent a database.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseProperties - properties to store
Returns:: unique identifier of the new metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseFromTemplate

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/from-template/{templateGUID}")
public GUIDResponse createDatabaseFromTemplate(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String databaseManagerGUID,
                                               @PathVariable
                                               String databaseManagerName,
                                               @PathVariable
                                               String templateGUID,
                                               @RequestBody
                                               TemplateProperties templateProperties)

Create a new metadata element to represent a database using an existing metadata element as a template.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; templateGUID - unique identifier of the metadata element to copy; templateProperties - properties that override the template
Returns:: unique identifier of the new metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

updateDatabase

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/{databaseGUID}")
public VoidResponse updateDatabase(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String databaseManagerGUID,
                                   @PathVariable
                                   String databaseManagerName,
                                   @PathVariable
                                   String databaseGUID,
                                   @RequestBody
                                   DatabaseProperties databaseProperties)

Update the metadata element representing a database.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseGUID - unique identifier of the metadata element to update; databaseProperties - new properties for this element
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

publishDatabase

@PostMapping(path="/databases/{databaseGUID}/publish")
public VoidResponse publishDatabase(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String databaseGUID,
                                    @RequestBody(required=false)
                                    NullRequestBody nullRequestBody)

Update the zones for the database asset so that it becomes visible to consumers. (The zones are set to the list of zones in the publishedZones option configured for each instance of the Data Manager OMAS).

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseGUID - unique identifier of the metadata element to publish; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

withdrawDatabase
```
@PostMapping(path="/databases/{databaseGUID}/withdraw")
public VoidResponse withdrawDatabase(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String databaseGUID,
                                     @RequestBody(required=false)
                                     NullRequestBody nullRequestBody)
```
Update the zones for the database asset so that it is no longer visible to consumers. (The zones are set to the list of zones in the defaultZones option configured for each instance of the Data Manager OMAS. This is the setting when the database is first created).

Parameters:

serverName - name of the service to route the request to.

userId - calling user

databaseGUID - unique identifier of the metadata element to withdraw

nullRequestBody - empty request body

Returns:

void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

removeDatabase

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/{databaseGUID}/{qualifiedName}/delete")
public VoidResponse removeDatabase(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String databaseManagerGUID,
                                   @PathVariable
                                   String databaseManagerName,
                                   @PathVariable
                                   String databaseGUID,
                                   @PathVariable
                                   String qualifiedName,
                                   @RequestBody(required=false)
                                   NullRequestBody nullRequestBody)

Remove the metadata element representing a database.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseGUID - unique identifier of the metadata element to remove; qualifiedName - unique name of the metadata element to remove; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

findDatabases

@PostMapping(path="/databases/by-search-string")
public DatabasesResponse findDatabases(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @RequestBody
                                       SearchStringRequestBody requestBody,
                                       @RequestParam
                                       int startFrom,
                                       @RequestParam
                                       int pageSize)

Retrieve the list of database 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabasesByName

@PostMapping(path="/databases/by-name")
public DatabasesResponse getDatabasesByName(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @RequestBody
                                            NameRequestBody requestBody,
                                            @RequestParam
                                            int startFrom,
                                            @RequestParam
                                            int pageSize)

Retrieve the list of database 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabasesForDatabaseManager

@GetMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases")
public DatabasesResponse getDatabasesForDatabaseManager(@PathVariable
                                                        String serverName,
                                                        @PathVariable
                                                        String userId,
                                                        @PathVariable
                                                        String databaseManagerGUID,
                                                        @PathVariable
                                                        String databaseManagerName,
                                                        @RequestParam
                                                        int startFrom,
                                                        @RequestParam
                                                        int pageSize)

Retrieve the list of databases created by this database manager.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseByGUID

@GetMapping(path="/databases/{guid}")
public DatabaseResponse getDatabaseByGUID(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String guid)

Retrieve the database metadata element with the supplied unique identifier.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; guid - unique identifier of the requested metadata element
Returns:: matching metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseSchema

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/{databaseGUID}/schemas")
public GUIDResponse createDatabaseSchema(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String databaseManagerGUID,
                                         @PathVariable
                                         String databaseManagerName,
                                         @PathVariable
                                         String databaseGUID,
                                         @RequestBody
                                         DatabaseSchemaProperties databaseSchemaProperties)

Create a new metadata element to represent a database schema.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseGUID - unique identifier of the database where the schema is located; databaseSchemaProperties - properties about the database schema
Returns:: unique identifier of the new database schema or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseSchemaFromTemplate

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/{databaseGUID}/schemas/from-template/{templateGUID}")
public GUIDResponse createDatabaseSchemaFromTemplate(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String databaseManagerGUID,
                                                     @PathVariable
                                                     String databaseManagerName,
                                                     @PathVariable
                                                     String templateGUID,
                                                     @PathVariable
                                                     String databaseGUID,
                                                     @RequestBody
                                                     TemplateProperties templateProperties)

Create a new metadata element to represent a database schema using an existing metadata element as a template.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; templateGUID - unique identifier of the metadata element to copy; databaseGUID - unique identifier of the database where the schema is located; templateProperties - properties that override the template
Returns:: unique identifier of the new database schema or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

updateDatabaseSchema

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/schemas/{databaseSchemaGUID}")
public VoidResponse updateDatabaseSchema(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String databaseManagerGUID,
                                         @PathVariable
                                         String databaseManagerName,
                                         @PathVariable
                                         String databaseSchemaGUID,
                                         @RequestBody
                                         DatabaseSchemaProperties databaseSchemaProperties)

Update the metadata element representing a database schema.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseSchemaGUID - unique identifier of the metadata element to update; databaseSchemaProperties - new properties for the metadata element
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

publishDatabaseSchema

@PostMapping(path="/databases/schemas/{databaseSchemaGUID}/publish")
public VoidResponse publishDatabaseSchema(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String databaseSchemaGUID,
                                          @RequestBody(required=false)
                                          NullRequestBody nullRequestBody)

Update the zones for the database asset so that it becomes visible to consumers. (The zones are set to the list of zones in the publishedZones option configured for each instance of the Data Manager OMAS).

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseSchemaGUID - unique identifier of the metadata element to publish; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

withdrawDatabaseSchema

@PostMapping(path="/databases/schemas/{databaseSchemaGUID}/withdraw")
public VoidResponse withdrawDatabaseSchema(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @PathVariable
                                           String databaseSchemaGUID,
                                           @RequestBody(required=false)
                                           NullRequestBody nullRequestBody)

Update the zones for the database asset so that it is no longer visible to consumers. (The zones are set to the list of zones in the defaultZones option configured for each instance of the Data Manager OMAS. This is the setting when the database is first created).

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseSchemaGUID - unique identifier of the metadata element to withdraw; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

removeDatabaseSchema

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/schemas/{databaseSchemaGUID}/{qualifiedName}/delete")
public VoidResponse removeDatabaseSchema(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String databaseManagerGUID,
                                         @PathVariable
                                         String databaseManagerName,
                                         @PathVariable
                                         String databaseSchemaGUID,
                                         @PathVariable
                                         String qualifiedName,
                                         @RequestBody(required=false)
                                         NullRequestBody nullRequestBody)

Remove the metadata element representing a database schema.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseSchemaGUID - unique identifier of the metadata element to remove; qualifiedName - unique name of the metadata element to remove; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

findDatabaseSchemas

@PostMapping(path="/databases/schemas/by-search-string")
public DatabaseSchemasResponse findDatabaseSchemas(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @RequestBody
                                                   SearchStringRequestBody requestBody,
                                                   @RequestParam
                                                   int startFrom,
                                                   @RequestParam
                                                   int pageSize)

Retrieve the list of database schema 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getSchemasForDatabase

@GetMapping(path="/databases/{databaseGUID}/schemas")
public DatabaseSchemasResponse getSchemasForDatabase(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String databaseGUID,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize)

Return the list of schemas associated with a database.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseGUID - unique identifier of the database to query; startFrom - paging start point; pageSize - maximum results that can be returned
Returns:: list of metadata elements describing the schemas associated with the requested database or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseSchemasByName

@PostMapping(path="/databases/schemas/by-name")
public DatabaseSchemasResponse getDatabaseSchemasByName(@PathVariable
                                                        String serverName,
                                                        @PathVariable
                                                        String userId,
                                                        @RequestBody
                                                        NameRequestBody requestBody,
                                                        @RequestParam
                                                        int startFrom,
                                                        @RequestParam
                                                        int pageSize)

Retrieve the list of database schema 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseSchemaByGUID

@GetMapping(path="/databases/schemas/{guid}")
public DatabaseSchemaResponse getDatabaseSchemaByGUID(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String guid)

Retrieve the database schema metadata element with the supplied unique identifier.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; guid - unique identifier of the requested metadata element
Returns:: requested metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseSchemaType

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/assets/schema-type")
public GUIDResponse createDatabaseSchemaType(@PathVariable
                                             String serverName,
                                             @PathVariable
                                             String userId,
                                             @PathVariable
                                             String databaseManagerGUID,
                                             @PathVariable
                                             String databaseManagerName,
                                             @RequestBody
                                             NameRequestBody requestBody)

Create a database top-level schema type used to attach tables and views to the database/database schema.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - guid of the software server capability entity that represented the external source - null for local; databaseManagerName - name of the software server capability entity that represented the external source - null for local; requestBody - qualified name of the schema type - suggest "SchemaOf:" + asset's qualified name
Returns:: unique identifier of the database schema type or InvalidParameterException the bean properties are invalid UserNotAuthorizedException user not authorized to issue this request PropertyServerException problem accessing the property server

attachSchemaTypeToDatabaseAsset

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/assets/{databaseAssetGUID}/schema-type/{schemaTypeGUID}")
public VoidResponse attachSchemaTypeToDatabaseAsset(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String databaseManagerGUID,
                                                    @PathVariable
                                                    String databaseManagerName,
                                                    @PathVariable
                                                    String databaseAssetGUID,
                                                    @PathVariable
                                                    String schemaTypeGUID,
                                                    @RequestBody(required=false)
                                                    NullRequestBody requestBody)

Link the schema type and asset. This is called from outside of AssetHandler. The databaseAssetGUID is checked to ensure the asset exists and updates are allowed. If there is already a schema attached, it is deleted.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - guid of the software server capability entity that represented the external source - null for local; databaseManagerName - name of the software server capability entity that represented the external source - null for local; databaseAssetGUID - unique identifier of the asset to connect the schema to; schemaTypeGUID - identifier for schema Type object; requestBody - null request body
Returns:: void or InvalidParameterException the bean properties are invalid UserNotAuthorizedException user not authorized to issue this request PropertyServerException problem accessing the property server

createDatabaseTable

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/assets/{databaseAssetGUID}/tables")
public GUIDResponse createDatabaseTable(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String databaseManagerGUID,
                                        @PathVariable
                                        String databaseManagerName,
                                        @PathVariable
                                        String databaseAssetGUID,
                                        @RequestBody
                                        DatabaseTableProperties databaseTableProperties)

Create a new metadata element to represent a database table.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseAssetGUID - unique identifier of the database or database schema where the database table is located.; databaseTableProperties - properties for the database table
Returns:: unique identifier of the new metadata element for the database table or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseTableFromTemplate

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/assets/{databaseAssetGUID}/tables/from-template/{templateGUID}")
public GUIDResponse createDatabaseTableFromTemplate(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String databaseManagerGUID,
                                                    @PathVariable
                                                    String databaseManagerName,
                                                    @PathVariable
                                                    String templateGUID,
                                                    @PathVariable
                                                    String databaseAssetGUID,
                                                    @RequestBody
                                                    TemplateProperties templateProperties)

Create a new metadata element to represent a database table using an existing metadata element as a template.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; templateGUID - unique identifier of the metadata element to copy; databaseAssetGUID - unique identifier of the database or database schema where the database table is located.; templateProperties - properties that override the template
Returns:: unique identifier of the new database table or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseTableForSchemaType

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/assets/schema-type/{databaseSchemaTypeGUID}/tables")
public GUIDResponse createDatabaseTableForSchemaType(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String databaseManagerGUID,
                                                     @PathVariable
                                                     String databaseManagerName,
                                                     @PathVariable
                                                     String databaseSchemaTypeGUID,
                                                     @RequestBody
                                                     DatabaseTableProperties databaseTableProperties)

Create a new metadata element to represent a database table.

Parameters:: serverName - name of the service to route the request to; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the DBMS; databaseManagerName - unique name of software server capability representing the DBMS; databaseSchemaTypeGUID - unique identifier of the database or database schema where the database table is located; databaseTableProperties - properties for the database table
Returns:: unique identifier of the new metadata element for the database table 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)

updateDatabaseTable

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/{databaseTableGUID}")
public VoidResponse updateDatabaseTable(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String databaseManagerGUID,
                                        @PathVariable
                                        String databaseManagerName,
                                        @PathVariable
                                        String databaseTableGUID,
                                        @RequestBody
                                        DatabaseTableProperties databaseTableProperties)

Update the metadata element representing a database table.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseTableGUID - unique identifier of the database table to update; databaseTableProperties - new properties for the database table
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

removeDatabaseTable

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/{databaseTableGUID}/{qualifiedName}/delete")
public VoidResponse removeDatabaseTable(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String databaseManagerGUID,
                                        @PathVariable
                                        String databaseManagerName,
                                        @PathVariable
                                        String databaseTableGUID,
                                        @PathVariable
                                        String qualifiedName,
                                        @RequestBody(required=false)
                                        NullRequestBody nullRequestBody)

Remove the metadata element representing a database table.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseTableGUID - unique identifier of the metadata element to remove; qualifiedName - unique name of the metadata element to remove; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

findDatabaseTables

@PostMapping(path="/databases/tables/by-search-string")
public DatabaseTablesResponse findDatabaseTables(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @RequestBody
                                                 SearchStringRequestBody requestBody,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize)

Retrieve the list of database table 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getTablesForDatabaseAsset

@GetMapping(path="/databases/assets/{databaseAssetGUID}/tables")
public DatabaseTablesResponse getTablesForDatabaseAsset(@PathVariable
                                                        String serverName,
                                                        @PathVariable
                                                        String userId,
                                                        @PathVariable
                                                        String databaseAssetGUID,
                                                        @RequestParam
                                                        int startFrom,
                                                        @RequestParam
                                                        int pageSize)

Retrieve the list of database tables associated with a database or database schema.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseAssetGUID - unique identifier of the database or database schema 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseTablesByName

@PostMapping(path="/databases/tables/by-name")
public DatabaseTablesResponse getDatabaseTablesByName(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @RequestBody
                                                      NameRequestBody requestBody,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize)

Retrieve the list of database table 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseTableByGUID

@GetMapping(path="/databases/tables/{guid}")
public DatabaseTableResponse getDatabaseTableByGUID(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String guid)

Retrieve the database table metadata element with the supplied unique identifier.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; guid - unique identifier of the requested metadata element
Returns:: matching metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseView

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/assets/{databaseAssetGUID}/tables/views")
public GUIDResponse createDatabaseView(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String databaseManagerGUID,
                                       @PathVariable
                                       String databaseManagerName,
                                       @PathVariable
                                       String databaseAssetGUID,
                                       @RequestBody
                                       DatabaseViewProperties databaseViewProperties)

Create a new metadata element to represent a database view.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseAssetGUID - unique identifier of the database or database schema where the database view is located.; databaseViewProperties - properties for the new view
Returns:: unique identifier of the new metadata element for the database view or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseViewFromTemplate

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/assets/{databaseAssetGUID}/tables/views/from-template/{templateGUID}")
public GUIDResponse createDatabaseViewFromTemplate(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String databaseManagerGUID,
                                                   @PathVariable
                                                   String databaseManagerName,
                                                   @PathVariable
                                                   String templateGUID,
                                                   @PathVariable
                                                   String databaseAssetGUID,
                                                   @RequestBody
                                                   TemplateProperties templateProperties)

Create a new metadata element to represent a database view using an existing metadata element as a template.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; templateGUID - unique identifier of the metadata element to copy; databaseAssetGUID - unique identifier of the database or database schema where the database view is located.; templateProperties - properties that override the template
Returns:: unique identifier of the new metadata element for the database view or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseViewForSchemaType

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/assets/schema-type/{databaseSchemaTypeGUID}/tables/views")
public GUIDResponse createDatabaseViewForSchemaType(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String databaseManagerGUID,
                                                    @PathVariable
                                                    String databaseManagerName,
                                                    @PathVariable
                                                    String databaseSchemaTypeGUID,
                                                    @RequestBody
                                                    DatabaseViewProperties databaseViewProperties)

Create a new metadata element to represent a database view.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the DBMS; databaseManagerName - unique name of software server capability representing the DBMS; databaseSchemaTypeGUID - unique identifier of the schema type where the database view is located.; databaseViewProperties - properties for the new view
Returns:: unique identifier of the new metadata element for the database view 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)

updateDatabaseView

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/views/{databaseViewGUID}")
public VoidResponse updateDatabaseView(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String databaseManagerGUID,
                                       @PathVariable
                                       String databaseManagerName,
                                       @PathVariable
                                       String databaseViewGUID,
                                       @RequestBody
                                       DatabaseViewProperties databaseViewProperties)

Update the metadata element representing a database table.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseViewGUID - unique identifier of the database view to update; databaseViewProperties - properties for the new database view
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

removeDatabaseView

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/views/{databaseViewGUID}/{qualifiedName}/delete")
public VoidResponse removeDatabaseView(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String databaseManagerGUID,
                                       @PathVariable
                                       String databaseManagerName,
                                       @PathVariable
                                       String databaseViewGUID,
                                       @PathVariable
                                       String qualifiedName,
                                       @RequestBody(required=false)
                                       NullRequestBody nullRequestBody)

Remove the metadata element representing a database table.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseViewGUID - unique identifier of the metadata element to remove; qualifiedName - unique name of the metadata element to remove; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

findDatabaseViews

@PostMapping(path="/databases/tables/views/by-search-string")
public DatabaseViewsResponse findDatabaseViews(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @RequestBody
                                               SearchStringRequestBody requestBody,
                                               @RequestParam
                                               int startFrom,
                                               @RequestParam
                                               int pageSize)

Retrieve the list of database view 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getViewsForDatabaseAsset

@GetMapping(path="/databases/assets/{databaseAssetGUID}/tables/views")
public DatabaseViewsResponse getViewsForDatabaseAsset(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String databaseAssetGUID,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize)

Retrieve the list of database views associated with a database or database schema.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseAssetGUID - unique identifier of the database or database schema 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseViewsByName

@PostMapping(path="/databases/tables/views/by-name")
public DatabaseViewsResponse getDatabaseViewsByName(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @RequestBody
                                                    NameRequestBody requestBody,
                                                    @RequestParam
                                                    int startFrom,
                                                    @RequestParam
                                                    int pageSize)

Retrieve the list of database view 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseViewByGUID

@GetMapping(path="/databases/tables/views/{guid}")
public DatabaseViewResponse getDatabaseViewByGUID(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @PathVariable
                                                  String guid)

Retrieve the database view metadata element with the supplied unique identifier.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; guid - unique identifier of the requested metadata element
Returns:: matching metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseColumn

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/{databaseTableGUID}/columns")
public GUIDResponse createDatabaseColumn(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String databaseManagerGUID,
                                         @PathVariable
                                         String databaseManagerName,
                                         @PathVariable
                                         String databaseTableGUID,
                                         @RequestBody
                                         DatabaseColumnProperties databaseColumnProperties)

Create a new metadata element to represent a database column.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseTableGUID - unique identifier of the database table where this column is located; databaseColumnProperties - properties for the new column
Returns:: unique identifier of the new metadata element for the database column or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

createDatabaseColumnFromTemplate

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/{databaseTableGUID}/columns/from-template/{templateGUID}")
public GUIDResponse createDatabaseColumnFromTemplate(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String databaseManagerGUID,
                                                     @PathVariable
                                                     String databaseManagerName,
                                                     @PathVariable
                                                     String templateGUID,
                                                     @PathVariable
                                                     String databaseTableGUID,
                                                     @RequestBody
                                                     TemplateProperties templateProperties)

Create a new metadata element to represent a database column using an existing metadata element as a template.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; templateGUID - unique identifier of the metadata element to copy; databaseTableGUID - unique identifier of the database table where this column is located; templateProperties - properties that override the template
Returns:: unique identifier of the new metadata element for the database column InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

updateDatabaseColumn

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/columns/{databaseColumnGUID}")
public VoidResponse updateDatabaseColumn(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String databaseManagerGUID,
                                         @PathVariable
                                         String databaseManagerName,
                                         @PathVariable
                                         String databaseColumnGUID,
                                         @RequestBody
                                         DatabaseColumnProperties databaseColumnProperties)

Update the metadata element representing a database column.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseColumnGUID - unique identifier of the metadata element to update; databaseColumnProperties - new properties for the metadata element
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

removeDatabaseColumn

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/columns/{databaseColumnGUID}/{qualifiedName}/delete")
public VoidResponse removeDatabaseColumn(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String databaseManagerGUID,
                                         @PathVariable
                                         String databaseManagerName,
                                         @PathVariable
                                         String databaseColumnGUID,
                                         @PathVariable
                                         String qualifiedName,
                                         @RequestBody(required=false)
                                         NullRequestBody nullRequestBody)

Remove the metadata element representing a database column.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseColumnGUID - unique identifier of the metadata element to remove; qualifiedName - unique name of the metadata element to remove; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

findDatabaseColumns

@PostMapping(path="/databases/tables/columns/by-search-string")
public DatabaseColumnsResponse findDatabaseColumns(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @RequestBody
                                                   SearchStringRequestBody requestBody,
                                                   @RequestParam
                                                   int startFrom,
                                                   @RequestParam
                                                   int pageSize)

Retrieve the list of database column 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 InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getColumnsForDatabaseTable

@GetMapping(path="/databases/tables/{databaseTableGUID}/columns")
public DatabaseColumnsResponse getColumnsForDatabaseTable(@PathVariable
                                                          String serverName,
                                                          @PathVariable
                                                          String userId,
                                                          @PathVariable
                                                          String databaseTableGUID,
                                                          @RequestParam
                                                          int startFrom,
                                                          @RequestParam
                                                          int pageSize)

Retrieve the list of column for a database table (or view)

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseTableGUID - unique identifier of the database table of interest; 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseColumnsByName

@PostMapping(path="/databases/tables/columns/by-name")
public DatabaseColumnsResponse getDatabaseColumnsByName(@PathVariable
                                                        String serverName,
                                                        @PathVariable
                                                        String userId,
                                                        @RequestBody
                                                        NameRequestBody requestBody,
                                                        @RequestParam
                                                        int startFrom,
                                                        @RequestParam
                                                        int pageSize)

Retrieve the list of database column 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 or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getDatabaseColumnByGUID

@GetMapping(path="/databases/tables/columns/{guid}")
public DatabaseColumnResponse getDatabaseColumnByGUID(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String guid)

Retrieve the database column metadata element with the supplied unique identifier.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; guid - unique identifier of the requested metadata element
Returns:: matching metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

setPrimaryKeyOnColumn

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/columns/{databaseColumnGUID}/primary-key")
public VoidResponse setPrimaryKeyOnColumn(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String databaseManagerGUID,
                                          @PathVariable
                                          String databaseManagerName,
                                          @PathVariable
                                          String databaseColumnGUID,
                                          @RequestBody
                                          DatabasePrimaryKeyProperties databasePrimaryKeyProperties)

Classify a column in a database table as the primary key. This means each row has a different value in this column and it can be used to uniquely identify the column.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseColumnGUID - unique identifier if the primary key column; databasePrimaryKeyProperties - properties to store
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

removePrimaryKeyFromColumn

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/columns/{databaseColumnGUID}/primary-key/delete")
public VoidResponse removePrimaryKeyFromColumn(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String databaseManagerGUID,
                                               @PathVariable
                                               String databaseManagerName,
                                               @PathVariable
                                               String databaseColumnGUID,
                                               @RequestBody(required=false)
                                               NullRequestBody nullRequestBody)

Remove the classification that this column is a primary key.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; databaseColumnGUID - unique identifier if the primary key column; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

addForeignKeyRelationship

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/columns/{foreignKeyColumnGUID}/foreign-key/{primaryKeyColumnGUID}")
public VoidResponse addForeignKeyRelationship(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @PathVariable
                                              String databaseManagerGUID,
                                              @PathVariable
                                              String databaseManagerName,
                                              @PathVariable
                                              String primaryKeyColumnGUID,
                                              @PathVariable
                                              String foreignKeyColumnGUID,
                                              @RequestBody
                                              DatabaseForeignKeyProperties databaseForeignKeyProperties)

Create a foreign relationship between two columns. One of the columns holds the primary key of the other to form a link.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; primaryKeyColumnGUID - unique identifier of the column containing the primary key; foreignKeyColumnGUID - unique identifier of the column containing the primary key from the other table; databaseForeignKeyProperties - properties about the foreign key relationship
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

removeForeignKeyRelationship

@PostMapping(path="/database-managers/{databaseManagerGUID}/{databaseManagerName}/databases/tables/columns/{foreignKeyColumnGUID}/foreign-key/{primaryKeyColumnGUID}/delete")
public VoidResponse removeForeignKeyRelationship(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String databaseManagerGUID,
                                                 @PathVariable
                                                 String databaseManagerName,
                                                 @PathVariable
                                                 String primaryKeyColumnGUID,
                                                 @PathVariable
                                                 String foreignKeyColumnGUID,
                                                 @RequestBody(required=false)
                                                 NullRequestBody nullRequestBody)

Remove the foreign key relationship for the requested columns.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; databaseManagerGUID - unique identifier of software server capability representing the owning DBMS; databaseManagerName - unique name of software server capability representing the owning DBMS; primaryKeyColumnGUID - unique identifier of the column that is the linked primary key; foreignKeyColumnGUID - unique identifier of the column the contains the primary key from another table; nullRequestBody - empty request body
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

Class DatabaseManagerResource

Constructor Summary