diff --git a/dbrepo-analyse-service/Pipfile.lock b/dbrepo-analyse-service/Pipfile.lock
index 9f00d97ca67d09383debec17f12a06b2eea6b568..ec9b5f13d4f8fcf78aad41dda5c26f4a00affee3 100644
--- a/dbrepo-analyse-service/Pipfile.lock
+++ b/dbrepo-analyse-service/Pipfile.lock
@@ -412,7 +412,7 @@
         },
         "dbrepo": {
             "hashes": [
-                "sha256:501b53c7e4b32774809f9685a18288da5b938fc1512e94d8b248f531ee8667fc"
+                "sha256:19c6bbcf9461e20681f0fb342087c618a91123d2d04d4df2f4fd1da80aa77b76"
             ],
             "path": "./lib/dbrepo-1.6.2.tar.gz"
         },
@@ -1612,7 +1612,7 @@
                 "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df",
                 "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d"
             ],
-            "markers": "python_version >= '3.9'",
+            "markers": "python_version >= '3.10'",
             "version": "==2.3.0"
         },
         "werkzeug": {
@@ -2236,7 +2236,7 @@
                 "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df",
                 "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d"
             ],
-            "markers": "python_version >= '3.9'",
+            "markers": "python_version >= '3.10'",
             "version": "==2.3.0"
         },
         "wrapt": {
diff --git a/dbrepo-analyse-service/lib/dbrepo-1.6.2.tar.gz b/dbrepo-analyse-service/lib/dbrepo-1.6.2.tar.gz
index 58081673e955d89fccf70c9161037a725b647f71..02ed2aec31c2b1881165a12d45060ed4a311192d 100644
Binary files a/dbrepo-analyse-service/lib/dbrepo-1.6.2.tar.gz and b/dbrepo-analyse-service/lib/dbrepo-1.6.2.tar.gz differ
diff --git a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/AccessEndpoint.java b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/AccessEndpoint.java
index 7947e87a495595441c945e950453499c635aaac2..99df658030a904139e60b660c42774c51fa9ac4d 100644
--- a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/AccessEndpoint.java
+++ b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/AccessEndpoint.java
@@ -1,9 +1,9 @@
 package at.tuwien.endpoints;
 
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.UpdateDatabaseAccessDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
 import at.tuwien.api.error.ApiErrorDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.exception.*;
 import at.tuwien.service.AccessService;
 import at.tuwien.service.CredentialService;
@@ -29,7 +29,7 @@ import java.util.UUID;
 @RestController
 @CrossOrigin(origins = "*")
 @RequestMapping(path = "/api/database/{databaseId}/access")
-public class AccessEndpoint extends AbstractEndpoint {
+public class AccessEndpoint extends RestEndpoint {
 
     private final AccessService accessService;
     private final CredentialService credentialService;
@@ -80,8 +80,8 @@ public class AccessEndpoint extends AbstractEndpoint {
             throws NotAllowedException, DatabaseUnavailableException, DatabaseNotFoundException,
             RemoteUnavailableException, UserNotFoundException, DatabaseMalformedException, MetadataServiceException {
         log.debug("endpoint give access to database, databaseId={}, userId={}", databaseId, userId);
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
-        final PrivilegedUserDto user = credentialService.getUser(userId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
+        final UserDto user = credentialService.getUser(userId);
         if (database.getAccesses().stream().anyMatch(a -> a.getUser().getId().equals(userId))) {
             log.error("Failed to create access to user with id {}: already has access", userId);
             throw new NotAllowedException("Failed to create access to user with id " + userId + ": already has access");
@@ -137,8 +137,8 @@ public class AccessEndpoint extends AbstractEndpoint {
             DatabaseMalformedException, MetadataServiceException {
         log.debug("endpoint modify access to database, databaseId={}, userId={}, access.type={}", databaseId, userId,
                 access.getType());
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
-        final PrivilegedUserDto user = credentialService.getUser(userId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
+        final UserDto user = credentialService.getUser(userId);
         if (database.getAccesses().stream().noneMatch(a -> a.getHuserid().equals(userId))) {
             log.error("Failed to update access to user with id {}: no access", userId);
             throw new NotAllowedException("Failed to update access to user with id " + userId + ": no access");
@@ -208,8 +208,8 @@ public class AccessEndpoint extends AbstractEndpoint {
             DatabaseUnavailableException, DatabaseNotFoundException, RemoteUnavailableException, UserNotFoundException,
             DatabaseMalformedException, MetadataServiceException {
         log.debug("endpoint revoke access to database, databaseId={}, userId={}", databaseId, userId);
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
-        final PrivilegedUserDto user = credentialService.getUser(userId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
+        final UserDto user = credentialService.getUser(userId);
         if (database.getAccesses().stream().noneMatch(a -> a.getUser().getId().equals(userId))) {
             log.error("Failed to delete access to user with id {}: no access", userId);
             throw new NotAllowedException("Failed to delete access to user with id " + userId + ": no access");
diff --git a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/DatabaseEndpoint.java b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/DatabaseEndpoint.java
index d101a8c97393a41ecf4e76ea4e4fb4aa3c1f4993..27848cf517ca0187f8ccd69d5ec894a4a6121304 100644
--- a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/DatabaseEndpoint.java
+++ b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/DatabaseEndpoint.java
@@ -1,19 +1,17 @@
 package at.tuwien.endpoints;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
+import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.database.AccessTypeDto;
 import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.internal.CreateDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
 import at.tuwien.api.error.ApiErrorDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.api.user.internal.UpdateUserPasswordDto;
 import at.tuwien.exception.*;
-import at.tuwien.mapper.MetadataMapper;
 import at.tuwien.service.AccessService;
+import at.tuwien.service.ContainerService;
 import at.tuwien.service.CredentialService;
 import at.tuwien.service.DatabaseService;
-import at.tuwien.service.SubsetService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -35,21 +33,19 @@ import java.sql.SQLException;
 @RestController
 @CrossOrigin(origins = "*")
 @RequestMapping(path = "/api/database")
-public class DatabaseEndpoint extends AbstractEndpoint {
+public class DatabaseEndpoint extends RestEndpoint {
 
-    private final SubsetService queryService;
     private final AccessService accessService;
-    private final MetadataMapper metadataMapper;
     private final DatabaseService databaseService;
+    private final ContainerService containerService;
     private final CredentialService credentialService;
 
     @Autowired
-    public DatabaseEndpoint(SubsetService queryService, AccessService accessService, MetadataMapper metadataMapper,
-                            DatabaseService databaseService, CredentialService credentialService) {
-        this.queryService = queryService;
+    public DatabaseEndpoint(AccessService accessService, DatabaseService databaseService,
+                            ContainerService containerService, CredentialService credentialService) {
         this.accessService = accessService;
-        this.metadataMapper = metadataMapper;
         this.databaseService = databaseService;
+        this.containerService = containerService;
         this.credentialService = credentialService;
     }
 
@@ -90,18 +86,18 @@ public class DatabaseEndpoint extends AbstractEndpoint {
             DatabaseMalformedException, QueryStoreCreateException, MetadataServiceException {
         log.debug("endpoint create database, data.containerId={}, data.internalName={}, data.username={}",
                 data.getContainerId(), data.getInternalName(), data.getUsername());
-        final PrivilegedContainerDto container = credentialService.getContainer(data.getContainerId());
+        final ContainerDto container = credentialService.getContainer(data.getContainerId());
         try {
-            final PrivilegedDatabaseDto database = databaseService.create(container, data);
-            queryService.createQueryStore(container, data.getInternalName());
-            final PrivilegedUserDto user = PrivilegedUserDto.builder()
+            final DatabaseDto database = containerService.createDatabase(container, data);
+            containerService.createQueryStore(container, data.getInternalName());
+            final UserDto user = UserDto.builder()
                     .id(data.getUserId())
                     .username(data.getUsername())
                     .password(data.getPassword())
                     .build();
             accessService.create(database, user, AccessTypeDto.WRITE_ALL);
             return ResponseEntity.status(HttpStatus.CREATED)
-                    .body(metadataMapper.privilegedDatabaseDtoToDatabaseDto(database));
+                    .body(database);
         } catch (SQLException e) {
             log.error("Failed to establish connection to database: {}", e.getMessage());
             throw new DatabaseUnavailableException("Failed to establish connection to database: " + e.getMessage(), e);
@@ -138,7 +134,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
             DatabaseMalformedException, MetadataServiceException {
         log.debug("endpoint update user password in database, databaseId={}, data.username={}", databaseId,
                 data.getUsername());
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         try {
             databaseService.update(database, data);
             return ResponseEntity.status(HttpStatus.ACCEPTED)
diff --git a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/AbstractEndpoint.java b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/RestEndpoint.java
similarity index 98%
rename from dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/AbstractEndpoint.java
rename to dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/RestEndpoint.java
index 87a4d32532c586c0f2517862f0cd3cc104f4f054..333e0c8398e487d689de2669171d07a2f0c70c3c 100644
--- a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/AbstractEndpoint.java
+++ b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/RestEndpoint.java
@@ -11,7 +11,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
-public abstract class AbstractEndpoint {
+public abstract class RestEndpoint {
 
     public boolean hasRole(Principal principal, String role) {
         if (principal == null || role == null) {
diff --git a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/SubsetEndpoint.java b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/SubsetEndpoint.java
index f30251a5ff09e895a7324a9857134c789f6b3c03..ed867715e1f10051089a4687b3d8568ec6e5f3cf 100644
--- a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/SubsetEndpoint.java
+++ b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/SubsetEndpoint.java
@@ -1,9 +1,9 @@
 package at.tuwien.endpoints;
 
 import at.tuwien.ExportResourceDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.ViewColumnDto;
 import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
 import at.tuwien.api.database.query.ExecuteStatementDto;
 import at.tuwien.api.database.query.QueryDto;
 import at.tuwien.api.database.query.QueryPersistDto;
@@ -46,25 +46,25 @@ import java.util.UUID;
 @RestController
 @CrossOrigin(origins = "*")
 @RequestMapping(path = "/api/database/{databaseId}/subset")
-public class SubsetEndpoint extends AbstractEndpoint {
+public class SubsetEndpoint extends RestEndpoint {
 
-    private final SchemaService schemaService;
     private final SubsetService subsetService;
     private final MetadataMapper metadataMapper;
     private final MetricsService metricsService;
     private final StorageService storageService;
+    private final DatabaseService databaseService;
     private final CredentialService credentialService;
     private final EndpointValidator endpointValidator;
 
     @Autowired
-    public SubsetEndpoint(SchemaService schemaService, SubsetService subsetService, MetadataMapper metadataMapper,
-                          MetricsService metricsService, StorageService storageService,
+    public SubsetEndpoint(SubsetService subsetService, MetadataMapper metadataMapper, MetricsService metricsService,
+                          StorageService storageService, DatabaseService databaseService,
                           CredentialService credentialService, EndpointValidator endpointValidator) {
-        this.schemaService = schemaService;
         this.subsetService = subsetService;
         this.metadataMapper = metadataMapper;
         this.metricsService = metricsService;
         this.storageService = storageService;
+        this.databaseService = databaseService;
         this.credentialService = credentialService;
         this.endpointValidator = endpointValidator;
     }
@@ -102,7 +102,7 @@ public class SubsetEndpoint extends AbstractEndpoint {
             throws DatabaseUnavailableException, DatabaseNotFoundException, RemoteUnavailableException,
             QueryNotFoundException, NotAllowedException, MetadataServiceException {
         log.debug("endpoint find subsets in database, databaseId={}, filterPersisted={}", databaseId, filterPersisted);
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         endpointValidator.validateOnlyPrivateSchemaAccess(database, principal);
         final List<QueryDto> queries;
         try {
@@ -164,7 +164,7 @@ public class SubsetEndpoint extends AbstractEndpoint {
             NotAllowedException {
         log.debug("endpoint find subset in database, databaseId={}, subsetId={}, accept={}, timestamp={}", databaseId,
                 subsetId, accept, timestamp);
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         endpointValidator.validateOnlyPrivateSchemaAccess(database, principal);
         final QueryDto subset;
         try {
@@ -286,7 +286,7 @@ public class SubsetEndpoint extends AbstractEndpoint {
             log.debug("timestamp not set: default to {}", timestamp);
         }
         /* create */
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         endpointValidator.validateOnlyPrivateSchemaAccess(database, principal);
         try {
             final Long subsetId = subsetService.create(database, data.getStatement(), timestamp, userId);
@@ -345,7 +345,7 @@ public class SubsetEndpoint extends AbstractEndpoint {
         log.debug("endpoint get subset data, databaseId={}, subsetId={}, principal.name={} page={}, size={}",
                 databaseId, subsetId, principal != null ? principal.getName() : null, page, size);
         endpointValidator.validateDataParams(page, size);
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         if (!database.getIsPublic()) {
             if (principal == null) {
                 log.error("Failed to re-execute query: no authentication found");
@@ -377,7 +377,8 @@ public class SubsetEndpoint extends AbstractEndpoint {
             }
             final Dataset<Row> dataset = subsetService.getData(database, subset, page, size);
             metricsService.countSubsetGetData(databaseId, subsetId);
-            final ViewDto view = schemaService.inspectView(database, metadataMapper.queryDtoToViewName(subset));
+            final String viewName = metadataMapper.queryDtoToViewName(subset);
+            final ViewDto view = databaseService.inspectView(database, viewName);
             headers.set("Access-Control-Expose-Headers", "X-Id X-Headers");
             headers.set("X-Headers", String.join(",", view.getColumns().stream().map(ViewColumnDto::getInternalName).toList()));
             return ResponseEntity.status(request.getMethod().equals("POST") ? HttpStatus.CREATED : HttpStatus.OK)
@@ -435,7 +436,7 @@ public class SubsetEndpoint extends AbstractEndpoint {
             DatabaseUnavailableException, QueryNotFoundException, UserNotFoundException, MetadataServiceException {
         log.debug("endpoint persist query, databaseId={}, queryId={}, data.persist={}, principal.name={}", databaseId,
                 queryId, data.getPersist(), principal.getName());
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         credentialService.getAccess(databaseId, getId(principal));
         try {
             subsetService.persist(database, queryId, data.getPersist());
diff --git a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/TableEndpoint.java b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/TableEndpoint.java
index f0ec00a035e729157726b65af9f3c85949581c4e..077ec5b8190064145b29b98cb8d5a50879b06689 100644
--- a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/TableEndpoint.java
+++ b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/TableEndpoint.java
@@ -3,11 +3,9 @@ package at.tuwien.endpoints;
 import at.tuwien.ExportResourceDto;
 import at.tuwien.api.database.DatabaseAccessDto;
 import at.tuwien.api.database.DatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
 import at.tuwien.api.database.query.ImportDto;
 import at.tuwien.api.database.table.*;
 import at.tuwien.api.database.table.columns.ColumnDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import at.tuwien.api.database.table.internal.TableCreateDto;
 import at.tuwien.api.error.ApiErrorDto;
 import at.tuwien.exception.*;
@@ -47,24 +45,24 @@ import java.util.Map;
 @RestController
 @CrossOrigin(origins = "*")
 @RequestMapping(path = "/api/database/{databaseId}/table")
-public class TableEndpoint extends AbstractEndpoint {
+public class TableEndpoint extends RestEndpoint {
 
     private final TableService tableService;
-    private final SchemaService schemaService;
     private final MetricsService metricsService;
     private final StorageService storageService;
+    private final DatabaseService databaseService;
     private final CredentialService credentialService;
     private final EndpointValidator endpointValidator;
     private final MetadataServiceGateway metadataServiceGateway;
 
     @Autowired
-    public TableEndpoint(TableService tableService, SchemaService schemaService, MetricsService metricsService,
-                         StorageService storageService, CredentialService credentialService,
+    public TableEndpoint(TableService tableService, MetricsService metricsService, StorageService storageService,
+                         DatabaseService databaseService, CredentialService credentialService,
                          EndpointValidator endpointValidator, MetadataServiceGateway metadataServiceGateway) {
         this.tableService = tableService;
-        this.schemaService = schemaService;
         this.metricsService = metricsService;
         this.storageService = storageService;
+        this.databaseService = databaseService;
         this.credentialService = credentialService;
         this.endpointValidator = endpointValidator;
         this.metadataServiceGateway = metadataServiceGateway;
@@ -113,11 +111,11 @@ public class TableEndpoint extends AbstractEndpoint {
             throw new TableMalformedException("Table must have a primary key");
         }
         /* create */
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         try {
-            final TableDto table = tableService.createTable(database, data);
+            final TableDto table = databaseService.createTable(database, data);
             return ResponseEntity.status(HttpStatus.CREATED)
-                    .body(schemaService.inspectTable(database, table.getInternalName()));
+                    .body(databaseService.inspectTable(database, table.getInternalName()));
         } catch (SQLException e) {
             log.error("Failed to establish connection to database: {}", e.getMessage());
             throw new DatabaseUnavailableException("Failed to establish connection to database: " + e.getMessage(), e);
@@ -157,7 +155,7 @@ public class TableEndpoint extends AbstractEndpoint {
             TableMalformedException, DatabaseUnavailableException, TableNotFoundException, MetadataServiceException {
         log.debug("endpoint update table, databaseId={}, data.description={}", databaseId, data.getDescription());
         /* create */
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         try {
             tableService.updateTable(table, data);
             return ResponseEntity.status(HttpStatus.ACCEPTED)
@@ -200,7 +198,7 @@ public class TableEndpoint extends AbstractEndpoint {
             throws DatabaseUnavailableException, RemoteUnavailableException, TableNotFoundException,
             QueryMalformedException, MetadataServiceException {
         log.debug("endpoint delete table, databaseId={}, tableId={}", databaseId, tableId);
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         try {
             tableService.delete(table);
             return ResponseEntity.status(HttpStatus.ACCEPTED)
@@ -253,7 +251,7 @@ public class TableEndpoint extends AbstractEndpoint {
                                                              @NotNull HttpServletRequest request,
                                                              Principal principal)
             throws DatabaseUnavailableException, RemoteUnavailableException, TableNotFoundException,
-            PaginationException, MetadataServiceException, NotAllowedException {
+            PaginationException, MetadataServiceException, NotAllowedException, DatabaseNotFoundException {
         log.debug("endpoint get table data, databaseId={}, tableId={}, timestamp={}, page={}, size={}", databaseId,
                 tableId, timestamp, page, size);
         endpointValidator.validateDataParams(page, size);
@@ -270,7 +268,7 @@ public class TableEndpoint extends AbstractEndpoint {
             timestamp = Instant.now();
             log.debug("timestamp not set: default to {}", timestamp);
         }
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         if (!table.getIsPublic()) {
             if (principal == null) {
                 log.error("Failed find table data: authentication required");
@@ -289,8 +287,8 @@ public class TableEndpoint extends AbstractEndpoint {
             }
             headers.set("Access-Control-Expose-Headers", "X-Headers");
             headers.set("X-Headers", String.join(",", table.getColumns().stream().map(ColumnDto::getInternalName).toList()));
-            final Dataset<Row> dataset = tableService.getData(table.getDatabase(), table.getInternalName(), timestamp,
-                    null, null, null, null);
+            final Dataset<Row> dataset = tableService.getData(credentialService.getDatabase(table.getTdbid()),
+                    table.getInternalName(), timestamp, null, null, null, null);
             metricsService.countTableGetData(databaseId, tableId);
             return ResponseEntity.ok()
                     .headers(headers)
@@ -340,7 +338,7 @@ public class TableEndpoint extends AbstractEndpoint {
             TableMalformedException, QueryMalformedException, NotAllowedException, StorageUnavailableException,
             StorageNotFoundException, MetadataServiceException {
         log.debug("endpoint insert raw table data, databaseId={}, tableId={}", databaseId, tableId);
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         final DatabaseAccessDto access = credentialService.getAccess(databaseId, getId(principal));
         endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(access.getType(), table.getOwner().getId(), getId(principal));
         try {
@@ -393,7 +391,7 @@ public class TableEndpoint extends AbstractEndpoint {
             TableMalformedException, QueryMalformedException, NotAllowedException, MetadataServiceException {
         log.debug("endpoint update raw table data, databaseId={}, tableId={}, data.keys={}", databaseId, tableId,
                 data.getKeys());
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         final DatabaseAccessDto access = credentialService.getAccess(databaseId, getId(principal));
         endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(access.getType(), table.getOwner().getId(), getId(principal));
         try {
@@ -446,7 +444,7 @@ public class TableEndpoint extends AbstractEndpoint {
             TableMalformedException, QueryMalformedException, NotAllowedException, MetadataServiceException {
         log.debug("endpoint delete raw table data, databaseId={}, tableId={}, data.keys={}", databaseId, tableId,
                 data.getKeys());
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         final DatabaseAccessDto access = credentialService.getAccess(databaseId, getId(principal));
         endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(access.getType(), table.getOwner().getId(), getId(principal));
         try {
@@ -506,7 +504,7 @@ public class TableEndpoint extends AbstractEndpoint {
             log.debug("size not set: default to 100L");
             size = 100L;
         }
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         if (!table.getIsPublic()) {
             if (principal == null) {
                 log.error("Failed to find table history: no authentication found");
@@ -565,9 +563,9 @@ public class TableEndpoint extends AbstractEndpoint {
             throws DatabaseUnavailableException, DatabaseNotFoundException, RemoteUnavailableException,
             DatabaseMalformedException, TableNotFoundException, MetadataServiceException {
         log.debug("endpoint inspect table schemas, databaseId={}", databaseId);
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         try {
-            return ResponseEntity.ok(tableService.getSchemas(database));
+            return ResponseEntity.ok(databaseService.exploreTables(database));
         } catch (SQLException e) {
             log.error("Failed to establish connection to database: {}", e.getMessage());
             throw new DatabaseUnavailableException("Failed to establish connection to database: " + e.getMessage(), e);
@@ -611,14 +609,14 @@ public class TableEndpoint extends AbstractEndpoint {
                                                              @RequestParam(required = false) Instant timestamp,
                                                              Principal principal)
             throws RemoteUnavailableException, TableNotFoundException, NotAllowedException, StorageUnavailableException,
-            QueryMalformedException, MetadataServiceException {
+            QueryMalformedException, MetadataServiceException, DatabaseNotFoundException {
         log.debug("endpoint export table data, databaseId={}, tableId={}, timestamp={}", databaseId, tableId, timestamp);
         /* parameters */
         if (timestamp == null) {
             timestamp = Instant.now();
             log.debug("timestamp not set: default to {}", timestamp);
         }
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         if (!table.getIsPublic()) {
             if (principal == null) {
                 log.error("Failed to export private table: principal is null");
@@ -626,8 +624,8 @@ public class TableEndpoint extends AbstractEndpoint {
             }
             credentialService.getAccess(databaseId, getId(principal));
         }
-        final Dataset<Row> dataset = tableService.getData(table.getDatabase(), table.getInternalName(), timestamp, null,
-                null, null, null);
+        final Dataset<Row> dataset = tableService.getData(credentialService.getDatabase(table.getTdbid()),
+                table.getInternalName(), timestamp, null, null, null, null);
         metricsService.countTableGetData(databaseId, tableId);
         final ExportResourceDto resource = storageService.transformDataset(dataset);
         final HttpHeaders headers = new HttpHeaders();
@@ -677,7 +675,7 @@ public class TableEndpoint extends AbstractEndpoint {
             StorageNotFoundException, MalformedException, StorageUnavailableException, QueryMalformedException,
             DatabaseUnavailableException {
         log.debug("endpoint insert table data, databaseId={}, tableId={}, data.location={}", databaseId, tableId, data.getLocation());
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         final DatabaseAccessDto access = credentialService.getAccess(databaseId, getId(principal));
         endpointValidator.validateOnlyWriteOwnOrWriteAllAccess(access.getType(), table.getOwner().getId(), getId(principal));
         if (data.getLineTermination() == null) {
@@ -725,11 +723,11 @@ public class TableEndpoint extends AbstractEndpoint {
     public ResponseEntity<TableStatisticDto> statistic(@NotNull @PathVariable("databaseId") Long databaseId,
                                                        @NotNull @PathVariable("tableId") Long tableId)
             throws DatabaseUnavailableException, RemoteUnavailableException, TableNotFoundException,
-            MetadataServiceException, TableMalformedException {
+            MetadataServiceException, TableMalformedException, DatabaseNotFoundException {
         log.debug("endpoint generate table statistic, databaseId={}, tableId={}", databaseId, tableId);
-        final PrivilegedTableDto table = credentialService.getTable(databaseId, tableId);
+        final TableDto table = credentialService.getTable(databaseId, tableId);
         try {
-            return ResponseEntity.ok(tableService.getStatistics(table));
+            return ResponseEntity.ok(tableService.getStatistics(credentialService.getDatabase(table.getTdbid()), table));
         } catch (SQLException e) {
             log.error("Failed to establish connection to database: {}", e.getMessage());
             throw new DatabaseUnavailableException("Failed to establish connection to database", e);
diff --git a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/ViewEndpoint.java b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/ViewEndpoint.java
index 2b0463483d66429dfb0afd942bbc80ccdfb2fd26..c662bf49c1a10ada160f41b45020613448d0c396 100644
--- a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/ViewEndpoint.java
+++ b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/endpoints/ViewEndpoint.java
@@ -1,11 +1,10 @@
 package at.tuwien.endpoints;
 
 import at.tuwien.ExportResourceDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.ViewColumnDto;
 import at.tuwien.api.database.ViewCreateDto;
 import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
 import at.tuwien.api.error.ApiErrorDto;
 import at.tuwien.exception.*;
 import at.tuwien.service.*;
@@ -42,23 +41,25 @@ import java.util.Map;
 @RestController
 @CrossOrigin(origins = "*")
 @RequestMapping(path = "/api/database/{databaseId}/view")
-public class ViewEndpoint extends AbstractEndpoint {
+public class ViewEndpoint extends RestEndpoint {
 
     private final ViewService viewService;
     private final TableService tableService;
     private final MetricsService metricsService;
     private final StorageService storageService;
+    private final DatabaseService databaseService;
     private final CredentialService credentialService;
     private final EndpointValidator endpointValidator;
 
     @Autowired
     public ViewEndpoint(ViewService viewService, TableService tableService, MetricsService metricsService,
-                        StorageService storageService, CredentialService credentialService,
-                        EndpointValidator endpointValidator) {
+                        StorageService storageService, DatabaseService databaseService,
+                        CredentialService credentialService, EndpointValidator endpointValidator) {
         this.viewService = viewService;
         this.tableService = tableService;
         this.metricsService = metricsService;
         this.storageService = storageService;
+        this.databaseService = databaseService;
         this.credentialService = credentialService;
         this.endpointValidator = endpointValidator;
     }
@@ -102,11 +103,11 @@ public class ViewEndpoint extends AbstractEndpoint {
     })
     public ResponseEntity<List<ViewDto>> getSchema(@NotNull @PathVariable("databaseId") Long databaseId)
             throws DatabaseUnavailableException, DatabaseNotFoundException, RemoteUnavailableException,
-            ViewNotFoundException, DatabaseMalformedException, MetadataServiceException {
+            DatabaseMalformedException, MetadataServiceException, ViewNotFoundException {
         log.debug("endpoint inspect view schemas, databaseId={}", databaseId);
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         try {
-            return ResponseEntity.ok(viewService.getSchemas(database));
+            return ResponseEntity.ok(databaseService.exploreViews(database));
         } catch (SQLException e) {
             log.error("Failed to establish connection to database: {}", e.getMessage());
             throw new DatabaseUnavailableException("Failed to establish connection to database: " + e.getMessage(), e);
@@ -149,10 +150,10 @@ public class ViewEndpoint extends AbstractEndpoint {
                                           @Valid @RequestBody ViewCreateDto data) throws DatabaseUnavailableException,
             DatabaseNotFoundException, RemoteUnavailableException, ViewMalformedException, MetadataServiceException {
         log.debug("endpoint create view, databaseId={}, data.name={}", databaseId, data.getName());
-        final PrivilegedDatabaseDto database = credentialService.getDatabase(databaseId);
+        final DatabaseDto database = credentialService.getDatabase(databaseId);
         try {
             return ResponseEntity.status(HttpStatus.CREATED)
-                    .body(viewService.create(database, data));
+                    .body(databaseService.createView(database, data));
         } catch (SQLException e) {
             log.error("Failed to establish connection to database: {}", e.getMessage());
             throw new DatabaseUnavailableException("Failed to establish connection to database: " + e.getMessage(), e);
@@ -193,9 +194,9 @@ public class ViewEndpoint extends AbstractEndpoint {
             throws DatabaseUnavailableException, RemoteUnavailableException, ViewNotFoundException,
             ViewMalformedException, MetadataServiceException {
         log.debug("endpoint delete view, databaseId={}, viewId={}", databaseId, viewId);
-        final PrivilegedViewDto view = credentialService.getView(databaseId, viewId);
+        final ViewDto view = credentialService.getView(databaseId, viewId);
         try {
-            viewService.delete(view.getDatabase(), view.getInternalName());
+            viewService.delete(view);
             return ResponseEntity.status(HttpStatus.ACCEPTED)
                     .build();
         } catch (SQLException e) {
@@ -251,7 +252,7 @@ public class ViewEndpoint extends AbstractEndpoint {
                                                              @NotNull HttpServletRequest request,
                                                              Principal principal)
             throws DatabaseUnavailableException, RemoteUnavailableException, ViewNotFoundException, PaginationException,
-            QueryMalformedException, NotAllowedException, MetadataServiceException, TableNotFoundException {
+            QueryMalformedException, NotAllowedException, MetadataServiceException, TableNotFoundException, DatabaseNotFoundException {
         log.debug("endpoint get view data, databaseId={}, viewId={}, page={}, size={}, timestamp={}", databaseId,
                 viewId, page, size, timestamp);
         endpointValidator.validateDataParams(page, size);
@@ -268,7 +269,7 @@ public class ViewEndpoint extends AbstractEndpoint {
             timestamp = Instant.now();
             log.debug("timestamp not set: default to {}", timestamp);
         }
-        final PrivilegedViewDto view = credentialService.getView(databaseId, viewId);
+        final ViewDto view = credentialService.getView(databaseId, viewId);
         if (!view.getIsPublic()) {
             if (principal == null) {
                 log.error("Failed to get data from view: unauthorized");
@@ -287,8 +288,8 @@ public class ViewEndpoint extends AbstractEndpoint {
             }
             headers.set("Access-Control-Expose-Headers", "X-Headers");
             headers.set("X-Headers", String.join(",", view.getColumns().stream().map(ViewColumnDto::getInternalName).toList()));
-            final Dataset<Row> dataset = tableService.getData(view.getDatabase(), view.getInternalName(), timestamp,
-                    page, size, null, null);
+            final Dataset<Row> dataset = tableService.getData(credentialService.getDatabase(databaseId),
+                    view.getInternalName(), timestamp, page, size, null, null);
             metricsService.countViewGetData(databaseId, viewId);
             return ResponseEntity.ok()
                     .headers(headers)
@@ -336,7 +337,7 @@ public class ViewEndpoint extends AbstractEndpoint {
                                                              @RequestParam(required = false) Instant timestamp,
                                                              Principal principal)
             throws RemoteUnavailableException, ViewNotFoundException, NotAllowedException, MetadataServiceException,
-            StorageUnavailableException, QueryMalformedException, TableNotFoundException {
+            StorageUnavailableException, QueryMalformedException, TableNotFoundException, DatabaseNotFoundException {
         log.debug("endpoint export view data, databaseId={}, viewId={}", databaseId, viewId);
         /* parameters */
         if (timestamp == null) {
@@ -344,7 +345,7 @@ public class ViewEndpoint extends AbstractEndpoint {
             log.debug("timestamp not set: default to {}", timestamp);
         }
         /* parameters */
-        final PrivilegedViewDto view = credentialService.getView(databaseId, viewId);
+        final ViewDto view = credentialService.getView(databaseId, viewId);
         if (!view.getIsPublic()) {
             if (principal == null) {
                 log.error("Failed to export private view: principal is null");
@@ -352,8 +353,8 @@ public class ViewEndpoint extends AbstractEndpoint {
             }
             credentialService.getAccess(databaseId, getId(principal));
         }
-        final Dataset<Row> dataset = tableService.getData(view.getDatabase(), view.getInternalName(), timestamp, null,
-                null, null, null);
+        final Dataset<Row> dataset = tableService.getData(credentialService.getDatabase(databaseId),
+                view.getInternalName(), timestamp, null, null, null, null);
         metricsService.countViewGetData(databaseId, viewId);
         final ExportResourceDto resource = storageService.transformDataset(dataset);
         final HttpHeaders headers = new HttpHeaders();
diff --git a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/validation/EndpointValidator.java b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/validation/EndpointValidator.java
index 25b858f51bd3f643f7879b9eac2dbb648b00aabb..18307b5ac21d685ccf40adea4fc75d7a2cce290f 100644
--- a/dbrepo-data-service/rest-service/src/main/java/at/tuwien/validation/EndpointValidator.java
+++ b/dbrepo-data-service/rest-service/src/main/java/at/tuwien/validation/EndpointValidator.java
@@ -2,9 +2,9 @@ package at.tuwien.validation;
 
 import at.tuwien.api.database.AccessTypeDto;
 import at.tuwien.api.database.DatabaseAccessDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.config.QueryConfig;
-import at.tuwien.endpoints.AbstractEndpoint;
+import at.tuwien.endpoints.RestEndpoint;
 import at.tuwien.exception.*;
 import at.tuwien.gateway.MetadataServiceGateway;
 import lombok.extern.log4j.Log4j2;
@@ -21,7 +21,7 @@ import java.util.regex.Pattern;
 
 @Log4j2
 @Component
-public class EndpointValidator extends AbstractEndpoint {
+public class EndpointValidator extends RestEndpoint {
 
     private final QueryConfig queryConfig;
     private final MetadataServiceGateway metadataServiceGateway;
@@ -48,12 +48,12 @@ public class EndpointValidator extends AbstractEndpoint {
         }
     }
 
-    public void validateOnlyPrivateSchemaAccess(PrivilegedDatabaseDto database, Principal principal)
+    public void validateOnlyPrivateSchemaAccess(DatabaseDto database, Principal principal)
             throws NotAllowedException, RemoteUnavailableException, MetadataServiceException {
         validateOnlyPrivateSchemaAccess(database, principal, false);
     }
 
-    public void validateOnlyPrivateSchemaAccess(PrivilegedDatabaseDto database, Principal principal,
+    public void validateOnlyPrivateSchemaAccess(DatabaseDto database, Principal principal,
                                                 boolean writeAccessOnly) throws NotAllowedException,
             RemoteUnavailableException, MetadataServiceException {
         if (database.getIsSchemaPublic()) {
@@ -63,7 +63,7 @@ public class EndpointValidator extends AbstractEndpoint {
         validateOnlyAccess(database, principal, writeAccessOnly);
     }
 
-    public void validateOnlyPrivateSchemaHasRole(PrivilegedDatabaseDto database, Principal principal, String role)
+    public void validateOnlyPrivateSchemaHasRole(DatabaseDto database, Principal principal, String role)
             throws NotAllowedException {
         if (database.getIsSchemaPublic()) {
             log.trace("database with id {} has public schema: no access needed", database.getId());
@@ -82,7 +82,7 @@ public class EndpointValidator extends AbstractEndpoint {
         log.trace("principal has role '{}': access granted", role);
     }
 
-    public void validateOnlyAccess(PrivilegedDatabaseDto database, Principal principal, boolean writeAccessOnly)
+    public void validateOnlyAccess(DatabaseDto database, Principal principal, boolean writeAccessOnly)
             throws NotAllowedException, RemoteUnavailableException, MetadataServiceException {
         if (principal == null) {
             throw new NotAllowedException("No principal provided");
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/config/MariaDbConfig.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/config/MariaDbConfig.java
index a30ffb7b81ec455fc4eaa0ca11472eafa2c7aaf2..d4daa90741fa306a2d5c19093d5ad9ebe0d6ba2a 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/config/MariaDbConfig.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/config/MariaDbConfig.java
@@ -1,18 +1,14 @@
 package at.tuwien.config;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
+import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.database.DatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
 import at.tuwien.api.database.query.QueryDto;
-import at.tuwien.api.database.table.columns.ColumnTypeDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import lombok.extern.log4j.Log4j2;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
 
 import java.sql.*;
-import java.time.Instant;
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -21,38 +17,7 @@ import java.util.regex.Pattern;
 @Configuration
 public class MariaDbConfig {
 
-    /**
-     * Inserts a query into a created database with given hostname and database name. The method uses the JDBC in-out
-     * notation <a href="#{@link}">{@link https://learn.microsoft.com/en-us/sql/connect/jdbc/using-sql-escape-sequences?view=sql-server-ver16#stored-procedure-calls}</a>
-     *
-     * @param database The database.
-     * @param query    The query.
-     * @param username The connection username.
-     * @param password The connection password.
-     * @return The generated or retrieved query id.
-     * @throws SQLException The procedure did not succeed.
-     */
-    public static Long mockSystemQueryInsert(PrivilegedDatabaseDto database, String query, String username, String password)
-            throws SQLException {
-        final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
-        log.trace("connect to database {}", jdbc);
-        try (Connection connection = DriverManager.getConnection(jdbc, username, password)) {
-            final String call = "{call _store_query(?,?,?,?)}";
-            log.trace("prepare procedure '{}'", call);
-            final CallableStatement statement = connection.prepareCall(call);
-            statement.setString(1, username);
-            statement.setString(2, query);
-            statement.setTimestamp(3, Timestamp.from(Instant.now()));
-            statement.registerOutParameter(4, Types.BIGINT);
-            statement.executeUpdate();
-            final Long queryId = statement.getLong(4);
-            statement.close();
-            log.debug("received queryId={}", queryId);
-            return queryId;
-        }
-    }
-
-    public static void createDatabase(PrivilegedContainerDto container, String database) throws SQLException {
+    public static void createDatabase(ContainerDto container, String database) throws SQLException {
         final String jdbc = "jdbc:mariadb://" + container.getHost() + ":" + container.getPort();
         log.trace("connect to database {}", jdbc);
         try (Connection connection = DriverManager.getConnection(jdbc, container.getUsername(), container.getPassword())) {
@@ -65,7 +30,7 @@ public class MariaDbConfig {
         log.debug("created database {}", database);
     }
 
-    public static void createInitDatabase(PrivilegedContainerDto container, DatabaseDto database) throws SQLException {
+    public static void createInitDatabase(ContainerDto container, DatabaseDto database) throws SQLException {
         final String jdbc = "jdbc:mariadb://" + container.getHost() + ":" + container.getPort();
         log.trace("connect to database {}", jdbc);
         try (Connection connection = DriverManager.getConnection(jdbc, container.getUsername(), container.getPassword())) {
@@ -76,21 +41,7 @@ public class MariaDbConfig {
         log.debug("created init database {}", database.getInternalName());
     }
 
-    public static void grantReadAccess(PrivilegedDatabaseDto database, String username) {
-        final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
-        log.trace("connect to database {}", jdbc);
-        try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getUsername(), database.getContainer().getPassword())) {
-            connection.prepareStatement("GRANT SELECT ON *.* TO `" + username + "`@`%`;")
-                    .executeUpdate();
-            connection.prepareStatement("FLUSH PRIVILEGES;")
-                    .executeUpdate();
-        } catch (SQLException e) {
-            log.error("could not grant read access", e);
-        }
-        log.debug("granted read access to user {} in database {}", username, database.getInternalName());
-    }
-
-    public static void grantWriteAccess(PrivilegedDatabaseDto database, String username) {
+    public static void grantWriteAccess(DatabaseDto database, String username) {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database {}", jdbc);
         try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getUsername(), database.getContainer().getPassword())) {
@@ -104,7 +55,7 @@ public class MariaDbConfig {
         log.debug("granted read access to user {} in database {}", username, database.getInternalName());
     }
 
-    public static void dropAllDatabases(PrivilegedContainerDto container) {
+    public static void dropAllDatabases(ContainerDto container) {
         final String jdbc = "jdbc:mariadb://" + container.getHost() + ":" + container.getPort();
         log.trace("connect to database {}", jdbc);
         try (Connection connection = DriverManager.getConnection(jdbc, container.getUsername(), container.getPassword())) {
@@ -130,7 +81,7 @@ public class MariaDbConfig {
         log.debug("dropped all databases");
     }
 
-    public static void dropDatabase(PrivilegedContainerDto container, String database)
+    public static void dropDatabase(ContainerDto container, String database)
             throws SQLException {
         final String jdbc = "jdbc:mariadb://" + container.getHost() + ":" + container.getPort();
         log.trace("connect to database {}", jdbc);
@@ -144,26 +95,7 @@ public class MariaDbConfig {
         log.debug("dropped database {}", database);
     }
 
-    public static List<String> getUsernames(String hostname, String database, String username, String password)
-            throws SQLException {
-        final String jdbc = "jdbc:mariadb://" + hostname + "/" + database;
-        log.trace("connect to database {}", jdbc);
-        final List<String> usernames = new LinkedList<>();
-        try (Connection connection = DriverManager.getConnection(jdbc, username, password)) {
-            final String query = "SELECT User FROM mysql.user;";
-            log.trace("prepare statement '{}'", query);
-            final PreparedStatement statement = connection.prepareStatement(query);
-            final ResultSet set = statement.executeQuery();
-            statement.close();
-            while (set.next()) {
-                usernames.add(set.getString("User"));
-            }
-            log.debug("received usernames={}", usernames);
-            return usernames;
-        }
-    }
-
-    public static List<String> getPrivileges(PrivilegedDatabaseDto database, String username) throws SQLException {
+    public static List<String> getPrivileges(DatabaseDto database, String username) throws SQLException {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database {}", jdbc);
         try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getUsername(), database.getContainer().getPassword())) {
@@ -185,7 +117,7 @@ public class MariaDbConfig {
         throw new SQLException("Failed to get privileges");
     }
 
-    public static void dropTable(PrivilegedDatabaseDto database, String table) throws SQLException {
+    public static void dropTable(DatabaseDto database, String table) throws SQLException {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database {}", jdbc);
         try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getUsername(), database.getContainer().getPassword())) {
@@ -209,50 +141,7 @@ public class MariaDbConfig {
         }
     }
 
-    /**
-     * Inserts a query into a created database with given hostname and database name. The method uses the JDBC in-out
-     * notation <a href="#{@link}">{@link https://learn.microsoft.com/en-us/sql/connect/jdbc/using-sql-escape-sequences?view=sql-server-ver16#stored-procedure-calls}</a>
-     *
-     * @param database The database.
-     * @param query    The query.
-     * @param username The connection username.
-     * @param password The connection password.
-     * @return The generated or retrieved query id.
-     * @throws SQLException The procedure did not succeed.
-     */
-    public static Long mockUserQueryInsert(PrivilegedDatabaseDto database, String query, String username, String password)
-            throws SQLException {
-        final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
-        log.trace("connect to database: {}", jdbc);
-        try (Connection connection = DriverManager.getConnection(jdbc, username, password)) {
-            final String call = "{call store_query(?,?,?)}";
-            log.trace("prepare procedure '{}'", call);
-            final CallableStatement statement = connection.prepareCall(call);
-            statement.setString(1, query);
-            statement.setTimestamp(2, Timestamp.from(Instant.now()));
-            statement.registerOutParameter(3, Types.BIGINT);
-            statement.executeUpdate();
-            final Long queryId = statement.getLong(3);
-            statement.close();
-            log.debug("received queryId={}", queryId);
-            return queryId;
-        }
-    }
-
-    /**
-     * Inserts a query into a created database with given hostname and database name. The method uses the JDBC in-out
-     * notation <a href="#{@link}">{@link https://learn.microsoft.com/en-us/sql/connect/jdbc/using-sql-escape-sequences?view=sql-server-ver16#stored-procedure-calls}</a>
-     *
-     * @param database The database.
-     * @param query    The query.
-     * @return The generated or retrieved query id.
-     * @throws SQLException The procedure did not succeed.
-     */
-    public static Long mockSystemQueryInsert(PrivilegedDatabaseDto database, String query) throws SQLException {
-        return mockSystemQueryInsert(database, query, database.getContainer().getUsername(), database.getContainer().getPassword());
-    }
-
-    public static void insertQueryStore(PrivilegedDatabaseDto database, QueryDto query, UUID userId) throws SQLException {
+    public static void insertQueryStore(DatabaseDto database, QueryDto query, UUID userId) throws SQLException {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database: {}", jdbc);
         try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getUsername(), database.getContainer().getPassword())) {
@@ -272,7 +161,7 @@ public class MariaDbConfig {
         }
     }
 
-    public static List<Map<String, Object>> listQueryStore(PrivilegedDatabaseDto database) throws SQLException {
+    public static List<Map<String, Object>> listQueryStore(DatabaseDto database) throws SQLException {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database {}", jdbc);
         try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getUsername(), database.getContainer().getPassword())) {
@@ -297,7 +186,7 @@ public class MariaDbConfig {
         }
     }
 
-    public static List<Map<String, String>> selectQuery(PrivilegedDatabaseDto database, String query, Set<String> columns)
+    public static List<Map<String, String>> selectQuery(DatabaseDto database, String query, Set<String> columns)
             throws SQLException {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database {}", jdbc);
@@ -318,7 +207,7 @@ public class MariaDbConfig {
         return rows;
     }
 
-    public static List<Map<String, byte[]>> selectQueryByteArr(PrivilegedDatabaseDto database, String query, Set<String> columns)
+    public static List<Map<String, byte[]>> selectQueryByteArr(DatabaseDto database, String query, Set<String> columns)
             throws SQLException {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database {}", jdbc);
@@ -339,7 +228,7 @@ public class MariaDbConfig {
         return rows;
     }
 
-    public static void execute(PrivilegedDatabaseDto database, String query)
+    public static void execute(DatabaseDto database, String query)
             throws SQLException {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database {}", jdbc);
@@ -349,17 +238,7 @@ public class MariaDbConfig {
         }
     }
 
-    public static void execute(PrivilegedContainerDto container, String query)
-            throws SQLException {
-        final String jdbc = "jdbc:mariadb://" + container.getHost() + ":" + container.getPort();
-        log.trace("connect to database: {}", jdbc);
-        try (Connection connection = DriverManager.getConnection(jdbc, container.getUsername(), container.getPassword())) {
-            final Statement statement = connection.createStatement();
-            statement.executeUpdate(query);
-        }
-    }
-
-    public static void dropQueryStore(PrivilegedDatabaseDto database)
+    public static void dropQueryStore(DatabaseDto database)
             throws SQLException {
         final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
         log.trace("connect to database: {}", jdbc);
@@ -373,78 +252,4 @@ public class MariaDbConfig {
         }
     }
 
-    public static Map<String, List<Object>> describeTableSchema(PrivilegedTableDto table, String username, String password)
-            throws SQLException {
-        final String jdbc = "jdbc:mariadb://" + table.getDatabase().getContainer().getHost() + ":" + table.getDatabase().getContainer().getPort() + "/" + table.getDatabase().getInternalName();
-        log.trace("connect to database {}", jdbc);
-        final Map<String, List<Object>> out = new HashMap<>();
-        try (Connection connection = DriverManager.getConnection(jdbc, username, password)) {
-            final String query = "SHOW COLUMNS FROM `" + table.getInternalName() + "`;";
-            log.trace("prepare statement '{}'", query);
-            final PreparedStatement statement = connection.prepareStatement(query);
-            final ResultSet resultSet = statement.executeQuery();
-            statement.close();
-            while (resultSet.next()) {
-                if (resultSet.getString("Field").equals("id")) {
-                    continue;
-                }
-                out.put(resultSet.getString("Field"), List.of(resultSet.getString("Type"), resultSet.getString("Null"), resultSet.getString("Key")));
-            }
-            return out;
-        }
-    }
-
-    public static ColumnTypeDto typetoColumnTypeDto(String data) throws Exception {
-        if (data.toUpperCase().startsWith("TINYINT(1)")) {
-            /* boolean in MySQL */
-            return ColumnTypeDto.BOOL;
-        }
-        final Matcher matcher = Pattern.compile("([A-Z]+)")
-                .matcher(data.toUpperCase());
-        if (!matcher.find()) {
-            log.error("Failed to map type: does not match expected format");
-            throw new Exception("Failed to map type: does not match expected format");
-        }
-        final String type = matcher.group(1);
-        try {
-            return ColumnTypeDto.valueOf(type);
-        } catch (IllegalArgumentException e) {
-            if (type.startsWith("TINYINT")) {
-                /* boolean in MySQL */
-                return ColumnTypeDto.BOOL;
-            } else if (type.startsWith("BOOL")) {
-                /* boolean */
-                return ColumnTypeDto.BOOL;
-            } else if (type.startsWith("DOUBLE")) {
-                /* double precision */
-                return ColumnTypeDto.DOUBLE;
-            } else if (type.startsWith("INT")) {
-                /* integer synonym */
-                return ColumnTypeDto.INT;
-            } else if (type.startsWith("DEC")) {
-                /* decimal synonym */
-                return ColumnTypeDto.DECIMAL;
-            } else if (type.startsWith("ENUM")) {
-                return ColumnTypeDto.ENUM;
-            } else if (type.startsWith("SET")) {
-                return ColumnTypeDto.SET;
-            }
-        }
-        log.error("Failed to map data {} and type {}", data, type);
-        throw new Exception("Failed to map data " + data + " and type " + type);
-    }
-
-    public static boolean tableExists(PrivilegedDatabaseDto database, String tableName)
-            throws SQLException {
-        final String jdbc = "jdbc:mariadb://" + database.getContainer().getHost() + ":" + database.getContainer().getPort() + "/" + database.getInternalName();
-        log.trace("connect to database {}", jdbc);
-        try (Connection connection = DriverManager.getConnection(jdbc, database.getContainer().getUsername(), database.getContainer().getPassword())) {
-            final Statement statement = connection.createStatement();
-            final String query = "SHOW TABLES LIKE '" + tableName + "';";
-            log.trace("execute query {}", query);
-            final ResultSet result = statement.executeQuery(query);
-            return result.next();
-        }
-    }
-
 }
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/AccessEndpointUnitTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/AccessEndpointUnitTest.java
index 9fb4003dba35234f81cedf8334e74c8489268269..00553dce066641b63afa36da7df33fe6e9c192ca 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/AccessEndpointUnitTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/AccessEndpointUnitTest.java
@@ -1,8 +1,8 @@
 package at.tuwien.endpoint;
 
 import at.tuwien.api.database.AccessTypeDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.endpoints.AccessEndpoint;
 import at.tuwien.exception.*;
 import at.tuwien.service.AccessService;
@@ -51,7 +51,7 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_4_ID))
                 .thenReturn(USER_4_PRIVILEGED_DTO);
 
@@ -68,7 +68,7 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_1_ID))
                 .thenReturn(USER_1_PRIVILEGED_DTO);
 
@@ -85,12 +85,12 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_4_ID))
                 .thenReturn(USER_4_PRIVILEGED_DTO);
         doThrow(SQLException.class)
                 .when(accessService)
-                .create(DATABASE_1_PRIVILEGED_DTO, USER_4_PRIVILEGED_DTO, AccessTypeDto.READ);
+                .create(DATABASE_1_DTO, USER_4_PRIVILEGED_DTO, AccessTypeDto.READ);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -121,7 +121,7 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(UserNotFoundException.class)
                 .when(credentialService)
                 .getUser(USER_4_ID);
@@ -149,7 +149,7 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_1_ID))
                 .thenReturn(USER_1_PRIVILEGED_DTO);
 
@@ -166,12 +166,12 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_1_ID))
                 .thenReturn(USER_1_PRIVILEGED_DTO);
         doThrow(SQLException.class)
                 .when(accessService)
-                .update(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO, AccessTypeDto.READ);
+                .update(DATABASE_1_DTO, USER_1_PRIVILEGED_DTO, AccessTypeDto.READ);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -186,7 +186,7 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_4_ID))
                 .thenReturn(USER_4_PRIVILEGED_DTO);
 
@@ -229,7 +229,7 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(UserNotFoundException.class)
                 .when(credentialService)
                 .getUser(USER_1_ID);
@@ -248,12 +248,12 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_1_ID))
                 .thenReturn(USER_1_PRIVILEGED_DTO);
         doNothing()
                 .when(accessService)
-                .delete(any(PrivilegedDatabaseDto.class), any(PrivilegedUserDto.class));
+                .delete(any(DatabaseDto.class), any(UserDto.class));
 
         /* test */
         final ResponseEntity<Void> response = accessEndpoint.revoke(DATABASE_1_ID, USER_1_ID);
@@ -268,7 +268,7 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_4_ID))
                 .thenReturn(USER_4_PRIVILEGED_DTO);
 
@@ -311,7 +311,7 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(UserNotFoundException.class)
                 .when(credentialService)
                 .getUser(USER_1_ID);
@@ -329,12 +329,12 @@ public class AccessEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         when(credentialService.getUser(USER_1_ID))
                 .thenReturn(USER_1_PRIVILEGED_DTO);
         doThrow(SQLException.class)
                 .when(accessService)
-                .delete(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO);
+                .delete(DATABASE_1_DTO, USER_1_PRIVILEGED_DTO);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/DatabaseEndpointUnitTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/DatabaseEndpointUnitTest.java
index c55442290ec1d17336dd73ac1dd4574f33e689a4..592063e03412f480db0e1bd796b4825445114e60 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/DatabaseEndpointUnitTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/DatabaseEndpointUnitTest.java
@@ -2,13 +2,10 @@ package at.tuwien.endpoint;
 
 import at.tuwien.api.database.AccessTypeDto;
 import at.tuwien.api.database.DatabaseDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.endpoints.DatabaseEndpoint;
 import at.tuwien.exception.*;
-import at.tuwien.service.AccessService;
-import at.tuwien.service.CredentialService;
-import at.tuwien.service.DatabaseService;
-import at.tuwien.service.SubsetService;
+import at.tuwien.service.*;
 import at.tuwien.test.AbstractUnitTest;
 import lombok.extern.log4j.Log4j2;
 import org.junit.jupiter.api.BeforeEach;
@@ -41,6 +38,9 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
     @MockBean
     private SubsetService queryService;
 
+    @MockBean
+    private ContainerService containerService;
+
     @MockBean
     private AccessService accessService;
 
@@ -63,15 +63,15 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getContainer(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
-        when(databaseService.create(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_CREATE_INTERNAL))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
+        when(containerService.createDatabase(CONTAINER_1_DTO, DATABASE_1_CREATE_INTERNAL))
+                .thenReturn(DATABASE_1_DTO);
         doNothing()
-                .when(queryService)
-                .createQueryStore(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
+                .when(containerService)
+                .createQueryStore(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
         doNothing()
                 .when(accessService)
-                .create(eq(DATABASE_1_PRIVILEGED_DTO), any(PrivilegedUserDto.class), any(AccessTypeDto.class));
+                .create(eq(DATABASE_1_DTO), any(UserDto.class), any(AccessTypeDto.class));
 
         /* test */
         final ResponseEntity<DatabaseDto> response = databaseEndpoint.create(DATABASE_1_CREATE_INTERNAL);
@@ -85,15 +85,15 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getContainer(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
-        when(databaseService.create(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_CREATE_INTERNAL))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
+        when(containerService.createDatabase(CONTAINER_1_DTO, DATABASE_1_CREATE_INTERNAL))
+                .thenReturn(DATABASE_1_DTO);
         doNothing()
-                .when(queryService)
-                .createQueryStore(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
+                .when(containerService)
+                .createQueryStore(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
         doNothing()
                 .when(accessService)
-                .create(eq(DATABASE_1_PRIVILEGED_DTO), any(PrivilegedUserDto.class), any(AccessTypeDto.class));
+                .create(eq(DATABASE_1_DTO), any(UserDto.class), any(AccessTypeDto.class));
 
         /* test */
         assertThrows(org.springframework.security.access.AccessDeniedException.class, () -> {
@@ -108,10 +108,10 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getContainer(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         doThrow(SQLException.class)
-                .when(databaseService)
-                .create(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_CREATE_INTERNAL);
+                .when(containerService)
+                .createDatabase(CONTAINER_1_DTO, DATABASE_1_CREATE_INTERNAL);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -144,11 +144,11 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
         doThrow(ContainerNotFoundException.class)
                 .when(credentialService)
                 .getContainer(CONTAINER_1_ID);
-        when(databaseService.create(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_CREATE_INTERNAL))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+        when(containerService.createDatabase(CONTAINER_1_DTO, DATABASE_1_CREATE_INTERNAL))
+                .thenReturn(DATABASE_1_DTO);
         doThrow(QueryStoreCreateException.class)
-                .when(queryService)
-                .createQueryStore(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
+                .when(containerService)
+                .createQueryStore(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
 
         /* test */
         assertThrows(ContainerNotFoundException.class, () -> {
@@ -163,7 +163,7 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
 
         /* test */
         databaseEndpoint.update(DATABASE_1_ID, USER_1_UPDATE_PASSWORD_DTO);
@@ -176,10 +176,10 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(SQLException.class)
                 .when(databaseService)
-                .update(DATABASE_1_PRIVILEGED_DTO, USER_1_UPDATE_PASSWORD_DTO);
+                .update(DATABASE_1_DTO, USER_1_UPDATE_PASSWORD_DTO);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -193,7 +193,7 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
 
         /* test */
         assertThrows(org.springframework.security.access.AccessDeniedException.class, () -> {
@@ -224,10 +224,10 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(DatabaseMalformedException.class)
                 .when(databaseService)
-                .update(DATABASE_1_PRIVILEGED_DTO, USER_1_UPDATE_PASSWORD_DTO);
+                .update(DATABASE_1_DTO, USER_1_UPDATE_PASSWORD_DTO);
 
         /* test */
         assertThrows(DatabaseMalformedException.class, () -> {
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/SubsetEndpointUnitTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/SubsetEndpointUnitTest.java
index 8a08f8231fe0de7babf1db995dc60786407425f8..c76aa91ebfe7e2bace3ed3d44d20bd5adb112747 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/SubsetEndpointUnitTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/SubsetEndpointUnitTest.java
@@ -1,6 +1,6 @@
 package at.tuwien.endpoint;
 
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.query.ExecuteStatementDto;
 import at.tuwien.api.database.query.QueryDto;
 import at.tuwien.api.database.query.QueryPersistDto;
@@ -8,7 +8,6 @@ import at.tuwien.endpoints.SubsetEndpoint;
 import at.tuwien.exception.*;
 import at.tuwien.gateway.MetadataServiceGateway;
 import at.tuwien.service.CredentialService;
-import at.tuwien.service.SchemaService;
 import at.tuwien.service.StorageService;
 import at.tuwien.service.SubsetService;
 import at.tuwien.test.AbstractUnitTest;
@@ -25,7 +24,6 @@ import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.security.test.context.support.WithAnonymousUser;
 import org.springframework.security.test.context.support.WithMockUser;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
@@ -53,9 +51,6 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
     @MockBean
     private SubsetService subsetService;
 
-    @MockBean
-    private SchemaService schemaService;
-
     @MockBean
     private MetadataServiceGateway metadataServiceGateway;
 
@@ -68,9 +63,6 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
     @MockBean
     private CredentialService credentialService;
 
-    @MockBean
-    private MockHttpServletRequest mockHttpServletRequest;
-
     @BeforeEach
     public void beforeEach() {
         genesis();
@@ -82,12 +74,12 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
             RemoteUnavailableException, SQLException, MetadataServiceException {
 
         /* mock */
-        when(subsetService.findAll(DATABASE_3_PRIVILEGED_DTO, null))
+        when(subsetService.findAll(DATABASE_3_DTO, null))
                 .thenReturn(List.of(QUERY_1_DTO, QUERY_2_DTO, QUERY_3_DTO, QUERY_4_DTO, QUERY_5_DTO, QUERY_6_DTO));
 
         /* test */
         assertThrows(NotAllowedException.class, () -> {
-            generic_list(DATABASE_3_ID, DATABASE_3_PRIVILEGED_DTO, null);
+            generic_list(DATABASE_3_ID, DATABASE_3_DTO, null);
         });
     }
 
@@ -98,11 +90,11 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
             MetadataServiceException {
 
         /* mock */
-        when(subsetService.findAll(DATABASE_3_PRIVILEGED_DTO, null))
+        when(subsetService.findAll(DATABASE_3_DTO, null))
                 .thenReturn(List.of(QUERY_1_DTO, QUERY_2_DTO, QUERY_3_DTO, QUERY_4_DTO, QUERY_5_DTO, QUERY_6_DTO));
 
         /* test */
-        final List<QueryDto> response = generic_list(DATABASE_3_ID, DATABASE_3_PRIVILEGED_DTO, USER_3_PRINCIPAL);
+        final List<QueryDto> response = generic_list(DATABASE_3_ID, DATABASE_3_DTO, USER_3_PRINCIPAL);
         assertEquals(6, response.size());
     }
 
@@ -123,14 +115,14 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_3_DTO);
         doThrow(SQLException.class)
                 .when(subsetService)
-                .findAll(DATABASE_3_PRIVILEGED_DTO, null);
+                .findAll(DATABASE_3_DTO, null);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
-            generic_list(DATABASE_3_ID, DATABASE_3_PRIVILEGED_DTO, USER_3_PRINCIPAL);
+            generic_list(DATABASE_3_ID, DATABASE_3_DTO, USER_3_PRINCIPAL);
         });
     }
 
@@ -141,8 +133,8 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_1_PRIVILEGED_DTO, QUERY_1_ID))
+                .thenReturn(DATABASE_1_DTO);
+        when(subsetService.findById(DATABASE_1_DTO, QUERY_1_ID))
                 .thenReturn(QUERY_1_DTO);
 
         /* test */
@@ -158,8 +150,8 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_1_PRIVILEGED_DTO, QUERY_1_ID))
+                .thenReturn(DATABASE_1_DTO);
+        when(subsetService.findById(DATABASE_1_DTO, QUERY_1_ID))
                 .thenReturn(QUERY_1_DTO);
 
         /* test */
@@ -176,8 +168,8 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(DATABASE_3_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
 
         /* test */
@@ -191,8 +183,8 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_4_ID))
-                .thenReturn(DATABASE_4_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_4_PRIVILEGED_DTO, QUERY_7_ID))
+                .thenReturn(DATABASE_4_DTO);
+        when(subsetService.findById(DATABASE_4_DTO, QUERY_7_ID))
                 .thenReturn(QUERY_7_DTO);
 
         /* test */
@@ -211,12 +203,12 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_1_PRIVILEGED_DTO, QUERY_1_ID))
+                .thenReturn(DATABASE_1_DTO);
+        when(subsetService.findById(DATABASE_1_DTO, QUERY_1_ID))
                 .thenReturn(QUERY_5_DTO);
         when(storageService.transformDataset(any(Dataset.class)))
                 .thenReturn(EXPORT_RESOURCE_DTO);
-        when(subsetService.getData(any(PrivilegedDatabaseDto.class), any(QueryDto.class), eq(null), eq(null)))
+        when(subsetService.getData(any(DatabaseDto.class), any(QueryDto.class), eq(null), eq(null)))
                 .thenReturn(mock);
 
         /* test */
@@ -233,10 +225,10 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(DATABASE_3_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
-        when(subsetService.getData(any(PrivilegedDatabaseDto.class), any(QueryDto.class), eq(null), eq(null)))
+        when(subsetService.getData(any(DatabaseDto.class), any(QueryDto.class), eq(null), eq(null)))
                 .thenReturn(mock);
         when(storageService.transformDataset(any(Dataset.class)))
                 .thenReturn(EXPORT_RESOURCE_DTO);
@@ -256,10 +248,10 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_4_PRIVILEGED_DTO, QUERY_5_ID))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(DATABASE_4_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
-        when(subsetService.getData(any(PrivilegedDatabaseDto.class), any(QueryDto.class), eq(null), eq(null)))
+        when(subsetService.getData(any(DatabaseDto.class), any(QueryDto.class), eq(null), eq(null)))
                 .thenReturn(mock);
         when(storageService.transformDataset(any(Dataset.class)))
                 .thenReturn(EXPORT_RESOURCE_DTO);
@@ -293,10 +285,10 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_3_DTO);
         doThrow(SQLException.class)
                 .when(subsetService)
-                .findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID);
+                .findById(DATABASE_3_DTO, QUERY_5_ID);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -312,14 +304,14 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(DATABASE_3_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
         when(storageService.transformDataset(any(Dataset.class)))
                 .thenReturn(EXPORT_RESOURCE_DTO);
         doThrow(SQLException.class)
                 .when(subsetService)
-                .getData(eq(DATABASE_3_PRIVILEGED_DTO), eq(QUERY_5_DTO), eq(null), eq(null));
+                .getData(eq(DATABASE_3_DTO), eq(QUERY_5_DTO), eq(null), eq(null));
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -341,13 +333,11 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.getData(eq(DATABASE_3_PRIVILEGED_DTO), any(QueryDto.class), eq(0L), eq(10L)))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.getData(eq(DATABASE_3_DTO), any(QueryDto.class), eq(0L), eq(10L)))
                 .thenReturn(mock);
-        when(subsetService.findById(eq(DATABASE_3_PRIVILEGED_DTO), anyLong()))
+        when(subsetService.findById(eq(DATABASE_3_DTO), anyLong()))
                 .thenReturn(QUERY_5_DTO);
-        when(schemaService.inspectView(eq(DATABASE_3_PRIVILEGED_DTO), anyString()))
-                .thenReturn(VIEW_5_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("POST");
 
@@ -387,12 +377,10 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(schemaService.inspectView(eq(DATABASE_3_PRIVILEGED_DTO), anyString()))
-                .thenReturn(VIEW_5_DTO);
-        when(subsetService.findById(eq(DATABASE_3_PRIVILEGED_DTO), anyLong()))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(eq(DATABASE_3_DTO), anyLong()))
                 .thenReturn(QUERY_5_DTO);
-        when(subsetService.getData(eq(DATABASE_3_PRIVILEGED_DTO), any(QueryDto.class), eq(0L), eq(10L)))
+        when(subsetService.getData(eq(DATABASE_3_DTO), any(QueryDto.class), eq(0L), eq(10L)))
                 .thenReturn(mock);
         when(httpServletRequest.getMethod())
                 .thenReturn("POST");
@@ -413,17 +401,17 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_3_DTO);
         doThrow(SQLException.class)
                 .when(subsetService)
-                .getData(eq(DATABASE_3_PRIVILEGED_DTO), any(QueryDto.class), eq(null), eq(null));
-        when(subsetService.findById(eq(DATABASE_3_PRIVILEGED_DTO), anyLong()))
+                .getData(eq(DATABASE_3_DTO), any(QueryDto.class), eq(null), eq(null));
+        when(subsetService.findById(eq(DATABASE_3_DTO), anyLong()))
                 .thenReturn(QUERY_5_DTO);
         when(metadataServiceGateway.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_READ_ACCESS_DTO);
         doThrow(SQLException.class)
                 .when(subsetService)
-                .create(eq(DATABASE_3_PRIVILEGED_DTO), eq(QUERY_5_STATEMENT), any(Instant.class), eq(USER_1_ID));
+                .create(eq(DATABASE_3_DTO), eq(QUERY_5_STATEMENT), any(Instant.class), eq(USER_1_ID));
         when(httpServletRequest.getMethod())
                 .thenReturn("POST");
 
@@ -468,13 +456,11 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.getData(eq(DATABASE_3_PRIVILEGED_DTO), any(QueryDto.class), eq(0L), eq(10L)))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.getData(eq(DATABASE_3_DTO), any(QueryDto.class), eq(0L), eq(10L)))
                 .thenReturn(mock);
-        when(subsetService.findById(eq(DATABASE_3_PRIVILEGED_DTO), anyLong()))
+        when(subsetService.findById(eq(DATABASE_3_DTO), anyLong()))
                 .thenReturn(QUERY_5_DTO);
-        when(schemaService.inspectView(eq(DATABASE_3_PRIVILEGED_DTO), anyString()))
-                .thenReturn(VIEW_5_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("POST");
 
@@ -496,13 +482,11 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_4_ID))
-                .thenReturn(DATABASE_4_PRIVILEGED_DTO);
-        when(subsetService.findById(eq(DATABASE_4_PRIVILEGED_DTO), anyLong()))
+                .thenReturn(DATABASE_4_DTO);
+        when(subsetService.findById(eq(DATABASE_4_DTO), anyLong()))
                 .thenReturn(QUERY_5_DTO);
-        when(subsetService.getData(eq(DATABASE_4_PRIVILEGED_DTO), any(QueryDto.class), eq(0L), eq(10L)))
+        when(subsetService.getData(eq(DATABASE_4_DTO), any(QueryDto.class), eq(0L), eq(10L)))
                 .thenReturn(mock);
-        when(schemaService.inspectView(eq(DATABASE_4_PRIVILEGED_DTO), anyString()))
-                .thenReturn(VIEW_5_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("POST");
 
@@ -524,13 +508,11 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(subsetService.findById(eq(DATABASE_1_PRIVILEGED_DTO), anyLong()))
+                .thenReturn(DATABASE_1_DTO);
+        when(subsetService.findById(eq(DATABASE_1_DTO), anyLong()))
                 .thenReturn(QUERY_1_DTO);
-        when(subsetService.getData(eq(DATABASE_1_PRIVILEGED_DTO), any(QueryDto.class), eq(0L), eq(10L)))
+        when(subsetService.getData(eq(DATABASE_1_DTO), any(QueryDto.class), eq(0L), eq(10L)))
                 .thenReturn(mock);
-        when(schemaService.inspectView(eq(DATABASE_1_PRIVILEGED_DTO), anyString()))
-                .thenReturn(VIEW_1_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("POST");
 
@@ -550,13 +532,11 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_2_ID))
-                .thenReturn(DATABASE_2_PRIVILEGED_DTO);
-        when(subsetService.findById(eq(DATABASE_2_PRIVILEGED_DTO), anyLong()))
+                .thenReturn(DATABASE_2_DTO);
+        when(subsetService.findById(eq(DATABASE_2_DTO), anyLong()))
                 .thenReturn(QUERY_2_DTO);
-        when(subsetService.getData(eq(DATABASE_2_PRIVILEGED_DTO), any(QueryDto.class), eq(0L), eq(10L)))
+        when(subsetService.getData(eq(DATABASE_2_DTO), any(QueryDto.class), eq(0L), eq(10L)))
                 .thenReturn(mock);
-        when(schemaService.inspectView(eq(DATABASE_2_PRIVILEGED_DTO), anyString()))
-                .thenReturn(VIEW_4_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("POST");
 
@@ -575,15 +555,13 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(DATABASE_3_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
-        when(subsetService.reExecuteCount(DATABASE_3_PRIVILEGED_DTO, QUERY_5_DTO))
+        when(subsetService.reExecuteCount(DATABASE_3_DTO, QUERY_5_DTO))
                 .thenReturn(QUERY_5_RESULT_NUMBER);
-        when(subsetService.getData(eq(DATABASE_3_PRIVILEGED_DTO), any(QueryDto.class), eq(0L), eq(10L)))
+        when(subsetService.getData(eq(DATABASE_3_DTO), any(QueryDto.class), eq(0L), eq(10L)))
                 .thenReturn(mock);
-        when(schemaService.inspectView(eq(DATABASE_3_PRIVILEGED_DTO), anyString()))
-                .thenReturn(VIEW_5_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("GET");
 
@@ -601,10 +579,10 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(DATABASE_3_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
-        when(subsetService.reExecuteCount(DATABASE_3_PRIVILEGED_DTO, QUERY_5_DTO))
+        when(subsetService.reExecuteCount(DATABASE_3_DTO, QUERY_5_DTO))
                 .thenReturn(QUERY_5_RESULT_NUMBER);
         when(httpServletRequest.getMethod())
                 .thenReturn("HEAD");
@@ -627,15 +605,13 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_1_PRIVILEGED_DTO, QUERY_1_ID))
+                .thenReturn(DATABASE_1_DTO);
+        when(subsetService.findById(DATABASE_1_DTO, QUERY_1_ID))
                 .thenReturn(QUERY_1_DTO);
-        when(subsetService.reExecuteCount(DATABASE_1_PRIVILEGED_DTO, QUERY_1_DTO))
+        when(subsetService.reExecuteCount(DATABASE_1_DTO, QUERY_1_DTO))
                 .thenReturn(QUERY_1_RESULT_NUMBER);
-        when(subsetService.getData(DATABASE_1_PRIVILEGED_DTO, QUERY_1_DTO, 0L, 10L))
+        when(subsetService.getData(DATABASE_1_DTO, QUERY_1_DTO, 0L, 10L))
                 .thenReturn(mock);
-        when(schemaService.inspectView(eq(DATABASE_1_PRIVILEGED_DTO), anyString()))
-                .thenReturn(VIEW_1_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("GET");
 
@@ -652,7 +628,7 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
 
         /* test */
         assertThrows(NotAllowedException.class, () -> {
@@ -667,7 +643,7 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(NotAllowedException.class)
                 .when(credentialService)
                 .getAccess(DATABASE_1_ID, USER_1_ID);
@@ -687,10 +663,10 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_1_PRIVILEGED_DTO, QUERY_1_ID))
+                .thenReturn(DATABASE_1_DTO);
+        when(subsetService.findById(DATABASE_1_DTO, QUERY_1_ID))
                 .thenReturn(QUERY_1_DTO);
-        when(subsetService.reExecuteCount(DATABASE_1_PRIVILEGED_DTO, QUERY_1_DTO))
+        when(subsetService.reExecuteCount(DATABASE_1_DTO, QUERY_1_DTO))
                 .thenReturn(QUERY_1_RESULT_NUMBER);
         when(httpServletRequest.getMethod())
                 .thenReturn("HEAD");
@@ -711,14 +687,14 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_1_PRIVILEGED_DTO, QUERY_1_ID))
+                .thenReturn(DATABASE_1_DTO);
+        when(subsetService.findById(DATABASE_1_DTO, QUERY_1_ID))
                 .thenReturn(QUERY_1_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("GET");
         doThrow(SQLException.class)
                 .when(subsetService)
-                .getData(DATABASE_1_PRIVILEGED_DTO, QUERY_1_DTO, 0L, 10L);
+                .getData(DATABASE_1_DTO, QUERY_1_DTO, 0L, 10L);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -739,11 +715,11 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_READ_ACCESS_DTO);
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_3_DTO);
         doNothing()
                 .when(subsetService)
-                .persist(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID, true);
-        when(subsetService.findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID))
+                .persist(DATABASE_3_DTO, QUERY_5_ID, true);
+        when(subsetService.findById(DATABASE_3_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
 
         /* test */
@@ -812,12 +788,12 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_3_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_READ_ACCESS_DTO);
         doThrow(SQLException.class)
                 .when(subsetService)
-                .persist(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID, true);
+                .persist(DATABASE_3_DTO, QUERY_5_ID, true);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -825,7 +801,7 @@ public class SubsetEndpointUnitTest extends AbstractUnitTest {
         });
     }
 
-    protected List<QueryDto> generic_list(Long databaseId, PrivilegedDatabaseDto database, Principal principal)
+    protected List<QueryDto> generic_list(Long databaseId, DatabaseDto database, Principal principal)
             throws NotAllowedException, DatabaseUnavailableException, QueryNotFoundException, DatabaseNotFoundException,
             RemoteUnavailableException, MetadataServiceException {
 
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/TableEndpointUnitTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/TableEndpointUnitTest.java
index e3171892a0be41f816feb749990a70aafc252f3d..82be231e56c5a467418328c4882db5f9f2ca8ad4 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/TableEndpointUnitTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/TableEndpointUnitTest.java
@@ -1,14 +1,14 @@
 package at.tuwien.endpoint;
 
 import at.tuwien.api.database.DatabaseAccessDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.query.ImportDto;
 import at.tuwien.api.database.table.*;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import at.tuwien.endpoints.TableEndpoint;
 import at.tuwien.exception.*;
 import at.tuwien.gateway.MetadataServiceGateway;
 import at.tuwien.service.CredentialService;
-import at.tuwien.service.SchemaService;
+import at.tuwien.service.DatabaseService;
 import at.tuwien.service.TableService;
 import at.tuwien.test.AbstractUnitTest;
 import jakarta.servlet.http.HttpServletRequest;
@@ -61,7 +61,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
     private TableService tableService;
 
     @MockBean
-    private SchemaService schemaService;
+    private DatabaseService databaseService;
 
     @MockBean
     private CredentialService credentialService;
@@ -92,16 +92,16 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
     @Test
     @WithMockUser(username = USER_LOCAL_ADMIN_USERNAME, authorities = {"system"})
-    public void create_succeeds() throws DatabaseUnavailableException, TableMalformedException,
+    public void create_succeeds() throws DatabaseUnavailableException, TableMalformedException, ViewNotFoundException,
             DatabaseNotFoundException, TableExistsException, RemoteUnavailableException, SQLException,
             TableNotFoundException, QueryMalformedException, MetadataServiceException, ContainerNotFoundException {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(tableService.createTable(DATABASE_1_PRIVILEGED_DTO, TABLE_4_CREATE_INTERNAL_DTO))
+                .thenReturn(DATABASE_1_DTO);
+        when(databaseService.createTable(DATABASE_1_DTO, TABLE_4_CREATE_INTERNAL_DTO))
                 .thenReturn(TABLE_4_DTO);
-        when(schemaService.inspectTable(DATABASE_1_PRIVILEGED_DTO, TABLE_4_INTERNALNAME))
+        when(databaseService.inspectTable(DATABASE_1_DTO, TABLE_4_INTERNALNAME))
                 .thenReturn(TABLE_4_DTO);
 
         /* test */
@@ -142,10 +142,10 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(SQLException.class)
-                .when(tableService)
-                .createTable(DATABASE_1_PRIVILEGED_DTO, TABLE_4_CREATE_INTERNAL_DTO);
+                .when(databaseService)
+                .createTable(DATABASE_1_DTO, TABLE_4_CREATE_INTERNAL_DTO);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -166,12 +166,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
     @Test
     @WithAnonymousUser
     public void statistic_succeeds() throws DatabaseUnavailableException, TableNotFoundException, SQLException,
-            TableMalformedException, RemoteUnavailableException, MetadataServiceException {
+            TableMalformedException, RemoteUnavailableException, MetadataServiceException, DatabaseNotFoundException {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
-        when(tableService.getStatistics(any(PrivilegedTableDto.class)))
+                .thenReturn(TABLE_8_DTO);
+        when(tableService.getStatistics(any(DatabaseDto.class), any(TableDto.class)))
                 .thenReturn(TABLE_8_STATISTIC_DTO);
 
         /* test */
@@ -186,10 +186,10 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         doThrow(SQLException.class)
                 .when(tableService)
-                .getStatistics(any(PrivilegedTableDto.class));
+                .getStatistics(any(DatabaseDto.class), any(TableDto.class));
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -220,10 +220,10 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         doNothing()
                 .when(tableService)
-                .delete(TABLE_1_PRIVILEGED_DTO);
+                .delete(TABLE_1_DTO);
 
         /* test */
         final ResponseEntity<Void> response = tableEndpoint.delete(DATABASE_1_ID, TABLE_1_ID);
@@ -263,10 +263,10 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         doThrow(SQLException.class)
                 .when(tableService)
-                .delete(TABLE_1_PRIVILEGED_DTO);
+                .delete(TABLE_1_DTO);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -277,13 +277,14 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
     @Test
     @WithAnonymousUser
     public void getData_succeeds() throws DatabaseUnavailableException, TableNotFoundException, QueryMalformedException,
-            RemoteUnavailableException, PaginationException, MetadataServiceException, NotAllowedException {
+            RemoteUnavailableException, PaginationException, MetadataServiceException, NotAllowedException,
+            DatabaseNotFoundException {
         final Dataset<Row> mock = sparkSession.emptyDataFrame();
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
-        when(tableService.getData(eq(DATABASE_3_PRIVILEGED_DTO), eq(TABLE_8_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
+                .thenReturn(TABLE_8_DTO);
+        when(tableService.getData(eq(DATABASE_3_DTO), eq(TABLE_8_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
                 .thenReturn(mock);
         when(httpServletRequest.getMethod())
                 .thenReturn("GET");
@@ -298,15 +299,15 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
     @WithAnonymousUser
     public void getData_head_succeeds() throws DatabaseUnavailableException, TableNotFoundException,
             SQLException, QueryMalformedException, RemoteUnavailableException, PaginationException,
-            MetadataServiceException, NotAllowedException {
+            MetadataServiceException, NotAllowedException, DatabaseNotFoundException {
         final Dataset<Row> mock = sparkSession.emptyDataFrame();
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
-        when(tableService.getCount(eq(TABLE_8_PRIVILEGED_DTO), any(Instant.class)))
+                .thenReturn(TABLE_8_DTO);
+        when(tableService.getCount(eq(TABLE_8_DTO), any(Instant.class)))
                 .thenReturn(3L);
-        when(tableService.getData(eq(DATABASE_3_PRIVILEGED_DTO), eq(TABLE_8_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
+        when(tableService.getData(eq(DATABASE_3_DTO), eq(TABLE_8_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
                 .thenReturn(mock);
         when(httpServletRequest.getMethod())
                 .thenReturn("HEAD");
@@ -328,7 +329,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
         assertThrows(NotAllowedException.class, () -> {
@@ -343,7 +344,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         doThrow(NotAllowedException.class)
                 .when(credentialService)
                 .getAccess(DATABASE_1_ID, USER_2_ID);
@@ -361,10 +362,10 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         doThrow(QueryMalformedException.class)
                 .when(tableService)
-                .getData(eq(DATABASE_3_PRIVILEGED_DTO), eq(TABLE_8_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null));
+                .getData(eq(DATABASE_3_DTO), eq(TABLE_8_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null));
         when(httpServletRequest.getMethod())
                 .thenReturn("GET");
 
@@ -381,7 +382,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         doThrow(RemoteUnavailableException.class)
                 .when(credentialService)
                 .getAccess(DATABASE_1_ID, USER_2_ID);
@@ -397,15 +398,15 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
     @MethodSource("anyAccess_parameters")
     public void getData_private_succeeds(String name, DatabaseAccessDto access) throws DatabaseUnavailableException,
             TableNotFoundException, QueryMalformedException, RemoteUnavailableException, PaginationException,
-            MetadataServiceException, NotAllowedException {
+            MetadataServiceException, NotAllowedException, DatabaseNotFoundException {
         final Dataset<Row> mock = sparkSession.emptyDataFrame();
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_2_ID))
                 .thenReturn(access);
-        when(tableService.getData(eq(DATABASE_1_PRIVILEGED_DTO), eq(TABLE_1_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
+        when(tableService.getData(eq(DATABASE_1_DTO), eq(TABLE_1_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
                 .thenReturn(mock);
         when(httpServletRequest.getMethod())
                 .thenReturn("GET");
@@ -445,12 +446,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_WRITE_OWN_ACCESS_DTO);
         doNothing()
                 .when(tableService)
-                .createTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .createTuple(TABLE_8_DTO, request);
         doNothing()
                 .when(metadataServiceGateway)
                 .updateTableStatistics(DATABASE_3_ID, TABLE_8_ID, TOKEN_ACCESS_TOKEN);
@@ -511,7 +512,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_READ_ACCESS_DTO);
 
@@ -535,12 +536,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_WRITE_OWN_ACCESS_DTO);
         doThrow(SQLException.class)
                 .when(tableService)
-                .createTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .createTuple(TABLE_8_DTO, request);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -562,7 +563,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_WRITE_OWN_ACCESS_DTO);
 
@@ -583,7 +584,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_OWN_ACCESS_DTO);
 
@@ -607,7 +608,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_ALL_ACCESS_DTO);
 
@@ -632,12 +633,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_WRITE_OWN_ACCESS_DTO);
         doNothing()
                 .when(tableService)
-                .updateTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .updateTuple(TABLE_8_DTO, request);
         doNothing()
                 .when(metadataServiceGateway)
                 .updateTableStatistics(DATABASE_3_ID, TABLE_8_ID, TOKEN_ACCESS_TOKEN);
@@ -707,7 +708,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_READ_ACCESS_DTO);
 
@@ -733,12 +734,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_ALL_ACCESS_DTO);
         doThrow(SQLException.class)
                 .when(tableService)
-                .updateTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .updateTuple(TABLE_8_DTO, request);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -763,12 +764,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_WRITE_OWN_ACCESS_DTO);
         doNothing()
                 .when(tableService)
-                .updateTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .updateTuple(TABLE_8_DTO, request);
         doNothing()
                 .when(metadataServiceGateway)
                 .updateTableStatistics(DATABASE_3_ID, TABLE_8_ID, TOKEN_ACCESS_TOKEN);
@@ -794,7 +795,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_OWN_ACCESS_DTO);
 
@@ -821,12 +822,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_ALL_ACCESS_DTO);
         doNothing()
                 .when(tableService)
-                .updateTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .updateTuple(TABLE_8_DTO, request);
         doNothing()
                 .when(metadataServiceGateway)
                 .updateTableStatistics(DATABASE_3_ID, TABLE_8_ID, TOKEN_ACCESS_TOKEN);
@@ -849,12 +850,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_WRITE_OWN_ACCESS_DTO);
         doNothing()
                 .when(tableService)
-                .deleteTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .deleteTuple(TABLE_8_DTO, request);
         doNothing()
                 .when(metadataServiceGateway)
                 .updateTableStatistics(DATABASE_3_ID, TABLE_8_ID, TOKEN_ACCESS_TOKEN);
@@ -912,7 +913,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_READ_ACCESS_DTO);
 
@@ -934,12 +935,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_OWN_ACCESS_DTO);
         doThrow(SQLException.class)
                 .when(tableService)
-                .deleteTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .deleteTuple(TABLE_8_DTO, request);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -960,12 +961,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_OWN_ACCESS_DTO);
         doNothing()
                 .when(tableService)
-                .deleteTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .deleteTuple(TABLE_8_DTO, request);
         doNothing()
                 .when(metadataServiceGateway)
                 .updateTableStatistics(DATABASE_3_ID, TABLE_8_ID, TOKEN_ACCESS_TOKEN);
@@ -987,7 +988,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_OWN_ACCESS_DTO);
 
@@ -1010,12 +1011,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_ALL_ACCESS_DTO);
         doNothing()
                 .when(tableService)
-                .deleteTuple(TABLE_8_PRIVILEGED_DTO, request);
+                .deleteTuple(TABLE_8_DTO, request);
         doNothing()
                 .when(metadataServiceGateway)
                 .updateTableStatistics(DATABASE_3_ID, TABLE_8_ID, TOKEN_ACCESS_TOKEN);
@@ -1032,8 +1033,8 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
-        when(tableService.history(TABLE_8_PRIVILEGED_DTO, null))
+                .thenReturn(TABLE_8_DTO);
+        when(tableService.history(TABLE_8_DTO, null))
                 .thenReturn(List.of());
 
         /* test */
@@ -1048,7 +1049,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
         assertThrows(NotAllowedException.class, () -> {
@@ -1074,7 +1075,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         doThrow(NotAllowedException.class)
                 .when(credentialService)
                 .getAccess(DATABASE_1_ID, USER_4_ID);
@@ -1092,10 +1093,10 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_2_ID))
                 .thenReturn(DATABASE_1_USER_2_READ_ACCESS_DTO);
-        when(tableService.history(TABLE_1_PRIVILEGED_DTO, 10L))
+        when(tableService.history(TABLE_1_DTO, 10L))
                 .thenReturn(List.of());
 
         /* test */
@@ -1110,10 +1111,10 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         doThrow(SQLException.class)
                 .when(tableService)
-                .history(TABLE_8_PRIVILEGED_DTO, 100L);
+                .history(TABLE_8_DTO, 100L);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -1139,14 +1140,14 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
     @Test
     @WithAnonymousUser
-    public void exportData_succeeds() throws TableNotFoundException, NotAllowedException,
-            StorageUnavailableException, QueryMalformedException, RemoteUnavailableException, MetadataServiceException {
+    public void exportData_succeeds() throws TableNotFoundException, NotAllowedException, StorageUnavailableException,
+            QueryMalformedException, RemoteUnavailableException, MetadataServiceException, DatabaseNotFoundException {
         final Dataset<Row> mock = sparkSession.emptyDataFrame();
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
-        when(tableService.getData(eq(DATABASE_3_PRIVILEGED_DTO), eq(TABLE_8_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
+                .thenReturn(TABLE_8_DTO);
+        when(tableService.getData(eq(DATABASE_3_DTO), eq(TABLE_8_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
                 .thenReturn(mock);
 
         /* test */
@@ -1159,15 +1160,15 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
     @MethodSource("anyAccess_parameters")
     public void exportData_private_succeeds(String name, DatabaseAccessDto access) throws TableNotFoundException,
             NotAllowedException, StorageUnavailableException, QueryMalformedException, RemoteUnavailableException,
-            MetadataServiceException {
+            MetadataServiceException, DatabaseNotFoundException {
         final Dataset<Row> mock = sparkSession.emptyDataFrame();
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_2_ID))
                 .thenReturn(access);
-        when(tableService.getData(eq(DATABASE_1_PRIVILEGED_DTO), eq(TABLE_1_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
+        when(tableService.getData(eq(DATABASE_1_DTO), eq(TABLE_1_INTERNAL_NAME), any(Instant.class), eq(null), eq(null), eq(null), eq(null)))
                 .thenReturn(mock);
 
         /* test */
@@ -1182,7 +1183,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         doThrow(NotAllowedException.class)
                 .when(credentialService)
                 .getAccess(DATABASE_1_ID, USER_4_ID);
@@ -1201,8 +1202,8 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(tableService.getSchemas(DATABASE_3_PRIVILEGED_DTO))
+                .thenReturn(DATABASE_3_DTO);
+        when(databaseService.exploreTables(DATABASE_3_DTO))
                 .thenReturn(List.of(TABLE_8_DTO));
 
         /* test */
@@ -1237,10 +1238,10 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_3_DTO);
         doThrow(SQLException.class)
-                .when(tableService)
-                .getSchemas(DATABASE_3_PRIVILEGED_DTO);
+                .when(databaseService)
+                .exploreTables(DATABASE_3_DTO);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -1260,12 +1261,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_WRITE_OWN_ACCESS_DTO);
         doNothing()
                 .when(tableService)
-                .importDataset(TABLE_8_PRIVILEGED_DTO, request);
+                .importDataset(TABLE_8_DTO, request);
         doNothing()
                 .when(metadataServiceGateway)
                 .updateTableStatistics(DATABASE_3_ID, TABLE_8_ID, TOKEN_ACCESS_TOKEN);
@@ -1324,12 +1325,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_ALL_ACCESS_DTO);
         doThrow(SQLException.class)
                 .when(tableService)
-                .importDataset(any(PrivilegedTableDto.class), eq(request));
+                .importDataset(any(TableDto.class), eq(request));
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -1350,12 +1351,12 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_OWN_ACCESS_DTO);
         doThrow(SQLException.class)
                 .when(tableService)
-                .importDataset(any(PrivilegedTableDto.class), eq(request));
+                .importDataset(any(TableDto.class), eq(request));
 
         /* test */
         assertThrows(NotAllowedException.class, () -> {
@@ -1375,7 +1376,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_READ_ACCESS_DTO);
 
@@ -1398,7 +1399,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_1_WRITE_OWN_ACCESS_DTO);
 
@@ -1418,7 +1419,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_3_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_OWN_ACCESS_DTO);
 
@@ -1441,7 +1442,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         when(credentialService.getAccess(DATABASE_3_ID, USER_1_ID))
                 .thenReturn(DATABASE_3_USER_3_WRITE_ALL_ACCESS_DTO);
 
@@ -1462,7 +1463,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_2_ID))
                 .thenReturn(DATABASE_1_USER_2_WRITE_ALL_ACCESS_DTO);
 
@@ -1483,7 +1484,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_2_ID))
-                .thenReturn(TABLE_2_PRIVILEGED_DTO);
+                .thenReturn(TABLE_2_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_2_ID))
                 .thenReturn(DATABASE_1_USER_2_WRITE_OWN_ACCESS_DTO);
 
@@ -1503,7 +1504,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_2_ID))
                 .thenReturn(DATABASE_1_USER_2_WRITE_OWN_ACCESS_DTO);
 
@@ -1525,7 +1526,7 @@ public class TableEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getTable(DATABASE_1_ID, TABLE_2_ID))
-                .thenReturn(TABLE_2_PRIVILEGED_DTO);
+                .thenReturn(TABLE_2_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_2_ID))
                 .thenReturn(DATABASE_1_USER_2_READ_ACCESS_DTO);
 
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/ViewEndpointUnitTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/ViewEndpointUnitTest.java
index 5f580a2fc12156c6702b4b54e215dd979611b5f9..8586f8f92da772235df50a56ee0f423db9238f10 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/ViewEndpointUnitTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/endpoint/ViewEndpointUnitTest.java
@@ -4,6 +4,7 @@ import at.tuwien.api.database.ViewDto;
 import at.tuwien.endpoints.ViewEndpoint;
 import at.tuwien.exception.*;
 import at.tuwien.service.CredentialService;
+import at.tuwien.service.DatabaseService;
 import at.tuwien.service.TableService;
 import at.tuwien.service.ViewService;
 import at.tuwien.test.AbstractUnitTest;
@@ -40,6 +41,9 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
     @MockBean
     private ViewService viewService;
 
+    @MockBean
+    private DatabaseService databaseService;
+
     @MockBean
     private CredentialService credentialService;
 
@@ -67,8 +71,8 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(viewService.create(DATABASE_1_PRIVILEGED_DTO, VIEW_1_CREATE_DTO))
+                .thenReturn(DATABASE_1_DTO);
+        when(databaseService.createView(DATABASE_1_DTO, VIEW_1_CREATE_DTO))
                 .thenReturn(VIEW_1_DTO);
 
         /* test */
@@ -83,10 +87,10 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(SQLException.class)
-                .when(viewService)
-                .create(DATABASE_1_PRIVILEGED_DTO, VIEW_1_CREATE_DTO);
+                .when(databaseService)
+                .createView(DATABASE_1_DTO, VIEW_1_CREATE_DTO);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -101,8 +105,8 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(viewService.create(DATABASE_1_PRIVILEGED_DTO, VIEW_1_CREATE_DTO))
+                .thenReturn(DATABASE_1_DTO);
+        when(databaseService.createView(DATABASE_1_DTO, VIEW_1_CREATE_DTO))
                 .thenReturn(VIEW_1_DTO);
 
         /* test */
@@ -134,8 +138,8 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
-        when(viewService.getSchemas(DATABASE_1_PRIVILEGED_DTO))
+                .thenReturn(DATABASE_1_DTO);
+        when(databaseService.exploreViews(DATABASE_1_DTO))
                 .thenReturn(List.of(VIEW_1_DTO, VIEW_2_DTO, VIEW_3_DTO));
 
         /* test */
@@ -176,10 +180,10 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doThrow(SQLException.class)
-                .when(viewService)
-                .getSchemas(DATABASE_1_PRIVILEGED_DTO);
+                .when(databaseService)
+                .exploreViews(DATABASE_1_DTO);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -204,10 +208,10 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getView(DATABASE_1_ID, VIEW_1_ID))
-                .thenReturn(VIEW_1_PRIVILEGED_DTO);
+                .thenReturn(VIEW_1_DTO);
         doNothing()
                 .when(viewService)
-                .delete(DATABASE_1_PRIVILEGED_DTO, VIEW_1_INTERNAL_NAME);
+                .delete(VIEW_1_DTO);
 
         /* test */
         final ResponseEntity<Void> response = viewEndpoint.delete(DATABASE_1_ID, VIEW_1_ID);
@@ -221,10 +225,10 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getView(DATABASE_1_ID, VIEW_1_ID))
-                .thenReturn(VIEW_1_PRIVILEGED_DTO);
+                .thenReturn(VIEW_1_DTO);
         doThrow(SQLException.class)
                 .when(viewService)
-                .delete(DATABASE_1_PRIVILEGED_DTO, VIEW_1_INTERNAL_NAME);
+                .delete(VIEW_1_DTO);
 
         /* test */
         assertThrows(DatabaseUnavailableException.class, () -> {
@@ -239,10 +243,10 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getDatabase(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
         doNothing()
                 .when(viewService)
-                .delete(DATABASE_1_PRIVILEGED_DTO, VIEW_1_INTERNAL_NAME);
+                .delete(VIEW_1_DTO);
 
         /* test */
         assertThrows(org.springframework.security.access.AccessDeniedException.class, () -> {
@@ -268,17 +272,17 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
     @Test
     @WithMockUser(username = USER_1_USERNAME, authorities = {"view-database-view-data"})
-    public void getData_private_succeeds() throws RemoteUnavailableException, ViewNotFoundException, ViewMalformedException,
+    public void getData_private_succeeds() throws RemoteUnavailableException, ViewNotFoundException,
             SQLException, DatabaseUnavailableException, QueryMalformedException, PaginationException,
-            NotAllowedException, MetadataServiceException, TableNotFoundException {
+            NotAllowedException, MetadataServiceException, TableNotFoundException, DatabaseNotFoundException {
         final Dataset<Row> mock = sparkSession.emptyDataFrame();
 
         /* mock */
         when(credentialService.getView(DATABASE_1_ID, VIEW_1_ID))
-                .thenReturn(VIEW_1_PRIVILEGED_DTO);
+                .thenReturn(VIEW_1_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_1_ID))
                 .thenReturn(DATABASE_1_USER_1_READ_ACCESS_DTO);
-        when(tableService.getData(eq(DATABASE_1_PRIVILEGED_DTO), eq(VIEW_1_INTERNAL_NAME), any(Instant.class), eq(0L), eq(10L), eq(null), eq(null)))
+        when(tableService.getData(eq(DATABASE_1_DTO), eq(VIEW_1_INTERNAL_NAME), any(Instant.class), eq(0L), eq(10L), eq(null), eq(null)))
                 .thenReturn(mock);
         when(httpServletRequest.getMethod())
                 .thenReturn("GET");
@@ -293,16 +297,16 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
     @WithMockUser(username = USER_1_USERNAME, authorities = {"view-database-view-data"})
     public void getData_privateHead_succeeds() throws RemoteUnavailableException, ViewNotFoundException,
             SQLException, DatabaseUnavailableException, QueryMalformedException, PaginationException,
-            NotAllowedException, MetadataServiceException, TableNotFoundException {
+            NotAllowedException, MetadataServiceException, TableNotFoundException, DatabaseNotFoundException {
 
         /* mock */
         when(credentialService.getView(DATABASE_1_ID, VIEW_3_ID))
-                .thenReturn(VIEW_3_PRIVILEGED_DTO);
+                .thenReturn(VIEW_3_DTO);
         when(credentialService.getAccess(DATABASE_1_ID, USER_1_ID))
                 .thenReturn(DATABASE_1_USER_1_READ_ACCESS_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("HEAD");
-        when(viewService.count(eq(VIEW_3_PRIVILEGED_DTO), any(Instant.class)))
+        when(viewService.count(eq(VIEW_3_DTO), any(Instant.class)))
                 .thenReturn(VIEW_3_DATA_COUNT);
 
         /* test */
@@ -324,7 +328,7 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getView(DATABASE_1_ID, VIEW_3_ID))
-                .thenReturn(VIEW_3_PRIVILEGED_DTO);
+                .thenReturn(VIEW_3_DTO);
         when(httpServletRequest.getMethod())
                 .thenReturn("GET");
         doThrow(NotAllowedException.class)
@@ -360,7 +364,7 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getView(DATABASE_1_ID, VIEW_3_ID))
-                .thenReturn(VIEW_3_PRIVILEGED_DTO);
+                .thenReturn(VIEW_3_DTO);
         doThrow(NotAllowedException.class)
                 .when(credentialService)
                 .getAccess(DATABASE_1_ID, USER_3_ID);
@@ -378,7 +382,7 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getView(DATABASE_1_ID, VIEW_3_ID))
-                .thenReturn(VIEW_3_PRIVILEGED_DTO);
+                .thenReturn(VIEW_3_DTO);
         doThrow(NotAllowedException.class)
                 .when(credentialService)
                 .getAccess(DATABASE_1_ID, USER_3_ID);
@@ -412,7 +416,7 @@ public class ViewEndpointUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(credentialService.getView(DATABASE_1_ID, VIEW_3_ID))
-                .thenReturn(VIEW_3_PRIVILEGED_DTO);
+                .thenReturn(VIEW_3_DTO);
         doThrow(NotAllowedException.class)
                 .when(credentialService)
                 .getAccess(DATABASE_1_ID, USER_1_ID);
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/gateway/MetadataServiceGatewayUnitTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/gateway/MetadataServiceGatewayUnitTest.java
index f65de0707eec016f502d66f45e8f52b5811f042f..a8633836b88705db66ae2c163796c7fd34b270c1 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/gateway/MetadataServiceGatewayUnitTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/gateway/MetadataServiceGatewayUnitTest.java
@@ -1,16 +1,12 @@
 package at.tuwien.gateway;
 
 import at.tuwien.api.container.ContainerDto;
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
 import at.tuwien.api.database.DatabaseAccessDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
 import at.tuwien.api.database.table.TableDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import at.tuwien.api.identifier.IdentifierBriefDto;
 import at.tuwien.api.user.UserDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
 import at.tuwien.exception.*;
 import at.tuwien.test.AbstractUnitTest;
 import lombok.extern.log4j.Log4j2;
@@ -75,13 +71,13 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
                         .body(TABLE_1_DTO));
 
         /* test */
-        final PrivilegedTableDto response = metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID);
-        assertEquals(IMAGE_1_JDBC, response.getDatabase().getContainer().getImage().getJdbcMethod());
-        assertEquals(CONTAINER_1_HOST, response.getDatabase().getContainer().getHost());
-        assertEquals(CONTAINER_1_PORT, response.getDatabase().getContainer().getPort());
-        assertEquals(CONTAINER_1_PRIVILEGED_USERNAME, response.getDatabase().getContainer().getUsername());
-        assertEquals(CONTAINER_1_PRIVILEGED_PASSWORD, response.getDatabase().getContainer().getPassword());
-        assertEquals(DATABASE_1_INTERNALNAME, response.getDatabase().getInternalName());
+        final TableDto response = metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID);
+        assertEquals(IMAGE_1_JDBC, response.getJdbcMethod());
+        assertEquals(CONTAINER_1_HOST, response.getHost());
+        assertEquals(CONTAINER_1_PORT, response.getPort());
+        assertEquals(CONTAINER_1_PRIVILEGED_USERNAME, response.getUsername());
+        assertEquals(CONTAINER_1_PRIVILEGED_PASSWORD, response.getPassword());
+        assertEquals(DATABASE_1_INTERNALNAME, response.getDatabase());
         assertEquals(TABLE_1_INTERNAL_NAME, response.getInternalName());
     }
 
@@ -181,13 +177,13 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
         headers.set("X-Port", "" + CONTAINER_1_PORT);
 
         /* mock */
-        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(PrivilegedDatabaseDto.class)))
+        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(DatabaseDto.class)))
                 .thenReturn(ResponseEntity.ok()
                         .headers(headers)
-                        .body(DATABASE_1_PRIVILEGED_DTO));
+                        .body(DATABASE_1_DTO));
 
         /* test */
-        final PrivilegedDatabaseDto response = metadataServiceGateway.getDatabaseById(DATABASE_1_ID);
+        final DatabaseDto response = metadataServiceGateway.getDatabaseById(DATABASE_1_ID);
         assertEquals(DATABASE_1_ID, response.getId());
     }
 
@@ -197,7 +193,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
         /* mock */
         doThrow(HttpServerErrorException.class)
                 .when(internalRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(PrivilegedDatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(DatabaseDto.class));
 
         /* test */
         assertThrows(RemoteUnavailableException.class, () -> {
@@ -211,7 +207,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
         /* mock */
         doThrow(HttpClientErrorException.NotFound.class)
                 .when(internalRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(PrivilegedDatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(DatabaseDto.class));
 
         /* test */
         assertThrows(DatabaseNotFoundException.class, () -> {
@@ -223,7 +219,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
     public void getDatabaseById_statusCode_fails() {
 
         /* mock */
-        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(PrivilegedDatabaseDto.class)))
+        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(DatabaseDto.class)))
                 .thenReturn(ResponseEntity.status(HttpStatus.NO_CONTENT)
                         .build());
 
@@ -240,7 +236,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
         headers.set("X-Password", CONTAINER_1_PRIVILEGED_PASSWORD);
 
         /* mock */
-        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(PrivilegedDatabaseDto.class)))
+        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(DatabaseDto.class)))
                 .thenReturn(ResponseEntity.status(HttpStatus.OK)
                         .headers(headers)
                         .build());
@@ -261,7 +257,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
                 headers.add(customHeaders.get(j), "");
             }
             /* mock */
-            when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(PrivilegedDatabaseDto.class)))
+            when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(DatabaseDto.class)))
                     .thenReturn(ResponseEntity.status(HttpStatus.OK)
                             .headers(headers)
                             .build());
@@ -285,7 +281,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
                         .body(CONTAINER_1_DTO));
 
         /* test */
-        final PrivilegedContainerDto response = metadataServiceGateway.getContainerById(CONTAINER_1_ID);
+        final ContainerDto response = metadataServiceGateway.getContainerById(CONTAINER_1_ID);
         assertEquals(CONTAINER_1_ID, response.getId());
     }
 
@@ -388,7 +384,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
                         .body(VIEW_1_DTO));
 
         /* test */
-        final PrivilegedViewDto response = metadataServiceGateway.getViewById(CONTAINER_1_ID, VIEW_1_ID);
+        final ViewDto response = metadataServiceGateway.getViewById(CONTAINER_1_ID, VIEW_1_ID);
         assertEquals(VIEW_1_ID, response.getId());
     }
 
@@ -477,19 +473,6 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
         });
     }
 
-    @Test
-    public void getUserById_succeeds() throws RemoteUnavailableException, UserNotFoundException, MetadataServiceException {
-
-        /* mock */
-        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(UserDto.class)))
-                .thenReturn(ResponseEntity.ok()
-                        .body(USER_1_DTO));
-
-        /* test */
-        final UserDto response = metadataServiceGateway.getUserById(USER_1_ID);
-        assertEquals(USER_1_ID, response.getId());
-    }
-
     @Test
     public void getUserById_unavailable_fails() {
 
@@ -505,49 +488,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
     }
 
     @Test
-    public void getUserById_notFound_fails() {
-
-        /* mock */
-        doThrow(HttpClientErrorException.NotFound.class)
-                .when(internalRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(UserDto.class));
-
-        /* test */
-        assertThrows(UserNotFoundException.class, () -> {
-            metadataServiceGateway.getUserById(USER_1_ID);
-        });
-    }
-
-    @Test
-    public void getUserById_statusCode_fails() {
-
-        /* mock */
-        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(UserDto.class)))
-                .thenReturn(ResponseEntity.status(HttpStatus.NO_CONTENT)
-                        .build());
-
-        /* test */
-        assertThrows(MetadataServiceException.class, () -> {
-            metadataServiceGateway.getUserById(USER_1_ID);
-        });
-    }
-
-    @Test
-    public void getUserById_emptyBody_fails() {
-
-        /* mock */
-        when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(UserDto.class)))
-                .thenReturn(ResponseEntity.ok()
-                        .build());
-
-        /* test */
-        assertThrows(MetadataServiceException.class, () -> {
-            metadataServiceGateway.getUserById(USER_1_ID);
-        });
-    }
-
-    @Test
-    public void getPrivilegedUserById_succeeds() throws RemoteUnavailableException, UserNotFoundException,
+    public void getUserById_succeeds() throws RemoteUnavailableException, UserNotFoundException,
             MetadataServiceException {
         final HttpHeaders headers = new HttpHeaders();
         headers.set("X-Username", CONTAINER_1_PRIVILEGED_USERNAME);
@@ -560,28 +501,14 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
                         .body(USER_1_DTO));
 
         /* test */
-        final PrivilegedUserDto response = metadataServiceGateway.getPrivilegedUserById(USER_1_ID);
+        final UserDto response = metadataServiceGateway.getUserById(USER_1_ID);
         assertEquals(USER_1_ID, response.getId());
         assertEquals(CONTAINER_1_PRIVILEGED_USERNAME, response.getUsername());
         assertEquals(CONTAINER_1_PRIVILEGED_PASSWORD, response.getPassword());
     }
 
     @Test
-    public void getPrivilegedUserById_unavailable_fails() {
-
-        /* mock */
-        doThrow(HttpServerErrorException.class)
-                .when(internalRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(UserDto.class));
-
-        /* test */
-        assertThrows(RemoteUnavailableException.class, () -> {
-            metadataServiceGateway.getPrivilegedUserById(USER_1_ID);
-        });
-    }
-
-    @Test
-    public void getPrivilegedUserById_notFound_fails() {
+    public void getUserById_notFound_fails() {
 
         /* mock */
         doThrow(HttpClientErrorException.NotFound.class)
@@ -590,12 +517,12 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
 
         /* test */
         assertThrows(UserNotFoundException.class, () -> {
-            metadataServiceGateway.getPrivilegedUserById(USER_1_ID);
+            metadataServiceGateway.getUserById(USER_1_ID);
         });
     }
 
     @Test
-    public void getPrivilegedUserById_statusCode_fails() {
+    public void getUserById_statusCode_fails() {
 
         /* mock */
         when(internalRestTemplate.exchange(anyString(), eq(HttpMethod.GET), eq(HttpEntity.EMPTY), eq(UserDto.class)))
@@ -604,12 +531,12 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
 
         /* test */
         assertThrows(MetadataServiceException.class, () -> {
-            metadataServiceGateway.getPrivilegedUserById(USER_1_ID);
+            metadataServiceGateway.getUserById(USER_1_ID);
         });
     }
 
     @Test
-    public void getPrivilegedUserById_headerMissing_fails() {
+    public void getUserById_headerMissing_fails() {
         final List<String> customHeaders = List.of("X-Username", "X-Password");
 
         for (int i = 0; i < customHeaders.size(); i++) {
@@ -624,13 +551,13 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
 
             /* test */
             assertThrows(MetadataServiceException.class, () -> {
-                metadataServiceGateway.getPrivilegedUserById(USER_1_ID);
+                metadataServiceGateway.getUserById(USER_1_ID);
             });
         }
     }
 
     @Test
-    public void getPrivilegedUserById_emptyBody_fails() {
+    public void getUserById_emptyBody_fails() {
         final HttpHeaders headers = new HttpHeaders();
         headers.set("X-Username", CONTAINER_1_PRIVILEGED_USERNAME);
         headers.set("X-Password", CONTAINER_1_PRIVILEGED_PASSWORD);
@@ -643,7 +570,7 @@ public class MetadataServiceGatewayUnitTest extends AbstractUnitTest {
 
         /* test */
         assertThrows(MetadataServiceException.class, () -> {
-            metadataServiceGateway.getPrivilegedUserById(USER_1_ID);
+            metadataServiceGateway.getUserById(USER_1_ID);
         });
     }
 
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/listener/DefaultListenerIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/listener/DefaultListenerIntegrationTest.java
index 88bad7b06124df10f5a3cec690e993ac5b8ffcd5..44e5f88912627f20741a25967f9774c24b945f65 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/listener/DefaultListenerIntegrationTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/listener/DefaultListenerIntegrationTest.java
@@ -57,8 +57,8 @@ public class DefaultListenerIntegrationTest extends AbstractUnitTest {
     public void beforeEach() throws SQLException {
         genesis();
         /* database */
-        MariaDbConfig.dropAllDatabases(CONTAINER_1_PRIVILEGED_DTO);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
+        MariaDbConfig.dropAllDatabases(CONTAINER_1_DTO);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
     }
 
     @Test
@@ -68,7 +68,7 @@ public class DefaultListenerIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
         defaultListener.onMessage(request);
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/listener/DefaultListenerUnitTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/listener/DefaultListenerUnitTest.java
index 648e36caa938f11e564ce772b00c25ba24d18281..b3a3bf639763cc0ff56837bff07d66c8d5a3b356 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/listener/DefaultListenerUnitTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/listener/DefaultListenerUnitTest.java
@@ -52,8 +52,8 @@ public class DefaultListenerUnitTest extends AbstractUnitTest {
     @BeforeEach
     public void beforeEach() throws SQLException {
         /* metadata database */
-        MariaDbConfig.dropAllDatabases(CONTAINER_1_PRIVILEGED_DTO);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
+        MariaDbConfig.dropAllDatabases(CONTAINER_1_DTO);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
     }
 
     @Test
@@ -81,7 +81,7 @@ public class DefaultListenerUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
         defaultListener.onMessage(request);
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/mvc/SubsetEndpointMvcTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/mvc/SubsetEndpointMvcTest.java
index 158c6743a4e7bac049cae0211fe764030ab4a3f0..abbe28d55a328086f4d726360f2e9b5d34929389 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/mvc/SubsetEndpointMvcTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/mvc/SubsetEndpointMvcTest.java
@@ -41,8 +41,8 @@ public class SubsetEndpointMvcTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getDatabaseById(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(DATABASE_3_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
 
         /* test */
@@ -56,8 +56,8 @@ public class SubsetEndpointMvcTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getDatabaseById(DATABASE_3_ID))
-                .thenReturn(DATABASE_3_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_3_PRIVILEGED_DTO, QUERY_5_ID))
+                .thenReturn(DATABASE_3_DTO);
+        when(subsetService.findById(DATABASE_3_DTO, QUERY_5_ID))
                 .thenReturn(QUERY_5_DTO);
 
         /* test */
@@ -72,8 +72,8 @@ public class SubsetEndpointMvcTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getDatabaseById(DATABASE_4_ID))
-                .thenReturn(DATABASE_4_PRIVILEGED_DTO);
-        when(subsetService.findById(DATABASE_4_PRIVILEGED_DTO, QUERY_7_ID))
+                .thenReturn(DATABASE_4_DTO);
+        when(subsetService.findById(DATABASE_4_DTO, QUERY_7_ID))
                 .thenReturn(QUERY_5_DTO);
 
         /* test */
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/AccessServiceIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/AccessServiceIntegrationTest.java
index 5eccf50ed2568a40d868a0f819f763c026368d83..bc121c3b265be3e1b40be470e9261615aaa7b84e 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/AccessServiceIntegrationTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/AccessServiceIntegrationTest.java
@@ -44,16 +44,16 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
     public void beforeEach() throws SQLException {
         genesis();
         /* metadata database */
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
     }
 
     @Test
     public void create_read_succeeds() throws SQLException, DatabaseMalformedException {
 
         /* test */
-        accessService.create(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO, AccessTypeDto.READ);
-        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_PRIVILEGED_DTO, USER_1_USERNAME);
+        accessService.create(DATABASE_1_DTO, USER_1_DTO, AccessTypeDto.READ);
+        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_DTO, USER_1_USERNAME);
         for (String privilege : grantDefaultRead.split(",")) {
             assertTrue(privileges.stream().anyMatch(p -> p.trim().equals(privilege.trim())));
         }
@@ -63,8 +63,8 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
     public void create_writeOwn_succeeds() throws SQLException, DatabaseMalformedException {
 
         /* test */
-        accessService.create(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO, AccessTypeDto.WRITE_OWN);
-        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_PRIVILEGED_DTO, USER_1_USERNAME);
+        accessService.create(DATABASE_1_DTO, USER_1_DTO, AccessTypeDto.WRITE_OWN);
+        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_DTO, USER_1_USERNAME);
         for (String privilege : grantDefaultWrite.split(",")) {
             assertTrue(privileges.stream().anyMatch(p -> p.trim().equals(privilege.trim())));
         }
@@ -74,8 +74,8 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
     public void create_writeAll_succeeds() throws SQLException, DatabaseMalformedException {
 
         /* test */
-        accessService.create(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO, AccessTypeDto.WRITE_ALL);
-        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_PRIVILEGED_DTO, USER_1_USERNAME);
+        accessService.create(DATABASE_1_DTO, USER_1_DTO, AccessTypeDto.WRITE_ALL);
+        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_DTO, USER_1_USERNAME);
         for (String privilege : grantDefaultWrite.split(",")) {
             assertTrue(privileges.stream().anyMatch(p -> p.trim().equals(privilege.trim())));
         }
@@ -85,8 +85,8 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
     public void update_read_succeeds() throws SQLException, DatabaseMalformedException {
 
         /* test */
-        accessService.update(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO, AccessTypeDto.READ);
-        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_PRIVILEGED_DTO, USER_1_USERNAME);
+        accessService.update(DATABASE_1_DTO, USER_1_DTO, AccessTypeDto.READ);
+        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_DTO, USER_1_USERNAME);
         for (String privilege : grantDefaultRead.split(",")) {
             assertTrue(privileges.stream().anyMatch(p -> p.trim().equals(privilege.trim())));
         }
@@ -96,8 +96,8 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
     public void update_writeOwn_succeeds() throws SQLException, DatabaseMalformedException {
 
         /* test */
-        accessService.update(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO, AccessTypeDto.WRITE_OWN);
-        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_PRIVILEGED_DTO, USER_1_USERNAME);
+        accessService.update(DATABASE_1_DTO, USER_1_DTO, AccessTypeDto.WRITE_OWN);
+        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_DTO, USER_1_USERNAME);
         for (String privilege : grantDefaultWrite.split(",")) {
             assertTrue(privileges.stream().anyMatch(p -> p.trim().equals(privilege.trim())));
         }
@@ -107,8 +107,8 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
     public void update_writeAll_succeeds() throws SQLException, DatabaseMalformedException {
 
         /* test */
-        accessService.update(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO, AccessTypeDto.WRITE_ALL);
-        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_PRIVILEGED_DTO, USER_1_USERNAME);
+        accessService.update(DATABASE_1_DTO, USER_1_DTO, AccessTypeDto.WRITE_ALL);
+        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_DTO, USER_1_USERNAME);
         for (String privilege : grantDefaultWrite.split(",")) {
             assertTrue(privileges.stream().anyMatch(p -> p.trim().equals(privilege.trim())));
         }
@@ -119,7 +119,7 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
 
         /* test */
         assertThrows(DatabaseMalformedException.class, () -> {
-            accessService.update(DATABASE_1_PRIVILEGED_DTO, USER_5_PRIVILEGED_DTO, AccessTypeDto.WRITE_ALL);
+            accessService.update(DATABASE_1_DTO, USER_5_DTO, AccessTypeDto.WRITE_ALL);
         });
     }
 
@@ -127,8 +127,8 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
     public void delete_succeeds() throws SQLException, DatabaseMalformedException {
 
         /* test */
-        accessService.delete(DATABASE_1_PRIVILEGED_DTO, USER_1_PRIVILEGED_DTO);
-        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_PRIVILEGED_DTO, USER_1_USERNAME);
+        accessService.delete(DATABASE_1_DTO, USER_1_DTO);
+        final List<String> privileges = MariaDbConfig.getPrivileges(DATABASE_1_DTO, USER_1_USERNAME);
         assertEquals(1, privileges.size());
         assertEquals("USAGE", privileges.get(0));
     }
@@ -138,7 +138,7 @@ public class AccessServiceIntegrationTest extends AbstractUnitTest {
 
         /* test */
         assertThrows(DatabaseMalformedException.class, () -> {
-            accessService.delete(DATABASE_1_PRIVILEGED_DTO, USER_5_PRIVILEGED_DTO);
+            accessService.delete(DATABASE_1_DTO, USER_5_DTO);
         });
     }
 
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/ContainerServiceIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/ContainerServiceIntegrationTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e793a8362c595eeeb9db6b4d9053ae94c40ac237
--- /dev/null
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/ContainerServiceIntegrationTest.java
@@ -0,0 +1,109 @@
+package at.tuwien.service;
+
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.config.MariaDbConfig;
+import at.tuwien.config.MariaDbContainerConfig;
+import at.tuwien.exception.DatabaseMalformedException;
+import at.tuwien.exception.QueryStoreCreateException;
+import at.tuwien.test.AbstractUnitTest;
+import lombok.extern.log4j.Log4j2;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.MariaDBContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@Log4j2
+@SpringBootTest
+@ExtendWith(SpringExtension.class)
+@Testcontainers
+public class ContainerServiceIntegrationTest extends AbstractUnitTest {
+
+    @Autowired
+    private ContainerService containerService;
+
+    @Container
+    private static MariaDBContainer<?> mariaDBContainer = MariaDbContainerConfig.getContainer();
+
+    @BeforeAll
+    public static void beforeAll() throws InterruptedException {
+        Thread.sleep(1000) /* wait for test container some more */;
+    }
+
+    @BeforeEach
+    public void beforeEach() throws SQLException {
+        genesis();
+        /* metadata database */
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
+    }
+
+    @Test
+    public void create_succeeds() throws SQLException, DatabaseMalformedException {
+
+        /* test */
+        final DatabaseDto response = containerService.createDatabase(CONTAINER_1_DTO, DATABASE_1_CREATE_INTERNAL);
+        assertNull(response.getName());
+        assertEquals(DATABASE_1_INTERNALNAME, response.getInternalName());
+        assertEquals(EXCHANGE_DBREPO_NAME, response.getExchangeName());
+        assertNotNull(response.getOwner());
+        assertEquals(USER_1_ID, response.getOwner().getId());
+        assertNotNull(response.getContact());
+        assertEquals(USER_1_ID, response.getContact().getId());
+        assertNotNull(response.getContainer());
+        assertEquals(CONTAINER_1_ID, response.getContainer().getId());
+    }
+
+    @Test
+    public void create_exists_fails() throws SQLException {
+
+        /* mock */
+        MariaDbConfig.createDatabase(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
+
+        /* test */
+        assertThrows(DatabaseMalformedException.class, () -> {
+            containerService.createDatabase(CONTAINER_1_DTO, DATABASE_1_CREATE_INTERNAL);
+        });
+    }
+
+    @Test
+    public void createQueryStore_succeeds() throws SQLException, QueryStoreCreateException, InterruptedException {
+
+        /* mock */
+        MariaDbConfig.dropQueryStore(DATABASE_1_DTO);
+
+        /* test */
+        createQueryStore_generic(DATABASE_1_INTERNALNAME);
+    }
+
+    @Test
+    public void createQueryStore_fails() {
+
+        /* test */
+        assertThrows(QueryStoreCreateException.class, () -> {
+            createQueryStore_generic(DATABASE_1_INTERNALNAME);
+        });
+    }
+
+    protected void createQueryStore_generic(String databaseName) throws SQLException, QueryStoreCreateException,
+            InterruptedException {
+
+        /* pre-condition */
+        Thread.sleep(1000) /* wait for test container some more */;
+
+        /* test */
+        containerService.createQueryStore(CONTAINER_1_DTO, databaseName);
+        final List<Map<String, Object>> response = MariaDbConfig.listQueryStore(DATABASE_1_DTO);
+        assertEquals(0, response.size());
+    }
+}
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/CredentialServiceUnitTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/CredentialServiceUnitTest.java
index 160918bfaadbd5563dbf311e18f305efa9c6823f..8b5e2cc7c5c5e1becf569bafcd0af6b9c3f13b66 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/CredentialServiceUnitTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/CredentialServiceUnitTest.java
@@ -1,11 +1,11 @@
 package at.tuwien.service;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
+import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.database.DatabaseAccessDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.ViewDto;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.exception.*;
 import at.tuwien.gateway.MetadataServiceGateway;
 import at.tuwien.service.impl.CredentialServiceImpl;
@@ -48,10 +48,10 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getDatabaseById(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_1_DTO);
 
         /* test */
-        final PrivilegedDatabaseDto response = credentialService.getDatabase(DATABASE_1_ID);
+        final DatabaseDto response = credentialService.getDatabase(DATABASE_1_ID);
         assertNotNull(response);
         assertEquals(DATABASE_1_ID, response.getId());
     }
@@ -62,12 +62,12 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getDatabaseById(DATABASE_1_ID))
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO)
+                .thenReturn(DATABASE_1_DTO)
                 .thenThrow(RuntimeException.class) /* should never be thrown */;
         credentialService.getDatabase(DATABASE_1_ID);
 
         /* test */
-        final PrivilegedDatabaseDto response = credentialService.getDatabase(DATABASE_1_ID);
+        final DatabaseDto response = credentialService.getDatabase(DATABASE_1_ID);
         assertNotNull(response);
         assertEquals(DATABASE_1_ID, response.getId());
     }
@@ -78,16 +78,16 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getDatabaseById(DATABASE_1_ID))
-                .thenReturn(DATABASE_2_PRIVILEGED_DTO) /* needs to be different id for test case */
-                .thenReturn(DATABASE_1_PRIVILEGED_DTO);
+                .thenReturn(DATABASE_2_DTO) /* needs to be different id for test case */
+                .thenReturn(DATABASE_1_DTO);
 
         /* pre-condition */
-        final PrivilegedDatabaseDto tmp = credentialService.getDatabase(DATABASE_1_ID);
+        final DatabaseDto tmp = credentialService.getDatabase(DATABASE_1_ID);
         assertNotEquals(DATABASE_1_ID, tmp.getId());
         Thread.sleep(5000);
 
         /* test */
-        final PrivilegedDatabaseDto response = credentialService.getDatabase(DATABASE_1_ID);
+        final DatabaseDto response = credentialService.getDatabase(DATABASE_1_ID);
         assertNotNull(response);
         assertEquals(DATABASE_1_ID, response.getId());
     }
@@ -98,10 +98,10 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
 
         /* test */
-        final PrivilegedContainerDto response = credentialService.getContainer(CONTAINER_1_ID);
+        final ContainerDto response = credentialService.getContainer(CONTAINER_1_ID);
         assertNotNull(response);
         assertEquals(CONTAINER_1_ID, response.getId());
     }
@@ -112,12 +112,12 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO)
+                .thenReturn(CONTAINER_1_DTO)
                 .thenThrow(RuntimeException.class) /* should never be thrown */;
         credentialService.getContainer(CONTAINER_1_ID);
 
         /* test */
-        final PrivilegedContainerDto response = credentialService.getContainer(CONTAINER_1_ID);
+        final ContainerDto response = credentialService.getContainer(CONTAINER_1_ID);
         assertNotNull(response);
         assertEquals(CONTAINER_1_ID, response.getId());
     }
@@ -128,16 +128,16 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(DATABASE_1_ID))
-                .thenReturn(CONTAINER_2_PRIVILEGED_DTO) /* needs to be different id for test case */
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_2_DTO) /* needs to be different id for test case */
+                .thenReturn(CONTAINER_1_DTO);
 
         /* pre-condition */
-        final PrivilegedContainerDto tmp = credentialService.getContainer(CONTAINER_1_ID);
+        final ContainerDto tmp = credentialService.getContainer(CONTAINER_1_ID);
         assertNotEquals(CONTAINER_1_ID, tmp.getId());
         Thread.sleep(5000);
 
         /* test */
-        final PrivilegedContainerDto response = credentialService.getContainer(CONTAINER_1_ID);
+        final ContainerDto response = credentialService.getContainer(CONTAINER_1_ID);
         assertNotNull(response);
         assertEquals(CONTAINER_1_ID, response.getId());
     }
@@ -147,11 +147,11 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
             UserNotFoundException {
 
         /* mock */
-        when(metadataServiceGateway.getPrivilegedUserById(USER_1_ID))
-                .thenReturn(USER_1_PRIVILEGED_DTO);
+        when(metadataServiceGateway.getUserById(USER_1_ID))
+                .thenReturn(USER_1_DTO);
 
         /* test */
-        final PrivilegedUserDto response = credentialService.getUser(USER_1_ID);
+        final UserDto response = credentialService.getUser(USER_1_ID);
         assertNotNull(response);
         assertEquals(USER_1_ID, response.getId());
     }
@@ -161,13 +161,13 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
             UserNotFoundException {
 
         /* mock */
-        when(metadataServiceGateway.getPrivilegedUserById(USER_1_ID))
-                .thenReturn(USER_1_PRIVILEGED_DTO)
+        when(metadataServiceGateway.getUserById(USER_1_ID))
+                .thenReturn(USER_1_DTO)
                 .thenThrow(RuntimeException.class) /* should never be thrown */;
         credentialService.getUser(USER_1_ID);
 
         /* test */
-        final PrivilegedUserDto response = credentialService.getUser(USER_1_ID);
+        final UserDto response = credentialService.getUser(USER_1_ID);
         assertNotNull(response);
         assertEquals(USER_1_ID, response.getId());
     }
@@ -177,17 +177,17 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
             InterruptedException, UserNotFoundException {
 
         /* mock */
-        when(metadataServiceGateway.getPrivilegedUserById(USER_1_ID))
-                .thenReturn(USER_2_PRIVILEGED_DTO) /* needs to be different id for test case */
-                .thenReturn(USER_1_PRIVILEGED_DTO);
+        when(metadataServiceGateway.getUserById(USER_1_ID))
+                .thenReturn(USER_2_DTO) /* needs to be different id for test case */
+                .thenReturn(USER_1_DTO);
 
         /* pre-condition */
-        final PrivilegedUserDto tmp = credentialService.getUser(USER_1_ID);
+        final UserDto tmp = credentialService.getUser(USER_1_ID);
         assertNotEquals(USER_1_ID, tmp.getId());
         Thread.sleep(5000);
 
         /* test */
-        final PrivilegedUserDto response = credentialService.getUser(USER_1_ID);
+        final UserDto response = credentialService.getUser(USER_1_ID);
         assertNotNull(response);
         assertEquals(USER_1_ID, response.getId());
     }
@@ -251,10 +251,10 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        final PrivilegedTableDto response = credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
+        final TableDto response = credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
         assertNotNull(response);
         assertEquals(TABLE_1_ID, response.getId());
     }
@@ -265,12 +265,12 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO)
+                .thenReturn(TABLE_1_DTO)
                 .thenThrow(RuntimeException.class) /* should never be thrown */;
         credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
 
         /* test */
-        final PrivilegedTableDto response = credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
+        final TableDto response = credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
         assertNotNull(response);
         assertEquals(TABLE_1_ID, response.getId());
     }
@@ -281,16 +281,16 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_2_PRIVILEGED_DTO) /* needs to be different id for test case */
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_2_DTO) /* needs to be different id for test case */
+                .thenReturn(TABLE_1_DTO);
 
         /* pre-condition */
-        final PrivilegedTableDto tmp = credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
+        final TableDto tmp = credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
         assertNotEquals(TABLE_1_ID, tmp.getId());
         Thread.sleep(5000);
 
         /* test */
-        final PrivilegedTableDto response = credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
+        final TableDto response = credentialService.getTable(DATABASE_1_ID, TABLE_1_ID);
         assertNotNull(response);
         assertEquals(TABLE_1_ID, response.getId());
     }
@@ -301,10 +301,10 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getViewById(DATABASE_1_ID, VIEW_1_ID))
-                .thenReturn(VIEW_1_PRIVILEGED_DTO);
+                .thenReturn(VIEW_1_DTO);
 
         /* test */
-        final PrivilegedViewDto response = credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
+        final ViewDto response = credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
         assertNotNull(response);
         assertEquals(VIEW_1_ID, response.getId());
     }
@@ -314,12 +314,12 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getViewById(DATABASE_1_ID, VIEW_1_ID))
-                .thenReturn(VIEW_1_PRIVILEGED_DTO)
+                .thenReturn(VIEW_1_DTO)
                 .thenThrow(RuntimeException.class) /* should never be thrown */;
         credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
 
         /* test */
-        final PrivilegedViewDto response = credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
+        final ViewDto response = credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
         assertNotNull(response);
         assertEquals(VIEW_1_ID, response.getId());
     }
@@ -330,16 +330,16 @@ public class CredentialServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getViewById(DATABASE_1_ID, VIEW_1_ID))
-                .thenReturn(VIEW_2_PRIVILEGED_DTO) /* needs to be different id for test case */
-                .thenReturn(VIEW_1_PRIVILEGED_DTO);
+                .thenReturn(VIEW_2_DTO) /* needs to be different id for test case */
+                .thenReturn(VIEW_1_DTO);
 
         /* pre-condition */
-        final PrivilegedViewDto tmp = credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
+        final ViewDto tmp = credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
         assertNotEquals(VIEW_1_ID, tmp.getId());
         Thread.sleep(5000);
 
         /* test */
-        final PrivilegedViewDto response = credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
+        final ViewDto response = credentialService.getView(DATABASE_1_ID, VIEW_1_ID);
         assertNotNull(response);
         assertEquals(VIEW_1_ID, response.getId());
     }
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/DatabaseServiceIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/DatabaseServiceIntegrationTest.java
index 83d81715bd79a82b7306a3330d2d08e96bab82d0..26ff951dda400984090eee3134b62813d8109638 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/DatabaseServiceIntegrationTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/DatabaseServiceIntegrationTest.java
@@ -1,12 +1,29 @@
 package at.tuwien.service;
 
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
+import at.tuwien.api.database.ViewColumnDto;
+import at.tuwien.api.database.ViewDto;
+import at.tuwien.api.database.table.TableBriefDto;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.api.database.table.columns.ColumnCreateDto;
+import at.tuwien.api.database.table.columns.ColumnDto;
+import at.tuwien.api.database.table.columns.ColumnTypeDto;
+import at.tuwien.api.database.table.constraints.ConstraintsCreateDto;
+import at.tuwien.api.database.table.constraints.ConstraintsDto;
+import at.tuwien.api.database.table.constraints.foreign.ForeignKeyCreateDto;
+import at.tuwien.api.database.table.constraints.foreign.ForeignKeyDto;
+import at.tuwien.api.database.table.constraints.foreign.ForeignKeyReferenceDto;
+import at.tuwien.api.database.table.constraints.foreign.ReferenceTypeDto;
+import at.tuwien.api.database.table.constraints.primary.PrimaryKeyDto;
+import at.tuwien.api.database.table.constraints.unique.UniqueDto;
+import at.tuwien.api.database.table.internal.TableCreateDto;
+import at.tuwien.api.identifier.IdentifierDto;
 import at.tuwien.api.user.internal.UpdateUserPasswordDto;
 import at.tuwien.config.MariaDbConfig;
 import at.tuwien.config.MariaDbContainerConfig;
-import at.tuwien.exception.DatabaseMalformedException;
+import at.tuwien.exception.*;
 import at.tuwien.test.AbstractUnitTest;
 import lombok.extern.log4j.Log4j2;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -19,6 +36,9 @@ import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.sql.SQLException;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -43,35 +63,39 @@ public class DatabaseServiceIntegrationTest extends AbstractUnitTest {
     public void beforeEach() throws SQLException {
         genesis();
         /* metadata database */
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
     }
 
     @Test
-    public void create_succeeds() throws SQLException, DatabaseMalformedException {
+    public void createView_succeeds() throws SQLException, ViewMalformedException {
 
         /* test */
-        final PrivilegedDatabaseDto response = databaseService.create(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_CREATE_INTERNAL);
-        assertNull(response.getName());
-        assertEquals(DATABASE_1_INTERNALNAME, response.getInternalName());
-        assertEquals(EXCHANGE_DBREPO_NAME, response.getExchangeName());
-        assertNotNull(response.getOwner());
-        assertEquals(USER_1_ID, response.getOwner().getId());
-        assertNotNull(response.getContact());
-        assertEquals(USER_1_ID, response.getContact().getId());
-        assertNotNull(response.getContainer());
-        assertEquals(CONTAINER_1_ID, response.getContainer().getId());
+        databaseService.createView(DATABASE_1_DTO, VIEW_1_CREATE_DTO);
     }
 
     @Test
-    public void create_exists_fails() throws SQLException {
-
-        /* mock */
-        MariaDbConfig.createDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
+    public void exploreViews_succeeds() throws SQLException, ViewNotFoundException, DatabaseMalformedException {
 
         /* test */
-        assertThrows(DatabaseMalformedException.class, () -> {
-            databaseService.create(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_CREATE_INTERNAL);
-        });
+        final List<ViewDto> response = databaseService.exploreViews(DATABASE_1_DTO);
+        final ViewDto view0 = response.get(0);
+        assertEquals("not_in_metadata_db2", view0.getName());
+        assertEquals("not_in_metadata_db2", view0.getInternalName());
+        assertEquals(DATABASE_1_ID, view0.getVdbid());
+        assertEquals(DATABASE_1_OWNER, view0.getOwner().getId());
+        assertFalse(view0.getIsInitialView());
+        assertEquals(DATABASE_1_PUBLIC, view0.getIsPublic());
+        assertTrue(view0.getQuery().length() >= 69);
+        assertNotNull(view0.getQueryHash());
+        assertEquals(4, view0.getColumns().size());
+        final ViewColumnDto column0a = view0.getColumns().get(0);
+        assertEquals("date", column0a.getInternalName());
+        final ViewColumnDto column1a = view0.getColumns().get(1);
+        assertEquals("location", column1a.getInternalName());
+        final ViewColumnDto column2a = view0.getColumns().get(2);
+        assertEquals("MinTemp", column2a.getInternalName());
+        final ViewColumnDto column3a = view0.getColumns().get(3);
+        assertEquals("Rainfall", column3a.getInternalName());
     }
 
     @Test
@@ -82,8 +106,8 @@ public class DatabaseServiceIntegrationTest extends AbstractUnitTest {
                 .build();
 
         /* mock */
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
-        MariaDbConfig.grantWriteAccess(DATABASE_1_PRIVILEGED_DTO, USER_1_USERNAME);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
+        MariaDbConfig.grantWriteAccess(DATABASE_1_DTO, USER_1_USERNAME);
 
         /* pre-condition */
         MariaDbConfig.mockQuery(CONTAINER_1_HOST, CONTAINER_1_PORT, DATABASE_1_INTERNALNAME, "CREATE SEQUENCE debug NOCACHE", USER_1_USERNAME, USER_1_PASSWORD);
@@ -95,7 +119,7 @@ public class DatabaseServiceIntegrationTest extends AbstractUnitTest {
         }
 
         /* test */
-        databaseService.update(DATABASE_1_PRIVILEGED_DTO, request);
+        databaseService.update(DATABASE_1_DTO, request);
         MariaDbConfig.mockQuery(CONTAINER_1_HOST, CONTAINER_1_PORT, DATABASE_1_INTERNALNAME, "CREATE SEQUENCE debug2 NOCACHE", USER_1_USERNAME, USER_2_PASSWORD);
     }
 
@@ -107,12 +131,612 @@ public class DatabaseServiceIntegrationTest extends AbstractUnitTest {
                 .build();
 
         /* mock */
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
 
         /* test */
         assertThrows(DatabaseMalformedException.class, () -> {
-            databaseService.update(DATABASE_1_PRIVILEGED_DTO, request);
+            databaseService.update(DATABASE_1_DTO, request);
         });
     }
+    
+    @Test
+    public void inspectTable_sameNameDifferentDb_succeeds() throws TableNotFoundException, SQLException {
+
+        /* mock */
+        MariaDbConfig.execute(DATABASE_2_DTO, "CREATE TABLE not_in_metadata_db (wrong_id BIGINT NOT NULL PRIMARY KEY, given_name VARCHAR(255) NOT NULL, middle_name VARCHAR(255), family_name VARCHAR(255) NOT NULL, age INT NOT NULL) WITH SYSTEM VERSIONING;");
+
+        /* test */
+        final TableDto response = databaseService.inspectTable(DATABASE_1_DTO, "not_in_metadata_db");
+        assertEquals("not_in_metadata_db", response.getInternalName());
+        assertEquals("not_in_metadata_db", response.getName());
+        assertEquals(DATABASE_1_ID, response.getTdbid());
+        assertTrue(response.getIsVersioned());
+        assertEquals(DATABASE_1_PUBLIC, response.getIsPublic());
+        final List<ColumnDto> columns = response.getColumns();
+        assertNotNull(columns);
+        assertEquals(5, columns.size());
+        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
+        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "given_name", "given_name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
+        assertColumn(columns.get(2), null, null, DATABASE_1_ID, "middle_name", "middle_name", ColumnTypeDto.VARCHAR, 255L, null, true, null);
+        assertColumn(columns.get(3), null, null, DATABASE_1_ID, "family_name", "family_name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
+        assertColumn(columns.get(4), null, null, DATABASE_1_ID, "age", "age", ColumnTypeDto.INT, 10L, 0L, false, null);
+        final ConstraintsDto constraints = response.getConstraints();
+        assertNotNull(constraints);
+        final Set<PrimaryKeyDto> primaryKey = constraints.getPrimaryKey();
+        assertEquals(1, primaryKey.size());
+        final Set<String> checks = constraints.getChecks();
+        assertEquals(1, checks.size());
+        assertEquals(Set.of("`age` > 0 and `age` < 120"), checks);
+        final List<UniqueDto> uniques = constraints.getUniques();
+        assertEquals(1, uniques.size());
+        assertEquals(2, uniques.get(0).getColumns().size());
+        assertEquals("not_in_metadata_db", uniques.get(0).getTable().getName());
+        assertEquals("not_in_metadata_db", uniques.get(0).getTable().getInternalName());
+        assertEquals("given_name", uniques.get(0).getColumns().get(0).getInternalName());
+        assertEquals("family_name", uniques.get(0).getColumns().get(1).getInternalName());
+        final List<ForeignKeyDto> foreignKeys = constraints.getForeignKeys();
+        assertEquals(0, foreignKeys.size());
+    }
+
+    @Test
+    public void inspectTableEnum_succeeds() throws TableNotFoundException, SQLException {
+
+        /* test */
+        final TableDto response = databaseService.inspectTable(DATABASE_2_DTO, "experiments");
+        assertEquals("experiments", response.getInternalName());
+        assertEquals("experiments", response.getName());
+        assertEquals(DATABASE_2_ID, response.getTdbid());
+        assertTrue(response.getIsVersioned());
+        assertEquals(DATABASE_2_PUBLIC, response.getIsPublic());
+        assertNotNull(response.getOwner());
+        assertEquals(DATABASE_2_OWNER, response.getOwner().getId());
+        assertEquals(USER_2_NAME, response.getOwner().getName());
+        assertEquals(USER_2_USERNAME, response.getOwner().getUsername());
+        assertEquals(USER_2_FIRSTNAME, response.getOwner().getFirstname());
+        assertEquals(USER_2_LASTNAME, response.getOwner().getLastname());
+        assertEquals(USER_2_QUALIFIED_NAME, response.getOwner().getQualifiedName());
+        final List<IdentifierDto> identifiers = response.getIdentifiers();
+        assertNotNull(identifiers);
+        assertEquals(0, identifiers.size());
+        final List<ColumnDto> columns = response.getColumns();
+        assertNotNull(columns);
+        assertEquals(3, columns.size());
+        assertColumn(columns.get(0), null, null, DATABASE_2_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
+        assertColumn(columns.get(1), null, null, DATABASE_2_ID, "mode", "mode", ColumnTypeDto.ENUM, 3L, null, false, null);
+        assertEquals(2, columns.get(1).getEnums().size());
+        assertEquals(List.of("ABC", "DEF"), columns.get(1).getEnums());
+        assertColumn(columns.get(2), null, null, DATABASE_2_ID, "seq", "seq", ColumnTypeDto.SET, 5L, null, true, null);
+        assertEquals(3, columns.get(2).getSets().size());
+        assertEquals(List.of("1", "2", "3"), columns.get(2).getSets());
+        /* ignore rest (constraints) */
+    }
+
+    @Test
+    public void inspectTableFullConstraints_succeeds() throws TableNotFoundException, SQLException {
+
+        /* test */
+        final TableDto response = databaseService.inspectTable(DATABASE_1_DTO, "weather_aus");
+        assertEquals("weather_aus", response.getInternalName());
+        assertEquals("weather_aus", response.getName());
+        assertEquals(DATABASE_1_ID, response.getTdbid());
+        assertTrue(response.getIsVersioned());
+        assertEquals(DATABASE_1_PUBLIC, response.getIsPublic());
+        assertNotNull(response.getOwner());
+        assertEquals(DATABASE_1_OWNER, response.getOwner().getId());
+        assertEquals(USER_1_NAME, response.getOwner().getName());
+        assertEquals(USER_1_USERNAME, response.getOwner().getUsername());
+        assertEquals(USER_1_FIRSTNAME, response.getOwner().getFirstname());
+        assertEquals(USER_1_LASTNAME, response.getOwner().getLastname());
+        assertEquals(USER_1_QUALIFIED_NAME, response.getOwner().getQualifiedName());
+        final List<IdentifierDto> identifiers = response.getIdentifiers();
+        assertNotNull(identifiers);
+        assertEquals(0, identifiers.size());
+        final List<ColumnDto> columns = response.getColumns();
+        assertNotNull(columns);
+        assertEquals(5, columns.size());
+        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 20L, 0L, false, null);
+        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "date", "date", ColumnTypeDto.DATE, null, null, false, null);
+        assertColumn(columns.get(2), null, null, DATABASE_1_ID, "location", "location", ColumnTypeDto.VARCHAR, 255L, null, true, "Closest city");
+        assertColumn(columns.get(3), null, null, DATABASE_1_ID, "mintemp", "mintemp", ColumnTypeDto.DOUBLE, 22L, null, true, null);
+        assertColumn(columns.get(4), null, null, DATABASE_1_ID, "rainfall", "rainfall", ColumnTypeDto.DOUBLE, 22L, null, true, null);
+        final ConstraintsDto constraints = response.getConstraints();
+        final List<PrimaryKeyDto> primaryKey = new LinkedList<>(constraints.getPrimaryKey());
+        assertEquals(1, primaryKey.size());
+        final PrimaryKeyDto pk0 = primaryKey.get(0);
+        assertNull(pk0.getId());
+        assertNotNull(pk0.getTable());
+        assertNull(pk0.getTable().getId());
+        assertEquals("weather_aus", pk0.getTable().getName());
+        assertEquals("weather_aus", pk0.getTable().getInternalName());
+        assertEquals("Weather in Australia", pk0.getTable().getDescription());
+        assertNotNull(pk0.getColumn());
+        assertNull(pk0.getColumn().getId());
+        assertNull(pk0.getColumn().getTableId());
+        assertEquals(DATABASE_1_ID, pk0.getColumn().getDatabaseId());
+        assertNull(pk0.getColumn().getAlias());
+        assertEquals("id", pk0.getColumn().getName());
+        assertEquals("id", pk0.getColumn().getInternalName());
+        assertEquals(ColumnTypeDto.BIGINT, pk0.getColumn().getColumnType());
+        final List<UniqueDto> uniques = constraints.getUniques();
+        assertEquals(1, uniques.size());
+        final UniqueDto unique0 = uniques.get(0);
+        assertNotNull(unique0.getTable());
+        assertEquals("some_constraint", unique0.getName());
+        assertNull(unique0.getTable().getId());
+        assertEquals(TABLE_1_INTERNAL_NAME, unique0.getTable().getName());
+        assertEquals(TABLE_1_INTERNAL_NAME, unique0.getTable().getInternalName());
+        assertEquals(TABLE_1_DESCRIPTION, unique0.getTable().getDescription());
+        assertTrue(unique0.getTable().getIsVersioned());
+        assertNotNull(unique0.getColumns());
+        assertEquals(1, unique0.getColumns().size());
+        assertNull(unique0.getColumns().get(0).getId());
+        assertNull(unique0.getColumns().get(0).getTableId());
+        assertEquals("date", unique0.getColumns().get(0).getName());
+        assertEquals("date", unique0.getColumns().get(0).getInternalName());
+        final List<String> checks = new LinkedList<>(constraints.getChecks());
+        assertEquals("`mintemp` > 0", checks.get(0));
+        final List<ForeignKeyDto> foreignKeys = constraints.getForeignKeys();
+        assertEquals(1, foreignKeys.size());
+        final ForeignKeyDto fk0 = foreignKeys.get(0);
+        assertNotNull(fk0.getName());
+        assertNotNull(fk0.getReferences());
+        final ForeignKeyReferenceDto fk0ref0 = fk0.getReferences().get(0);
+        assertNull(fk0ref0.getId());
+        assertNotNull(fk0ref0.getColumn());
+        assertNotNull(fk0ref0.getReferencedColumn());
+        assertNotNull(fk0ref0.getForeignKey());
+        assertEquals(DATABASE_1_ID, fk0ref0.getColumn().getDatabaseId());
+        assertNull(fk0ref0.getColumn().getId());
+        assertNull(fk0ref0.getColumn().getTableId());
+        assertEquals("location", fk0ref0.getColumn().getName());
+        assertEquals("location", fk0ref0.getColumn().getInternalName());
+        assertEquals(DATABASE_1_ID, fk0ref0.getReferencedColumn().getDatabaseId());
+        assertNull(fk0ref0.getReferencedColumn().getId());
+        assertNull(fk0ref0.getReferencedColumn().getTableId());
+        assertEquals("location", fk0ref0.getReferencedColumn().getName());
+        assertEquals("location", fk0ref0.getReferencedColumn().getInternalName());
+        assertNotNull(fk0.getOnUpdate());
+        assertEquals(ReferenceTypeDto.RESTRICT, fk0.getOnUpdate());
+        assertNotNull(fk0.getOnDelete());
+        assertEquals(ReferenceTypeDto.SET_NULL, fk0.getOnDelete());
+        final TableBriefDto fk0table = fk0.getTable();
+        assertNull(fk0table.getId());
+        assertEquals(DATABASE_1_ID, fk0table.getDatabaseId());
+        assertEquals(TABLE_1_INTERNAL_NAME, fk0table.getName());
+        assertEquals(TABLE_1_INTERNAL_NAME, fk0table.getInternalName());
+        assertNotNull(fk0.getOnDelete());
+        assertNotNull(fk0.getOnUpdate());
+        assertNotNull(fk0.getReferencedTable());
+        assertEquals(TABLE_2_INTERNALNAME, fk0.getReferencedTable().getName());
+        assertEquals(TABLE_2_INTERNALNAME, fk0.getReferencedTable().getInternalName());
+    }
+
+    @Test
+    public void inspectTable_multipleForeignKeyReferences_succeeds() throws TableNotFoundException, SQLException {
+
+        /* test */
+        final TableDto response = databaseService.inspectTable(DATABASE_1_DTO, "complex_foreign_keys");
+        final ConstraintsDto constraints = response.getConstraints();
+        final List<ForeignKeyDto> foreignKeys = constraints.getForeignKeys();
+        assertEquals(1, foreignKeys.size());
+        final ForeignKeyDto fk0 = foreignKeys.get(0);
+        assertNotNull(fk0.getName());
+        assertNotNull(fk0.getReferences());
+        final ForeignKeyReferenceDto fk0ref0 = fk0.getReferences().get(0);
+        assertNull(fk0ref0.getId());
+        assertNotNull(fk0ref0.getColumn());
+        assertNotNull(fk0ref0.getReferencedColumn());
+        assertNotNull(fk0ref0.getForeignKey());
+        assertEquals(DATABASE_1_ID, fk0ref0.getColumn().getDatabaseId());
+        assertNull(fk0ref0.getColumn().getId());
+        assertNull(fk0ref0.getColumn().getTableId());
+        assertEquals("weather_id", fk0ref0.getColumn().getName());
+        assertEquals("weather_id", fk0ref0.getColumn().getInternalName());
+        assertEquals(DATABASE_1_ID, fk0ref0.getReferencedColumn().getDatabaseId());
+        assertNull(fk0ref0.getReferencedColumn().getId());
+        assertNull(fk0ref0.getReferencedColumn().getTableId());
+        assertEquals("id", fk0ref0.getReferencedColumn().getName());
+        assertEquals("id", fk0ref0.getReferencedColumn().getInternalName());
+        final ForeignKeyReferenceDto fk0ref1 = fk0.getReferences().get(1);
+        assertNull(fk0ref1.getId());
+        assertNotNull(fk0ref1.getColumn());
+        assertNotNull(fk0ref1.getReferencedColumn());
+        assertNotNull(fk0ref1.getForeignKey());
+        assertEquals(DATABASE_1_ID, fk0ref1.getColumn().getDatabaseId());
+        assertNull(fk0ref1.getColumn().getId());
+        assertNull(fk0ref1.getColumn().getTableId());
+        assertEquals("other_id", fk0ref1.getColumn().getName());
+        assertEquals("other_id", fk0ref1.getColumn().getInternalName());
+        assertEquals(DATABASE_1_ID, fk0ref1.getReferencedColumn().getDatabaseId());
+        assertNull(fk0ref1.getReferencedColumn().getId());
+        assertNull(fk0ref1.getReferencedColumn().getTableId());
+        assertEquals("other_id", fk0ref1.getReferencedColumn().getName());
+        assertEquals("other_id", fk0ref1.getReferencedColumn().getInternalName());
+        final TableBriefDto fk0refT0 = fk0.getTable();
+        assertNull(fk0refT0.getId());
+        assertEquals(DATABASE_1_ID, fk0refT0.getDatabaseId());
+        assertEquals("complex_foreign_keys", fk0refT0.getName());
+        assertEquals("complex_foreign_keys", fk0refT0.getInternalName());
+        assertNotNull(fk0.getReferencedTable());
+        assertEquals("complex_primary_key", fk0.getReferencedTable().getName());
+        assertEquals("complex_primary_key", fk0.getReferencedTable().getInternalName());
+        assertNotNull(fk0.getOnDelete());
+        assertNotNull(fk0.getOnUpdate());
+    }
+
+    @Test
+    public void inspectTable_multiplePrimaryKey_succeeds() throws TableNotFoundException, SQLException {
+
+        /* test */
+        final TableDto response = databaseService.inspectTable(DATABASE_1_DTO, "complex_primary_key");
+        final ConstraintsDto constraints = response.getConstraints();
+        final List<PrimaryKeyDto> primaryKey = new LinkedList<>(constraints.getPrimaryKey());
+        assertEquals(2, primaryKey.size());
+        final PrimaryKeyDto pk0 = primaryKey.get(0);
+        assertNull(pk0.getId());
+        assertNotNull(pk0.getTable());
+        assertNull(pk0.getTable().getId());
+        assertEquals("complex_primary_key", pk0.getTable().getName());
+        assertEquals("complex_primary_key", pk0.getTable().getInternalName());
+        assertNotNull(pk0.getColumn());
+        assertNull(pk0.getColumn().getId());
+        assertNull(pk0.getColumn().getTableId());
+        assertEquals(DATABASE_1_ID, pk0.getColumn().getDatabaseId());
+        assertNull(pk0.getColumn().getAlias());
+        assertEquals("id", pk0.getColumn().getName());
+        assertEquals("id", pk0.getColumn().getInternalName());
+        assertEquals(ColumnTypeDto.BIGINT, pk0.getColumn().getColumnType());
+        final PrimaryKeyDto pk1 = primaryKey.get(1);
+        assertNull(pk1.getId());
+        assertNotNull(pk1.getTable());
+        assertNull(pk1.getTable().getId());
+        assertEquals("complex_primary_key", pk1.getTable().getName());
+        assertEquals("complex_primary_key", pk1.getTable().getInternalName());
+        assertNotNull(pk1.getColumn());
+        assertNull(pk1.getColumn().getId());
+        assertNull(pk1.getColumn().getTableId());
+        assertEquals(DATABASE_1_ID, pk1.getColumn().getDatabaseId());
+        assertNull(pk1.getColumn().getAlias());
+        assertEquals("other_id", pk1.getColumn().getName());
+        assertEquals("other_id", pk1.getColumn().getInternalName());
+        assertEquals(ColumnTypeDto.BIGINT, pk1.getColumn().getColumnType());
+    }
+
+    @Test
+    public void inspectTable_exoticBoolean_succeeds() throws TableNotFoundException, SQLException {
+
+        /* test */
+        final TableDto response = databaseService.inspectTable(DATABASE_1_DTO, "exotic_boolean");
+        final ConstraintsDto constraints = response.getConstraints();
+        final List<PrimaryKeyDto> primaryKey = new LinkedList<>(constraints.getPrimaryKey());
+        assertEquals(1, primaryKey.size());
+        final PrimaryKeyDto pk0 = primaryKey.get(0);
+        assertNull(pk0.getId());
+        assertNotNull(pk0.getTable());
+        assertNull(pk0.getTable().getId());
+        assertEquals("exotic_boolean", pk0.getTable().getName());
+        assertEquals("exotic_boolean", pk0.getTable().getInternalName());
+        assertNotNull(pk0.getColumn());
+        assertNull(pk0.getColumn().getId());
+        assertNull(pk0.getColumn().getTableId());
+        assertEquals(DATABASE_1_ID, pk0.getColumn().getDatabaseId());
+        assertNull(pk0.getColumn().getAlias());
+        assertEquals("bool_default", pk0.getColumn().getName());
+        assertEquals("bool_default", pk0.getColumn().getInternalName());
+        assertEquals(ColumnTypeDto.BOOL, pk0.getColumn().getColumnType());
+        final List<ColumnDto> columns = response.getColumns();
+        assertEquals(3, columns.size());
+        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "bool_default", "bool_default", ColumnTypeDto.BOOL, null, 0L, false, null);
+        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "bool_tinyint", "bool_tinyint", ColumnTypeDto.BOOL, null, 0L, false, null);
+        assertColumn(columns.get(2), null, null, DATABASE_1_ID, "bool_tinyint_unsigned", "bool_tinyint_unsigned", ColumnTypeDto.BOOL, null, 0L, false, null);
+    }
+
+    @Test
+    public void inspectView_succeeds() throws SQLException, ViewNotFoundException {
+
+        /* test */
+        final ViewDto response = databaseService.inspectView(DATABASE_1_DTO, "not_in_metadata_db2");
+        assertEquals("not_in_metadata_db2", response.getInternalName());
+        assertEquals("not_in_metadata_db2", response.getName());
+        assertEquals(DATABASE_1_ID, response.getVdbid());
+        assertEquals(DATABASE_1_OWNER, response.getOwner().getId());
+        assertFalse(response.getIsInitialView());
+        assertEquals(DATABASE_1_PUBLIC, response.getIsPublic());
+        assertTrue(response.getQuery().length() >= 69);
+        assertNotNull(response.getQueryHash());
+        assertEquals(4, response.getColumns().size());
+        final ViewColumnDto column0 = response.getColumns().get(0);
+        assertNotNull(column0.getName());
+        assertEquals("date", column0.getInternalName());
+        assertEquals(DATABASE_1_ID, column0.getDatabaseId());
+        final ViewColumnDto column1 = response.getColumns().get(1);
+        assertNotNull(column1.getName());
+        assertEquals("location", column1.getInternalName());
+        assertEquals(DATABASE_1_ID, column1.getDatabaseId());
+        final ViewColumnDto column2 = response.getColumns().get(2);
+        assertNotNull(column2.getName());
+        assertEquals("MinTemp", column2.getInternalName());
+        assertEquals(DATABASE_1_ID, column2.getDatabaseId());
+        final ViewColumnDto column3 = response.getColumns().get(3);
+        assertNotNull(column3.getName());
+        assertEquals("Rainfall", column3.getInternalName());
+        assertEquals(DATABASE_1_ID, column3.getDatabaseId());
+    }
+
+    @Test
+    public void getSchemas_succeeds() throws TableNotFoundException, SQLException, DatabaseMalformedException {
+
+        /* test */
+        final List<TableDto> response = databaseService.exploreTables(DATABASE_1_DTO);
+        assertEquals(4, response.size());
+        final TableDto table0 = response.get(0);
+        Assertions.assertEquals("complex_foreign_keys", table0.getInternalName());
+        Assertions.assertEquals("complex_foreign_keys", table0.getName());
+        Assertions.assertEquals(DATABASE_1_ID, table0.getTdbid());
+        assertTrue(table0.getIsVersioned());
+        Assertions.assertEquals(DATABASE_1_PUBLIC, table0.getIsPublic());
+        final List<ColumnDto> columns0 = table0.getColumns();
+        assertNotNull(columns0);
+        Assertions.assertEquals(3, columns0.size());
+        assertColumn(columns0.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
+        assertColumn(columns0.get(1), null, null, DATABASE_1_ID, "weather_id", "weather_id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
+        assertColumn(columns0.get(2), null, null, DATABASE_1_ID, "other_id", "other_id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
+        final ConstraintsDto constraints0 = table0.getConstraints();
+        assertNotNull(constraints0);
+        assertEquals(1, constraints0.getPrimaryKey().size());
+        final PrimaryKeyDto pk0 = new LinkedList<>(constraints0.getPrimaryKey()).get(0);
+        assertNull(pk0.getId());
+        assertNull(pk0.getColumn().getId());
+        assertEquals("id", pk0.getColumn().getName());
+        assertEquals("id", pk0.getColumn().getInternalName());
+        assertEquals(1, constraints0.getForeignKeys().size());
+        final ForeignKeyDto fk0 = constraints0.getForeignKeys().get(0);
+        assertNotNull(fk0.getName());
+        assertNull(fk0.getTable().getId());
+        assertEquals("complex_foreign_keys", fk0.getTable().getName());
+        assertEquals("complex_foreign_keys", fk0.getTable().getInternalName());
+        assertNull(fk0.getReferencedTable().getId());
+        assertEquals("complex_primary_key", fk0.getReferencedTable().getName());
+        assertEquals("complex_primary_key", fk0.getReferencedTable().getInternalName());
+        assertEquals(2, fk0.getReferences().size());
+        final ForeignKeyReferenceDto fk0r0 = fk0.getReferences().get(0);
+        assertEquals("weather_id", fk0r0.getColumn().getName());
+        assertEquals("weather_id", fk0r0.getColumn().getInternalName());
+        assertNotNull(fk0r0.getColumn().getName());
+        assertNotNull(fk0r0.getForeignKey());
+        assertEquals("id", fk0r0.getReferencedColumn().getName());
+        assertEquals("id", fk0r0.getReferencedColumn().getInternalName());
+        final ForeignKeyReferenceDto fk0r1 = fk0.getReferences().get(1);
+        assertEquals("other_id", fk0r1.getColumn().getName());
+        assertEquals("other_id", fk0r1.getColumn().getInternalName());
+        assertNotNull(fk0r1.getColumn().getName());
+        assertNotNull(fk0r1.getForeignKey());
+        assertEquals("other_id", fk0r1.getReferencedColumn().getName());
+        assertEquals("other_id", fk0r1.getReferencedColumn().getInternalName());
+        assertEquals(0, constraints0.getChecks().size());
+        assertEquals(0, constraints0.getUniques().size());
+        /* table 1 */
+        final TableDto table1 = response.get(1);
+        Assertions.assertEquals("complex_primary_key", table1.getInternalName());
+        Assertions.assertEquals("complex_primary_key", table1.getName());
+        Assertions.assertEquals(DATABASE_1_ID, table1.getTdbid());
+        assertTrue(table1.getIsVersioned());
+        Assertions.assertEquals(DATABASE_1_PUBLIC, table1.getIsPublic());
+        final List<ColumnDto> columns1 = table1.getColumns();
+        assertNotNull(columns1);
+        Assertions.assertEquals(2, columns1.size());
+        assertColumn(columns1.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
+        assertColumn(columns1.get(1), null, null, DATABASE_1_ID, "other_id", "other_id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
+        final ConstraintsDto constraints1 = table1.getConstraints();
+        assertNotNull(constraints1);
+        assertEquals(2, constraints1.getPrimaryKey().size());
+        final PrimaryKeyDto pk10 = new LinkedList<>(constraints1.getPrimaryKey()).get(0);
+        assertNull(pk10.getId());
+        assertNull(pk10.getColumn().getId());
+        assertEquals("id", pk10.getColumn().getName());
+        assertEquals("id", pk10.getColumn().getInternalName());
+        final PrimaryKeyDto pk11 = new LinkedList<>(constraints1.getPrimaryKey()).get(1);
+        assertNull(pk11.getId());
+        assertNull(pk11.getColumn().getId());
+        assertEquals("other_id", pk11.getColumn().getName());
+        assertEquals("other_id", pk11.getColumn().getInternalName());
+        assertEquals(0, constraints1.getForeignKeys().size());
+        assertEquals(0, constraints1.getChecks().size());
+        assertEquals(0, constraints1.getUniques().size());
+        /* table 2 */
+        final TableDto table2 = response.get(2);
+        Assertions.assertEquals("exotic_boolean", table2.getInternalName());
+        Assertions.assertEquals("exotic_boolean", table2.getName());
+        Assertions.assertEquals(DATABASE_1_ID, table2.getTdbid());
+        assertTrue(table2.getIsVersioned());
+        Assertions.assertEquals(DATABASE_1_PUBLIC, table2.getIsPublic());
+        final List<ColumnDto> columns2 = table2.getColumns();
+        assertNotNull(columns2);
+        Assertions.assertEquals(3, columns2.size());
+        assertColumn(columns2.get(0), null, null, DATABASE_1_ID, "bool_default", "bool_default", ColumnTypeDto.BOOL, null, 0L, false, null);
+        assertColumn(columns2.get(1), null, null, DATABASE_1_ID, "bool_tinyint", "bool_tinyint", ColumnTypeDto.BOOL, null, 0L, false, null);
+        assertColumn(columns2.get(2), null, null, DATABASE_1_ID, "bool_tinyint_unsigned", "bool_tinyint_unsigned", ColumnTypeDto.BOOL, null, 0L, false, null);
+        final ConstraintsDto constraints2 = table2.getConstraints();
+        assertNotNull(constraints2);
+        final Set<PrimaryKeyDto> primaryKey2 = constraints2.getPrimaryKey();
+        Assertions.assertEquals(1, primaryKey2.size());
+        final Set<String> checks2 = constraints2.getChecks();
+        Assertions.assertEquals(0, checks2.size());
+        final List<UniqueDto> uniques2 = constraints2.getUniques();
+        Assertions.assertEquals(0, uniques2.size());
+        /* table 3 */
+        final TableDto table3 = response.get(3);
+        Assertions.assertEquals("not_in_metadata_db", table3.getInternalName());
+        Assertions.assertEquals("not_in_metadata_db", table3.getName());
+        Assertions.assertEquals(DATABASE_1_ID, table3.getTdbid());
+        assertTrue(table3.getIsVersioned());
+        Assertions.assertEquals(DATABASE_1_PUBLIC, table3.getIsPublic());
+        final List<ColumnDto> columns3 = table3.getColumns();
+        assertNotNull(columns3);
+        Assertions.assertEquals(5, columns3.size());
+        assertColumn(columns3.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
+        assertColumn(columns3.get(1), null, null, DATABASE_1_ID, "given_name", "given_name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
+        assertColumn(columns3.get(2), null, null, DATABASE_1_ID, "middle_name", "middle_name", ColumnTypeDto.VARCHAR, 255L, null, true, null);
+        assertColumn(columns3.get(3), null, null, DATABASE_1_ID, "family_name", "family_name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
+        assertColumn(columns3.get(4), null, null, DATABASE_1_ID, "age", "age", ColumnTypeDto.INT, 10L, 0L, false, null);
+        final ConstraintsDto constraints3 = table3.getConstraints();
+        assertNotNull(constraints3);
+        final Set<PrimaryKeyDto> primaryKey3 = constraints3.getPrimaryKey();
+        Assertions.assertEquals(1, primaryKey3.size());
+        final Set<String> checks3 = constraints3.getChecks();
+        Assertions.assertEquals(1, checks3.size());
+        Assertions.assertEquals(Set.of("`age` > 0 and `age` < 120"), checks3);
+        final List<UniqueDto> uniques3 = constraints3.getUniques();
+        Assertions.assertEquals(1, uniques3.size());
+        Assertions.assertEquals(2, uniques3.get(0).getColumns().size());
+        Assertions.assertEquals("not_in_metadata_db", uniques3.get(0).getTable().getInternalName());
+        Assertions.assertEquals("given_name", uniques3.get(0).getColumns().get(0).getInternalName());
+        Assertions.assertEquals("family_name", uniques3.get(0).getColumns().get(1).getInternalName());
+    }
+
+    @Test
+    public void createTable_succeeds() throws TableNotFoundException, TableMalformedException, SQLException,
+            TableExistsException {
+
+        /* test */
+        final TableDto response = databaseService.createTable(DATABASE_1_DTO, TABLE_4_CREATE_INTERNAL_DTO);
+        assertEquals(TABLE_4_NAME, response.getName());
+        assertEquals(TABLE_4_INTERNALNAME, response.getInternalName());
+        final List<ColumnDto> columns = response.getColumns();
+        assertEquals(TABLE_4_COLUMNS.size(), columns.size());
+        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "timestamp", "timestamp", ColumnTypeDto.TIMESTAMP, null, null, false, null);
+        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "value", "value", ColumnTypeDto.DECIMAL, 10L, 10L, true, null);
+        final ConstraintsDto constraints = response.getConstraints();
+        assertNotNull(constraints);
+        final Set<PrimaryKeyDto> primaryKey = constraints.getPrimaryKey();
+        Assertions.assertEquals(1, primaryKey.size());
+        final Set<String> checks = constraints.getChecks();
+        Assertions.assertEquals(0, checks.size());
+    }
+
+    @Test
+    public void createTable_malformed_fails() {
+        final at.tuwien.api.database.table.internal.TableCreateDto request = TableCreateDto.builder()
+                .name("missing_foreign_key")
+                .columns(List.of())
+                .constraints(ConstraintsCreateDto.builder()
+                        .foreignKeys(List.of(ForeignKeyCreateDto.builder()
+                                .columns(List.of("i_do_not_exist"))
+                                .referencedTable("neither_do_i")
+                                .referencedColumns(List.of("behold"))
+                                .build()))
+                        .build())
+                .build();
+
+        /* test */
+        assertThrows(TableMalformedException.class, () -> {
+            databaseService.createTable(DATABASE_1_DTO, request);
+        });
+    }
+
+    @Test
+    public void createTable_compositePrimaryKey_fails() throws TableNotFoundException, TableMalformedException, SQLException,
+            TableExistsException {
+        final at.tuwien.api.database.table.internal.TableCreateDto request = TableCreateDto.builder()
+                .name("composite_primary_key")
+                .columns(List.of(ColumnCreateDto.builder()
+                                .name("name")
+                                .type(ColumnTypeDto.VARCHAR)
+                                .size(255L)
+                                .nullAllowed(false)
+                                .build(),
+                        ColumnCreateDto.builder()
+                                .name("lat")
+                                .type(ColumnTypeDto.DECIMAL)
+                                .size(10L)
+                                .d(10L)
+                                .nullAllowed(false)
+                                .build(),
+                        ColumnCreateDto.builder()
+                                .name("lng")
+                                .type(ColumnTypeDto.DECIMAL)
+                                .size(10L)
+                                .d(10L)
+                                .nullAllowed(false)
+                                .build()))
+                .constraints(ConstraintsCreateDto.builder()
+                        .primaryKey(Set.of("lat", "lng"))
+                        .foreignKeys(List.of())
+                        .checks(Set.of())
+                        .uniques(List.of())
+                        .build())
+                .build();
+
+        /* test */
+        final TableDto response = databaseService.createTable(DATABASE_1_DTO, request);
+        assertEquals("composite_primary_key", response.getName());
+        assertEquals("composite_primary_key", response.getInternalName());
+        final List<ColumnDto> columns = response.getColumns();
+        assertEquals(3, columns.size());
+        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "name", "name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
+        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "lat", "lat", ColumnTypeDto.DECIMAL, 10L, 10L, false, null);
+        assertColumn(columns.get(2), null, null, DATABASE_1_ID, "lng", "lng", ColumnTypeDto.DECIMAL, 10L, 10L, false, null);
+        final ConstraintsDto constraints = response.getConstraints();
+        assertNotNull(constraints);
+        final Set<String> checks = constraints.getChecks();
+        assertNotNull(checks);
+        assertEquals(0, checks.size());
+        final List<PrimaryKeyDto> primaryKeys = new LinkedList<>(constraints.getPrimaryKey());
+        assertNotNull(primaryKeys);
+        assertEquals(2, primaryKeys.size());
+        assertEquals("lat", primaryKeys.get(0).getColumn().getInternalName());
+        assertEquals("lng", primaryKeys.get(1).getColumn().getInternalName());
+        final List<ForeignKeyDto> foreignKeys = constraints.getForeignKeys();
+        assertNotNull(foreignKeys);
+        assertEquals(0, foreignKeys.size());
+        final List<UniqueDto> uniques = constraints.getUniques();
+        assertNotNull(uniques);
+        assertEquals(0, uniques.size());
+    }
+
+    @Test
+    public void createTable_needSequence_succeeds() throws TableNotFoundException, TableMalformedException, SQLException,
+            TableExistsException {
+
+        /* mock */
+        MariaDbConfig.dropTable(DATABASE_1_DTO, TABLE_1_INTERNAL_NAME);
+
+        /* test */
+        final TableDto response = databaseService.createTable(DATABASE_1_DTO, TABLE_1_CREATE_INTERNAL_DTO);
+        assertEquals(TABLE_1_NAME, response.getName());
+        assertEquals(TABLE_1_INTERNAL_NAME, response.getInternalName());
+        assertEquals(TABLE_1_COLUMNS.size(), response.getColumns().size());
+    }
+
+    protected static void assertViewColumn(ViewColumnDto column, ViewColumnDto other) {
+        assertNotNull(column);
+        assertNotNull(other);
+        assertEquals(column.getId(), other.getId());
+        assertEquals(column.getDatabaseId(), other.getDatabaseId());
+        assertEquals(column.getName(), other.getName());
+        assertEquals(column.getInternalName(), other.getInternalName());
+        assertEquals(column.getColumnType(), other.getColumnType());
+        assertEquals(column.getSize(), other.getSize());
+        assertEquals(column.getD(), other.getD());
+        assertEquals(column.getIsNullAllowed(), other.getIsNullAllowed());
+        assertEquals(column.getDescription(), other.getDescription());
+    }
+
+    protected static void assertColumn(ColumnDto column, Long id, Long tableId, Long databaseId, String name,
+                                       String internalName, ColumnTypeDto type, Long size, Long d, Boolean nullAllowed,
+                                       String description) {
+        log.trace("assert column: {}", internalName);
+        assertNotNull(column);
+        assertEquals(id, column.getId());
+        assertEquals(tableId, column.getTableId());
+        assertEquals(databaseId, column.getDatabaseId());
+        assertEquals(name, column.getName());
+        assertEquals(internalName, column.getInternalName());
+        assertEquals(type, column.getColumnType());
+        assertEquals(size, column.getSize());
+        assertEquals(d, column.getD());
+        assertEquals(nullAllowed, column.getIsNullAllowed());
+        assertEquals(description, column.getDescription());
+    }
 
 }
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/QueueServiceIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/QueueServiceIntegrationTest.java
index bd57eafacc47a1107e309be0fba94de75371bc95..a2ff1716e5ecf6a1432bf241cc45044c9ca4f663 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/QueueServiceIntegrationTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/QueueServiceIntegrationTest.java
@@ -52,8 +52,8 @@ public class QueueServiceIntegrationTest extends AbstractUnitTest {
     public void beforeEach() throws SQLException {
         genesis();
         /* metadata database */
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
     }
 
     @Test
@@ -69,12 +69,12 @@ public class QueueServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        queueService.insert(TABLE_1_PRIVILEGED_DTO, request);
+        queueService.insert(TABLE_1_DTO, request);
     }
 
     @Test
@@ -87,10 +87,10 @@ public class QueueServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        queueService.insert(TABLE_1_PRIVILEGED_DTO, request);
+        queueService.insert(TABLE_1_DTO, request);
     }
 
 }
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/SchemaServiceIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/SchemaServiceIntegrationTest.java
deleted file mode 100644
index 2a0ad624dbbb8399cf9d360148c96bd0524c8453..0000000000000000000000000000000000000000
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/SchemaServiceIntegrationTest.java
+++ /dev/null
@@ -1,416 +0,0 @@
-package at.tuwien.service;
-
-import at.tuwien.api.database.ViewColumnDto;
-import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.table.TableBriefDto;
-import at.tuwien.api.database.table.TableDto;
-import at.tuwien.api.database.table.columns.ColumnDto;
-import at.tuwien.api.database.table.columns.ColumnTypeDto;
-import at.tuwien.api.database.table.constraints.ConstraintsDto;
-import at.tuwien.api.database.table.constraints.foreign.ForeignKeyDto;
-import at.tuwien.api.database.table.constraints.foreign.ForeignKeyReferenceDto;
-import at.tuwien.api.database.table.constraints.foreign.ReferenceTypeDto;
-import at.tuwien.api.database.table.constraints.primary.PrimaryKeyDto;
-import at.tuwien.api.database.table.constraints.unique.UniqueDto;
-import at.tuwien.api.identifier.IdentifierDto;
-import at.tuwien.config.MariaDbConfig;
-import at.tuwien.config.MariaDbContainerConfig;
-import at.tuwien.exception.TableNotFoundException;
-import at.tuwien.exception.ViewNotFoundException;
-import at.tuwien.test.AbstractUnitTest;
-import lombok.extern.log4j.Log4j2;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.test.context.junit.jupiter.SpringExtension;
-import org.testcontainers.containers.MariaDBContainer;
-import org.testcontainers.junit.jupiter.Container;
-import org.testcontainers.junit.jupiter.Testcontainers;
-
-import java.sql.SQLException;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-@Log4j2
-@SpringBootTest
-@ExtendWith(SpringExtension.class)
-@Testcontainers
-public class SchemaServiceIntegrationTest extends AbstractUnitTest {
-
-    @Autowired
-    private SchemaService schemaService;
-
-    @Container
-    private static MariaDBContainer<?> mariaDBContainer = MariaDbContainerConfig.getContainer();
-
-    @BeforeEach
-    public void beforeEach() throws SQLException {
-        genesis();
-        /* metadata database */
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_2_INTERNALNAME);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_2_DTO);
-    }
-
-    @Test
-    public void inspectTable_sameNameDifferentDb_succeeds() throws TableNotFoundException, SQLException {
-
-        /* mock */
-        MariaDbConfig.execute(DATABASE_2_PRIVILEGED_DTO, "CREATE TABLE not_in_metadata_db (wrong_id BIGINT NOT NULL PRIMARY KEY, given_name VARCHAR(255) NOT NULL, middle_name VARCHAR(255), family_name VARCHAR(255) NOT NULL, age INT NOT NULL) WITH SYSTEM VERSIONING;");
-
-        /* test */
-        final TableDto response = schemaService.inspectTable(DATABASE_1_PRIVILEGED_DTO, "not_in_metadata_db");
-        assertEquals("not_in_metadata_db", response.getInternalName());
-        assertEquals("not_in_metadata_db", response.getName());
-        assertEquals(DATABASE_1_ID, response.getTdbid());
-        assertTrue(response.getIsVersioned());
-        assertEquals(DATABASE_1_PUBLIC, response.getIsPublic());
-        final List<ColumnDto> columns = response.getColumns();
-        assertNotNull(columns);
-        assertEquals(5, columns.size());
-        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
-        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "given_name", "given_name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
-        assertColumn(columns.get(2), null, null, DATABASE_1_ID, "middle_name", "middle_name", ColumnTypeDto.VARCHAR, 255L, null, true, null);
-        assertColumn(columns.get(3), null, null, DATABASE_1_ID, "family_name", "family_name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
-        assertColumn(columns.get(4), null, null, DATABASE_1_ID, "age", "age", ColumnTypeDto.INT, 10L, 0L, false, null);
-        final ConstraintsDto constraints = response.getConstraints();
-        assertNotNull(constraints);
-        final Set<PrimaryKeyDto> primaryKey = constraints.getPrimaryKey();
-        assertEquals(1, primaryKey.size());
-        final Set<String> checks = constraints.getChecks();
-        assertEquals(1, checks.size());
-        assertEquals(Set.of("`age` > 0 and `age` < 120"), checks);
-        final List<UniqueDto> uniques = constraints.getUniques();
-        assertEquals(1, uniques.size());
-        assertEquals(2, uniques.get(0).getColumns().size());
-        assertEquals("not_in_metadata_db", uniques.get(0).getTable().getName());
-        assertEquals("not_in_metadata_db", uniques.get(0).getTable().getInternalName());
-        assertEquals("given_name", uniques.get(0).getColumns().get(0).getInternalName());
-        assertEquals("family_name", uniques.get(0).getColumns().get(1).getInternalName());
-        final List<ForeignKeyDto> foreignKeys = constraints.getForeignKeys();
-        assertEquals(0, foreignKeys.size());
-    }
-
-    @Test
-    public void inspectTableEnum_succeeds() throws TableNotFoundException, SQLException {
-
-        /* test */
-        final TableDto response = schemaService.inspectTable(DATABASE_2_PRIVILEGED_DTO, "experiments");
-        assertEquals("experiments", response.getInternalName());
-        assertEquals("experiments", response.getName());
-        assertEquals(DATABASE_2_ID, response.getTdbid());
-        assertTrue(response.getIsVersioned());
-        assertEquals(DATABASE_2_PUBLIC, response.getIsPublic());
-        assertNotNull(response.getOwner());
-        assertEquals(DATABASE_2_OWNER, response.getOwner().getId());
-        assertEquals(USER_2_NAME, response.getOwner().getName());
-        assertEquals(USER_2_USERNAME, response.getOwner().getUsername());
-        assertEquals(USER_2_FIRSTNAME, response.getOwner().getFirstname());
-        assertEquals(USER_2_LASTNAME, response.getOwner().getLastname());
-        assertEquals(USER_2_QUALIFIED_NAME, response.getOwner().getQualifiedName());
-        final List<IdentifierDto> identifiers = response.getIdentifiers();
-        assertNotNull(identifiers);
-        assertEquals(0, identifiers.size());
-        final List<ColumnDto> columns = response.getColumns();
-        assertNotNull(columns);
-        assertEquals(3, columns.size());
-        assertColumn(columns.get(0), null, null, DATABASE_2_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
-        assertColumn(columns.get(1), null, null, DATABASE_2_ID, "mode", "mode", ColumnTypeDto.ENUM, 3L, null, false, null);
-        assertEquals(2, columns.get(1).getEnums().size());
-        assertEquals(List.of("ABC", "DEF"), columns.get(1).getEnums());
-        assertColumn(columns.get(2), null, null, DATABASE_2_ID, "seq", "seq", ColumnTypeDto.SET, 5L, null, true, null);
-        assertEquals(3, columns.get(2).getSets().size());
-        assertEquals(List.of("1", "2", "3"), columns.get(2).getSets());
-        /* ignore rest (constraints) */
-    }
-
-    @Test
-    public void inspectTableFullConstraints_succeeds() throws TableNotFoundException, SQLException {
-
-        /* test */
-        final TableDto response = schemaService.inspectTable(DATABASE_1_PRIVILEGED_DTO, "weather_aus");
-        assertEquals("weather_aus", response.getInternalName());
-        assertEquals("weather_aus", response.getName());
-        assertEquals(DATABASE_1_ID, response.getTdbid());
-        assertTrue(response.getIsVersioned());
-        assertEquals(DATABASE_1_PUBLIC, response.getIsPublic());
-        assertNotNull(response.getOwner());
-        assertEquals(DATABASE_1_OWNER, response.getOwner().getId());
-        assertEquals(USER_1_NAME, response.getOwner().getName());
-        assertEquals(USER_1_USERNAME, response.getOwner().getUsername());
-        assertEquals(USER_1_FIRSTNAME, response.getOwner().getFirstname());
-        assertEquals(USER_1_LASTNAME, response.getOwner().getLastname());
-        assertEquals(USER_1_QUALIFIED_NAME, response.getOwner().getQualifiedName());
-        final List<IdentifierDto> identifiers = response.getIdentifiers();
-        assertNotNull(identifiers);
-        assertEquals(0, identifiers.size());
-        final List<ColumnDto> columns = response.getColumns();
-        assertNotNull(columns);
-        assertEquals(5, columns.size());
-        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 20L, 0L, false, null);
-        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "date", "date", ColumnTypeDto.DATE, null, null, false, null);
-        assertColumn(columns.get(2), null, null, DATABASE_1_ID, "location", "location", ColumnTypeDto.VARCHAR, 255L, null, true, "Closest city");
-        assertColumn(columns.get(3), null, null, DATABASE_1_ID, "mintemp", "mintemp", ColumnTypeDto.DOUBLE, 22L, null, true, null);
-        assertColumn(columns.get(4), null, null, DATABASE_1_ID, "rainfall", "rainfall", ColumnTypeDto.DOUBLE, 22L, null, true, null);
-        final ConstraintsDto constraints = response.getConstraints();
-        final List<PrimaryKeyDto> primaryKey = new LinkedList<>(constraints.getPrimaryKey());
-        assertEquals(1, primaryKey.size());
-        final PrimaryKeyDto pk0 = primaryKey.get(0);
-        assertNull(pk0.getId());
-        assertNotNull(pk0.getTable());
-        assertNull(pk0.getTable().getId());
-        assertEquals("weather_aus", pk0.getTable().getName());
-        assertEquals("weather_aus", pk0.getTable().getInternalName());
-        assertEquals("Weather in Australia", pk0.getTable().getDescription());
-        assertNotNull(pk0.getColumn());
-        assertNull(pk0.getColumn().getId());
-        assertNull(pk0.getColumn().getTableId());
-        assertEquals(DATABASE_1_ID, pk0.getColumn().getDatabaseId());
-        assertNull(pk0.getColumn().getAlias());
-        assertEquals("id", pk0.getColumn().getName());
-        assertEquals("id", pk0.getColumn().getInternalName());
-        assertEquals(ColumnTypeDto.BIGINT, pk0.getColumn().getColumnType());
-        final List<UniqueDto> uniques = constraints.getUniques();
-        assertEquals(1, uniques.size());
-        final UniqueDto unique0 = uniques.get(0);
-        assertNotNull(unique0.getTable());
-        assertEquals("some_constraint", unique0.getName());
-        assertNull(unique0.getTable().getId());
-        assertEquals(TABLE_1_INTERNAL_NAME, unique0.getTable().getName());
-        assertEquals(TABLE_1_INTERNAL_NAME, unique0.getTable().getInternalName());
-        assertEquals(TABLE_1_DESCRIPTION, unique0.getTable().getDescription());
-        assertTrue(unique0.getTable().getIsVersioned());
-        assertNotNull(unique0.getColumns());
-        assertEquals(1, unique0.getColumns().size());
-        assertNull(unique0.getColumns().get(0).getId());
-        assertNull(unique0.getColumns().get(0).getTableId());
-        assertEquals("date", unique0.getColumns().get(0).getName());
-        assertEquals("date", unique0.getColumns().get(0).getInternalName());
-        final List<String> checks = new LinkedList<>(constraints.getChecks());
-        assertEquals("`mintemp` > 0", checks.get(0));
-        final List<ForeignKeyDto> foreignKeys = constraints.getForeignKeys();
-        assertEquals(1, foreignKeys.size());
-        final ForeignKeyDto fk0 = foreignKeys.get(0);
-        assertNotNull(fk0.getName());
-        assertNotNull(fk0.getReferences());
-        final ForeignKeyReferenceDto fk0ref0 = fk0.getReferences().get(0);
-        assertNull(fk0ref0.getId());
-        assertNotNull(fk0ref0.getColumn());
-        assertNotNull(fk0ref0.getReferencedColumn());
-        assertNotNull(fk0ref0.getForeignKey());
-        assertEquals(DATABASE_1_ID, fk0ref0.getColumn().getDatabaseId());
-        assertNull(fk0ref0.getColumn().getId());
-        assertNull(fk0ref0.getColumn().getTableId());
-        assertEquals("location", fk0ref0.getColumn().getName());
-        assertEquals("location", fk0ref0.getColumn().getInternalName());
-        assertEquals(DATABASE_1_ID, fk0ref0.getReferencedColumn().getDatabaseId());
-        assertNull(fk0ref0.getReferencedColumn().getId());
-        assertNull(fk0ref0.getReferencedColumn().getTableId());
-        assertEquals("location", fk0ref0.getReferencedColumn().getName());
-        assertEquals("location", fk0ref0.getReferencedColumn().getInternalName());
-        assertNotNull(fk0.getOnUpdate());
-        assertEquals(ReferenceTypeDto.RESTRICT, fk0.getOnUpdate());
-        assertNotNull(fk0.getOnDelete());
-        assertEquals(ReferenceTypeDto.SET_NULL, fk0.getOnDelete());
-        final TableBriefDto fk0table = fk0.getTable();
-        assertNull(fk0table.getId());
-        assertEquals(DATABASE_1_ID, fk0table.getDatabaseId());
-        assertEquals(TABLE_1_INTERNAL_NAME, fk0table.getName());
-        assertEquals(TABLE_1_INTERNAL_NAME, fk0table.getInternalName());
-        assertNotNull(fk0.getOnDelete());
-        assertNotNull(fk0.getOnUpdate());
-        assertNotNull(fk0.getReferencedTable());
-        assertEquals(TABLE_2_INTERNALNAME, fk0.getReferencedTable().getName());
-        assertEquals(TABLE_2_INTERNALNAME, fk0.getReferencedTable().getInternalName());
-    }
-
-    @Test
-    public void inspectTable_multipleForeignKeyReferences_succeeds() throws TableNotFoundException, SQLException {
-
-        /* test */
-        final TableDto response = schemaService.inspectTable(DATABASE_1_PRIVILEGED_DTO, "complex_foreign_keys");
-        final ConstraintsDto constraints = response.getConstraints();
-        final List<ForeignKeyDto> foreignKeys = constraints.getForeignKeys();
-        assertEquals(1, foreignKeys.size());
-        final ForeignKeyDto fk0 = foreignKeys.get(0);
-        assertNotNull(fk0.getName());
-        assertNotNull(fk0.getReferences());
-        final ForeignKeyReferenceDto fk0ref0 = fk0.getReferences().get(0);
-        assertNull(fk0ref0.getId());
-        assertNotNull(fk0ref0.getColumn());
-        assertNotNull(fk0ref0.getReferencedColumn());
-        assertNotNull(fk0ref0.getForeignKey());
-        assertEquals(DATABASE_1_ID, fk0ref0.getColumn().getDatabaseId());
-        assertNull(fk0ref0.getColumn().getId());
-        assertNull(fk0ref0.getColumn().getTableId());
-        assertEquals("weather_id", fk0ref0.getColumn().getName());
-        assertEquals("weather_id", fk0ref0.getColumn().getInternalName());
-        assertEquals(DATABASE_1_ID, fk0ref0.getReferencedColumn().getDatabaseId());
-        assertNull(fk0ref0.getReferencedColumn().getId());
-        assertNull(fk0ref0.getReferencedColumn().getTableId());
-        assertEquals("id", fk0ref0.getReferencedColumn().getName());
-        assertEquals("id", fk0ref0.getReferencedColumn().getInternalName());
-        final ForeignKeyReferenceDto fk0ref1 = fk0.getReferences().get(1);
-        assertNull(fk0ref1.getId());
-        assertNotNull(fk0ref1.getColumn());
-        assertNotNull(fk0ref1.getReferencedColumn());
-        assertNotNull(fk0ref1.getForeignKey());
-        assertEquals(DATABASE_1_ID, fk0ref1.getColumn().getDatabaseId());
-        assertNull(fk0ref1.getColumn().getId());
-        assertNull(fk0ref1.getColumn().getTableId());
-        assertEquals("other_id", fk0ref1.getColumn().getName());
-        assertEquals("other_id", fk0ref1.getColumn().getInternalName());
-        assertEquals(DATABASE_1_ID, fk0ref1.getReferencedColumn().getDatabaseId());
-        assertNull(fk0ref1.getReferencedColumn().getId());
-        assertNull(fk0ref1.getReferencedColumn().getTableId());
-        assertEquals("other_id", fk0ref1.getReferencedColumn().getName());
-        assertEquals("other_id", fk0ref1.getReferencedColumn().getInternalName());
-        final TableBriefDto fk0refT0 = fk0.getTable();
-        assertNull(fk0refT0.getId());
-        assertEquals(DATABASE_1_ID, fk0refT0.getDatabaseId());
-        assertEquals("complex_foreign_keys", fk0refT0.getName());
-        assertEquals("complex_foreign_keys", fk0refT0.getInternalName());
-        assertNotNull(fk0.getReferencedTable());
-        assertEquals("complex_primary_key", fk0.getReferencedTable().getName());
-        assertEquals("complex_primary_key", fk0.getReferencedTable().getInternalName());
-        assertNotNull(fk0.getOnDelete());
-        assertNotNull(fk0.getOnUpdate());
-    }
-
-    @Test
-    public void inspectTable_multiplePrimaryKey_succeeds() throws TableNotFoundException, SQLException {
-
-        /* test */
-        final TableDto response = schemaService.inspectTable(DATABASE_1_PRIVILEGED_DTO, "complex_primary_key");
-        final ConstraintsDto constraints = response.getConstraints();
-        final List<PrimaryKeyDto> primaryKey = new LinkedList<>(constraints.getPrimaryKey());
-        assertEquals(2, primaryKey.size());
-        final PrimaryKeyDto pk0 = primaryKey.get(0);
-        assertNull(pk0.getId());
-        assertNotNull(pk0.getTable());
-        assertNull(pk0.getTable().getId());
-        assertEquals("complex_primary_key", pk0.getTable().getName());
-        assertEquals("complex_primary_key", pk0.getTable().getInternalName());
-        assertNotNull(pk0.getColumn());
-        assertNull(pk0.getColumn().getId());
-        assertNull(pk0.getColumn().getTableId());
-        assertEquals(DATABASE_1_ID, pk0.getColumn().getDatabaseId());
-        assertNull(pk0.getColumn().getAlias());
-        assertEquals("id", pk0.getColumn().getName());
-        assertEquals("id", pk0.getColumn().getInternalName());
-        assertEquals(ColumnTypeDto.BIGINT, pk0.getColumn().getColumnType());
-        final PrimaryKeyDto pk1 = primaryKey.get(1);
-        assertNull(pk1.getId());
-        assertNotNull(pk1.getTable());
-        assertNull(pk1.getTable().getId());
-        assertEquals("complex_primary_key", pk1.getTable().getName());
-        assertEquals("complex_primary_key", pk1.getTable().getInternalName());
-        assertNotNull(pk1.getColumn());
-        assertNull(pk1.getColumn().getId());
-        assertNull(pk1.getColumn().getTableId());
-        assertEquals(DATABASE_1_ID, pk1.getColumn().getDatabaseId());
-        assertNull(pk1.getColumn().getAlias());
-        assertEquals("other_id", pk1.getColumn().getName());
-        assertEquals("other_id", pk1.getColumn().getInternalName());
-        assertEquals(ColumnTypeDto.BIGINT, pk1.getColumn().getColumnType());
-    }
-
-    @Test
-    public void inspectTable_exoticBoolean_succeeds() throws TableNotFoundException, SQLException {
-
-        /* test */
-        final TableDto response = schemaService.inspectTable(DATABASE_1_PRIVILEGED_DTO, "exotic_boolean");
-        final ConstraintsDto constraints = response.getConstraints();
-        final List<PrimaryKeyDto> primaryKey = new LinkedList<>(constraints.getPrimaryKey());
-        assertEquals(1, primaryKey.size());
-        final PrimaryKeyDto pk0 = primaryKey.get(0);
-        assertNull(pk0.getId());
-        assertNotNull(pk0.getTable());
-        assertNull(pk0.getTable().getId());
-        assertEquals("exotic_boolean", pk0.getTable().getName());
-        assertEquals("exotic_boolean", pk0.getTable().getInternalName());
-        assertNotNull(pk0.getColumn());
-        assertNull(pk0.getColumn().getId());
-        assertNull(pk0.getColumn().getTableId());
-        assertEquals(DATABASE_1_ID, pk0.getColumn().getDatabaseId());
-        assertNull(pk0.getColumn().getAlias());
-        assertEquals("bool_default", pk0.getColumn().getName());
-        assertEquals("bool_default", pk0.getColumn().getInternalName());
-        assertEquals(ColumnTypeDto.BOOL, pk0.getColumn().getColumnType());
-        final List<ColumnDto> columns = response.getColumns();
-        assertEquals(3, columns.size());
-        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "bool_default", "bool_default", ColumnTypeDto.BOOL, null, 0L, false, null);
-        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "bool_tinyint", "bool_tinyint", ColumnTypeDto.BOOL, null, 0L, false, null);
-        assertColumn(columns.get(2), null, null, DATABASE_1_ID, "bool_tinyint_unsigned", "bool_tinyint_unsigned", ColumnTypeDto.BOOL, null, 0L, false, null);
-    }
-
-    @Test
-    public void inspectView_succeeds() throws SQLException, ViewNotFoundException {
-
-        /* test */
-        final ViewDto response = schemaService.inspectView(DATABASE_1_PRIVILEGED_DTO, "not_in_metadata_db2");
-        assertEquals("not_in_metadata_db2", response.getInternalName());
-        assertEquals("not_in_metadata_db2", response.getName());
-        assertEquals(DATABASE_1_ID, response.getVdbid());
-        assertEquals(DATABASE_1_OWNER, response.getOwner().getId());
-        assertFalse(response.getIsInitialView());
-        assertEquals(DATABASE_1_PUBLIC, response.getIsPublic());
-        assertTrue(response.getQuery().length() >= 69);
-        assertNotNull(response.getQueryHash());
-        assertEquals(4, response.getColumns().size());
-        final ViewColumnDto column0 = response.getColumns().get(0);
-        assertNotNull(column0.getName());
-        assertEquals("date", column0.getInternalName());
-        assertEquals(DATABASE_1_ID, column0.getDatabaseId());
-        final ViewColumnDto column1 = response.getColumns().get(1);
-        assertNotNull(column1.getName());
-        assertEquals("location", column1.getInternalName());
-        assertEquals(DATABASE_1_ID, column1.getDatabaseId());
-        final ViewColumnDto column2 = response.getColumns().get(2);
-        assertNotNull(column2.getName());
-        assertEquals("MinTemp", column2.getInternalName());
-        assertEquals(DATABASE_1_ID, column2.getDatabaseId());
-        final ViewColumnDto column3 = response.getColumns().get(3);
-        assertNotNull(column3.getName());
-        assertEquals("Rainfall", column3.getInternalName());
-        assertEquals(DATABASE_1_ID, column3.getDatabaseId());
-    }
-
-    protected static void assertViewColumn(ViewColumnDto column, ViewColumnDto other) {
-        assertNotNull(column);
-        assertNotNull(other);
-        assertEquals(column.getId(), other.getId());
-        assertEquals(column.getDatabaseId(), other.getDatabaseId());
-        assertEquals(column.getName(), other.getName());
-        assertEquals(column.getInternalName(), other.getInternalName());
-        assertEquals(column.getColumnType(), other.getColumnType());
-        assertEquals(column.getSize(), other.getSize());
-        assertEquals(column.getD(), other.getD());
-        assertEquals(column.getIsNullAllowed(), other.getIsNullAllowed());
-        assertEquals(column.getDescription(), other.getDescription());
-    }
-
-    protected static void assertColumn(ColumnDto column, Long id, Long tableId, Long databaseId, String name,
-                                       String internalName, ColumnTypeDto type, Long size, Long d, Boolean nullAllowed,
-                                       String description) {
-        log.trace("assert column: {}", internalName);
-        assertNotNull(column);
-        assertEquals(id, column.getId());
-        assertEquals(tableId, column.getTableId());
-        assertEquals(databaseId, column.getDatabaseId());
-        assertEquals(name, column.getName());
-        assertEquals(internalName, column.getInternalName());
-        assertEquals(type, column.getColumnType());
-        assertEquals(size, column.getSize());
-        assertEquals(d, column.getD());
-        assertEquals(nullAllowed, column.getIsNullAllowed());
-        assertEquals(description, column.getDescription());
-    }
-
-}
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/SubsetServiceIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/SubsetServiceIntegrationTest.java
index 0eab9c6ff3e012950dd011f472ca65e67c4912e9..886d492cd7bc873131215d9fadc0c3eb8484c94d 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/SubsetServiceIntegrationTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/SubsetServiceIntegrationTest.java
@@ -21,7 +21,6 @@ import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.sql.SQLException;
 import java.util.List;
-import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.when;
@@ -45,8 +44,8 @@ public class SubsetServiceIntegrationTest extends AbstractUnitTest {
     public void beforeEach() throws SQLException {
         genesis();
         /* metadata database */
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
     }
 
     @Test
@@ -108,7 +107,7 @@ public class SubsetServiceIntegrationTest extends AbstractUnitTest {
 
         /* test */
         persist_generic(QUERY_2_ID, List.of(IDENTIFIER_5_BRIEF_DTO), true);
-        final QueryDto response = queryService.findById(DATABASE_1_PRIVILEGED_DTO, QUERY_2_ID);
+        final QueryDto response = queryService.findById(DATABASE_1_DTO, QUERY_2_ID);
         assertEquals(2L, response.getId());
         assertTrue(response.getIsPersisted());
     }
@@ -124,30 +123,11 @@ public class SubsetServiceIntegrationTest extends AbstractUnitTest {
 
         /* test */
         persist_generic(QUERY_1_ID, List.of(IDENTIFIER_2_BRIEF_DTO), false);
-        final QueryDto response = queryService.findById(DATABASE_1_PRIVILEGED_DTO, QUERY_1_ID);
+        final QueryDto response = queryService.findById(DATABASE_1_DTO, QUERY_1_ID);
         assertEquals(1L, response.getId());
         assertFalse(response.getIsPersisted());
     }
 
-    @Test
-    public void createQueryStore_succeeds() throws SQLException, QueryStoreCreateException, InterruptedException {
-
-        /* mock */
-        MariaDbConfig.dropQueryStore(DATABASE_1_PRIVILEGED_DTO);
-
-        /* test */
-        createQueryStore_generic(DATABASE_1_INTERNALNAME);
-    }
-
-    @Test
-    public void createQueryStore_fails() {
-
-        /* test */
-        assertThrows(QueryStoreCreateException.class, () -> {
-            createQueryStore_generic(DATABASE_1_INTERNALNAME);
-        });
-    }
-
     protected void findById_generic(Long queryId) throws RemoteUnavailableException, SQLException,
             UserNotFoundException, QueryNotFoundException, MetadataServiceException, DatabaseNotFoundException,
             InterruptedException {
@@ -160,10 +140,10 @@ public class SubsetServiceIntegrationTest extends AbstractUnitTest {
                 .thenReturn(List.of(IDENTIFIER_2_BRIEF_DTO));
         when(metadataServiceGateway.getUserById(USER_1_ID))
                 .thenReturn(USER_1_DTO);
-        MariaDbConfig.insertQueryStore(DATABASE_1_PRIVILEGED_DTO, QUERY_1_DTO, USER_1_ID);
+        MariaDbConfig.insertQueryStore(DATABASE_1_DTO, QUERY_1_DTO, USER_1_ID);
 
         /* test */
-        final QueryDto response = queryService.findById(DATABASE_1_PRIVILEGED_DTO, queryId);
+        final QueryDto response = queryService.findById(DATABASE_1_DTO, queryId);
         assertEquals(QUERY_1_ID, response.getId());
     }
 
@@ -175,13 +155,13 @@ public class SubsetServiceIntegrationTest extends AbstractUnitTest {
         Thread.sleep(1000) /* wait for test container some more */;
 
         /* mock */
-        MariaDbConfig.insertQueryStore(DATABASE_1_PRIVILEGED_DTO, QUERY_1_DTO, USER_1_ID);
-        MariaDbConfig.insertQueryStore(DATABASE_1_PRIVILEGED_DTO, QUERY_2_DTO, USER_1_ID);
+        MariaDbConfig.insertQueryStore(DATABASE_1_DTO, QUERY_1_DTO, USER_1_ID);
+        MariaDbConfig.insertQueryStore(DATABASE_1_DTO, QUERY_2_DTO, USER_1_ID);
         when(metadataServiceGateway.getIdentifiers(DATABASE_1_ID, null))
                 .thenReturn(List.of(IDENTIFIER_2_BRIEF_DTO, IDENTIFIER_5_BRIEF_DTO));
 
         /* test */
-        return queryService.findAll(DATABASE_1_PRIVILEGED_DTO, filterPersisted);
+        return queryService.findAll(DATABASE_1_DTO, filterPersisted);
     }
 
     protected void persist_generic(Long queryId, List<IdentifierBriefDto> identifiers, Boolean persist)
@@ -194,23 +174,11 @@ public class SubsetServiceIntegrationTest extends AbstractUnitTest {
         /* mock */
         when(metadataServiceGateway.getIdentifiers(DATABASE_1_ID, queryId))
                 .thenReturn(identifiers);
-        MariaDbConfig.insertQueryStore(DATABASE_1_PRIVILEGED_DTO, QUERY_1_DTO, USER_1_ID);
-        MariaDbConfig.insertQueryStore(DATABASE_1_PRIVILEGED_DTO, QUERY_2_DTO, USER_1_ID);
-
-        /* test */
-        queryService.persist(DATABASE_1_PRIVILEGED_DTO, queryId, persist);
-    }
-
-    protected void createQueryStore_generic(String databaseName) throws SQLException, QueryStoreCreateException,
-            InterruptedException {
-
-        /* pre-condition */
-        Thread.sleep(1000) /* wait for test container some more */;
+        MariaDbConfig.insertQueryStore(DATABASE_1_DTO, QUERY_1_DTO, USER_1_ID);
+        MariaDbConfig.insertQueryStore(DATABASE_1_DTO, QUERY_2_DTO, USER_1_ID);
 
         /* test */
-        queryService.createQueryStore(CONTAINER_1_PRIVILEGED_DTO, databaseName);
-        final List<Map<String, Object>> response = MariaDbConfig.listQueryStore(DATABASE_1_PRIVILEGED_DTO);
-        assertEquals(0, response.size());
+        queryService.persist(DATABASE_1_DTO, queryId, persist);
     }
 
 }
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/TableServiceIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/TableServiceIntegrationTest.java
index 383c44770f251876836190f7729834c6d8ba84b5..f8687d8e0d3f4c3aa9c6197fb523163b1262a276 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/TableServiceIntegrationTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/TableServiceIntegrationTest.java
@@ -2,18 +2,7 @@ package at.tuwien.service;
 
 import at.tuwien.api.database.query.ImportDto;
 import at.tuwien.api.database.table.*;
-import at.tuwien.api.database.table.columns.ColumnCreateDto;
-import at.tuwien.api.database.table.columns.ColumnDto;
 import at.tuwien.api.database.table.columns.ColumnStatisticDto;
-import at.tuwien.api.database.table.columns.ColumnTypeDto;
-import at.tuwien.api.database.table.constraints.ConstraintsCreateDto;
-import at.tuwien.api.database.table.constraints.ConstraintsDto;
-import at.tuwien.api.database.table.constraints.foreign.ForeignKeyCreateDto;
-import at.tuwien.api.database.table.constraints.foreign.ForeignKeyDto;
-import at.tuwien.api.database.table.constraints.foreign.ForeignKeyReferenceDto;
-import at.tuwien.api.database.table.constraints.primary.PrimaryKeyDto;
-import at.tuwien.api.database.table.constraints.unique.UniqueDto;
-import at.tuwien.api.database.table.internal.TableCreateDto;
 import at.tuwien.config.MariaDbConfig;
 import at.tuwien.config.MariaDbContainerConfig;
 import at.tuwien.config.S3Config;
@@ -22,7 +11,10 @@ import at.tuwien.gateway.MetadataServiceGateway;
 import at.tuwien.test.AbstractUnitTest;
 import com.google.common.io.Files;
 import lombok.extern.log4j.Log4j2;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -44,9 +36,11 @@ import java.io.IOException;
 import java.math.BigDecimal;
 import java.sql.SQLException;
 import java.time.Instant;
-import java.util.*;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
-import static at.tuwien.service.SchemaServiceIntegrationTest.assertColumn;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.when;
 
@@ -88,11 +82,11 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
     public void beforeEach() throws SQLException {
         genesis();
         /* metadata database */
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_2_INTERNALNAME);
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_3_INTERNALNAME);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_3_DTO);
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_2_INTERNALNAME);
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_3_INTERNALNAME);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_3_DTO);
         /* s3 */
         if (s3Client.listBuckets().buckets().stream().noneMatch(b -> b.name().equals(s3Config.getS3Bucket()))) {
             s3Client.createBucket(CreateBucketRequest.builder()
@@ -124,13 +118,13 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        tableService.updateTuple(TABLE_1_PRIVILEGED_DTO, request);
-        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_PRIVILEGED_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 1", Set.of("id", "date", "location", "mintemp", "rainfall"));
+        tableService.updateTuple(TABLE_1_DTO, request);
+        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 1", Set.of("id", "date", "location", "mintemp", "rainfall"));
         assertEquals("1", result.get(0).get("id"));
         assertEquals("2023-10-03", result.get(0).get("date")); // <<<
         assertEquals("Vienna", result.get(0).get("location")); // <<<
@@ -158,13 +152,13 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        tableService.updateTuple(TABLE_1_PRIVILEGED_DTO, request);
-        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_PRIVILEGED_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 4", Set.of("id", "date", "location", "mintemp", "rainfall"));
+        tableService.updateTuple(TABLE_1_DTO, request);
+        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 4", Set.of("id", "date", "location", "mintemp", "rainfall"));
         assertEquals("4", result.get(0).get("id"));
         assertEquals("2023-10-03", result.get(0).get("date")); // <<<
         assertEquals("Vienna", result.get(0).get("location")); // <<<
@@ -191,13 +185,13 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        tableService.updateTuple(TABLE_1_PRIVILEGED_DTO, request);
-        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_PRIVILEGED_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 1", Set.of("id", "date", "location", "mintemp", "rainfall"));
+        tableService.updateTuple(TABLE_1_DTO, request);
+        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 1", Set.of("id", "date", "location", "mintemp", "rainfall"));
         assertEquals("1", result.get(0).get("id"));
         assertEquals("2023-10-03", result.get(0).get("date")); // <<<
         assertEquals("Vienna", result.get(0).get("location")); // <<<
@@ -224,13 +218,13 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        tableService.updateTuple(TABLE_1_PRIVILEGED_DTO, request);
-        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_PRIVILEGED_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 1", Set.of("id", "date", "location", "mintemp", "rainfall"));
+        tableService.updateTuple(TABLE_1_DTO, request);
+        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 1", Set.of("id", "date", "location", "mintemp", "rainfall"));
         assertEquals("1", result.get(0).get("id"));
         assertEquals("2023-10-03", result.get(0).get("date")); // <<<
         assertEquals("Vienna", result.get(0).get("location")); // <<<
@@ -255,13 +249,13 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        tableService.createTuple(TABLE_1_PRIVILEGED_DTO, request);
-        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_PRIVILEGED_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 4", Set.of("id", "date", "location", "mintemp", "rainfall"));
+        tableService.createTuple(TABLE_1_DTO, request);
+        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 4", Set.of("id", "date", "location", "mintemp", "rainfall"));
         assertEquals("4", result.get(0).get("id"));
         assertEquals("2023-10-03", result.get(0).get("date"));
         assertEquals("Vienna", result.get(0).get("location"));
@@ -283,17 +277,17 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_3_ID, TABLE_8_ID))
-                .thenReturn(TABLE_8_PRIVILEGED_DTO);
+                .thenReturn(TABLE_8_DTO);
         s3Client.putObject(PutObjectRequest.builder()
                 .key("s3key")
                 .bucket(s3Config.getS3Bucket())
                 .build(), RequestBody.fromFile(new File("src/test/resources/csv/keyboard.csv")));
 
         /* test */
-        tableService.createTuple(TABLE_8_PRIVILEGED_DTO, request);
-        final List<Map<String, byte[]>> result = MariaDbConfig.selectQueryByteArr(DATABASE_3_PRIVILEGED_DTO, "SELECT raw FROM mfcc WHERE raw IS NOT NULL", Set.of("raw"));
+        tableService.createTuple(TABLE_8_DTO, request);
+        final List<Map<String, byte[]>> result = MariaDbConfig.selectQueryByteArr(DATABASE_3_DTO, "SELECT raw FROM mfcc WHERE raw IS NOT NULL", Set.of("raw"));
         assertNotNull(result.get(0).get("raw"));
         assertArrayEquals(Files.toByteArray(new File("src/test/resources/csv/keyboard.csv")), result.get(0).get("raw"));
     }
@@ -315,13 +309,13 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        tableService.createTuple(TABLE_1_PRIVILEGED_DTO, request);
-        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_PRIVILEGED_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 4", Set.of("id", "date", "location", "mintemp", "rainfall"));
+        tableService.createTuple(TABLE_1_DTO, request);
+        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_DTO, "SELECT id, `date`, location, mintemp, rainfall FROM weather_aus WHERE id = 4", Set.of("id", "date", "location", "mintemp", "rainfall"));
         assertEquals("4", result.get(0).get("id"));
         assertEquals("2023-10-03", result.get(0).get("date"));
         assertEquals("Vienna", result.get(0).get("location"));
@@ -341,13 +335,13 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        tableService.deleteTuple(TABLE_1_PRIVILEGED_DTO, request);
-        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_PRIVILEGED_DTO, "SELECT id FROM weather_aus WHERE id = 1", Set.of("id"));
+        tableService.deleteTuple(TABLE_1_DTO, request);
+        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_DTO, "SELECT id FROM weather_aus WHERE id = 1", Set.of("id"));
         assertEquals(0, result.size());
     }
 
@@ -365,173 +359,22 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* mock */
         when(metadataServiceGateway.getContainerById(CONTAINER_1_ID))
-                .thenReturn(CONTAINER_1_PRIVILEGED_DTO);
+                .thenReturn(CONTAINER_1_DTO);
         when(metadataServiceGateway.getTableById(DATABASE_1_ID, TABLE_1_ID))
-                .thenReturn(TABLE_1_PRIVILEGED_DTO);
+                .thenReturn(TABLE_1_DTO);
 
         /* test */
-        tableService.deleteTuple(TABLE_1_PRIVILEGED_DTO, request);
-        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_PRIVILEGED_DTO, "SELECT id FROM weather_aus WHERE id = 1", Set.of("id"));
+        tableService.deleteTuple(TABLE_1_DTO, request);
+        final List<Map<String, String>> result = MariaDbConfig.selectQuery(DATABASE_1_DTO, "SELECT id FROM weather_aus WHERE id = 1", Set.of("id"));
         assertEquals(0, result.size());
     }
 
-    @Test
-    public void getSchemas_succeeds() throws TableNotFoundException, SQLException, DatabaseMalformedException {
-
-        /* test */
-        final List<TableDto> response = tableService.getSchemas(DATABASE_1_PRIVILEGED_DTO);
-        assertEquals(4, response.size());
-        final TableDto table0 = response.get(0);
-        Assertions.assertEquals("complex_foreign_keys", table0.getInternalName());
-        Assertions.assertEquals("complex_foreign_keys", table0.getName());
-        Assertions.assertEquals(DATABASE_1_ID, table0.getTdbid());
-        assertTrue(table0.getIsVersioned());
-        Assertions.assertEquals(DATABASE_1_PUBLIC, table0.getIsPublic());
-        final List<ColumnDto> columns0 = table0.getColumns();
-        assertNotNull(columns0);
-        Assertions.assertEquals(3, columns0.size());
-        assertColumn(columns0.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
-        assertColumn(columns0.get(1), null, null, DATABASE_1_ID, "weather_id", "weather_id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
-        assertColumn(columns0.get(2), null, null, DATABASE_1_ID, "other_id", "other_id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
-        final ConstraintsDto constraints0 = table0.getConstraints();
-        assertNotNull(constraints0);
-        assertEquals(1, constraints0.getPrimaryKey().size());
-        final PrimaryKeyDto pk0 = new LinkedList<>(constraints0.getPrimaryKey()).get(0);
-        assertNull(pk0.getId());
-        assertNull(pk0.getColumn().getId());
-        assertEquals("id", pk0.getColumn().getName());
-        assertEquals("id", pk0.getColumn().getInternalName());
-        assertEquals(1, constraints0.getForeignKeys().size());
-        final ForeignKeyDto fk0 = constraints0.getForeignKeys().get(0);
-        assertNotNull(fk0.getName());
-        assertNull(fk0.getTable().getId());
-        assertEquals("complex_foreign_keys", fk0.getTable().getName());
-        assertEquals("complex_foreign_keys", fk0.getTable().getInternalName());
-        assertNull(fk0.getReferencedTable().getId());
-        assertEquals("complex_primary_key", fk0.getReferencedTable().getName());
-        assertEquals("complex_primary_key", fk0.getReferencedTable().getInternalName());
-        assertEquals(2, fk0.getReferences().size());
-        final ForeignKeyReferenceDto fk0r0 = fk0.getReferences().get(0);
-        assertEquals("weather_id", fk0r0.getColumn().getName());
-        assertEquals("weather_id", fk0r0.getColumn().getInternalName());
-        assertNotNull(fk0r0.getColumn().getName());
-        assertNotNull(fk0r0.getForeignKey());
-        assertEquals("id", fk0r0.getReferencedColumn().getName());
-        assertEquals("id", fk0r0.getReferencedColumn().getInternalName());
-        final ForeignKeyReferenceDto fk0r1 = fk0.getReferences().get(1);
-        assertEquals("other_id", fk0r1.getColumn().getName());
-        assertEquals("other_id", fk0r1.getColumn().getInternalName());
-        assertNotNull(fk0r1.getColumn().getName());
-        assertNotNull(fk0r1.getForeignKey());
-        assertEquals("other_id", fk0r1.getReferencedColumn().getName());
-        assertEquals("other_id", fk0r1.getReferencedColumn().getInternalName());
-        assertEquals(0, constraints0.getChecks().size());
-        assertEquals(0, constraints0.getUniques().size());
-        /* table 1 */
-        final TableDto table1 = response.get(1);
-        Assertions.assertEquals("complex_primary_key", table1.getInternalName());
-        Assertions.assertEquals("complex_primary_key", table1.getName());
-        Assertions.assertEquals(DATABASE_1_ID, table1.getTdbid());
-        assertTrue(table1.getIsVersioned());
-        Assertions.assertEquals(DATABASE_1_PUBLIC, table1.getIsPublic());
-        final List<ColumnDto> columns1 = table1.getColumns();
-        assertNotNull(columns1);
-        Assertions.assertEquals(2, columns1.size());
-        assertColumn(columns1.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
-        assertColumn(columns1.get(1), null, null, DATABASE_1_ID, "other_id", "other_id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
-        final ConstraintsDto constraints1 = table1.getConstraints();
-        assertNotNull(constraints1);
-        assertEquals(2, constraints1.getPrimaryKey().size());
-        final PrimaryKeyDto pk10 = new LinkedList<>(constraints1.getPrimaryKey()).get(0);
-        assertNull(pk10.getId());
-        assertNull(pk10.getColumn().getId());
-        assertEquals("id", pk10.getColumn().getName());
-        assertEquals("id", pk10.getColumn().getInternalName());
-        final PrimaryKeyDto pk11 = new LinkedList<>(constraints1.getPrimaryKey()).get(1);
-        assertNull(pk11.getId());
-        assertNull(pk11.getColumn().getId());
-        assertEquals("other_id", pk11.getColumn().getName());
-        assertEquals("other_id", pk11.getColumn().getInternalName());
-        assertEquals(0, constraints1.getForeignKeys().size());
-        assertEquals(0, constraints1.getChecks().size());
-        assertEquals(0, constraints1.getUniques().size());
-        /* table 2 */
-        final TableDto table2 = response.get(2);
-        Assertions.assertEquals("exotic_boolean", table2.getInternalName());
-        Assertions.assertEquals("exotic_boolean", table2.getName());
-        Assertions.assertEquals(DATABASE_1_ID, table2.getTdbid());
-        assertTrue(table2.getIsVersioned());
-        Assertions.assertEquals(DATABASE_1_PUBLIC, table2.getIsPublic());
-        final List<ColumnDto> columns2 = table2.getColumns();
-        assertNotNull(columns2);
-        Assertions.assertEquals(3, columns2.size());
-        assertColumn(columns2.get(0), null, null, DATABASE_1_ID, "bool_default", "bool_default", ColumnTypeDto.BOOL, null, 0L, false, null);
-        assertColumn(columns2.get(1), null, null, DATABASE_1_ID, "bool_tinyint", "bool_tinyint", ColumnTypeDto.BOOL, null, 0L, false, null);
-        assertColumn(columns2.get(2), null, null, DATABASE_1_ID, "bool_tinyint_unsigned", "bool_tinyint_unsigned", ColumnTypeDto.BOOL, null, 0L, false, null);
-        final ConstraintsDto constraints2 = table2.getConstraints();
-        assertNotNull(constraints2);
-        final Set<PrimaryKeyDto> primaryKey2 = constraints2.getPrimaryKey();
-        Assertions.assertEquals(1, primaryKey2.size());
-        final Set<String> checks2 = constraints2.getChecks();
-        Assertions.assertEquals(0, checks2.size());
-        final List<UniqueDto> uniques2 = constraints2.getUniques();
-        Assertions.assertEquals(0, uniques2.size());
-        /* table 3 */
-        final TableDto table3 = response.get(3);
-        Assertions.assertEquals("not_in_metadata_db", table3.getInternalName());
-        Assertions.assertEquals("not_in_metadata_db", table3.getName());
-        Assertions.assertEquals(DATABASE_1_ID, table3.getTdbid());
-        assertTrue(table3.getIsVersioned());
-        Assertions.assertEquals(DATABASE_1_PUBLIC, table3.getIsPublic());
-        final List<ColumnDto> columns3 = table3.getColumns();
-        assertNotNull(columns3);
-        Assertions.assertEquals(5, columns3.size());
-        assertColumn(columns3.get(0), null, null, DATABASE_1_ID, "id", "id", ColumnTypeDto.BIGINT, 19L, 0L, false, null);
-        assertColumn(columns3.get(1), null, null, DATABASE_1_ID, "given_name", "given_name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
-        assertColumn(columns3.get(2), null, null, DATABASE_1_ID, "middle_name", "middle_name", ColumnTypeDto.VARCHAR, 255L, null, true, null);
-        assertColumn(columns3.get(3), null, null, DATABASE_1_ID, "family_name", "family_name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
-        assertColumn(columns3.get(4), null, null, DATABASE_1_ID, "age", "age", ColumnTypeDto.INT, 10L, 0L, false, null);
-        final ConstraintsDto constraints3 = table3.getConstraints();
-        assertNotNull(constraints3);
-        final Set<PrimaryKeyDto> primaryKey3 = constraints3.getPrimaryKey();
-        Assertions.assertEquals(1, primaryKey3.size());
-        final Set<String> checks3 = constraints3.getChecks();
-        Assertions.assertEquals(1, checks3.size());
-        Assertions.assertEquals(Set.of("`age` > 0 and `age` < 120"), checks3);
-        final List<UniqueDto> uniques3 = constraints3.getUniques();
-        Assertions.assertEquals(1, uniques3.size());
-        Assertions.assertEquals(2, uniques3.get(0).getColumns().size());
-        Assertions.assertEquals("not_in_metadata_db", uniques3.get(0).getTable().getInternalName());
-        Assertions.assertEquals("given_name", uniques3.get(0).getColumns().get(0).getInternalName());
-        Assertions.assertEquals("family_name", uniques3.get(0).getColumns().get(1).getInternalName());
-    }
-
-    @Test
-    public void create_succeeds() throws TableNotFoundException, TableMalformedException, SQLException,
-            TableExistsException {
-
-        /* test */
-        final TableDto response = tableService.createTable(DATABASE_1_PRIVILEGED_DTO, TABLE_4_CREATE_INTERNAL_DTO);
-        assertEquals(TABLE_4_NAME, response.getName());
-        assertEquals(TABLE_4_INTERNALNAME, response.getInternalName());
-        final List<ColumnDto> columns = response.getColumns();
-        assertEquals(TABLE_4_COLUMNS.size(), columns.size());
-        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "timestamp", "timestamp", ColumnTypeDto.TIMESTAMP, null, null, false, null);
-        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "value", "value", ColumnTypeDto.DECIMAL, 10L, 10L, true, null);
-        final ConstraintsDto constraints = response.getConstraints();
-        assertNotNull(constraints);
-        final Set<PrimaryKeyDto> primaryKey = constraints.getPrimaryKey();
-        Assertions.assertEquals(1, primaryKey.size());
-        final Set<String> checks = constraints.getChecks();
-        Assertions.assertEquals(0, checks.size());
-    }
-
     @Test
     @Disabled("Not stable CI/CD")
     public void getStatistics_succeeds() throws TableMalformedException, SQLException, TableNotFoundException {
 
         /* test */
-        final TableStatisticDto response = tableService.getStatistics(TABLE_2_PRIVILEGED_DTO);
+        final TableStatisticDto response = tableService.getStatistics(DATABASE_1_DTO, TABLE_2_DTO);
         assertEquals(TABLE_2_COLUMNS.size(), response.getColumns().size());
         log.trace("response rows: {}", response.getRows());
         assertEquals(3L, response.getRows());
@@ -556,116 +399,22 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
         assertNotNull(column4.getStdDev());
     }
 
-    @Test
-    public void create_malformed_fails() {
-        final at.tuwien.api.database.table.internal.TableCreateDto request = TableCreateDto.builder()
-                .name("missing_foreign_key")
-                .columns(List.of())
-                .constraints(ConstraintsCreateDto.builder()
-                        .foreignKeys(List.of(ForeignKeyCreateDto.builder()
-                                .columns(List.of("i_do_not_exist"))
-                                .referencedTable("neither_do_i")
-                                .referencedColumns(List.of("behold"))
-                                .build()))
-                        .build())
-                .build();
-
-        /* test */
-        assertThrows(TableMalformedException.class, () -> {
-            tableService.createTable(DATABASE_1_PRIVILEGED_DTO, request);
-        });
-    }
-
-    @Test
-    public void create_compositePrimaryKey_fails() throws TableNotFoundException, TableMalformedException, SQLException,
-            TableExistsException {
-        final at.tuwien.api.database.table.internal.TableCreateDto request = TableCreateDto.builder()
-                .name("composite_primary_key")
-                .columns(List.of(ColumnCreateDto.builder()
-                                .name("name")
-                                .type(ColumnTypeDto.VARCHAR)
-                                .size(255L)
-                                .nullAllowed(false)
-                                .build(),
-                        ColumnCreateDto.builder()
-                                .name("lat")
-                                .type(ColumnTypeDto.DECIMAL)
-                                .size(10L)
-                                .d(10L)
-                                .nullAllowed(false)
-                                .build(),
-                        ColumnCreateDto.builder()
-                                .name("lng")
-                                .type(ColumnTypeDto.DECIMAL)
-                                .size(10L)
-                                .d(10L)
-                                .nullAllowed(false)
-                                .build()))
-                .constraints(ConstraintsCreateDto.builder()
-                        .primaryKey(Set.of("lat", "lng"))
-                        .foreignKeys(List.of())
-                        .checks(Set.of())
-                        .uniques(List.of())
-                        .build())
-                .build();
-
-        /* test */
-        final TableDto response = tableService.createTable(DATABASE_1_PRIVILEGED_DTO, request);
-        assertEquals("composite_primary_key", response.getName());
-        assertEquals("composite_primary_key", response.getInternalName());
-        final List<ColumnDto> columns = response.getColumns();
-        assertEquals(3, columns.size());
-        assertColumn(columns.get(0), null, null, DATABASE_1_ID, "name", "name", ColumnTypeDto.VARCHAR, 255L, null, false, null);
-        assertColumn(columns.get(1), null, null, DATABASE_1_ID, "lat", "lat", ColumnTypeDto.DECIMAL, 10L, 10L, false, null);
-        assertColumn(columns.get(2), null, null, DATABASE_1_ID, "lng", "lng", ColumnTypeDto.DECIMAL, 10L, 10L, false, null);
-        final ConstraintsDto constraints = response.getConstraints();
-        assertNotNull(constraints);
-        final Set<String> checks = constraints.getChecks();
-        assertNotNull(checks);
-        assertEquals(0, checks.size());
-        final List<PrimaryKeyDto> primaryKeys = new LinkedList<>(constraints.getPrimaryKey());
-        assertNotNull(primaryKeys);
-        assertEquals(2, primaryKeys.size());
-        assertEquals("lat", primaryKeys.get(0).getColumn().getInternalName());
-        assertEquals("lng", primaryKeys.get(1).getColumn().getInternalName());
-        final List<ForeignKeyDto> foreignKeys = constraints.getForeignKeys();
-        assertNotNull(foreignKeys);
-        assertEquals(0, foreignKeys.size());
-        final List<UniqueDto> uniques = constraints.getUniques();
-        assertNotNull(uniques);
-        assertEquals(0, uniques.size());
-    }
-
-    @Test
-    public void create_needSequence_succeeds() throws TableNotFoundException, TableMalformedException, SQLException,
-            TableExistsException {
-
-        /* mock */
-        MariaDbConfig.dropTable(DATABASE_1_PRIVILEGED_DTO, TABLE_1_INTERNAL_NAME);
-
-        /* test */
-        final TableDto response = tableService.createTable(DATABASE_1_PRIVILEGED_DTO, TABLE_1_CREATE_INTERNAL_DTO);
-        assertEquals(TABLE_1_NAME, response.getName());
-        assertEquals(TABLE_1_INTERNAL_NAME, response.getInternalName());
-        assertEquals(TABLE_1_COLUMNS.size(), response.getColumns().size());
-    }
-
     @Test
     public void delete_succeeds() throws SQLException, QueryMalformedException {
 
         /* test */
-        tableService.delete(TABLE_1_PRIVILEGED_DTO);
+        tableService.delete(TABLE_1_DTO);
     }
 
     @Test
     public void delete_notFound_fails() throws SQLException {
 
         /* mock */
-        MariaDbConfig.createDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_2_INTERNALNAME);
+        MariaDbConfig.createDatabase(CONTAINER_1_DTO, DATABASE_2_INTERNALNAME);
 
         /* test */
         assertThrows(QueryMalformedException.class, () -> {
-            tableService.delete(TABLE_5_PRIVILEGED_DTO);
+            tableService.delete(TABLE_5_DTO);
         });
     }
 
@@ -673,7 +422,7 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
     public void getCount_succeeds() throws SQLException, QueryMalformedException {
 
         /* test */
-        final Long response = tableService.getCount(TABLE_1_PRIVILEGED_DTO, null);
+        final Long response = tableService.getCount(TABLE_1_DTO, null);
         assertEquals(3, response);
     }
 
@@ -681,7 +430,7 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
     public void getCount_timestamp_succeeds() throws SQLException, QueryMalformedException {
 
         /* test */
-        final Long response = tableService.getCount(TABLE_1_PRIVILEGED_DTO, Instant.ofEpochSecond(0));
+        final Long response = tableService.getCount(TABLE_1_DTO, Instant.ofEpochSecond(0));
         assertEquals(0, response);
     }
 
@@ -689,11 +438,11 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
     public void getCount_notFound_fails() throws SQLException {
 
         /* mock */
-        MariaDbConfig.createDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_2_INTERNALNAME);
+        MariaDbConfig.createDatabase(CONTAINER_1_DTO, DATABASE_2_INTERNALNAME);
 
         /* test */
         assertThrows(QueryMalformedException.class, () -> {
-            tableService.getCount(TABLE_5_PRIVILEGED_DTO, null);
+            tableService.getCount(TABLE_5_DTO, null);
         });
     }
 
@@ -701,7 +450,7 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
     public void history_succeeds() throws SQLException, TableNotFoundException {
 
         /* test */
-        final List<TableHistoryDto> response = tableService.history(TABLE_1_PRIVILEGED_DTO, 1000L);
+        final List<TableHistoryDto> response = tableService.history(TABLE_1_DTO, 1000L);
         assertEquals(1, response.size());
         final TableHistoryDto history0 = response.get(0);
         assertNotNull(history0.getTimestamp());
@@ -713,11 +462,11 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
     public void history_notFound_fails() throws SQLException {
 
         /* mock */
-        MariaDbConfig.createDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_2_INTERNALNAME);
+        MariaDbConfig.createDatabase(CONTAINER_1_DTO, DATABASE_2_INTERNALNAME);
 
         /* test */
         assertThrows(TableNotFoundException.class, () -> {
-            tableService.history(TABLE_5_PRIVILEGED_DTO, null);
+            tableService.history(TABLE_5_DTO, null);
         });
     }
 
@@ -739,7 +488,7 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
                 .build(), RequestBody.fromFile(new File("src/test/resources/csv/weather_aus.csv")));
 
         /* test */
-        tableService.importDataset(TABLE_1_PRIVILEGED_DTO, request);
+        tableService.importDataset(TABLE_1_DTO, request);
     }
 
     @Test
@@ -760,7 +509,7 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* test */
         assertThrows(TableMalformedException.class, () -> {
-            tableService.importDataset(TABLE_1_PRIVILEGED_DTO, request);
+            tableService.importDataset(TABLE_1_DTO, request);
         });
     }
 
@@ -782,7 +531,7 @@ public class TableServiceIntegrationTest extends AbstractUnitTest {
 
         /* test */
         assertThrows(MalformedException.class, () -> {
-            tableService.importDataset(TABLE_1_PRIVILEGED_DTO, request);
+            tableService.importDataset(TABLE_1_DTO, request);
         });
     }
 
diff --git a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/ViewServiceIntegrationTest.java b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/ViewServiceIntegrationTest.java
index b5555611c666f60f0af6e2d8a122dc11ec3264dd..658c099724ca493659917604c46153ae9362cd07 100644
--- a/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/ViewServiceIntegrationTest.java
+++ b/dbrepo-data-service/rest-service/src/test/java/at/tuwien/service/ViewServiceIntegrationTest.java
@@ -1,12 +1,8 @@
 package at.tuwien.service;
 
-import at.tuwien.api.database.ViewColumnDto;
-import at.tuwien.api.database.ViewDto;
 import at.tuwien.config.MariaDbConfig;
 import at.tuwien.config.MariaDbContainerConfig;
-import at.tuwien.exception.DatabaseMalformedException;
 import at.tuwien.exception.ViewMalformedException;
-import at.tuwien.exception.ViewNotFoundException;
 import at.tuwien.test.AbstractUnitTest;
 import lombok.extern.log4j.Log4j2;
 import org.junit.jupiter.api.BeforeEach;
@@ -20,9 +16,6 @@ import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.sql.SQLException;
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.*;
 
 @Log4j2
 @SpringBootTest
@@ -40,47 +33,15 @@ public class ViewServiceIntegrationTest extends AbstractUnitTest {
     public void beforeEach() throws SQLException {
         genesis();
         /* metadata database */
-        MariaDbConfig.dropDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_INTERNALNAME);
-        MariaDbConfig.createInitDatabase(CONTAINER_1_PRIVILEGED_DTO, DATABASE_1_DTO);
+        MariaDbConfig.dropDatabase(CONTAINER_1_DTO, DATABASE_1_INTERNALNAME);
+        MariaDbConfig.createInitDatabase(CONTAINER_1_DTO, DATABASE_1_DTO);
     }
 
     @Test
     public void delete_succeeds() throws SQLException, ViewMalformedException {
 
         /* test */
-        viewService.delete(DATABASE_1_PRIVILEGED_DTO, VIEW_1_INTERNAL_NAME);
-    }
-
-    @Test
-    public void create_succeeds() throws SQLException, ViewMalformedException {
-
-        /* test */
-        viewService.create(DATABASE_1_PRIVILEGED_DTO, VIEW_1_CREATE_DTO);
-    }
-
-    @Test
-    public void getSchemas_succeeds() throws SQLException, ViewNotFoundException, DatabaseMalformedException {
-
-        /* test */
-        final List<ViewDto> response = viewService.getSchemas(DATABASE_1_PRIVILEGED_DTO);
-        final ViewDto view0 = response.get(0);
-        assertEquals("not_in_metadata_db2", view0.getName());
-        assertEquals("not_in_metadata_db2", view0.getInternalName());
-        assertEquals(DATABASE_1_ID, view0.getVdbid());
-        assertEquals(DATABASE_1_OWNER, view0.getOwner().getId());
-        assertFalse(view0.getIsInitialView());
-        assertEquals(DATABASE_1_PUBLIC, view0.getIsPublic());
-        assertTrue(view0.getQuery().length() >= 69);
-        assertNotNull(view0.getQueryHash());
-        assertEquals(4, view0.getColumns().size());
-        final ViewColumnDto column0a = view0.getColumns().get(0);
-        assertEquals("date", column0a.getInternalName());
-        final ViewColumnDto column1a = view0.getColumns().get(1);
-        assertEquals("location", column1a.getInternalName());
-        final ViewColumnDto column2a = view0.getColumns().get(2);
-        assertEquals("MinTemp", column2a.getInternalName());
-        final ViewColumnDto column3a = view0.getColumns().get(3);
-        assertEquals("Rainfall", column3a.getInternalName());
+        viewService.delete(VIEW_1_DTO);
     }
 
 }
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/config/CacheConfig.java b/dbrepo-data-service/services/src/main/java/at/tuwien/config/CacheConfig.java
index 45654157d1a7564d6504e08bd6d6d5fa5d24b206..c798537b5b378822a82119b2ffcb7ec4c7bf1384 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/config/CacheConfig.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/config/CacheConfig.java
@@ -1,11 +1,11 @@
 package at.tuwien.config;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
+import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.database.DatabaseAccessDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.ViewDto;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.api.user.UserDto;
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import org.springframework.beans.factory.annotation.Value;
@@ -22,13 +22,13 @@ public class CacheConfig {
     private Long credentialCacheTimeout;
 
     @Bean
-    public Cache<UUID, PrivilegedUserDto> userCache() {
-        return new ExpiryCache<UUID, PrivilegedUserDto>().build();
+    public Cache<UUID, UserDto> userCache() {
+        return new ExpiryCache<UUID, UserDto>().build();
     }
 
     @Bean
-    public Cache<Long, PrivilegedViewDto> viewCache() {
-        return new ExpiryCache<Long, PrivilegedViewDto>().build();
+    public Cache<Long, ViewDto> viewCache() {
+        return new ExpiryCache<Long, ViewDto>().build();
     }
 
     @Bean
@@ -37,18 +37,18 @@ public class CacheConfig {
     }
 
     @Bean
-    public Cache<Long, PrivilegedTableDto> tableCache() {
-        return new ExpiryCache<Long, PrivilegedTableDto>().build();
+    public Cache<Long, TableDto> tableCache() {
+        return new ExpiryCache<Long, TableDto>().build();
     }
 
     @Bean
-    public Cache<Long, PrivilegedDatabaseDto> databaseCache() {
-        return new ExpiryCache<Long, PrivilegedDatabaseDto>().build();
+    public Cache<Long, DatabaseDto> databaseCache() {
+        return new ExpiryCache<Long, DatabaseDto>().build();
     }
 
     @Bean
-    public Cache<Long, PrivilegedContainerDto> containerCache() {
-        return new ExpiryCache<Long, PrivilegedContainerDto>().build();
+    public Cache<Long, ContainerDto> containerCache() {
+        return new ExpiryCache<Long, ContainerDto>().build();
     }
 
     class ExpiryCache<K, T> {
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/gateway/MetadataServiceGateway.java b/dbrepo-data-service/services/src/main/java/at/tuwien/gateway/MetadataServiceGateway.java
index e2851071dad176ca44a9f2d0952a0392101ad2eb..f7fe2f207512791b17144cea27cedcc5f7bfd2b9 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/gateway/MetadataServiceGateway.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/gateway/MetadataServiceGateway.java
@@ -1,13 +1,12 @@
 package at.tuwien.gateway;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
+import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.database.DatabaseAccessDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.ViewDto;
+import at.tuwien.api.database.table.TableDto;
 import at.tuwien.api.identifier.IdentifierBriefDto;
 import at.tuwien.api.user.UserDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
 import at.tuwien.exception.*;
 import jakarta.validation.constraints.NotNull;
 
@@ -20,12 +19,12 @@ public interface MetadataServiceGateway {
      * Get a container with given id from the metadata service.
      *
      * @param containerId The container id
-     * @return The container with privileged connection information, if successful.
+     * @return The container with  connection information, if successful.
      * @throws ContainerNotFoundException The table was not found in the metadata service.
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedContainerDto getContainerById(Long containerId) throws RemoteUnavailableException,
+    ContainerDto getContainerById(Long containerId) throws RemoteUnavailableException,
             ContainerNotFoundException, MetadataServiceException;
 
     /**
@@ -37,7 +36,7 @@ public interface MetadataServiceGateway {
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedDatabaseDto getDatabaseById(Long id) throws DatabaseNotFoundException, RemoteUnavailableException,
+    DatabaseDto getDatabaseById(Long id) throws DatabaseNotFoundException, RemoteUnavailableException,
             MetadataServiceException;
 
     /**
@@ -50,7 +49,7 @@ public interface MetadataServiceGateway {
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedTableDto getTableById(Long databaseId, Long id) throws TableNotFoundException, RemoteUnavailableException,
+    TableDto getTableById(Long databaseId, Long id) throws TableNotFoundException, RemoteUnavailableException,
             MetadataServiceException;
 
     /**
@@ -63,7 +62,7 @@ public interface MetadataServiceGateway {
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedViewDto getViewById(Long databaseId, Long id) throws RemoteUnavailableException, ViewNotFoundException,
+    ViewDto getViewById(Long databaseId, Long id) throws RemoteUnavailableException, ViewNotFoundException,
             MetadataServiceException;
 
     /**
@@ -77,18 +76,6 @@ public interface MetadataServiceGateway {
      */
     UserDto getUserById(UUID userId) throws RemoteUnavailableException, UserNotFoundException, MetadataServiceException;
 
-    /**
-     * Get a user with given user id from the metadata service.
-     *
-     * @param userId The user id.
-     * @return The user, if successful.
-     * @throws RemoteUnavailableException The remote service is not available and invalid data was returned.
-     * @throws UserNotFoundException      The user was not found in the metadata service.
-     * @throws MetadataServiceException   The remote service returned invalid data.
-     */
-    PrivilegedUserDto getPrivilegedUserById(UUID userId) throws RemoteUnavailableException, UserNotFoundException,
-            MetadataServiceException;
-
     /**
      * Get database access for a given user and database id from the metadata service.
      *
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/gateway/impl/MetadataServiceGatewayImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/gateway/impl/MetadataServiceGatewayImpl.java
index 7d834992cc73b689bc990b6639061ae1ca2ddb71..57d6ffab7ccf87336066e0a8c5b9ec700434099f 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/gateway/impl/MetadataServiceGatewayImpl.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/gateway/impl/MetadataServiceGatewayImpl.java
@@ -1,17 +1,12 @@
 package at.tuwien.gateway.impl;
 
 import at.tuwien.api.container.ContainerDto;
-import at.tuwien.api.container.image.ImageDto;
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
 import at.tuwien.api.database.DatabaseAccessDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
 import at.tuwien.api.database.table.TableDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import at.tuwien.api.identifier.IdentifierBriefDto;
 import at.tuwien.api.user.UserDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
 import at.tuwien.config.GatewayConfig;
 import at.tuwien.exception.*;
 import at.tuwien.gateway.MetadataServiceGateway;
@@ -36,27 +31,24 @@ import java.util.UUID;
 @Service
 public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
 
-    private final RestTemplate restTemplate;
     private final RestTemplate internalRestTemplate;
     private final GatewayConfig gatewayConfig;
     private final MetadataMapper metadataMapper;
 
     @Autowired
     public MetadataServiceGatewayImpl(@Qualifier("internalRestTemplate") RestTemplate internalRestTemplate,
-                                      RestTemplate restTemplate, GatewayConfig gatewayConfig,
-                                      MetadataMapper metadataMapper) {
-        this.restTemplate = restTemplate;
+                                      GatewayConfig gatewayConfig, MetadataMapper metadataMapper) {
         this.internalRestTemplate = internalRestTemplate;
         this.gatewayConfig = gatewayConfig;
         this.metadataMapper = metadataMapper;
     }
 
     @Override
-    public PrivilegedContainerDto getContainerById(Long containerId) throws RemoteUnavailableException,
+    public ContainerDto getContainerById(Long containerId) throws RemoteUnavailableException,
             ContainerNotFoundException, MetadataServiceException {
         final ResponseEntity<ContainerDto> response;
         final String url = "/api/container/" + containerId;
-        log.debug("get privileged container info from metadata service: {}", url);
+        log.debug("get  container info from metadata service: {}", url);
         try {
             response = internalRestTemplate.exchange(url, HttpMethod.GET, HttpEntity.EMPTY,
                     ContainerDto.class);
@@ -73,16 +65,16 @@ public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
         }
         final List<String> expectedHeaders = List.of("X-Username", "X-Password");
         if (!response.getHeaders().keySet().containsAll(expectedHeaders)) {
-            log.error("Failed to find all privileged container headers");
+            log.error("Failed to find all  container headers");
             log.debug("expected headers: {}", expectedHeaders);
             log.debug("found headers: {}", response.getHeaders().keySet());
-            throw new MetadataServiceException("Failed to find all privileged container headers");
+            throw new MetadataServiceException("Failed to find all  container headers");
         }
         if (response.getBody() == null) {
             log.error("Failed to find container with id {}: body is empty", containerId);
             throw new MetadataServiceException("Failed to find container with id " + containerId + ": body is empty");
         }
-        final PrivilegedContainerDto container = metadataMapper.containerDtoToPrivilegedContainerDto(response.getBody());
+        final ContainerDto container = metadataMapper.containerDtoToContainerDto(response.getBody());
         container.setUsername(response.getHeaders().get("X-Username").get(0));
         container.setPassword(response.getHeaders().get("X-Password").get(0));
         container.setLastRetrieved(Instant.now());
@@ -90,13 +82,13 @@ public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
     }
 
     @Override
-    public PrivilegedDatabaseDto getDatabaseById(Long id) throws DatabaseNotFoundException, RemoteUnavailableException,
+    public DatabaseDto getDatabaseById(Long id) throws DatabaseNotFoundException, RemoteUnavailableException,
             MetadataServiceException {
-        final ResponseEntity<PrivilegedDatabaseDto> response;
+        final ResponseEntity<DatabaseDto> response;
         final String url = "/api/database/" + id;
-        log.debug("get privileged database info from metadata service: {}", url);
+        log.debug("get  database info from metadata service: {}", url);
         try {
-            response = internalRestTemplate.exchange(url, HttpMethod.GET, HttpEntity.EMPTY, PrivilegedDatabaseDto.class);
+            response = internalRestTemplate.exchange(url, HttpMethod.GET, HttpEntity.EMPTY, DatabaseDto.class);
         } catch (ResourceAccessException | HttpServerErrorException e) {
             log.error("Failed to find database with id {}: {}", id, e.getMessage());
             throw new RemoteUnavailableException("Failed to find database: " + e.getMessage(), e);
@@ -110,16 +102,16 @@ public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
         }
         final List<String> expectedHeaders = List.of("X-Username", "X-Password", "X-Host", "X-Port");
         if (!response.getHeaders().keySet().containsAll(expectedHeaders)) {
-            log.error("Failed to find all privileged database headers");
+            log.error("Failed to find all  database headers");
             log.debug("expected headers: {}", expectedHeaders);
             log.debug("found headers: {}", response.getHeaders().keySet());
-            throw new MetadataServiceException("Failed to find all privileged database headers");
+            throw new MetadataServiceException("Failed to find all  database headers");
         }
         if (response.getBody() == null) {
             log.error("Failed to find database with id {}: body is empty", id);
             throw new MetadataServiceException("Failed to find database with id " + id + ": body is empty");
         }
-        final PrivilegedDatabaseDto database = response.getBody();
+        final DatabaseDto database = response.getBody();
         database.getContainer().setUsername(response.getHeaders().get("X-Username").get(0));
         database.getContainer().setPassword(response.getHeaders().get("X-Password").get(0));
         database.getContainer().setHost(response.getHeaders().get("X-Host").get(0));
@@ -129,11 +121,11 @@ public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
     }
 
     @Override
-    public PrivilegedTableDto getTableById(Long databaseId, Long id) throws TableNotFoundException,
+    public TableDto getTableById(Long databaseId, Long id) throws TableNotFoundException,
             RemoteUnavailableException, MetadataServiceException {
         final ResponseEntity<TableDto> response;
         final String url = "/api/database/" + databaseId + "/table/" + id;
-        log.debug("get privileged table info from metadata service: {}", url);
+        log.debug("get  table info from metadata service: {}", url);
         try {
             response = internalRestTemplate.exchange(url, HttpMethod.GET, HttpEntity.EMPTY, TableDto.class);
         } catch (ResourceAccessException | HttpServerErrorException e) {
@@ -149,33 +141,33 @@ public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
         }
         final List<String> expectedHeaders = List.of("X-Type", "X-Host", "X-Port", "X-Username", "X-Password", "X-Database", "X-Table");
         if (!response.getHeaders().keySet().containsAll(expectedHeaders)) {
-            log.error("Failed to find all privileged table headers");
+            log.error("Failed to find all  table headers");
             log.debug("expected headers: {}", expectedHeaders);
             log.debug("found headers: {}", response.getHeaders().keySet());
-            throw new MetadataServiceException("Failed to find all privileged table headers");
+            throw new MetadataServiceException("Failed to find all  table headers");
         }
         if (response.getBody() == null) {
             log.error("Failed to find table with id {}: body is empty", id);
             throw new MetadataServiceException("Failed to find table with id " + id + ": body is empty");
         }
-        final PrivilegedTableDto table = metadataMapper.tableDtoToPrivilegedTableDto(response.getBody());
-        table.getDatabase().getContainer().getImage().setJdbcMethod(response.getHeaders().get("X-Type").get(0));
-        table.getDatabase().getContainer().setHost(response.getHeaders().get("X-Host").get(0));
-        table.getDatabase().getContainer().setPort(Integer.parseInt(response.getHeaders().get("X-Port").get(0)));
-        table.getDatabase().getContainer().setUsername(response.getHeaders().get("X-Username").get(0));
-        table.getDatabase().getContainer().setPassword(response.getHeaders().get("X-Password").get(0));
-        table.getDatabase().setInternalName(response.getHeaders().get("X-Database").get(0));
+        final TableDto table = metadataMapper.tableDtoToTableDto(response.getBody());
+        table.setJdbcMethod(response.getHeaders().get("X-Type").get(0));
+        table.setHost(response.getHeaders().get("X-Host").get(0));
+        table.setPort(Integer.parseInt(response.getHeaders().get("X-Port").get(0)));
+        table.setUsername(response.getHeaders().get("X-Username").get(0));
+        table.setPassword(response.getHeaders().get("X-Password").get(0));
+        table.setDatabase(response.getHeaders().get("X-Database").get(0));
         table.setInternalName(response.getHeaders().get("X-Table").get(0));
         table.setLastRetrieved(Instant.now());
         return table;
     }
 
     @Override
-    public PrivilegedViewDto getViewById(Long databaseId, Long id) throws RemoteUnavailableException,
+    public ViewDto getViewById(Long databaseId, Long id) throws RemoteUnavailableException,
             ViewNotFoundException, MetadataServiceException {
         final ResponseEntity<ViewDto> response;
         final String url = "/api/database/" + databaseId + "/view/" + id;
-        log.debug("get privileged view info from metadata service: {}", url);
+        log.debug("get  view info from metadata service: {}", url);
         try {
             response = internalRestTemplate.exchange(url, HttpMethod.GET, HttpEntity.EMPTY, ViewDto.class);
         } catch (ResourceAccessException | HttpServerErrorException e) {
@@ -191,28 +183,22 @@ public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
         }
         final List<String> expectedHeaders = List.of("X-Type", "X-Host", "X-Port", "X-Username", "X-Password", "X-Database", "X-View");
         if (!response.getHeaders().keySet().containsAll(expectedHeaders)) {
-            log.error("Failed to find all privileged view headers");
+            log.error("Failed to find all  view headers");
             log.debug("expected headers: {}", expectedHeaders);
             log.debug("found headers: {}", response.getHeaders().keySet());
-            throw new MetadataServiceException("Failed to find all privileged view headers");
+            throw new MetadataServiceException("Failed to find all  view headers");
         }
         if (response.getBody() == null) {
             log.error("Failed to find view with id {}: body is empty", id);
             throw new MetadataServiceException("Failed to find view with id " + id + ": body is empty");
         }
-        final PrivilegedViewDto view = metadataMapper.viewDtoToPrivilegedViewDto(response.getBody());
-        view.setDatabase(PrivilegedDatabaseDto.builder()
-                .internalName(response.getHeaders().get("X-Database").get(0))
-                .container(PrivilegedContainerDto.builder()
-                        .host(response.getHeaders().get("X-Host").get(0))
-                        .port(Integer.parseInt(response.getHeaders().get("X-Port").get(0)))
-                        .username(response.getHeaders().get("X-Username").get(0))
-                        .password(response.getHeaders().get("X-Password").get(0))
-                        .image(ImageDto.builder()
-                                .jdbcMethod(response.getHeaders().get("X-Type").get(0))
-                                .build())
-                        .build())
-                .build());
+        final ViewDto view = metadataMapper.viewDtoToViewDto(response.getBody());
+        view.setJdbcMethod(response.getHeaders().get("X-Type").get(0));
+        view.setHost(response.getHeaders().get("X-Host").get(0));
+        view.setPort(Integer.parseInt(response.getHeaders().get("X-Port").get(0)));
+        view.setUsername(response.getHeaders().get("X-Username").get(0));
+        view.setPassword(response.getHeaders().get("X-Password").get(0));
+        view.setDatabase(response.getHeaders().get("X-Database").get(0));
         view.setInternalName(response.getHeaders().get("X-View").get(0));
         view.setLastRetrieved(Instant.now());
         return view;
@@ -223,33 +209,7 @@ public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
             MetadataServiceException {
         final ResponseEntity<UserDto> response;
         final String url = "/api/user/" + userId;
-        log.debug("get user info from metadata service: {}", url);
-        try {
-            response = internalRestTemplate.exchange(url, HttpMethod.GET, HttpEntity.EMPTY, UserDto.class);
-        } catch (ResourceAccessException | HttpServerErrorException e) {
-            log.error("Failed to find user with id {}: {}", userId, e.getMessage());
-            throw new RemoteUnavailableException("Failed to find user: " + e.getMessage(), e);
-        } catch (HttpClientErrorException.NotFound e) {
-            log.error("Failed to find user with id {}: not found: {}", userId, e.getMessage());
-            throw new UserNotFoundException("Failed to find user: " + e.getMessage(), e);
-        }
-        if (!response.getStatusCode().equals(HttpStatus.OK)) {
-            log.error("Failed to find user with id {}: service responded unsuccessful: {}", userId, response.getStatusCode());
-            throw new MetadataServiceException("Failed to find user: service responded unsuccessful: " + response.getStatusCode());
-        }
-        if (response.getBody() == null) {
-            log.error("Failed to find user with id {}: body is empty", userId);
-            throw new MetadataServiceException("Failed to find user with id " + userId + ": body is empty");
-        }
-        return response.getBody();
-    }
-
-    @Override
-    public PrivilegedUserDto getPrivilegedUserById(UUID userId) throws RemoteUnavailableException, UserNotFoundException,
-            MetadataServiceException {
-        final ResponseEntity<UserDto> response;
-        final String url = "/api/user/" + userId;
-        log.debug("get privileged user info from metadata service: {}", url);
+        log.debug("get  user info from metadata service: {}", url);
         try {
             response = internalRestTemplate.exchange(url, HttpMethod.GET, HttpEntity.EMPTY, UserDto.class);
         } catch (ResourceAccessException | HttpServerErrorException e) {
@@ -265,16 +225,16 @@ public class MetadataServiceGatewayImpl implements MetadataServiceGateway {
         }
         final List<String> expectedHeaders = List.of("X-Username", "X-Password");
         if (!response.getHeaders().keySet().containsAll(expectedHeaders)) {
-            log.error("Failed to find all privileged user headers");
+            log.error("Failed to find all  user headers");
             log.debug("expected headers: {}", expectedHeaders);
             log.debug("found headers: {}", response.getHeaders().keySet());
-            throw new MetadataServiceException("Failed to find all privileged user headers");
+            throw new MetadataServiceException("Failed to find all  user headers");
         }
         if (response.getBody() == null) {
             log.error("Failed to find user with id {}: body is empty", userId);
             throw new MetadataServiceException("Failed to find user with id " + userId + ": body is empty");
         }
-        final PrivilegedUserDto user = metadataMapper.userDtoToPrivilegedUserDto(response.getBody());
+        final UserDto user = metadataMapper.userDtoToUserDto(response.getBody());
         user.setUsername(response.getHeaders().get("X-Username").get(0));
         user.setPassword(response.getHeaders().get("X-Password").get(0));
         user.setLastRetrieved(Instant.now());
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/listener/DefaultListener.java b/dbrepo-data-service/services/src/main/java/at/tuwien/listener/DefaultListener.java
index fac47a3d80f6030f5e7d4d561c4262123e9feea7..e31455a75efa96fe0c2bc1ffb0f176bc3e3ce4dd 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/listener/DefaultListener.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/listener/DefaultListener.java
@@ -1,7 +1,9 @@
 package at.tuwien.listener;
 
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
-import at.tuwien.exception.*;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.exception.MetadataServiceException;
+import at.tuwien.exception.RemoteUnavailableException;
+import at.tuwien.exception.TableNotFoundException;
 import at.tuwien.gateway.MetadataServiceGateway;
 import at.tuwien.service.QueueService;
 import com.fasterxml.jackson.core.type.TypeReference;
@@ -57,7 +59,7 @@ public class DefaultListener implements MessageListener {
         log.trace("received message for table with id {} of database id {}: {} bytes", tableId, databaseId, message.getMessageProperties().getContentLength());
         final Map<String, Object> body;
         try {
-            final PrivilegedTableDto table = metadataServiceGateway.getTableById(databaseId, tableId);
+            final TableDto table = metadataServiceGateway.getTableById(databaseId, tableId);
             body = objectMapper.readValue(message.getBody(), typeRef);
             queueService.insert(table, body);
         } catch (IOException e) {
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/mapper/MariaDbMapper.java b/dbrepo-data-service/services/src/main/java/at/tuwien/mapper/MariaDbMapper.java
index db848cab7ef8b59f1bfaac58aa5d7c008410732f..7f5b63b21cc629a0087bf5737b66aa9c677aeaa5 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/mapper/MariaDbMapper.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/mapper/MariaDbMapper.java
@@ -1,12 +1,12 @@
 package at.tuwien.mapper;
 
+import at.tuwien.api.database.table.TableDto;
 import at.tuwien.api.database.table.TupleDeleteDto;
 import at.tuwien.api.database.table.TupleDto;
 import at.tuwien.api.database.table.TupleUpdateDto;
 import at.tuwien.api.database.table.columns.ColumnCreateDto;
 import at.tuwien.api.database.table.columns.ColumnDto;
 import at.tuwien.api.database.table.columns.ColumnTypeDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import at.tuwien.exception.QueryMalformedException;
 import at.tuwien.exception.TableMalformedException;
 import at.tuwien.utils.MariaDbUtil;
@@ -519,7 +519,7 @@ public interface MariaDbMapper {
         return statement.toString();
     }
 
-    default String tupleToRawDeleteQuery(PrivilegedTableDto table, TupleDeleteDto data) throws TableMalformedException {
+    default String tupleToRawDeleteQuery(TableDto table, TupleDeleteDto data) throws TableMalformedException {
         log.trace("table csv to delete query, table.id={}, data.keys={}", table.getId(), data.getKeys());
         if (table.getColumns().isEmpty()) {
             throw new TableMalformedException("Columns are not known");
@@ -540,14 +540,14 @@ public interface MariaDbMapper {
         return statement.toString();
     }
 
-    default String tupleToRawUpdateQuery(PrivilegedTableDto table, TupleUpdateDto data)
+    default String tupleToRawUpdateQuery(TableDto table, TupleUpdateDto data)
             throws TableMalformedException {
         if (table.getColumns().isEmpty()) {
             throw new TableMalformedException("Columns are not known");
         }
         /* parameterized query for prepared statement */
         final StringBuilder statement = new StringBuilder("UPDATE `")
-                .append(table.getDatabase().getInternalName())
+                .append(table.getDatabase())
                 .append("`.`")
                 .append(table.getInternalName())
                 .append("` SET ");
@@ -579,13 +579,13 @@ public interface MariaDbMapper {
         return statement.toString();
     }
 
-    default String tupleToRawCreateQuery(PrivilegedTableDto table, TupleDto data) throws TableMalformedException {
+    default String tupleToRawCreateQuery(TableDto table, TupleDto data) throws TableMalformedException {
         if (table.getColumns().isEmpty()) {
             throw new TableMalformedException("Columns are not known");
         }
         /* parameterized query for prepared statement */
         final StringBuilder statement = new StringBuilder("INSERT INTO `")
-                .append(table.getDatabase().getInternalName())
+                .append(table.getDatabase())
                 .append("`.`")
                 .append(table.getInternalName())
                 .append("` (");
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/mapper/MetadataMapper.java b/dbrepo-data-service/services/src/main/java/at/tuwien/mapper/MetadataMapper.java
index 0adfafa8f96c1c63dafea3a8edd6f45230f88a3d..359e251ea2c6d3ca7f0194a64f06d1165a01cce9 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/mapper/MetadataMapper.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/mapper/MetadataMapper.java
@@ -2,28 +2,23 @@ package at.tuwien.mapper;
 
 import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.container.image.ImageDto;
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
 import at.tuwien.api.database.DatabaseBriefDto;
 import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.ViewColumnDto;
 import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
 import at.tuwien.api.database.query.QueryDto;
 import at.tuwien.api.database.table.TableBriefDto;
 import at.tuwien.api.database.table.TableDto;
 import at.tuwien.api.database.table.columns.ColumnDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import at.tuwien.api.identifier.IdentifierBriefDto;
 import at.tuwien.api.identifier.IdentifierDto;
 import at.tuwien.api.user.UserBriefDto;
 import at.tuwien.api.user.UserDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
 import org.mapstruct.Mappings;
 
-@Mapper(componentModel = "spring", imports = {PrivilegedDatabaseDto.class, PrivilegedContainerDto.class, ImageDto.class})
+@Mapper(componentModel = "spring", imports = {DatabaseDto.class, ContainerDto.class, ImageDto.class})
 public interface MetadataMapper {
 
     org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(MetadataMapper.class);
@@ -32,28 +27,21 @@ public interface MetadataMapper {
         return subset.getQueryHash();
     }
 
-    PrivilegedContainerDto containerDtoToPrivilegedContainerDto(ContainerDto data);
+    ContainerDto containerDtoToContainerDto(ContainerDto data);
 
-    DatabaseDto privilegedDatabaseDtoToDatabaseDto(PrivilegedDatabaseDto data);
-
-    DatabaseBriefDto privilegedDatabaseDtoToDatabaseBriefDto(PrivilegedDatabaseDto data);
-
-    TableDto privilegedTableDtoToTableDto(PrivilegedTableDto data);
+    DatabaseBriefDto databaseDtoToDatabaseBriefDto(DatabaseDto data);
 
     ColumnDto viewColumnDtoToColumnDto(ViewColumnDto data);
 
     ViewColumnDto columnDtoToViewColumnDto(ColumnDto data);
 
-    @Mappings({
-            @Mapping(target = "database", expression = "java(PrivilegedDatabaseDto.builder().container(PrivilegedContainerDto.builder().image(new ImageDto()).build()).build())")
-    })
-    PrivilegedTableDto tableDtoToPrivilegedTableDto(TableDto data);
+    TableDto tableDtoToTableDto(TableDto data);
 
-    PrivilegedViewDto viewDtoToPrivilegedViewDto(ViewDto data);
+    ViewDto viewDtoToViewDto(ViewDto data);
 
-    ContainerDto privilegedContainerDtoToContainerDto(PrivilegedContainerDto data);
+    ContainerDto ContainerDtoToContainerDto(ContainerDto data);
 
-    PrivilegedUserDto userDtoToPrivilegedUserDto(UserDto data);
+    UserDto userDtoToUserDto(UserDto data);
 
     UserBriefDto userDtoToUserBriefDto(UserDto data);
 
@@ -64,6 +52,8 @@ public interface MetadataMapper {
 
     IdentifierBriefDto identifierDtoToIdentifierBriefDto(IdentifierDto data);
 
+    TableDto databaseDtoToTableDto(DatabaseDto data);
+
     default String metricToUri(String baseUrl, Long databaseId, Long tableId, Long subsetId, Long viewId) {
         final StringBuilder uri = new StringBuilder(baseUrl)
                 .append("/database/")
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/AccessService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/AccessService.java
index 89707ce8f2a834ca8aee1acd7d57ac238dfe9fb9..c42fc28101ba6498e2723f4b02acca6c6d6c2a1b 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/AccessService.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/AccessService.java
@@ -1,8 +1,8 @@
 package at.tuwien.service;
 
 import at.tuwien.api.database.AccessTypeDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.exception.DatabaseMalformedException;
 
 import java.sql.SQLException;
@@ -18,7 +18,7 @@ public interface AccessService {
      * @throws SQLException               The connection to the database could not be established.
      * @throws DatabaseMalformedException The database schema is malformed.
      */
-    void create(PrivilegedDatabaseDto database, PrivilegedUserDto user, AccessTypeDto access) throws SQLException,
+    void create(DatabaseDto database, UserDto user, AccessTypeDto access) throws SQLException,
             DatabaseMalformedException;
 
     /**
@@ -30,7 +30,7 @@ public interface AccessService {
      * @throws SQLException               The connection to the database could not be established.
      * @throws DatabaseMalformedException The database schema is malformed.
      */
-    void update(PrivilegedDatabaseDto database, PrivilegedUserDto user, AccessTypeDto access) throws SQLException,
+    void update(DatabaseDto database, UserDto user, AccessTypeDto access) throws SQLException,
             DatabaseMalformedException;
 
     /**
@@ -41,6 +41,5 @@ public interface AccessService {
      * @throws SQLException               The connection to the database could not be established.
      * @throws DatabaseMalformedException The database schema is malformed.
      */
-    void delete(PrivilegedDatabaseDto database, PrivilegedUserDto user) throws SQLException,
-            DatabaseMalformedException;
+    void delete(DatabaseDto database, UserDto user) throws SQLException, DatabaseMalformedException;
 }
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/ContainerService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/ContainerService.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f9e92ed7899149b518ef6018bade9818e1a4bc5
--- /dev/null
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/ContainerService.java
@@ -0,0 +1,33 @@
+package at.tuwien.service;
+
+import at.tuwien.api.container.ContainerDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.internal.CreateDatabaseDto;
+import at.tuwien.exception.DatabaseMalformedException;
+import at.tuwien.exception.QueryStoreCreateException;
+
+import java.sql.SQLException;
+
+public interface ContainerService {
+
+    /**
+     * Creates a database in the given container.
+     * @param container The container.
+     * @param data The database metadata.
+     * @return The created database, if successful.
+     * @throws SQLException The connection to the database could not be established.
+     * @throws DatabaseMalformedException The database schema is malformed.
+     */
+    DatabaseDto createDatabase(ContainerDto container, CreateDatabaseDto data) throws SQLException,
+            DatabaseMalformedException;
+
+    /**
+     * Creates the query store in the container and database.
+     *
+     * @param container    The container.
+     * @param databaseName The database name.
+     * @throws SQLException              The connection to the database could not be established.
+     * @throws QueryStoreCreateException The query store could not be created.
+     */
+    void createQueryStore(ContainerDto container, String databaseName) throws SQLException, QueryStoreCreateException;
+}
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/CredentialService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/CredentialService.java
index ff09d6672fe23904181d1e7600a263b847146e0d..fe3df343dba29ca489a8559e1cc741b7cc03359c 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/CredentialService.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/CredentialService.java
@@ -1,11 +1,11 @@
 package at.tuwien.service;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
+import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.database.DatabaseAccessDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.ViewDto;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.exception.*;
 
 import java.util.UUID;
@@ -22,7 +22,7 @@ public interface CredentialService {
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedDatabaseDto getDatabase(Long id) throws DatabaseNotFoundException, RemoteUnavailableException,
+    DatabaseDto getDatabase(Long id) throws DatabaseNotFoundException, RemoteUnavailableException,
             MetadataServiceException;
 
     /**
@@ -35,7 +35,7 @@ public interface CredentialService {
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedContainerDto getContainer(Long id) throws ContainerNotFoundException, RemoteUnavailableException,
+    ContainerDto getContainer(Long id) throws ContainerNotFoundException, RemoteUnavailableException,
             MetadataServiceException;
 
     /**
@@ -49,7 +49,7 @@ public interface CredentialService {
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedTableDto getTable(Long databaseId, Long tableId) throws RemoteUnavailableException,
+    TableDto getTable(Long databaseId, Long tableId) throws RemoteUnavailableException,
             MetadataServiceException, TableNotFoundException;
 
     /**
@@ -63,7 +63,7 @@ public interface CredentialService {
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedViewDto getView(Long databaseId, Long viewId) throws RemoteUnavailableException,
+    ViewDto getView(Long databaseId, Long viewId) throws RemoteUnavailableException,
             MetadataServiceException, ViewNotFoundException;
 
     /**
@@ -76,7 +76,7 @@ public interface CredentialService {
      * @throws RemoteUnavailableException The remote service is not available.
      * @throws MetadataServiceException   The remote service returned invalid data.
      */
-    PrivilegedUserDto getUser(UUID id) throws RemoteUnavailableException, MetadataServiceException,
+    UserDto getUser(UUID id) throws RemoteUnavailableException, MetadataServiceException,
             UserNotFoundException;
 
     /**
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/DatabaseService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/DatabaseService.java
index 271b2abb82918027053a357c648a1d2ac1926278..5a120f44d288f5a1fadb5d0c75d478a097558725 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/DatabaseService.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/DatabaseService.java
@@ -1,27 +1,92 @@
 package at.tuwien.service;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
 import at.tuwien.api.database.DatabaseDto;
-import at.tuwien.api.database.internal.CreateDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
+import at.tuwien.api.database.ViewCreateDto;
+import at.tuwien.api.database.ViewDto;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.api.database.table.internal.TableCreateDto;
 import at.tuwien.api.user.internal.UpdateUserPasswordDto;
 import at.tuwien.exception.*;
 
 import java.sql.SQLException;
+import java.util.List;
 
 public interface DatabaseService {
 
     /**
-     * Creates a database in the given container.
-     * @param container The container.
-     * @param data The database metadata.
-     * @return The created database, if successful.
+     * Inspects the schema (columns with names, data types) of a view with given name in the given database.
+     * @param database The database.
+     * @param viewName The view name.
+     * @return The inspected view if successful.
      * @throws SQLException The connection to the database could not be established.
-     * @throws DatabaseMalformedException The database schema is malformed.
+     * @throws ViewNotFoundException The view was not found in the given database.
+     */
+    ViewDto inspectView(DatabaseDto database, String viewName) throws SQLException, ViewNotFoundException;
+
+    /**
+     * Creates a table in given data database with table definition.
+     *
+     * @param database The data database object.
+     * @param data     The table definition.
+     * @return The generated table.
+     * @throws SQLException            Query statement is malformed.
+     * @throws TableMalformedException The table schema is malformed.
+     * @throws TableExistsException    The table name already exists in the information_schema.
+     * @throws TableNotFoundException  The table could not be inspected in the metadata database.
      */
-    PrivilegedDatabaseDto create(PrivilegedContainerDto container, CreateDatabaseDto data) throws SQLException,
+    TableDto createTable(DatabaseDto database, TableCreateDto data) throws SQLException,
+            TableMalformedException, TableExistsException, TableNotFoundException;
+
+    Boolean existsView(DatabaseDto database, String viewName) throws SQLException,
+            QueryMalformedException;
+
+    /**
+     * Creates a view in given data database with view definition.
+     * @param database The data database object.
+     * @param data The view definition.
+     * @return The generated view.
+     * @throws SQLException
+     * @throws ViewMalformedException
+     */
+    ViewDto createView(DatabaseDto database, ViewCreateDto data) throws SQLException,
+            ViewMalformedException;
+
+    /**
+     * Gets the metadata schema for a given database.
+     *
+     * @param database The database.
+     * @return The list of view metadata.
+     * @throws SQLException               The connection to the data database was unsuccessful.
+     * @throws DatabaseMalformedException The columns that are referenced in the views are unknown to the Metadata Database. Call {@link TableService#getSchemas(DatabaseDto)} beforehand.
+     * @throws ViewNotFoundException      The view with given name was not found.
+     */
+    List<ViewDto> exploreViews(DatabaseDto database) throws SQLException, DatabaseMalformedException,
+            ViewNotFoundException;
+
+    /**
+     * Get table schemas from the information_schema in the data database.
+     *
+     * @param database The data database  object.
+     * @return List of tables, if successful.
+     * @throws SQLException               Failed to parse SQL query, contains invalid syntax.
+     * @throws TableNotFoundException     The table could not be inspected in the data database.
+     * @throws DatabaseMalformedException The database inspection was unsuccessful, likely due to a bug in the mapping.
+     */
+    List<TableDto> exploreTables(DatabaseDto database) throws SQLException, TableNotFoundException,
             DatabaseMalformedException;
 
+    /**
+     * Inspects the schema (columns with names, data types, unique-, check-, primary- and foreign key constraints) of
+     * a table with given name in the given database.
+     *
+     * @param database The database.
+     * @param tableName The table name.
+     * @return The inspected table if successful.
+     * @throws SQLException The connection to the database could not be established.
+     * @throws TableNotFoundException The table was not found in the given database.
+     */
+    TableDto inspectTable(DatabaseDto database, String tableName) throws SQLException, TableNotFoundException;
+
     /**
      * Updates a user's password in a given database.
      * @param database The database.
@@ -29,6 +94,6 @@ public interface DatabaseService {
      * @throws SQLException The connection to the database could not be established.
      * @throws DatabaseMalformedException The database schema is malformed.
      */
-    void update(PrivilegedDatabaseDto database, UpdateUserPasswordDto data) throws SQLException,
+    void update(DatabaseDto database, UpdateUserPasswordDto data) throws SQLException,
             DatabaseMalformedException;
 }
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/QueueService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/QueueService.java
index 79a23932b5aee74da800c0b41023a7257fa4d32b..6a03f5d767115314f6683ae726caaaf26538ebf9 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/QueueService.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/QueueService.java
@@ -1,6 +1,6 @@
 package at.tuwien.service;
 
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
+import at.tuwien.api.database.table.TableDto;
 
 import java.sql.SQLException;
 import java.util.Map;
@@ -14,5 +14,5 @@ public interface QueueService {
      * @param data     The data.
      * @throws SQLException The connection to the database could not be established.
      */
-    void insert(PrivilegedTableDto table, Map<String, Object> data) throws SQLException;
+    void insert(TableDto table, Map<String, Object> data) throws SQLException;
 }
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/SchemaService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/SchemaService.java
deleted file mode 100644
index f5ef05b44aed27a8fb43dbd123b5096e36c2283d..0000000000000000000000000000000000000000
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/SchemaService.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package at.tuwien.service;
-
-import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.table.TableDto;
-import at.tuwien.exception.*;
-
-import java.sql.SQLException;
-
-public interface SchemaService {
-
-    /**
-     * Inspects the schema (columns with names, data types, unique-, check-, primary- and foreign key constraints) of
-     * a table with given name in the given database.
-     * @param database The database.
-     * @param tableName The table name.
-     * @return The inspected table if successful.
-     * @throws SQLException The connection to the database could not be established.
-     * @throws TableNotFoundException The table was not found in the given database.
-     */
-    TableDto inspectTable(PrivilegedDatabaseDto database, String tableName) throws SQLException,
-            TableNotFoundException;
-
-    /**
-     * Inspects the schema (columns with names, data types) of a view with given name in the given database.
-     * @param database The database.
-     * @param viewName The table name.
-     * @return The inspected view if successful.
-     * @throws SQLException The connection to the database could not be established.
-     * @throws ViewNotFoundException The view was not found in the given database.
-     */
-    ViewDto inspectView(PrivilegedDatabaseDto database, String viewName) throws SQLException, ViewNotFoundException;
-}
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/SubsetService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/SubsetService.java
index 4a3455fbc4e10f9632148fbe12e92f4298973f9d..b2de5cecca0d5ec607563e658ee210186997a91e 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/SubsetService.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/SubsetService.java
@@ -1,7 +1,6 @@
 package at.tuwien.service;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.query.QueryDto;
 import at.tuwien.exception.*;
 import org.apache.spark.sql.Dataset;
@@ -14,17 +13,6 @@ import java.util.UUID;
 
 public interface SubsetService {
 
-    /**
-     * Creates the query store in the container and database.
-     *
-     * @param container    The container.
-     * @param databaseName The database name.
-     * @throws SQLException              The connection to the database could not be established.
-     * @throws QueryStoreCreateException The query store could not be created.
-     */
-    void createQueryStore(PrivilegedContainerDto container, String databaseName) throws SQLException,
-            QueryStoreCreateException;
-
     /**
      * Retrieve data from a subset in a database and optionally paginate with number of page and size of results.
      *
@@ -38,7 +26,7 @@ public interface SubsetService {
      * @throws QueryMalformedException The mapped query produced a database error.
      * @throws TableNotFoundException  The database table is malformed.
      */
-    Dataset<Row> getData(PrivilegedDatabaseDto database, QueryDto subset, Long page, Long size)
+    Dataset<Row> getData(DatabaseDto database, QueryDto subset, Long page, Long size)
             throws ViewMalformedException, SQLException, QueryMalformedException, TableNotFoundException;
 
     /**
@@ -52,7 +40,7 @@ public interface SubsetService {
      * @throws QueryStoreInsertException The query store refused to insert the query.
      * @throws SQLException              The connection to the database could not be established.
      */
-    Long create(PrivilegedDatabaseDto database, String statement, Instant timestamp, UUID userId)
+    Long create(DatabaseDto database, String statement, Instant timestamp, UUID userId)
             throws QueryStoreInsertException, SQLException;
 
     /**
@@ -64,7 +52,7 @@ public interface SubsetService {
      * @throws TableMalformedException The table is malformed.
      * @throws SQLException            The connection to the database could not be established.
      */
-    Long reExecuteCount(PrivilegedDatabaseDto database, QueryDto query) throws TableMalformedException,
+    Long reExecuteCount(DatabaseDto database, QueryDto query) throws TableMalformedException,
             SQLException, QueryMalformedException;
 
     /**
@@ -75,11 +63,11 @@ public interface SubsetService {
      * @return The list of queries.
      * @throws SQLException               The connection to the database could not be established.
      * @throws QueryNotFoundException     The query was not found for re-execution.
-     * @throws RemoteUnavailableException The privileged database information could not be found in the Metadata Service.
+     * @throws RemoteUnavailableException The  database information could not be found in the Metadata Service.
      * @throws DatabaseNotFoundException  The database was not found in the Metadata Service.
      * @throws MetadataServiceException   The Metadata Service responded unexpected.
      */
-    List<QueryDto> findAll(PrivilegedDatabaseDto database, Boolean filterPersisted) throws SQLException,
+    List<QueryDto> findAll(DatabaseDto database, Boolean filterPersisted) throws SQLException,
             QueryNotFoundException, RemoteUnavailableException, DatabaseNotFoundException, MetadataServiceException;
 
     /**
@@ -93,7 +81,7 @@ public interface SubsetService {
      * @throws QueryMalformedException The mapped query produced a database error.
      * @throws TableMalformedException The database table is malformed.
      */
-    Long executeCountNonPersistent(PrivilegedDatabaseDto database, String statement, Instant timestamp)
+    Long executeCountNonPersistent(DatabaseDto database, String statement, Instant timestamp)
             throws SQLException, QueryMalformedException, TableMalformedException;
 
     /**
@@ -104,12 +92,12 @@ public interface SubsetService {
      * @return The query.
      * @throws QueryNotFoundException     The query store did not return a query.
      * @throws SQLException               The connection to the database could not be established.
-     * @throws RemoteUnavailableException The privileged database information could not be found in the Metadata Service.
+     * @throws RemoteUnavailableException The  database information could not be found in the Metadata Service.
      * @throws UserNotFoundException      The user that created the query was not found in the Metadata Service.
      * @throws DatabaseNotFoundException  The database metadata was not found in the Metadata Service.
      * @throws MetadataServiceException   Communication with the Metadata Service failed.
      */
-    QueryDto findById(PrivilegedDatabaseDto database, Long queryId) throws QueryNotFoundException, SQLException,
+    QueryDto findById(DatabaseDto database, Long queryId) throws QueryNotFoundException, SQLException,
             RemoteUnavailableException, UserNotFoundException, DatabaseNotFoundException, MetadataServiceException;
 
     /**
@@ -122,7 +110,7 @@ public interface SubsetService {
      * @throws SQLException              The connection to the database could not be established.
      * @throws QueryStoreInsertException The query store failed to insert the query.
      */
-    Long storeQuery(PrivilegedDatabaseDto database, String query, Instant timestamp, UUID userId) throws SQLException,
+    Long storeQuery(DatabaseDto database, String query, Instant timestamp, UUID userId) throws SQLException,
             QueryStoreInsertException;
 
     /**
@@ -134,7 +122,7 @@ public interface SubsetService {
      * @throws SQLException               The connection to the database could not be established.
      * @throws QueryStorePersistException The query store failed to persist/unpersist the query.
      */
-    void persist(PrivilegedDatabaseDto database, Long queryId, Boolean persist) throws SQLException,
+    void persist(DatabaseDto database, Long queryId, Boolean persist) throws SQLException,
             QueryStorePersistException;
 
     /**
@@ -144,5 +132,5 @@ public interface SubsetService {
      * @throws SQLException          The connection to the database could not be established.
      * @throws QueryStoreGCException The query store failed to delete stale queries.
      */
-    void deleteStaleQueries(PrivilegedDatabaseDto database) throws SQLException, QueryStoreGCException;
+    void deleteStaleQueries(DatabaseDto database) throws SQLException, QueryStoreGCException;
 }
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/TableService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/TableService.java
index 0564639874b53e07ba5c900d85688af14552ec39..b74c491abe0af3e02eb4aaa533b72ad6a772e112 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/TableService.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/TableService.java
@@ -1,11 +1,9 @@
 package at.tuwien.service;
 
 import at.tuwien.api.SortTypeDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.query.ImportDto;
 import at.tuwien.api.database.table.*;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
-import at.tuwien.api.database.table.internal.TableCreateDto;
 import at.tuwien.exception.*;
 import org.apache.spark.sql.Dataset;
 import org.apache.spark.sql.Row;
@@ -16,57 +14,19 @@ import java.util.List;
 
 public interface TableService {
 
-    /**
-     * Get table schemas from the information_schema in the data database.
-     *
-     * @param database The data database privileged object.
-     * @return List of tables, if successful.
-     * @throws SQLException               Failed to parse SQL query, contains invalid syntax.
-     * @throws TableNotFoundException     The table could not be inspected in the data database.
-     * @throws DatabaseMalformedException The database inspection was unsuccessful, likely due to a bug in the mapping.
-     */
-    List<TableDto> getSchemas(PrivilegedDatabaseDto database) throws SQLException, TableNotFoundException,
-            DatabaseMalformedException;
-
     /**
      * Generate table statistic for a given table. Only numerical columns are calculated.
      *
+     * @param database The database.
      * @param table The table.
      * @return The table statistic, if successful.
      * @throws SQLException            Failed to parse SQL query, contains invalid syntax.
      * @throws TableMalformedException The table statistic generation was unsuccessful, likely due to a bug in the mapping.
      * @throws TableNotFoundException  The table could not be inspected in the data database.
      */
-    TableStatisticDto getStatistics(PrivilegedTableDto table) throws SQLException, TableMalformedException,
+    TableStatisticDto getStatistics(DatabaseDto database, TableDto table) throws SQLException, TableMalformedException,
             TableNotFoundException;
 
-    /**
-     * Finds a table with given data database and table name.
-     *
-     * @param database  The data database.
-     * @param tableName The table name.
-     * @return The table, if successful.
-     * @throws TableNotFoundException  The table could not be inspected in the data database.
-     * @throws SQLException            Failed to parse SQL query, contains invalid syntax.
-     * @throws QueryMalformedException The inspection query is malformed.
-     */
-    TableDto find(PrivilegedDatabaseDto database, String tableName) throws TableNotFoundException, SQLException,
-            QueryMalformedException;
-
-    /**
-     * Creates a table in given data database with table definition.
-     *
-     * @param database The data database privileged object.
-     * @param data     The table definition.
-     * @return The created table, if successful.
-     * @throws SQLException            Query statement is malformed.
-     * @throws TableMalformedException The table schema is malformed.
-     * @throws TableExistsException    The table name already exists in the information_schema.
-     * @throws TableNotFoundException  The table could not be inspected in the metadata database.
-     */
-    TableDto createTable(PrivilegedDatabaseDto database, TableCreateDto data) throws SQLException,
-            TableMalformedException, TableExistsException, TableNotFoundException;
-
     /**
      * Updating table description.
      *
@@ -76,7 +36,7 @@ public interface TableService {
      * @throws TableMalformedException The table schema is malformed.
      * @throws TableNotFoundException  The table could not be inspected in the metadata database.
      */
-    void updateTable(PrivilegedTableDto table, TableUpdateDto data) throws SQLException,
+    void updateTable(TableDto table, TableUpdateDto data) throws SQLException,
             TableMalformedException, TableNotFoundException;
 
     /**
@@ -86,7 +46,7 @@ public interface TableService {
      * @throws SQLException            Failed to parse SQL query, contains invalid syntax.
      * @throws QueryMalformedException The drop table query is malformed.
      */
-    void delete(PrivilegedTableDto table) throws SQLException, QueryMalformedException;
+    void delete(TableDto table) throws SQLException, QueryMalformedException;
 
     /**
      * Obtains the table history for a given table object.
@@ -97,7 +57,7 @@ public interface TableService {
      * @throws SQLException           Failed to parse SQL query, contains invalid syntax.
      * @throws TableNotFoundException The table could not be found in the data database.
      */
-    List<TableHistoryDto> history(PrivilegedTableDto table, Long size) throws SQLException, TableNotFoundException;
+    List<TableHistoryDto> history(TableDto table, Long size) throws SQLException, TableNotFoundException;
 
     /**
      * Obtains the table data tuples count at time.
@@ -108,7 +68,7 @@ public interface TableService {
      * @throws SQLException            Failed to parse SQL query, contains invalid syntax.
      * @throws QueryMalformedException The count query is malformed, likely due to a bug in the application.
      */
-    Long getCount(PrivilegedTableDto table, Instant timestamp) throws SQLException,
+    Long getCount(TableDto table, Instant timestamp) throws SQLException,
             QueryMalformedException;
 
     /**
@@ -123,7 +83,7 @@ public interface TableService {
      * @throws SQLException                Failed to parse SQL query, contains invalid syntax.
      * @throws QueryMalformedException     The import query is malformed, likely due to a bug in the application.
      */
-    void importDataset(PrivilegedTableDto table, ImportDto data) throws MalformedException, StorageNotFoundException,
+    void importDataset(TableDto table, ImportDto data) throws MalformedException, StorageNotFoundException,
             StorageUnavailableException, SQLException, QueryMalformedException, TableMalformedException;
 
     /**
@@ -135,7 +95,7 @@ public interface TableService {
      * @throws TableMalformedException The tuple is malformed and does not fit the table schema.
      * @throws QueryMalformedException The delete query is malformed, likely due to a bug in the application.
      */
-    void deleteTuple(PrivilegedTableDto table, TupleDeleteDto data) throws SQLException,
+    void deleteTuple(TableDto table, TupleDeleteDto data) throws SQLException,
             TableMalformedException, QueryMalformedException;
 
     /**
@@ -149,7 +109,7 @@ public interface TableService {
      * @throws StorageUnavailableException Failed to establish a connection with the Storage Service.
      * @throws StorageNotFoundException    The storage service was not able to find the dataset for import.
      */
-    void createTuple(PrivilegedTableDto table, TupleDto data) throws SQLException,
+    void createTuple(TableDto table, TupleDto data) throws SQLException,
             QueryMalformedException, TableMalformedException, StorageUnavailableException, StorageNotFoundException;
 
     /**
@@ -161,10 +121,10 @@ public interface TableService {
      * @throws QueryMalformedException The update query is malformed, likely due to a bug in the application.
      * @throws TableMalformedException The tuple is malformed and does not fit the table schema.
      */
-    void updateTuple(PrivilegedTableDto table, TupleUpdateDto data) throws SQLException,
+    void updateTuple(TableDto table, TupleUpdateDto data) throws SQLException,
             QueryMalformedException, TableMalformedException;
 
-    Dataset<Row> getData(PrivilegedDatabaseDto database, String tableOrView, Instant timestamp,
+    Dataset<Row> getData(DatabaseDto database, String tableOrView, Instant timestamp,
                          Long page, Long size, SortTypeDto sortDirection, String sortColumn)
             throws QueryMalformedException, TableNotFoundException;
 }
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/ViewService.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/ViewService.java
index ec7a723261372d1414f0590e74ef915bb62264f4..8f721f9974b0a35d5158fba0d67f9bf7a95faf70 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/ViewService.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/ViewService.java
@@ -1,66 +1,22 @@
 package at.tuwien.service;
 
-import at.tuwien.api.database.ViewCreateDto;
 import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
-import at.tuwien.api.database.query.QueryDto;
-import at.tuwien.exception.DatabaseMalformedException;
 import at.tuwien.exception.QueryMalformedException;
 import at.tuwien.exception.ViewMalformedException;
-import at.tuwien.exception.ViewNotFoundException;
 
 import java.sql.SQLException;
 import java.time.Instant;
-import java.util.List;
 
 public interface ViewService {
 
-    Boolean existsByName(PrivilegedDatabaseDto database, String name) throws SQLException,
-            QueryMalformedException;
-
-    /**
-     * Gets the metadata schema for a given database.
-     *
-     * @param database The database.
-     * @return The list of view metadata.
-     * @throws SQLException               The connection to the data database was unsuccessful.
-     * @throws DatabaseMalformedException The columns that are referenced in the views are unknown to the Metadata Database. Call {@link TableService#getSchemas(PrivilegedDatabaseDto)} beforehand.
-     * @throws ViewNotFoundException      The view with given name was not found.
-     */
-    List<ViewDto> getSchemas(PrivilegedDatabaseDto database) throws SQLException, DatabaseMalformedException,
-            ViewNotFoundException;
-
-    /**
-     * Creates a view if not already exists.
-     * @param database
-     * @param subset
-     * @return
-     * @throws ViewMalformedException
-     * @throws SQLException
-     */
-    ViewDto create(PrivilegedDatabaseDto database, QueryDto subset) throws ViewMalformedException, SQLException;
-
-    /**
-     * Creates a view in the given data database.
-     *
-     * @param database The data database.
-     * @param data     The view.
-     * @throws SQLException           The connection to the data database was unsuccessful.
-     * @throws ViewMalformedException The query is malformed and was rejected by the data database.
-     */
-    ViewDto create(PrivilegedDatabaseDto database, ViewCreateDto data) throws SQLException,
-            ViewMalformedException;
-
     /**
      * Deletes a view.
      *
-     * @param database The database.
-     * @param viewName The view name.
+     * @param view The view.
      * @throws SQLException           The connection to the data database was unsuccessful.
      * @throws ViewMalformedException The query is malformed and was rejected by the data database.
      */
-    void delete(PrivilegedDatabaseDto database, String viewName) throws SQLException, ViewMalformedException;
+    void delete(ViewDto view) throws SQLException, ViewMalformedException;
 
     /**
      * Counts tuples in a view at system-versioned timestamp.
@@ -71,5 +27,5 @@ public interface ViewService {
      * @throws SQLException            The connection to the data database was unsuccessful.
      * @throws QueryMalformedException The query is malformed and was rejected by the data database.
      */
-    Long count(PrivilegedViewDto view, Instant timestamp) throws SQLException, QueryMalformedException;
+    Long count(ViewDto view, Instant timestamp) throws SQLException, QueryMalformedException;
 }
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/AccessServiceMariaDbImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/AccessServiceMariaDbImpl.java
index c50ac2f0d6bc9f298dfc0a334d524f5e15a91170..16ace6dc9e68adf96762f8b5ef66fc1c02ad17af 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/AccessServiceMariaDbImpl.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/AccessServiceMariaDbImpl.java
@@ -1,8 +1,8 @@
 package at.tuwien.service.impl;
 
 import at.tuwien.api.database.AccessTypeDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.exception.DatabaseMalformedException;
 import at.tuwien.mapper.MariaDbMapper;
 import at.tuwien.service.AccessService;
@@ -17,7 +17,7 @@ import java.sql.SQLException;
 
 @Log4j2
 @Service
-public class AccessServiceMariaDbImpl extends HibernateConnector implements AccessService {
+public class AccessServiceMariaDbImpl extends DataConnector<DatabaseDto> implements AccessService {
 
     @Value("${dbrepo.grant.default.read}")
     private String grantDefaultRead;
@@ -33,9 +33,9 @@ public class AccessServiceMariaDbImpl extends HibernateConnector implements Acce
     }
 
     @Override
-    public void create(PrivilegedDatabaseDto database, PrivilegedUserDto user, AccessTypeDto access)
+    public void create(DatabaseDto database, UserDto user, AccessTypeDto access)
             throws SQLException, DatabaseMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             /* create user if not exists */
@@ -71,9 +71,9 @@ public class AccessServiceMariaDbImpl extends HibernateConnector implements Acce
     }
 
     @Override
-    public void update(PrivilegedDatabaseDto database, PrivilegedUserDto user, AccessTypeDto access)
+    public void update(DatabaseDto database, UserDto user, AccessTypeDto access)
             throws DatabaseMalformedException, SQLException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             /* grant access */
@@ -96,9 +96,9 @@ public class AccessServiceMariaDbImpl extends HibernateConnector implements Acce
     }
 
     @Override
-    public void delete(PrivilegedDatabaseDto database, PrivilegedUserDto user) throws DatabaseMalformedException,
+    public void delete(DatabaseDto database, UserDto user) throws DatabaseMalformedException,
             SQLException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             /* revoke access */
@@ -109,7 +109,7 @@ public class AccessServiceMariaDbImpl extends HibernateConnector implements Acce
             /* apply access rights */
             start = System.currentTimeMillis();
             connection.prepareStatement(mariaDbMapper.databaseFlushPrivilegesQuery())
-                            .execute();
+                    .execute();
             log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
             connection.commit();
         } catch (SQLException e) {
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/ContainerServiceMariaDbImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/ContainerServiceMariaDbImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc9b2d97c3a4a88342eaa44f5c9995a4b9f537e3
--- /dev/null
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/ContainerServiceMariaDbImpl.java
@@ -0,0 +1,103 @@
+package at.tuwien.service.impl;
+
+import at.tuwien.api.container.ContainerDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.internal.CreateDatabaseDto;
+import at.tuwien.api.user.UserBriefDto;
+import at.tuwien.config.RabbitConfig;
+import at.tuwien.exception.DatabaseMalformedException;
+import at.tuwien.exception.QueryStoreCreateException;
+import at.tuwien.mapper.MariaDbMapper;
+import at.tuwien.service.ContainerService;
+import com.mchange.v2.c3p0.ComboPooledDataSource;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+@Log4j2
+@Service
+public class ContainerServiceMariaDbImpl extends DataConnector<ContainerDto> implements ContainerService {
+
+    private final RabbitConfig rabbitConfig;
+    private final MariaDbMapper mariaDbMapper;
+
+    @Autowired
+    public ContainerServiceMariaDbImpl(RabbitConfig rabbitConfig, MariaDbMapper mariaDbMapper) {
+        this.rabbitConfig = rabbitConfig;
+        this.mariaDbMapper = mariaDbMapper;
+    }
+
+    @Override
+    public DatabaseDto createDatabase(ContainerDto container, CreateDatabaseDto data) throws SQLException,
+            DatabaseMalformedException {
+        final ComboPooledDataSource dataSource = getDataSource(container);
+        final Connection connection = dataSource.getConnection();
+        try {
+            /* create database if not exists */
+            final long start = System.currentTimeMillis();
+            connection.prepareStatement(mariaDbMapper.databaseCreateDatabaseQuery(data.getInternalName()))
+                    .execute();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            connection.commit();
+        } catch (SQLException e) {
+            connection.rollback();
+            log.error("Failed to create database access: {}", e.getMessage());
+            throw new DatabaseMalformedException("Failed to create database access: " + e.getMessage(), e);
+        } finally {
+            dataSource.close();
+        }
+        log.info("Created database with name {}", data.getInternalName());
+        return DatabaseDto.builder()
+                .internalName(data.getInternalName())
+                .exchangeName(rabbitConfig.getExchangeName())
+                .owner(UserBriefDto.builder()
+                        .id(data.getUserId())
+                        .build())
+                .contact(UserBriefDto.builder()
+                        .id(data.getUserId())
+                        .build())
+                .container(container)
+                .build();
+    }
+
+    @Override
+    public void createQueryStore(ContainerDto container, String databaseName) throws SQLException,
+            QueryStoreCreateException {
+        final ComboPooledDataSource dataSource = getDataSource(container, databaseName);
+        final Connection connection = dataSource.getConnection();
+        try {
+            /* create query store */
+            long start = System.currentTimeMillis();
+            connection.prepareStatement(mariaDbMapper.queryStoreCreateSequenceRawQuery())
+                    .execute();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            start = System.currentTimeMillis();
+            connection.prepareStatement(mariaDbMapper.queryStoreCreateTableRawQuery())
+                    .execute();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            start = System.currentTimeMillis();
+            connection.prepareStatement(mariaDbMapper.queryStoreCreateHashTableProcedureRawQuery())
+                    .execute();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            start = System.currentTimeMillis();
+            connection.prepareStatement(mariaDbMapper.queryStoreCreateStoreQueryProcedureRawQuery())
+                    .execute();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            start = System.currentTimeMillis();
+            connection.prepareStatement(mariaDbMapper.queryStoreCreateInternalStoreQueryProcedureRawQuery())
+                    .execute();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            connection.commit();
+        } catch (SQLException e) {
+            connection.rollback();
+            log.error("Failed to create query store: {}", e.getMessage());
+            throw new QueryStoreCreateException("Failed to create query store: " + e.getMessage(), e);
+        } finally {
+            dataSource.close();
+        }
+        log.info("Created query store in database with name {}", databaseName);
+    }
+}
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/CredentialServiceImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/CredentialServiceImpl.java
index 05b9e0a3feec4930111b5cdad5f839c132daaeac..fbc800bf4719bee556dc597ad593de93b8e9e0be 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/CredentialServiceImpl.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/CredentialServiceImpl.java
@@ -1,11 +1,11 @@
 package at.tuwien.service.impl;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
+import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.database.DatabaseAccessDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.ViewDto;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.api.user.UserDto;
 import at.tuwien.exception.*;
 import at.tuwien.gateway.MetadataServiceGateway;
 import at.tuwien.service.CredentialService;
@@ -21,19 +21,19 @@ import java.util.UUID;
 public class CredentialServiceImpl implements CredentialService {
 
     private final MetadataServiceGateway gateway;
-    private final Cache<UUID, PrivilegedUserDto> userCache;
-    private final Cache<Long, PrivilegedViewDto> viewCache;
+    private final Cache<UUID, UserDto> userCache;
+    private final Cache<Long, ViewDto> viewCache;
     private final Cache<Long, DatabaseAccessDto> accessCache;
-    private final Cache<Long, PrivilegedTableDto> tableCache;
-    private final Cache<Long, PrivilegedDatabaseDto> databaseCache;
-    private final Cache<Long, PrivilegedContainerDto> containerCache;
+    private final Cache<Long, TableDto> tableCache;
+    private final Cache<Long, DatabaseDto> databaseCache;
+    private final Cache<Long, ContainerDto> containerCache;
 
     @Autowired
-    public CredentialServiceImpl(MetadataServiceGateway gateway, Cache<UUID, PrivilegedUserDto> userCache,
-                                 Cache<Long, PrivilegedViewDto> viewCache, Cache<Long, DatabaseAccessDto> accessCache,
-                                 Cache<Long, PrivilegedTableDto> tableCache,
-                                 Cache<Long, PrivilegedDatabaseDto> databaseCache,
-                                 Cache<Long, PrivilegedContainerDto> containerCache) {
+    public CredentialServiceImpl(MetadataServiceGateway gateway, Cache<UUID, UserDto> userCache,
+                                 Cache<Long, ViewDto> viewCache, Cache<Long, DatabaseAccessDto> accessCache,
+                                 Cache<Long, TableDto> tableCache,
+                                 Cache<Long, DatabaseDto> databaseCache,
+                                 Cache<Long, ContainerDto> containerCache) {
         this.gateway = gateway;
         this.userCache = userCache;
         this.viewCache = viewCache;
@@ -44,29 +44,29 @@ public class CredentialServiceImpl implements CredentialService {
     }
 
     @Override
-    public PrivilegedDatabaseDto getDatabase(Long id) throws DatabaseNotFoundException, RemoteUnavailableException,
+    public DatabaseDto getDatabase(Long id) throws DatabaseNotFoundException, RemoteUnavailableException,
             MetadataServiceException {
-        final PrivilegedDatabaseDto cacheDatabase = databaseCache.getIfPresent(id);
+        final DatabaseDto cacheDatabase = databaseCache.getIfPresent(id);
         if (cacheDatabase != null) {
             log.trace("found database with id {} in cache", id);
             return cacheDatabase;
         }
         log.debug("database with id {} not it cache (anymore): reload from metadata service", id);
-        final PrivilegedDatabaseDto database = gateway.getDatabaseById(id);
+        final DatabaseDto database = gateway.getDatabaseById(id);
         databaseCache.put(id, database);
         return database;
     }
 
     @Override
-    public PrivilegedTableDto getTable(Long databaseId, Long tableId) throws RemoteUnavailableException,
+    public TableDto getTable(Long databaseId, Long tableId) throws RemoteUnavailableException,
             MetadataServiceException, TableNotFoundException {
-        final PrivilegedTableDto cacheTable = tableCache.getIfPresent(tableId);
+        final TableDto cacheTable = tableCache.getIfPresent(tableId);
         if (cacheTable != null) {
             log.trace("found table with id {} in cache", tableId);
             return cacheTable;
         }
         log.debug("table with id {} not it cache (anymore): reload from metadata service", tableId);
-        final PrivilegedTableDto table = gateway.getTableById(databaseId, tableId);
+        final TableDto table = gateway.getTableById(databaseId, tableId);
         tableCache.put(tableId, table);
         return table;
     }
@@ -78,43 +78,43 @@ public class CredentialServiceImpl implements CredentialService {
     }
 
     @Override
-    public PrivilegedContainerDto getContainer(Long id) throws RemoteUnavailableException, MetadataServiceException,
+    public ContainerDto getContainer(Long id) throws RemoteUnavailableException, MetadataServiceException,
             ContainerNotFoundException {
-        final PrivilegedContainerDto cacheContainer = containerCache.getIfPresent(id);
+        final ContainerDto cacheContainer = containerCache.getIfPresent(id);
         if (cacheContainer != null) {
             log.trace("found container with id {} in cache", id);
             return cacheContainer;
         }
         log.debug("container with id {} not it cache (anymore): reload from metadata service", id);
-        final PrivilegedContainerDto container = gateway.getContainerById(id);
+        final ContainerDto container = gateway.getContainerById(id);
         containerCache.put(id, container);
         return container;
     }
 
     @Override
-    public PrivilegedViewDto getView(Long databaseId, Long viewId) throws RemoteUnavailableException,
+    public ViewDto getView(Long databaseId, Long viewId) throws RemoteUnavailableException,
             MetadataServiceException, ViewNotFoundException {
-        final PrivilegedViewDto cacheView = viewCache.getIfPresent(viewId);
+        final ViewDto cacheView = viewCache.getIfPresent(viewId);
         if (cacheView != null) {
             log.trace("found view with id {} in cache", viewId);
             return cacheView;
         }
         log.debug("view with id {} not it cache (anymore): reload from metadata service", viewId);
-        final PrivilegedViewDto view = gateway.getViewById(databaseId, viewId);
+        final ViewDto view = gateway.getViewById(databaseId, viewId);
         viewCache.put(viewId, view);
         return view;
     }
 
     @Override
-    public PrivilegedUserDto getUser(UUID id) throws RemoteUnavailableException, MetadataServiceException,
+    public UserDto getUser(UUID id) throws RemoteUnavailableException, MetadataServiceException,
             UserNotFoundException {
-        final PrivilegedUserDto cacheUser = userCache.getIfPresent(id);
+        final UserDto cacheUser = userCache.getIfPresent(id);
         if (cacheUser != null) {
             log.trace("found user with id {} in cache", id);
             return cacheUser;
         }
         log.debug("user with id {} not it cache (anymore): reload from metadata service", id);
-        final PrivilegedUserDto user = gateway.getPrivilegedUserById(id);
+        final UserDto user = gateway.getUserById(id);
         userCache.put(id, user);
         return user;
     }
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/DataConnector.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/DataConnector.java
new file mode 100644
index 0000000000000000000000000000000000000000..9fbee30fa6b91df13075d2895ab3921e36893dc8
--- /dev/null
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/DataConnector.java
@@ -0,0 +1,66 @@
+package at.tuwien.service.impl;
+
+import at.tuwien.api.CacheableDto;
+import com.mchange.v2.c3p0.ComboPooledDataSource;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.stereotype.Service;
+
+@Log4j2
+@Service
+public abstract class DataConnector<T extends CacheableDto> {
+
+    public ComboPooledDataSource getDataSource(T entity) {
+        final long start = System.currentTimeMillis();
+        final ComboPooledDataSource dataSource = new ComboPooledDataSource();
+        dataSource.setJdbcUrl(getJdbcUrl(entity.getJdbcMethod(), entity.getHost(), entity.getPassword(),
+                entity.getDatabase()));
+        dataSource.setUser(entity.getUsername());
+        dataSource.setPassword(entity.getPassword());
+        dataSource.setInitialPoolSize(5);
+        dataSource.setMinPoolSize(5);
+        dataSource.setAcquireIncrement(5);
+        dataSource.setMaxPoolSize(20);
+        dataSource.setMaxStatements(100);
+        return dataSource;
+    }
+
+    public ComboPooledDataSource getDataSource(T entity, String databaseName) {
+        final long start = System.currentTimeMillis();
+        final ComboPooledDataSource dataSource = new ComboPooledDataSource();
+        dataSource.setJdbcUrl(getJdbcUrl(entity.getJdbcMethod(), entity.getHost(), entity.getPassword(), databaseName));
+        dataSource.setUser(entity.getUsername());
+        dataSource.setPassword(entity.getPassword());
+        dataSource.setInitialPoolSize(5);
+        dataSource.setMinPoolSize(5);
+        dataSource.setAcquireIncrement(5);
+        dataSource.setMaxPoolSize(20);
+        dataSource.setMaxStatements(100);
+        return dataSource;
+    }
+
+    public String getSparkUrl(String jdbcMethod, String host, String password, String databaseName) {
+        final StringBuilder sb = new StringBuilder(getJdbcUrl(jdbcMethod, host, password, databaseName))
+                .append("?sessionVariables=sql_mode='ANSI_QUOTES'");
+        log.trace("mapped container to spark url: {}", sb.toString());
+        return sb.toString();
+    }
+
+    public String getSparkUrl(T entity) {
+        return getSparkUrl(entity.getJdbcMethod(), entity.getHost(), entity.getPassword(), entity.getDatabase());
+    }
+
+    public String getJdbcUrl(String jdbcMethod, String host, String password, String databaseName) {
+        final StringBuilder stringBuilder = new StringBuilder("jdbc:")
+                .append(jdbcMethod)
+                .append("://")
+                .append(host)
+                .append(":")
+                .append(password);
+        if (databaseName != null) {
+            stringBuilder.append("/")
+                    .append(databaseName);
+        }
+        return stringBuilder.toString();
+    }
+
+}
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/DatabaseServiceMariaDbImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/DatabaseServiceMariaDbImpl.java
index a15c22f55e9c7731de47e81d114431961114877d..2b5af71d1c98d51d656fecb1f32430c7baae1c96 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/DatabaseServiceMariaDbImpl.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/DatabaseServiceMariaDbImpl.java
@@ -1,72 +1,353 @@
 package at.tuwien.service.impl;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
-import at.tuwien.api.database.internal.CreateDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.user.UserBriefDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.ViewCreateDto;
+import at.tuwien.api.database.ViewDto;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.api.database.table.constraints.unique.UniqueDto;
+import at.tuwien.api.database.table.internal.TableCreateDto;
 import at.tuwien.api.user.internal.UpdateUserPasswordDto;
-import at.tuwien.config.RabbitConfig;
-import at.tuwien.exception.DatabaseMalformedException;
+import at.tuwien.config.QueryConfig;
+import at.tuwien.exception.*;
+import at.tuwien.mapper.DataMapper;
 import at.tuwien.mapper.MariaDbMapper;
+import at.tuwien.mapper.MetadataMapper;
 import at.tuwien.service.DatabaseService;
+import at.tuwien.service.TableService;
+import at.tuwien.service.ViewService;
+import com.google.common.hash.Hashing;
 import com.mchange.v2.c3p0.ComboPooledDataSource;
 import lombok.extern.log4j.Log4j2;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 
+import java.nio.charset.StandardCharsets;
 import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.LinkedList;
+import java.util.List;
 
 @Log4j2
 @Service
-public class DatabaseServiceMariaDbImpl extends HibernateConnector implements DatabaseService {
+public class DatabaseServiceMariaDbImpl extends DataConnector<DatabaseDto> implements DatabaseService {
 
-    private final RabbitConfig rabbitConfig;
+    private final DataMapper dataMapper;
+    private final QueryConfig queryConfig;
+    private final ViewService viewService;
+    private final TableService tableService;
     private final MariaDbMapper mariaDbMapper;
+    private final MetadataMapper metadataMapper;
 
     @Autowired
-    public DatabaseServiceMariaDbImpl(RabbitConfig rabbitConfig, MariaDbMapper mariaDbMapper) {
-        this.rabbitConfig = rabbitConfig;
+    public DatabaseServiceMariaDbImpl(DataMapper dataMapper, QueryConfig queryConfig, ViewService viewService,
+                                      TableService tableService, MariaDbMapper mariaDbMapper,
+                                      @Qualifier("metadataMapper") MetadataMapper metadataMapper) {
+        this.dataMapper = dataMapper;
+        this.queryConfig = queryConfig;
+        this.viewService = viewService;
+        this.tableService = tableService;
         this.mariaDbMapper = mariaDbMapper;
+        this.metadataMapper = metadataMapper;
     }
 
     @Override
-    public PrivilegedDatabaseDto create(PrivilegedContainerDto container, CreateDatabaseDto data) throws SQLException,
-            DatabaseMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(container, null);
+    public ViewDto inspectView(DatabaseDto database, String viewName) throws SQLException, ViewNotFoundException {
+        final ComboPooledDataSource dataSource = getDataSource(database);
+        final Connection connection = dataSource.getConnection();
+        try {
+            /* obtain only view metadata */
+            long start = System.currentTimeMillis();
+            final PreparedStatement statement1 = connection.prepareStatement(mariaDbMapper.databaseViewSelectRawQuery());
+            statement1.setString(1, database.getInternalName());
+            statement1.setString(2, viewName);
+            log.trace("1={}, 2={}", database.getInternalName(), viewName);
+            final ResultSet resultSet1 = statement1.executeQuery();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            if (!resultSet1.next()) {
+                throw new ViewNotFoundException("Failed to find view in the information schema");
+            }
+            final ViewDto view = dataMapper.schemaResultSetToView(database, resultSet1);
+            view.setVdbid(database.getId());
+            view.setOwner(database.getOwner());
+            /* obtain view columns */
+            start = System.currentTimeMillis();
+            final PreparedStatement statement2 = connection.prepareStatement(mariaDbMapper.databaseTableColumnsSelectRawQuery());
+            statement2.setString(1, database.getInternalName());
+            statement2.setString(2, view.getInternalName());
+            log.trace("1={}, 2={}", database.getInternalName(), view.getInternalName());
+            final ResultSet resultSet2 = statement2.executeQuery();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            TableDto tmp = TableDto.builder()
+                    .columns(new LinkedList<>())
+                    .build();
+            while (resultSet2.next()) {
+                tmp = dataMapper.resultSetToTable(resultSet2, tmp);
+            }
+            view.setColumns(tmp.getColumns()
+                    .stream()
+                    .map(metadataMapper::columnDtoToViewColumnDto)
+                    .toList());
+            view.getColumns()
+                    .forEach(column -> column.setDatabaseId(database.getId()));
+            log.debug("obtained metadata for view {}.{}", database.getInternalName(), view.getInternalName());
+            return view;
+        } finally {
+            dataSource.close();
+        }
+    }
+
+    @Override
+    public TableDto createTable(DatabaseDto database, TableCreateDto data) throws SQLException,
+            TableMalformedException, TableExistsException {
+        final String tableName = mariaDbMapper.nameToInternalName(data.getName());
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
-            /* create database if not exists */
+            /* create table if not exists */
             final long start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.databaseCreateDatabaseQuery(data.getInternalName()))
+            connection.prepareStatement(mariaDbMapper.tableCreateDtoToCreateTableRawQuery(data))
                     .execute();
             log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
             connection.commit();
         } catch (SQLException e) {
             connection.rollback();
-            log.error("Failed to create database access: {}", e.getMessage());
-            throw new DatabaseMalformedException("Failed to create database access: " + e.getMessage(), e);
+            if (e.getMessage().contains("already exists")) {
+                log.error("Failed to create table: already exists");
+                throw new TableExistsException("Failed to create table: already exists", e);
+            }
+            log.error("Failed to create table: {}", e.getMessage());
+            throw new TableMalformedException("Failed to create table: " + e.getMessage(), e);
+        } finally {
+            dataSource.close();
+        }
+        log.info("Created table with name {}", tableName);
+        final TableDto table = metadataMapper.databaseDtoToTableDto(database);
+        table.setInternalName(tableName);
+        return table;
+    }
+
+    @Override
+    public Boolean existsView(DatabaseDto database, String viewName) throws SQLException,
+            QueryMalformedException {
+        final ComboPooledDataSource dataSource = getDataSource(database);
+        final Connection connection = dataSource.getConnection();
+        final Boolean queryResult;
+        try {
+            /* find view data */
+            final long start = System.currentTimeMillis();
+            final PreparedStatement statement = connection.prepareStatement(mariaDbMapper.selectExistsTableOrViewRawQuery());
+            statement.setString(1, database.getInternalName());
+            statement.setString(2, viewName);
+            final ResultSet resultSet = statement.executeQuery();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            queryResult = mariaDbMapper.resultSetToBoolean(resultSet);
+        } catch (SQLException e) {
+            log.error("Failed to prepare statement {}", e.getMessage());
+            throw new QueryMalformedException("Failed to prepare statement: " + e.getMessage(), e);
         } finally {
             dataSource.close();
         }
-        log.info("Created database with name {}", data.getInternalName());
-        return PrivilegedDatabaseDto.builder()
-                .internalName(data.getInternalName())
-                .exchangeName(rabbitConfig.getExchangeName())
-                .owner(UserBriefDto.builder()
-                        .id(data.getUserId())
-                        .build())
-                .contact(UserBriefDto.builder()
-                        .id(data.getUserId())
-                        .build())
-                .container(container)
+        return queryResult;
+    }
+
+    @Override
+    public ViewDto createView(DatabaseDto database, ViewCreateDto data) throws SQLException,
+            ViewMalformedException {
+        final ComboPooledDataSource dataSource = getDataSource(database);
+        final Connection connection = dataSource.getConnection();
+        ViewDto view = ViewDto.builder()
+                .name(data.getName())
+                .internalName(mariaDbMapper.nameToInternalName(data.getName()))
+                .query(data.getQuery())
+                .queryHash(Hashing.sha256()
+                        .hashString(data.getQuery(), StandardCharsets.UTF_8)
+                        .toString())
+                .isPublic(database.getIsPublic())
+                .owner(database.getOwner())
+                .identifiers(new LinkedList<>())
+                .isInitialView(false)
+                .vdbid(database.getId())
+                .columns(new LinkedList<>())
                 .build();
+        try {
+            /* create view if not exists */
+            final long start = System.currentTimeMillis();
+            connection.prepareStatement(mariaDbMapper.viewCreateRawQuery(view.getInternalName(), data.getQuery()))
+                    .execute();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            /* select view columns */
+            final PreparedStatement statement2 = connection.prepareStatement(mariaDbMapper.databaseTableColumnsSelectRawQuery());
+            statement2.setString(1, database.getInternalName());
+            statement2.setString(2, view.getInternalName());
+            final ResultSet resultSet2 = statement2.executeQuery();
+            while (resultSet2.next()) {
+                view = dataMapper.resultSetToTable(resultSet2, view, queryConfig);
+            }
+            connection.commit();
+        } catch (SQLException e) {
+            connection.rollback();
+            log.error("Failed to create view: {}", e.getMessage());
+            throw new ViewMalformedException("Failed to create view: " + e.getMessage(), e);
+        } finally {
+            dataSource.close();
+        }
+        log.info("Created view with name {}", view.getName());
+        return view;
+    }
+
+    @Override
+    public List<ViewDto> exploreViews(DatabaseDto database) throws SQLException, DatabaseMalformedException,
+            ViewNotFoundException {
+        final ComboPooledDataSource dataSource = getDataSource(database);
+        final Connection connection = dataSource.getConnection();
+        final List<ViewDto> views = new LinkedList<>();
+        try {
+            /* inspect tables before views */
+            final PreparedStatement statement = connection.prepareStatement(mariaDbMapper.databaseViewsSelectRawQuery());
+            statement.setString(1, database.getInternalName());
+            final long start = System.currentTimeMillis();
+            final ResultSet resultSet1 = statement.executeQuery();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            while (resultSet1.next()) {
+                final String viewName = resultSet1.getString(1);
+                if (viewName.length() == 64) {
+                    log.trace("view {}.{} seems to be a subset view (name length = 64), skip.", database.getInternalName(), viewName);
+                    continue;
+                }
+                if (database.getViews().stream().anyMatch(v -> v.getInternalName().equals(viewName))) {
+                    log.trace("view {}.{} already known to metadata database, skip.", database.getInternalName(), viewName);
+                    continue;
+                }
+                if (database.getTables().stream().noneMatch(t -> t.getInternalName().equals(viewName))) {
+                    views.add(inspectView(database, viewName));
+                }
+            }
+        } catch (SQLException e) {
+            log.error("Failed to get view schemas: {}", e.getMessage());
+            throw new DatabaseMalformedException("Failed to get view schemas: " + e.getMessage(), e);
+        } finally {
+            dataSource.close();
+        }
+        log.info("Found {} view schema(s)", views.size());
+        return views;
+    }
+
+    @Override
+    public List<TableDto> exploreTables(DatabaseDto database) throws SQLException, TableNotFoundException,
+            DatabaseMalformedException {
+        final ComboPooledDataSource dataSource = getDataSource(database);
+        final Connection connection = dataSource.getConnection();
+        final List<TableDto> tables = new LinkedList<>();
+        try {
+            /* inspect tables before views */
+            final long start = System.currentTimeMillis();
+            final PreparedStatement statement = connection.prepareStatement(mariaDbMapper.databaseTablesSelectRawQuery());
+            statement.setString(1, database.getInternalName());
+            final ResultSet resultSet1 = statement.executeQuery();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            while (resultSet1.next()) {
+                final String tableName = resultSet1.getString(1);
+                if (database.getTables().stream().anyMatch(t -> t.getInternalName().equals(tableName))) {
+                    log.trace("view {}.{} already known to metadata database, skip.", database.getInternalName(), tableName);
+                    continue;
+                }
+                final TableDto table = inspectTable(database, tableName);
+                if (database.getTables().stream().noneMatch(t -> t.getInternalName().equals(tableName))) {
+                    tables.add(table);
+                }
+            }
+        } catch (SQLException e) {
+            log.error("Failed to get table schemas: {}", e.getMessage());
+            throw new DatabaseMalformedException("Failed to get table schemas: " + e.getMessage(), e);
+        } finally {
+            dataSource.close();
+        }
+        log.info("Found {} table schema(s)", tables.size());
+        return tables;
+    }
+
+    @Override
+    public TableDto inspectTable(DatabaseDto database, String tableName) throws SQLException, TableNotFoundException {
+        log.trace("inspecting table: {}.{}", database.getInternalName(), tableName);
+        final ComboPooledDataSource dataSource = getDataSource(database);
+        final Connection connection = dataSource.getConnection();
+        try {
+            /* obtain only table metadata */
+            long start = System.currentTimeMillis();
+            final PreparedStatement statement1 = connection.prepareStatement(mariaDbMapper.databaseTableSelectRawQuery());
+            statement1.setString(1, database.getInternalName());
+            statement1.setString(2, tableName);
+            log.trace("1={}, 2={}", database.getInternalName(), tableName);
+            TableDto table = dataMapper.schemaResultSetToTable(database, statement1.executeQuery());
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            /* obtain columns metadata */
+            start = System.currentTimeMillis();
+            final PreparedStatement statement2 = connection.prepareStatement(mariaDbMapper.databaseTableColumnsSelectRawQuery());
+            statement2.setString(1, database.getInternalName());
+            statement2.setString(2, tableName);
+            log.trace("1={}, 2={}", database.getInternalName(), tableName);
+            final ResultSet resultSet2 = statement2.executeQuery();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            while (resultSet2.next()) {
+                table = dataMapper.resultSetToTable(resultSet2, table);
+            }
+            /* obtain check constraints metadata */
+            start = System.currentTimeMillis();
+            final PreparedStatement statement3 = connection.prepareStatement(mariaDbMapper.columnsCheckConstraintSelectRawQuery());
+            statement3.setString(1, database.getInternalName());
+            statement3.setString(2, tableName);
+            log.trace("1={}, 2={}", database.getInternalName(), tableName);
+            final ResultSet resultSet3 = statement3.executeQuery();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            while (resultSet3.next()) {
+                final String clause = resultSet3.getString(1);
+                table.getConstraints()
+                        .getChecks()
+                        .add(clause);
+                log.trace("found check clause: {}", clause);
+            }
+            /* obtain column constraints metadata */
+            start = System.currentTimeMillis();
+            final PreparedStatement statement4 = connection.prepareStatement(mariaDbMapper.databaseTableConstraintsSelectRawQuery());
+            statement4.setString(1, database.getInternalName());
+            statement4.setString(2, tableName);
+            log.trace("1={}, 2={}", database.getInternalName(), tableName);
+            final ResultSet resultSet4 = statement4.executeQuery();
+            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
+            while (resultSet4.next()) {
+                table = dataMapper.resultSetToConstraint(resultSet4, table);
+                for (UniqueDto uk : table.getConstraints().getUniques()) {
+                    uk.setTable(metadataMapper.tableDtoToTableBriefDto(table));
+                    final TableDto tmpTable = table;
+                    uk.getColumns()
+                            .forEach(column -> {
+                                column.setTableId(tmpTable.getId());
+                                column.setDatabaseId(database.getId());
+                            });
+                }
+            }
+            table.setTdbid(database.getId());
+            table.setOwner(database.getOwner());
+            final TableDto tmpTable = table;
+            tmpTable.getColumns()
+                    .forEach(column -> {
+                        column.setTableId(tmpTable.getId());
+                        column.setDatabaseId(database.getId());
+                    });
+            log.debug("obtained metadata for table {}.{}", database.getInternalName(), tableName);
+            return tmpTable;
+        } finally {
+            dataSource.close();
+        }
     }
 
     @Override
-    public void update(PrivilegedDatabaseDto database, UpdateUserPasswordDto data) throws SQLException,
+    public void update(DatabaseDto database, UpdateUserPasswordDto data) throws SQLException,
             DatabaseMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             /* update user password */
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/HibernateConnector.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/HibernateConnector.java
deleted file mode 100644
index 242cefd557cfd68ef95a0b06b5ac4efb91ed83f1..0000000000000000000000000000000000000000
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/HibernateConnector.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package at.tuwien.service.impl;
-
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import com.mchange.v2.c3p0.ComboPooledDataSource;
-import lombok.extern.log4j.Log4j2;
-import org.springframework.stereotype.Service;
-
-@Log4j2
-@Service
-public abstract class HibernateConnector {
-
-    public ComboPooledDataSource getPrivilegedDataSource(PrivilegedContainerDto container, String databaseName) {
-        final long start = System.currentTimeMillis();
-        final ComboPooledDataSource dataSource = new ComboPooledDataSource();
-        dataSource.setJdbcUrl(url(container, databaseName));
-        dataSource.setUser(container.getUsername());
-        dataSource.setPassword(container.getPassword());
-        dataSource.setInitialPoolSize(5);
-        dataSource.setMinPoolSize(5);
-        dataSource.setAcquireIncrement(5);
-        dataSource.setMaxPoolSize(20);
-        dataSource.setMaxStatements(100);
-        log.trace("created pooled data source {} in {} ms, user={}", url(container, databaseName), System.currentTimeMillis() - start, container.getUsername());
-        return dataSource;
-    }
-
-    public ComboPooledDataSource getPrivilegedDataSource(PrivilegedDatabaseDto database) {
-        return getPrivilegedDataSource(database.getContainer(), database.getInternalName());
-    }
-
-    public String getSparkUrl(PrivilegedContainerDto container, String databaseName) {
-        final StringBuilder sb = new StringBuilder(url(container, databaseName))
-                .append("?sessionVariables=sql_mode='ANSI_QUOTES'");
-        log.trace("mapped container to spark url: {}", sb.toString());
-        return sb.toString();
-    }
-
-    private String url(PrivilegedContainerDto container, String databaseName) {
-        final StringBuilder stringBuilder = new StringBuilder("jdbc:")
-                .append(container.getImage().getJdbcMethod())
-                .append("://")
-                .append(container.getHost())
-                .append(":")
-                .append(container.getPort());
-        if (databaseName != null) {
-            stringBuilder.append("/")
-                    .append(databaseName);
-        }
-        return stringBuilder.toString();
-    }
-
-}
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/QueueServiceRabbitMqImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/QueueServiceRabbitMqImpl.java
index d5127e050e521b69e5130c4af836680ffaae013d..1a26a84ef68fb6e0626ece50dff129a8fb449135 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/QueueServiceRabbitMqImpl.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/QueueServiceRabbitMqImpl.java
@@ -1,7 +1,7 @@
 package at.tuwien.service.impl;
 
+import at.tuwien.api.database.table.TableDto;
 import at.tuwien.api.database.table.columns.ColumnDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import at.tuwien.mapper.DataMapper;
 import at.tuwien.mapper.MetadataMapper;
 import at.tuwien.service.QueueService;
@@ -18,7 +18,7 @@ import java.util.Optional;
 
 @Log4j2
 @Service
-public class QueueServiceRabbitMqImpl extends HibernateConnector implements QueueService {
+public class QueueServiceRabbitMqImpl extends DataConnector<TableDto> implements QueueService {
 
     private final DataMapper dataMapper;
     private final MetadataMapper metadataMapper;
@@ -30,13 +30,13 @@ public class QueueServiceRabbitMqImpl extends HibernateConnector implements Queu
     }
 
     @Override
-    public void insert(PrivilegedTableDto table, Map<String, Object> data) throws SQLException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+    public void insert(TableDto table, Map<String, Object> data) throws SQLException {
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         try {
             final int[] idx = new int[]{1};
             final PreparedStatement preparedStatement = connection.prepareStatement(
-                    dataMapper.rabbitMqTupleToInsertOrUpdateQuery(metadataMapper.privilegedTableDtoToTableDto(table), data));
+                    dataMapper.rabbitMqTupleToInsertOrUpdateQuery(metadataMapper.tableDtoToTableDto(table), data));
             for (Map.Entry<String, Object> entry : data.entrySet()) {
                 final Optional<ColumnDto> optional = table.getColumns().stream().filter(c -> c.getInternalName().equals(entry.getKey())).findFirst();
                 if (optional.isEmpty()) {
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/SchemaServiceMariaDbImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/SchemaServiceMariaDbImpl.java
deleted file mode 100644
index e2b0c984e0f53c68bf9d384a301ab62ad67bbff7..0000000000000000000000000000000000000000
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/SchemaServiceMariaDbImpl.java
+++ /dev/null
@@ -1,164 +0,0 @@
-package at.tuwien.service.impl;
-
-import at.tuwien.api.database.DatabaseDto;
-import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.table.TableDto;
-import at.tuwien.api.database.table.constraints.unique.UniqueDto;
-import at.tuwien.exception.TableNotFoundException;
-import at.tuwien.exception.ViewNotFoundException;
-import at.tuwien.mapper.DataMapper;
-import at.tuwien.mapper.MariaDbMapper;
-import at.tuwien.mapper.MetadataMapper;
-import at.tuwien.service.SchemaService;
-import com.mchange.v2.c3p0.ComboPooledDataSource;
-import lombok.extern.log4j.Log4j2;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.LinkedList;
-
-@Log4j2
-@Service
-public class SchemaServiceMariaDbImpl extends HibernateConnector implements SchemaService {
-
-    private final DataMapper dataMapper;
-    private final MariaDbMapper mariaDbMapper;
-    private final MetadataMapper metadataMapper;
-
-    @Autowired
-    public SchemaServiceMariaDbImpl(DataMapper dataMapper, MariaDbMapper mariaDbMapper, MetadataMapper metadataMapper) {
-        this.dataMapper = dataMapper;
-        this.mariaDbMapper = mariaDbMapper;
-        this.metadataMapper = metadataMapper;
-    }
-
-    @Override
-    public TableDto inspectTable(PrivilegedDatabaseDto database, String tableName) throws SQLException,
-            TableNotFoundException {
-        log.trace("inspecting table: {}.{}", database.getInternalName(), tableName);
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
-        final Connection connection = dataSource.getConnection();
-        try {
-            /* obtain only table metadata */
-            long start = System.currentTimeMillis();
-            final PreparedStatement statement1 = connection.prepareStatement(mariaDbMapper.databaseTableSelectRawQuery());
-            statement1.setString(1, database.getInternalName());
-            statement1.setString(2, tableName);
-            log.trace("1={}, 2={}", database.getInternalName(), tableName);
-            TableDto table = dataMapper.schemaResultSetToTable(metadataMapper.privilegedDatabaseDtoToDatabaseDto(database), statement1.executeQuery());
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            /* obtain columns metadata */
-            start = System.currentTimeMillis();
-            final PreparedStatement statement2 = connection.prepareStatement(mariaDbMapper.databaseTableColumnsSelectRawQuery());
-            statement2.setString(1, database.getInternalName());
-            statement2.setString(2, tableName);
-            log.trace("1={}, 2={}", database.getInternalName(), tableName);
-            final ResultSet resultSet2 = statement2.executeQuery();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            while (resultSet2.next()) {
-                table = dataMapper.resultSetToTable(resultSet2, table);
-            }
-            /* obtain check constraints metadata */
-            start = System.currentTimeMillis();
-            final PreparedStatement statement3 = connection.prepareStatement(mariaDbMapper.columnsCheckConstraintSelectRawQuery());
-            statement3.setString(1, database.getInternalName());
-            statement3.setString(2, tableName);
-            log.trace("1={}, 2={}", database.getInternalName(), tableName);
-            final ResultSet resultSet3 = statement3.executeQuery();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            while (resultSet3.next()) {
-                final String clause = resultSet3.getString(1);
-                table.getConstraints()
-                        .getChecks()
-                        .add(clause);
-                log.trace("found check clause: {}", clause);
-            }
-            /* obtain column constraints metadata */
-            start = System.currentTimeMillis();
-            final PreparedStatement statement4 = connection.prepareStatement(mariaDbMapper.databaseTableConstraintsSelectRawQuery());
-            statement4.setString(1, database.getInternalName());
-            statement4.setString(2, tableName);
-            log.trace("1={}, 2={}", database.getInternalName(), tableName);
-            final ResultSet resultSet4 = statement4.executeQuery();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            while (resultSet4.next()) {
-                table = dataMapper.resultSetToConstraint(resultSet4, table);
-                for (UniqueDto uk : table.getConstraints().getUniques()) {
-                    uk.setTable(metadataMapper.tableDtoToTableBriefDto(table));
-                    final TableDto tmpTable = table;
-                    uk.getColumns()
-                            .forEach(column -> {
-                                column.setTableId(tmpTable.getId());
-                                column.setDatabaseId(database.getId());
-                            });
-                }
-            }
-            table.setTdbid(database.getId());
-            table.setOwner(database.getOwner());
-            final TableDto tmpTable = table;
-            tmpTable.getColumns()
-                    .forEach(column -> {
-                        column.setTableId(tmpTable.getId());
-                        column.setDatabaseId(database.getId());
-                    });
-            log.debug("obtained metadata for table {}.{}", database.getInternalName(), tableName);
-            return tmpTable;
-        } finally {
-            dataSource.close();
-        }
-    }
-
-    @Override
-    public ViewDto inspectView(PrivilegedDatabaseDto privilegedDatabase, String viewName) throws SQLException,
-            ViewNotFoundException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(privilegedDatabase);
-        final Connection connection = dataSource.getConnection();
-        final DatabaseDto database = metadataMapper.privilegedDatabaseDtoToDatabaseDto(privilegedDatabase);
-        try {
-            /* obtain only view metadata */
-            long start = System.currentTimeMillis();
-            final PreparedStatement statement1 = connection.prepareStatement(mariaDbMapper.databaseViewSelectRawQuery());
-            statement1.setString(1, database.getInternalName());
-            statement1.setString(2, viewName);
-            log.trace("1={}, 2={}", database.getInternalName(), viewName);
-            final ResultSet resultSet1 = statement1.executeQuery();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            if (!resultSet1.next()) {
-                throw new ViewNotFoundException("Failed to find view in the information schema");
-            }
-            ViewDto view = dataMapper.schemaResultSetToView(database, resultSet1);
-            view.setVdbid(database.getId());
-            view.setOwner(database.getOwner());
-            /* obtain view columns */
-            start = System.currentTimeMillis();
-            final PreparedStatement statement2 = connection.prepareStatement(mariaDbMapper.databaseTableColumnsSelectRawQuery());
-            statement2.setString(1, database.getInternalName());
-            statement2.setString(2, viewName);
-            log.trace("1={}, 2={}", database.getInternalName(), viewName);
-            final ResultSet resultSet2 = statement2.executeQuery();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            TableDto tmp = TableDto.builder()
-                    .columns(new LinkedList<>())
-                    .build();
-            while (resultSet2.next()) {
-                tmp = dataMapper.resultSetToTable(resultSet2, tmp);
-            }
-            view.setColumns(tmp.getColumns()
-                    .stream()
-                    .map(metadataMapper::columnDtoToViewColumnDto)
-                    .toList());
-            view.getColumns()
-                    .forEach(column -> column.setDatabaseId(database.getId()));
-            log.debug("obtained metadata for view {}.{}", database.getInternalName(), viewName);
-            return view;
-        } finally {
-            dataSource.close();
-        }
-    }
-
-}
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/SubsetServiceMariaDbImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/SubsetServiceMariaDbImpl.java
index fb244bb30113ab90f4f2209bf4e80b5d11cd9185..62b7c77a845d6d1ed6e317d43bbc1a18ae9943d7 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/SubsetServiceMariaDbImpl.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/SubsetServiceMariaDbImpl.java
@@ -1,7 +1,7 @@
 package at.tuwien.service.impl;
 
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
+import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.ViewCreateDto;
 import at.tuwien.api.database.query.QueryDto;
 import at.tuwien.api.identifier.IdentifierBriefDto;
 import at.tuwien.api.identifier.IdentifierTypeDto;
@@ -10,6 +10,7 @@ import at.tuwien.gateway.MetadataServiceGateway;
 import at.tuwien.mapper.DataMapper;
 import at.tuwien.mapper.MariaDbMapper;
 import at.tuwien.mapper.MetadataMapper;
+import at.tuwien.service.DatabaseService;
 import at.tuwien.service.SubsetService;
 import at.tuwien.service.TableService;
 import at.tuwien.service.ViewService;
@@ -28,72 +29,41 @@ import java.util.UUID;
 
 @Log4j2
 @Service
-public class SubsetServiceMariaDbImpl extends HibernateConnector implements SubsetService {
+public class SubsetServiceMariaDbImpl extends DataConnector<DatabaseDto> implements SubsetService {
 
     private final DataMapper dataMapper;
     private final ViewService viewService;
     private final TableService tableService;
     private final MariaDbMapper mariaDbMapper;
     private final MetadataMapper metadataMapper;
+    private final DatabaseService databaseService;
     private final MetadataServiceGateway metadataServiceGateway;
 
     @Autowired
     public SubsetServiceMariaDbImpl(DataMapper dataMapper, ViewService viewService, TableService tableService,
                                     MariaDbMapper mariaDbMapper, MetadataMapper metadataMapper,
-                                    MetadataServiceGateway metadataServiceGateway) {
+                                    DatabaseService databaseService, MetadataServiceGateway metadataServiceGateway) {
         this.dataMapper = dataMapper;
         this.viewService = viewService;
         this.tableService = tableService;
         this.mariaDbMapper = mariaDbMapper;
         this.metadataMapper = metadataMapper;
+        this.databaseService = databaseService;
         this.metadataServiceGateway = metadataServiceGateway;
     }
 
     @Override
-    public void createQueryStore(PrivilegedContainerDto container, String databaseName) throws SQLException,
-            QueryStoreCreateException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(container, databaseName);
-        final Connection connection = dataSource.getConnection();
-        try {
-            /* create query store */
-            long start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.queryStoreCreateSequenceRawQuery())
-                    .execute();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.queryStoreCreateTableRawQuery())
-                    .execute();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.queryStoreCreateHashTableProcedureRawQuery())
-                    .execute();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.queryStoreCreateStoreQueryProcedureRawQuery())
-                    .execute();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.queryStoreCreateInternalStoreQueryProcedureRawQuery())
-                    .execute();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            connection.commit();
-        } catch (SQLException e) {
-            connection.rollback();
-            log.error("Failed to create query store: {}", e.getMessage());
-            throw new QueryStoreCreateException("Failed to create query store: " + e.getMessage(), e);
-        } finally {
-            dataSource.close();
-        }
-        log.info("Created query store in database with name {}", databaseName);
-    }
-
-    @Override
-    public Dataset<Row> getData(PrivilegedDatabaseDto database, QueryDto subset, Long page, Long size)
+    public Dataset<Row> getData(DatabaseDto database, QueryDto subset, Long page, Long size)
             throws ViewMalformedException, SQLException, QueryMalformedException, TableNotFoundException {
         final String viewName = metadataMapper.queryDtoToViewName(subset);
-        if (!viewService.existsByName(database, viewName)) {
+        if (!databaseService.existsView(database, viewName)) {
             log.warn("Missing internal view {} for subset with id {}: create it from subset query", viewName, subset.getId());
-            viewService.create(database, subset);
+            databaseService.createView(database, ViewCreateDto.builder()
+                    .isPublic(false)
+                    .isSchemaPublic(false)
+                    .name(viewName)
+                    .query(subset.getQuery())
+                    .build());
         } else {
             log.debug("internal view {}.{} for subset with id {} exists", database.getInternalName(), viewName, subset.getId());
         }
@@ -101,22 +71,22 @@ public class SubsetServiceMariaDbImpl extends HibernateConnector implements Subs
     }
 
     @Override
-    public Long create(PrivilegedDatabaseDto database, String statement, Instant timestamp, UUID userId)
+    public Long create(DatabaseDto database, String statement, Instant timestamp, UUID userId)
             throws QueryStoreInsertException, SQLException {
         return storeQuery(database, statement, timestamp, userId);
     }
 
     @Override
-    public Long reExecuteCount(PrivilegedDatabaseDto database, QueryDto query) throws TableMalformedException,
+    public Long reExecuteCount(DatabaseDto database, QueryDto query) throws TableMalformedException,
             SQLException, QueryMalformedException {
         return executeCountNonPersistent(database, query.getQuery(), query.getExecution());
     }
 
     @Override
-    public List<QueryDto> findAll(PrivilegedDatabaseDto database, Boolean filterPersisted) throws SQLException,
+    public List<QueryDto> findAll(DatabaseDto database, Boolean filterPersisted) throws SQLException,
             QueryNotFoundException, RemoteUnavailableException, DatabaseNotFoundException, MetadataServiceException {
         final List<IdentifierBriefDto> identifiers = metadataServiceGateway.getIdentifiers(database.getId(), null);
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             final long start = System.currentTimeMillis();
@@ -147,9 +117,9 @@ public class SubsetServiceMariaDbImpl extends HibernateConnector implements Subs
     }
 
     @Override
-    public Long executeCountNonPersistent(PrivilegedDatabaseDto database, String statement, Instant timestamp)
+    public Long executeCountNonPersistent(DatabaseDto database, String statement, Instant timestamp)
             throws SQLException, QueryMalformedException, TableMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             final long start = System.currentTimeMillis();
@@ -166,9 +136,9 @@ public class SubsetServiceMariaDbImpl extends HibernateConnector implements Subs
     }
 
     @Override
-    public QueryDto findById(PrivilegedDatabaseDto database, Long queryId) throws QueryNotFoundException, SQLException,
+    public QueryDto findById(DatabaseDto database, Long queryId) throws QueryNotFoundException, SQLException,
             RemoteUnavailableException, DatabaseNotFoundException, MetadataServiceException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             final long start = System.currentTimeMillis();
@@ -193,11 +163,11 @@ public class SubsetServiceMariaDbImpl extends HibernateConnector implements Subs
     }
 
     @Override
-    public Long storeQuery(PrivilegedDatabaseDto database, String query, Instant timestamp, UUID userId) throws SQLException,
+    public Long storeQuery(DatabaseDto database, String query, Instant timestamp, UUID userId) throws SQLException,
             QueryStoreInsertException {
         /* save */
         final Long queryId;
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             /* insert query into query store */
@@ -228,9 +198,9 @@ public class SubsetServiceMariaDbImpl extends HibernateConnector implements Subs
     }
 
     @Override
-    public void persist(PrivilegedDatabaseDto database, Long queryId, Boolean persist) throws SQLException,
+    public void persist(DatabaseDto database, Long queryId, Boolean persist) throws SQLException,
             QueryStorePersistException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             /* update query */
@@ -250,8 +220,8 @@ public class SubsetServiceMariaDbImpl extends HibernateConnector implements Subs
     }
 
     @Override
-    public void deleteStaleQueries(PrivilegedDatabaseDto database) throws SQLException, QueryStoreGCException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+    public void deleteStaleQueries(DatabaseDto database) throws SQLException, QueryStoreGCException {
+        final ComboPooledDataSource dataSource = getDataSource(database);
         final Connection connection = dataSource.getConnection();
         try {
             final long start = System.currentTimeMillis();
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/TableServiceMariaDbImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/TableServiceMariaDbImpl.java
index c34f057e0129bd1c65277648adf3b5985952235c..6586c8ba42669dfc63d6b5c70aaaf84559a1b634 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/TableServiceMariaDbImpl.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/TableServiceMariaDbImpl.java
@@ -1,18 +1,16 @@
 package at.tuwien.service.impl;
 
 import at.tuwien.api.SortTypeDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
+import at.tuwien.api.database.DatabaseDto;
 import at.tuwien.api.database.query.ImportDto;
 import at.tuwien.api.database.table.*;
 import at.tuwien.api.database.table.columns.ColumnDto;
 import at.tuwien.api.database.table.columns.ColumnStatisticDto;
 import at.tuwien.api.database.table.columns.ColumnTypeDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
-import at.tuwien.api.database.table.internal.TableCreateDto;
 import at.tuwien.exception.*;
 import at.tuwien.mapper.DataMapper;
 import at.tuwien.mapper.MariaDbMapper;
-import at.tuwien.service.SchemaService;
+import at.tuwien.service.DatabaseService;
 import at.tuwien.service.StorageService;
 import at.tuwien.service.TableService;
 import at.tuwien.utils.MariaDbUtil;
@@ -28,66 +26,35 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.Instant;
-import java.util.*;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Properties;
 
 @Log4j2
 @Service
-public class TableServiceMariaDbImpl extends HibernateConnector implements TableService {
+public class TableServiceMariaDbImpl extends DataConnector<TableDto> implements TableService {
 
     private final DataMapper dataMapper;
     private final SparkSession sparkSession;
     private final MariaDbMapper mariaDbMapper;
-    private final SchemaService schemaService;
     private final StorageService storageService;
+    private final DatabaseService databaseService;
 
     @Autowired
     public TableServiceMariaDbImpl(DataMapper dataMapper, SparkSession sparkSession, MariaDbMapper mariaDbMapper,
-                                   SchemaService schemaService, StorageService storageService) {
+                                   StorageService storageService, DatabaseService databaseService) {
         this.dataMapper = dataMapper;
         this.sparkSession = sparkSession;
         this.mariaDbMapper = mariaDbMapper;
-        this.schemaService = schemaService;
         this.storageService = storageService;
+        this.databaseService = databaseService;
     }
 
     @Override
-    public List<TableDto> getSchemas(PrivilegedDatabaseDto database) throws SQLException, TableNotFoundException,
-            DatabaseMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
-        final Connection connection = dataSource.getConnection();
-        final List<TableDto> tables = new LinkedList<>();
-        try {
-            /* inspect tables before views */
-            final long start = System.currentTimeMillis();
-            final PreparedStatement statement = connection.prepareStatement(mariaDbMapper.databaseTablesSelectRawQuery());
-            statement.setString(1, database.getInternalName());
-            final ResultSet resultSet1 = statement.executeQuery();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            while (resultSet1.next()) {
-                final String tableName = resultSet1.getString(1);
-                if (database.getTables().stream().anyMatch(t -> t.getInternalName().equals(tableName))) {
-                    log.trace("view {}.{} already known to metadata database, skip.", database.getInternalName(), tableName);
-                    continue;
-                }
-                final TableDto table = schemaService.inspectTable(database, tableName);
-                if (database.getTables().stream().noneMatch(t -> t.getInternalName().equals(table.getInternalName()))) {
-                    tables.add(table);
-                }
-            }
-        } catch (SQLException e) {
-            log.error("Failed to get table schemas: {}", e.getMessage());
-            throw new DatabaseMalformedException("Failed to get table schemas: " + e.getMessage(), e);
-        } finally {
-            dataSource.close();
-        }
-        log.info("Found {} table schema(s)", tables.size());
-        return tables;
-    }
-
-    @Override
-    public TableStatisticDto getStatistics(PrivilegedTableDto table) throws SQLException, TableMalformedException,
+    public TableStatisticDto getStatistics(DatabaseDto database, TableDto table) throws SQLException, TableMalformedException,
             TableNotFoundException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         final TableStatisticDto statistic;
         try {
@@ -95,14 +62,14 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
             final long start = System.currentTimeMillis();
             final String query = mariaDbMapper.tableColumnStatisticsSelectRawQuery(table.getColumns(), table.getInternalName());
             if (query == null) {
-                log.debug("table {}.{} does not have columns that can be analysed for statistical properties (i.e. no numeric columns)", table.getDatabase().getInternalName(), table.getInternalName());
+                log.debug("table {}.{} does not have columns that can be analysed for statistical properties (i.e. no numeric columns)", database.getInternalName(), table.getInternalName());
                 statistic = null;
             } else {
                 final ResultSet resultSet = connection.prepareStatement(query)
                         .executeQuery();
                 log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
                 statistic = dataMapper.resultSetToTableStatistic(resultSet);
-                final TableDto tmpTable = schemaService.inspectTable(table.getDatabase(), table.getInternalName());
+                final TableDto tmpTable = databaseService.inspectTable(database, table.getInternalName());
                 statistic.setAvgRowLength(tmpTable.getAvgRowLength());
                 statistic.setDataLength(tmpTable.getDataLength());
                 statistic.setMaxDataLength(tmpTable.getMaxDataLength());
@@ -126,44 +93,9 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
     }
 
     @Override
-    public TableDto find(PrivilegedDatabaseDto database, String tableName) throws TableNotFoundException, SQLException {
-        return schemaService.inspectTable(database, tableName);
-    }
-
-    @Override
-    public TableDto createTable(PrivilegedDatabaseDto database, TableCreateDto data) throws SQLException,
-            TableMalformedException, TableExistsException, TableNotFoundException {
-        final String tableName = mariaDbMapper.nameToInternalName(data.getName());
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
-        final Connection connection = dataSource.getConnection();
-        try {
-            /* create table if not exists */
-            final long start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.tableCreateDtoToCreateTableRawQuery(data))
-                    .execute();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            connection.commit();
-        } catch (SQLException e) {
-            connection.rollback();
-            if (e.getMessage().contains("already exists")) {
-                log.error("Failed to create table: already exists");
-                throw new TableExistsException("Failed to create table: already exists", e);
-            }
-            log.error("Failed to create table: {}", e.getMessage());
-            throw new TableMalformedException("Failed to create table: " + e.getMessage(), e);
-        } finally {
-            dataSource.close();
-        }
-        log.info("Created table with name {}", tableName);
-        final TableDto table = find(database, tableName);
-        table.setName(data.getName());
-        return table;
-    }
-
-    @Override
-    public void updateTable(PrivilegedTableDto table, TableUpdateDto data) throws SQLException,
+    public void updateTable(TableDto table, TableUpdateDto data) throws SQLException,
             TableMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         try {
             /* create table if not exists */
@@ -189,14 +121,13 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
     }
 
     @Override
-    public void delete(PrivilegedTableDto table) throws SQLException, QueryMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
-        final String tableName = mariaDbMapper.nameToInternalName(table.getInternalName());
+    public void delete(TableDto table) throws SQLException, QueryMalformedException {
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         try {
             /* create table if not exists */
             final long start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.dropTableRawQuery(tableName))
+            connection.prepareStatement(mariaDbMapper.dropTableRawQuery(table.getInternalName()))
                     .execute();
             log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
             connection.commit();
@@ -207,63 +138,63 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
         } finally {
             dataSource.close();
         }
-        log.info("Deleted table with name {}", tableName);
+        log.info("Deleted table with name {}", table.getInternalName());
     }
 
     @Override
-    public List<TableHistoryDto> history(PrivilegedTableDto table, Long size) throws SQLException,
+    public List<TableHistoryDto> history(TableDto table, Long size) throws SQLException,
             TableNotFoundException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         final List<TableHistoryDto> history;
         try {
             /* find table data */
             final long start = System.currentTimeMillis();
             final ResultSet resultSet = connection.prepareStatement(mariaDbMapper.selectHistoryRawQuery(
-                            table.getDatabase().getInternalName(), table.getInternalName(), size))
+                            table.getDatabase(), table.getInternalName(), size))
                     .executeQuery();
             log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
             history = dataMapper.resultSetToTableHistory(resultSet);
             connection.commit();
         } catch (SQLException e) {
             connection.rollback();
-            log.error("Failed to find history for table {}.{}: {}", table.getDatabase().getInternalName(), table.getInternalName(), e.getMessage());
-            throw new TableNotFoundException("Failed to find history for table " + table.getDatabase().getInternalName() + "." + table.getInternalName() + ": " + e.getMessage(), e);
+            log.error("Failed to find history for table {}.{}: {}", table.getDatabase(), table.getInternalName(), e.getMessage());
+            throw new TableNotFoundException("Failed to find history for table " + table.getDatabase() + "." + table.getInternalName() + ": " + e.getMessage(), e);
         } finally {
             dataSource.close();
         }
-        log.info("Find history for table {}.{}", table.getDatabase().getInternalName(), table.getInternalName());
+        log.info("Find history for table {}.{}", table.getDatabase(), table.getInternalName());
         return history;
     }
 
     @Override
-    public Long getCount(PrivilegedTableDto table, Instant timestamp) throws SQLException,
+    public Long getCount(TableDto table, Instant timestamp) throws SQLException,
             QueryMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         final Long queryResult;
         try {
             /* find table data */
             final long start = System.currentTimeMillis();
             final ResultSet resultSet = connection.prepareStatement(mariaDbMapper.selectCountRawQuery(
-                            table.getDatabase().getInternalName(), table.getInternalName(), timestamp))
+                            table.getDatabase(), table.getInternalName(), timestamp))
                     .executeQuery();
             log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
             queryResult = mariaDbMapper.resultSetToNumber(resultSet);
             connection.commit();
         } catch (SQLException e) {
             connection.rollback();
-            log.error("Failed to find row count from table {}.{}: {}", table.getDatabase().getInternalName(), table.getInternalName(), e.getMessage());
-            throw new QueryMalformedException("Failed to find row count from table " + table.getDatabase().getInternalName() + "." + table.getInternalName() + ": " + e.getMessage(), e);
+            log.error("Failed to find row count from table {}.{}: {}", table.getDatabase(), table.getInternalName(), e.getMessage());
+            throw new QueryMalformedException("Failed to find row count from table " + table.getDatabase() + "." + table.getInternalName() + ": " + e.getMessage(), e);
         } finally {
             dataSource.close();
         }
-        log.info("Find row count from table {}.{}", table.getDatabase().getInternalName(), table.getInternalName());
+        log.info("Find row count from table {}.{}", table.getDatabase(), table.getInternalName());
         return queryResult;
     }
 
     @Override
-    public void importDataset(PrivilegedTableDto table, ImportDto data) throws MalformedException,
+    public void importDataset(TableDto table, ImportDto data) throws MalformedException,
             StorageNotFoundException, StorageUnavailableException, SQLException, QueryMalformedException,
             TableMalformedException {
         final List<String> columns = table.getColumns()
@@ -273,8 +204,8 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
         final Dataset<Row> dataset = storageService.loadDataset(columns, data.getLocation(),
                 String.valueOf(data.getSeparator()), data.getHeader());
         final Properties properties = new Properties();
-        properties.setProperty("user", table.getDatabase().getContainer().getUsername());
-        properties.setProperty("password", table.getDatabase().getContainer().getPassword());
+        properties.setProperty("user", table.getUsername());
+        properties.setProperty("password", table.getPassword());
         final String temporaryTable = table.getInternalName() + "_tmp";
         try {
             log.trace("import dataset to temporary table: {}", temporaryTable);
@@ -282,8 +213,7 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
                     .mode(SaveMode.Overwrite)
                     .option("header", data.getHeader())
                     .option("inferSchema", "true")
-                    .jdbc(getSparkUrl(table.getDatabase().getContainer(), table.getDatabase().getInternalName()),
-                            temporaryTable, properties);
+                    .jdbc(getSparkUrl(table), temporaryTable, properties);
         } catch (Exception e) {
             if (e instanceof AnalysisException exception) {
                 final String message = exception.getSimpleMessage()
@@ -295,7 +225,7 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
             throw new MalformedException("Failed to write dataset: " + e.getMessage()) /* remove throwable on purpose, clutters the output */;
         }
         /* import .csv from sidecar to database */
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         try {
             /* import tuple */
@@ -314,15 +244,15 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
             connection.commit();
             dataSource.close();
         }
-        log.info("Imported dataset into table: {}.{}", table.getDatabase().getInternalName(), table.getInternalName());
+        log.info("Imported dataset into table: {}.{}", table.getDatabase(), table.getInternalName());
     }
 
     @Override
-    public void deleteTuple(PrivilegedTableDto table, TupleDeleteDto data) throws SQLException,
+    public void deleteTuple(TableDto table, TupleDeleteDto data) throws SQLException,
             TableMalformedException, QueryMalformedException {
         log.trace("delete tuple: {}", data);
         /* prepare the statement */
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         try {
             /* import tuple */
@@ -344,11 +274,11 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
         } finally {
             dataSource.close();
         }
-        log.info("Deleted tuple(s) from table: {}.{}", table.getDatabase().getInternalName(), table.getInternalName());
+        log.info("Deleted tuple(s) from table: {}.{}", table.getDatabase(), table.getInternalName());
     }
 
     @Override
-    public void createTuple(PrivilegedTableDto table, TupleDto data) throws SQLException, QueryMalformedException,
+    public void createTuple(TableDto table, TupleDto data) throws SQLException, QueryMalformedException,
             TableMalformedException, StorageUnavailableException, StorageNotFoundException {
         log.trace("create tuple: {}", data);
         /* for each LOB-like data-column, retrieve the bytes and replace the value */
@@ -366,7 +296,7 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
                     .replace(key, blob);
         }
         /* prepare the statement */
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         try {
             /* create tuple */
@@ -388,15 +318,15 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
         } finally {
             dataSource.close();
         }
-        log.info("Created tuple(s) in table: {}.{}", table.getDatabase().getInternalName(), table.getInternalName());
+        log.info("Created tuple(s) in table: {}.{}", table.getDatabase(), table.getInternalName());
     }
 
     @Override
-    public void updateTuple(PrivilegedTableDto table, TupleUpdateDto data) throws SQLException,
+    public void updateTuple(TableDto table, TupleUpdateDto data) throws SQLException,
             QueryMalformedException, TableMalformedException {
         log.trace("update tuple: {}", data);
         /* prepare the statement */
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(table.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(table);
         final Connection connection = dataSource.getConnection();
         try {
             final int[] idx = new int[]{1};
@@ -424,7 +354,7 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
         } finally {
             dataSource.close();
         }
-        log.info("Updated tuple(s) from table: {}.{}", table.getDatabase().getInternalName(), table.getInternalName());
+        log.info("Updated tuple(s) from table: {}.{}", table.getDatabase(), table.getInternalName());
     }
 
     public ColumnTypeDto getColumnType(List<ColumnDto> columns, String name) throws QueryMalformedException {
@@ -439,7 +369,7 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
     }
 
     @Override
-    public Dataset<Row> getData(PrivilegedDatabaseDto database, String tableOrView, Instant timestamp,
+    public Dataset<Row> getData(DatabaseDto database, String tableOrView, Instant timestamp,
                                 Long page, Long size, SortTypeDto sortDirection, String sortColumn)
             throws QueryMalformedException, TableNotFoundException {
         try {
@@ -447,7 +377,8 @@ public class TableServiceMariaDbImpl extends HibernateConnector implements Table
             properties.setProperty("user", database.getContainer().getUsername());
             properties.setProperty("password", database.getContainer().getPassword());
             return sparkSession.read()
-                    .jdbc(getSparkUrl(database.getContainer(), database.getInternalName()), tableOrView, properties);
+                    .jdbc(getSparkUrl(database.getJdbcMethod(), database.getHost(), database.getPassword(),
+                            database.getInternalName()), tableOrView, properties);
         } catch (Exception e) {
             if (e instanceof ExtendedAnalysisException exception) {
                 if (exception.getSimpleMessage().contains("TABLE_OR_VIEW_NOT_FOUND")) {
diff --git a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/ViewServiceMariaDbImpl.java b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/ViewServiceMariaDbImpl.java
index d85bdc53ac235a3a95bb8b3543bddcfdd143dc6d..3224c371a34774978b72bd58f6acaadb8081af99 100644
--- a/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/ViewServiceMariaDbImpl.java
+++ b/dbrepo-data-service/services/src/main/java/at/tuwien/service/impl/ViewServiceMariaDbImpl.java
@@ -1,182 +1,39 @@
 package at.tuwien.service.impl;
 
-import at.tuwien.api.database.ViewCreateDto;
 import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
-import at.tuwien.api.database.query.QueryDto;
-import at.tuwien.config.QueryConfig;
-import at.tuwien.exception.DatabaseMalformedException;
 import at.tuwien.exception.QueryMalformedException;
 import at.tuwien.exception.ViewMalformedException;
-import at.tuwien.exception.ViewNotFoundException;
-import at.tuwien.mapper.DataMapper;
 import at.tuwien.mapper.MariaDbMapper;
-import at.tuwien.mapper.MetadataMapper;
-import at.tuwien.service.SchemaService;
 import at.tuwien.service.ViewService;
-import com.google.common.hash.Hashing;
 import com.mchange.v2.c3p0.ComboPooledDataSource;
 import lombok.extern.log4j.Log4j2;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.nio.charset.StandardCharsets;
 import java.sql.Connection;
-import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.Instant;
-import java.util.LinkedList;
-import java.util.List;
 
 @Log4j2
 @Service
-public class ViewServiceMariaDbImpl extends HibernateConnector implements ViewService {
+public class ViewServiceMariaDbImpl extends DataConnector<ViewDto> implements ViewService {
 
-    private final DataMapper dataMapper;
-    private final QueryConfig queryConfig;
-    private final SchemaService schemaService;
     private final MariaDbMapper mariaDbMapper;
-    private final MetadataMapper metadataMapper;
 
     @Autowired
-    public ViewServiceMariaDbImpl(DataMapper dataMapper, QueryConfig queryConfig, SchemaService schemaService,
-                                  MariaDbMapper mariaDbMapper, MetadataMapper metadataMapper) {
-        this.dataMapper = dataMapper;
-        this.queryConfig = queryConfig;
-        this.schemaService = schemaService;
+    public ViewServiceMariaDbImpl(MariaDbMapper mariaDbMapper) {
         this.mariaDbMapper = mariaDbMapper;
-        this.metadataMapper = metadataMapper;
     }
 
     @Override
-    public Boolean existsByName(PrivilegedDatabaseDto database, String name) throws SQLException,
-            QueryMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
-        final Connection connection = dataSource.getConnection();
-        final Boolean queryResult;
-        try {
-            /* find view data */
-            final long start = System.currentTimeMillis();
-            final PreparedStatement statement = connection.prepareStatement(mariaDbMapper.selectExistsTableOrViewRawQuery());
-            statement.setString(1, database.getInternalName());
-            statement.setString(2, name);
-            final ResultSet resultSet = statement.executeQuery();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            queryResult = mariaDbMapper.resultSetToBoolean(resultSet);
-        } catch (SQLException e) {
-            log.error("Failed to prepare statement {}", e.getMessage());
-            throw new QueryMalformedException("Failed to prepare statement: " + e.getMessage(), e);
-        } finally {
-            dataSource.close();
-        }
-        return queryResult;
-    }
-
-    @Override
-    public List<ViewDto> getSchemas(PrivilegedDatabaseDto database) throws SQLException, DatabaseMalformedException,
-            ViewNotFoundException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
-        final Connection connection = dataSource.getConnection();
-        final List<ViewDto> views = new LinkedList<>();
-        try {
-            /* inspect tables before views */
-            final PreparedStatement statement = connection.prepareStatement(mariaDbMapper.databaseViewsSelectRawQuery());
-            statement.setString(1, database.getInternalName());
-            final long start = System.currentTimeMillis();
-            final ResultSet resultSet1 = statement.executeQuery();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            while (resultSet1.next()) {
-                final String viewName = resultSet1.getString(1);
-                if (viewName.length() == 64) {
-                    log.trace("view {}.{} seems to be a subset view (name length = 64), skip.", database.getInternalName(), viewName);
-                    continue;
-                }
-                if (database.getViews().stream().anyMatch(v -> v.getInternalName().equals(viewName))) {
-                    log.trace("view {}.{} already known to metadata database, skip.", database.getInternalName(), viewName);
-                    continue;
-                }
-                final ViewDto view;
-                view = schemaService.inspectView(database, viewName);
-                if (database.getTables().stream().noneMatch(t -> t.getInternalName().equals(view.getInternalName()))) {
-                    views.add(view);
-                }
-            }
-        } catch (SQLException e) {
-            log.error("Failed to get view schemas: {}", e.getMessage());
-            throw new DatabaseMalformedException("Failed to get view schemas: " + e.getMessage(), e);
-        } finally {
-            dataSource.close();
-        }
-        log.info("Found {} view schema(s)", views.size());
-        return views;
-    }
-
-    @Override
-    public ViewDto create(PrivilegedDatabaseDto database, QueryDto subset) throws ViewMalformedException,
-            SQLException {
-        final ViewCreateDto data = ViewCreateDto.builder()
-                .name(metadataMapper.queryDtoToViewName(subset))
-                .query(subset.getQuery())
-                .isPublic(false)
-                .build();
-        return create(database, data);
-    }
-
-    @Override
-    public ViewDto create(PrivilegedDatabaseDto database, ViewCreateDto data) throws SQLException,
-            ViewMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
-        final Connection connection = dataSource.getConnection();
-        ViewDto view = ViewDto.builder()
-                .name(data.getName())
-                .internalName(mariaDbMapper.nameToInternalName(data.getName()))
-                .query(data.getQuery())
-                .queryHash(Hashing.sha256()
-                        .hashString(data.getQuery(), StandardCharsets.UTF_8)
-                        .toString())
-                .isPublic(database.getIsPublic())
-                .owner(database.getOwner())
-                .identifiers(new LinkedList<>())
-                .isInitialView(false)
-                .vdbid(database.getId())
-                .columns(new LinkedList<>())
-                .build();
-        try {
-            /* create view if not exists */
-            final long start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.viewCreateRawQuery(view.getInternalName(), data.getQuery()))
-                    .execute();
-            log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
-            /* select view columns */
-            final PreparedStatement statement2 = connection.prepareStatement(mariaDbMapper.databaseTableColumnsSelectRawQuery());
-            statement2.setString(1, database.getInternalName());
-            statement2.setString(2, view.getInternalName());
-            final ResultSet resultSet2 = statement2.executeQuery();
-            while (resultSet2.next()) {
-                view = dataMapper.resultSetToTable(resultSet2, view, queryConfig);
-            }
-            connection.commit();
-        } catch (SQLException e) {
-            connection.rollback();
-            log.error("Failed to create view: {}", e.getMessage());
-            throw new ViewMalformedException("Failed to create view: " + e.getMessage(), e);
-        } finally {
-            dataSource.close();
-        }
-        log.info("Created view with name {}", view.getName());
-        return view;
-    }
-
-    @Override
-    public void delete(PrivilegedDatabaseDto database, String viewName) throws SQLException, ViewMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(database);
+    public void delete(ViewDto view) throws SQLException, ViewMalformedException {
+        final ComboPooledDataSource dataSource = getDataSource(view);
         final Connection connection = dataSource.getConnection();
         try {
             /* drop view if exists */
             final long start = System.currentTimeMillis();
-            connection.prepareStatement(mariaDbMapper.dropViewRawQuery(viewName))
+            connection.prepareStatement(mariaDbMapper.dropViewRawQuery(view.getInternalName()))
                     .execute();
             log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
             connection.commit();
@@ -187,33 +44,32 @@ public class ViewServiceMariaDbImpl extends HibernateConnector implements ViewSe
         } finally {
             dataSource.close();
         }
-        log.info("Deleted view {}.{}", database.getInternalName(), viewName);
+        log.info("Deleted view {}.{}", view.getDatabase(), view.getInternalName());
     }
 
-
     @Override
-    public Long count(PrivilegedViewDto view, Instant timestamp) throws SQLException,
+    public Long count(ViewDto view, Instant timestamp) throws SQLException,
             QueryMalformedException {
-        final ComboPooledDataSource dataSource = getPrivilegedDataSource(view.getDatabase());
+        final ComboPooledDataSource dataSource = getDataSource(view);
         final Connection connection = dataSource.getConnection();
         final Long queryResult;
         try {
             /* find view data */
             final long start = System.currentTimeMillis();
             final ResultSet resultSet = connection.prepareStatement(mariaDbMapper.selectCountRawQuery(
-                            view.getDatabase().getInternalName(), view.getInternalName(), timestamp))
+                            view.getDatabase(), view.getInternalName(), timestamp))
                     .executeQuery();
             log.trace("executed statement in {} ms", System.currentTimeMillis() - start);
             queryResult = mariaDbMapper.resultSetToNumber(resultSet);
             connection.commit();
         } catch (SQLException e) {
             connection.rollback();
-            log.error("Failed to find row count from view {}.{}: {}", view.getDatabase().getInternalName(), view.getInternalName(), e.getMessage());
-            throw new QueryMalformedException("Failed to find row count from view " + view.getDatabase().getInternalName() + "." + view.getInternalName() + ": " + e.getMessage(), e);
+            log.error("Failed to find row count from view {}.{}: {}", view.getDatabase(), view.getInternalName(), e.getMessage());
+            throw new QueryMalformedException("Failed to find row count from view " + view.getDatabase() + "." + view.getInternalName() + ": " + e.getMessage(), e);
         } finally {
             dataSource.close();
         }
-        log.info("Find row count from view {}.{}", view.getDatabase().getInternalName(), view.getInternalName());
+        log.info("Find row count from view {}.{}", view.getDatabase(), view.getInternalName());
         return queryResult;
     }
 
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/CacheableDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/CacheableDto.java
new file mode 100644
index 0000000000000000000000000000000000000000..66de637504b45ce516c2e1bbcef7abea81f747aa
--- /dev/null
+++ b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/CacheableDto.java
@@ -0,0 +1,45 @@
+package at.tuwien.api;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.time.Instant;
+
+@Getter
+@Setter
+@EqualsAndHashCode
+@ToString
+public abstract class CacheableDto {
+
+    @JsonProperty("last_retrieved")
+    private Instant lastRetrieved;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String jdbcMethod;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String host;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private Integer port;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String username;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String password;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String database;
+
+}
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/PrivilegedObjectDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/PrivilegedObjectDto.java
deleted file mode 100644
index c88fcabccfba67130fbc4a230d98fb749d5857dd..0000000000000000000000000000000000000000
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/PrivilegedObjectDto.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package at.tuwien.api;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Getter;
-import lombok.Setter;
-import lombok.ToString;
-
-import java.time.Instant;
-
-@Getter
-@Setter
-@ToString
-public abstract class PrivilegedObjectDto {
-
-    @JsonProperty("last_retrieved")
-    private Instant lastRetrieved;
-
-}
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/container/ContainerDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/container/ContainerDto.java
index 9928c8e54d39287fc7a19bf84b6a99c7429f69bd..da782c2bb7a7c7bce6b5ed58f5986093c084e9ae 100644
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/container/ContainerDto.java
+++ b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/container/ContainerDto.java
@@ -1,7 +1,9 @@
 package at.tuwien.api.container;
 
+import at.tuwien.api.CacheableDto;
 import at.tuwien.api.container.image.ImageDto;
 import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
@@ -18,7 +20,7 @@ import java.time.Instant;
 @AllArgsConstructor
 @Jacksonized
 @ToString
-public class ContainerDto {
+public class ContainerDto extends CacheableDto {
 
     @NotNull
     private Long id;
@@ -55,4 +57,25 @@ public class ContainerDto {
     @Schema(example = "10")
     private Long count;
 
+    /* lombok limitations prevent from convenient builder functions */
+
+    @JsonProperty("last_retrieved")
+    private Instant lastRetrieved;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String jdbcMethod;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String username;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String password;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String database;
+
 }
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/container/internal/PrivilegedContainerDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/container/internal/PrivilegedContainerDto.java
deleted file mode 100644
index 9c414e5ef1f0201da252e58494048d537996bb56..0000000000000000000000000000000000000000
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/container/internal/PrivilegedContainerDto.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package at.tuwien.api.container.internal;
-
-import at.tuwien.api.PrivilegedObjectDto;
-import at.tuwien.api.container.image.ImageDto;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import lombok.*;
-import lombok.extern.jackson.Jacksonized;
-
-import java.time.Instant;
-
-@Getter
-@Setter
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Jacksonized
-@ToString
-public class PrivilegedContainerDto extends PrivilegedObjectDto {
-
-    @NotNull
-    private Long id;
-
-    @NotBlank
-    @Schema(example = "Air Quality")
-    private String name;
-
-    @NotBlank
-    @JsonProperty("internal_name")
-    @Schema(example = "data-db")
-    private String internalName;
-
-    @NotBlank
-    private String host;
-
-    @NotNull
-    private Integer port;
-
-    @JsonProperty("ui_host")
-    private String uiHost;
-
-    @JsonProperty("ui_port")
-    private Integer uiPort;
-
-    @NotNull
-    private ImageDto image;
-
-    @ToString.Exclude
-    private String username;
-
-    @ToString.Exclude
-    private String password;
-
-    @JsonProperty("last_retrieved")
-    private Instant lastRetrieved;
-
-}
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/DatabaseBriefDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/DatabaseBriefDto.java
index 46072e83dc14af22d09923d3e9462a53506aa4f8..7b47a617ec2a5a55256c04554357cd26a467a0fa 100644
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/DatabaseBriefDto.java
+++ b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/DatabaseBriefDto.java
@@ -56,4 +56,7 @@ public class DatabaseBriefDto {
     @JsonProperty("owner_id")
     private UUID ownerId;
 
+    @JsonProperty("preview_image")
+    private String previewImage;
+
 }
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/DatabaseDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/DatabaseDto.java
index 5fc253c4335044a1eaabbb43d02f7ae07510178b..044e52df382cad09207487005ab496915b93dd99 100644
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/DatabaseDto.java
+++ b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/DatabaseDto.java
@@ -1,9 +1,11 @@
 package at.tuwien.api.database;
 
-import at.tuwien.api.container.ContainerBriefDto;
-import at.tuwien.api.database.table.TableBriefDto;
-import at.tuwien.api.identifier.IdentifierBriefDto;
+import at.tuwien.api.CacheableDto;
+import at.tuwien.api.container.ContainerDto;
+import at.tuwien.api.database.table.TableDto;
+import at.tuwien.api.identifier.IdentifierDto;
 import at.tuwien.api.user.UserBriefDto;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
@@ -11,17 +13,18 @@ import jakarta.validation.constraints.NotNull;
 import lombok.*;
 import lombok.extern.jackson.Jacksonized;
 
+import java.time.Instant;
 import java.util.List;
 
 @Getter
 @Setter
 @Builder
-@EqualsAndHashCode
+@EqualsAndHashCode(callSuper = true)
 @NoArgsConstructor
 @AllArgsConstructor
 @Jacksonized
 @ToString
-public class DatabaseDto {
+public class DatabaseDto extends CacheableDto {
 
     @NotNull
     private Long id;
@@ -47,9 +50,9 @@ public class DatabaseDto {
     @Schema(example = "Air Quality")
     private String description;
 
-    private List<TableBriefDto> tables;
+    private List<TableDto> tables;
 
-    private List<ViewBriefDto> views;
+    private List<ViewDto> views;
 
     @NotNull
     @JsonProperty("is_public")
@@ -62,13 +65,13 @@ public class DatabaseDto {
     private Boolean isSchemaPublic;
 
     @NotNull
-    private ContainerBriefDto container;
+    private ContainerDto container;
 
     private List<DatabaseAccessDto> accesses;
 
-    private List<IdentifierBriefDto> identifiers;
+    private List<IdentifierDto> identifiers;
 
-    private List<IdentifierBriefDto> subsets;
+    private List<IdentifierDto> subsets;
 
     @NotNull
     private UserBriefDto contact;
@@ -79,4 +82,33 @@ public class DatabaseDto {
     @JsonProperty("preview_image")
     private String previewImage;
 
+    /* lombok limitations prevent from convenient builder functions */
+
+    @JsonProperty("last_retrieved")
+    private Instant lastRetrieved;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String jdbcMethod;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String host;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private Integer port;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String username;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String password;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String database;
+
 }
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/ViewDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/ViewDto.java
index d1ee156e9b95c09a9dd31c1ddf01926818f75879..13e64911f5f9e43fb8141ed1879b84bd3410e8fd 100644
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/ViewDto.java
+++ b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/ViewDto.java
@@ -1,7 +1,9 @@
 package at.tuwien.api.database;
 
+import at.tuwien.api.CacheableDto;
 import at.tuwien.api.identifier.IdentifierDto;
 import at.tuwien.api.user.UserBriefDto;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
@@ -9,17 +11,18 @@ import jakarta.validation.constraints.NotNull;
 import lombok.*;
 import lombok.extern.jackson.Jacksonized;
 
+import java.time.Instant;
 import java.util.List;
 
 @Getter
 @Setter
 @Builder
-@EqualsAndHashCode
+@EqualsAndHashCode(callSuper = true)
 @NoArgsConstructor
 @AllArgsConstructor
 @Jacksonized
 @ToString
-public class ViewDto {
+public class ViewDto extends CacheableDto {
 
     @NotNull
     private Long id;
@@ -66,4 +69,33 @@ public class ViewDto {
     @NotNull
     private List<ViewColumnDto> columns;
 
+    /* lombok limitations prevent from convenient builder functions */
+
+    @JsonProperty("last_retrieved")
+    private Instant lastRetrieved;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String jdbcMethod;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String host;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private Integer port;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String username;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String password;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String database;
+
 }
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/internal/PrivilegedDatabaseDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/internal/PrivilegedDatabaseDto.java
deleted file mode 100644
index 2335ea39baf1a2e8f1461b56c844409f8e21b207..0000000000000000000000000000000000000000
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/internal/PrivilegedDatabaseDto.java
+++ /dev/null
@@ -1,88 +0,0 @@
-package at.tuwien.api.database.internal;
-
-import at.tuwien.api.PrivilegedObjectDto;
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
-import at.tuwien.api.database.DatabaseAccessDto;
-import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.table.TableDto;
-import at.tuwien.api.identifier.IdentifierDto;
-import at.tuwien.api.user.UserBriefDto;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import lombok.*;
-import lombok.extern.jackson.Jacksonized;
-
-import java.time.Instant;
-import java.util.List;
-
-@Getter
-@Setter
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Jacksonized
-@ToString
-public class PrivilegedDatabaseDto extends PrivilegedObjectDto {
-
-    @NotNull
-    private Long id;
-
-    @NotBlank
-    @Schema(example = "Air Quality")
-    private String name;
-
-    @NotBlank
-    @JsonProperty("exchange_name")
-    @Schema(example = "dbrepo")
-    private String exchangeName;
-
-    @JsonProperty("exchange_type")
-    @Schema(example = "topic")
-    private String exchangeType;
-
-    @NotBlank
-    @JsonProperty("internal_name")
-    @Schema(example = "air_quality")
-    private String internalName;
-
-    @Schema(example = "Air Quality")
-    private String description;
-
-    private List<TableDto> tables;
-
-    private List<ViewDto> views;
-
-    @NotNull
-    @JsonProperty("is_public")
-    @Schema(example = "true")
-    private Boolean isPublic;
-
-    @NotNull
-    @JsonProperty("is_schema_public")
-    @Schema(example = "true")
-    private Boolean isSchemaPublic;
-
-    @NotNull
-    private PrivilegedContainerDto container;
-
-    private List<DatabaseAccessDto> accesses;
-
-    private List<IdentifierDto> identifiers;
-
-    private List<IdentifierDto> subsets;
-
-    @NotNull
-    private UserBriefDto contact;
-
-    @NotNull
-    private UserBriefDto owner;
-
-    @JsonProperty("preview_image")
-    private String previewImage;
-
-    @JsonProperty("last_retrieved")
-    private Instant lastRetrieved;
-
-}
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/internal/PrivilegedViewDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/internal/PrivilegedViewDto.java
deleted file mode 100644
index bda575f45d05f21a29a7be3d9da6cdfe1511d855..0000000000000000000000000000000000000000
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/internal/PrivilegedViewDto.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package at.tuwien.api.database.internal;
-
-import at.tuwien.api.PrivilegedObjectDto;
-import at.tuwien.api.database.ViewColumnDto;
-import at.tuwien.api.identifier.IdentifierDto;
-import at.tuwien.api.user.UserBriefDto;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import lombok.*;
-import lombok.extern.jackson.Jacksonized;
-
-import java.time.Instant;
-import java.util.List;
-
-@Getter
-@Setter
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Jacksonized
-@ToString
-public class PrivilegedViewDto extends PrivilegedObjectDto {
-
-    @NotNull
-    private Long id;
-
-    @NotNull
-    @JsonProperty("database_id")
-    private Long vdbid;
-
-    @NotNull
-    private PrivilegedDatabaseDto database;
-
-    @NotBlank
-    @Schema(example = "Air Quality")
-    private String name;
-
-    private List<IdentifierDto> identifiers;
-
-    @NotBlank
-    @Schema(example = "air_quality")
-    @JsonProperty("internal_name")
-    private String internalName;
-
-    @JsonProperty("is_public")
-    @Schema(example = "true")
-    private Boolean isPublic;
-
-    @JsonProperty("is_schema_public")
-    @Schema(example = "true")
-    private Boolean isSchemaPublic;
-
-    @JsonProperty("initial_view")
-    @Schema(example = "true", description = "True if it is the default view for the database")
-    private Boolean isInitialView;
-
-    @NotNull
-    @Schema(example = "SELECT `id` FROM `air_quality` ORDER BY `value` DESC")
-    private String query;
-
-    @NotNull
-    @JsonProperty("query_hash")
-    @Schema(example = "7de03e818900b6ea6d58ad0306d4a741d658c6df3d1964e89ed2395d8c7e7916")
-    private String queryHash;
-
-    @NotNull
-    private UserBriefDto owner;
-
-    @NotNull
-    private List<ViewColumnDto> columns;
-
-    @JsonProperty("last_retrieved")
-    private Instant lastRetrieved;
-
-}
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/table/TableDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/table/TableDto.java
index 67087d438daedf60cd0236a8f5427310b06464e4..cf18e321a42fea956345bdafa1ff265a3f6426b2 100644
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/table/TableDto.java
+++ b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/table/TableDto.java
@@ -1,9 +1,11 @@
 package at.tuwien.api.database.table;
 
+import at.tuwien.api.CacheableDto;
 import at.tuwien.api.database.table.columns.ColumnDto;
 import at.tuwien.api.database.table.constraints.ConstraintsDto;
 import at.tuwien.api.identifier.IdentifierDto;
 import at.tuwien.api.user.UserBriefDto;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
@@ -12,17 +14,18 @@ import jakarta.validation.constraints.Size;
 import lombok.*;
 import lombok.extern.jackson.Jacksonized;
 
+import java.time.Instant;
 import java.util.List;
 
 @Getter
 @Setter
 @Builder
-@EqualsAndHashCode
+@EqualsAndHashCode(callSuper = true)
 @NoArgsConstructor
 @AllArgsConstructor
 @Jacksonized
 @ToString
-public class TableDto {
+public class TableDto extends CacheableDto {
 
     @NotNull
     private Long id;
@@ -103,4 +106,33 @@ public class TableDto {
     @NotNull
     private ConstraintsDto constraints;
 
+    /* lombok limitations prevent from convenient builder functions */
+
+    @JsonProperty("last_retrieved")
+    private Instant lastRetrieved;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String jdbcMethod;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String host;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private Integer port;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String username;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String password;
+
+    @ToString.Exclude
+    @JsonIgnore
+    private String database;
+
 }
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/table/internal/PrivilegedTableDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/table/internal/PrivilegedTableDto.java
deleted file mode 100644
index 64b23f17c412c1042c0a1db9a040a67fcc612b39..0000000000000000000000000000000000000000
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/database/table/internal/PrivilegedTableDto.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package at.tuwien.api.database.table.internal;
-
-import at.tuwien.api.PrivilegedObjectDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.table.columns.ColumnDto;
-import at.tuwien.api.database.table.constraints.ConstraintsDto;
-import at.tuwien.api.identifier.IdentifierDto;
-import at.tuwien.api.user.UserBriefDto;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Size;
-import lombok.*;
-import lombok.extern.jackson.Jacksonized;
-
-import java.time.Instant;
-import java.util.List;
-
-@Getter
-@Setter
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Jacksonized
-@ToString
-@EqualsAndHashCode
-public class PrivilegedTableDto extends PrivilegedObjectDto {
-
-    @NotNull
-    private Long id;
-
-    @NotNull
-    @JsonProperty("database_id")
-    private Long tdbid;
-
-    @NotBlank
-    @Schema(example = "Air Quality")
-    private String name;
-
-    @NotBlank
-    @JsonProperty("internal_name")
-    @Schema(example = "air_quality")
-    private String internalName;
-
-    @Schema
-    private String alias;
-
-    private List<IdentifierDto> identifiers;
-
-    @NotNull
-    @JsonProperty("is_versioned")
-    @Schema(example = "true")
-    private Boolean isVersioned;
-
-    @NotNull
-    @JsonProperty("is_schema_public")
-    @Schema(example = "true")
-    private Boolean isSchemaPublic;
-
-    @NotNull
-    private UserBriefDto owner;
-
-    @NotBlank
-    @JsonProperty("queue_name")
-    @Schema(example = "air_quality")
-    private String queueName;
-
-    @JsonProperty("queue_type")
-    @Schema(example = "quorum")
-    private String queueType;
-
-    @NotBlank
-    @JsonProperty("routing_key")
-    @Schema(example = "dbrepo.1.2")
-    private String routingKey;
-
-    @Size(max = 2048)
-    @Schema(example = "Air Quality in Austria")
-    private String description;
-
-    @NotNull
-    @JsonProperty("is_public")
-    @Schema(example = "true")
-    private Boolean isPublic;
-
-    @JsonProperty("num_rows")
-    @Schema(example = "5")
-    private Long numRows;
-
-    @JsonProperty("data_length")
-    @Schema(example = "16384", description = "in bytes")
-    private Long dataLength;
-
-    @JsonProperty("max_data_length")
-    @Schema(example = "0", description = "in bytes")
-    private Long maxDataLength;
-
-    @JsonProperty("avg_row_length")
-    @Schema(example = "3276", description = "in bytes")
-    private Long avgRowLength;
-
-    @NotNull
-    private List<ColumnDto> columns;
-
-    @NotNull
-    private ConstraintsDto constraints;
-
-    @NotNull
-    private PrivilegedDatabaseDto database;
-
-    @JsonProperty("last_retrieved")
-    private Instant lastRetrieved;
-
-}
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/identifier/IdentifierBriefDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/identifier/IdentifierBriefDto.java
index 0a36c561a30a480f14251e1ddab396b8a3fcc9ae..82ff3b0fe7947af8e6d9e79ec4b2efa5a001f38b 100644
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/identifier/IdentifierBriefDto.java
+++ b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/identifier/IdentifierBriefDto.java
@@ -1,6 +1,5 @@
 package at.tuwien.api.identifier;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
@@ -8,7 +7,6 @@ import jakarta.validation.constraints.NotNull;
 import lombok.*;
 import lombok.extern.jackson.Jacksonized;
 
-import java.time.Instant;
 import java.util.List;
 import java.util.UUID;
 
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/user/UserDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/user/UserDto.java
index 343d582b55da3af324aa23fd31ef61d8e1cd564d..43fb10201ba0ebbbb69c2286c629ff0d99fb57b1 100644
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/user/UserDto.java
+++ b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/user/UserDto.java
@@ -1,22 +1,25 @@
 package at.tuwien.api.user;
 
+import at.tuwien.api.CacheableDto;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.*;
 import lombok.extern.jackson.Jacksonized;
 
+import java.time.Instant;
 import java.util.UUID;
 
 @Getter
 @Setter
 @Builder
-@EqualsAndHashCode
+@EqualsAndHashCode(callSuper = true)
 @NoArgsConstructor
 @AllArgsConstructor
 @Jacksonized
 @ToString
-public class UserDto {
+public class UserDto extends CacheableDto {
 
     @NotNull
     @Schema(example = "1ffc7b0e-9aeb-4e8b-b8f1-68f3936155b4")
@@ -41,7 +44,14 @@ public class UserDto {
     @Schema(example = "Carberry")
     private String lastname;
 
+    @ToString.Exclude
+    @JsonIgnore
+    private String password;
+
     @NotNull
     private UserAttributesDto attributes;
 
+    @JsonProperty("last_retrieved")
+    private Instant lastRetrieved;
+
 }
diff --git a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/user/internal/PrivilegedUserDto.java b/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/user/internal/PrivilegedUserDto.java
deleted file mode 100644
index 56e24cd81590261137cfa3d4f0f3c45399d80e70..0000000000000000000000000000000000000000
--- a/dbrepo-metadata-service/api/src/main/java/at/tuwien/api/user/internal/PrivilegedUserDto.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package at.tuwien.api.user.internal;
-
-import at.tuwien.api.PrivilegedObjectDto;
-import at.tuwien.api.user.UserAttributesDto;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import lombok.*;
-import lombok.extern.jackson.Jacksonized;
-
-import java.time.Instant;
-import java.util.UUID;
-
-@Getter
-@Setter
-@Builder
-@EqualsAndHashCode
-@NoArgsConstructor
-@AllArgsConstructor
-@Jacksonized
-@ToString
-public class PrivilegedUserDto extends PrivilegedObjectDto {
-
-    @NotNull
-    @Schema(example = "1ffc7b0e-9aeb-4e8b-b8f1-68f3936155b4")
-    private UUID id;
-
-    @NotBlank
-    @Schema(example = "jcarberry", description = "Only contains lowercase characters")
-    private String username;
-
-    @NotBlank
-    @Schema(example = "jcarberry")
-    private String password;
-
-    @Schema(example = "Josiah Carberry")
-    private String name;
-
-    @JsonProperty("qualified_name")
-    @Schema(example = "Josiah Carberry — @jcarberry")
-    private String qualifiedName;
-
-    @JsonProperty("given_name")
-    @Schema(example = "Josiah")
-    private String firstname;
-
-    @JsonProperty("family_name")
-    @Schema(example = "Carberry")
-    private String lastname;
-
-    @NotNull
-    private UserAttributesDto attributes;
-
-    @JsonProperty("last_retrieved")
-    private Instant lastRetrieved;
-
-}
diff --git a/dbrepo-metadata-service/repositories/src/main/java/at/tuwien/mapper/MetadataMapper.java b/dbrepo-metadata-service/repositories/src/main/java/at/tuwien/mapper/MetadataMapper.java
index c5482f70411433f5df08bd0281a60c75d132bf26..ab13affe7e095cd0112827f8ccb49d760071a5ac 100644
--- a/dbrepo-metadata-service/repositories/src/main/java/at/tuwien/mapper/MetadataMapper.java
+++ b/dbrepo-metadata-service/repositories/src/main/java/at/tuwien/mapper/MetadataMapper.java
@@ -10,7 +10,6 @@ import at.tuwien.api.container.image.ImageCreateDto;
 import at.tuwien.api.container.image.ImageDto;
 import at.tuwien.api.crossref.CrossrefDto;
 import at.tuwien.api.database.*;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
 import at.tuwien.api.database.table.TableBriefDto;
 import at.tuwien.api.database.table.TableDto;
 import at.tuwien.api.database.table.columns.ColumnCreateDto;
@@ -120,7 +119,10 @@ public interface MetadataMapper {
     })
     ContainerBriefDto containerToContainerBriefDto(Container data);
 
-    PrivilegedDatabaseDto databaseToPrivilegedDatabaseDto(Database data);
+    @Mappings({
+            @Mapping(target = "previewImage", expression = "java(database.getImage() != null ? \"/api/database/\" + database.getId() + \"/image\" : null)")
+    })
+    DatabaseDto databaseToDatabaseDto(Database database);
 
     @Mappings({
             @Mapping(target = "titles", source = "."),
@@ -531,7 +533,7 @@ public interface MetadataMapper {
                 .build();
     }
 
-    default TableDto customTableToTableDto(Table data) {
+    default TableDto tableToTableDto(Table data) {
         final TableDto table = TableDto.builder()
                 .id(data.getId())
                 .name(data.getName())
@@ -620,7 +622,8 @@ public interface MetadataMapper {
     Unique uniqueDtoToUnique(UniqueDto data);
 
     @Mappings({
-            @Mapping(target = "ownedBy", source = "owner.id")
+            @Mapping(target = "ownedBy", source = "owner.id"),
+            @Mapping(target = "database", ignore = true)
     })
     Table tableDtoToTable(TableDto data);
 
@@ -822,6 +825,9 @@ public interface MetadataMapper {
                 .trim();
     }
 
+    @Mappings({
+            @Mapping(target = "database", ignore = true)
+    })
     ViewDto viewToViewDto(View data);
 
     @Mappings({
@@ -831,6 +837,9 @@ public interface MetadataMapper {
 
     ViewBriefDto viewToViewBriefDto(View data);
 
+    @Mappings({
+            @Mapping(target = "database", ignore = true)
+    })
     View viewDtoToView(ViewDto data);
 
     /* keep */
@@ -852,60 +861,7 @@ public interface MetadataMapper {
 
     LanguageType languageTypeDtoToLanguageType(LanguageTypeDto data);
 
-    default DatabaseDto customDatabaseToDatabaseDto(Database data) {
-        if (data == null) {
-            return null;
-        }
-        final DatabaseDto database = DatabaseDto.builder()
-                .id(data.getId())
-                .name(data.getName())
-                .internalName(data.getInternalName())
-                .description(data.getDescription())
-                .exchangeName(data.getExchangeName())
-                .previewImage(data.getImage() != null ? "/api/database/" + data.getId() + "/image" : null)
-                .isPublic(data.getIsPublic())
-                .isSchemaPublic(data.getIsSchemaPublic())
-                .container(containerToContainerBriefDto(data.getContainer()))
-                .owner(userToUserBriefDto(data.getOwner()))
-                .contact(userToUserBriefDto(data.getContact()))
-                .subsets(new LinkedList<>())
-                .accesses(new LinkedList<>())
-                .tables(new LinkedList<>())
-                .identifiers(new LinkedList<>())
-                .build();
-        if (data.getSubsets() != null) {
-            database.setSubsets(new LinkedList<>(data.getSubsets()
-                    .stream()
-                    .map(this::identifierToIdentifierBriefDto)
-                    .toList()));
-        }
-        if (data.getTables() != null) {
-            database.setTables(new LinkedList<>(data.getTables()
-                    .stream()
-                    .map(this::tableToTableBriefDto)
-                    .toList()));
-        }
-        if (data.getViews() != null) {
-            database.setViews(new LinkedList<>(data.getViews()
-                    .stream()
-                    .map(this::viewToViewBriefDto)
-                    .toList()));
-        }
-        if (data.getAccesses() != null) {
-            database.setAccesses(new LinkedList<>(data.getAccesses()
-                    .stream()
-                    .filter(a -> !a.getUser().getIsInternal())
-                    .map(this::databaseAccessToDatabaseAccessDto)
-                    .toList()));
-        }
-        if (data.getIdentifiers() != null) {
-            database.setIdentifiers(new LinkedList<>(data.getIdentifiers()
-                    .stream()
-                    .map(this::identifierToIdentifierBriefDto)
-                    .toList()));
-        }
-        return database;
-    }
+    DatabaseBriefDto databaseDtoToDatabaseBriefDto(DatabaseDto data);
 
     @Mappings({
             @Mapping(target = "ownerId", source = "owner.id")
diff --git a/dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/DatabaseEndpoint.java b/dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/DatabaseEndpoint.java
index ad72fb0756f20fac58bc717c0da601f9b5bb1c74..7e0320248049b800d26d2f81b98a736bde31c6ca 100644
--- a/dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/DatabaseEndpoint.java
+++ b/dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/DatabaseEndpoint.java
@@ -5,8 +5,6 @@ import at.tuwien.api.error.ApiErrorDto;
 import at.tuwien.entities.container.Container;
 import at.tuwien.entities.database.Database;
 import at.tuwien.entities.database.DatabaseAccess;
-import at.tuwien.entities.database.View;
-import at.tuwien.entities.database.table.Table;
 import at.tuwien.entities.user.User;
 import at.tuwien.exception.*;
 import at.tuwien.mapper.MetadataMapper;
@@ -73,7 +71,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                             @Header(name = "Access-Control-Expose-Headers", description = "Expose `X-Count` custom header", schema = @Schema(implementation = String.class), required = true)},
                     content = {@Content(
                             mediaType = "application/json",
-                            array = @ArraySchema(schema = @Schema(implementation = DatabaseDto.class)))}),
+                            array = @ArraySchema(schema = @Schema(implementation = DatabaseBriefDto.class)))}),
     })
     public ResponseEntity<List<DatabaseBriefDto>> list(@RequestParam(name = "internal_name", required = false) String internalName,
                                                        Principal principal) {
@@ -118,7 +116,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                     description = "Created a new database",
                     content = {@Content(
                             mediaType = "application/json",
-                            schema = @Schema(implementation = DatabaseDto.class))}),
+                            schema = @Schema(implementation = DatabaseBriefDto.class))}),
             @ApiResponse(responseCode = "400",
                     description = "Database create query is malformed or image is not supported",
                     content = {@Content(
@@ -155,8 +153,8 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                             mediaType = "application/json",
                             schema = @Schema(implementation = ApiErrorDto.class))}),
     })
-    public ResponseEntity<DatabaseDto> create(@Valid @RequestBody DatabaseCreateDto data,
-                                              @NotNull Principal principal) throws DataServiceException,
+    public ResponseEntity<DatabaseBriefDto> create(@Valid @RequestBody DatabaseCreateDto data,
+                                                   @NotNull Principal principal) throws DataServiceException,
             DataServiceConnectionException, UserNotFoundException, DatabaseNotFoundException,
             ContainerNotFoundException, SearchServiceException, SearchServiceConnectionException,
             ContainerQuotaException {
@@ -168,8 +166,8 @@ public class DatabaseEndpoint extends AbstractEndpoint {
         }
         final User caller = userService.findById(getId(principal));
         return ResponseEntity.status(HttpStatus.CREATED)
-                .body(databaseMapper.customDatabaseToDatabaseDto(
-                        databaseService.create(container, data, caller, userService.findAllInternalUsers())));
+                .body(databaseMapper.databaseDtoToDatabaseBriefDto(databaseMapper.databaseToDatabaseDto(
+                        databaseService.create(container, data, caller, userService.findAllInternalUsers()))));
     }
 
     @PutMapping("/{databaseId}/metadata/table")
@@ -184,7 +182,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                     description = "Refreshed database tables metadata",
                     content = {@Content(
                             mediaType = "application/json",
-                            schema = @Schema(implementation = DatabaseDto.class))}),
+                            schema = @Schema(implementation = DatabaseBriefDto.class))}),
             @ApiResponse(responseCode = "400",
                     description = "Failed to parse payload at search service",
                     content = {@Content(
@@ -211,8 +209,8 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                             mediaType = "application/json",
                             schema = @Schema(implementation = ApiErrorDto.class))}),
     })
-    public ResponseEntity<DatabaseDto> refreshTableMetadata(@NotNull @PathVariable("databaseId") Long databaseId,
-                                                            @NotNull Principal principal) throws DataServiceException,
+    public ResponseEntity<DatabaseBriefDto> refreshTableMetadata(@NotNull @PathVariable("databaseId") Long databaseId,
+                                                                 @NotNull Principal principal) throws DataServiceException,
             DataServiceConnectionException, DatabaseNotFoundException, SearchServiceException, UserNotFoundException,
             SearchServiceConnectionException, NotAllowedException, QueryNotFoundException, MalformedException,
             TableNotFoundException {
@@ -222,8 +220,8 @@ public class DatabaseEndpoint extends AbstractEndpoint {
             log.error("Failed to refresh database tables metadata: not owner");
             throw new NotAllowedException("Failed to refresh tables metadata: not owner");
         }
-        return ResponseEntity.ok(databaseMapper.customDatabaseToDatabaseDto(
-                databaseService.updateTableMetadata(database)));
+        return ResponseEntity.ok(databaseMapper.databaseDtoToDatabaseBriefDto(databaseMapper.databaseToDatabaseDto(
+                databaseService.updateTableMetadata(database))));
     }
 
     @PutMapping("/{databaseId}/metadata/view")
@@ -238,7 +236,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                     description = "Refreshed database views metadata",
                     content = {@Content(
                             mediaType = "application/json",
-                            schema = @Schema(implementation = DatabaseDto.class))}),
+                            schema = @Schema(implementation = DatabaseBriefDto.class))}),
             @ApiResponse(responseCode = "403",
                     description = "Refresh view metadata is not permitted",
                     content = {@Content(
@@ -260,9 +258,9 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                             mediaType = "application/json",
                             schema = @Schema(implementation = ApiErrorDto.class))}),
     })
-    public ResponseEntity<DatabaseDto> refreshViewMetadata(@NotNull @PathVariable("databaseId") Long databaseId,
-                                                           @NotNull Principal principal) throws DataServiceException,
-            DataServiceConnectionException, DatabaseNotFoundException, SearchServiceException, UserNotFoundException,
+    public ResponseEntity<DatabaseBriefDto> refreshViewMetadata(@NotNull @PathVariable("databaseId") Long databaseId,
+                                                                @NotNull Principal principal) throws DataServiceException,
+            DataServiceConnectionException, DatabaseNotFoundException, SearchServiceException,
             SearchServiceConnectionException, NotAllowedException, QueryNotFoundException, ViewNotFoundException {
         log.debug("endpoint refresh database metadata, databaseId={}, principal.name={}", databaseId, principal.getName());
         final Database database = databaseService.findById(databaseId);
@@ -270,8 +268,8 @@ public class DatabaseEndpoint extends AbstractEndpoint {
             log.error("Failed to refresh database views metadata: not owner");
             throw new NotAllowedException("Failed to refresh database views metadata: not owner");
         }
-        return ResponseEntity.ok(databaseMapper.customDatabaseToDatabaseDto(
-                databaseService.updateViewMetadata(database)));
+        return ResponseEntity.ok(databaseMapper.databaseDtoToDatabaseBriefDto(databaseMapper.databaseToDatabaseDto(
+                databaseService.updateViewMetadata(database))));
     }
 
     @PutMapping("/{databaseId}/visibility")
@@ -286,7 +284,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                     description = "Visibility modified successfully",
                     content = {@Content(
                             mediaType = "application/json",
-                            schema = @Schema(implementation = DatabaseDto.class))}),
+                            schema = @Schema(implementation = DatabaseBriefDto.class))}),
             @ApiResponse(responseCode = "400",
                     description = "The visibility payload is malformed",
                     content = {@Content(
@@ -313,9 +311,9 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                             mediaType = "application/json",
                             schema = @Schema(implementation = ApiErrorDto.class))}),
     })
-    public ResponseEntity<DatabaseDto> visibility(@NotNull @PathVariable("databaseId") Long databaseId,
-                                                  @Valid @RequestBody DatabaseModifyVisibilityDto data,
-                                                  @NotNull Principal principal) throws DatabaseNotFoundException,
+    public ResponseEntity<DatabaseBriefDto> visibility(@NotNull @PathVariable("databaseId") Long databaseId,
+                                                       @Valid @RequestBody DatabaseModifyVisibilityDto data,
+                                                       @NotNull Principal principal) throws DatabaseNotFoundException,
             NotAllowedException, SearchServiceException, SearchServiceConnectionException, UserNotFoundException {
         log.debug("endpoint modify database visibility, databaseId={}, data={}", databaseId, data);
         final Database database = databaseService.findById(databaseId);
@@ -324,8 +322,8 @@ public class DatabaseEndpoint extends AbstractEndpoint {
             throw new NotAllowedException("Failed to modify database visibility: not owner");
         }
         return ResponseEntity.accepted()
-                .body(databaseMapper.customDatabaseToDatabaseDto(
-                        databaseService.modifyVisibility(database, data)));
+                .body(databaseMapper.databaseDtoToDatabaseBriefDto(databaseMapper.databaseToDatabaseDto(
+                        databaseService.modifyVisibility(database, data))));
     }
 
     @PutMapping("/{databaseId}/owner")
@@ -340,7 +338,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                     description = "Transfer of ownership was successful",
                     content = {@Content(
                             mediaType = "application/json",
-                            schema = @Schema(implementation = DatabaseDto.class))}),
+                            schema = @Schema(implementation = DatabaseBriefDto.class))}),
             @ApiResponse(responseCode = "400",
                     description = "Owner payload is malformed",
                     content = {@Content(
@@ -367,9 +365,9 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                             mediaType = "application/json",
                             schema = @Schema(implementation = ApiErrorDto.class))}),
     })
-    public ResponseEntity<DatabaseDto> transfer(@NotNull @PathVariable("databaseId") Long databaseId,
-                                                @Valid @RequestBody DatabaseTransferDto data,
-                                                @NotNull Principal principal) throws NotAllowedException,
+    public ResponseEntity<DatabaseBriefDto> transfer(@NotNull @PathVariable("databaseId") Long databaseId,
+                                                     @Valid @RequestBody DatabaseTransferDto data,
+                                                     @NotNull Principal principal) throws NotAllowedException,
             DataServiceException, DataServiceConnectionException, DatabaseNotFoundException, UserNotFoundException,
             SearchServiceException, SearchServiceConnectionException {
         log.debug("endpoint transfer database, databaseId={}, transferDto.id={}", databaseId, data.getId());
@@ -380,8 +378,8 @@ public class DatabaseEndpoint extends AbstractEndpoint {
             throw new NotAllowedException("Failed to transfer database: not owner");
         }
         return ResponseEntity.accepted()
-                .body(databaseMapper.customDatabaseToDatabaseDto(
-                        databaseService.modifyOwner(database, newOwner)));
+                .body(databaseMapper.databaseDtoToDatabaseBriefDto(databaseMapper.databaseToDatabaseDto(
+                        databaseService.modifyOwner(database, newOwner))));
     }
 
     @PutMapping("/{databaseId}/image")
@@ -396,7 +394,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                     description = "Modify of image was successful",
                     content = {@Content(
                             mediaType = "application/json",
-                            schema = @Schema(implementation = DatabaseDto.class))}),
+                            schema = @Schema(implementation = DatabaseBriefDto.class))}),
             @ApiResponse(responseCode = "403",
                     description = "Modify of image is not permitted",
                     content = {@Content(
@@ -423,9 +421,9 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                             mediaType = "application/json",
                             schema = @Schema(implementation = ApiErrorDto.class))}),
     })
-    public ResponseEntity<DatabaseDto> modifyImage(@NotNull @PathVariable("databaseId") Long databaseId,
-                                                   @Valid @RequestBody DatabaseModifyImageDto data,
-                                                   @NotNull Principal principal) throws NotAllowedException,
+    public ResponseEntity<DatabaseBriefDto> modifyImage(@NotNull @PathVariable("databaseId") Long databaseId,
+                                                        @Valid @RequestBody DatabaseModifyImageDto data,
+                                                        @NotNull Principal principal) throws NotAllowedException,
             DatabaseNotFoundException, SearchServiceException, SearchServiceConnectionException,
             StorageUnavailableException, StorageNotFoundException {
         log.debug("endpoint modify database image, databaseId={}, data.key={}", databaseId, data.getKey());
@@ -439,8 +437,8 @@ public class DatabaseEndpoint extends AbstractEndpoint {
             image = storageService.getBytes(data.getKey());
         }
         return ResponseEntity.accepted()
-                .body(databaseMapper.customDatabaseToDatabaseDto(
-                        databaseService.modifyImage(database, image)));
+                .body(databaseMapper.databaseDtoToDatabaseBriefDto(databaseMapper.databaseToDatabaseDto(
+                        databaseService.modifyImage(database, image))));
     }
 
     @GetMapping("/{databaseId}/image")
@@ -480,7 +478,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                             @Header(name = "Access-Control-Expose-Headers", description = "Expose custom headers", schema = @Schema(implementation = String.class))},
                     content = {@Content(
                             mediaType = "application/json",
-                            schema = @Schema(implementation = DatabaseDto.class))}),
+                            schema = @Schema(implementation = DatabaseBriefDto.class))}),
             @ApiResponse(responseCode = "403",
                     description = "Not allowed to view database",
                     content = {@Content(
@@ -546,7 +544,7 @@ public class DatabaseEndpoint extends AbstractEndpoint {
                     .toList());
             database.setAccesses(List.of());
         }
-        final DatabaseDto dto = databaseMapper.customDatabaseToDatabaseDto(database);
+        final DatabaseDto dto = databaseMapper.databaseToDatabaseDto(database);
         final HttpHeaders headers = new HttpHeaders();
         if (isSystem(principal)) {
             headers.set("X-Username", database.getContainer().getPrivilegedUsername());
diff --git a/dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/TableEndpoint.java b/dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/TableEndpoint.java
index 9f4542fc023f8aaf336fc2de196d0c36ab93cea4..39d7f614608534c5252bcfe92cd749b251660ddb 100644
--- a/dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/TableEndpoint.java
+++ b/dbrepo-metadata-service/rest-service/src/main/java/at/tuwien/endpoints/TableEndpoint.java
@@ -370,7 +370,7 @@ public class TableEndpoint extends AbstractEndpoint {
         endpointValidator.validateOnlyAccess(database, principal, true);
         endpointValidator.validateColumnCreateConstraints(data);
         return ResponseEntity.status(HttpStatus.CREATED)
-                .body(metadataMapper.customTableToTableDto(
+                .body(metadataMapper.tableToTableDto(
                         tableService.createTable(database, data, principal)));
     }
 
@@ -428,7 +428,7 @@ public class TableEndpoint extends AbstractEndpoint {
             throw new NotAllowedException("Failed to update table: not owner");
         }
         return ResponseEntity.accepted()
-                .body(metadataMapper.customTableToTableDto(
+                .body(metadataMapper.tableToTableDto(
                         tableService.updateTable(table, data)));
     }
 
@@ -513,7 +513,7 @@ public class TableEndpoint extends AbstractEndpoint {
         }
         return ResponseEntity.ok()
                 .headers(headers)
-                .body(metadataMapper.customTableToTableDto(table));
+                .body(metadataMapper.tableToTableDto(table));
     }
 
     @DeleteMapping("/{tableId}")
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/endpoints/DatabaseEndpointUnitTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/endpoints/DatabaseEndpointUnitTest.java
index 11d64faf8b9562ff42ab2120d5f6fa151710d462..371e710faed24100589904d8e82a9934edf18dae 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/endpoints/DatabaseEndpointUnitTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/endpoints/DatabaseEndpointUnitTest.java
@@ -198,7 +198,7 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
                 .thenReturn(DATABASE_1);
 
         /* test */
-        final ResponseEntity<DatabaseDto> response = databaseEndpoint.refreshTableMetadata(DATABASE_1_ID, USER_1_PRINCIPAL);
+        final ResponseEntity<DatabaseBriefDto> response = databaseEndpoint.refreshTableMetadata(DATABASE_1_ID, USER_1_PRINCIPAL);
         assertEquals(HttpStatus.OK, response.getStatusCode());
         assertNotNull(response.getBody());
     }
@@ -218,7 +218,7 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
                 .thenReturn(DATABASE_1);
 
         /* test */
-        final ResponseEntity<DatabaseDto> response = databaseEndpoint.refreshViewMetadata(DATABASE_1_ID, USER_1_PRINCIPAL);
+        final ResponseEntity<DatabaseBriefDto> response = databaseEndpoint.refreshViewMetadata(DATABASE_1_ID, USER_1_PRINCIPAL);
         assertEquals(HttpStatus.OK, response.getStatusCode());
         assertNotNull(response.getBody());
     }
@@ -682,7 +682,7 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
                 .thenReturn(DATABASE_1);
 
         /* test */
-        final ResponseEntity<DatabaseDto> response = databaseEndpoint.create(data, principal);
+        final ResponseEntity<DatabaseBriefDto> response = databaseEndpoint.create(data, principal);
         assertEquals(HttpStatus.CREATED, response.getStatusCode());
         assertNotNull(response.getBody());
     }
@@ -704,7 +704,7 @@ public class DatabaseEndpointUnitTest extends AbstractUnitTest {
         }
 
         /* test */
-        final ResponseEntity<DatabaseDto> response = databaseEndpoint.visibility(databaseId, data, principal);
+        final ResponseEntity<DatabaseBriefDto> response = databaseEndpoint.visibility(databaseId, data, principal);
         assertEquals(HttpStatus.ACCEPTED, response.getStatusCode());
         assertNotNull(response.getBody());
     }
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/gateway/DataServiceGatewayUnitTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/gateway/DataServiceGatewayUnitTest.java
index daeb1c1a96340323c85ca15080a3bc9d2685823e..c423d6b1ae5ef11aaaf47a11eda5af6147db579c 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/gateway/DataServiceGatewayUnitTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/gateway/DataServiceGatewayUnitTest.java
@@ -2,7 +2,7 @@ package at.tuwien.gateway;
 
 import at.tuwien.ExportResourceDto;
 import at.tuwien.api.database.AccessTypeDto;
-import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.DatabaseBriefDto;
 import at.tuwien.api.database.ViewDto;
 import at.tuwien.api.database.query.QueryDto;
 import at.tuwien.api.database.table.TableDto;
@@ -252,9 +252,9 @@ public class DataServiceGatewayUnitTest extends AbstractUnitTest {
             DatabaseNotFoundException {
 
         /* mock */
-        when(dataServiceRestTemplate.exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseDto.class)))
+        when(dataServiceRestTemplate.exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseBriefDto.class)))
                 .thenReturn(ResponseEntity.status(HttpStatus.CREATED)
-                        .body(DATABASE_1_DTO));
+                        .body(DATABASE_1_BRIEF_DTO));
 
         /* test */
         dataServiceGateway.createDatabase(DATABASE_1_CREATE_INTERNAL);
@@ -266,7 +266,7 @@ public class DataServiceGatewayUnitTest extends AbstractUnitTest {
         /* mock */
         doThrow(HttpServerErrorException.class)
                 .when(dataServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(DataServiceConnectionException.class, () -> {
@@ -280,7 +280,7 @@ public class DataServiceGatewayUnitTest extends AbstractUnitTest {
         /* mock */
         doThrow(HttpClientErrorException.Unauthorized.class)
                 .when(dataServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(DataServiceException.class, () -> {
@@ -294,7 +294,7 @@ public class DataServiceGatewayUnitTest extends AbstractUnitTest {
         /* mock */
         doThrow(HttpClientErrorException.BadRequest.class)
                 .when(dataServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(DataServiceException.class, () -> {
@@ -306,7 +306,7 @@ public class DataServiceGatewayUnitTest extends AbstractUnitTest {
     public void createDatabase_responseCode_fails() {
 
         /* mock */
-        when(dataServiceRestTemplate.exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseDto.class)))
+        when(dataServiceRestTemplate.exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(DatabaseBriefDto.class)))
                 .thenReturn(ResponseEntity.status(HttpStatus.NO_CONTENT)
                         .build());
 
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/gateway/SearchServiceGatewayUnitTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/gateway/SearchServiceGatewayUnitTest.java
index b1ce21d4e5e8315b08087dc0d85712509a07973e..b39dd06bac8cd722ccc6e464b1b97438f48b4850 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/gateway/SearchServiceGatewayUnitTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/gateway/SearchServiceGatewayUnitTest.java
@@ -1,7 +1,7 @@
 package at.tuwien.gateway;
 
 import at.tuwien.test.AbstractUnitTest;
-import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.DatabaseBriefDto;
 import at.tuwien.exception.*;
 import lombok.extern.log4j.Log4j2;
 import org.junit.jupiter.api.Test;
@@ -37,11 +37,11 @@ public class SearchServiceGatewayUnitTest extends AbstractUnitTest {
     @Test
     public void update_succeeds() throws DatabaseNotFoundException, SearchServiceException,
             SearchServiceConnectionException {
-        final ResponseEntity<DatabaseDto> mock = ResponseEntity.accepted()
+        final ResponseEntity<DatabaseBriefDto> mock = ResponseEntity.accepted()
                 .build();
 
         /* mock */
-        when(restTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class)))
+        when(restTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class)))
                 .thenReturn(mock);
 
         /* test */
@@ -50,11 +50,11 @@ public class SearchServiceGatewayUnitTest extends AbstractUnitTest {
 
     @Test
     public void update_badRequest_fails() {
-        final ResponseEntity<DatabaseDto> mock = ResponseEntity.status(HttpStatus.BAD_REQUEST)
+        final ResponseEntity<DatabaseBriefDto> mock = ResponseEntity.status(HttpStatus.BAD_REQUEST)
                 .build();
 
         /* mock */
-        when(restTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class)))
+        when(restTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class)))
                 .thenReturn(mock);
 
         /* test */
@@ -65,11 +65,11 @@ public class SearchServiceGatewayUnitTest extends AbstractUnitTest {
 
     @Test
     public void update_unexpectedResponse_fails() {
-        final ResponseEntity<DatabaseDto> mock = ResponseEntity.status(HttpStatus.OK)
+        final ResponseEntity<DatabaseBriefDto> mock = ResponseEntity.status(HttpStatus.OK)
                 .build();
 
         /* mock */
-        when(restTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class)))
+        when(restTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class)))
                 .thenReturn(mock);
 
         /* test */
@@ -84,7 +84,7 @@ public class SearchServiceGatewayUnitTest extends AbstractUnitTest {
         /* mock */
         doThrow(HttpServerErrorException.ServiceUnavailable.class)
                 .when(restTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceConnectionException.class, () -> {
@@ -98,7 +98,7 @@ public class SearchServiceGatewayUnitTest extends AbstractUnitTest {
         /* mock */
         doThrow(HttpClientErrorException.NotFound.class)
                 .when(restTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(DatabaseNotFoundException.class, () -> {
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/mapper/MetadataMapperUnitTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/mapper/MetadataMapperUnitTest.java
index 9b778e67fb3243e238053972add0f3522c07b9d6..6505506eeaca607cd96e3324e869c2db0907cc4f 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/mapper/MetadataMapperUnitTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/mapper/MetadataMapperUnitTest.java
@@ -1,13 +1,7 @@
 package at.tuwien.mapper;
 
-import at.tuwien.api.database.DatabaseDto;
-import at.tuwien.api.database.ViewBriefDto;
-import at.tuwien.api.database.ViewDto;
-import at.tuwien.api.database.table.TableBriefDto;
-import at.tuwien.api.identifier.IdentifierDto;
 import at.tuwien.api.identifier.IdentifierTypeDto;
 import at.tuwien.api.user.UserBriefDto;
-import at.tuwien.api.user.UserDto;
 import at.tuwien.entities.identifier.Identifier;
 import at.tuwien.entities.identifier.IdentifierType;
 import at.tuwien.test.AbstractUnitTest;
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/AccessServiceUnitTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/AccessServiceUnitTest.java
index c647cdbd7403b5f5c742953fd9978e0c8d98ab06..1c96e6283d3d62bc5c31652f82a73312454e2035 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/AccessServiceUnitTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/AccessServiceUnitTest.java
@@ -3,7 +3,7 @@ package at.tuwien.service;
 import at.tuwien.exception.*;
 import at.tuwien.test.AbstractUnitTest;
 import at.tuwien.api.database.AccessTypeDto;
-import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.DatabaseBriefDto;
 import at.tuwien.entities.database.AccessType;
 import at.tuwien.entities.database.Database;
 import at.tuwien.entities.database.DatabaseAccess;
@@ -80,7 +80,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
         when(dataServiceRestTemplate.exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(Void.class)))
                 .thenReturn(ResponseEntity.status(HttpStatus.CREATED)
                         .build());
-        when(searchServiceRestTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class)))
+        when(searchServiceRestTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class)))
                 .thenReturn(ResponseEntity.accepted()
                         .build());
 
@@ -155,7 +155,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.BadRequest.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceException.class, () -> {
@@ -174,7 +174,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.Unauthorized.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceException.class, () -> {
@@ -193,7 +193,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.NotFound.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(DatabaseNotFoundException.class, () -> {
@@ -212,7 +212,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpServerErrorException.InternalServerError.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceConnectionException.class, () -> {
@@ -230,7 +230,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
         when(dataServiceRestTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(Void.class)))
                 .thenReturn(ResponseEntity.accepted()
                         .build());
-        when(searchServiceRestTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class)))
+        when(searchServiceRestTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class)))
                 .thenReturn(ResponseEntity.accepted()
                         .build());
 
@@ -305,7 +305,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.BadRequest.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceException.class, () -> {
@@ -324,7 +324,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.Unauthorized.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceException.class, () -> {
@@ -343,7 +343,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.NotFound.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(DatabaseNotFoundException.class, () -> {
@@ -362,7 +362,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpServerErrorException.InternalServerError.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceConnectionException.class, () -> {
@@ -382,7 +382,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
         when(dataServiceRestTemplate.exchange(anyString(), eq(HttpMethod.DELETE), any(HttpEntity.class), eq(Void.class)))
                 .thenReturn(ResponseEntity.accepted()
                         .build());
-        when(searchServiceRestTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class)))
+        when(searchServiceRestTemplate.exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class)))
                 .thenReturn(ResponseEntity.accepted()
                         .build());
 
@@ -445,7 +445,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.BadRequest.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceException.class, () -> {
@@ -466,7 +466,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.Unauthorized.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceException.class, () -> {
@@ -487,7 +487,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpClientErrorException.NotFound.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(DatabaseNotFoundException.class, () -> {
@@ -508,7 +508,7 @@ public class AccessServiceUnitTest extends AbstractUnitTest {
                         .build());
         doThrow(HttpServerErrorException.InternalServerError.class)
                 .when(searchServiceRestTemplate)
-                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseDto.class));
+                .exchange(anyString(), eq(HttpMethod.PUT), any(HttpEntity.class), eq(DatabaseBriefDto.class));
 
         /* test */
         assertThrows(SearchServiceConnectionException.class, () -> {
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/DataCiteIdentifierServicePersistenceTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/DataCiteIdentifierServicePersistenceTest.java
index 182fe8e14ac5cd63ad1752fec07ee9b511ba8726..b77bc30d3811ed30c7994129ae2110e12903d0f9 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/DataCiteIdentifierServicePersistenceTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/DataCiteIdentifierServicePersistenceTest.java
@@ -1,20 +1,20 @@
 package at.tuwien.service;
 
+import at.tuwien.api.datacite.DataCiteBody;
+import at.tuwien.api.datacite.doi.DataCiteDoi;
 import at.tuwien.api.identifier.BibliographyTypeDto;
+import at.tuwien.entities.database.Database;
 import at.tuwien.entities.identifier.Creator;
 import at.tuwien.entities.identifier.Identifier;
 import at.tuwien.entities.identifier.IdentifierStatusType;
 import at.tuwien.entities.identifier.NameIdentifierSchemeType;
+import at.tuwien.exception.*;
+import at.tuwien.gateway.SearchServiceGateway;
 import at.tuwien.repository.ContainerRepository;
 import at.tuwien.repository.DatabaseRepository;
 import at.tuwien.repository.LicenseRepository;
 import at.tuwien.repository.UserRepository;
 import at.tuwien.test.AbstractUnitTest;
-import at.tuwien.api.datacite.DataCiteBody;
-import at.tuwien.api.datacite.doi.DataCiteDoi;
-import at.tuwien.entities.database.Database;
-import at.tuwien.exception.*;
-import at.tuwien.gateway.SearchServiceGateway;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -141,7 +141,7 @@ public class DataCiteIdentifierServicePersistenceTest extends AbstractUnitTest {
         when(restTemplate.exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(dataCiteBodyParameterizedTypeReference)))
                 .thenReturn(mock);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         dataCiteIdentifierService.save(DATABASE_1, USER_1, IDENTIFIER_1_SAVE_DTO);
@@ -156,7 +156,7 @@ public class DataCiteIdentifierServicePersistenceTest extends AbstractUnitTest {
                 .when(restTemplate)
                 .exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(dataCiteBodyParameterizedTypeReference));
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         assertThrows(MalformedException.class, () -> {
@@ -173,7 +173,7 @@ public class DataCiteIdentifierServicePersistenceTest extends AbstractUnitTest {
                 .when(restTemplate)
                 .exchange(anyString(), eq(HttpMethod.POST), any(HttpEntity.class), eq(dataCiteBodyParameterizedTypeReference));
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         assertThrows(DataServiceConnectionException.class, () -> {
@@ -332,7 +332,7 @@ public class DataCiteIdentifierServicePersistenceTest extends AbstractUnitTest {
 
         /* mock */
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         dataCiteIdentifierService.delete(IDENTIFIER_1);
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/DatabaseServiceUnitTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/DatabaseServiceUnitTest.java
index 1b6570abd821337fe032bead021cf9d5a4b9fc8c..18d037fe452cb6cdab5b4d0f0fe68b5ed6142cf0 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/DatabaseServiceUnitTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/DatabaseServiceUnitTest.java
@@ -110,7 +110,7 @@ public class DatabaseServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Database response = databaseService.modifyImage(DATABASE_1, image);
@@ -164,7 +164,7 @@ public class DatabaseServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Database response = databaseService.updateViewMetadata(DATABASE_1);
@@ -222,7 +222,7 @@ public class DatabaseServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Database response = databaseService.updateViewMetadata(DATABASE_1);
@@ -240,7 +240,7 @@ public class DatabaseServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Database response = databaseService.updateViewMetadata(DATABASE_1);
@@ -258,7 +258,7 @@ public class DatabaseServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Database response = databaseService.updateTableMetadata(DATABASE_1);
@@ -276,7 +276,7 @@ public class DatabaseServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Database response = databaseService.updateTableMetadata(DATABASE_1);
@@ -294,7 +294,7 @@ public class DatabaseServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Database response = databaseService.updateTableMetadata(DATABASE_1);
@@ -517,7 +517,7 @@ public class DatabaseServiceUnitTest extends AbstractUnitTest {
 
         /* mock */
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
 
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/IdentifierServicePersistenceTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/IdentifierServicePersistenceTest.java
index 0c87dcdd692533cd751401f9be37fee69b5186cc..40fc28fe4d89524a928d474e0d3328853bee5df7 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/IdentifierServicePersistenceTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/IdentifierServicePersistenceTest.java
@@ -176,7 +176,7 @@ public class IdentifierServicePersistenceTest extends AbstractUnitTest {
         when(dataServiceGateway.findQuery(IDENTIFIER_5_DATABASE_ID, IDENTIFIER_5_QUERY_ID))
                 .thenReturn(QUERY_2_DTO);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_2_DTO);
+                .thenReturn(DATABASE_2_BRIEF_DTO);
 
         /* test */
         identifierService.save(DATABASE_2, USER_2, IDENTIFIER_5_SAVE_DTO);
@@ -286,7 +286,7 @@ public class IdentifierServicePersistenceTest extends AbstractUnitTest {
 
         /* mock */
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         identifierService.delete(IDENTIFIER_1);
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/TableServicePersistenceTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/TableServicePersistenceTest.java
index 3126f9e9f42b36fb8dc09dfa3f8e60c88d851722..5250f7e106d7bdcd31b01e1c887b6ffd8a5cc852 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/TableServicePersistenceTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/TableServicePersistenceTest.java
@@ -112,7 +112,7 @@ public class TableServicePersistenceTest extends AbstractUnitTest {
                 .when(dataServiceGateway)
                 .createTable(DATABASE_1_ID, request);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Table response = tableService.createTable(DATABASE_1, request, USER_1_PRINCIPAL);
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/TableServiceUnitTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/TableServiceUnitTest.java
index d975e808e3dd03e3b4fd0f27d3af4b60f4fec7a1..5fb8e9ad7eecd267ffa9fb58ffc2b6404f93d737 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/TableServiceUnitTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/TableServiceUnitTest.java
@@ -135,7 +135,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         tableService.updateStatistics(TABLE_8);
@@ -224,7 +224,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final TableColumn response = tableService.update(TABLE_1_COLUMNS.get(0), request);
@@ -256,7 +256,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final TableColumn response = tableService.update(TABLE_1_COLUMNS.get(0), request);
@@ -279,7 +279,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Table response = tableService.createTable(DATABASE_1, TABLE_3_CREATE_DTO, USER_1_PRINCIPAL);
@@ -316,7 +316,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Table response = tableService.createTable(DATABASE_1, request, USER_1_PRINCIPAL);
@@ -369,7 +369,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         assertThrows(MalformedException.class, () -> {
@@ -392,7 +392,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
                 .when(dataServiceGateway)
                 .createTable(DATABASE_1_ID, TABLE_3_CREATE_DTO);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final Table response = tableService.createTable(DATABASE_1, TABLE_3_CREATE_DTO, USER_1_PRINCIPAL);
@@ -413,7 +413,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
                 .when(dataServiceGateway)
                 .createTable(DATABASE_1_ID, TABLE_5_CREATE_DTO);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         assertThrows(DataServiceException.class, () -> {
@@ -511,7 +511,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
                 .when(dataServiceGateway)
                 .deleteTable(DATABASE_1_ID, TABLE_1_ID);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         tableService.deleteTable(TABLE_1);
@@ -527,7 +527,7 @@ public class TableServiceUnitTest extends AbstractUnitTest {
                 .when(dataServiceGateway)
                 .deleteTable(DATABASE_1_ID, TABLE_4_ID);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         tableService.deleteTable(TABLE_4);
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/ViewServicePersistenceTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/ViewServicePersistenceTest.java
index 8ca002472a085a58ea5ee58fff8a2a0614c94fd9..57a84965dc81615613f201e6aee4e771582ac090 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/ViewServicePersistenceTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/ViewServicePersistenceTest.java
@@ -89,7 +89,7 @@ public class ViewServicePersistenceTest extends AbstractUnitTest {
                 .when(dataServiceGateway)
                 .deleteView(DATABASE_1_ID, VIEW_1_ID);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         viewService.delete(VIEW_1);
diff --git a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/ViewServiceUnitTest.java b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/ViewServiceUnitTest.java
index cd9fe03c655d33b014239af4f05f0f0ae9b6d1e9..c63d207e6e3f1022ce861a967016206b7702ee95 100644
--- a/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/ViewServiceUnitTest.java
+++ b/dbrepo-metadata-service/rest-service/src/test/java/at/tuwien/service/ViewServiceUnitTest.java
@@ -62,7 +62,7 @@ public class ViewServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         final View response = viewService.create(DATABASE_1, USER_1, request);
@@ -117,7 +117,7 @@ public class ViewServiceUnitTest extends AbstractUnitTest {
         when(databaseRepository.save(any(Database.class)))
                 .thenReturn(DATABASE_1);
         when(searchServiceGateway.update(any(Database.class)))
-                .thenReturn(DATABASE_1_DTO);
+                .thenReturn(DATABASE_1_BRIEF_DTO);
 
         /* test */
         viewService.delete(VIEW_1);
diff --git a/dbrepo-metadata-service/services/src/main/java/at/tuwien/gateway/SearchServiceGateway.java b/dbrepo-metadata-service/services/src/main/java/at/tuwien/gateway/SearchServiceGateway.java
index f5e2f49c02023fe9145f137089e4550c9ae5b769..6632a08194411f74d5b4d22d4f1e0de6eda91a47 100644
--- a/dbrepo-metadata-service/services/src/main/java/at/tuwien/gateway/SearchServiceGateway.java
+++ b/dbrepo-metadata-service/services/src/main/java/at/tuwien/gateway/SearchServiceGateway.java
@@ -1,12 +1,12 @@
 package at.tuwien.gateway;
 
-import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.DatabaseBriefDto;
 import at.tuwien.entities.database.Database;
 import at.tuwien.exception.*;
 
 public interface SearchServiceGateway {
 
-    DatabaseDto update(Database database) throws SearchServiceConnectionException, SearchServiceException, DatabaseNotFoundException;
+    DatabaseBriefDto update(Database database) throws SearchServiceConnectionException, SearchServiceException, DatabaseNotFoundException;
 
     void delete(Long databaseId) throws SearchServiceConnectionException, SearchServiceException, DatabaseNotFoundException;
 }
diff --git a/dbrepo-metadata-service/services/src/main/java/at/tuwien/gateway/impl/SearchServiceGatewayImpl.java b/dbrepo-metadata-service/services/src/main/java/at/tuwien/gateway/impl/SearchServiceGatewayImpl.java
index 0f14b8d34826fe94829146f53a0cc22fb9e97333..503cad47ec5d2a8abd7ec4e76757b2f8ddb48ecd 100644
--- a/dbrepo-metadata-service/services/src/main/java/at/tuwien/gateway/impl/SearchServiceGatewayImpl.java
+++ b/dbrepo-metadata-service/services/src/main/java/at/tuwien/gateway/impl/SearchServiceGatewayImpl.java
@@ -1,6 +1,6 @@
 package at.tuwien.gateway.impl;
 
-import at.tuwien.api.database.DatabaseDto;
+import at.tuwien.api.database.DatabaseBriefDto;
 import at.tuwien.config.GatewayConfig;
 import at.tuwien.entities.database.Database;
 import at.tuwien.exception.DatabaseNotFoundException;
@@ -35,8 +35,8 @@ public class SearchServiceGatewayImpl implements SearchServiceGateway {
     }
 
     @Override
-    public DatabaseDto update(Database database) throws SearchServiceConnectionException, SearchServiceException, DatabaseNotFoundException {
-        final ResponseEntity<DatabaseDto> response;
+    public DatabaseBriefDto update(Database database) throws SearchServiceConnectionException, SearchServiceException, DatabaseNotFoundException {
+        final ResponseEntity<DatabaseBriefDto> response;
         final HttpHeaders headers = new HttpHeaders();
         headers.set("Accept", "application/json");
         headers.set("Content-Type", "application/json");
@@ -44,7 +44,7 @@ public class SearchServiceGatewayImpl implements SearchServiceGateway {
         log.trace("update database at endpoint {} with path {}", gatewayConfig.getSearchEndpoint(), path);
         try {
             response = restTemplate.exchange(path, HttpMethod.PUT, new HttpEntity<>(
-                    metadataMapper.databaseToPrivilegedDatabaseDto(database), headers), DatabaseDto.class);
+                    metadataMapper.databaseToDatabaseDto(database), headers), DatabaseBriefDto.class);
         } catch (ResourceAccessException | HttpServerErrorException.ServiceUnavailable |
                  HttpServerErrorException.InternalServerError e) {
             log.error("Failed to update database: {}", e.getMessage());
diff --git a/dbrepo-metadata-service/test/src/main/java/at/tuwien/test/AbstractUnitTest.java b/dbrepo-metadata-service/test/src/main/java/at/tuwien/test/AbstractUnitTest.java
index 91936adaf8f27c87dbd4019b4ee6ce8a67e118a5..232b4cd28020819bba79b10f689f47352b797c42 100644
--- a/dbrepo-metadata-service/test/src/main/java/at/tuwien/test/AbstractUnitTest.java
+++ b/dbrepo-metadata-service/test/src/main/java/at/tuwien/test/AbstractUnitTest.java
@@ -12,7 +12,7 @@ public abstract class AbstractUnitTest extends BaseTest {
 
     public void genesis() {
         IMAGE_1_DTO.setOperators(IMAGE_1_OPERATORS_DTO);
-        CONTAINER_1_PRIVILEGED_DTO.setImage(IMAGE_1_DTO);
+        CONTAINER_1_DTO.setImage(IMAGE_1_DTO);
         IMAGE_1.setOperators(new LinkedList<>(IMAGE_1_OPERATORS));
         CONTAINER_1.setDatabases(new LinkedList<>(List.of(DATABASE_1, DATABASE_2, DATABASE_3)));
         CONTAINER_4.setDatabases(new LinkedList<>(List.of(DATABASE_4)));
@@ -36,13 +36,12 @@ public abstract class AbstractUnitTest extends BaseTest {
         DATABASE_1.setIsSchemaPublic(DATABASE_1_SCHEMA_PUBLIC);
         DATABASE_1_USER_1_READ_ACCESS.setType(AccessType.READ);
         DATABASE_1.setAccesses(new LinkedList<>(List.of(DATABASE_1_USER_1_READ_ACCESS, DATABASE_1_USER_2_WRITE_OWN_ACCESS, DATABASE_1_USER_3_WRITE_ALL_ACCESS)));
-        DATABASE_1_PRIVILEGED_DTO.setAccesses(new LinkedList<>(List.of(DATABASE_1_USER_1_READ_ACCESS_DTO, DATABASE_1_USER_2_WRITE_OWN_ACCESS_DTO, DATABASE_1_USER_3_WRITE_ALL_ACCESS_DTO)));
+        DATABASE_1_DTO.setAccesses(new LinkedList<>(List.of(DATABASE_1_USER_1_READ_ACCESS_DTO, DATABASE_1_USER_2_WRITE_OWN_ACCESS_DTO, DATABASE_1_USER_3_WRITE_ALL_ACCESS_DTO)));
         TABLE_1.setDatabase(DATABASE_1);
         UNIT_1.setId(UNIT_1_ID);
         TABLE_1.setColumns(new LinkedList<>(TABLE_1_COLUMNS));
         TABLE_1.setConstraints(TABLE_1_CONSTRAINTS);
-        TABLE_1_PRIVILEGED_DTO.setColumns(new LinkedList<>(TABLE_1_COLUMNS_DTO));
-        TABLE_1_PRIVILEGED_DTO.setDatabase(DATABASE_1_PRIVILEGED_DTO);
+        TABLE_1_DTO.setColumns(new LinkedList<>(TABLE_1_COLUMNS_DTO));
         VIEW_1_DTO.setIdentifiers(VIEW_1_DTO_IDENTIFIERS);
         DATABASE_1.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_1, IDENTIFIER_2, IDENTIFIER_3, IDENTIFIER_4)));
         IDENTIFIER_1.setDatabase(DATABASE_1);
@@ -51,18 +50,17 @@ public abstract class AbstractUnitTest extends BaseTest {
         IDENTIFIER_4.setDatabase(DATABASE_1);
         DATABASE_1.setTables(new LinkedList<>(List.of(TABLE_1, TABLE_2, TABLE_3, TABLE_4)));
         DATABASE_1.setViews(new LinkedList<>(List.of(VIEW_1, VIEW_2, VIEW_3)));
-        DATABASE_1_PRIVILEGED_DTO.setContainer(CONTAINER_1_PRIVILEGED_DTO);
-        DATABASE_1_PRIVILEGED_DTO.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_1_DTO, IDENTIFIER_2_DTO, IDENTIFIER_3_DTO, IDENTIFIER_4_DTO)));
-        DATABASE_1_PRIVILEGED_DTO.setTables(new LinkedList<>(List.of(TABLE_1_DTO, TABLE_2_DTO, TABLE_3_DTO, TABLE_4_DTO)));
-        DATABASE_1_PRIVILEGED_DTO.setViews(new LinkedList<>(List.of(VIEW_1_DTO, VIEW_2_DTO, VIEW_3_DTO)));
+        DATABASE_1_DTO.setContainer(CONTAINER_1_DTO);
+        DATABASE_1_DTO.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_1_DTO, IDENTIFIER_2_DTO, IDENTIFIER_3_DTO, IDENTIFIER_4_DTO)));
+        DATABASE_1_DTO.setTables(new LinkedList<>(List.of(TABLE_1_DTO, TABLE_2_DTO, TABLE_3_DTO, TABLE_4_DTO)));
+        DATABASE_1_DTO.setViews(new LinkedList<>(List.of(VIEW_1_DTO, VIEW_2_DTO, VIEW_3_DTO)));
         TABLE_1_DTO.setColumns(new LinkedList<>(TABLE_1_COLUMNS_DTO));
         TABLE_1_DTO.setConstraints(TABLE_1_CONSTRAINTS_DTO);
         TABLE_2.setDatabase(DATABASE_1);
         TABLE_2.setColumns(new LinkedList<>(TABLE_2_COLUMNS));
         TABLE_2_CONSTRAINTS.getForeignKeys().get(0).getReferences().get(0).setForeignKey(TABLE_2_CONSTRAINTS.getForeignKeys().get(0));
         TABLE_2.setConstraints(TABLE_2_CONSTRAINTS);
-        TABLE_2_PRIVILEGED_DTO.setColumns(new LinkedList<>(TABLE_2_COLUMNS_DTO));
-        TABLE_2_PRIVILEGED_DTO.setDatabase(DATABASE_1_PRIVILEGED_DTO);
+        TABLE_2_DTO.setColumns(new LinkedList<>(TABLE_2_COLUMNS_DTO));
         TABLE_2_DTO.setColumns(new LinkedList<>(TABLE_2_COLUMNS_DTO));
         TABLE_2_DTO.setConstraints(TABLE_2_CONSTRAINTS_DTO);
         TABLE_3.setDatabase(DATABASE_1);
@@ -78,13 +76,10 @@ public abstract class AbstractUnitTest extends BaseTest {
         VIEW_1.setDatabase(DATABASE_1);
         VIEW_1.setColumns(new LinkedList<>(VIEW_1_COLUMNS));
         VIEW_1.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_3)));
-        VIEW_1_PRIVILEGED_DTO.setDatabase(DATABASE_1_PRIVILEGED_DTO);
         VIEW_2.setDatabase(DATABASE_1);
         VIEW_2.setColumns(new LinkedList<>(VIEW_2_COLUMNS));
-        VIEW_2_PRIVILEGED_DTO.setDatabase(DATABASE_1_PRIVILEGED_DTO);
         VIEW_3.setDatabase(DATABASE_1);
         VIEW_3.setColumns(new LinkedList<>(VIEW_3_COLUMNS));
-        VIEW_3_PRIVILEGED_DTO.setDatabase(DATABASE_1_PRIVILEGED_DTO);
         IDENTIFIER_1.setDatabase(DATABASE_1);
         IDENTIFIER_2.setDatabase(DATABASE_1);
         IDENTIFIER_3.setDatabase(DATABASE_1);
@@ -92,20 +87,19 @@ public abstract class AbstractUnitTest extends BaseTest {
         /* DATABASE 2 */
         DATABASE_2.setSubsets(new LinkedList<>());
         DATABASE_2.setAccesses(new LinkedList<>(List.of(DATABASE_2_USER_2_WRITE_ALL_ACCESS, DATABASE_2_USER_3_READ_ACCESS)));
-        DATABASE_2_PRIVILEGED_DTO.setAccesses(new LinkedList<>(List.of(DATABASE_2_USER_2_WRITE_ALL_ACCESS_DTO, DATABASE_2_USER_3_READ_ACCESS_DTO)));
+        DATABASE_2_DTO.setAccesses(new LinkedList<>(List.of(DATABASE_2_USER_2_WRITE_ALL_ACCESS_DTO, DATABASE_2_USER_3_READ_ACCESS_DTO)));
         DATABASE_2.setTables(new LinkedList<>(List.of(TABLE_5, TABLE_6, TABLE_7)));
         VIEW_4.setColumns(new LinkedList<>(VIEW_4_COLUMNS));
         DATABASE_2.setViews(new LinkedList<>(List.of(VIEW_4)));
         DATABASE_2.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_5)));
-        DATABASE_2_PRIVILEGED_DTO.setTables(new LinkedList<>(List.of(TABLE_5_DTO, TABLE_6_DTO, TABLE_7_DTO)));
-        DATABASE_2_PRIVILEGED_DTO.setViews(new LinkedList<>(List.of(VIEW_4_DTO)));
-        DATABASE_2_PRIVILEGED_DTO.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_5_DTO)));
+        DATABASE_2_DTO.setTables(new LinkedList<>(List.of(TABLE_5_DTO, TABLE_6_DTO, TABLE_7_DTO)));
+        DATABASE_2_DTO.setViews(new LinkedList<>(List.of(VIEW_4_DTO)));
+        DATABASE_2_DTO.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_5_DTO)));
         TABLE_5.setDatabase(DATABASE_2);
         TABLE_5.setColumns(new LinkedList<>(TABLE_5_COLUMNS));
         TABLE_5.setConstraints(TABLE_5_CONSTRAINTS);
-        TABLE_5_PRIVILEGED_DTO.setColumns(new LinkedList<>(TABLE_5_COLUMNS_DTO));
-        TABLE_5_PRIVILEGED_DTO.setConstraints(TABLE_5_CONSTRAINTS_DTO);
-        TABLE_5_PRIVILEGED_DTO.setDatabase(DATABASE_2_PRIVILEGED_DTO);
+        TABLE_5_DTO.setColumns(new LinkedList<>(TABLE_5_COLUMNS_DTO));
+        TABLE_5_DTO.setConstraints(TABLE_5_CONSTRAINTS_DTO);
         TABLE_5_DTO.setColumns(TABLE_5_COLUMNS_DTO);
         TABLE_5_DTO.setConstraints(TABLE_5_CONSTRAINTS_DTO);
         TABLE_6.setDatabase(DATABASE_2);
@@ -128,27 +122,31 @@ public abstract class AbstractUnitTest extends BaseTest {
         DATABASE_3.setTables(new LinkedList<>(List.of(TABLE_8)));
         DATABASE_3.setViews(new LinkedList<>(List.of(VIEW_5)));
         DATABASE_3.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_6)));
+        DATABASE_3_DTO.setTables(new LinkedList<>(List.of(TABLE_8_DTO)));
+        DATABASE_3_DTO.setViews(new LinkedList<>(List.of(VIEW_5_DTO)));
+        DATABASE_3_DTO.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_6_DTO)));
         TABLE_8.setDatabase(DATABASE_3);
         TABLE_8.setColumns(new LinkedList<>(TABLE_8_COLUMNS));
         TABLE_8.setConstraints(TABLE_8_CONSTRAINTS);
         TABLE_8_DTO.setColumns(new LinkedList<>(TABLE_8_COLUMNS_DTO));
         TABLE_8_DTO.setConstraints(TABLE_8_CONSTRAINTS_DTO);
-        TABLE_8_PRIVILEGED_DTO.setColumns(new LinkedList<>(TABLE_8_COLUMNS_DTO));
-        TABLE_8_PRIVILEGED_DTO.setConstraints(TABLE_8_CONSTRAINTS_DTO);
-        TABLE_8_PRIVILEGED_DTO.setDatabase(DATABASE_3_PRIVILEGED_DTO);
+        TABLE_8_DTO.setColumns(new LinkedList<>(TABLE_8_COLUMNS_DTO));
+        TABLE_8_DTO.setConstraints(TABLE_8_CONSTRAINTS_DTO);
         VIEW_5.setDatabase(DATABASE_3);
         VIEW_5.setColumns(VIEW_5_COLUMNS);
         VIEW_5_DTO.setColumns(VIEW_5_COLUMNS_DTO);
         IDENTIFIER_6.setDatabase(DATABASE_3);
         /* DATABASE 4 */
+        DATABASE_4.setSubsets(new LinkedList<>());
+        DATABASE_4.setAccesses(new LinkedList<>(List.of(DATABASE_4_USER_1_READ_ACCESS, DATABASE_4_USER_2_WRITE_OWN_ACCESS, DATABASE_4_USER_3_WRITE_ALL_ACCESS)));
+        DATABASE_4.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_7)));
+        DATABASE_4_DTO.setTables(new LinkedList<>(List.of(TABLE_9_DTO)));
+        DATABASE_4_DTO.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_7_DTO)));
         TABLE_9.setDatabase(DATABASE_4);
         TABLE_9.setColumns(TABLE_9_COLUMNS);
         TABLE_9.setConstraints(TABLE_9_CONSTRAINTS);
         TABLE_9_DTO.setColumns(TABLE_9_COLUMNS_DTO);
         TABLE_9_DTO.setConstraints(TABLE_9_CONSTRAINTS_DTO);
-        DATABASE_4.setSubsets(new LinkedList<>());
-        DATABASE_4.setAccesses(new LinkedList<>(List.of(DATABASE_4_USER_1_READ_ACCESS, DATABASE_4_USER_2_WRITE_OWN_ACCESS, DATABASE_4_USER_3_WRITE_ALL_ACCESS)));
-        DATABASE_4.setIdentifiers(new LinkedList<>(List.of(IDENTIFIER_7)));
         IDENTIFIER_7.setStatus(IdentifierStatusType.DRAFT);
         IDENTIFIER_7.setDatabase(DATABASE_4);
     }
diff --git a/dbrepo-metadata-service/test/src/main/java/at/tuwien/test/BaseTest.java b/dbrepo-metadata-service/test/src/main/java/at/tuwien/test/BaseTest.java
index 368b1d182c3b4d4289426673804bab23ccd8c0e1..12dbd35efce4c2dfbbec8edb933be4c1eba59c07 100644
--- a/dbrepo-metadata-service/test/src/main/java/at/tuwien/test/BaseTest.java
+++ b/dbrepo-metadata-service/test/src/main/java/at/tuwien/test/BaseTest.java
@@ -11,11 +11,8 @@ import at.tuwien.api.auth.SignupRequestDto;
 import at.tuwien.api.container.ContainerBriefDto;
 import at.tuwien.api.container.ContainerDto;
 import at.tuwien.api.container.image.*;
-import at.tuwien.api.container.internal.PrivilegedContainerDto;
 import at.tuwien.api.database.*;
 import at.tuwien.api.database.internal.CreateDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedDatabaseDto;
-import at.tuwien.api.database.internal.PrivilegedViewDto;
 import at.tuwien.api.database.query.QueryBriefDto;
 import at.tuwien.api.database.query.QueryDto;
 import at.tuwien.api.database.table.TableBriefDto;
@@ -29,7 +26,6 @@ import at.tuwien.api.database.table.constraints.ConstraintsDto;
 import at.tuwien.api.database.table.constraints.foreign.*;
 import at.tuwien.api.database.table.constraints.primary.PrimaryKeyDto;
 import at.tuwien.api.database.table.constraints.unique.UniqueDto;
-import at.tuwien.api.database.table.internal.PrivilegedTableDto;
 import at.tuwien.api.datacite.DataCiteBody;
 import at.tuwien.api.datacite.DataCiteData;
 import at.tuwien.api.datacite.doi.DataCiteDoi;
@@ -53,7 +49,6 @@ import at.tuwien.api.semantics.*;
 import at.tuwien.api.user.UserAttributesDto;
 import at.tuwien.api.user.UserDto;
 import at.tuwien.api.user.*;
-import at.tuwien.api.user.internal.PrivilegedUserDto;
 import at.tuwien.api.user.internal.UpdateUserPasswordDto;
 import at.tuwien.entities.container.Container;
 import at.tuwien.entities.container.image.ContainerImage;
@@ -553,7 +548,7 @@ public abstract class BaseTest {
                     .build())
             .build();
 
-    public final static PrivilegedUserDto USER_1_PRIVILEGED_DTO = PrivilegedUserDto.builder()
+    public final static UserDto USER_1_PRIVILEGED_DTO = UserDto.builder()
             .id(USER_1_ID)
             .username(USER_1_USERNAME)
             .password(USER_1_PASSWORD)
@@ -741,7 +736,7 @@ public abstract class BaseTest {
             .tags(new String[]{})
             .build();
 
-    public final static PrivilegedUserDto USER_2_PRIVILEGED_DTO = PrivilegedUserDto.builder()
+    public final static UserDto USER_2_PRIVILEGED_DTO = UserDto.builder()
             .id(USER_2_ID)
             .username(USER_2_USERNAME)
             .password(USER_2_PASSWORD)
@@ -843,7 +838,7 @@ public abstract class BaseTest {
             .tags(new String[]{})
             .build();
 
-    public final static PrivilegedUserDto USER_3_PRIVILEGED_DTO = PrivilegedUserDto.builder()
+    public final static UserDto USER_3_PRIVILEGED_DTO = UserDto.builder()
             .id(USER_3_ID)
             .username(USER_3_USERNAME)
             .password(USER_3_PASSWORD)
@@ -925,7 +920,7 @@ public abstract class BaseTest {
     public final static Principal USER_4_PRINCIPAL = new UsernamePasswordAuthenticationToken(USER_4_DETAILS,
             USER_4_PASSWORD, USER_4_DETAILS.getAuthorities());
 
-    public final static PrivilegedUserDto USER_4_PRIVILEGED_DTO = PrivilegedUserDto.builder()
+    public final static UserDto USER_4_PRIVILEGED_DTO = UserDto.builder()
             .id(USER_4_ID)
             .username(USER_4_USERNAME)
             .password(USER_4_PASSWORD)
@@ -973,7 +968,7 @@ public abstract class BaseTest {
             .attributes(USER_5_ATTRIBUTES_DTO)
             .build();
 
-    public final static PrivilegedUserDto USER_5_PRIVILEGED_DTO = PrivilegedUserDto.builder()
+    public final static UserDto USER_5_PRIVILEGED_DTO = UserDto.builder()
             .id(USER_5_ID)
             .username(USER_5_USERNAME)
             .firstname(USER_5_FIRSTNAME)
@@ -1187,7 +1182,7 @@ public abstract class BaseTest {
             .image(IMAGE_1_BRIEF_DTO)
             .build();
 
-    public final static PrivilegedContainerDto CONTAINER_1_PRIVILEGED_DTO = PrivilegedContainerDto.builder()
+    public final static ContainerDto CONTAINER_1_PRIVILEGED_DTO = ContainerDto.builder()
             .id(CONTAINER_1_ID)
             .name(CONTAINER_1_NAME)
             .internalName(CONTAINER_1_INTERNALNAME)
@@ -1243,7 +1238,7 @@ public abstract class BaseTest {
             .quota(CONTAINER_2_QUOTA)
             .build();
 
-    public final static PrivilegedContainerDto CONTAINER_2_PRIVILEGED_DTO = PrivilegedContainerDto.builder()
+    public final static ContainerDto CONTAINER_2_PRIVILEGED_DTO = ContainerDto.builder()
             .id(CONTAINER_2_ID)
             .name(CONTAINER_2_NAME)
             .internalName(CONTAINER_2_INTERNALNAME)
@@ -1385,11 +1380,21 @@ public abstract class BaseTest {
             .id(DATABASE_3_ID)
             .isPublic(DATABASE_3_PUBLIC)
             .name(DATABASE_3_NAME)
-            .container(CONTAINER_1_BRIEF_DTO)
             .internalName(DATABASE_3_INTERNALNAME)
+            .owner(USER_3_BRIEF_DTO)
+            .container(CONTAINER_1_DTO)
             .exchangeName(DATABASE_3_EXCHANGE)
-            .tables(new LinkedList<>()) /* TABLE_3, TABLE_3, TABLE_3 */
-            .views(new LinkedList<>())
+            .tables(new LinkedList<>()) /* TABLE_8_DTO */
+            .views(new LinkedList<>()) /* VIEW_5_DTO */
+            .identifiers(new LinkedList<>()) /* IDENTIFIER_6_DTO */
+            .build();
+
+    public final static DatabaseBriefDto DATABASE_3_BRIEF_DTO = DatabaseBriefDto.builder()
+            .id(DATABASE_3_ID)
+            .isPublic(DATABASE_3_PUBLIC)
+            .name(DATABASE_3_NAME)
+            .internalName(DATABASE_3_INTERNALNAME)
+            .ownerId(USER_3_ID)
             .identifiers(new LinkedList<>())
             .build();
 
@@ -1411,6 +1416,17 @@ public abstract class BaseTest {
     public final static UUID DATABASE_4_OWNER = USER_4_ID;
     public final static UUID DATABASE_4_CREATOR = USER_4_ID;
 
+    public final static DatabaseBriefDto DATABASE_4_BRIEF_DTO = DatabaseBriefDto.builder()
+            .id(DATABASE_4_ID)
+            .isPublic(DATABASE_4_PUBLIC)
+            .isSchemaPublic(DATABASE_4_SCHEMA_PUBLIC)
+            .name(DATABASE_4_NAME)
+            .description(DATABASE_4_DESCRIPTION)
+            .internalName(DATABASE_4_INTERNALNAME)
+            .ownerId(USER_4_ID)
+            .identifiers(new LinkedList<>())
+            .build();
+
     public final static DatabaseDto DATABASE_4_DTO = DatabaseDto.builder()
             .id(DATABASE_4_ID)
             .isPublic(DATABASE_4_PUBLIC)
@@ -1420,9 +1436,9 @@ public abstract class BaseTest {
             .internalName(DATABASE_4_INTERNALNAME)
             .exchangeName(DATABASE_4_EXCHANGE)
             .owner(USER_4_BRIEF_DTO)
-            .tables(new LinkedList<>())
+            .tables(new LinkedList<>()) /* TABLE_9_DTO */
             .views(new LinkedList<>())
-            .identifiers(new LinkedList<>())
+            .identifiers(new LinkedList<>()) /* IDENTIFIER_7_DTO */
             .build();
 
     public final static TableCreateDto TABLE_0_CREATE_DTO = TableCreateDto.builder()
@@ -1612,10 +1628,9 @@ public abstract class BaseTest {
     public final static Instant TABLE_1_CREATED = Instant.ofEpochSecond(1677399975L) /* 2023-02-26 08:26:15 (UTC) */;
     public final static Instant TABLE_1_LAST_MODIFIED = Instant.ofEpochSecond(1677399975L) /* 2023-02-26 08:26:15 (UTC) */;
 
-    public final static PrivilegedTableDto TABLE_1_PRIVILEGED_DTO = PrivilegedTableDto.builder()
+    public final static TableDto TABLE_1_PRIVILEGED_DTO = TableDto.builder()
             .id(TABLE_1_ID)
             .tdbid(DATABASE_1_ID)
-            .database(null) /* DATABASE_1_PRIVILEGED_DTO */
             .internalName(TABLE_1_INTERNAL_NAME)
             .isVersioned(TABLE_1_VERSIONED)
             .isPublic(TABLE_1_SCHEMA_PUBLIC)
@@ -1826,10 +1841,9 @@ public abstract class BaseTest {
             .maxDataLength(TABLE_2_MAX_DATA_LENGTH)
             .build();
 
-    public final static PrivilegedTableDto TABLE_2_PRIVILEGED_DTO = PrivilegedTableDto.builder()
+    public final static TableDto TABLE_2_PRIVILEGED_DTO = TableDto.builder()
             .id(TABLE_2_ID)
             .tdbid(DATABASE_1_ID)
-            .database(null) /* DATABASE_1_PRIVILEGED_DTO */
             .internalName(TABLE_2_INTERNALNAME)
             .isVersioned(TABLE_2_VERSIONED)
             .isPublic(TABLE_2_IS_PUBLIC)
@@ -2036,10 +2050,9 @@ public abstract class BaseTest {
             .owner(USER_1_BRIEF_DTO)
             .build();
 
-    public final static PrivilegedTableDto TABLE_5_PRIVILEGED_DTO = PrivilegedTableDto.builder()
+    public final static TableDto TABLE_5_PRIVILEGED_DTO = TableDto.builder()
             .id(TABLE_5_ID)
             .tdbid(DATABASE_2_ID)
-            .database(null) /* DATABASE_2_PRIVILEGED_DTO */
             .internalName(TABLE_5_INTERNALNAME)
             .isVersioned(TABLE_5_VERSIONED)
             .isPublic(TABLE_5_IS_PUBLIC)
@@ -2407,7 +2420,7 @@ public abstract class BaseTest {
             .ownedBy(USER_1_ID)
             .build();
 
-    public final static PrivilegedTableDto TABLE_8_PRIVILEGED_DTO = PrivilegedTableDto.builder()
+    public final static TableDto TABLE_8_PRIVILEGED_DTO = TableDto.builder()
             .id(TABLE_8_ID)
             .tdbid(TABLE_8_DATABASE_ID)
             .internalName(TABLE_8_INTERNAL_NAME)
@@ -2483,7 +2496,7 @@ public abstract class BaseTest {
             .ownedBy(USER_1_ID)
             .build();
 
-    public final static PrivilegedTableDto TABLE_9_PRIVILEGED_DTO = PrivilegedTableDto.builder()
+    public final static TableDto TABLE_9_PRIVILEGED_DTO = TableDto.builder()
             .id(TABLE_9_ID)
             .tdbid(TABLE_9_DATABASE_ID)
             .internalName(TABLE_9_INTERNAL_NAME)
@@ -2979,7 +2992,7 @@ public abstract class BaseTest {
             .isPersisted(QUERY_3_PERSISTED)
             .resultNumber(2L)
             .build();
-    
+
     public final static Long QUERY_7_ID = 7L;
     public final static String QUERY_7_STATEMENT = "SELECT id, date, a.location, lat, lng FROM weather_aus a JOIN weather_location l on a.location = l.location WHERE date = '2008-12-01'";
     public final static String QUERY_7_QUERY_HASH = "df7da3801dfb5c191ff6711d79ce6455f3c09ec8323ce1ff7208ab85387263f5";
@@ -5117,10 +5130,9 @@ public abstract class BaseTest {
             .columns(VIEW_1_COLUMNS_DTO)
             .build();
 
-    public final static PrivilegedViewDto VIEW_1_PRIVILEGED_DTO = PrivilegedViewDto.builder()
+    public final static ViewDto VIEW_1_PRIVILEGED_DTO = ViewDto.builder()
             .id(VIEW_1_ID)
             .isInitialView(VIEW_1_INITIAL_VIEW)
-            .database(null) /* DATABASE_1_PRIVILEGED_DTO */
             .name(VIEW_1_NAME)
             .internalName(VIEW_1_INTERNAL_NAME)
             .vdbid(VIEW_1_DATABASE_ID)
@@ -5279,10 +5291,9 @@ public abstract class BaseTest {
             .owner(USER_1_BRIEF_DTO)
             .build();
 
-    public final static PrivilegedViewDto VIEW_2_PRIVILEGED_DTO = PrivilegedViewDto.builder()
+    public final static ViewDto VIEW_2_PRIVILEGED_DTO = ViewDto.builder()
             .id(VIEW_2_ID)
             .isInitialView(VIEW_2_INITIAL_VIEW)
-            .database(null) /* DATABASE_1_PRIVILEGED_DTO */
             .name(VIEW_2_NAME)
             .internalName(VIEW_2_INTERNAL_NAME)
             .vdbid(VIEW_2_DATABASE_ID)
@@ -5380,10 +5391,9 @@ public abstract class BaseTest {
             .owner(USER_1)
             .build();
 
-    public final static PrivilegedViewDto VIEW_3_PRIVILEGED_DTO = PrivilegedViewDto.builder()
+    public final static ViewDto VIEW_3_PRIVILEGED_DTO = ViewDto.builder()
             .id(VIEW_3_ID)
             .isInitialView(VIEW_3_INITIAL_VIEW)
-            .database(null) /* DATABASE_1_PRIVILEGED_DTO */
             .name(VIEW_3_NAME)
             .internalName(VIEW_3_INTERNAL_NAME)
             .vdbid(VIEW_3_DATABASE_ID)
@@ -7518,27 +7528,20 @@ public abstract class BaseTest {
             .id(DATABASE_1_ID)
             .isPublic(DATABASE_1_PUBLIC)
             .name(DATABASE_1_NAME)
-            .container(CONTAINER_1_BRIEF_DTO)
+            .container(CONTAINER_1_DTO)
             .internalName(DATABASE_1_INTERNALNAME)
             .exchangeName(DATABASE_1_EXCHANGE)
-            .identifiers(new LinkedList<>(List.of(IDENTIFIER_1_BRIEF_DTO, IDENTIFIER_2_BRIEF_DTO, IDENTIFIER_3_BRIEF_DTO, IDENTIFIER_4_BRIEF_DTO)))
-            .tables(new LinkedList<>(List.of(TABLE_1_BRIEF_DTO, TABLE_2_BRIEF_DTO, TABLE_3_BRIEF_DTO, TABLE_4_BRIEF_DTO)))
-            .views(new LinkedList<>(List.of(VIEW_1_BRIEF_DTO, VIEW_2_BRIEF_DTO, VIEW_3_BRIEF_DTO)))
+            .identifiers(new LinkedList<>(List.of(IDENTIFIER_1_DTO, IDENTIFIER_2_DTO, IDENTIFIER_3_DTO, IDENTIFIER_4_DTO)))
+            .tables(new LinkedList<>(List.of(TABLE_1_DTO, TABLE_2_DTO, TABLE_3_DTO, TABLE_4_DTO)))
+            .views(new LinkedList<>(List.of(VIEW_1_DTO, VIEW_2_DTO, VIEW_3_DTO)))
             .build();
 
-    public final static PrivilegedDatabaseDto DATABASE_1_PRIVILEGED_DTO = PrivilegedDatabaseDto.builder()
+    public final static DatabaseBriefDto DATABASE_1_BRIEF_DTO = DatabaseBriefDto.builder()
             .id(DATABASE_1_ID)
             .isPublic(DATABASE_1_PUBLIC)
-            .isSchemaPublic(DATABASE_1_SCHEMA_PUBLIC)
             .name(DATABASE_1_NAME)
-            .container(CONTAINER_1_PRIVILEGED_DTO)
             .internalName(DATABASE_1_INTERNALNAME)
-            .exchangeName(DATABASE_1_EXCHANGE)
-            .identifiers(new LinkedList<>(List.of(IDENTIFIER_1_DTO, IDENTIFIER_2_DTO, IDENTIFIER_3_DTO, IDENTIFIER_4_DTO)))
-            .tables(new LinkedList<>(List.of(TABLE_1_DTO, TABLE_2_DTO, TABLE_3_DTO, TABLE_4_DTO)))
-            .views(new LinkedList<>(List.of(VIEW_1_DTO, VIEW_2_DTO, VIEW_3_DTO)))
-            .owner(USER_1_BRIEF_DTO)
-            .lastRetrieved(Instant.now())
+            .identifiers(new LinkedList<>(List.of(IDENTIFIER_1_BRIEF_DTO, IDENTIFIER_2_BRIEF_DTO, IDENTIFIER_3_BRIEF_DTO, IDENTIFIER_4_BRIEF_DTO)))
             .build();
 
     public final static DatabaseAccess DATABASE_1_USER_1_READ_ACCESS = DatabaseAccess.builder()
@@ -7672,7 +7675,7 @@ public abstract class BaseTest {
             .identifiers(new LinkedList<>())
             .build();
 
-    public final static PrivilegedDatabaseDto DATABASE_2_PRIVILEGED_DTO = PrivilegedDatabaseDto.builder()
+    public final static DatabaseDto DATABASE_2_DTO = DatabaseDto.builder()
             .id(DATABASE_2_ID)
             .isPublic(DATABASE_2_PUBLIC)
             .isSchemaPublic(DATABASE_2_SCHEMA_PUBLIC)
@@ -7687,18 +7690,13 @@ public abstract class BaseTest {
             .lastRetrieved(Instant.now())
             .build();
 
-    public final static DatabaseDto DATABASE_2_DTO = DatabaseDto.builder()
+    public final static DatabaseBriefDto DATABASE_2_BRIEF_DTO = DatabaseBriefDto.builder()
             .id(DATABASE_2_ID)
             .isPublic(DATABASE_2_PUBLIC)
             .name(DATABASE_2_NAME)
-            .container(CONTAINER_1_BRIEF_DTO)
             .internalName(DATABASE_2_INTERNALNAME)
-            .exchangeName(DATABASE_2_EXCHANGE)
             .identifiers(new LinkedList<>(List.of(IDENTIFIER_5_BRIEF_DTO)))
-            .tables(new LinkedList<>(List.of(TABLE_5_BRIEF_DTO, TABLE_6_BRIEF_DTO, TABLE_7_BRIEF_DTO)))
-            .views(new LinkedList<>(List.of(VIEW_4_BRIEF_DTO)))
-            .identifiers(new LinkedList<>())
-            .owner(USER_2_BRIEF_DTO)
+            .ownerId(USER_2_ID)
             .build();
 
     public final static DatabaseAccess DATABASE_2_USER_1_READ_ACCESS = DatabaseAccess.builder()
@@ -7924,21 +7922,6 @@ public abstract class BaseTest {
             .user(USER_3_BRIEF_DTO)
             .build();
 
-    public final static PrivilegedDatabaseDto DATABASE_3_PRIVILEGED_DTO = PrivilegedDatabaseDto.builder()
-            .id(DATABASE_3_ID)
-            .isPublic(DATABASE_3_PUBLIC)
-            .isSchemaPublic(DATABASE_3_SCHEMA_PUBLIC)
-            .name(DATABASE_3_NAME)
-            .container(CONTAINER_1_PRIVILEGED_DTO)
-            .internalName(DATABASE_3_INTERNALNAME)
-            .exchangeName(DATABASE_3_EXCHANGE)
-            .identifiers(new LinkedList<>(List.of(IDENTIFIER_6_DTO)))
-            .tables(new LinkedList<>(List.of(TABLE_8_DTO)))
-            .views(new LinkedList<>(List.of(VIEW_5_DTO)))
-            .owner(USER_3_BRIEF_DTO)
-            .lastRetrieved(Instant.now())
-            .build();
-
     public final static Identifier IDENTIFIER_7 = Identifier.builder()
             .id(IDENTIFIER_7_ID)
             .descriptions(new LinkedList<>())
@@ -7985,21 +7968,6 @@ public abstract class BaseTest {
             .identifiers(new LinkedList<>())
             .build();
 
-    public final static PrivilegedDatabaseDto DATABASE_4_PRIVILEGED_DTO = PrivilegedDatabaseDto.builder()
-            .id(DATABASE_4_ID)
-            .isPublic(DATABASE_4_PUBLIC)
-            .isSchemaPublic(DATABASE_4_SCHEMA_PUBLIC)
-            .name(DATABASE_4_NAME)
-            .container(CONTAINER_1_PRIVILEGED_DTO)
-            .internalName(DATABASE_4_INTERNALNAME)
-            .exchangeName(DATABASE_4_EXCHANGE)
-            .identifiers(new LinkedList<>(List.of(IDENTIFIER_7_DTO)))
-            .tables(new LinkedList<>(List.of(TABLE_9_DTO)))
-            .views(new LinkedList<>(List.of()))
-            .owner(USER_3_BRIEF_DTO)
-            .lastRetrieved(Instant.now())
-            .build();
-
     public final static DatabaseAccess DATABASE_4_USER_1_READ_ACCESS = DatabaseAccess.builder()
             .type(AccessType.READ)
             .hdbid(DATABASE_4_ID)
diff --git a/dbrepo-search-service/Pipfile.lock b/dbrepo-search-service/Pipfile.lock
index c78990407791ee200448088048a436e8b662d5db..8362cd2df3676640ad25e045008240c21b77ce05 100644
--- a/dbrepo-search-service/Pipfile.lock
+++ b/dbrepo-search-service/Pipfile.lock
@@ -360,7 +360,7 @@
         },
         "dbrepo": {
             "hashes": [
-                "sha256:501b53c7e4b32774809f9685a18288da5b938fc1512e94d8b248f531ee8667fc"
+                "sha256:19c6bbcf9461e20681f0fb342087c618a91123d2d04d4df2f4fd1da80aa77b76"
             ],
             "path": "./lib/dbrepo-1.6.2.tar.gz"
         },
diff --git a/dbrepo-search-service/init/Pipfile.lock b/dbrepo-search-service/init/Pipfile.lock
index 64f5fc6cc63e79cc3ac9c94a03900a6671f9e60f..e72262e85d16a2c3518981d7efedd2b7c791a368 100644
--- a/dbrepo-search-service/init/Pipfile.lock
+++ b/dbrepo-search-service/init/Pipfile.lock
@@ -254,10 +254,9 @@
         },
         "dbrepo": {
             "hashes": [
-                "sha256:501b53c7e4b32774809f9685a18288da5b938fc1512e94d8b248f531ee8667fc"
+                "sha256:19c6bbcf9461e20681f0fb342087c618a91123d2d04d4df2f4fd1da80aa77b76"
             ],
-            "path": "./lib/dbrepo-1.6.2.tar.gz",
-            "version": "==1.6.2"
+            "path": "./lib/dbrepo-1.6.2.tar.gz"
         },
         "docker": {
             "hashes": [
@@ -279,6 +278,7 @@
                 "sha256:f69fcd559dc907ed196ab9df0e48471709175e696d6e698dd4dbe940f96ce66b"
             ],
             "index": "pypi",
+            "markers": "python_version >= '3.8'",
             "version": "==2.3.3"
         },
         "frozenlist": {
@@ -643,6 +643,7 @@
                 "sha256:6598df0bc7a003294edd0ba88a331e0793acbb8c910c43edf398791e3b2eccda"
             ],
             "index": "pypi",
+            "markers": "python_version >= '3.8' and python_version < '4'",
             "version": "==2.8.0"
         },
         "packaging": {
@@ -933,6 +934,7 @@
                 "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"
             ],
             "index": "pypi",
+            "markers": "python_version >= '3.8'",
             "version": "==8.3.4"
         },
         "python-dateutil": {
@@ -940,7 +942,7 @@
                 "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3",
                 "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"
             ],
-            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2'",
             "version": "==2.9.0.post0"
         },
         "python-dotenv": {
@@ -949,6 +951,7 @@
                 "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"
             ],
             "index": "pypi",
+            "markers": "python_version >= '3.8'",
             "version": "==1.0.1"
         },
         "pytz": {
@@ -964,6 +967,7 @@
                 "sha256:f3dcb4c106a8cd9e060d92f43d593d09ebc3d07adc244f4c7315856a12e383ee"
             ],
             "index": "pypi",
+            "markers": "python_full_version >= '3.8.1' and python_full_version < '4.0.0'",
             "version": "==7.1.3"
         },
         "requests": {
@@ -979,7 +983,7 @@
                 "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274",
                 "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81"
             ],
-            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2'",
             "version": "==1.17.0"
         },
         "testcontainers-core": {
@@ -994,6 +998,7 @@
                 "sha256:0bdf270b5b7f53915832f7c31dd2bd3ffdc20b534ea6b32231cc7003049bd0e1"
             ],
             "index": "pypi",
+            "markers": "python_version >= '3.7'",
             "version": "==0.0.1rc1"
         },
         "tinydb": {
@@ -1285,6 +1290,7 @@
                 "sha256:fd34e7b3405f0cc7ab03d54a334c17a9e802897580d964bd8c2001f4b9fd488f"
             ],
             "index": "pypi",
+            "markers": "python_version >= '3.9'",
             "version": "==7.6.10"
         },
         "iniconfig": {
@@ -1317,6 +1323,7 @@
                 "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"
             ],
             "index": "pypi",
+            "markers": "python_version >= '3.8'",
             "version": "==8.3.4"
         }
     }
diff --git a/dbrepo-search-service/init/lib/dbrepo-1.6.2.tar.gz b/dbrepo-search-service/init/lib/dbrepo-1.6.2.tar.gz
index 58081673e955d89fccf70c9161037a725b647f71..02ed2aec31c2b1881165a12d45060ed4a311192d 100644
Binary files a/dbrepo-search-service/init/lib/dbrepo-1.6.2.tar.gz and b/dbrepo-search-service/init/lib/dbrepo-1.6.2.tar.gz differ
diff --git a/dbrepo-search-service/lib/dbrepo-1.6.2.tar.gz b/dbrepo-search-service/lib/dbrepo-1.6.2.tar.gz
index 58081673e955d89fccf70c9161037a725b647f71..02ed2aec31c2b1881165a12d45060ed4a311192d 100644
Binary files a/dbrepo-search-service/lib/dbrepo-1.6.2.tar.gz and b/dbrepo-search-service/lib/dbrepo-1.6.2.tar.gz differ
diff --git a/dbrepo-ui/pages/database/[database_id]/table/[table_id]/settings.vue b/dbrepo-ui/pages/database/[database_id]/table/[table_id]/settings.vue
index 3d718d57398324f1099ceff42b80d80a55cf18b5..f9530711363fb38884ac05dcaba3d28e1b6ee82a 100644
--- a/dbrepo-ui/pages/database/[database_id]/table/[table_id]/settings.vue
+++ b/dbrepo-ui/pages/database/[database_id]/table/[table_id]/settings.vue
@@ -24,7 +24,7 @@
                     v-model="modify.description"
                     rows="2"
                     :rules="[
-                      v => !max(v, 180) || ($t('validation.max-length') + 180),
+                      v => max(v, 180) || ($t('validation.max-length') + 180),
                     ]"
                     clearable
                     counter="180"
diff --git a/lib/python/dbrepo/api/dto.py b/lib/python/dbrepo/api/dto.py
index fa7eb063fc453c3dd8fabef04f141d07012c94a3..a8518ec79e923231552d827c68c8ab6e0b75a3b1 100644
--- a/lib/python/dbrepo/api/dto.py
+++ b/lib/python/dbrepo/api/dto.py
@@ -511,6 +511,7 @@ class CreateTableColumn(BaseModel):
     name: str
     type: ColumnType
     null_allowed: bool
+    description: Optional[str] = None
     concept_uri: Optional[str] = None
     unit_uri: Optional[str] = None
     index_length: Optional[int] = None
@@ -622,6 +623,21 @@ class Identifier(BaseModel):
     publication_month: Optional[int] = None
 
 
+class IdentifierBrief(BaseModel):
+    id: int
+    database_id: int
+    type: IdentifierType
+    created_by: str
+    status: IdentifierStatusType
+    publication_year: int
+    publisher: str
+    titles: List[IdentifierTitle]
+    doi: Optional[str] = None
+    query_id: Optional[int] = None
+    table_id: Optional[int] = None
+    view_id: Optional[int] = None
+
+
 class View(BaseModel):
     id: int
     database_id: int
@@ -961,7 +977,7 @@ class ColumnMinimal(BaseModel):
     database_id: int
 
 
-class Database(BaseModel):
+class DatabaseBrief(BaseModel):
     id: int
     name: str
     owner: UserBrief
@@ -971,26 +987,36 @@ class Database(BaseModel):
     is_public: bool
     is_schema_public: bool
     container: ContainerBrief
-    identifiers: Optional[List[Identifier]] = field(default_factory=list)
-    subsets: Optional[List[Identifier]] = field(default_factory=list)
+    identifiers: Optional[List[IdentifierBrief]] = field(default_factory=list)
+    subsets: Optional[List[IdentifierBrief]] = field(default_factory=list)
+    preview_image: Optional[str] = None
     description: Optional[str] = None
-    tables: Optional[List[Table]] = field(default_factory=list)
-    views: Optional[List[View]] = field(default_factory=list)
+    tables: Optional[List[TableBrief]] = field(default_factory=list)
+    views: Optional[List[ViewBrief]] = field(default_factory=list)
     image: Optional[str] = None
     accesses: Optional[List[DatabaseAccess]] = field(default_factory=list)
-    exchange_type: Optional[str] = None
+    exchange_name: Optional[str] = None
 
 
-class DatabaseBrief(BaseModel):
+class Database(BaseModel):
     id: int
     name: str
+    owner: UserBrief
+    contact: UserBrief
+    exchange_name: str
     internal_name: str
-    description: Optional[str] = None
     is_public: bool
     is_schema_public: bool
+    container: ContainerBrief
     identifiers: Optional[List[Identifier]] = field(default_factory=list)
-    contact: UserBrief
-    owner_id: str
+    subsets: Optional[List[Identifier]] = field(default_factory=list)
+    preview_image: Optional[str] = None
+    description: Optional[str] = None
+    tables: Optional[List[Table]] = field(default_factory=list)
+    views: Optional[List[View]] = field(default_factory=list)
+    image: Optional[str] = None
+    accesses: Optional[List[DatabaseAccess]] = field(default_factory=list)
+    exchange_name: Optional[str] = None
 
 
 class Unique(BaseModel):