diff --git a/api/pom.xml b/api/pom.xml
index fef2cc86..7ce657fb 100644
--- a/api/pom.xml
+++ b/api/pom.xml
@@ -54,5 +54,52 @@
org.eclipse.daanse.mdx.model.api
0.0.1-SNAPSHOT
+
+
+ org.eclipse.daanse
+ org.eclipse.daanse.cwm.model.cwm.objectmodel.core
+ ${project.version}
+ test
+
+
+ org.eclipse.daanse
+ org.eclipse.daanse.cwm.model.cwm.resource.relational
+ ${project.version}
+ compile
+
+
+
+ org.eclipse.emf
+ org.eclipse.emf.ecore
+ compile
+
diff --git a/api/src/main/java/org/eclipse/daanse/olap/api/element/Catalog.java b/api/src/main/java/org/eclipse/daanse/olap/api/element/Catalog.java
index 829b25b6..77bb4b35 100644
--- a/api/src/main/java/org/eclipse/daanse/olap/api/element/Catalog.java
+++ b/api/src/main/java/org/eclipse/daanse/olap/api/element/Catalog.java
@@ -32,6 +32,7 @@
import java.util.List;
import java.util.Optional;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.Schema;
import org.eclipse.daanse.olap.api.Parameter;
import org.eclipse.daanse.olap.api.access.Role;
import org.eclipse.daanse.olap.api.catalog.CatalogReader;
@@ -122,4 +123,6 @@ public interface Catalog extends MetaElement {
Connection getInternalConnection();
NamedSet getNamedSet(IdentifierSegment segment);
+
+ List getRelationalSchemas();
}
diff --git a/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/DBSchemaDiscoverService.java b/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/DBSchemaDiscoverService.java
index c1e7dddd..4123da23 100644
--- a/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/DBSchemaDiscoverService.java
+++ b/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/DBSchemaDiscoverService.java
@@ -17,6 +17,7 @@
import static org.eclipse.daanse.olap.xmla.bridge.discover.Utils.getDbSchemaSchemataResponseRow;
import static org.eclipse.daanse.olap.xmla.bridge.discover.Utils.getDbSchemaSourceTablesResponseRow;
import static org.eclipse.daanse.olap.xmla.bridge.discover.Utils.getDbSchemaTablesInfoResponseRow;
+import static org.eclipse.daanse.olap.xmla.bridge.discover.Utils.getDbSchemaAssertionsResponseRow;
import static org.eclipse.daanse.olap.xmla.bridge.discover.Utils.getRoles;
import static org.eclipse.daanse.olap.xmla.bridge.discover.Utils.isDataTypeCond;
@@ -34,20 +35,74 @@
import org.eclipse.daanse.xmla.api.common.enums.ColumnOlapTypeEnum;
import org.eclipse.daanse.xmla.api.common.enums.LevelDbTypeEnum;
import org.eclipse.daanse.xmla.api.common.enums.TableTypeEnum;
+import org.eclipse.daanse.xmla.api.discover.dbschema.assertions.DbSchemaAssertionsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.assertions.DbSchemaAssertionsResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.catalogs.DbSchemaCatalogsRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.catalogs.DbSchemaCatalogsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.charactersets.DbSchemaCharacterSetsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.charactersets.DbSchemaCharacterSetsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraints.DbSchemaCheckConstraintsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraints.DbSchemaCheckConstraintsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraintsbytable.DbSchemaCheckConstraintsByTableRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraintsbytable.DbSchemaCheckConstraintsByTableResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.collations.DbSchemaCollationsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.collations.DbSchemaCollationsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.columndomainusage.DbSchemaColumnDomainUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.columndomainusage.DbSchemaColumnDomainUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.columnprivileges.DbSchemaColumnPrivilegesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.columnprivileges.DbSchemaColumnPrivilegesResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.columns.DbSchemaColumnsRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.columns.DbSchemaColumnsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.constraintcolumnusage.DbSchemaConstraintColumnUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.constraintcolumnusage.DbSchemaConstraintColumnUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.constrainttableusage.DbSchemaConstraintTableUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.constrainttableusage.DbSchemaConstraintTableUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.foreignkeys.DbSchemaForeignKeysRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.foreignkeys.DbSchemaForeignKeysResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.indexes.DbSchemaIndexesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.indexes.DbSchemaIndexesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.keycolumnusage.DbSchemaKeyColumnUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.keycolumnusage.DbSchemaKeyColumnUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.primarykeys.DbSchemaPrimaryKeysRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.primarykeys.DbSchemaPrimaryKeysResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedurecolumns.DbSchemaProcedureColumnsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedurecolumns.DbSchemaProcedureColumnsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedureparameters.DbSchemaProcedureParametersRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedureparameters.DbSchemaProcedureParametersResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedures.DbSchemaProceduresRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedures.DbSchemaProceduresResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.providertypes.DbSchemaProviderTypesRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.providertypes.DbSchemaProviderTypesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.referentialconstraints.DbSchemaReferentialConstraintsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.referentialconstraints.DbSchemaReferentialConstraintsResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.schemata.DbSchemaSchemataRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.schemata.DbSchemaSchemataResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.sourcetables.DbSchemaSourceTablesRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.sourcetables.DbSchemaSourceTablesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.sqllanguages.DbSchemaSqlLanguagesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.sqllanguages.DbSchemaSqlLanguagesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.statistics.DbSchemaStatisticsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.statistics.DbSchemaStatisticsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableconstraints.DbSchemaTableConstraintsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableconstraints.DbSchemaTableConstraintsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableprivileges.DbSchemaTablePrivilegesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableprivileges.DbSchemaTablePrivilegesResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.tables.DbSchemaTablesRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.tables.DbSchemaTablesResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.tablesinfo.DbSchemaTablesInfoRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.tablesinfo.DbSchemaTablesInfoResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tablestatistics.DbSchemaTableStatisticsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tablestatistics.DbSchemaTableStatisticsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.translations.DbSchemaTranslationsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.translations.DbSchemaTranslationsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.usageprivileges.DbSchemaUsagePrivilegesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.usageprivileges.DbSchemaUsagePrivilegesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewcolumnusage.DbSchemaViewColumnUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewcolumnusage.DbSchemaViewColumnUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.views.DbSchemaViewsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.views.DbSchemaViewsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewtableusage.DbSchemaViewTableUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewtableusage.DbSchemaViewTableUsageResponseRow;
import org.eclipse.daanse.xmla.model.record.discover.dbschema.catalogs.DbSchemaCatalogsResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.dbschema.providertypes.DbSchemaProviderTypesResponseRowR;
@@ -255,4 +310,336 @@ public List dbSchemaTablesInfo(DbSchemaTablesInfo
return List.of();
}
+ public List dbSchemaAssertions(DbSchemaAssertionsRequest request,
+ RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().constraintCatalog();
+ Optional oSchemaName = request.restrictions().constraintSchema();
+ Optional oConstraintName = request.restrictions().constraintName();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return getDbSchemaAssertionsResponseRow(oCatalog.get(), oSchemaName, oConstraintName);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> getDbSchemaAssertionsResponseRow(c, oSchemaName, oConstraintName))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaCharacterSets(DbSchemaCharacterSetsRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaCheckConstraints(DbSchemaCheckConstraintsRequest request,
+ RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().constraintCatalog();
+ Optional oSchemaName = request.restrictions().constraintSchema();
+ Optional oConstraintName = request.restrictions().constraintName();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaCheckConstraints(oCatalog.get(), oSchemaName, oConstraintName);
+ } else {
+ return List.of();
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaCheckConstraints(c, oSchemaName, oConstraintName))
+ .flatMap(Collection::stream).toList();
+ }
+ }
+
+ public List dbSchemaCheckConstraintsByTable(
+ DbSchemaCheckConstraintsByTableRequest request, RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().constraintCatalog();
+ Optional oSchemaName = request.restrictions().constraintSchema();
+ Optional oConstraintName = request.restrictions().constraintName();
+ Optional oTableSchemaName = request.restrictions().tableSchema();
+ Optional oTableCatalogName = request.restrictions().tableCatalog();
+ Optional oTableName = request.restrictions().tableName();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaCheckConstraintsByTable(oCatalog.get(), oSchemaName, oConstraintName, oTableCatalogName, oTableSchemaName, oTableName);
+ } else {
+ return List.of();
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaCheckConstraintsByTable(c, oSchemaName, oConstraintName, oTableCatalogName, oTableSchemaName, oTableName))
+ .flatMap(Collection::stream).toList();
+ }
+ }
+
+ public List dbSchemaCollations(DbSchemaCollationsRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaColumnDomainUsage(
+ DbSchemaColumnDomainUsageRequest request, RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaColumnPrivileges(DbSchemaColumnPrivilegesRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaConstraintColumnUsage(
+ DbSchemaConstraintColumnUsageRequest request, RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaConstraintTableUsage(
+ DbSchemaConstraintTableUsageRequest request, RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbDbSchemaForeignKeys(DbSchemaForeignKeysRequest request,
+ RequestMetaData metaData) {
+ Optional oFkCatalogName = request.restrictions().fkTableCatalog();
+ Optional oFkSchemaName = request.restrictions().fkTableSchema();
+ Optional oFkTableName = request.restrictions().fkTableName();
+ Optional oPkCatalogName = request.restrictions().pkTableCatalog();
+ Optional oPkSchemaName = request.restrictions().pkTableSchema();
+ Optional oPkTableName = request.restrictions().pkTableName();
+ if (oFkCatalogName.isPresent()) {
+ Optional oCatalog = oFkCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaForeignKeys(oCatalog.get(), oFkSchemaName, oFkTableName, oPkCatalogName, oPkSchemaName, oPkTableName);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaForeignKeys(c, oFkSchemaName, oFkTableName, oPkCatalogName, oPkSchemaName, oPkTableName))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaIndexes(DbSchemaIndexesRequest request, RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().tableCatalog();
+ Optional oSchemaName = request.restrictions().tableSchema();
+ Optional oIndexName = request.restrictions().indexName();
+ Optional oTableName = request.restrictions().tableName();
+ Optional oType = request.restrictions().type();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaIndexesResponseRow(oCatalog.get(), oSchemaName, oTableName, oIndexName, oType);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaIndexesResponseRow(c, oSchemaName, oTableName, oIndexName, oType))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaKeyColumnUsage(DbSchemaKeyColumnUsageRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaPrimaryKeys(DbSchemaPrimaryKeysRequest request,
+ RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().tableCatalog();
+ Optional oSchemaName = request.restrictions().tableSchema();
+ Optional oTableName = request.restrictions().tableName();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaPrimaryKeysResponseRow(oCatalog.get(), oSchemaName, oTableName);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaPrimaryKeysResponseRow(c, oSchemaName, oTableName))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaProcedureColumns(DbSchemaProcedureColumnsRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaProcedureParameters(
+ DbSchemaProcedureParametersRequest request, RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().procedureCatalog();
+ Optional oSchemaName = request.restrictions().procedureSchema();
+ Optional oProcedureName = request.restrictions().procedureName();
+ Optional oParameterName = request.restrictions().parameterName();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaProcedureParametersResponseRow(oCatalog.get(), oSchemaName, oProcedureName, oParameterName);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaProcedureParametersResponseRow(c, oSchemaName, oProcedureName, oParameterName))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaProcedures(DbSchemaProceduresRequest request,
+ RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().procedureCatalog();
+ Optional oSchemaName = request.restrictions().procedureSchema();
+ Optional oProcedureName = request.restrictions().procedureName();
+ Optional oProcedureType = request.restrictions().procedureType();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaProceduresResponseRow(oCatalog.get(), oSchemaName, oProcedureName, oProcedureType);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaProceduresResponseRow(c, oSchemaName, oProcedureName, oProcedureType))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaReferentialConstraints(
+ DbSchemaReferentialConstraintsRequest request, RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaSqlLanguages(DbSchemaSqlLanguagesRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaStatistics(DbSchemaStatisticsRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaTableConstraints(DbSchemaTableConstraintsRequest request,
+ RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().constraintCatalog();
+ Optional oSchemaName = request.restrictions().constraintSchema();
+ Optional oTableCatalogName = request.restrictions().tableCatalog();
+ Optional oTableSchemaName = request.restrictions().tableSchema();
+ Optional oConstraintName = request.restrictions().constraintName();
+ Optional oTableName = request.restrictions().tableName();
+ Optional oConstraintType = request.restrictions().constraintType();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaTableConstraintsResponseRow(oCatalog.get(), oSchemaName, oTableCatalogName, oTableSchemaName, oTableName, oConstraintName, oConstraintType);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaTableConstraintsResponseRow(c, oSchemaName, oTableCatalogName, oTableSchemaName, oTableName, oConstraintName, oConstraintType))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaTablePrivileges(DbSchemaTablePrivilegesRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaTableStatistics(DbSchemaTableStatisticsRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaTranslations(DbSchemaTranslationsRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaUsagePrivileges(DbSchemaUsagePrivilegesRequest request,
+ RequestMetaData metaData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public List dbSchemaViewColumnUsage(DbSchemaViewColumnUsageRequest request,
+ RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().viewCatalog();
+ Optional oSchemaName = request.restrictions().viewSchema();
+ Optional oViewName = request.restrictions().viewName();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaViewColumnUsageResponseRow(oCatalog.get(), oSchemaName, oViewName);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaViewColumnUsageResponseRow(c, oSchemaName, oViewName))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaViewTableUsage(DbSchemaViewTableUsageRequest request,
+ RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().viewCatalog();
+ Optional oSchemaName = request.restrictions().viewSchema();
+ Optional oViewName = request.restrictions().viewName();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaViewTableUsageResponseRow(oCatalog.get(), oSchemaName, oViewName);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaViewTableUsageResponseRow(c, oSchemaName, oViewName))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
+ public List dbSchemaViews(DbSchemaViewsRequest request, RequestMetaData metaData) {
+ Optional oCatalogName = request.restrictions().tableCatalog();
+ Optional oSchemaName = request.restrictions().tableSchema();
+ Optional oTableName = request.restrictions().tableName();
+ if (oCatalogName.isPresent()) {
+ Optional oCatalog = oCatalogName
+ .flatMap(name -> contextsListSupplyer.tryGetFirstByName(name, metaData.sessionId()));
+ if (oCatalog.isPresent()) {
+ return Utils.getDbSchemaViewsResponseRow(oCatalog.get(), oSchemaName, oTableName);
+ }
+ } else {
+ return contextsListSupplyer.get(metaData.sessionId()).stream()
+ .map(c -> Utils.getDbSchemaViewsResponseRow(c, oSchemaName, oTableName))
+ .flatMap(Collection::stream).toList();
+ }
+ return List.of();
+ }
+
}
diff --git a/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/DelegatingDiscoverService.java b/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/DelegatingDiscoverService.java
index e671703a..98717a64 100644
--- a/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/DelegatingDiscoverService.java
+++ b/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/DelegatingDiscoverService.java
@@ -21,20 +21,74 @@
import org.eclipse.daanse.xmla.api.RequestMetaData;
import org.eclipse.daanse.xmla.api.UserRolePrincipal;
import org.eclipse.daanse.xmla.api.discover.DiscoverService;
+import org.eclipse.daanse.xmla.api.discover.dbschema.assertions.DbSchemaAssertionsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.assertions.DbSchemaAssertionsResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.catalogs.DbSchemaCatalogsRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.catalogs.DbSchemaCatalogsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.charactersets.DbSchemaCharacterSetsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.charactersets.DbSchemaCharacterSetsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraints.DbSchemaCheckConstraintsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraints.DbSchemaCheckConstraintsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraintsbytable.DbSchemaCheckConstraintsByTableRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraintsbytable.DbSchemaCheckConstraintsByTableResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.collations.DbSchemaCollationsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.collations.DbSchemaCollationsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.columndomainusage.DbSchemaColumnDomainUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.columndomainusage.DbSchemaColumnDomainUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.columnprivileges.DbSchemaColumnPrivilegesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.columnprivileges.DbSchemaColumnPrivilegesResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.columns.DbSchemaColumnsRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.columns.DbSchemaColumnsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.constraintcolumnusage.DbSchemaConstraintColumnUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.constraintcolumnusage.DbSchemaConstraintColumnUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.constrainttableusage.DbSchemaConstraintTableUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.constrainttableusage.DbSchemaConstraintTableUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.foreignkeys.DbSchemaForeignKeysRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.foreignkeys.DbSchemaForeignKeysResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.indexes.DbSchemaIndexesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.indexes.DbSchemaIndexesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.keycolumnusage.DbSchemaKeyColumnUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.keycolumnusage.DbSchemaKeyColumnUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.primarykeys.DbSchemaPrimaryKeysRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.primarykeys.DbSchemaPrimaryKeysResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedurecolumns.DbSchemaProcedureColumnsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedurecolumns.DbSchemaProcedureColumnsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedureparameters.DbSchemaProcedureParametersRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedureparameters.DbSchemaProcedureParametersResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedures.DbSchemaProceduresRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedures.DbSchemaProceduresResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.providertypes.DbSchemaProviderTypesRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.providertypes.DbSchemaProviderTypesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.referentialconstraints.DbSchemaReferentialConstraintsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.referentialconstraints.DbSchemaReferentialConstraintsResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.schemata.DbSchemaSchemataRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.schemata.DbSchemaSchemataResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.sourcetables.DbSchemaSourceTablesRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.sourcetables.DbSchemaSourceTablesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.sqllanguages.DbSchemaSqlLanguagesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.sqllanguages.DbSchemaSqlLanguagesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.statistics.DbSchemaStatisticsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.statistics.DbSchemaStatisticsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableconstraints.DbSchemaTableConstraintsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableconstraints.DbSchemaTableConstraintsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableprivileges.DbSchemaTablePrivilegesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableprivileges.DbSchemaTablePrivilegesResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.tables.DbSchemaTablesRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.tables.DbSchemaTablesResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.tablesinfo.DbSchemaTablesInfoRequest;
import org.eclipse.daanse.xmla.api.discover.dbschema.tablesinfo.DbSchemaTablesInfoResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tablestatistics.DbSchemaTableStatisticsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tablestatistics.DbSchemaTableStatisticsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.translations.DbSchemaTranslationsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.translations.DbSchemaTranslationsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.usageprivileges.DbSchemaUsagePrivilegesRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.usageprivileges.DbSchemaUsagePrivilegesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewcolumnusage.DbSchemaViewColumnUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewcolumnusage.DbSchemaViewColumnUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.views.DbSchemaViewsRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.views.DbSchemaViewsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewtableusage.DbSchemaViewTableUsageRequest;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewtableusage.DbSchemaViewTableUsageResponseRow;
import org.eclipse.daanse.xmla.api.discover.discover.csdlmetadata.DiscoverCsdlMetaDataRequest;
import org.eclipse.daanse.xmla.api.discover.discover.csdlmetadata.DiscoverCsdlMetaDataResponseRow;
import org.eclipse.daanse.xmla.api.discover.discover.datasources.DiscoverDataSourcesRequest;
@@ -277,4 +331,166 @@ public List csdlMetaData(DiscoverCsdlMetaDataRe
return otherSchemaService.csdlMetaData(request, metaData);
}
+ @Override
+ public List dbSchemaAssertions(DbSchemaAssertionsRequest request, RequestMetaData metaData,
+ UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaAssertions(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaCharacterSets(DbSchemaCharacterSetsRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaCharacterSets(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaCheckConstraints(DbSchemaCheckConstraintsRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaCheckConstraints(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaCheckConstraintsByTable(
+ DbSchemaCheckConstraintsByTableRequest request, RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaCheckConstraintsByTable(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaCollations(DbSchemaCollationsRequest request, RequestMetaData metaData,
+ UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaCollations(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaColumnDomainUsage(DbSchemaColumnDomainUsageRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaColumnDomainUsage(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaColumnPrivileges(DbSchemaColumnPrivilegesRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaColumnPrivileges(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaConstraintColumnUsage(
+ DbSchemaConstraintColumnUsageRequest request, RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaConstraintColumnUsage(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaConstraintTableUsage(
+ DbSchemaConstraintTableUsageRequest request, RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaConstraintTableUsage(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaForeignKeys(DbSchemaForeignKeysRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaForeignKeys(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaIndexes(DbSchemaIndexesRequest request, RequestMetaData metaData,
+ UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaIndexes(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaKeyColumnUsage(DbSchemaKeyColumnUsageRequest request, RequestMetaData metaData,
+ UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaKeyColumnUsage(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaPrimaryKeys(DbSchemaPrimaryKeysRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaPrimaryKeys(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaProcedureColumns(DbSchemaProcedureColumnsRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaProcedureColumns(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaProcedureParameters(
+ DbSchemaProcedureParametersRequest request, RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaProcedureParameters(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaProcedures(DbSchemaProceduresRequest request, RequestMetaData metaData,
+ UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaProcedures(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaReferentialConstraints(
+ DbSchemaReferentialConstraintsRequest request, RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaReferentialConstraints(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaSqlLanguages(DbSchemaSqlLanguagesRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaSqlLanguages(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaStatistics(DbSchemaStatisticsRequest request, RequestMetaData metaData,
+ UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaStatistics(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaTableConstraints(DbSchemaTableConstraintsRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaTableConstraints(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaTablePrivileges(DbSchemaTablePrivilegesRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaTablePrivileges(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaTableStatistics(DbSchemaTableStatisticsRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaTableStatistics(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaTranslations(DbSchemaTranslationsRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaTranslations(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaUsagePrivileges(DbSchemaUsagePrivilegesRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaUsagePrivileges(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaViewColumnUsage(DbSchemaViewColumnUsageRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaViewColumnUsage(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaViewTableUsage(DbSchemaViewTableUsageRequest request,
+ RequestMetaData metaData, UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaViewTableUsage(request, metaData);
+ }
+
+ @Override
+ public List dbSchemaViews(DbSchemaViewsRequest request, RequestMetaData metaData,
+ UserRolePrincipal userRolePrincipal) {
+ return dbSchemaService.dbSchemaViews(request, metaData);
+ }
+
}
diff --git a/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/Utils.java b/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/Utils.java
index 3f472349..042e5930 100644
--- a/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/Utils.java
+++ b/xmla/bridge/src/main/java/org/eclipse/daanse/olap/xmla/bridge/discover/Utils.java
@@ -23,11 +23,23 @@
import java.util.Set;
import java.util.stream.Collectors;
-import org.eclipse.daanse.mdx.model.api.expression.operation.EmptyOperationAtom;
-import org.eclipse.daanse.mdx.model.api.expression.operation.InternalOperationAtom;
-import org.eclipse.daanse.mdx.model.api.expression.operation.ParenthesesOperationAtom;
-import org.eclipse.daanse.olap.api.Context;
-import org.eclipse.daanse.olap.api.DataType;
+import org.eclipse.daanse.cwm.model.cwm.foundation.keysindexes.UniqueKey;
+import org.eclipse.daanse.cwm.model.cwm.objectmodel.behavioral.Parameter;
+import org.eclipse.daanse.cwm.model.cwm.objectmodel.core.BooleanExpression;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.CheckConstraint;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.Column;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.ForeignKey;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.PrimaryKey;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.Procedure;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.SQLIndex;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.SQLIndexColumn;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.Schema;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.Table;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.UniqueConstraint;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.View;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.enumerations.DeferrabilityType;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.util.Columns;
+import org.eclipse.daanse.cwm.model.cwm.resource.relational.util.ForeignKeys;
import org.eclipse.daanse.olap.api.catalog.CatalogReader;
import org.eclipse.daanse.olap.api.connection.Connection;
import org.eclipse.daanse.olap.api.element.Catalog;
@@ -43,12 +55,10 @@
import org.eclipse.daanse.olap.api.element.db.DatabaseColumn;
import org.eclipse.daanse.olap.api.element.db.DatabaseSchema;
import org.eclipse.daanse.olap.api.element.db.DatabaseTable;
-import org.eclipse.daanse.olap.api.function.FunctionMetaData;
import org.eclipse.daanse.olap.api.result.Property;
import org.eclipse.daanse.olap.api.result.Property.TypeFlag;
import org.eclipse.daanse.olap.common.StandardProperty;
import org.eclipse.daanse.xmla.api.RequestMetaData;
-import org.eclipse.daanse.xmla.api.VarType;
import org.eclipse.daanse.xmla.api.XmlaConstants;
import org.eclipse.daanse.xmla.api.XmlaConstants.DBType;
import org.eclipse.daanse.xmla.api.common.enums.ColumnOlapTypeEnum;
@@ -59,14 +69,12 @@
import org.eclipse.daanse.xmla.api.common.enums.DimensionTypeEnum;
import org.eclipse.daanse.xmla.api.common.enums.DimensionUniqueSettingEnum;
import org.eclipse.daanse.xmla.api.common.enums.HierarchyOriginEnum;
-import org.eclipse.daanse.xmla.api.common.enums.InterfaceNameEnum;
import org.eclipse.daanse.xmla.api.common.enums.LevelDbTypeEnum;
import org.eclipse.daanse.xmla.api.common.enums.LevelOriginEnum;
import org.eclipse.daanse.xmla.api.common.enums.LevelTypeEnum;
import org.eclipse.daanse.xmla.api.common.enums.LevelUniqueSettingsEnum;
import org.eclipse.daanse.xmla.api.common.enums.MeasureAggregatorEnum;
import org.eclipse.daanse.xmla.api.common.enums.MemberTypeEnum;
-import org.eclipse.daanse.xmla.api.common.enums.OriginEnum;
import org.eclipse.daanse.xmla.api.common.enums.PreferredQueryPatternsEnum;
import org.eclipse.daanse.xmla.api.common.enums.PropertyContentTypeEnum;
import org.eclipse.daanse.xmla.api.common.enums.PropertyOriginEnum;
@@ -77,13 +85,24 @@
import org.eclipse.daanse.xmla.api.common.enums.TableTypeEnum;
import org.eclipse.daanse.xmla.api.common.enums.TreeOpEnum;
import org.eclipse.daanse.xmla.api.common.enums.VisibilityEnum;
+import org.eclipse.daanse.xmla.api.discover.dbschema.assertions.DbSchemaAssertionsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraints.DbSchemaCheckConstraintsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.checkconstraintsbytable.DbSchemaCheckConstraintsByTableResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.columns.DbSchemaColumnsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.foreignkeys.DbSchemaForeignKeysResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.indexes.DbSchemaIndexesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.primarykeys.DbSchemaPrimaryKeysResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedureparameters.DbSchemaProcedureParametersResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.procedures.DbSchemaProceduresResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.sourcetables.DbSchemaSourceTablesResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.tableconstraints.DbSchemaTableConstraintsResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.tables.DbSchemaTablesResponseRow;
import org.eclipse.daanse.xmla.api.discover.dbschema.tablesinfo.DbSchemaTablesInfoResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewcolumnusage.DbSchemaViewColumnUsageResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.views.DbSchemaViewsResponseRow;
+import org.eclipse.daanse.xmla.api.discover.dbschema.viewtableusage.DbSchemaViewTableUsageResponseRow;
import org.eclipse.daanse.xmla.api.discover.mdschema.cubes.MdSchemaCubesResponseRow;
import org.eclipse.daanse.xmla.api.discover.mdschema.dimensions.MdSchemaDimensionsResponseRow;
-import org.eclipse.daanse.xmla.api.discover.mdschema.functions.MdSchemaFunctionsResponseRow;
import org.eclipse.daanse.xmla.api.discover.mdschema.hierarchies.MdSchemaHierarchiesResponseRow;
import org.eclipse.daanse.xmla.api.discover.mdschema.kpis.MdSchemaKpisResponseRow;
import org.eclipse.daanse.xmla.api.discover.mdschema.levels.MdSchemaLevelsResponseRow;
@@ -93,13 +112,23 @@
import org.eclipse.daanse.xmla.api.discover.mdschema.members.MdSchemaMembersResponseRow;
import org.eclipse.daanse.xmla.api.discover.mdschema.properties.MdSchemaPropertiesResponseRow;
import org.eclipse.daanse.xmla.api.discover.mdschema.sets.MdSchemaSetsResponseRow;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.checkconstraints.DbSchemaCheckConstraintsResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.checkconstraintsbytable.DbSchemaCheckConstraintsByTableResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.dbschema.columns.DbSchemaColumnsResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.foreignkeys.DbSchemaForeignKeysResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.indexes.DbSchemaIndexesResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.primarykeys.DbSchemaPrimaryKeysResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.procedureparameters.DbSchemaProcedureParametersResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.procedures.DbSchemaProceduresResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.dbschema.schemata.DbSchemaSchemataResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.tableconstraints.DbSchemaTableConstraintsResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.dbschema.tables.DbSchemaTablesResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.dbschema.tablesinfo.DbSchemaTablesInfoResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.viewcolumnusage.DbSchemaViewColumnUsageResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.views.DbSchemaViewsResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.dbschema.viewtableusage.DbSchemaViewTableUsageResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.mdschema.cubes.MdSchemaCubesResponseRowR;
-import org.eclipse.daanse.xmla.model.record.discover.mdschema.demensions.MdSchemaDimensionsResponseRowR;
-import org.eclipse.daanse.xmla.model.record.discover.mdschema.functions.MdSchemaFunctionsResponseRowR;
+import org.eclipse.daanse.xmla.model.record.discover.mdschema.dimensions.MdSchemaDimensionsResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.mdschema.hierarchies.MdSchemaHierarchiesResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.mdschema.kpis.MdSchemaKpisResponseRowR;
import org.eclipse.daanse.xmla.model.record.discover.mdschema.levels.MdSchemaLevelsResponseRowR;
@@ -272,7 +301,9 @@ static List getDbSchemaSchemataResponseRow(Catalog
String schemaOwnerRequ) {
return catalog.getDatabaseSchemas().stream()
.filter(dbs -> (schemaNameReq == null || dbs.getName().equals(schemaNameReq)))
- .map(dbs -> new DbSchemaSchemataResponseRowR(catalog.getName(), dbs.getName(), "")).toList();
+ //TODO
+ .map(dbs -> new DbSchemaSchemataResponseRowR(catalog.getName(), dbs.getName(), "", Optional.empty(), Optional.empty(),
+ Optional.empty())).toList();
}
static List getMdSchemaCubesResponseRow(Connection connection, Catalog catalog, Optional schemaName,
@@ -1639,4 +1670,724 @@ private static List getMeasureWithFi
}
return measures;
}
+
+ static List getDbSchemaAssertionsResponseRow(Catalog catalog,
+ Optional oSchemaName, Optional oConstraintName) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ static List getDbSchemaIndexesResponseRow(Catalog catalog,
+ Optional oSchemaName, Optional oTableName, Optional oIndexName,
+ Optional oType) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaIndexesResponseRow(catalog.getName(), dbs, oTableName, oIndexName, oType)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaIndexesResponseRow(catalog.getName(), dbs, oTableName, oIndexName, oType)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaIndexesResponseRow(String catalogName, Schema databaseSchema, Optional oTableName,
+ Optional oIndexName, Optional oType) {
+ String databaseSchemaName = databaseSchema.getName();
+ if (oIndexName.isPresent()) {
+ return databaseSchema.getOwnedElement().stream().filter(SQLIndex.class::isInstance)
+ .map(SQLIndex.class::cast).toList().stream().filter(i -> i.getName().equals(oIndexName.get()))
+ .map(di -> getDbSchemaIndexesResponseRow(catalogName, databaseSchemaName, di, oTableName, oType)).flatMap(Collection::stream).toList();
+ } else {
+ return databaseSchema.getOwnedElement().stream().filter(SQLIndex.class::isInstance)
+ .map(SQLIndex.class::cast).toList().stream()
+ .map(di -> getDbSchemaIndexesResponseRow(catalogName, databaseSchemaName, di, oTableName, oType)).flatMap(Collection::stream).toList();
+ }
+ }
+
+ private static List getDbSchemaIndexesResponseRow(String catalogName, String databaseSchemaName, SQLIndex index, Optional oTableName, Optional oType) {
+ return index.getIndexedFeature().stream().filter(SQLIndexColumn.class::isInstance)
+ .map(SQLIndexColumn.class::cast).toList().stream().map(sic -> new DbSchemaIndexesResponseRowR(Optional.of(catalogName), Optional.ofNullable(databaseSchemaName),
+ Optional.ofNullable(index.getSpannedClass().getName()),
+ Optional.of(catalogName), Optional.ofNullable(databaseSchemaName), Optional.ofNullable(index.getName()), Optional.empty(),
+ Optional.ofNullable(index.isIsUnique()), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(),
+ Optional.empty(), Optional.empty(), Optional.ofNullable(index.isAutoUpdate()), Optional.empty(),
+ Optional.empty(), Optional.ofNullable(sic.getFeature().getName()), Optional.empty(), Optional.empty(),
+ Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(),
+ Optional.empty()))
+ .map(DbSchemaIndexesResponseRow.class::cast)
+ .toList();
+ }
+
+ static List getDbSchemaProceduresResponseRow(Catalog catalog,
+ Optional oSchemaName, Optional oProcedureName, Optional oProcedureType) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaProceduresResponseRow(catalog.getName(), dbs, oProcedureName, oProcedureType)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaProceduresResponseRow(catalog.getName(), dbs, oProcedureName, oProcedureType)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaProceduresResponseRow(String catalogName, Schema dbs,
+ Optional oProcedureName, Optional oProcedureType) {
+ if (oProcedureName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(Procedure.class::isInstance)
+ .map(Procedure.class::cast).toList().stream()
+ .filter(p -> (p.getName().equals(oProcedureName.get())))
+ .map(p -> getDbSchemaProceduresResponseRow(catalogName, dbs.getName(), p, oProcedureType)).flatMap(Collection::stream).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(Procedure.class::isInstance)
+ .map(Procedure.class::cast).toList().stream()
+ .map(p -> getDbSchemaProceduresResponseRow(catalogName, dbs.getName(), p, oProcedureType)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaProceduresResponseRow(String catalogName, String dbSchemaName, Procedure p,
+ Optional oProcedureType) {
+ return List.of(new DbSchemaProceduresResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(dbSchemaName), Optional.ofNullable(p.getName()),
+ Optional.ofNullable(p.getType() != null ? p.getType().getValue() : null), Optional.ofNullable(p.getBody() != null ? p.getBody().getBody() : null), Optional.ofNullable(p.getName()), Optional.empty(), Optional.empty()));
+ }
+
+ static List getDbSchemaProcedureParametersResponseRow(Catalog catalog, Optional oSchemaName,
+ Optional oProcedureName, Optional oParameterName) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaProcedureParametersResponseRow(catalog.getName(), dbs, oProcedureName, oParameterName)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaProcedureParametersResponseRow(catalog.getName(), dbs, oProcedureName, oParameterName)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaProcedureParametersResponseRow(String catalogName, Schema dbs,
+ Optional oProcedureName, Optional oParameterName) {
+ if (oProcedureName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(Procedure.class::isInstance)
+ .map(Procedure.class::cast).toList().stream()
+ .filter(p -> (p.getName().equals(oProcedureName.get())))
+ .map(p -> getDbSchemaProcedureParametersResponseRow(catalogName, dbs.getName(), p, oParameterName)).flatMap(Collection::stream).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(Procedure.class::isInstance)
+ .map(Procedure.class::cast).toList().stream()
+ .map(p -> getDbSchemaProcedureParametersResponseRow(catalogName, dbs.getName(), p, oParameterName)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+
+ private static List getDbSchemaProcedureParametersResponseRow(String catalogName, String schemaName, Procedure procedure,
+ Optional oParameterName) {
+ if (oParameterName.isPresent()) {
+ return procedure.getParameter().stream()
+ .filter(p -> (p.getName().equals(oParameterName.get())))
+ .map(p -> getDbSchemaProcedureParametersResponseRow1(catalogName, schemaName, p.getName(), procedure.getParameter().indexOf(p), p)).toList();
+ } else {
+ return procedure.getParameter().stream()
+ .map(p -> getDbSchemaProcedureParametersResponseRow1(catalogName, schemaName, p.getName(), procedure.getParameter().indexOf(p), p)).toList();
+
+ }
+ }
+
+ private static DbSchemaProcedureParametersResponseRow getDbSchemaProcedureParametersResponseRow1(String catalogName, String schemaName, String procedureName, Integer ordinalPosition, Parameter parameter) {
+ return new DbSchemaProcedureParametersResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(procedureName), Optional.ofNullable(parameter.getName()),
+ Optional.of(ordinalPosition), Optional.empty(), Optional.of(parameter.getDefaultValue() != null),
+ Optional.ofNullable(parameter.getDefaultValue() != null ? parameter.getDefaultValue().getBody() : null), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(),
+ Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty());
+ }
+
+ static List getDbSchemaViewsResponseRow(Catalog catalog, Optional oSchemaName,
+ Optional oTableName) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaViewsResponseRow(catalog.getName(), dbs, oTableName)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaViewsResponseRow(catalog.getName(), dbs, oTableName)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaViewsResponseRow(String catalogName, Schema dbs, Optional oTableName) {
+ if (oTableName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(View.class::isInstance)
+ .map(View.class::cast).toList().stream()
+ .filter(v -> (v.getName().equals(oTableName.get())))
+ .map(v -> getDbSchemaViewsResponseRow(catalogName, dbs.getName(), v)).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(View.class::isInstance)
+ .map(View.class::cast).toList().stream()
+ .map(v -> getDbSchemaViewsResponseRow(catalogName, dbs.getName(), v)).toList();
+
+ }
+ }
+
+ private static DbSchemaViewsResponseRow getDbSchemaViewsResponseRow(String catalogName, String schemaName, View v) {
+ return new DbSchemaViewsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(v.getName()),
+ Optional.ofNullable(v.getQueryExpression() != null ? v.getQueryExpression().getBody() : null), Optional.ofNullable(v.isCheckOption()),
+ Optional.of(Boolean.valueOf(!v.isIsReadOnly())), Optional.ofNullable(v.getName()), Optional.empty(), Optional.empty());
+ }
+
+ static List getDbSchemaViewTableUsageResponseRow(Catalog catalog,
+ Optional oSchemaName, Optional oViewName) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaViewTableUsageResponseRow(catalog.getName(), dbs, oViewName)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaViewTableUsageResponseRow(catalog.getName(), dbs, oViewName)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaViewTableUsageResponseRow(String catalogName, Schema dbs, Optional oViewName) {
+ if (oViewName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(View.class::isInstance)
+ .map(View.class::cast).toList().stream()
+ .filter(v -> (v.getName().equals(oViewName.get())))
+ .map(v -> getDbSchemaViewTableUsageResponseRow(catalogName, dbs.getName(), v)).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(View.class::isInstance)
+ .map(View.class::cast).toList().stream()
+ .map(v -> getDbSchemaViewTableUsageResponseRow(catalogName, dbs.getName(), v)).toList();
+
+ }
+ }
+
+ private static DbSchemaViewTableUsageResponseRow getDbSchemaViewTableUsageResponseRow(String catalogName, String schemaName, View v) {
+ return new DbSchemaViewTableUsageResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(v.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(v.getName()));
+ }
+
+ static List getDbSchemaViewColumnUsageResponseRow(Catalog catalog,
+ Optional oSchemaName, Optional oViewName) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaViewColumnUsageResponseRow(catalog.getName(), dbs, oViewName)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaViewColumnUsageResponseRow(catalog.getName(), dbs, oViewName)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaViewColumnUsageResponseRow(String catalogName, Schema dbs, Optional oViewName) {
+ if (oViewName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(View.class::isInstance)
+ .map(View.class::cast).toList().stream()
+ .filter(v -> (v.getName().equals(oViewName.get())))
+ .map(v -> getDbSchemaViewColumnUsageResponseRow(catalogName, dbs.getName(), v)).flatMap(Collection::stream).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(View.class::isInstance)
+ .map(View.class::cast).toList().stream()
+ .map(v -> getDbSchemaViewColumnUsageResponseRow(catalogName, dbs.getName(), v)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaViewColumnUsageResponseRow(String catalogName, String schemaName, View v) {
+ return v.getFeature().stream().filter(Column.class::isInstance)
+ .map(Column.class::cast).toList().stream()
+ .map(c -> {
+ final Optional oTable = Columns.tableOwner(c);
+ final String tableName = oTable.isPresent() ? oTable.get().getName() : null;
+ return new DbSchemaViewColumnUsageResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(v.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(tableName), Optional.ofNullable(c.getName()),
+ Optional.empty(), Optional.empty());
+ })
+ .map(DbSchemaViewColumnUsageResponseRow.class::cast)
+ .toList();
+ }
+
+ static List getDbSchemaTableConstraintsResponseRow(Catalog catalog,
+ Optional oSchemaName, Optional oTableCatalogName, Optional oTableSchemaName,
+ Optional oTableName, Optional oConstraintName, Optional oConstraintType) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaTableConstraintsResponseRow(catalog.getName(), dbs, oTableCatalogName, oTableSchemaName,
+ oTableName, oConstraintName, oConstraintType)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaTableConstraintsResponseRow(catalog.getName(), dbs, oTableCatalogName, oTableSchemaName,
+ oTableName, oConstraintName, oConstraintType)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaTableConstraintsResponseRow(String catalogName, Schema dbs,
+ Optional oTableCatalogName, Optional oTableSchemaName, Optional oTableName, Optional oConstraintName,
+ Optional oConstraintType) {
+ if (oTableName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .filter(t -> (t.getName().equals(oTableName.get())))
+ .map(t -> getDbSchemaTableConstraintsResponseRow(catalogName, dbs.getName(), t, oConstraintName, oConstraintType)).flatMap(Collection::stream).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .map(t -> getDbSchemaTableConstraintsResponseRow(catalogName, dbs.getName(), t, oConstraintName, oConstraintType)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaTableConstraintsResponseRow(String catalogName, String scemaName, Table t,
+ Optional oConstraintName, Optional oConstraintType) {
+ List result = new ArrayList();
+ if (oConstraintType.isPresent()) {
+ String constraintType = oConstraintType.get();
+ switch (constraintType) {
+ case "PRIMARY KEY":
+ result.addAll(getDbSchemaTableConstraintsPKResponseRow(catalogName, scemaName, t, oConstraintName));
+ break;
+ case "UNIQUE":
+ result.addAll(getDbSchemaTableConstraintsUniqueResponseRow(catalogName, scemaName, t, oConstraintName));
+ break;
+ case "FOREIGN KEY":
+ result.addAll(getDbSchemaTableConstraintsFKResponseRow(catalogName, scemaName, t, oConstraintName));
+ break;
+ case "CHECK":
+ result.addAll(getDbSchemaTableConstraintsCheckResponseRow(catalogName, scemaName, t, oConstraintName));
+ break;
+ }
+ } else {
+ result.addAll(getDbSchemaTableConstraintsPKResponseRow(catalogName, scemaName, t, oConstraintName));
+ result.addAll(getDbSchemaTableConstraintsUniqueResponseRow(catalogName, scemaName, t, oConstraintName));
+ result.addAll(getDbSchemaTableConstraintsFKResponseRow(catalogName, scemaName, t, oConstraintName));
+ result.addAll(getDbSchemaTableConstraintsCheckResponseRow(catalogName, scemaName, t, oConstraintName));
+ }
+ return result;
+ }
+
+ private static Collection getDbSchemaTableConstraintsCheckResponseRow(
+ String catalogName, String schemaName, Table t, Optional oConstraintName) {
+ List result = new ArrayList();
+ if (oConstraintName.isPresent()) {
+ result.addAll(t.getConstraint().stream().filter(CheckConstraint.class::isInstance).map(CheckConstraint.class::cast).toList().stream().filter(c -> c.getName().equals(oConstraintName.get()))
+ .map(c -> new DbSchemaTableConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(c.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(t.getName()), Optional.of("CHECK"), getDeferrability(c.getDeferrability()),
+ getInitiallyDeferred(c.getDeferrability()), Optional.ofNullable(c.getName())))
+ .toList());
+ result.addAll(
+ t.getFeature().stream()
+ .filter(Column.class::isInstance)
+ .map(Column.class::cast)
+ .flatMap(column -> column.getConstraint().stream()
+ .filter(CheckConstraint.class::isInstance)
+ .map(CheckConstraint.class::cast)
+ .filter(c -> oConstraintName.map(name -> c.getName().equals(name)).orElse(false))
+ .map(c -> new DbSchemaTableConstraintsResponseRowR(
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(c.getName()),
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(t.getName()),
+ Optional.of("CHECK"),
+ getDeferrability(c.getDeferrability()),
+ getInitiallyDeferred(c.getDeferrability()),
+ Optional.ofNullable(c.getName())
+ ))
+ )
+ .toList()
+ );
+ } else {
+ result.addAll(t.getConstraint().stream().filter(CheckConstraint.class::isInstance).map(CheckConstraint.class::cast).toList().stream()
+ .map(c -> new DbSchemaTableConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(c.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(t.getName()), Optional.of("CHECK"), getDeferrability(c.getDeferrability()),
+ getInitiallyDeferred(c.getDeferrability()), Optional.ofNullable(c.getName())))
+ .toList());
+ result.addAll(
+ t.getFeature().stream()
+ .filter(Column.class::isInstance)
+ .map(Column.class::cast)
+ .flatMap(column -> column.getConstraint().stream()
+ .filter(CheckConstraint.class::isInstance)
+ .map(CheckConstraint.class::cast)
+ .map(c -> new DbSchemaTableConstraintsResponseRowR(
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(c.getName()),
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(t.getName()),
+ Optional.of("CHECK"),
+ getDeferrability(c.getDeferrability()),
+ getInitiallyDeferred(c.getDeferrability()),
+ Optional.ofNullable(c.getName())
+ ))
+ )
+ .toList()
+ );
+ }
+ return result;
+ }
+
+ private static Optional getDeferrability(DeferrabilityType deferrability) {
+ return deferrability != null ? Optional.of(Boolean.TRUE) : Optional.of(Boolean.FALSE);
+ }
+
+ private static Optional getInitiallyDeferred(DeferrabilityType deferrability) {
+ return deferrability != null ? Optional.of(deferrability.equals(DeferrabilityType.INITIALLY_DEFERRED) || deferrability.equals(DeferrabilityType.INITIALLY_IMMEDIATE)) : Optional.empty();
+ }
+
+ private static Collection getDbSchemaTableConstraintsFKResponseRow(
+ String catalogName, String schemaName, Table t, Optional oConstraintName) {
+ List result = new ArrayList();
+ if (oConstraintName.isPresent()) {
+ result.addAll(t.getOwnedElement().stream().filter(ForeignKey.class::isInstance).map(ForeignKey.class::cast).toList().stream().filter(pk -> pk.getName().equals(oConstraintName.get()))
+ .map(fk -> new DbSchemaTableConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(fk.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(t.getName()), Optional.of("FOREIGN KEY"), getDeferrability(fk.getDeferrability()),
+ getInitiallyDeferred(fk.getDeferrability()), Optional.ofNullable(fk.getName())))
+ .toList());
+ } else {
+ result.addAll(t.getConstraint().stream().filter(ForeignKey.class::isInstance).map(ForeignKey.class::cast).toList().stream()
+ .map(fk -> new DbSchemaTableConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(fk.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(t.getName()), Optional.of("FOREIGN KEY"), getDeferrability(fk.getDeferrability()),
+ getInitiallyDeferred(fk.getDeferrability()), Optional.ofNullable(fk.getName())))
+ .toList());
+ }
+ return result;
+ }
+
+ private static Collection getDbSchemaTableConstraintsUniqueResponseRow(
+ String catalogName, String schemaName, Table t, Optional oConstraintName) {
+ List result = new ArrayList();
+ if (oConstraintName.isPresent()) {
+ result.addAll(t.getOwnedElement().stream().filter(UniqueConstraint.class::isInstance).map(UniqueConstraint.class::cast).toList().stream().filter(pk -> pk.getName().equals(oConstraintName.get()))
+ .map(uk -> new DbSchemaTableConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(uk.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(t.getName()), Optional.of("UNIQUE"), getDeferrability(uk.getDeferrability()),
+ getInitiallyDeferred(uk.getDeferrability()), Optional.ofNullable(uk.getName())))
+ .toList());
+ } else {
+ result.addAll(t.getConstraint().stream().filter(UniqueConstraint.class::isInstance).map(UniqueConstraint.class::cast).toList().stream()
+ .map(uk -> new DbSchemaTableConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(uk.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(t.getName()), Optional.of("UNIQUE"), getDeferrability(uk.getDeferrability()),
+ getInitiallyDeferred(uk.getDeferrability()), Optional.ofNullable(uk.getName())))
+ .toList());
+ }
+ return result;
+ }
+
+ private static Collection getDbSchemaTableConstraintsPKResponseRow(
+ String catalogName, String schemaName, Table t, Optional oConstraintName) {
+ List result = new ArrayList();
+ if (oConstraintName.isPresent()) {
+ result.addAll(t.getOwnedElement().stream().filter(PrimaryKey.class::isInstance).map(PrimaryKey.class::cast).toList().stream().filter(pk -> pk.getName().equals(oConstraintName.get()))
+ .map(pk -> new DbSchemaTableConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(pk.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(t.getName()), Optional.of("PRIMARY KEY"), getDeferrability(pk.getDeferrability()),
+ getInitiallyDeferred(pk.getDeferrability()), Optional.ofNullable(pk.getName())))
+ .toList());
+ } else {
+ result.addAll(t.getConstraint().stream().filter(PrimaryKey.class::isInstance).map(PrimaryKey.class::cast).toList().stream()
+ .map(pk -> new DbSchemaTableConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(pk.getName()),
+ Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(t.getName()), Optional.of("PRIMARY KEY"), getDeferrability(pk.getDeferrability()),
+ getInitiallyDeferred(pk.getDeferrability()), Optional.ofNullable(pk.getName())))
+ .toList());
+ }
+ return result;
+ }
+
+ public static List getDbSchemaPrimaryKeysResponseRow(Catalog catalog,
+ Optional oSchemaName, Optional oTableName) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaPrimaryKeysResponseRow(catalog.getName(), dbs, oTableName)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaPrimaryKeysResponseRow(catalog.getName(), dbs, oTableName)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaPrimaryKeysResponseRow(String catalogName, Schema dbs, Optional oTableName) {
+ if (oTableName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .filter(t -> (t.getName().equals(oTableName.get())))
+ .map(t -> getDbSchemaPrimaryKeysResponseRow(catalogName, dbs.getName(), t)).flatMap(Collection::stream).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .map(t -> getDbSchemaPrimaryKeysResponseRow(catalogName, dbs.getName(), t)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaPrimaryKeysResponseRow(String catalogName, String schemaName, Table t) {
+ return t.getOwnedElement().stream()
+ .filter(PrimaryKey.class::isInstance)
+ .map(PrimaryKey.class::cast)
+ .flatMap(pk -> pk.getFeature().stream()
+ .filter(Column.class::isInstance)
+ .map(Column.class::cast)
+ .map(c -> new DbSchemaPrimaryKeysResponseRowR(
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(t.getName()),
+ Optional.ofNullable(c.getName()),
+ Optional.empty(),
+ Optional.empty(),
+ Optional.empty(),
+ Optional.ofNullable(pk.getName())
+ ))
+ ).map(DbSchemaPrimaryKeysResponseRow.class::cast)
+ .toList();
+ }
+
+ public static List getDbSchemaCheckConstraints(Catalog catalog,
+ Optional oSchemaName, Optional oConstraintName) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaCheckConstraints(catalog.getName(), dbs, oConstraintName)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaCheckConstraints(catalog.getName(), dbs, oConstraintName)).flatMap(Collection::stream).toList();
+ }
+ }
+
+ private static List getDbSchemaCheckConstraints(String catalogName, Schema dbs, Optional oConstraintName) {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .map(t -> getDbSchemaCheckConstraints(catalogName, dbs.getName(), t, oConstraintName)).flatMap(Collection::stream).toList();
+ }
+
+ private static List getDbSchemaCheckConstraints(String catalogName, String schemaName, Table t,
+ Optional oConstraintName) {
+ List result = new ArrayList();
+ result.addAll(t.getConstraint().stream().filter(CheckConstraint.class::isInstance).map(CheckConstraint.class::cast).toList().stream()
+ .map(c -> new DbSchemaCheckConstraintsResponseRowR(Optional.ofNullable(catalogName), Optional.ofNullable(schemaName), Optional.ofNullable(c.getName()),
+ Optional.ofNullable(c.getBody() != null ? c.getBody().getBody() : null), Optional.of(c.getName())))
+ .toList());
+ result.addAll(
+ t.getFeature().stream()
+ .filter(Column.class::isInstance)
+ .map(Column.class::cast)
+ .flatMap(column -> column.getConstraint().stream()
+ .filter(CheckConstraint.class::isInstance)
+ .map(CheckConstraint.class::cast)
+ .map(c -> {
+ String bodyText = Optional.ofNullable(c.getBody())
+ .map(BooleanExpression::getBody)
+ .orElse(null);
+ return new DbSchemaCheckConstraintsResponseRowR(
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(c.getName()),
+ Optional.ofNullable(bodyText),
+ Optional.of(c.getName())
+ );
+ })
+ )
+ .toList());
+ return result;
+ }
+
+ public static List getDbSchemaCheckConstraintsByTable(Catalog catalog,
+ Optional oSchemaName, Optional oConstraintName, Optional oTableCatalogName,
+ Optional oTableSchemaName, Optional oTableName) {
+ if (oSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oSchemaName.get())))
+ .map(dbs -> getDbSchemaCheckConstraintsByTable(catalog.getName(), dbs, oConstraintName, oTableCatalogName, oTableSchemaName, oTableName)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaCheckConstraintsByTable(catalog.getName(), dbs, oConstraintName, oTableCatalogName, oTableSchemaName, oTableName)).flatMap(Collection::stream).toList();
+ }
+ }
+
+ private static List getDbSchemaCheckConstraintsByTable(String catalogName, Schema dbs, Optional oConstraintName,
+ Optional oTableCatalogName, Optional oTableSchemaName, Optional oTableName) {
+ if (oTableName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .filter(t -> (t.getName().equals(oTableName.get())))
+ .map(t -> getDbSchemaCheckConstraintsByTable(catalogName, dbs.getName(), t, oConstraintName)).flatMap(Collection::stream).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .map(t -> getDbSchemaCheckConstraintsByTable(catalogName, dbs.getName(), t, oConstraintName)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaCheckConstraintsByTable(String catalogName, String schemaName, Table t,
+ Optional oConstraintName) {
+ List result = new ArrayList();
+ if (oConstraintName.isPresent()) {
+ result.addAll(t.getConstraint().stream().filter(CheckConstraint.class::isInstance).map(CheckConstraint.class::cast).toList().stream().filter(c -> c.getName().equals(oConstraintName.get()))
+ .map(c -> {
+ String bodyText = Optional.ofNullable(c.getBody())
+ .map(BooleanExpression::getBody)
+ .orElse(null);
+ return new DbSchemaCheckConstraintsByTableResponseRowR(
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(t.getName()),
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(c.getName()),
+ Optional.ofNullable(bodyText),
+ Optional.ofNullable(c.getName()));
+ })
+ .toList());
+
+ result.addAll(
+ t.getFeature().stream()
+ .filter(Column.class::isInstance)
+ .map(Column.class::cast)
+ .flatMap(column -> column.getConstraint().stream()
+ .filter(CheckConstraint.class::isInstance)
+ .map(CheckConstraint.class::cast)
+ .filter(c -> oConstraintName.map(name -> c.getName().equals(name)).orElse(false))
+ .map(c -> {
+ String bodyText = Optional.ofNullable(c.getBody())
+ .map(BooleanExpression::getBody)
+ .orElse(null);
+ return new DbSchemaCheckConstraintsByTableResponseRowR(
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(t.getName()),
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(c.getName()),
+ Optional.ofNullable(bodyText),
+ Optional.ofNullable(c.getName()));
+ })
+ )
+ .toList()
+ );
+ } else {
+ result.addAll(t.getConstraint().stream().filter(CheckConstraint.class::isInstance).map(CheckConstraint.class::cast).toList().stream()
+ .map(c -> {
+ String bodyText = Optional.ofNullable(c.getBody())
+ .map(BooleanExpression::getBody)
+ .orElse(null);
+ return new DbSchemaCheckConstraintsByTableResponseRowR(
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(t.getName()),
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(c.getName()),
+ Optional.ofNullable(bodyText),
+ Optional.ofNullable(c.getName()));
+ })
+ .toList());
+
+ result.addAll(
+ t.getFeature().stream()
+ .filter(Column.class::isInstance)
+ .map(Column.class::cast)
+ .flatMap(column -> column.getConstraint().stream()
+ .filter(CheckConstraint.class::isInstance)
+ .map(CheckConstraint.class::cast)
+ .map(c -> {
+ String bodyText = Optional.ofNullable(c.getBody())
+ .map(BooleanExpression::getBody)
+ .orElse(null);
+ return new DbSchemaCheckConstraintsByTableResponseRowR(
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(t.getName()),
+ Optional.ofNullable(catalogName),
+ Optional.ofNullable(schemaName),
+ Optional.ofNullable(c.getName()),
+ Optional.ofNullable(bodyText),
+ Optional.ofNullable(c.getName()));
+ })
+ )
+ .toList()
+ );
+ }
+ return result;
+ }
+
+ public static List getDbSchemaForeignKeys(Catalog catalog,
+ Optional oFkSchemaName, Optional oFkTableName, Optional oPkCatalogName,
+ Optional oPkSchemaName, Optional oPkTableName) {
+ if (oFkSchemaName.isPresent()) {
+ return catalog.getRelationalSchemas().stream()
+ .filter(dbs -> (dbs.getName().equals(oFkSchemaName.get())))
+ .map(dbs -> getDbSchemaForeignKeys(catalog.getName(), dbs, oFkTableName, oPkCatalogName,
+ oPkSchemaName, oPkTableName)).flatMap(Collection::stream).toList();
+ } else {
+ return catalog.getRelationalSchemas().stream()
+ .map(dbs -> getDbSchemaForeignKeys(catalog.getName(), dbs, oFkTableName, oPkCatalogName,
+ oPkSchemaName, oPkTableName)).flatMap(Collection::stream).toList();
+ }
+ }
+
+ private static List getDbSchemaForeignKeys(String catalogName, Schema dbs, Optional oFkTableName,
+ Optional oPkCatalogName, Optional oPkSchemaName, Optional oPkTableName) {
+ if (oFkTableName.isPresent()) {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .filter(t -> (t.getName().equals(oFkTableName.get())))
+ .map(t -> getDbSchemaForeignKeys(catalogName, dbs.getName(), t, oPkCatalogName, oPkSchemaName, oPkTableName)).flatMap(Collection::stream).toList();
+ } else {
+ return dbs.getOwnedElement().stream().filter(Table.class::isInstance)
+ .map(Table.class::cast).toList().stream()
+ .map(t -> getDbSchemaForeignKeys(catalogName, dbs.getName(), t, oPkCatalogName, oPkSchemaName, oPkTableName)).flatMap(Collection::stream).toList();
+
+ }
+ }
+
+ private static List getDbSchemaForeignKeys(String catalogName, String schemaName, Table t,
+ Optional oPkCatalogName, Optional oPkSchemaName, Optional oPkTableName) {
+ return t.getOwnedElement().stream()
+ .filter(ForeignKey.class::isInstance)
+ .map(ForeignKey.class::cast)
+ .collect(Collectors.toList()).stream().map(fk -> getDbSchemaForeignKeys(catalogName, schemaName, t.getName(), fk,
+ oPkCatalogName, oPkSchemaName, oPkTableName)).flatMap(Collection::stream).toList();
+ }
+
+ private static List getDbSchemaForeignKeys(String catalogName, String schemaName, String fktableName, ForeignKey fk,
+ Optional oPkCatalogName, Optional oPkSchemaName, Optional