diff --git a/instance/emf/complex/expressivenames/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/expressivenames/CheckSuiteSupplier.java b/instance/emf/complex/expressivenames/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/expressivenames/CheckSuiteSupplier.java new file mode 100644 index 00000000..c75425aa --- /dev/null +++ b/instance/emf/complex/expressivenames/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/expressivenames/CheckSuiteSupplier.java @@ -0,0 +1,300 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.complex.expressivenames; + +import java.util.List; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the ExpressiveNames complex mapping example. + * Checks that the catalog with Cube1 and its associated dimensions and measures exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "ExpressiveNames"; + + // Cube name + private static final String CUBE_1_NAME = "Cube1"; + + // Measure name + private static final String MEASURE_1 = "Measure1"; + + // Dimension names + private static final String DIMENSION_1 = "Dimension1"; + private static final String DIMENSION_2 = "Dimension2"; + private static final String DIMENSION_3 = "Dimension3"; + + @Override + public OlapCheckSuite get() { + // Create dimension checks + DimensionCheck dimCheckDimension1 = createDimensionCheck(DIMENSION_1, + createHierarchyCheck("D1H1", + createLevelCheck("D1H1L1"))); + DimensionCheck dimCheckDimension2 = createDimensionCheck(DIMENSION_2, + createHierarchyCheck("D2H1", + createLevelCheck("D2H1L1")), + createHierarchyCheck("D2H2", + createLevelCheck("D2H2L1"), + createLevelCheck("D2H2L2"))); + DimensionCheck dimCheckDimension3 = createDimensionCheck(DIMENSION_3, + createHierarchyCheck("D3H1", + createLevelCheck("D3H1L1")), + createHierarchyCheck("D3H2", + createLevelCheck("D3H2L1"), + createLevelCheck("D3H2L2")), + createHierarchyCheck("D3H3", + createLevelCheck("D3H3L1"), + createLevelCheck("D3H3L2"), + createLevelCheck("D3H3L3"))); + + // Create measure check + MeasureCheck measureCheck1 = createMeasureCheck(MEASURE_1); + + // Create cube check + CubeCheck cubeCheckCube1 = factory.createCubeCheck(); + cubeCheckCube1.setName("CubeCheck-" + CUBE_1_NAME); + cubeCheckCube1.setDescription("Check that cube '" + CUBE_1_NAME + "' exists"); + cubeCheckCube1.setCubeName(CUBE_1_NAME); + cubeCheckCube1.getMeasureChecks().add(measureCheck1); + cubeCheckCube1.getDimensionChecks().add(dimCheckDimension1); + cubeCheckCube1.getDimensionChecks().add(dimCheckDimension2); + cubeCheckCube1.getDimensionChecks().add(dimCheckDimension3); + + // Create database table and column checks + DatabaseTableCheck tableCheckCube1Fact = createTableCheck("Cube1Fact", + createColumnCheck("D1", "VARCHAR"), + createColumnCheck("D2", "VARCHAR"), + createColumnCheck("D3", "VARCHAR"), + createColumnCheck("M1", "INTEGER") + ); + + DatabaseTableCheck tableCheckD1H1L1Table = createTableCheck("D1H1L1Table", + createColumnCheck("D1H1L1", "VARCHAR"), + createColumnCheck("D1H1L1_NAME", "VARCHAR"), + createColumnCheck("D1H1L1_Ordinal", "VARCHAR") + ); + + DatabaseTableCheck tableCheckD2H1L1Table = createTableCheck("D2H1L1Table", + createColumnCheck("D2H1L1", "VARCHAR"), + createColumnCheck("D2H1L1_NAME", "VARCHAR"), + createColumnCheck("D2H1L1_Ordinal", "VARCHAR") + ); + + DatabaseTableCheck tableCheckD2H2L2Table = createTableCheck("D2H2L2Table", + createColumnCheck("D2H2L2", "VARCHAR"), + createColumnCheck("D2H2L1", "VARCHAR"), + createColumnCheck("D2H2L2_NAME", "VARCHAR"), + createColumnCheck("D2H2L1_NAME", "VARCHAR"), + createColumnCheck("D2H2L2_Ordinal", "VARCHAR"), + createColumnCheck("D2H2L1_Ordinal", "VARCHAR") + ); + + DatabaseTableCheck tableCheckD3H1L1Table = createTableCheck("D3H1L1Table", + createColumnCheck("D3H1L1", "VARCHAR"), + createColumnCheck("D3H1L1_NAME", "VARCHAR"), + createColumnCheck("D3H1L1_Ordinal", "VARCHAR") + ); + + DatabaseTableCheck tableCheckD3H2L2Table = createTableCheck("D3H2L2Table", + createColumnCheck("D3H2L2", "VARCHAR"), + createColumnCheck("D3H2L2_id", "VARCHAR"), + createColumnCheck("D3H2L1_id", "VARCHAR"), + createColumnCheck("D3H2L2_NAME", "VARCHAR"), + createColumnCheck("D3H2L2_Ordinal", "VARCHAR") + ); + + DatabaseTableCheck tableCheckD3H2L1Table = createTableCheck("D3H2L1Table", + createColumnCheck("D3H2L1", "VARCHAR"), + createColumnCheck("D3H2L1_NAME", "VARCHAR"), + createColumnCheck("D3H2L1_Ordinal", "VARCHAR") + ); + + DatabaseTableCheck tableCheckD3H3L3Table = createTableCheck("D3H3L3Table", + createColumnCheck("D3H3L3", "VARCHAR"), + createColumnCheck("D3H3L2_id", "VARCHAR"), + createColumnCheck("D3H3L3_NAME", "VARCHAR"), + createColumnCheck("D3H3L3_Ordinal", "VARCHAR") + ); + + DatabaseTableCheck tableCheckD3H3L2Table = createTableCheck("D3H3L2Table", + createColumnCheck("D3H3L2", "VARCHAR"), + createColumnCheck("D3H3L1_id", "VARCHAR"), + createColumnCheck("D3H3L2_NAME", "VARCHAR"), + createColumnCheck("D3H3L2_Ordinal", "VARCHAR") + ); + + DatabaseTableCheck tableCheckD3H3L1Table = createTableCheck("D3H3L1Table", + createColumnCheck("D3H3L1", "VARCHAR"), + createColumnCheck("D3H3L1_NAME", "VARCHAR"), + createColumnCheck("D3H3L1_Ordinal", "VARCHAR") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for ExpressiveNames mapping"); + databaseSchemaCheck.getTableChecks().add(tableCheckCube1Fact); + databaseSchemaCheck.getTableChecks().add(tableCheckD1H1L1Table); + databaseSchemaCheck.getTableChecks().add(tableCheckD2H1L1Table); + databaseSchemaCheck.getTableChecks().add(tableCheckD2H2L2Table); + databaseSchemaCheck.getTableChecks().add(tableCheckD3H1L1Table); + databaseSchemaCheck.getTableChecks().add(tableCheckD3H2L2Table); + databaseSchemaCheck.getTableChecks().add(tableCheckD3H2L1Table); + databaseSchemaCheck.getTableChecks().add(tableCheckD3H3L3Table); + databaseSchemaCheck.getTableChecks().add(tableCheckD3H3L2Table); + databaseSchemaCheck.getTableChecks().add(tableCheckD3H3L1Table); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes and dimensions"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckCube1); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for ExpressiveNames mapping example"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("ExpressiveNames Example Suite"); + suite.setDescription("Check suite for the ExpressiveNames mapping example"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @param hierarchyChecks the hierarchy checks to add to the dimension check + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName, HierarchyCheck... hierarchyChecks) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + if (hierarchyChecks != null) { + for (HierarchyCheck hierarchyCheck : hierarchyChecks) { + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + } + } + return dimensionCheck; + } + + /** + * Creates a HierarchyCheck with the specified name and level checks. + * + * @param hierarchyName the name of the hierarchy + * @param levelChecks the level checks to add to the hierarchy check + * @return the configured HierarchyCheck + */ + private HierarchyCheck createHierarchyCheck(String hierarchyName, LevelCheck... levelChecks) { + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-" + hierarchyName); + hierarchyCheck.setHierarchyName(hierarchyName); + if (levelChecks != null) { + for (LevelCheck levelCheck : levelChecks) { + hierarchyCheck.getLevelChecks().add(levelCheck); + } + } + return hierarchyCheck; + } + + /** + * Creates a LevelCheck with the specified name. + * + * @param levelName the name of the level + * @return the configured LevelCheck + */ + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-" + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/complex/foodmart/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/foodmart/CheckSuiteSupplier.java b/instance/emf/complex/foodmart/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/foodmart/CheckSuiteSupplier.java new file mode 100644 index 00000000..272d6086 --- /dev/null +++ b/instance/emf/complex/foodmart/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/foodmart/CheckSuiteSupplier.java @@ -0,0 +1,871 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.complex.foodmart; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the FoodMart complex mapping example. + * Checks that the catalog with Sales, Warehouse, Store, HR, Sales Ragged, Sales 2, and Warehouse and Sales cubes exist with their associated dimensions and measures. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "FoodMart"; + + // Cube names + private static final String CUBE_SALES = "Sales"; + private static final String CUBE_WAREHOUSE = "Warehouse"; + private static final String CUBE_STORE = "Store"; + private static final String CUBE_HR = "HR"; + private static final String CUBE_SALES_RAGGED = "Sales Ragged"; + private static final String CUBE_SALES_2 = "Sales 2"; + private static final String CUBE_WAREHOUSE_AND_SALES = "Warehouse and Sales"; + + // Sales cube measure names + private static final String MEASURE_UNIT_SALES = "Unit Sales"; + private static final String MEASURE_STORE_SALES = "Store Sales"; + private static final String MEASURE_STORE_COST = "Store Cost"; + private static final String MEASURE_SALES_COUNT = "Sales Count"; + private static final String MEASURE_CUSTOMER_COUNT = "Customer Count"; + private static final String MEASURE_PROMOTION_SALES = "Promotion Sales"; + + // Warehouse cube measure names + private static final String MEASURE_WAREHOUSE_SALES = "Warehouse Sales"; + private static final String MEASURE_WAREHOUSE_COST = "Warehouse Cost"; + private static final String MEASURE_WAREHOUSE_PROFIT = "Warehouse Profit"; + private static final String MEASURE_UNITS_SHIPPED = "Units Shipped"; + private static final String MEASURE_UNITS_ORDERED = "Units Ordered"; + private static final String MEASURE_STORE_INVOICE = "Store Invoice"; + private static final String MEASURE_SUPPLY_TIME = "Supply Time"; + + // Store cube measure names + private static final String MEASURE_STORE_SQFT = "Store Sqft"; + private static final String MEASURE_GROCERY_SQFT = "Grocery Sqft"; + + // HR cube measure names + private static final String MEASURE_ORG_SALARY = "Org Salary"; + private static final String MEASURE_COUNT = "Count"; + private static final String MEASURE_NUMBER_OF_EMPLOYEES = "Number of Employees"; + + // Common dimension names + private static final String DIM_TIME = "Time"; + private static final String DIM_STORE = "Store"; + private static final String HIERARCHY_STORE = "Store"; + private static final String DIM_PRODUCT = "Product"; + private static final String DIM_CUSTOMERS = "Customers"; + private static final String DIM_PROMOTIONS = "Promotions"; + private static final String DIM_PROMOTION_MEDIA = "Promotion Media"; + private static final String DIM_STORE_SIZE_IN_SQFT = "Store Size in SQFT"; + private static final String DIM_STORE_TYPE = "Store Type"; + private static final String DIM_WAREHOUSE = "Warehouse"; + private static final String DIM_EDUCATION_LEVEL = "Education Level"; + private static final String DIM_GENDER = "Gender"; + private static final String DIM_MARITAL_STATUS = "Marital Status"; + private static final String DIM_YEARLY_INCOME = "Yearly Income"; + private static final String DIM_GEOGRAPHY = "Geography"; + private static final String DIM_POSITION = "Position"; + private static final String DIM_DEPARTMENT = "Department"; + private static final String DIM_EMPLOYEES = "Employees"; + private static final String DIM_HAS_COFFEE_BAR = "Has coffee bar"; + private static final String DIM_PAY_TYPE = "Pay Type"; + + @Override + public OlapCheckSuite get() { + // Create Sales cube check + CubeCheck cubeCheckSales = createSalesCubeCheck(); + + // Create Warehouse cube check + CubeCheck cubeCheckWarehouse = createWarehouseCubeCheck(); + + // Create Store cube check + CubeCheck cubeCheckStore = createStoreCubeCheck(); + + // Create HR cube check + CubeCheck cubeCheckHR = createHRCubeCheck(); + + // Create Sales Ragged cube check + CubeCheck cubeCheckSalesRagged = createSalesRaggedCubeCheck(); + + // Create Sales 2 cube check + CubeCheck cubeCheckSales2 = createSales2CubeCheck(); + + // Create Warehouse and Sales cube check + CubeCheck cubeCheckWarehouseAndSales = createWarehouseAndSalesCubeCheck(); + + // Create database table and column checks + DatabaseTableCheck tableCheckSalesFact = createTableCheck("sales_fact_1997", + createColumnCheck("time_id", "INTEGER"), + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("customer_id", "INTEGER"), + createColumnCheck("promotion_id", "INTEGER"), + createColumnCheck("product_id", "INTEGER"), + createColumnCheck("unit_sales", "DECIMAL"), + createColumnCheck("store_sales", "DECIMAL"), + createColumnCheck("store_cost", "DECIMAL") + ); + + DatabaseTableCheck tableCheckSalesFact1998 = createTableCheck("sales_fact_1998", + createColumnCheck("product_id", "INTEGER"), + createColumnCheck("time_id", "INTEGER"), + createColumnCheck("customer_id", "INTEGER"), + createColumnCheck("promotion_id", "INTEGER"), + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("store_sales", "DECIMAL"), + createColumnCheck("store_cost", "DECIMAL"), + createColumnCheck("unit_sales", "DECIMAL") + ); + + DatabaseTableCheck tableCheckTime = createTableCheck("time_by_day", + createColumnCheck("time_id", "INTEGER"), + createColumnCheck("the_date", "TIMESTAMP"), + createColumnCheck("the_year", "VARCHAR"), + createColumnCheck("quarter", "VARCHAR"), + createColumnCheck("the_month", "VARCHAR") + ); + + DatabaseTableCheck tableCheckStore = createTableCheck("store", + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("store_name", "VARCHAR"), + createColumnCheck("store_country", "VARCHAR"), + createColumnCheck("store_state", "VARCHAR"), + createColumnCheck("store_city", "VARCHAR") + ); + + DatabaseTableCheck tableCheckStoreRagged = createTableCheck("store_ragged", + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("store_type", "VARCHAR"), + createColumnCheck("store_name", "VARCHAR"), + createColumnCheck("store_street_address", "VARCHAR"), + createColumnCheck("store_state", "VARCHAR"), + createColumnCheck("store_country", "VARCHAR"), + createColumnCheck("store_manager", "VARCHAR"), + createColumnCheck("store_city", "VARCHAR"), + createColumnCheck("store_sqft", "INTEGER"), + createColumnCheck("grocery_sqft", "INTEGER"), + createColumnCheck("frozen_sqft", "INTEGER"), + createColumnCheck("meat_sqft", "INTEGER"), + createColumnCheck("coffee_bar", "SMALLINT"), + createColumnCheck("region_id", "INTEGER") + ); + + DatabaseTableCheck tableCheckCustomer = createTableCheck("customer", + createColumnCheck("customer_id", "INTEGER"), + createColumnCheck("fullname", "VARCHAR"), + createColumnCheck("gender", "VARCHAR"), + createColumnCheck("country", "VARCHAR"), + createColumnCheck("state_province", "VARCHAR"), + createColumnCheck("city", "VARCHAR") + ); + + DatabaseTableCheck tableCheckProduct = createTableCheck("product", + createColumnCheck("product_class_id", "INTEGER"), + createColumnCheck("product_id", "INTEGER"), + createColumnCheck("product_name", "VARCHAR"), + createColumnCheck("brand_name", "VARCHAR") + ); + + DatabaseTableCheck tableCheckPromotion = createTableCheck("promotion", + createColumnCheck("promotion_id", "INTEGER"), + createColumnCheck("promotion_name", "VARCHAR"), + createColumnCheck("media_type", "VARCHAR") + ); + + DatabaseTableCheck tableCheckWarehouse = createTableCheck("warehouse", + createColumnCheck("warehouse_id", "INTEGER"), + createColumnCheck("warehouse_name", "VARCHAR"), + createColumnCheck("warehouse_city", "VARCHAR"), + createColumnCheck("warehouse_state_province", "VARCHAR"), + createColumnCheck("warehouse_country", "VARCHAR") + ); + + DatabaseTableCheck tableCheckInventoryFact = createTableCheck("inventory_fact_1997", + createColumnCheck("product_id", "INTEGER"), + createColumnCheck("time_id", "INTEGER"), + createColumnCheck("warehouse_id", "INTEGER"), + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("units_ordered", "INTEGER"), + createColumnCheck("units_shipped", "INTEGER"), + createColumnCheck("warehouse_sales", "DECIMAL"), + createColumnCheck("warehouse_cost", "DECIMAL"), + createColumnCheck("supply_time", "INTEGER"), + createColumnCheck("store_invoice", "DECIMAL") + ); + + DatabaseTableCheck tableCheckEmployee = createTableCheck("employee", + createColumnCheck("employee_id", "INTEGER"), + createColumnCheck("full_name", "VARCHAR"), + createColumnCheck("first_name", "VARCHAR"), + createColumnCheck("last_name", "VARCHAR"), + createColumnCheck("position_id", "INTEGER"), + createColumnCheck("position_title", "VARCHAR"), + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("department_id", "INTEGER"), + createColumnCheck("supervisor_id", "INTEGER"), + createColumnCheck("salary", "DECIMAL") + ); + + DatabaseTableCheck tableCheckEmployeeClosure = createTableCheck("employee_closure", + createColumnCheck("supervisor_id", "INTEGER"), + createColumnCheck("employee_id", "INTEGER"), + createColumnCheck("distance", "INTEGER") + ); + + DatabaseTableCheck tableCheckDepartment = createTableCheck("department", + createColumnCheck("department_id", "INTEGER"), + createColumnCheck("department_description", "VARCHAR") + ); + + DatabaseTableCheck tableCheckPosition = createTableCheck("position", + createColumnCheck("position_id", "INTEGER"), + createColumnCheck("position_title", "VARCHAR"), + createColumnCheck("pay_type", "VARCHAR"), + createColumnCheck("min_scale", "DECIMAL"), + createColumnCheck("max_scale", "DECIMAL") + ); + + DatabaseTableCheck tableCheckSalary = createTableCheck("salary", + createColumnCheck("employee_id", "INTEGER"), + createColumnCheck("department_id", "INTEGER"), + createColumnCheck("pay_date", "TIMESTAMP"), + createColumnCheck("salary_paid", "DECIMAL"), + createColumnCheck("overtime_paid", "DECIMAL"), + createColumnCheck("vacation_accrued", "REAL"), + createColumnCheck("vacation_used", "REAL") + ); + + DatabaseTableCheck tableCheckAggCSpecialSalesFact1997 = createTableCheck("agg_c_special_sales_fact_1997", + createColumnCheck("product_id", "INTEGER"), + createColumnCheck("promotion_id", "INTEGER"), + createColumnCheck("customer_id", "INTEGER"), + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("time_month", "SMALLINT"), + createColumnCheck("time_quarter", "VARCHAR"), + createColumnCheck("time_year", "SMALLINT"), + createColumnCheck("store_sales_sum", "DECIMAL"), + createColumnCheck("store_cost_sum", "DECIMAL"), + createColumnCheck("unit_sales_sum", "DECIMAL"), + createColumnCheck("fact_count", "INTEGER") + ); + + DatabaseTableCheck tableCheckAggC10SalesFact1997 = createTableCheck("agg_c_10_sales_fact_1997", + createColumnCheck("month_of_year", "SMALLINT"), + createColumnCheck("quarter", "VARCHAR"), + createColumnCheck("the_year", "SMALLINT"), + createColumnCheck("store_sales", "DECIMAL"), + createColumnCheck("store_cost", "DECIMAL"), + createColumnCheck("unit_sales", "DECIMAL"), + createColumnCheck("customer_count", "INTEGER"), + createColumnCheck("fact_count", "INTEGER") + ); + + DatabaseTableCheck tableCheckAggL05SalesFact1997 = createTableCheck("agg_l_05_sales_fact_1997", + createColumnCheck("product_id", "INTEGER"), + createColumnCheck("customer_id", "INTEGER"), + createColumnCheck("promotion_id", "INTEGER"), + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("store_sales", "DECIMAL"), + createColumnCheck("store_cost", "DECIMAL"), + createColumnCheck("unit_sales", "DECIMAL"), + createColumnCheck("fact_count", "INTEGER") + ); + + DatabaseTableCheck tableCheckAggL03SalesFact1997 = createTableCheck("agg_l_03_sales_fact_1997", + createColumnCheck("time_id", "INTEGER"), + createColumnCheck("customer_id", "INTEGER"), + createColumnCheck("store_sales", "DECIMAL"), + createColumnCheck("store_cost", "DECIMAL"), + createColumnCheck("unit_sales", "DECIMAL"), + createColumnCheck("fact_count", "INTEGER") + ); + + DatabaseTableCheck tableCheckAggPl01SalesFact1997 = createTableCheck("agg_pl_01_sales_fact_1997", + createColumnCheck("product_id", "INTEGER"), + createColumnCheck("time_id", "INTEGER"), + createColumnCheck("customer_id", "INTEGER"), + createColumnCheck("store_sales_sum", "DECIMAL"), + createColumnCheck("store_cost_sum", "DECIMAL"), + createColumnCheck("unit_sales_sum", "DECIMAL"), + createColumnCheck("fact_count", "DECIMAL") + ); + + DatabaseTableCheck tableCheckAggGMsPcatSalesFact1997 = createTableCheck("agg_g_ms_pcat_sales_fact_1997", + createColumnCheck("gender", "VARCHAR"), + createColumnCheck("marital_status", "VARCHAR"), + createColumnCheck("product_family", "VARCHAR"), + createColumnCheck("product_department", "VARCHAR"), + createColumnCheck("product_category", "VARCHAR"), + createColumnCheck("month_of_year", "SMALLINT"), + createColumnCheck("quarter", "VARCHAR"), + createColumnCheck("the_year", "SMALLINT"), + createColumnCheck("store_sales", "DECIMAL"), + createColumnCheck("store_cost", "DECIMAL"), + createColumnCheck("unit_sales", "DECIMAL"), + createColumnCheck("customer_count", "INTEGER"), + createColumnCheck("fact_count", "INTEGER") + ); + + DatabaseTableCheck tableCheckAggC14SalesFact1997 = createTableCheck("agg_c_14_sales_fact_1997", + createColumnCheck("product_id", "INTEGER"), + createColumnCheck("customer_id", "INTEGER"), + createColumnCheck("store_id", "INTEGER"), + createColumnCheck("promotion_id", "INTEGER"), + createColumnCheck("month_of_year", "SMALLINT"), + createColumnCheck("quarter", "VARCHAR"), + createColumnCheck("the_year", "SMALLINT"), + createColumnCheck("store_sales", "DECIMAL"), + createColumnCheck("store_cost", "DECIMAL"), + createColumnCheck("unit_sales", "DECIMAL"), + createColumnCheck("fact_count", "INTEGER") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for FoodMart mapping"); + databaseSchemaCheck.getTableChecks().add(tableCheckSalesFact); + databaseSchemaCheck.getTableChecks().add(tableCheckSalesFact1998); + databaseSchemaCheck.getTableChecks().add(tableCheckTime); + databaseSchemaCheck.getTableChecks().add(tableCheckStore); + databaseSchemaCheck.getTableChecks().add(tableCheckStoreRagged); + databaseSchemaCheck.getTableChecks().add(tableCheckCustomer); + databaseSchemaCheck.getTableChecks().add(tableCheckProduct); + databaseSchemaCheck.getTableChecks().add(tableCheckPromotion); + databaseSchemaCheck.getTableChecks().add(tableCheckWarehouse); + databaseSchemaCheck.getTableChecks().add(tableCheckInventoryFact); + databaseSchemaCheck.getTableChecks().add(tableCheckEmployee); + databaseSchemaCheck.getTableChecks().add(tableCheckEmployeeClosure); + databaseSchemaCheck.getTableChecks().add(tableCheckDepartment); + databaseSchemaCheck.getTableChecks().add(tableCheckPosition); + databaseSchemaCheck.getTableChecks().add(tableCheckSalary); + databaseSchemaCheck.getTableChecks().add(tableCheckAggCSpecialSalesFact1997); + databaseSchemaCheck.getTableChecks().add(tableCheckAggC10SalesFact1997); + databaseSchemaCheck.getTableChecks().add(tableCheckAggL05SalesFact1997); + databaseSchemaCheck.getTableChecks().add(tableCheckAggL03SalesFact1997); + databaseSchemaCheck.getTableChecks().add(tableCheckAggPl01SalesFact1997); + databaseSchemaCheck.getTableChecks().add(tableCheckAggGMsPcatSalesFact1997); + databaseSchemaCheck.getTableChecks().add(tableCheckAggC14SalesFact1997); + + // Create catalog check with cube checks + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes and dimensions"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckSales); + catalogCheck.getCubeChecks().add(cubeCheckWarehouse); + catalogCheck.getCubeChecks().add(cubeCheckStore); + catalogCheck.getCubeChecks().add(cubeCheckHR); + catalogCheck.getCubeChecks().add(cubeCheckSalesRagged); + catalogCheck.getCubeChecks().add(cubeCheckSales2); + catalogCheck.getCubeChecks().add(cubeCheckWarehouseAndSales); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for FoodMart mapping example"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("FoodMart Example Suite"); + suite.setDescription("Check suite for the FoodMart mapping example"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates the Sales cube check with its dimensions and measures. + * + * @return the configured CubeCheck for Sales + */ + private CubeCheck createSalesCubeCheck() { + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_SALES); + cubeCheck.setDescription("Check that cube '" + CUBE_SALES + "' exists"); + cubeCheck.setCubeName(CUBE_SALES); + + // Add measures + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_UNIT_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_COST)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_SALES_COUNT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_CUSTOMER_COUNT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_PROMOTION_SALES)); + + // Add dimensions + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_TIME, + createHierarchyCheck("Time", + createLevelCheck("Year"), + createLevelCheck("Quarter"), + createLevelCheck("Month")), + createHierarchyCheck("Weekly", + createLevelCheck("Year"), + createLevelCheck("Week"), + createLevelCheck("Day")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE, + createHierarchyCheck(HIERARCHY_STORE, + createLevelCheck("Store Country"), + createLevelCheck("Store State"), + createLevelCheck("Store City"), + createLevelCheck("Store Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PRODUCT, + createHierarchyCheck("Product", + createLevelCheck("Product Family"), + createLevelCheck("Product Department"), + createLevelCheck("Product Category"), + createLevelCheck("Product Subcategory"), + createLevelCheck("Brand Name"), + createLevelCheck("Product Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_CUSTOMERS, + createHierarchyCheck("Customers", + createLevelCheck("Country"), + createLevelCheck("State Province"), + createLevelCheck("City"), + createLevelCheck("Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PROMOTIONS, + createHierarchyCheck("Promotions", + createLevelCheck("Promotion Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PROMOTION_MEDIA, + createHierarchyCheck("Promotion Media", + createLevelCheck("Media Type")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE_SIZE_IN_SQFT, + createHierarchyCheck("Store Size in SQFT", + createLevelCheck("Store Sqft")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE_TYPE, + createHierarchyCheck("Store Type", + createLevelCheck("Store Type")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_EDUCATION_LEVEL, + createHierarchyCheck("Education Level", + createLevelCheck("Education Level")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_GENDER, + createHierarchyCheck("Gender", + createLevelCheck("Gender")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_MARITAL_STATUS, + createHierarchyCheck("Marital Status", + createLevelCheck("Marital Status")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_YEARLY_INCOME, + createHierarchyCheck("Yearly Income", + createLevelCheck("Yearly Income")))); + + return cubeCheck; + } + + private HierarchyCheck createHierarchyCheck(String hierarchyName, LevelCheck... levelChecks) { + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-" + hierarchyName); + hierarchyCheck.setHierarchyName(hierarchyName); + if (levelChecks != null) { + for (LevelCheck levelCheck : levelChecks) { + hierarchyCheck.getLevelChecks().add(levelCheck); + } + } + return hierarchyCheck; + } + + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-" + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates the Warehouse cube check with its dimensions and measures. + * + * @return the configured CubeCheck for Warehouse + */ + private CubeCheck createWarehouseCubeCheck() { + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_WAREHOUSE); + cubeCheck.setDescription("Check that cube '" + CUBE_WAREHOUSE + "' exists"); + cubeCheck.setCubeName(CUBE_WAREHOUSE); + + // Add measures + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_WAREHOUSE_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_WAREHOUSE_COST)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_WAREHOUSE_PROFIT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_UNITS_SHIPPED)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_UNITS_ORDERED)); + + // Add dimensions + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_TIME, + createHierarchyCheck("Time", + createLevelCheck("Year"), + createLevelCheck("Quarter"), + createLevelCheck("Month")), + createHierarchyCheck("Weekly", + createLevelCheck("Year"), + createLevelCheck("Week"), + createLevelCheck("Day")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE, + createHierarchyCheck(HIERARCHY_STORE, + createLevelCheck("Store Country"), + createLevelCheck("Store State"), + createLevelCheck("Store City"), + createLevelCheck("Store Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE_SIZE_IN_SQFT, + createHierarchyCheck("Store Size in SQFT", + createLevelCheck("Store Sqft")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE_TYPE, + createHierarchyCheck("Store Type", + createLevelCheck("Store Type")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PRODUCT, + createHierarchyCheck("Product", + createLevelCheck("Product Family"), + createLevelCheck("Product Department"), + createLevelCheck("Product Category"), + createLevelCheck("Product Subcategory"), + createLevelCheck("Brand Name"), + createLevelCheck("Product Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_WAREHOUSE, + createHierarchyCheck("Warehouse", + createLevelCheck("Country"), + createLevelCheck("State Province"), + createLevelCheck("City"), + createLevelCheck("Warehouse Name")))); + + return cubeCheck; + } + + /** + * Creates the Store cube check with its dimensions and measures. + * + * @return the configured CubeCheck for Store + */ + private CubeCheck createStoreCubeCheck() { + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_STORE); + cubeCheck.setDescription("Check that cube '" + CUBE_STORE + "' exists"); + cubeCheck.setCubeName(CUBE_STORE); + + // Add measures + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_SQFT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_GROCERY_SQFT)); + + // Add dimensions + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE, + createHierarchyCheck(HIERARCHY_STORE, + createLevelCheck("Store Country"), + createLevelCheck("Store State"), + createLevelCheck("Store City"), + createLevelCheck("Store Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE_TYPE, + createHierarchyCheck("Store Type", + createLevelCheck("Store Type")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_HAS_COFFEE_BAR, + createHierarchyCheck("Has coffee bar", + createLevelCheck("Has coffee bar")))); + + return cubeCheck; + } + + /** + * Creates the HR cube check with its dimensions and measures. + * + * @return the configured CubeCheck for HR + */ + private CubeCheck createHRCubeCheck() { + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_HR); + cubeCheck.setDescription("Check that cube '" + CUBE_HR + "' exists"); + cubeCheck.setCubeName(CUBE_HR); + + // Add measures + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_ORG_SALARY)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_COUNT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_NUMBER_OF_EMPLOYEES)); + + // Add dimensions + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_TIME, + createHierarchyCheck("Time", + createLevelCheck("Year"), + createLevelCheck("Quarter"), + createLevelCheck("Month")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE, + createHierarchyCheck(HIERARCHY_STORE, + createLevelCheck("Store Country"), + createLevelCheck("Store State"), + createLevelCheck("Store City"), + createLevelCheck("Store Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PAY_TYPE, + createHierarchyCheck("Pay Type", + createLevelCheck("Pay Type")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE_TYPE, + createHierarchyCheck("Store Type", + createLevelCheck("Store Type")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_POSITION, + createHierarchyCheck("Position", + createLevelCheck("Management Role"), + createLevelCheck("Position Title")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_DEPARTMENT, + createHierarchyCheck("Department", + createLevelCheck("Department Description")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_EMPLOYEES, + createHierarchyCheck("Employees", + createLevelCheck("Employee Id")))); + + return cubeCheck; + } + + /** + * Creates the Sales Ragged cube check with its dimensions and measures. + * + * @return the configured CubeCheck for Sales Ragged + */ + private CubeCheck createSalesRaggedCubeCheck() { + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_SALES_RAGGED); + cubeCheck.setDescription("Check that cube '" + CUBE_SALES_RAGGED + "' exists"); + cubeCheck.setCubeName(CUBE_SALES_RAGGED); + + // Add measures + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_UNIT_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_COST)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_SALES_COUNT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_CUSTOMER_COUNT)); + + // Add dimensions + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE, + createHierarchyCheck("Store", + createLevelCheck("Store Country"), + createLevelCheck("Store State"), + createLevelCheck("Store City"), + createLevelCheck("Store Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_GEOGRAPHY, + createHierarchyCheck("Geography", + createLevelCheck("Country"), + createLevelCheck("State"), + createLevelCheck("City")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE_SIZE_IN_SQFT, + createHierarchyCheck("Store Size in SQFT", + createLevelCheck("Store Sqft")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE_TYPE, + createHierarchyCheck("Store Type", + createLevelCheck("Store Type")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_TIME, + createHierarchyCheck("Time", + createLevelCheck("Year"), + createLevelCheck("Quarter"), + createLevelCheck("Month")), + createHierarchyCheck("Weekly", + createLevelCheck("Year"), + createLevelCheck("Week"), + createLevelCheck("Day")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PRODUCT, + createHierarchyCheck("Product", + createLevelCheck("Product Family"), + createLevelCheck("Product Department"), + createLevelCheck("Product Category"), + createLevelCheck("Product Subcategory"), + createLevelCheck("Brand Name"), + createLevelCheck("Product Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PROMOTION_MEDIA, + createHierarchyCheck("Promotion Media", + createLevelCheck("Media Type")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PROMOTIONS, + createHierarchyCheck("Promotions", + createLevelCheck("Promotion Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_CUSTOMERS, + createHierarchyCheck("Customers", + createLevelCheck("Country"), + createLevelCheck("State Province"), + createLevelCheck("City"), + createLevelCheck("Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_EDUCATION_LEVEL, + createHierarchyCheck("Education Level", + createLevelCheck("Education Level")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_GENDER, + createHierarchyCheck("Gender", + createLevelCheck("Gender")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_MARITAL_STATUS, + createHierarchyCheck("Marital Status", + createLevelCheck("Marital Status")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_YEARLY_INCOME, + createHierarchyCheck("Yearly Income", + createLevelCheck("Yearly Income")))); + + return cubeCheck; + } + + /** + * Creates the Sales 2 cube check with its dimensions and measures. + * + * @return the configured CubeCheck for Sales 2 + */ + private CubeCheck createSales2CubeCheck() { + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_SALES_2); + cubeCheck.setDescription("Check that cube '" + CUBE_SALES_2 + "' exists"); + cubeCheck.setCubeName(CUBE_SALES_2); + + // Add measures + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_SALES_COUNT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_UNIT_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_COST)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_CUSTOMER_COUNT)); + + // Add dimensions + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_TIME, + createHierarchyCheck("Time", + createLevelCheck("Year"), + createLevelCheck("Quarter"), + createLevelCheck("Month")), + createHierarchyCheck("Weekly", + createLevelCheck("Year"), + createLevelCheck("Week"), + createLevelCheck("Day")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PRODUCT, + createHierarchyCheck("Product", + createLevelCheck("Product Family"), + createLevelCheck("Product Department"), + createLevelCheck("Product Category"), + createLevelCheck("Product Subcategory"), + createLevelCheck("Brand Name"), + createLevelCheck("Product Name")))); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_GENDER, + createHierarchyCheck("Gender", + createLevelCheck("Gender")))); + + return cubeCheck; + } + + /** + * Creates the Warehouse and Sales virtual cube check with its dimensions and measures. + * + * @return the configured CubeCheck for Warehouse and Sales + */ + private CubeCheck createWarehouseAndSalesCubeCheck() { + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_WAREHOUSE_AND_SALES); + cubeCheck.setDescription("Check that cube '" + CUBE_WAREHOUSE_AND_SALES + "' exists"); + cubeCheck.setCubeName(CUBE_WAREHOUSE_AND_SALES); + + // Add measures + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_SALES_COUNT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_COST)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_UNIT_SALES)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_STORE_INVOICE)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_SUPPLY_TIME)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_UNITS_ORDERED)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_UNITS_SHIPPED)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_WAREHOUSE_COST)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_WAREHOUSE_PROFIT)); + cubeCheck.getMeasureChecks().add(createMeasureCheck(MEASURE_WAREHOUSE_SALES)); + + // Add dimensions + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_CUSTOMERS)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_EDUCATION_LEVEL)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_GENDER)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_MARITAL_STATUS)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PRODUCT)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PROMOTION_MEDIA)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_PROMOTIONS)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_STORE)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_TIME)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_YEARLY_INCOME)); + cubeCheck.getDimensionChecks().add(createDimensionCheck(DIM_WAREHOUSE)); + + return cubeCheck; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName, HierarchyCheck...hierarchyChecks ) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + if (hierarchyChecks != null) { + for (HierarchyCheck hierarchyCheck : hierarchyChecks) { + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + } + } + return dimensionCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/complex/parcel/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/parcel/CheckSuiteSupplier.java b/instance/emf/complex/parcel/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/parcel/CheckSuiteSupplier.java new file mode 100644 index 00000000..6ae956f5 --- /dev/null +++ b/instance/emf/complex/parcel/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/parcel/CheckSuiteSupplier.java @@ -0,0 +1,328 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.complex.parcel; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the Parcel Delivery Service complex mapping example. + * Checks that the catalog with Parcels cube and its associated dimensions and measures exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Parcel Delivery Service"; + + // Cube name + private static final String CUBE_PARCELS = "Parcels"; + + // Measure names + private static final String MEASURE_PARCEL_COUNT = "Parcel Count"; + private static final String MEASURE_POSTAGE_SUM = "Postage Sum"; + private static final String MEASURE_INSURANCE_VALUE_SUM = "Insurance Value Sum"; + private static final String MEASURE_WEIGHT_MIN = "Weight Min"; + private static final String MEASURE_WEIGHT_MAX = "Weight Max"; + private static final String MEASURE_WEIGHT_AVG = "Weight Avg"; + + // Dimension names + private static final String DIM_WIDTH = "Width"; + private static final String DIM_DEPTH = "Depth"; + private static final String DIM_HEIGHT = "Height"; + private static final String DIM_PARCEL_TYPE = "Parcel Type"; + private static final String DIM_DEFECT = "Defect"; + private static final String DIM_DELIVERABLE = "Deliverable"; + private static final String DIM_CUSTOMS = "Customs"; + private static final String DIM_RETURN = "Return"; + private static final String DIM_SENDER_ADDRESS = "Sender Address"; + private static final String DIM_RECEIVER_ADDRESS = "Receiver Address"; + private static final String DIM_DROP_OFF_ADDRESS = "Drop Off Address"; + private static final String DIM_DELIVERY_ADDRESS = "Delivery Address"; + + @Override + public OlapCheckSuite get() { + // Create dimension checks + DimensionCheck dimCheckWidth = createDimensionCheck(DIM_WIDTH, + createHierarchyCheck("Width", + createLevelCheck("Width"))); + DimensionCheck dimCheckDepth = createDimensionCheck(DIM_DEPTH, + createHierarchyCheck("Depth", + createLevelCheck("Depth"))); + DimensionCheck dimCheckHeight = createDimensionCheck(DIM_HEIGHT, + createHierarchyCheck("Height", + createLevelCheck("Height"))); + DimensionCheck dimCheckParcelType = createDimensionCheck(DIM_PARCEL_TYPE, + createHierarchyCheck("Parcel Type", + createLevelCheck("Parcel Type"))); + DimensionCheck dimCheckDefect = createDimensionCheck(DIM_DEFECT, + createHierarchyCheck("Defect", + createLevelCheck("Defect"))); + DimensionCheck dimCheckDeliverable = createDimensionCheck(DIM_DELIVERABLE, + createHierarchyCheck("Deliverable", + createLevelCheck("Deliverable"))); + DimensionCheck dimCheckCustoms = createDimensionCheck(DIM_CUSTOMS, + createHierarchyCheck("Customs", + createLevelCheck("Customs"))); + DimensionCheck dimCheckReturn = createDimensionCheck(DIM_RETURN, + createHierarchyCheck("Return", + createLevelCheck("Return"))); + DimensionCheck dimCheckSenderAddress = createDimensionCheck(DIM_SENDER_ADDRESS, + createHierarchyCheck("Geographic Address", + createLevelCheck("Continent"), + createLevelCheck("Country"), + createLevelCheck("City"), + createLevelCheck("Postal Code"), + createLevelCheck("Street"))); + DimensionCheck dimCheckReceiverAddress = createDimensionCheck(DIM_RECEIVER_ADDRESS, + createHierarchyCheck("Geographic Address", + createLevelCheck("Continent"), + createLevelCheck("Country"), + createLevelCheck("City"), + createLevelCheck("Postal Code"), + createLevelCheck("Street"))); + DimensionCheck dimCheckDropOffAddress = createDimensionCheck(DIM_DROP_OFF_ADDRESS, + createHierarchyCheck("Geographic Address", + createLevelCheck("Continent"), + createLevelCheck("Country"), + createLevelCheck("City"), + createLevelCheck("Postal Code"), + createLevelCheck("Street"))); + DimensionCheck dimCheckDeliveryAddress = createDimensionCheck(DIM_DELIVERY_ADDRESS, + createHierarchyCheck("Geographic Address", + createLevelCheck("Continent"), + createLevelCheck("Country"), + createLevelCheck("City"), + createLevelCheck("Postal Code"), + createLevelCheck("Street"))); + + // Create measure checks + MeasureCheck measureCheckParcelCount = createMeasureCheck(MEASURE_PARCEL_COUNT); + MeasureCheck measureCheckPostageSum = createMeasureCheck(MEASURE_POSTAGE_SUM); + MeasureCheck measureCheckInsuranceValueSum = createMeasureCheck(MEASURE_INSURANCE_VALUE_SUM); + MeasureCheck measureCheckWeightMin = createMeasureCheck(MEASURE_WEIGHT_MIN); + MeasureCheck measureCheckWeightMax = createMeasureCheck(MEASURE_WEIGHT_MAX); + MeasureCheck measureCheckWeightAvg = createMeasureCheck(MEASURE_WEIGHT_AVG); + + // Create cube check for Parcels + CubeCheck cubeCheckParcels = factory.createCubeCheck(); + cubeCheckParcels.setName("CubeCheck-" + CUBE_PARCELS); + cubeCheckParcels.setDescription("Check that cube '" + CUBE_PARCELS + "' exists"); + cubeCheckParcels.setCubeName(CUBE_PARCELS); + cubeCheckParcels.getMeasureChecks().add(measureCheckParcelCount); + cubeCheckParcels.getMeasureChecks().add(measureCheckPostageSum); + cubeCheckParcels.getMeasureChecks().add(measureCheckInsuranceValueSum); + cubeCheckParcels.getMeasureChecks().add(measureCheckWeightMin); + cubeCheckParcels.getMeasureChecks().add(measureCheckWeightMax); + cubeCheckParcels.getMeasureChecks().add(measureCheckWeightAvg); + cubeCheckParcels.getDimensionChecks().add(dimCheckWidth); + cubeCheckParcels.getDimensionChecks().add(dimCheckDepth); + cubeCheckParcels.getDimensionChecks().add(dimCheckHeight); + cubeCheckParcels.getDimensionChecks().add(dimCheckParcelType); + cubeCheckParcels.getDimensionChecks().add(dimCheckDefect); + cubeCheckParcels.getDimensionChecks().add(dimCheckDeliverable); + cubeCheckParcels.getDimensionChecks().add(dimCheckCustoms); + cubeCheckParcels.getDimensionChecks().add(dimCheckReturn); + cubeCheckParcels.getDimensionChecks().add(dimCheckSenderAddress); + cubeCheckParcels.getDimensionChecks().add(dimCheckReceiverAddress); + cubeCheckParcels.getDimensionChecks().add(dimCheckDropOffAddress); + cubeCheckParcels.getDimensionChecks().add(dimCheckDeliveryAddress); + + // Create database table and column checks + DatabaseTableCheck tableCheckParcels = createTableCheck("parcels", + createColumnCheck("parcel_id", "INTEGER"), + createColumnCheck("width", "DECIMAL"), + createColumnCheck("depth", "DECIMAL"), + createColumnCheck("height", "DECIMAL"), + createColumnCheck("type_id", "INTEGER"), + createColumnCheck("defect_id", "INTEGER"), + createColumnCheck("deliverable", "VARCHAR"), + createColumnCheck("customs", "VARCHAR"), + createColumnCheck("return_status", "VARCHAR"), + createColumnCheck("sender_id", "INTEGER"), + createColumnCheck("receiver_id", "INTEGER"), + createColumnCheck("drop_off_id", "INTEGER"), + createColumnCheck("delivery_id", "INTEGER"), + createColumnCheck("postage", "DECIMAL"), + createColumnCheck("insurance_value", "DECIMAL"), + createColumnCheck("weight", "DECIMAL") + ); + + DatabaseTableCheck tableCheckParcelTypes = createTableCheck("parcel_types", + createColumnCheck("type_id", "INTEGER"), + createColumnCheck("type_name", "VARCHAR") + ); + + DatabaseTableCheck tableCheckDefects = createTableCheck("defects", + createColumnCheck("defect_id", "INTEGER"), + createColumnCheck("defect_name", "VARCHAR") + ); + + DatabaseTableCheck tableCheckAddresses = createTableCheck("addresses", + createColumnCheck("address_id", "INTEGER"), + createColumnCheck("continent", "VARCHAR"), + createColumnCheck("country", "VARCHAR"), + createColumnCheck("city", "VARCHAR"), + createColumnCheck("postal_code", "VARCHAR"), + createColumnCheck("street", "VARCHAR") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for Parcel Delivery Service mapping"); + databaseSchemaCheck.getTableChecks().add(tableCheckParcels); + databaseSchemaCheck.getTableChecks().add(tableCheckParcelTypes); + databaseSchemaCheck.getTableChecks().add(tableCheckDefects); + databaseSchemaCheck.getTableChecks().add(tableCheckAddresses); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes and dimensions"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckParcels); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for Parcel Delivery Service mapping example"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Parcel Delivery Service Example Suite"); + suite.setDescription("Check suite for the Parcel Delivery Service mapping example"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @param hierarchyChecks the hierarchy checks to add to the dimension check + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName, HierarchyCheck... hierarchyChecks) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + if (hierarchyChecks != null) { + for (HierarchyCheck hierarchyCheck : hierarchyChecks) { + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + } + } + return dimensionCheck; + } + + /** + * Creates a HierarchyCheck with the specified name and level checks. + * + * @param hierarchyName the name of the hierarchy + * @param levelChecks the level checks to add to the hierarchy check + * @return the configured HierarchyCheck + */ + private HierarchyCheck createHierarchyCheck(String hierarchyName, LevelCheck... levelChecks) { + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-" + hierarchyName); + hierarchyCheck.setHierarchyName(hierarchyName); + if (levelChecks != null) { + for (LevelCheck levelCheck : levelChecks) { + hierarchyCheck.getLevelChecks().add(levelCheck); + } + } + return hierarchyCheck; + } + + /** + * Creates a LevelCheck with the specified name. + * + * @param levelName the name of the level + * @return the configured LevelCheck + */ + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-" + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/complex/population.jena/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/population/jena/CheckSuiteSupplier.java b/instance/emf/complex/population.jena/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/population/jena/CheckSuiteSupplier.java new file mode 100644 index 00000000..6c5d651a --- /dev/null +++ b/instance/emf/complex/population.jena/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/population/jena/CheckSuiteSupplier.java @@ -0,0 +1,294 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.complex.population.jena; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the Bevölkerung (Population) Jena complex mapping example. + * Checks that the catalog with Bevölkerung cube and its associated dimensions and measures exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Bevölkerung"; + + // Cube name + private static final String CUBE_BEVOELKERUNG = "Bevölkerung"; + + // Measure name + private static final String MEASURE_EINWOHNERZAHL = "Einwohnerzahl"; + + // Dimension names + private static final String DIM_JAHR = "Jahr"; + private static final String DIM_STATISTISCHER_BEZIRK = "statistischer Bezirk"; + private static final String DIM_GESCHLECHT = "Geschlecht"; + private static final String DIM_ALTER = "Alter"; + + @Override + public OlapCheckSuite get() { + // Create dimension checks + DimensionCheck dimCheckJahr = createDimensionCheck(DIM_JAHR, + createHierarchyCheck("Jahr", + createLevelCheck("Jahr"))); + DimensionCheck dimCheckStatistischerBezirk = createDimensionCheck(DIM_STATISTISCHER_BEZIRK, + createHierarchyCheck("Stadt - Planungsraum - statistischer Bezirk", + createLevelCheck("Stadt"), + createLevelCheck("Planungsraum"), + createLevelCheck("Statistischer Bezirk"))); + DimensionCheck dimCheckGeschlecht = createDimensionCheck(DIM_GESCHLECHT, + createHierarchyCheck("Geschlecht", + createLevelCheck("Geschlecht"))); + DimensionCheck dimCheckAlter = createDimensionCheck(DIM_ALTER, + createHierarchyCheck("Alter (Einzeljahrgänge)", + createLevelCheck("Alter")), + createHierarchyCheck("Altersgruppen (Standard)", + createLevelCheck("Altersgruppe"), + createLevelCheck("Alter Standard")), + createHierarchyCheck("Altersgruppen (Kinder)", + createLevelCheck("Altersgruppe"), + createLevelCheck("Alter Kinder")), + createHierarchyCheck("Altersgruppen (Systematik RKI H7)", + createLevelCheck("Altersgruppe"), + createLevelCheck("Alter H7")), + createHierarchyCheck("Altersgruppen (Systematik RKI H8)", + createLevelCheck("Altersgruppe"), + createLevelCheck("Alter H8")), + createHierarchyCheck("Altersgruppen (10-Jahres-Gruppen)", + createLevelCheck("Altersgruppe"), + createLevelCheck("Alter 10"))); + + // Create measure check + MeasureCheck measureCheckEinwohnerzahl = createMeasureCheck(MEASURE_EINWOHNERZAHL); + + // Create cube check for Bevölkerung + CubeCheck cubeCheckBevoelkerung = factory.createCubeCheck(); + cubeCheckBevoelkerung.setName("CubeCheck-" + CUBE_BEVOELKERUNG); + cubeCheckBevoelkerung.setDescription("Check that cube '" + CUBE_BEVOELKERUNG + "' exists"); + cubeCheckBevoelkerung.setCubeName(CUBE_BEVOELKERUNG); + cubeCheckBevoelkerung.getMeasureChecks().add(measureCheckEinwohnerzahl); + cubeCheckBevoelkerung.getDimensionChecks().add(dimCheckJahr); + cubeCheckBevoelkerung.getDimensionChecks().add(dimCheckStatistischerBezirk); + cubeCheckBevoelkerung.getDimensionChecks().add(dimCheckGeschlecht); + cubeCheckBevoelkerung.getDimensionChecks().add(dimCheckAlter); + + // Create database table and column checks + DatabaseTableCheck tableCheckEinwohner = createTableCheck("einwohner", + createColumnCheck("JAHR", "INTEGER"), + createColumnCheck("STATBEZ", "INTEGER"), + createColumnCheck("KER_GESCH", "VARCHAR"), + createColumnCheck("AGE", "INTEGER"), + createColumnCheck("Anzahl", "INTEGER"), + createColumnCheck("GEOJSON", "VARCHAR") + ); + + DatabaseTableCheck tableCheckYear = createTableCheck("year", + createColumnCheck("year", "INTEGER"), + createColumnCheck("ordinal", "INTEGER") + ); + + DatabaseTableCheck tableCheckTown = createTableCheck("town", + createColumnCheck("id", "INTEGER"), + createColumnCheck("name", "VARCHAR"), + createColumnCheck("geojson", "VARCHAR") + ); + + DatabaseTableCheck tableCheckPlraum = createTableCheck("plraum", + createColumnCheck("gid", "INTEGER"), + createColumnCheck("plraum", "VARCHAR"), + createColumnCheck("uuid", "VARCHAR"), + createColumnCheck("geojson", "VARCHAR"), + createColumnCheck("townid", "INTEGER") + ); + + DatabaseTableCheck tableCheckStatbez = createTableCheck("statbez", + createColumnCheck("gid", "INTEGER"), + createColumnCheck("plraum", "INTEGER"), + createColumnCheck("statbez_name", "VARCHAR"), + createColumnCheck("uuid", "VARCHAR"), + createColumnCheck("geojson", "VARCHAR") + ); + + DatabaseTableCheck tableCheckGender = createTableCheck("gender", + createColumnCheck("key", "VARCHAR"), + createColumnCheck("name", "VARCHAR") + ); + + DatabaseTableCheck tableCheckAgeGroups = createTableCheck("AgeGroups", + createColumnCheck("Age", "INTEGER"), + createColumnCheck("H1", "VARCHAR"), + createColumnCheck("H1_Order", "INTEGER"), + createColumnCheck("H2", "VARCHAR"), + createColumnCheck("H2_Order", "INTEGER"), + createColumnCheck("H7", "VARCHAR"), + createColumnCheck("H7_Order", "INTEGER"), + createColumnCheck("H8", "VARCHAR"), + createColumnCheck("H8_Order", "INTEGER"), + createColumnCheck("H9", "VARCHAR"), + createColumnCheck("H9_Order", "INTEGER") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for Bevölkerung Jena mapping"); + databaseSchemaCheck.getTableChecks().add(tableCheckEinwohner); + databaseSchemaCheck.getTableChecks().add(tableCheckYear); + databaseSchemaCheck.getTableChecks().add(tableCheckTown); + databaseSchemaCheck.getTableChecks().add(tableCheckPlraum); + databaseSchemaCheck.getTableChecks().add(tableCheckStatbez); + databaseSchemaCheck.getTableChecks().add(tableCheckGender); + databaseSchemaCheck.getTableChecks().add(tableCheckAgeGroups); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes and dimensions"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckBevoelkerung); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for Bevölkerung Jena mapping example"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Bevölkerung Jena Example Suite"); + suite.setDescription("Check suite for the Bevölkerung Jena (Population) mapping example"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @param hierarchyChecks the hierarchy checks to add to the dimension check + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName, HierarchyCheck... hierarchyChecks) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + if (hierarchyChecks != null) { + for (HierarchyCheck hierarchyCheck : hierarchyChecks) { + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + } + } + return dimensionCheck; + } + + /** + * Creates a HierarchyCheck with the specified name and level checks. + * + * @param hierarchyName the name of the hierarchy + * @param levelChecks the level checks to add to the hierarchy check + * @return the configured HierarchyCheck + */ + private HierarchyCheck createHierarchyCheck(String hierarchyName, LevelCheck... levelChecks) { + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-" + hierarchyName); + hierarchyCheck.setHierarchyName(hierarchyName); + if (levelChecks != null) { + for (LevelCheck levelCheck : levelChecks) { + hierarchyCheck.getLevelChecks().add(levelCheck); + } + } + return hierarchyCheck; + } + + /** + * Creates a LevelCheck with the specified name. + * + * @param levelName the name of the level + * @return the configured LevelCheck + */ + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-" + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/complex/school/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/school/CheckSuiteSupplier.java b/instance/emf/complex/school/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/school/CheckSuiteSupplier.java new file mode 100644 index 00000000..22e7b764 --- /dev/null +++ b/instance/emf/complex/school/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/school/CheckSuiteSupplier.java @@ -0,0 +1,556 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.complex.school; + +import java.util.List; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the complex school mapping example. + * Checks that the catalog with three cubes (Schulen, Personal, SchülerInnen), + * their measures, and dimensions exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Example - Schulwesen"; + + // Cube names + private static final String CUBE_SCHULEN_NAME = "Schulen in Jena (Institutionen)"; + private static final String CUBE_PERSONAL_NAME = "Pädagogisches Personal an Jenaer Schulen"; + private static final String CUBE_SCHUELER_NAME = "Schüler:innen an Jenaer Schulen"; + + // Measure names + private static final String MEASURE_ANZAHL_SCHULEN = "Anzahl Schulen"; + private static final String MEASURE_ANZAHL_KLASSEN = "Anzahl Klassen"; + private static final String MEASURE_ANZAHL_PERSONEN = "Anzahl Personen"; + private static final String MEASURE_ANZAHL_SCHUELER = "Anzahl SchülerInnen"; + + // Dimension names + private static final String DIM_SCHULEN = "Schulen"; + private static final String DIM_SCHULJAHRE = "Schuljahre"; + private static final String DIM_ALTERSGRUPPEN_PERSONAL = "Altersgruppen Personal"; + private static final String DIM_GESCHLECHT = "Geschlecht"; + private static final String DIM_BERUFSGRUPPEN_PERSONAL = "Berufsgruppen Personal"; + private static final String DIM_EINSCHULUNGEN = "Einschulungen"; + private static final String DIM_KLASSENWIEDERHOLUNG = "Klassenwiederholung"; + private static final String DIM_SCHULABSCHLUSS = "Schulabschluss"; + private static final String DIM_MIGRATIONSHINTERGRUND = "Migrationshintergrund"; + private static final String DIM_WOHNLANDKREIS = "Wohnlandkreis"; + private static final String DIM_INKLUSION = "Inklusion"; + + private static final String Q1 = """ + SELECT + foerderung_art.foerderung_art AS Foerderungsart, + schul_jahr.schul_jahr AS Schuljahr, + count(fact_schueler.schule_id) AS Schulen_mit_Foerderbedarf, + sum(fact_schueler.klassen_wdh) AS Betroffene_Klassen + FROM fact_schueler + JOIN foerderung_art ON fact_schueler.foerder_art_id = foerderung_art.id + JOIN sonderpaed_foerderbedarf ON sonderpaed_foerderbedarf.id = foerderung_art.sp_foerderbedarf_id + JOIN schul_jahr ON fact_schueler.schul_jahr_id = schul_jahr.id + WHERE schul_jahr.schul_jahr = '2019/2020' + GROUP BY foerderung_art.foerderung_art, schul_jahr.schul_jahr + ORDER BY sum(fact_schueler.klassen_wdh) DESC + """; + + private static final String Q2 = """ + SELECT bundesland.bezeichnung AS Bundesland_Name, sum(fact_schulen.anzahl_schulen) AS Anzahl_Schulen, sum(fact_schulen.anzahl_klassen) AS Anzahl_Klassen + FROM fact_schulen + JOIN schule ON fact_schulen.schule_id = schule.id + JOIN bundesland JOIN wohnort_landkreis ON wohnort_landkreis.bundesland_id = bundesland.id + GROUP BY bundesland.id, bundesland.bezeichnung + ORDER BY bundesland.bezeichnung + """; + + private static final String Q3 = """ + SELECT schul_jahr.schul_jahr AS Schuljahr, alters_gruppe.altersgruppe AS Altersgruppe, geschlecht.bezeichnung AS Geschlecht, personal_art.bezeichnung AS Personalart, sum(fact_personal.anzahl_personen) AS Anzahl_Personen + FROM fact_personal + JOIN schul_jahr ON fact_personal.schul_jahr_id = schul_jahr.id + JOIN alters_gruppe ON fact_personal.alters_gruppe_id = alters_gruppe.id JOIN geschlecht ON fact_personal.geschlecht_id = geschlecht.id + JOIN personal_art ON fact_personal.personal_art_id = personal_art.id + WHERE schul_jahr.schul_jahr = '2018/2019' + GROUP BY schul_jahr.schul_jahr, alters_gruppe.altersgruppe, geschlecht.bezeichnung, personal_art.bezeichnung + ORDER BY alters_gruppe.altersgruppe, geschlecht.bezeichnung + """; + + private static final String Q4 = """ + SELECT + traeger_art.traeger_art AS Traegerart, + count(fact_schulen.schule_id) AS Anzahl_Schulen, + sum(fact_schulen.anzahl_klassen) AS Gesamt_Klassen + FROM fact_schulen + JOIN schule ON fact_schulen.schule_id = schule.id + JOIN traeger ON schule.traeger_id = traeger.id + JOIN traeger_art ON traeger.traeger_art_id = traeger_art.id + JOIN traeger_kategorie ON traeger_art.traeger_kat_id = traeger_kategorie.id + JOIN schul_jahr ON fact_schulen.schul_jahr_id = schul_jahr.id + WHERE schul_jahr.schul_jahr = '2018/2019' + GROUP BY traeger_art.traeger_art + ORDER BY count(DISTINCT fact_schulen.schule_id) DESC + """; + + @Override + public OlapCheckSuite get() { + // Create dimension checks for shared dimensions + DimensionCheck dimCheckSchulen = createDimensionCheck(DIM_SCHULEN, + createHierarchyCheck("Schulen nach Ganztagsangebot", + createLevelCheck("Art des Ganztagsangebots"), + createLevelCheck("Schule")), + createHierarchyCheck("Schulen nach Trägerschaft", + createLevelCheck("Schulträger-Kategorie"), + createLevelCheck("Schulträger-Art"), + createLevelCheck("Schulträger"), + createLevelCheck("Schule")), + createHierarchyCheck("Schulen nach Art", + createLevelCheck("Schulkategorie"), + createLevelCheck("Schulart"), + createLevelCheck("Schule"))); + DimensionCheck dimCheckSchuljahre = createDimensionCheck(DIM_SCHULJAHRE, + createHierarchyCheck("Schuljahre", + createLevelCheck("Schuljahr"))); + DimensionCheck dimCheckGeschlecht = createDimensionCheck(DIM_GESCHLECHT, + createHierarchyCheck("Geschlecht", + createLevelCheck("Geschlecht"))); + DimensionCheck dimCheckAltersgruppenPersonal = createDimensionCheck(DIM_ALTERSGRUPPEN_PERSONAL, + createHierarchyCheck("Altersgruppen", + createLevelCheck("Altersgruppe"))); + DimensionCheck dimCheckBerufsgruppenPersonal = createDimensionCheck(DIM_BERUFSGRUPPEN_PERSONAL, + createHierarchyCheck("Berufsgruppen", + createLevelCheck("Berufsgruppe"))); + DimensionCheck dimCheckEinschulungen = createDimensionCheck(DIM_EINSCHULUNGEN, + createHierarchyCheck("Einschulung", + createLevelCheck("Einschulung"))); + DimensionCheck dimCheckKlassenwiederholung = createDimensionCheck(DIM_KLASSENWIEDERHOLUNG, + createHierarchyCheck("Klassenwiederholung", + createLevelCheck("Klassenwiederholung"))); + DimensionCheck dimCheckSchulabschluss = createDimensionCheck(DIM_SCHULABSCHLUSS, + createHierarchyCheck("Schulabschlüsse", + createLevelCheck("Schulabschlüsse"))); + DimensionCheck dimCheckMigrationshintergrund = createDimensionCheck(DIM_MIGRATIONSHINTERGRUND, + createHierarchyCheck("Migrationshintergrund", + createLevelCheck("Migrationshintergrund"))); + DimensionCheck dimCheckWohnlandkreis = createDimensionCheck(DIM_WOHNLANDKREIS, + createHierarchyCheck("Wohnlandkreis", + createLevelCheck("Bundesland"), + createLevelCheck("Wohnlandkreis"))); + DimensionCheck dimCheckInklusion = createDimensionCheck(DIM_INKLUSION, + createHierarchyCheck("Sonderpädagogische Förderung", + createLevelCheck("Förderbedarf"), + createLevelCheck("Art der Förderung"))); + + // Create cube 1: Schulen in Jena (Institutionen) + MeasureCheck measureCheckAnzahlSchulen = createMeasureCheck(MEASURE_ANZAHL_SCHULEN); + MeasureCheck measureCheckAnzahlKlassen = createMeasureCheck(MEASURE_ANZAHL_KLASSEN); + + CubeCheck cubeCheckSchulen = factory.createCubeCheck(); + cubeCheckSchulen.setName("CubeCheck-" + CUBE_SCHULEN_NAME); + cubeCheckSchulen.setDescription("Check that cube '" + CUBE_SCHULEN_NAME + "' exists"); + cubeCheckSchulen.setCubeName(CUBE_SCHULEN_NAME); + cubeCheckSchulen.getMeasureChecks().add(measureCheckAnzahlSchulen); + cubeCheckSchulen.getMeasureChecks().add(measureCheckAnzahlKlassen); + cubeCheckSchulen.getDimensionChecks().add(dimCheckSchulen); + cubeCheckSchulen.getDimensionChecks().add(dimCheckSchuljahre); + + // Create cube 2: Pädagogisches Personal an Jenaer Schulen + MeasureCheck measureCheckAnzahlPersonen = createMeasureCheck(MEASURE_ANZAHL_PERSONEN); + + CubeCheck cubeCheckPersonal = factory.createCubeCheck(); + cubeCheckPersonal.setName("CubeCheck-" + CUBE_PERSONAL_NAME); + cubeCheckPersonal.setDescription("Check that cube '" + CUBE_PERSONAL_NAME + "' exists"); + cubeCheckPersonal.setCubeName(CUBE_PERSONAL_NAME); + cubeCheckPersonal.getMeasureChecks().add(measureCheckAnzahlPersonen); + cubeCheckPersonal.getDimensionChecks().add(dimCheckSchulen); + cubeCheckPersonal.getDimensionChecks().add(dimCheckSchuljahre); + cubeCheckPersonal.getDimensionChecks().add(dimCheckAltersgruppenPersonal); + cubeCheckPersonal.getDimensionChecks().add(dimCheckGeschlecht); + cubeCheckPersonal.getDimensionChecks().add(dimCheckBerufsgruppenPersonal); + + // Create cube 3: Schüler:innen an Jenaer Schulen + MeasureCheck measureCheckAnzahlSchueler = createMeasureCheck(MEASURE_ANZAHL_SCHUELER); + + CubeCheck cubeCheckSchueler = factory.createCubeCheck(); + cubeCheckSchueler.setName("CubeCheck-" + CUBE_SCHUELER_NAME); + cubeCheckSchueler.setDescription("Check that cube '" + CUBE_SCHUELER_NAME + "' exists"); + cubeCheckSchueler.setCubeName(CUBE_SCHUELER_NAME); + cubeCheckSchueler.getMeasureChecks().add(measureCheckAnzahlSchueler); + cubeCheckSchueler.getDimensionChecks().add(dimCheckSchulen); + cubeCheckSchueler.getDimensionChecks().add(dimCheckSchuljahre); + cubeCheckSchueler.getDimensionChecks().add(dimCheckGeschlecht); + cubeCheckSchueler.getDimensionChecks().add(dimCheckEinschulungen); + cubeCheckSchueler.getDimensionChecks().add(dimCheckKlassenwiederholung); + cubeCheckSchueler.getDimensionChecks().add(dimCheckSchulabschluss); + cubeCheckSchueler.getDimensionChecks().add(dimCheckMigrationshintergrund); + cubeCheckSchueler.getDimensionChecks().add(dimCheckWohnlandkreis); + cubeCheckSchueler.getDimensionChecks().add(dimCheckInklusion); + + CellValueCheck cellCheck100 = factory.createCellValueCheck(); + cellCheck100.setName("FOERDERUNGSART"); + cellCheck100.setExpectedValue("Gemeinsamer Unterricht"); + cellCheck100.getCoordinates().add(0); + cellCheck100.getCoordinates().add(0); + + CellValueCheck cellCheck101 = factory.createCellValueCheck(); + cellCheck101.setName("SCHULJAHR"); + cellCheck101.setExpectedValue("2019//2020"); + cellCheck101.getCoordinates().add(0); + cellCheck101.getCoordinates().add(1); + + CellValueCheck cellCheck102 = factory.createCellValueCheck(); + cellCheck102.setName("SCHULEN_MIT_FOERDERBEDARF"); + cellCheck102.setExpectedValue("13152"); + cellCheck102.getCoordinates().add(0); + cellCheck102.getCoordinates().add(2); + + CellValueCheck cellCheck103 = factory.createCellValueCheck(); + cellCheck103.setName("BETROFFENE_KLASSEN"); + cellCheck103.setExpectedValue("6576"); + cellCheck103.getCoordinates().add(0); + cellCheck103.getCoordinates().add(2); + + QueryCheck sqlQueryCheck1 = factory.createQueryCheck(); + sqlQueryCheck1.setName("Sql Query Check1 for " + CATALOG_NAME); + sqlQueryCheck1.setQuery(Q1); + sqlQueryCheck1.setQueryLanguage(QueryLanguage.SQL); + sqlQueryCheck1.getCellChecks().add(cellCheck100); + sqlQueryCheck1.getCellChecks().add(cellCheck101); + sqlQueryCheck1.getCellChecks().add(cellCheck102); + sqlQueryCheck1.getCellChecks().add(cellCheck103); + + CellValueCheck cellCheck200 = factory.createCellValueCheck(); + cellCheck200.setName("BUNDESLAND_NAME"); + cellCheck200.setExpectedValue("Außerhalb Thüringens"); + cellCheck200.getCoordinates().addAll(List.of(0,0)); + + CellValueCheck cellCheck201 = factory.createCellValueCheck(); + cellCheck201.setName("ANZAHL_SCHULEN"); + cellCheck201.setExpectedValue("189"); + cellCheck201.getCoordinates().addAll(List.of(0,1)); + + CellValueCheck cellCheck202 = factory.createCellValueCheck(); + cellCheck202.setName("ANZAHL_KLASSEN"); + cellCheck202.setExpectedValue("3710"); + cellCheck202.getCoordinates().addAll(List.of(0,2)); + + QueryCheck sqlQueryCheck2 = factory.createQueryCheck(); + sqlQueryCheck2.setName("Sql Query Check2 for " + CATALOG_NAME); + sqlQueryCheck2.setQuery(Q2); + sqlQueryCheck2.setQueryLanguage(QueryLanguage.SQL); + sqlQueryCheck2.getCellChecks().addAll(List.of(cellCheck200, cellCheck201, cellCheck202)); + + CellValueCheck cellCheck300 = factory.createCellValueCheck(); + cellCheck300.setName("SCHULJAHR"); + cellCheck300.setExpectedValue("2018/2019"); + cellCheck300.getCoordinates().addAll(List.of(0,0)); + + CellValueCheck cellCheck301 = factory.createCellValueCheck(); + cellCheck301.setName("ALTERSGRUPPE"); + cellCheck301.setExpectedValue("30 bis unter 45 Jahre"); + cellCheck301.getCoordinates().addAll(List.of(0,1)); + + CellValueCheck cellCheck302 = factory.createCellValueCheck(); + cellCheck302.setName("GESCHLECHT"); + cellCheck302.setExpectedValue("männlich"); + cellCheck302.getCoordinates().addAll(List.of(0,2)); + + CellValueCheck cellCheck303 = factory.createCellValueCheck(); + cellCheck303.setName("PERSONALART"); + cellCheck303.setExpectedValue("Erzieher:in"); + cellCheck303.getCoordinates().addAll(List.of(0,3)); + + CellValueCheck cellCheck304 = factory.createCellValueCheck(); + cellCheck304.setName("ANZAHL_PERSONEN"); + cellCheck304.setExpectedValue("12"); + cellCheck304.getCoordinates().addAll(List.of(0,4)); + + QueryCheck sqlQueryCheck3 = factory.createQueryCheck(); + sqlQueryCheck3.setName("Sql Query Check2 for " + CATALOG_NAME); + sqlQueryCheck3.setQuery(Q3); + sqlQueryCheck3.setQueryLanguage(QueryLanguage.SQL); + sqlQueryCheck3.getCellChecks().addAll(List.of(cellCheck300, cellCheck301, cellCheck302, cellCheck303, cellCheck304)); + + CellValueCheck cellCheck400 = factory.createCellValueCheck(); + cellCheck400.setName("TRAEGERART"); + cellCheck400.setExpectedValue("kommunaler Träger"); + cellCheck400.getCoordinates().addAll(List.of(0,0)); + + CellValueCheck cellCheck401 = factory.createCellValueCheck(); + cellCheck401.setName("ANZAHL_SCHULEN"); + cellCheck401.setExpectedValue("27"); + cellCheck401.getCoordinates().addAll(List.of(0,1)); + + CellValueCheck cellCheck402 = factory.createCellValueCheck(); + cellCheck402.setName("GESAMT_KLASSEN"); + cellCheck402.setExpectedValue("602"); + cellCheck402.getCoordinates().addAll(List.of(0,2)); + + QueryCheck sqlQueryCheck4 = factory.createQueryCheck(); + sqlQueryCheck4.setName("Sql Query Check2 for " + CATALOG_NAME); + sqlQueryCheck4.setQuery(Q4); + sqlQueryCheck4.setQueryLanguage(QueryLanguage.SQL); + sqlQueryCheck4.getCellChecks().addAll(List.of(cellCheck400, cellCheck401, cellCheck402)); + + // Create database table and column checks + DatabaseTableCheck tableCheckFactSchueler = createTableCheck("fact_schueler", + createColumnCheck("schule_id", "INTEGER"), + createColumnCheck("klassen_wdh", "INTEGER"), + createColumnCheck("foerder_art_id", "INTEGER"), + createColumnCheck("schul_jahr_id", "INTEGER") + ); + + DatabaseTableCheck tableCheckFactSchulen = createTableCheck("fact_schulen", + createColumnCheck("schule_id", "INTEGER"), + createColumnCheck("anzahl_schulen", "INTEGER"), + createColumnCheck("anzahl_klassen", "INTEGER"), + createColumnCheck("schul_jahr_id", "INTEGER") + ); + + DatabaseTableCheck tableCheckFactPersonal = createTableCheck("fact_personal", + createColumnCheck("schul_jahr_id", "INTEGER"), + createColumnCheck("alters_gruppe_id", "INTEGER"), + createColumnCheck("geschlecht_id", "INTEGER"), + createColumnCheck("personal_art_id", "INTEGER"), + createColumnCheck("anzahl_personen", "INTEGER") + ); + + DatabaseTableCheck tableCheckSchule = createTableCheck("schule", + createColumnCheck("id", "INTEGER"), + createColumnCheck("traeger_id", "INTEGER") + ); + + DatabaseTableCheck tableCheckSchulJahr = createTableCheck("schul_jahr", + createColumnCheck("id", "INTEGER"), + createColumnCheck("schul_jahr", "VARCHAR") + ); + + DatabaseTableCheck tableCheckFoerderungArt = createTableCheck("foerderung_art", + createColumnCheck("id", "INTEGER"), + createColumnCheck("foerderung_art", "VARCHAR"), + createColumnCheck("sp_foerderbedarf_id", "INTEGER") + ); + + DatabaseTableCheck tableCheckSonderpaedFoerderbedarf = createTableCheck("sonderpaed_foerderbedarf", + createColumnCheck("id", "INTEGER") + ); + + DatabaseTableCheck tableCheckBundesland = createTableCheck("bundesland", + createColumnCheck("id", "INTEGER"), + createColumnCheck("bezeichnung", "VARCHAR") + ); + + DatabaseTableCheck tableCheckWohnortLandkreis = createTableCheck("wohnort_landkreis", + createColumnCheck("bundesland_id", "INTEGER") + ); + + DatabaseTableCheck tableCheckAltersGruppe = createTableCheck("alters_gruppe", + createColumnCheck("id", "INTEGER"), + createColumnCheck("altersgruppe", "VARCHAR") + ); + + DatabaseTableCheck tableCheckGeschlecht = createTableCheck("geschlecht", + createColumnCheck("id", "INTEGER"), + createColumnCheck("bezeichnung", "VARCHAR") + ); + + DatabaseTableCheck tableCheckPersonalArt = createTableCheck("personal_art", + createColumnCheck("id", "INTEGER"), + createColumnCheck("bezeichnung", "VARCHAR") + ); + + DatabaseTableCheck tableCheckTraeger = createTableCheck("traeger", + createColumnCheck("id", "INTEGER"), + createColumnCheck("traeger_art_id", "INTEGER") + ); + + DatabaseTableCheck tableCheckTraegerArt = createTableCheck("traeger_art", + createColumnCheck("id", "INTEGER"), + createColumnCheck("traeger_art", "VARCHAR"), + createColumnCheck("traeger_kat_id", "INTEGER") + ); + + DatabaseTableCheck tableCheckTraegerKategorie = createTableCheck("traeger_kategorie", + createColumnCheck("id", "INTEGER") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for complex school mapping"); + databaseSchemaCheck.getTableChecks().add(tableCheckFactSchueler); + databaseSchemaCheck.getTableChecks().add(tableCheckFactSchulen); + databaseSchemaCheck.getTableChecks().add(tableCheckFactPersonal); + databaseSchemaCheck.getTableChecks().add(tableCheckSchule); + databaseSchemaCheck.getTableChecks().add(tableCheckSchulJahr); + databaseSchemaCheck.getTableChecks().add(tableCheckFoerderungArt); + databaseSchemaCheck.getTableChecks().add(tableCheckSonderpaedFoerderbedarf); + databaseSchemaCheck.getTableChecks().add(tableCheckBundesland); + databaseSchemaCheck.getTableChecks().add(tableCheckWohnortLandkreis); + databaseSchemaCheck.getTableChecks().add(tableCheckAltersGruppe); + databaseSchemaCheck.getTableChecks().add(tableCheckGeschlecht); + databaseSchemaCheck.getTableChecks().add(tableCheckPersonalArt); + databaseSchemaCheck.getTableChecks().add(tableCheckTraeger); + databaseSchemaCheck.getTableChecks().add(tableCheckTraegerArt); + databaseSchemaCheck.getTableChecks().add(tableCheckTraegerKategorie); + + // Create catalog check with all cube checks + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes and dimensions"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckSchulen); + catalogCheck.getCubeChecks().add(cubeCheckPersonal); + catalogCheck.getCubeChecks().add(cubeCheckSchueler); + catalogCheck.getQueryChecks().add(sqlQueryCheck1); + catalogCheck.getQueryChecks().add(sqlQueryCheck2); + catalogCheck.getQueryChecks().add(sqlQueryCheck3); + catalogCheck.getQueryChecks().add(sqlQueryCheck4); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for complex school mapping example"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("School Example Suite"); + suite.setDescription("Check suite for the complex school mapping example"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @param hierarchyChecks the hierarchy checks to add to the dimension check + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName, HierarchyCheck... hierarchyChecks) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + if (hierarchyChecks != null) { + for (HierarchyCheck hierarchyCheck : hierarchyChecks) { + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + } + } + return dimensionCheck; + } + + /** + * Creates a HierarchyCheck with the specified name and level checks. + * + * @param hierarchyName the name of the hierarchy + * @param levelChecks the level checks to add to the hierarchy check + * @return the configured HierarchyCheck + */ + private HierarchyCheck createHierarchyCheck(String hierarchyName, LevelCheck... levelChecks) { + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-" + hierarchyName); + hierarchyCheck.setHierarchyName(hierarchyName); + if (levelChecks != null) { + for (LevelCheck levelCheck : levelChecks) { + hierarchyCheck.getLevelChecks().add(levelCheck); + } + } + return hierarchyCheck; + } + + /** + * Creates a LevelCheck with the specified name. + * + * @param levelName the name of the level + * @return the configured LevelCheck + */ + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-" + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/complex/steelwheels/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/steelwheels/CheckSuiteSupplier.java b/instance/emf/complex/steelwheels/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/steelwheels/CheckSuiteSupplier.java new file mode 100644 index 00000000..728231fa --- /dev/null +++ b/instance/emf/complex/steelwheels/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/complex/steelwheels/CheckSuiteSupplier.java @@ -0,0 +1,278 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.complex.steelwheels; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the SteelWheels complex mapping example. + * Checks that the catalog with SteelWheelsSales cube and its associated dimensions and measures exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "SteelWheels"; + + // Cube name + private static final String CUBE_STEELWHEELSSALES = "SteelWheelsSales"; + + // Measure names + private static final String MEASURE_QUANTITY = "Quantity"; + private static final String MEASURE_SALES = "Sales"; + + // Dimension names + private static final String DIM_MARKETS = "Markets"; + private static final String DIM_CUSTOMERS = "Customers"; + private static final String DIM_PRODUCT = "Product"; + private static final String DIM_TIME = "Time"; + private static final String DIM_ORDERSTATUS = "Order Status"; + + @Override + public OlapCheckSuite get() { + // Create dimension checks + DimensionCheck dimCheckMarkets = createDimensionCheck(DIM_MARKETS, + createHierarchyCheck("Markets", + createLevelCheck("Territory"), + createLevelCheck("Country"), + createLevelCheck("State Province"), + createLevelCheck("City"))); + DimensionCheck dimCheckCustomers = createDimensionCheck(DIM_CUSTOMERS, + createHierarchyCheck("Customers", + createLevelCheck("Customer"))); + DimensionCheck dimCheckProduct = createDimensionCheck(DIM_PRODUCT, + createHierarchyCheck("Product", + createLevelCheck("Line"), + createLevelCheck("Vendor"), + createLevelCheck("Product"))); + DimensionCheck dimCheckTime = createDimensionCheck(DIM_TIME, + createHierarchyCheck("Time", + createLevelCheck("Years"), + createLevelCheck("Quarters"), + createLevelCheck("Months"))); + DimensionCheck dimCheckOrderStatus = createDimensionCheck(DIM_ORDERSTATUS, + createHierarchyCheck("Order Status", + createLevelCheck("Type"))); + + // Create measure checks + MeasureCheck measureCheckQuantity = createMeasureCheck(MEASURE_QUANTITY); + MeasureCheck measureCheckSales = createMeasureCheck(MEASURE_SALES); + + // Create cube check for SteelWheelsSales + CubeCheck cubeCheckSteelWheelsSales = factory.createCubeCheck(); + cubeCheckSteelWheelsSales.setName("CubeCheck-" + CUBE_STEELWHEELSSALES); + cubeCheckSteelWheelsSales.setDescription("Check that cube '" + CUBE_STEELWHEELSSALES + "' exists"); + cubeCheckSteelWheelsSales.setCubeName(CUBE_STEELWHEELSSALES); + cubeCheckSteelWheelsSales.getMeasureChecks().add(measureCheckQuantity); + cubeCheckSteelWheelsSales.getMeasureChecks().add(measureCheckSales); + cubeCheckSteelWheelsSales.getDimensionChecks().add(dimCheckMarkets); + cubeCheckSteelWheelsSales.getDimensionChecks().add(dimCheckCustomers); + cubeCheckSteelWheelsSales.getDimensionChecks().add(dimCheckProduct); + cubeCheckSteelWheelsSales.getDimensionChecks().add(dimCheckTime); + cubeCheckSteelWheelsSales.getDimensionChecks().add(dimCheckOrderStatus); + + // Create database table and column checks + DatabaseTableCheck tableCheckOrderFact = createTableCheck("orderfact", + createColumnCheck("CUSTOMERNUMBER", "INTEGER"), + createColumnCheck("PRODUCTCODE", "VARCHAR"), + createColumnCheck("TIME_ID", "VARCHAR"), + createColumnCheck("QUANTITYORDERED", "INTEGER"), + createColumnCheck("TOTALPRICE", "NUMERIC"), + createColumnCheck("STATUS", "VARCHAR"), + createColumnCheck("ORDERDATE", "TIMESTAMP"), + createColumnCheck("PRICEEACH", "NUMERIC"), + createColumnCheck("REQUIREDDATE", "TIMESTAMP"), + createColumnCheck("SHIPPEDDATE", "TIMESTAMP") + ); + + DatabaseTableCheck tableCheckCustomer = createTableCheck("customer_w_ter", + createColumnCheck("CUSTOMERNUMBER", "INTEGER"), + createColumnCheck("CUSTOMERNAME", "VARCHAR"), + createColumnCheck("TERRITORY", "VARCHAR"), + createColumnCheck("COUNTRY", "VARCHAR"), + createColumnCheck("STATE", "VARCHAR"), + createColumnCheck("CITY", "VARCHAR"), + createColumnCheck("CONTACTFIRSTNAME", "VARCHAR"), + createColumnCheck("CONTACTLASTNAME", "VARCHAR"), + createColumnCheck("PHONE", "VARCHAR"), + createColumnCheck("ADDRESSLINE1", "VARCHAR"), + createColumnCheck("CREDITLIMIT", "NUMERIC") + ); + + DatabaseTableCheck tableCheckProducts = createTableCheck("products", + createColumnCheck("PRODUCTCODE", "VARCHAR"), + createColumnCheck("PRODUCTNAME", "VARCHAR"), + createColumnCheck("PRODUCTLINE", "VARCHAR"), + createColumnCheck("PRODUCTVENDOR", "VARCHAR"), + createColumnCheck("PRODUCTDESCRIPTION", "VARCHAR") + ); + + DatabaseTableCheck tableCheckTime = createTableCheck("time", + createColumnCheck("TIME_ID", "VARCHAR"), + createColumnCheck("YEAR_ID", "INTEGER"), + createColumnCheck("QTR_NAME", "VARCHAR"), + createColumnCheck("QTR_ID", "INTEGER"), + createColumnCheck("MONTH_NAME", "VARCHAR"), + createColumnCheck("MONTH_ID", "INTEGER") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for SteelWheels mapping"); + databaseSchemaCheck.getTableChecks().add(tableCheckOrderFact); + databaseSchemaCheck.getTableChecks().add(tableCheckCustomer); + databaseSchemaCheck.getTableChecks().add(tableCheckProducts); + databaseSchemaCheck.getTableChecks().add(tableCheckTime); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes and dimensions"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckSteelWheelsSales); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for SteelWheels mapping example"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("SteelWheels Example Suite"); + suite.setDescription("Check suite for the SteelWheels mapping example"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @param hierarchyChecks the hierarchy checks to add to the dimension check + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName, HierarchyCheck... hierarchyChecks) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + if (hierarchyChecks != null) { + for (HierarchyCheck hierarchyCheck : hierarchyChecks) { + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + } + } + return dimensionCheck; + } + + /** + * Creates a HierarchyCheck with the specified name and level checks. + * + * @param hierarchyName the name of the hierarchy + * @param levelChecks the level checks to add to the hierarchy check + * @return the configured HierarchyCheck + */ + private HierarchyCheck createHierarchyCheck(String hierarchyName, LevelCheck... levelChecks) { + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-" + hierarchyName); + hierarchyCheck.setHierarchyName(hierarchyName); + if (levelChecks != null) { + for (LevelCheck levelCheck : levelChecks) { + hierarchyCheck.getLevelChecks().add(levelCheck); + } + } + return hierarchyCheck; + } + + /** + * Creates a LevelCheck with the specified name. + * + * @param levelName the name of the level + * @return the configured LevelCheck + */ + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-" + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/serializer/src/test/java/org/eclipse/daanse/rolap/mapping/instance/emf/serializer/integration/ResourceSetWriteReadTest.java b/instance/emf/serializer/src/test/java/org/eclipse/daanse/rolap/mapping/instance/emf/serializer/integration/ResourceSetWriteReadTest.java index 6a3cd27e..4b9e4b28 100644 --- a/instance/emf/serializer/src/test/java/org/eclipse/daanse/rolap/mapping/instance/emf/serializer/integration/ResourceSetWriteReadTest.java +++ b/instance/emf/serializer/src/test/java/org/eclipse/daanse/rolap/mapping/instance/emf/serializer/integration/ResourceSetWriteReadTest.java @@ -38,6 +38,9 @@ import java.util.zip.ZipOutputStream; import org.eclipse.daanse.rolap.mapping.model.provider.CatalogMappingSupplier; +import org.eclipse.daanse.olap.check.model.check.OlapCheckPackage; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; import org.eclipse.daanse.rolap.mapping.model.AbstractElement; import org.eclipse.daanse.rolap.mapping.model.Catalog; import org.eclipse.daanse.rolap.mapping.model.Documentation; @@ -114,18 +117,21 @@ public static void beforeAll() throws IOException { public void writePopulation(@InjectBundleContext BundleContext bc, @InjectService(cardinality = 1, filter = "(" + EMFNamespaces.EMF_MODEL_NAME + "=" + RolapMappingPackage.eNAME + ")") ResourceSet resourceSet, - @InjectService ServiceAware mappingSuppiersSA) + @InjectService ServiceAware mappingSuppiersSA, + @InjectService ServiceAware checkSuiteSuppliersSA) throws SQLException, InterruptedException, IOException { try { List> srs = mappingSuppiersSA.getServiceReferences(); + List> chrs = checkSuiteSuppliersSA.getServiceReferences(); StringBuilder parentReadme = new StringBuilder(); parentReadme.append(TEXT); // Create combined ZIP directory structure Path zipDir = Files.createDirectories(tempDir.resolve("cubeserver/tutorial/zip")); ZipOutputStream combinedZos = new ZipOutputStream(new FileOutputStream(zipDir.resolve("all-tutorials.zip").toFile())); + ZipOutputStream combinedCheckSuiteZos = new ZipOutputStream(new FileOutputStream(zipDir.resolve("all-check-suites.zip").toFile())); srs.sort((o1, o2) -> { Object s1 = o1.getProperty("number"); @@ -148,6 +154,17 @@ public void writePopulation(@InjectBundleContext BundleContext bc, } } + for (ServiceReference chs : chrs) { + + try { + OlapCheckSuiteSupplier catalogMappingSupplier = checkSuiteSuppliersSA.getService(chs); + + serializeCheckSuite(resourceSet, catalogMappingSupplier, combinedCheckSuiteZos); + } catch (Exception e) { + e.printStackTrace(); + } + } + // Close combined ZIP combinedZos.close(); @@ -161,6 +178,54 @@ public void writePopulation(@InjectBundleContext BundleContext bc, Map map = new HashMap(); + private void serializeCheckSuite(ResourceSet resourceSet, + OlapCheckSuiteSupplier checkSuiteSupplier, ZipOutputStream combinedZos) throws IOException { + + String name = checkSuiteSupplier.getClass().getPackageName(); + name = name.substring(46); + + Path zipDir = Files.createDirectories(tempDir.resolve("cubeserver/checkSuite/zip")); + ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipDir.resolve(name + ".zip").toFile())); + + OlapCheckSuite chs = checkSuiteSupplier.get(); + + URI uriCatalog = URI.createFileURI("catalog.xmi"); + Resource resourceCatalog = resourceSet.createResource(uriCatalog); + + Set set = new HashSet<>(); + + set = allRef(set, chs); + + // sort + + List sortedList = set.stream().sorted(checkSuiteComparator).toList(); + + + for (EObject eObject : sortedList) { + if (eObject.eContainer() == null) { + resourceCatalog.getContents().add(eObject); + } + } + Map options = new HashMap<>(); + options.put(XMLResource.OPTION_ENCODING, "UTF-8"); + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + resourceCatalog.save(baos, options); + + ZipEntry entry = new ZipEntry(name + "/checkSuite.xmi"); + zos.putNextEntry(entry); + zos.write(baos.toByteArray()); + zos.closeEntry(); + + ZipEntry combinedEntry = new ZipEntry(name + "/checkSuite.xmi"); + combinedZos.putNextEntry(combinedEntry); + combinedZos.write(baos.toByteArray()); + combinedZos.closeEntry(); + + Files.createDirectories(zipDir); + zos.close(); + } + + private void serializeCatalog(ResourceSet resourceSet, StringBuilder parentReadme, CatalogMappingSupplier catalogMappingSupplier, Dictionary dictionary, ZipOutputStream combinedZos) throws IOException { @@ -628,6 +693,75 @@ public int compare(EObject o1, EObject o2) { } }; + static CheckSuiteEObjectComparator checkSuiteComparator = new CheckSuiteEObjectComparator(); + + static class CheckSuiteEObjectComparator implements Comparator { + + AtomicInteger COUNTER = new AtomicInteger(1); + Map map = new HashMap(); + + CheckSuiteEObjectComparator() { + add(OlapCheckPackage.Literals.CATALOG_CHECK); + add(OlapCheckPackage.Literals.CATALOG_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.DATABASE_SCHEMA_CHECK); + add(OlapCheckPackage.Literals.DATABASE_SCHEMA_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.DATABASE_TABLE_CHECK); + add(OlapCheckPackage.Literals.DATABASE_TABLE_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.DATABASE_COLUMN_CHECK); + add(OlapCheckPackage.Literals.DATABASE_COLUMN_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.CUBE_CHECK); + add(OlapCheckPackage.Literals.CUBE_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.DIMENSION_CHECK); + add(OlapCheckPackage.Literals.DIMENSION_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.HIERARCHY_CHECK); + add(OlapCheckPackage.Literals.HIERARCHY_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.LEVEL_CHECK); + add(OlapCheckPackage.Literals.LEVEL_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.MEASURE_CHECK); + add(OlapCheckPackage.Literals.MEASURE_ATTRIBUTE_CHECK); + add(OlapCheckPackage.Literals.QUERY_CHECK); + add(OlapCheckPackage.Literals.QUERY_CHECK_RESULT); + //TODO + } + + void add(EClass eClass) { + map.put(eClass, COUNTER.incrementAndGet()); + } + + @Override + public int compare(EObject o1, EObject o2) { + + EClass eClass1 = o1.eClass(); + EClass eClass2 = o2.eClass(); + int value = map.getOrDefault(eClass1, 0) - map.getOrDefault(eClass2, 0); + + if (value != 0) { + return value; + } + + Object s1 = ""; + Object s2 = ""; + EStructuralFeature eStructuralFeature1 = eClass1.getEStructuralFeature("id"); + if (eStructuralFeature1 != null) { + + s1 = o1.eGet(eStructuralFeature1); + } + EStructuralFeature eStructuralFeature2 = eClass2.getEStructuralFeature("id"); + if (eStructuralFeature2 != null) { + + s2 = o2.eGet(eStructuralFeature2); + } + if (s1 == null) { + s1 = ""; + } + if (s2 == null) { + s2 = ""; + } + + return s1.toString().compareToIgnoreCase(s2.toString()); + } + }; + public static void deleteDirectory(Path directory) throws IOException { if (!Files.exists(directory)) { return; diff --git a/instance/emf/tutorial/access/cataloggrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/cataloggrand/CheckSuiteSupplier.java b/instance/emf/tutorial/access/cataloggrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/cataloggrand/CheckSuiteSupplier.java new file mode 100644 index 00000000..62777b91 --- /dev/null +++ b/instance/emf/tutorial/access/cataloggrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/cataloggrand/CheckSuiteSupplier.java @@ -0,0 +1,243 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.cataloggrand; +import java.util.List; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionAttribute; +import org.eclipse.daanse.olap.check.model.check.DimensionAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Catalog Check"); + catalogCheck.setDescription("Demonstrates access control with catalog grants and roles"); + catalogCheck.setCatalogName("Daanse Tutorial - Access Catalog Gran"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + + // Add query checks at catalog level + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRoleAll(), + createQueryCheckForRoleAllDimWithCubeGrand(), + createQueryCheckForRoleNone() + )); + + ConnectionConfig roleAllConnectionConfig = FACTORY.createConnectionConfig(); + roleAllConnectionConfig.setCatalogName("Daanse Tutorial - Access Catalog Gran"); + roleAllConnectionConfig.getRoles().add("roleAll"); + + ConnectionConfig roleAllDimWithCubeGrandConnectionConfig = FACTORY.createConnectionConfig(); + roleAllDimWithCubeGrandConnectionConfig.setCatalogName("Daanse Tutorial - Access Catalog Gran"); + roleAllDimWithCubeGrandConnectionConfig.getRoles().add("roleAllDimWithCubeGrand"); + + ConnectionConfig roleNoneConnectionConfig = FACTORY.createConnectionConfig(); + roleNoneConnectionConfig.setCatalogName("Daanse Tutorial - Access Catalog Gran"); + roleNoneConnectionConfig.getRoles().add("roleNone"); + + OlapConnectionCheck connectionCheckRoleAll = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleAll.setName("Connection Check Catalog Gran with roleAll"); + connectionCheckRoleAll.setDescription("Connection check for Catalog Gran tutorial with roleAll"); + connectionCheckRoleAll.setConnectionConfig(roleNoneConnectionConfig); + connectionCheckRoleAll.getCatalogChecks().add(catalogCheck); + + OlapConnectionCheck connectionCheckRoleAllDimWithCubeGrand = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleAllDimWithCubeGrand.setName("Connection Check Catalog Gran with RoleAllDimWithCubeGrand"); + connectionCheckRoleAllDimWithCubeGrand.setDescription("Connection check for Catalog Gran tutorial with roleAllDimWithCubeGrand"); + connectionCheckRoleAllDimWithCubeGrand.setConnectionConfig(roleAllDimWithCubeGrandConnectionConfig); + connectionCheckRoleAllDimWithCubeGrand.getCatalogChecks().add(catalogCheck); + + OlapConnectionCheck connectionCheckRoleNone = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleNone.setName("Catalog Gran Check"); + connectionCheckRoleNone.setDescription("Connection check for Catalog Gran tutorial with roleNone"); + connectionCheckRoleNone.setConnectionConfig(roleNoneConnectionConfig); + connectionCheckRoleNone.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Access Catalog Gran Suite"); + suite.setDescription("Check suite for Access Catalog Gran catalog"); + suite.getConnectionChecks().addAll(List.of(connectionCheckRoleAll, connectionCheckRoleAllDimWithCubeGrand, connectionCheckRoleNone)); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access Catalog Grand Database Schema Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access Catalog Grand"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Access Catalog Grant Cube Check"); + cubeCheck.setDescription("Verify Access Catalog Gran cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add dimension checks + cubeCheck.getDimensionChecks().add(createDimensionCheck("Dimension1", null)); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + private DimensionCheck createDimensionCheck(String dimensionName, String description) { + DimensionCheck dimCheck = FACTORY.createDimensionCheck(); + dimCheck.setName(dimensionName + " Dimension Check"); + dimCheck.setDescription(description); + dimCheck.setDimensionName(dimensionName); + dimCheck.setEnabled(true); + + DimensionAttributeCheck visibleCheck = FACTORY.createDimensionAttributeCheck(); + visibleCheck.setName(dimensionName + " Visible Check"); + visibleCheck.setAttributeType(DimensionAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + dimCheck.getDimensionAttributeChecks().add(visibleCheck); + + HierarchyCheck hierarchyCheck = FACTORY.createHierarchyCheck(); + hierarchyCheck.setName("Hierarchy1 Hierarchy Check"); + hierarchyCheck.setEnabled(true); + hierarchyCheck.setHierarchyName("Hierarchy1"); + + HierarchyAttributeCheck hasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hasAllCheck.setName("Hierarchy1 HasAll Check"); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedBoolean(false); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + LevelCheck levelCheck = FACTORY.createLevelCheck(); + levelCheck.setName("Level1 Level Check"); + levelCheck.setLevelName("Level1"); + levelCheck.setDescription("Verify level Level1 exists"); + levelCheck.setEnabled(true); + + //LevelAttributeCheck levelAttributeCheck = FACTORY.createLevelAttributeCheck(); + //TODO add column type + //levelCheck.getLevelAttributeChecks().add(levelAttributeCheck); + + hierarchyCheck.getLevelChecks().add(levelCheck); + dimCheck.getHierarchyChecks().add(hierarchyCheck); + + return dimCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + private QueryCheck createQueryCheckForRoleAll() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + + private QueryCheck createQueryCheckForRoleAllDimWithCubeGrand() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + + private QueryCheck createQueryCheckForRoleNone() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(0); + queryCheck.setEnabled(true); + return queryCheck; + } + +} diff --git a/instance/emf/tutorial/access/columngrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/columngrand/CheckSuiteSupplier.java b/instance/emf/tutorial/access/columngrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/columngrand/CheckSuiteSupplier.java new file mode 100644 index 00000000..6e98fb9f --- /dev/null +++ b/instance/emf/tutorial/access/columngrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/columngrand/CheckSuiteSupplier.java @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.columngrand; + +import java.util.List; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = CheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + //ConnectionConfig connectionConfig = FACTORY.createConnectionConfig(); + //connectionConfig.setCatalogName("Daanse Tutorial - Access Catalog Gran"); + //connectionConfig.getRoles().add("role1"); + //model.setConnectionConfig(connectionConfig); + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Access Column Grant Check"); + catalogCheck.setDescription("Demonstrates access control with column grant and roles"); + catalogCheck.setCatalogName("Daanse Tutorial - Access Column Grant"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + + // Add query checks at catalog level + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRoleAll() + //createQueryCheckForRoleNone() + )); + + ConnectionConfig roleAllConnectionConfig = FACTORY.createConnectionConfig(); + roleAllConnectionConfig.setCatalogName("Daanse Tutorial - Access Column Gran"); + roleAllConnectionConfig.getRoles().add("roleAll"); + + ConnectionConfig roleNoneConnectionConfig = FACTORY.createConnectionConfig(); + roleNoneConnectionConfig.setCatalogName("Daanse Tutorial - Access Column Gran"); + roleNoneConnectionConfig.getRoles().add("roleNone"); + + OlapConnectionCheck connectionCheckRoleAll = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleAll.setName("Connection Check Column Gran with roleAll"); + connectionCheckRoleAll.setDescription("Connection check for Catalog Gran tutorial with roleAll"); + connectionCheckRoleAll.setConnectionConfig(roleAllConnectionConfig); + connectionCheckRoleAll.getCatalogChecks().add(catalogCheck); + + OlapConnectionCheck connectionCheckRoleNone = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleNone.setName("Column Gran Check"); + connectionCheckRoleNone.setDescription("Connection check for Column Gran tutorial with roleNone"); + connectionCheckRoleNone.setConnectionConfig(roleNoneConnectionConfig); + connectionCheckRoleNone.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Access Column Grant Checks"); + suite.setDescription("Comprehensive checks for Daanse Tutorial - Access Column Grant catalog"); + suite.getConnectionChecks().addAll(List.of(connectionCheckRoleAll, connectionCheckRoleNone)); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access Column Grand Database Schema Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access Column Grand"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Access Catalog Gran Cube Check"); + cubeCheck.setDescription("Verify Access Catalog Gran cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + private QueryCheck createQueryCheckForRoleAll() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + +} diff --git a/instance/emf/tutorial/access/cubegrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/cubegrand/CheckSuiteSupplier.java b/instance/emf/tutorial/access/cubegrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/cubegrand/CheckSuiteSupplier.java new file mode 100644 index 00000000..8a2e4ee5 --- /dev/null +++ b/instance/emf/tutorial/access/cubegrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/cubegrand/CheckSuiteSupplier.java @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2024 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.cubegrand; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionAttribute; +import org.eclipse.daanse.olap.check.model.check.DimensionAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Parcel Catalog Check"); + catalogCheck.setDescription("Demonstrates access control with cube grants and roles"); + catalogCheck.setCatalogName("Daanse Tutorial - Access Cube Grant"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + + // Add query checks at catalog level + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRole1() + )); + + ConnectionConfig role1ConnectionConfig = FACTORY.createConnectionConfig(); + role1ConnectionConfig.setCatalogName("Daanse Tutorial - Access Cube Gran"); + role1ConnectionConfig.getRoles().add("role1"); + + OlapConnectionCheck connectionCheckRole1 = FACTORY.createOlapConnectionCheck(); + connectionCheckRole1.setName("Cube Gran Check"); + connectionCheckRole1.setDescription("Connection check for Cube Gran tutorial with role1"); + connectionCheckRole1.setConnectionConfig(role1ConnectionConfig); + connectionCheckRole1.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Access Cube Grand Checks"); + suite.setDescription("Comprehensive checks for Access Cube Grand catalog - logistics and package delivery analysis"); + suite.getConnectionChecks().add(connectionCheckRole1); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access Cube Grand Database Schema Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access Cube Grand"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Access Cube Grant Check"); + cubeCheck.setDescription("Verify Access Cube Gran cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add dimension checks + cubeCheck.getDimensionChecks().add(createDimensionCheck("Dimension1", null)); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + + private DimensionCheck createDimensionCheck(String dimensionName, String description) { + DimensionCheck dimCheck = FACTORY.createDimensionCheck(); + dimCheck.setName(dimensionName + " Dimension Check"); + dimCheck.setDescription(description); + dimCheck.setDimensionName(dimensionName); + dimCheck.setEnabled(true); + + DimensionAttributeCheck visibleCheck = FACTORY.createDimensionAttributeCheck(); + visibleCheck.setName(dimensionName + " Visible Check"); + visibleCheck.setAttributeType(DimensionAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + dimCheck.getDimensionAttributeChecks().add(visibleCheck); + + HierarchyCheck hierarchyCheck = FACTORY.createHierarchyCheck(); + hierarchyCheck.setName("Hierarchy1 Hierarchy Check"); + hierarchyCheck.setEnabled(true); + hierarchyCheck.setHierarchyName("Hierarchy1"); + + HierarchyAttributeCheck hasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hasAllCheck.setName("Hierarchy1 Type HasAll Check"); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedBoolean(false); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + LevelCheck levelCheck = FACTORY.createLevelCheck(); + levelCheck.setName("Level1 Level Check"); + levelCheck.setLevelName("Level1"); + levelCheck.setDescription("Verify level Level1 exists"); + levelCheck.setEnabled(true); + + hierarchyCheck.getLevelChecks().add(levelCheck); + dimCheck.getHierarchyChecks().add(hierarchyCheck); + + return dimCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + private QueryCheck createQueryCheckForRole1() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data for role1"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + +} diff --git a/instance/emf/tutorial/access/databaseschemagrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/databaseschemagrand/CheckSuiteSupplier.java b/instance/emf/tutorial/access/databaseschemagrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/databaseschemagrand/CheckSuiteSupplier.java new file mode 100644 index 00000000..fefb21c7 --- /dev/null +++ b/instance/emf/tutorial/access/databaseschemagrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/databaseschemagrand/CheckSuiteSupplier.java @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2024 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.databaseschemagrand; +import java.util.List; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + //ConnectionConfig connectionConfig = FACTORY.createConnectionConfig(); + //connectionConfig.setCatalogName("Daanse Tutorial - Access Catalog Gran"); + //connectionConfig.getRoles().add("role1"); + //model.setConnectionConfig(connectionConfig); + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Catalog Check"); + catalogCheck.setDescription("Demonstrates access control with database grants and roles"); + catalogCheck.setCatalogName("Daanse Tutorial - Access Database Schema Grant"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + + // Add query checks at catalog + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRoleAll(), + createQueryCheckForRoleNone() + )); + + ConnectionConfig roleAllConnectionConfig = FACTORY.createConnectionConfig(); + roleAllConnectionConfig.setCatalogName("Daanse Tutorial - Access Database Schema Gran"); + roleAllConnectionConfig.getRoles().add("roleAll"); + + ConnectionConfig roleNoneConnectionConfig = FACTORY.createConnectionConfig(); + roleNoneConnectionConfig.setCatalogName("Daanse Tutorial - Access Database Schema Gran"); + roleNoneConnectionConfig.getRoles().add("roleNone"); + + OlapConnectionCheck connectionCheckRoleAll = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleAll.setName("Connection Check Database Schema Gran with roleAll"); + connectionCheckRoleAll.setDescription("Connection check for Database Schema Gran tutorial with roleAll"); + connectionCheckRoleAll.setConnectionConfig(roleAllConnectionConfig); + connectionCheckRoleAll.getCatalogChecks().add(catalogCheck); + + OlapConnectionCheck connectionCheckRoleNone = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleNone.setName("Connection Check Database Schema Gran Check with roleNone"); + connectionCheckRoleNone.setDescription("Connection check for Database Schema Gran tutorial with roleNone"); + connectionCheckRoleNone.setConnectionConfig(roleNoneConnectionConfig); + connectionCheckRoleNone.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Access Database Schema Grant Checks"); + suite.setDescription("Comprehensive checks for Daanse Tutorial - Access Database Schema Grant catalog - logistics and package delivery analysis"); + suite.getConnectionChecks().addAll(List.of(connectionCheckRoleAll, connectionCheckRoleNone)); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access Database Schema Grant Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access Database Schema Grant"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Access Database Schema Grant Cube Check"); + cubeCheck.setDescription("Verify Access Database Schema Grant cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + private QueryCheck createQueryCheckForRoleAll() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + + private QueryCheck createQueryCheckForRoleNone() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(0); + queryCheck.setEnabled(true); + return queryCheck; + } +} diff --git a/instance/emf/tutorial/access/defaultrole/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/defaultrole/CheckSuiteSupplier.java b/instance/emf/tutorial/access/defaultrole/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/defaultrole/CheckSuiteSupplier.java new file mode 100644 index 00000000..79dd99c7 --- /dev/null +++ b/instance/emf/tutorial/access/defaultrole/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/defaultrole/CheckSuiteSupplier.java @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2024 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.defaultrole; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionAttribute; +import org.eclipse.daanse.olap.check.model.check.DimensionAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Catalog Check"); + catalogCheck.setDescription("Demonstrates access control with default role"); + catalogCheck.setCatalogName("Daanse Tutorial - Access With Default Role"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + + // Add query checks at catalog level + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRole1(), + createQueryCheckWithoutRole() + )); + + ConnectionConfig role1ConnectionConfig = FACTORY.createConnectionConfig(); + role1ConnectionConfig.setCatalogName("Daanse Tutorial - Access With Default Role"); + role1ConnectionConfig.getRoles().add("role1"); + + OlapConnectionCheck connectionCheckRole1 = FACTORY.createOlapConnectionCheck(); + connectionCheckRole1.setName("With Default Role Check"); + connectionCheckRole1.setDescription("Connection check for With Default Role tutorial with role1"); + connectionCheckRole1.setConnectionConfig(role1ConnectionConfig); + connectionCheckRole1.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Access With Default Role Checks"); + suite.setDescription("Comprehensive checks for Daanse Tutorial - Access With Default Role catalog - logistics and package delivery analysis"); + suite.getConnectionChecks().add(connectionCheckRole1); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access With Default Role Database Schema Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access With Default Role"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Daanse Tutorial - Access With Default Role Cube Check"); + cubeCheck.setDescription("Verify Daanse Tutorial - Access With Default Role cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add dimension checks + cubeCheck.getDimensionChecks().add(createDimension1Check()); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + + private DimensionCheck createDimension1Check() { + DimensionCheck dimCheck = FACTORY.createDimensionCheck(); + dimCheck.setName("Dimension1 Dimension Check"); + dimCheck.setDescription("Dimension1 Dimension Check"); + dimCheck.setDimensionName("Dimension1"); + dimCheck.setEnabled(true); + + DimensionAttributeCheck visibleCheck = FACTORY.createDimensionAttributeCheck(); + visibleCheck.setName("Dimension1 Visible Check"); + visibleCheck.setAttributeType(DimensionAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + dimCheck.getDimensionAttributeChecks().add(visibleCheck); + + HierarchyCheck hierarchy1Check = FACTORY.createHierarchyCheck(); + hierarchy1Check.setName("Hierarchy1 Hierarchy Check"); + hierarchy1Check.setHierarchyName("Hierarchy1"); + hierarchy1Check.setEnabled(true); + + HierarchyAttributeCheck hierarchy1HasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hierarchy1HasAllCheck.setName("Hierarchy1 HasAll Check"); + hierarchy1HasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchy1HasAllCheck.setExpectedBoolean(false); + hierarchy1Check.getHierarchyAttributeChecks().add(hierarchy1HasAllCheck); + + LevelCheck level1Check = FACTORY.createLevelCheck(); + level1Check.setName("Level1 Level Check"); + level1Check.setLevelName("Level1"); + level1Check.setDescription("Verify level Level1 exists"); + level1Check.setEnabled(true); + + hierarchy1Check.getLevelChecks().add(level1Check); + + HierarchyCheck hierarchy2Check = FACTORY.createHierarchyCheck(); + hierarchy1Check.setName("Hierarchy2 Hierarchy Check"); + hierarchy1Check.setHierarchyName("Hierarchy2"); + hierarchy1Check.setEnabled(true); + + HierarchyAttributeCheck hierarchy2HasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hierarchy2HasAllCheck.setName("Hierarchy2 HasAll Check"); + hierarchy2HasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchy2HasAllCheck.setExpectedBoolean(false); + hierarchy2Check.getHierarchyAttributeChecks().add(hierarchy1HasAllCheck); + + LevelCheck level2Check = FACTORY.createLevelCheck(); + level2Check.setName("Level2 Level Check"); + level2Check.setLevelName("Level2"); + level2Check.setDescription("Verify level Level2 exists"); + level2Check.setEnabled(true); + + hierarchy1Check.getLevelChecks().add(level2Check); + + dimCheck.getHierarchyChecks().add(hierarchy1Check); + dimCheck.getHierarchyChecks().add(hierarchy2Check); + + return dimCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + private QueryCheck createQueryCheckForRole1() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + + private QueryCheck createQueryCheckWithoutRole() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + +} diff --git a/instance/emf/tutorial/access/dimensiongrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/dimensiongrand/CheckSuiteSupplier.java b/instance/emf/tutorial/access/dimensiongrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/dimensiongrand/CheckSuiteSupplier.java new file mode 100644 index 00000000..efc2b15d --- /dev/null +++ b/instance/emf/tutorial/access/dimensiongrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/dimensiongrand/CheckSuiteSupplier.java @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2024 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.dimensiongrand; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionAttribute; +import org.eclipse.daanse.olap.check.model.check.DimensionAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Parcel Catalog Check"); + catalogCheck.setDescription("Demonstrates access control with dimension grants and roles"); + catalogCheck.setCatalogName("Daanse Tutorial - Access Dimension Grant"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + // Add query checks at catalog level + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRole1() + )); + + ConnectionConfig role1ConnectionConfig = FACTORY.createConnectionConfig(); + role1ConnectionConfig.setCatalogName("Daanse Tutorial - Access Dimension Gran"); + role1ConnectionConfig.getRoles().add("role1"); + + OlapConnectionCheck connectionCheckRole1 = FACTORY.createOlapConnectionCheck(); + connectionCheckRole1.setName("Dimension Gran Check"); + connectionCheckRole1.setDescription("Connection check for Dimension Gran tutorial with role1"); + connectionCheckRole1.setConnectionConfig(role1ConnectionConfig); + connectionCheckRole1.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Access Dimension Grant Catalog Checks"); + suite.setDescription("Comprehensive checks for Daanse Tutorial - Access Dimension Grant catalog - logistics and package delivery analysis"); + suite.getConnectionChecks().add(connectionCheckRole1); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access Dimension Grant Database Schema Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access Dimension Grant"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Daanse Tutorial - Access Dimension Grant Cube Check"); + cubeCheck.setDescription("Verify Access Dimension Gran cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add dimension checks + cubeCheck.getDimensionChecks().add(createDimension1Check()); + cubeCheck.getDimensionChecks().add(createDimension2Check()); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + + private DimensionCheck createDimension1Check() { + DimensionCheck dimCheck = FACTORY.createDimensionCheck(); + dimCheck.setName("Dimension1 Dimension Check"); + dimCheck.setDescription("Dimension1 Dimension Check"); + dimCheck.setDimensionName("Dimension1"); + dimCheck.setEnabled(true); + + DimensionAttributeCheck visibleCheck = FACTORY.createDimensionAttributeCheck(); + visibleCheck.setName("Dimension1 Visible Check"); + visibleCheck.setAttributeType(DimensionAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + dimCheck.getDimensionAttributeChecks().add(visibleCheck); + + HierarchyCheck hierarchyCheck = FACTORY.createHierarchyCheck(); + hierarchyCheck.setName("Hierarchy1 Hierarchy Check"); + hierarchyCheck.setEnabled(true); + + HierarchyAttributeCheck hasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hasAllCheck.setName("Hierarchy2 HasAll Check"); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedBoolean(false); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + LevelCheck levelCheck = FACTORY.createLevelCheck(); + levelCheck.setName("Level1 Level Check"); + levelCheck.setLevelName("Level1"); + levelCheck.setDescription("Verify level Level1 exists"); + levelCheck.setEnabled(true); + + hierarchyCheck.getLevelChecks().add(levelCheck); + dimCheck.getHierarchyChecks().add(hierarchyCheck); + + return dimCheck; + } + + private DimensionCheck createDimension2Check() { + DimensionCheck dimCheck = FACTORY.createDimensionCheck(); + dimCheck.setName("Dimension2 Dimension Check"); + dimCheck.setDescription("Dimension2 Dimension Check"); + dimCheck.setDimensionName("Dimension2"); + dimCheck.setEnabled(true); + + DimensionAttributeCheck visibleCheck = FACTORY.createDimensionAttributeCheck(); + visibleCheck.setName("Dimension2 Visible Check"); + visibleCheck.setAttributeType(DimensionAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + dimCheck.getDimensionAttributeChecks().add(visibleCheck); + + HierarchyCheck hierarchyCheck = FACTORY.createHierarchyCheck(); + hierarchyCheck.setName("Hierarchy2 Hierarchy Check"); + hierarchyCheck.setEnabled(false); + + HierarchyAttributeCheck hasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hasAllCheck.setName("Hierarchy2 HasAll Check"); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedBoolean(true); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + LevelCheck levelCheck = FACTORY.createLevelCheck(); + levelCheck.setName("Level2 Level Check"); + levelCheck.setLevelName("Level2"); + levelCheck.setDescription("Verify level Level2 exists"); + levelCheck.setEnabled(true); + + hierarchyCheck.getLevelChecks().add(levelCheck); + dimCheck.getHierarchyChecks().add(hierarchyCheck); + + return dimCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + private QueryCheck createQueryCheckForRole1() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query Dimension1 Hierarchy1"); + queryCheck.setQuery("SELECT NON EMPTY Hierarchize(AddCalculatedMembers({DrilldownLevel({[Dimension1].[Hierarchy1].[All Hierarchy1s]})})) DIMENSION PROPERTIES PARENT_UNIQUE_NAME ON COLUMNS FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + +} diff --git a/instance/emf/tutorial/access/hierarchygrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/hierarchygrand/CheckSuiteSupplier.java b/instance/emf/tutorial/access/hierarchygrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/hierarchygrand/CheckSuiteSupplier.java new file mode 100644 index 00000000..a1c8fcf3 --- /dev/null +++ b/instance/emf/tutorial/access/hierarchygrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/hierarchygrand/CheckSuiteSupplier.java @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2024 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.hierarchygrand; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionAttribute; +import org.eclipse.daanse.olap.check.model.check.DimensionAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Access Hierarchy Grant Catalog Check"); + catalogCheck.setDescription("Demonstrates access control with hierarchy grants and roles"); + catalogCheck.setCatalogName("Daanse Tutorial - Access Hierarchy Grant"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + // Add query checks at catalog level + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRole1() + )); + + ConnectionConfig role1ConnectionConfig = FACTORY.createConnectionConfig(); + role1ConnectionConfig.setCatalogName("Daanse Tutorial - Access Hierarchy Gran"); + role1ConnectionConfig.getRoles().add("role1"); + + OlapConnectionCheck connectionCheckRole1 = FACTORY.createOlapConnectionCheck(); + connectionCheckRole1.setName("Hierarchy Gran Check"); + connectionCheckRole1.setDescription("Connection check for Hierarchy Gran tutorial with role1"); + connectionCheckRole1.setConnectionConfig(role1ConnectionConfig); + connectionCheckRole1.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Access Hierarchy Grant Catalog Checks"); + suite.setDescription("Comprehensive checks for Daanse Tutorial - Access Hierarchy Grant catalog - logistics and package delivery analysis"); + suite.getConnectionChecks().add(connectionCheckRole1); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access Hierarchy Grant Database Schema Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access Hierarchy Grant"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Daanse Tutorial - Access Hierarchy Grant Cube Check"); + cubeCheck.setDescription("Verify Daanse Tutorial - Access Hierarchy Grant cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add dimension checks + cubeCheck.getDimensionChecks().add(createDimension1Check()); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + + private DimensionCheck createDimension1Check() { + DimensionCheck dimCheck = FACTORY.createDimensionCheck(); + dimCheck.setName("Dimension1 Dimension Check"); + dimCheck.setDescription("Dimension1 Dimension Check"); + dimCheck.setDimensionName("Dimension1"); + dimCheck.setEnabled(true); + + DimensionAttributeCheck visibleCheck = FACTORY.createDimensionAttributeCheck(); + visibleCheck.setName("Dimension1 Visible Check"); + visibleCheck.setAttributeType(DimensionAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + dimCheck.getDimensionAttributeChecks().add(visibleCheck); + + HierarchyCheck hierarchy1Check = FACTORY.createHierarchyCheck(); + hierarchy1Check.setName("Hierarchy1 Hierarchy Check"); + hierarchy1Check.setHierarchyName("Hierarchy1"); + hierarchy1Check.setEnabled(true); + + HierarchyAttributeCheck hierarchy1HasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hierarchy1HasAllCheck.setName("Hierarchy1 HasAll Check"); + hierarchy1HasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchy1HasAllCheck.setExpectedBoolean(false); + hierarchy1Check.getHierarchyAttributeChecks().add(hierarchy1HasAllCheck); + + LevelCheck level1Check = FACTORY.createLevelCheck(); + level1Check.setName("Level1 Level Check"); + level1Check.setLevelName("Level1"); + level1Check.setDescription("Verify level Level1 exists"); + level1Check.setEnabled(true); + + hierarchy1Check.getLevelChecks().add(level1Check); + + HierarchyCheck hierarchy2Check = FACTORY.createHierarchyCheck(); + hierarchy1Check.setName("Hierarchy2 Hierarchy Check"); + hierarchy1Check.setHierarchyName("Hierarchy2"); + hierarchy1Check.setEnabled(true); + + HierarchyAttributeCheck hierarchy2HasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hierarchy2HasAllCheck.setName("Hierarchy2 HasAll Check"); + hierarchy2HasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchy2HasAllCheck.setExpectedBoolean(false); + hierarchy2Check.getHierarchyAttributeChecks().add(hierarchy1HasAllCheck); + + LevelCheck level2Check = FACTORY.createLevelCheck(); + level2Check.setName("Level2 Level Check"); + level2Check.setLevelName("Level2"); + level2Check.setDescription("Verify level Level2 exists"); + level2Check.setEnabled(true); + + hierarchy1Check.getLevelChecks().add(level2Check); + + dimCheck.getHierarchyChecks().add(hierarchy1Check); + dimCheck.getHierarchyChecks().add(hierarchy2Check); + + return dimCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + private QueryCheck createQueryCheckForRole1() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT NON EMPTY Hierarchize(AddCalculatedMembers({DrilldownLevel({[Dimension1].[Hierarchy1].[All Hierarchy1s]})})) DIMENSION PROPERTIES PARENT_UNIQUE_NAME ON COLUMNS FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + +} diff --git a/instance/emf/tutorial/access/membergrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/membergrand/CheckSuiteSupplier.java b/instance/emf/tutorial/access/membergrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/membergrand/CheckSuiteSupplier.java new file mode 100644 index 00000000..430eb155 --- /dev/null +++ b/instance/emf/tutorial/access/membergrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/membergrand/CheckSuiteSupplier.java @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2024 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.membergrand; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionAttribute; +import org.eclipse.daanse.olap.check.model.check.DimensionAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + //ConnectionConfig connectionConfig = FACTORY.createConnectionConfig(); + //connectionConfig.setCatalogName("Daanse Tutorial - Access Catalog Gran"); + //connectionConfig.getRoles().add("role1"); + //model.setConnectionConfig(connectionConfig); + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Access Member Grant Catalog Check"); + catalogCheck.setDescription("Demonstrates access control with member grants and roles"); + catalogCheck.setCatalogName("Daanse Tutorial - Access Member Grant"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + // Add query checks at catalog level + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRole1() + )); + + ConnectionConfig role1ConnectionConfig = FACTORY.createConnectionConfig(); + role1ConnectionConfig.setCatalogName("Daanse Tutorial - Access Member Gran"); + role1ConnectionConfig.getRoles().add("role1"); + + OlapConnectionCheck connectionCheckRole1 = FACTORY.createOlapConnectionCheck(); + connectionCheckRole1.setName("Member Gran Check"); + connectionCheckRole1.setDescription("Connection check for Member Gran tutorial with role1"); + connectionCheckRole1.setConnectionConfig(role1ConnectionConfig); + connectionCheckRole1.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Access Member Grant Catalog Checks"); + suite.setDescription("Comprehensive checks for Daanse Tutorial - Access Member Grant catalog - logistics and package delivery analysis"); + suite.getConnectionChecks().add(connectionCheckRole1); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access Member Grant Database Schema Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access Member Grant"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Daanse Tutorial - Access Member Grant Cube Check"); + cubeCheck.setDescription("Verify Daanse Tutorial - Access Member Grant cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add dimension checks + cubeCheck.getDimensionChecks().add(createDimensionCheck("Dimension1", null)); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + private DimensionCheck createDimensionCheck(String dimensionName, String description) { + DimensionCheck dimCheck = FACTORY.createDimensionCheck(); + dimCheck.setName(dimensionName + " Dimension Check"); + dimCheck.setDescription(description); + dimCheck.setDimensionName(dimensionName); + dimCheck.setEnabled(true); + + DimensionAttributeCheck visibleCheck = FACTORY.createDimensionAttributeCheck(); + visibleCheck.setName(dimensionName + " Visible Check"); + visibleCheck.setAttributeType(DimensionAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + dimCheck.getDimensionAttributeChecks().add(visibleCheck); + + HierarchyCheck hierarchyCheck = FACTORY.createHierarchyCheck(); + hierarchyCheck.setName("Hierarchy1 Hierarchy Check"); + hierarchyCheck.setEnabled(true); + + HierarchyAttributeCheck hasAllCheck = FACTORY.createHierarchyAttributeCheck(); + hasAllCheck.setName("Hierarchy HasAll Check"); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedBoolean(true); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + LevelCheck levelCheck = FACTORY.createLevelCheck(); + levelCheck.setName("Level1 Level Check"); + levelCheck.setLevelName("Level1"); + levelCheck.setDescription("Verify level Level1 exists"); + levelCheck.setEnabled(true); + + hierarchyCheck.getLevelChecks().add(levelCheck); + dimCheck.getHierarchyChecks().add(hierarchyCheck); + + return dimCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + private QueryCheck createQueryCheckForRole1() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT NON EMPTY Hierarchize(AddCalculatedMembers({DrilldownLevel({[Dimension1].[Hierarchy1].[All Hierarchy1s]})})) DIMENSION PROPERTIES PARENT_UNIQUE_NAME ON COLUMNS FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + +} diff --git a/instance/emf/tutorial/access/tablegrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/tablegrand/CheckSuiteSupplier.java b/instance/emf/tutorial/access/tablegrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/tablegrand/CheckSuiteSupplier.java new file mode 100644 index 00000000..38d6c890 --- /dev/null +++ b/instance/emf/tutorial/access/tablegrand/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/access/tablegrand/CheckSuiteSupplier.java @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.tablegrand; +import java.util.List; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.ConnectionConfig; +import org.eclipse.daanse.olap.check.model.check.CubeAttribute; +import org.eclipse.daanse.olap.check.model.check.CubeAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MatchMode; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + private static final OlapCheckFactory FACTORY = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create catalog check + CatalogCheck catalogCheck = FACTORY.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Access Table Grant Catalog Check"); + catalogCheck.setDescription("Demonstrates access control with table grants and roles"); + catalogCheck.setCatalogName("Daanse Tutorial - Access Table Grant"); + catalogCheck.setEnabled(true); + // Add database schema check with detailed column checks + catalogCheck.getDatabaseSchemaChecks().add(createDatabaseSchemaCheck()); + // Add cube check + catalogCheck.getCubeChecks().add(createCubeCheck()); + + // Add query checks at catalog level + catalogCheck.getQueryChecks().addAll(java.util.List.of( + createQueryCheckForRoleAll() + )); + + ConnectionConfig roleAllConnectionConfig = FACTORY.createConnectionConfig(); + roleAllConnectionConfig.setCatalogName("Daanse Tutorial - Access Table Gran"); + roleAllConnectionConfig.getRoles().add("roleAll"); + + ConnectionConfig roleNoneConnectionConfig = FACTORY.createConnectionConfig(); + roleNoneConnectionConfig.setCatalogName("Daanse Tutorial - Access Table Gran"); + roleNoneConnectionConfig.getRoles().add("roleNone"); + + OlapConnectionCheck connectionCheckRoleAll = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleAll.setName("Connection Check Table Gran with roleAll"); + connectionCheckRoleAll.setDescription("Connection check for Catalog Gran tutorial with roleAll"); + connectionCheckRoleAll.setConnectionConfig(roleAllConnectionConfig); + connectionCheckRoleAll.getCatalogChecks().add(catalogCheck); + + OlapConnectionCheck connectionCheckRoleNone = FACTORY.createOlapConnectionCheck(); + connectionCheckRoleNone.setName("Column Gran Check"); + connectionCheckRoleNone.setDescription("Connection check for Table Gran tutorial with roleNone"); + connectionCheckRoleNone.setConnectionConfig(roleNoneConnectionConfig); + connectionCheckRoleNone.getCatalogChecks().add(catalogCheck); + + OlapCheckSuite suite = FACTORY.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Access Table Grant Catalog Checks"); + suite.setDescription("Comprehensive checks for Daanse Tutorial - Access Table Grant catalog - logistics and package delivery analysis"); + suite.getConnectionChecks().addAll(List.of(connectionCheckRoleAll, connectionCheckRoleNone)); + return suite; + } + + private DatabaseSchemaCheck createDatabaseSchemaCheck() { + DatabaseSchemaCheck schemaCheck = FACTORY.createDatabaseSchemaCheck(); + schemaCheck.setName("Daanse Tutorial - Access Table Grant Database Schema Check"); + schemaCheck.setDescription("Verify database tables and columns exist for Daanse Tutorial - Access Table Grant"); + schemaCheck.setEnabled(true); + // Check parcels fact table with columns + DatabaseTableCheck factTableCheck = FACTORY.createDatabaseTableCheck(); + factTableCheck.setTableName("Fact"); + factTableCheck.setEnabled(true); + // Add column checks for Fact table + factTableCheck.getColumnChecks().add(createColumnCheck("KEY", "VARCHAR")); + factTableCheck.getColumnChecks().add(createColumnCheck("VALUE", "INTEGER")); + schemaCheck.getTableChecks().add(factTableCheck); + return schemaCheck; + } + private DatabaseColumnCheck createColumnCheck(String columnName, String type) { + DatabaseColumnCheck columnCheck = FACTORY.createDatabaseColumnCheck(); + columnCheck.setName(columnName + " Column Check"); + columnCheck.setColumnName(columnName); + DatabaseColumnAttributeCheck typeCheck = FACTORY.createDatabaseColumnAttributeCheck(); + typeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + typeCheck.setExpectedValue(type); + columnCheck.getColumnAttributeChecks().add(typeCheck); + columnCheck.setEnabled(true); + return columnCheck; + } + private CubeCheck createCubeCheck() { + CubeCheck cubeCheck = FACTORY.createCubeCheck(); + cubeCheck.setName("Daanse Tutorial - Access Table Grant Cube Check"); + cubeCheck.setDescription("Verify Daanse Tutorial - Access Table Grant cube structure with all dimensions and measures"); + cubeCheck.setCubeName("Cube1"); + cubeCheck.setEnabled(true); + // Add cube attribute checks + CubeAttributeCheck visibleCheck = FACTORY.createCubeAttributeCheck(); + visibleCheck.setName("Cube Visibility Check"); + visibleCheck.setAttributeType(CubeAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + cubeCheck.getCubeAttributeChecks().add(visibleCheck); + // Add measure checks + cubeCheck.getMeasureChecks().add(createMeasureCheck("Measure1", "sum")); + return cubeCheck; + } + + private MeasureCheck createMeasureCheck(String measureName, String expectedAggregator) { + MeasureCheck measureCheck = FACTORY.createMeasureCheck(); + measureCheck.setName(measureName + " Measure Check"); + measureCheck.setMeasureName(measureName); + measureCheck.setEnabled(true); + MeasureAttributeCheck visibleCheck = FACTORY.createMeasureAttributeCheck(); + visibleCheck.setName(measureName + " Visible Check"); + visibleCheck.setAttributeType(MeasureAttribute.VISIBLE); + visibleCheck.setExpectedBoolean(true); + measureCheck.getMeasureAttributeChecks().add(visibleCheck); + MeasureAttributeCheck aggregatorCheck = FACTORY.createMeasureAttributeCheck(); + aggregatorCheck.setName(measureName + " Aggregator Check"); + aggregatorCheck.setAttributeType(MeasureAttribute.AGGREGATOR); + aggregatorCheck.setExpectedValue(expectedAggregator); + aggregatorCheck.setMatchMode(MatchMode.EQUALS); + aggregatorCheck.setCaseSensitive(false); + measureCheck.getMeasureAttributeChecks().add(aggregatorCheck); + return measureCheck; + } + + private QueryCheck createQueryCheckForRoleAll() { + QueryCheck queryCheck = FACTORY.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube1] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.setEnabled(true); + return queryCheck; + } + +} diff --git a/instance/emf/tutorial/action/drillthrough/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/action/drillthrough/CheckSuiteSupplier.java b/instance/emf/tutorial/action/drillthrough/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/action/drillthrough/CheckSuiteSupplier.java new file mode 100644 index 00000000..3aec233d --- /dev/null +++ b/instance/emf/tutorial/action/drillthrough/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/action/drillthrough/CheckSuiteSupplier.java @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.action.drillthrough; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the action drillthrough tutorial. + * Checks that the catalog, cube, measure, and drillthrough actions exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure1"); + measureCheck.setDescription("Check that measure 'Measure1' exists"); + measureCheck.setMeasureName("Measure1"); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1]"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create database column checks for H1_L1 table + DatabaseColumnAttributeCheck columnH1L1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH1L1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH1L1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckH1L1Key = factory.createDatabaseColumnCheck(); + columnCheckH1L1Key.setName("Database Column Check KEY (H1_L1)"); + columnCheckH1L1Key.setColumnName("KEY"); + columnCheckH1L1Key.getColumnAttributeChecks().add(columnH1L1KeyTypeCheck); + + DatabaseColumnAttributeCheck columnH1L1NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH1L1NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH1L1NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckH1L1Name = factory.createDatabaseColumnCheck(); + columnCheckH1L1Name.setName("Database Column Check NAME (H1_L1)"); + columnCheckH1L1Name.setColumnName("NAME"); + columnCheckH1L1Name.getColumnAttributeChecks().add(columnH1L1NameTypeCheck); + + DatabaseTableCheck databaseTableCheckH1L1 = factory.createDatabaseTableCheck(); + databaseTableCheckH1L1.setName("Database Table H1_L1 Check"); + databaseTableCheckH1L1.setTableName("H1_L1"); + databaseTableCheckH1L1.getColumnChecks().add(columnCheckH1L1Key); + databaseTableCheckH1L1.getColumnChecks().add(columnCheckH1L1Name); + + // Create database column checks for H2_L1 table + DatabaseColumnAttributeCheck columnH2L1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH2L1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH2L1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckH2L1Key = factory.createDatabaseColumnCheck(); + columnCheckH2L1Key.setName("Database Column Check KEY (H2_L1)"); + columnCheckH2L1Key.setColumnName("KEY"); + columnCheckH2L1Key.getColumnAttributeChecks().add(columnH2L1KeyTypeCheck); + + DatabaseColumnAttributeCheck columnH2L1NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH2L1NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH2L1NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckH2L1Name = factory.createDatabaseColumnCheck(); + columnCheckH2L1Name.setName("Database Column Check NAME (H2_L1)"); + columnCheckH2L1Name.setColumnName("NAME"); + columnCheckH2L1Name.getColumnAttributeChecks().add(columnH2L1NameTypeCheck); + + DatabaseTableCheck databaseTableCheckH2L1 = factory.createDatabaseTableCheck(); + databaseTableCheckH2L1.setName("Database Table H2_L1 Check"); + databaseTableCheckH2L1.setTableName("H2_L1"); + databaseTableCheckH2L1.getColumnChecks().add(columnCheckH2L1Key); + databaseTableCheckH2L1.getColumnChecks().add(columnCheckH2L1Name); + + // Create database column checks for HX_L2 table + DatabaseColumnAttributeCheck columnHXL2KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnHXL2KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnHXL2KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckHXL2Key = factory.createDatabaseColumnCheck(); + columnCheckHXL2Key.setName("Database Column Check KEY (HX_L2)"); + columnCheckHXL2Key.setColumnName("KEY"); + columnCheckHXL2Key.getColumnAttributeChecks().add(columnHXL2KeyTypeCheck); + + DatabaseColumnAttributeCheck columnHXL2NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnHXL2NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnHXL2NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckHXL2Name = factory.createDatabaseColumnCheck(); + columnCheckHXL2Name.setName("Database Column Check NAME (HX_L2)"); + columnCheckHXL2Name.setColumnName("NAME"); + columnCheckHXL2Name.getColumnAttributeChecks().add(columnHXL2NameTypeCheck); + + DatabaseColumnAttributeCheck columnH1L1KeyFKTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH1L1KeyFKTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH1L1KeyFKTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckH1L1KeyFK = factory.createDatabaseColumnCheck(); + columnCheckH1L1KeyFK.setName("Database Column Check H1L1_KEY (HX_L2)"); + columnCheckH1L1KeyFK.setColumnName("H1L1_KEY"); + columnCheckH1L1KeyFK.getColumnAttributeChecks().add(columnH1L1KeyFKTypeCheck); + + DatabaseColumnAttributeCheck columnH2L1KeyFKTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH2L1KeyFKTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH2L1KeyFKTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckH2L1KeyFK = factory.createDatabaseColumnCheck(); + columnCheckH2L1KeyFK.setName("Database Column Check H2L1_KEY (HX_L2)"); + columnCheckH2L1KeyFK.setColumnName("H2L1_KEY"); + columnCheckH2L1KeyFK.getColumnAttributeChecks().add(columnH2L1KeyFKTypeCheck); + + DatabaseTableCheck databaseTableCheckHXL2 = factory.createDatabaseTableCheck(); + databaseTableCheckHXL2.setName("Database Table HX_L2 Check"); + databaseTableCheckHXL2.setTableName("HX_L2"); + databaseTableCheckHXL2.getColumnChecks().add(columnCheckHXL2Key); + databaseTableCheckHXL2.getColumnChecks().add(columnCheckHXL2Name); + databaseTableCheckHXL2.getColumnChecks().add(columnCheckH1L1KeyFK); + databaseTableCheckHXL2.getColumnChecks().add(columnCheckH2L1KeyFK); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Action Drillthrough"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckH1L1); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckH2L1); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckHXL2); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Action Drillthrough"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Action Drillthrough' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Action Drillthrough"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Action Drillthrough"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Action Drillthrough"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Action Drillthrough"); + suite.setDescription("Check suite for the Daanse Tutorial - Action Drillthrough"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/aggregation/aggexclude/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/aggregation/aggexclude/CheckSuiteSupplier.java b/instance/emf/tutorial/aggregation/aggexclude/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/aggregation/aggexclude/CheckSuiteSupplier.java new file mode 100644 index 00000000..c4820e5a --- /dev/null +++ b/instance/emf/tutorial/aggregation/aggexclude/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/aggregation/aggexclude/CheckSuiteSupplier.java @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.aggregation.aggexclude; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the aggregation exclude tutorial. + * Checks that the catalog, cube, measure, and aggregation exclude configuration exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure"); + measureCheck.setDescription("Check that measure 'Measure' exists"); + measureCheck.setMeasureName("Measure"); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure]"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create database column checks for agg_01_Fact table + DatabaseColumnAttributeCheck columnAggKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnAggKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAggKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckAggKey = factory.createDatabaseColumnCheck(); + columnCheckAggKey.setName("Database Column Check KEY (agg_01_Fact)"); + columnCheckAggKey.setColumnName("KEY"); + columnCheckAggKey.getColumnAttributeChecks().add(columnAggKeyTypeCheck); + + DatabaseTableCheck databaseTableCheckAgg = factory.createDatabaseTableCheck(); + databaseTableCheckAgg.setName("Database Table agg_01_Fact Check"); + databaseTableCheckAgg.setTableName("agg_01_Fact"); + databaseTableCheckAgg.getColumnChecks().add(columnCheckAggKey); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Aggregation Agg Exclude"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckAgg); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Aggregation Agg Exclude"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Aggregation Agg Exclude' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Aggregation Agg Exclude"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Aggregation Agg Exclude"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Aggregation Agg Exclude"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Aggregation Agg Exclude"); + suite.setDescription("Check suite for the Daanse Tutorial - Aggregation Agg Exclude"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/aggregation/aggregatetables/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/aggregation/aggregatetables/CheckSuiteSupplier.java b/instance/emf/tutorial/aggregation/aggregatetables/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/aggregation/aggregatetables/CheckSuiteSupplier.java new file mode 100644 index 00000000..69ebd94c --- /dev/null +++ b/instance/emf/tutorial/aggregation/aggregatetables/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/aggregation/aggregatetables/CheckSuiteSupplier.java @@ -0,0 +1,242 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.aggregation.aggregatetables; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the aggregation aggregate tables tutorial. + * Checks that the catalog, cube, measure, and aggregation tables configuration exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Store Cost"); + measureCheck.setDescription("Check that measure 'Store Cost' exists"); + measureCheck.setMeasureName("Store Cost"); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Sales"); + cubeCheck.setDescription("Check that cube 'Sales' exists"); + cubeCheck.setCubeName("Sales"); + cubeCheck.getMeasureChecks().add(measureCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Store Cost]"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Store Cost Query Check"); + queryCheck.setDescription("Verify MDX query returns Store Cost data"); + queryCheck.setQuery("SELECT FROM [Sales] WHERE ([Measures].[Store Cost])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for SALES_FACT_1997 table + DatabaseColumnAttributeCheck columnProductIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnProductIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnProductIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckProductId = factory.createDatabaseColumnCheck(); + columnCheckProductId.setName("Database Column Check PRODUCT_ID"); + columnCheckProductId.setColumnName("PRODUCT_ID"); + columnCheckProductId.getColumnAttributeChecks().add(columnProductIdTypeCheck); + + DatabaseColumnAttributeCheck columnStoreCostTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnStoreCostTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnStoreCostTypeCheck.setExpectedValue("DECIMAL"); + + DatabaseColumnCheck columnCheckStoreCost = factory.createDatabaseColumnCheck(); + columnCheckStoreCost.setName("Database Column Check STORE_COST"); + columnCheckStoreCost.setColumnName("STORE_COST"); + columnCheckStoreCost.getColumnAttributeChecks().add(columnStoreCostTypeCheck); + + DatabaseTableCheck databaseTableCheckSalesFact1997 = factory.createDatabaseTableCheck(); + databaseTableCheckSalesFact1997.setName("Database Table SALES_FACT_1997 Check"); + databaseTableCheckSalesFact1997.setTableName("SALES_FACT_1997"); + databaseTableCheckSalesFact1997.getColumnChecks().add(columnCheckProductId); + databaseTableCheckSalesFact1997.getColumnChecks().add(columnCheckStoreCost); + + // Create database column checks for PRODUCT table + DatabaseColumnAttributeCheck columnProductClassIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnProductClassIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnProductClassIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckProductClassId = factory.createDatabaseColumnCheck(); + columnCheckProductClassId.setName("Database Column Check PRODUCT_CLASS_ID"); + columnCheckProductClassId.setColumnName("PRODUCT_CLASS_ID"); + columnCheckProductClassId.getColumnAttributeChecks().add(columnProductClassIdTypeCheck); + + DatabaseColumnAttributeCheck columnProductProductIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnProductProductIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnProductProductIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckProductProductId = factory.createDatabaseColumnCheck(); + columnCheckProductProductId.setName("Database Column Check PRODUCT_ID (PRODUCT)"); + columnCheckProductProductId.setColumnName("PRODUCT_ID"); + columnCheckProductProductId.getColumnAttributeChecks().add(columnProductProductIdTypeCheck); + + DatabaseColumnAttributeCheck columnBrandNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnBrandNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnBrandNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckBrandName = factory.createDatabaseColumnCheck(); + columnCheckBrandName.setName("Database Column Check brand_name"); + columnCheckBrandName.setColumnName("brand_name"); + columnCheckBrandName.getColumnAttributeChecks().add(columnBrandNameTypeCheck); + + DatabaseColumnAttributeCheck columnProductNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnProductNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnProductNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckProductName = factory.createDatabaseColumnCheck(); + columnCheckProductName.setName("Database Column Check product_name"); + columnCheckProductName.setColumnName("product_name"); + columnCheckProductName.getColumnAttributeChecks().add(columnProductNameTypeCheck); + + DatabaseTableCheck databaseTableCheckProduct = factory.createDatabaseTableCheck(); + databaseTableCheckProduct.setName("Database Table PRODUCT Check"); + databaseTableCheckProduct.setTableName("PRODUCT"); + databaseTableCheckProduct.getColumnChecks().add(columnCheckProductClassId); + databaseTableCheckProduct.getColumnChecks().add(columnCheckProductProductId); + databaseTableCheckProduct.getColumnChecks().add(columnCheckBrandName); + databaseTableCheckProduct.getColumnChecks().add(columnCheckProductName); + + // Create database column checks for PRODUCT_CLASS table + DatabaseColumnAttributeCheck columnProductClassProductClassIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnProductClassProductClassIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnProductClassProductClassIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckProductClassProductClassId = factory.createDatabaseColumnCheck(); + columnCheckProductClassProductClassId.setName("Database Column Check PRODUCT_CLASS_ID (PRODUCT_CLASS)"); + columnCheckProductClassProductClassId.setColumnName("PRODUCT_CLASS_ID"); + columnCheckProductClassProductClassId.getColumnAttributeChecks().add(columnProductClassProductClassIdTypeCheck); + + DatabaseColumnAttributeCheck columnProductFamileTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnProductFamileTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnProductFamileTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckProductFamile = factory.createDatabaseColumnCheck(); + columnCheckProductFamile.setName("Database Column Check PRODUCT_FAMILE"); + columnCheckProductFamile.setColumnName("PRODUCT_FAMILE"); + columnCheckProductFamile.getColumnAttributeChecks().add(columnProductFamileTypeCheck); + + DatabaseTableCheck databaseTableCheckProductClass = factory.createDatabaseTableCheck(); + databaseTableCheckProductClass.setName("Database Table PRODUCT_CLASS Check"); + databaseTableCheckProductClass.setTableName("PRODUCT_CLASS"); + databaseTableCheckProductClass.getColumnChecks().add(columnCheckProductClassProductClassId); + databaseTableCheckProductClass.getColumnChecks().add(columnCheckProductFamile); + + // Create database column checks for AGG_C_SPECIAL_SALES_FACT_1997 table + DatabaseColumnAttributeCheck columnAggProductIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnAggProductIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAggProductIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckAggProductId = factory.createDatabaseColumnCheck(); + columnCheckAggProductId.setName("Database Column Check PRODUCT_ID (AGG_C_SPECIAL_SALES_FACT_1997)"); + columnCheckAggProductId.setColumnName("PRODUCT_ID"); + columnCheckAggProductId.getColumnAttributeChecks().add(columnAggProductIdTypeCheck); + + DatabaseColumnAttributeCheck columnStoreCostSumTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnStoreCostSumTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnStoreCostSumTypeCheck.setExpectedValue("DECIMAL"); + + DatabaseColumnCheck columnCheckStoreCostSum = factory.createDatabaseColumnCheck(); + columnCheckStoreCostSum.setName("Database Column Check STORE_COST_SUM"); + columnCheckStoreCostSum.setColumnName("STORE_COST_SUM"); + columnCheckStoreCostSum.getColumnAttributeChecks().add(columnStoreCostSumTypeCheck); + + DatabaseColumnAttributeCheck columnFactCountTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFactCountTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFactCountTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactCount = factory.createDatabaseColumnCheck(); + columnCheckFactCount.setName("Database Column Check FACT_COUNT"); + columnCheckFactCount.setColumnName("FACT_COUNT"); + columnCheckFactCount.getColumnAttributeChecks().add(columnFactCountTypeCheck); + + DatabaseTableCheck databaseTableCheckAggCSpecial = factory.createDatabaseTableCheck(); + databaseTableCheckAggCSpecial.setName("Database Table AGG_C_SPECIAL_SALES_FACT_1997 Check"); + databaseTableCheckAggCSpecial.setTableName("AGG_C_SPECIAL_SALES_FACT_1997"); + databaseTableCheckAggCSpecial.getColumnChecks().add(columnCheckAggProductId); + databaseTableCheckAggCSpecial.getColumnChecks().add(columnCheckStoreCostSum); + databaseTableCheckAggCSpecial.getColumnChecks().add(columnCheckFactCount); + + // Create table checks for excluded aggregation tables (without column checks) + DatabaseTableCheck databaseTableCheckAggC14 = factory.createDatabaseTableCheck(); + databaseTableCheckAggC14.setName("Database Table AGG_C_14_SALES_FACT_1997 Check"); + databaseTableCheckAggC14.setTableName("AGG_C_14_SALES_FACT_1997"); + + DatabaseTableCheck databaseTableCheckAggLC100 = factory.createDatabaseTableCheck(); + databaseTableCheckAggLC100.setName("Database Table AGG_LC_100_SALES_FACT_1997 Check"); + databaseTableCheckAggLC100.setTableName("AGG_LC_100_SALES_FACT_1997"); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Aggregation Aggregate Tables"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckSalesFact1997); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckProduct); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckProductClass); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckAggCSpecial); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckAggC14); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckAggLC100); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Aggregation Aggregate Tables"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Aggregation Aggregate Tables' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Aggregation Aggregate Tables"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Aggregation Aggregate Tables"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Aggregation Aggregate Tables"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Aggregation Aggregate Tables"); + suite.setDescription("Check suite for the Daanse Tutorial - Aggregation Aggregate Tables"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/CheckSuiteSupplier.java new file mode 100644 index 00000000..504a0d4d --- /dev/null +++ b/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/CheckSuiteSupplier.java @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.calculatedmember.color; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureSumCheck = factory.createMeasureCheck(); + measureSumCheck.setName("MeasureCheck-Measure-Sum"); + measureSumCheck.setDescription("Check that measure 'Measure-Sum' exists"); + measureSumCheck.setMeasureName("Measure-Sum"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + MeasureAttributeCheck measureSumAttributeCheckFormat = factory.createMeasureAttributeCheck(); + measureSumAttributeCheckFormat.setAttributeType(MeasureAttribute.FORMAT_STRING); + measureSumAttributeCheckFormat.setExpectedValue("$#,##0.00;BACK_COLOR=32768;FORE_COLOR=0"); + + measureSumCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + measureSumCheck.getMeasureAttributeChecks().add(measureSumAttributeCheckFormat); + + MeasureCheck measureCountCheck = factory.createMeasureCheck(); + measureCountCheck.setName("MeasureCheck-Measure-Count"); + measureCountCheck.setDescription("Check that measure 'Measure-Count' exists"); + measureCountCheck.setMeasureName("Measure-Count"); + + MeasureAttributeCheck measureCountAttributeCheck = factory.createMeasureAttributeCheck(); + measureCountAttributeCheck.setExpectedAggregator(AggregatorType.COUNT); + + MeasureAttributeCheck measureCountAttributeCheckFormat = factory.createMeasureAttributeCheck(); + measureCountAttributeCheckFormat.setAttributeType(MeasureAttribute.FORMAT_STRING); + measureCountAttributeCheckFormat.setExpectedValue("$#,##0.00;BACK_COLOR=16711680;FORE_COLOR=0"); + + measureCountCheck.getMeasureAttributeChecks().add(measureCountAttributeCheck); + measureCountCheck.getMeasureAttributeChecks().add(measureCountAttributeCheckFormat); + + MeasureCheck measureCheckCalculatedMember1 = factory.createMeasureCheck(); + measureCheckCalculatedMember1.setName("MemberCheck-Calculated Member 1"); + measureCheckCalculatedMember1.setMeasureName("Calculated Member 1"); + measureCheckCalculatedMember1.setMeasureUniqueName("[Measures].[Calculated Member 1]"); + + MeasureAttributeCheck calculatedMember1AttributeCheckFormat = factory.createMeasureAttributeCheck(); + calculatedMember1AttributeCheckFormat.setAttributeType(MeasureAttribute.FORMAT_STRING); + calculatedMember1AttributeCheckFormat.setExpectedValue("$#,##0.00;BACK_COLOR=65535;FORE_COLOR=13369395"); + + measureCheckCalculatedMember1.getMeasureAttributeChecks().add(calculatedMember1AttributeCheckFormat); + + MeasureCheck measureCheckCalculatedMember2 = factory.createMeasureCheck(); + measureCheckCalculatedMember2.setName("MemberCheck-Calculated Member 2"); + measureCheckCalculatedMember2.setMeasureName("Calculated Member 2"); + measureCheckCalculatedMember2.setMeasureUniqueName("[Measures].[Calculated Member 2]"); + + MeasureAttributeCheck calculatedMember2AttributeCheckFormat = factory.createMeasureAttributeCheck(); + calculatedMember2AttributeCheckFormat.setAttributeType(MeasureAttribute.FORMAT_STRING); + calculatedMember2AttributeCheckFormat.setExpectedValue("$#,##;BACK_COLOR=255;FORE_COLOR=13369395"); + + measureCheckCalculatedMember2.getMeasureAttributeChecks().add(calculatedMember2AttributeCheckFormat); + + // Create Level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("levelCheck for theLevel"); + levelCheck.setLevelName("theLevel"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for theHierarchy"); + hierarchyCheck.setHierarchyName("theHierarchy"); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for theDimension"); + dimensionCheck.setDimensionName("theDimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube CalculatedMember with different colors"); + cubeCheck.setDescription("Check that cube 'Cube CalculatedMember with different colors' exists with its measures"); + cubeCheck.setCubeName("Cube CalculatedMember with different colors"); + cubeCheck.getMeasureChecks().add(measureSumCheck); + cubeCheck.getMeasureChecks().add(measureCountCheck); + cubeCheck.getMeasureChecks().add(measureCheckCalculatedMember1); + cubeCheck.getMeasureChecks().add(measureCheckCalculatedMember2); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Measure-Sum]"); + queryCheck1CellValueCheck.setExpectedValue("84"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Measure-Sum"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Measure-Sum"); + queryCheck1.setQuery("SELECT FROM [Cube CalculatedMember with different colors] WHERE ([Measures].[Measure-Sum])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Measure-Count]"); + queryCheck2CellValueCheck.setExpectedValue("84"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Measure-Count"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Measure-Count"); + queryCheck2.setQuery("SELECT FROM [Cube CalculatedMember with different colors] WHERE ([Measures].[Measure-Count])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[Calculated Member 1]"); + queryCheck3CellValueCheck.setExpectedValue("84"); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check Calculated Member 1"); + queryCheck3.setDescription("Verify MDX query returns Measure data for Calculated Member 1"); + queryCheck3.setQuery("SELECT FROM [Cube CalculatedMember with different colors] WHERE ([Measures].[Calculated Member 1])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + CellValueCheck queryCheck4CellValueCheck = factory.createCellValueCheck(); + queryCheck4CellValueCheck.setName("[Measures].[Calculated Member 2]"); + queryCheck4CellValueCheck.setExpectedValue("84"); + + QueryCheck queryCheck4 = factory.createQueryCheck(); + queryCheck4.setName("Measure Query Check Calculated Member 2"); + queryCheck4.setDescription("Verify MDX query returns Measure data for Calculated Member 2"); + queryCheck4.setQuery("SELECT FROM [Cube CalculatedMember with different colors] WHERE ([Measures].[Calculated Member 2])"); + queryCheck4.setQueryLanguage(QueryLanguage.MDX); + queryCheck4.setExpectedColumnCount(1); + queryCheck4.getCellChecks().add(queryCheck4CellValueCheck); + queryCheck4.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check Key"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check Value"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Cube Calculated Member Color catalog check"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Cube Calculated Member Color catalog check"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Cube Calculated Member Color' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Cube Calculated Member Color"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getQueryChecks().add(queryCheck4); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check for Cube CalculatedMember with different colors"); + connectionCheck.setDescription("Connection check for Cube CalculatedMember with different colors"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Cube Calculated Member Color Cube Suite"); + suite.setDescription("Check suite for the Daanse Tutorial - Cube Calculated Member Color"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/calculatedmember.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/intro/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/calculatedmember.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/intro/CheckSuiteSupplier.java new file mode 100644 index 00000000..94221117 --- /dev/null +++ b/instance/emf/tutorial/cube/calculatedmember.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/intro/CheckSuiteSupplier.java @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.calculatedmember.intro; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureSumCheck = factory.createMeasureCheck(); + measureSumCheck.setName("MeasureCheck-Measure-Sum"); + measureSumCheck.setDescription("Check that measure 'Measure-Sum' exists"); + measureSumCheck.setMeasureName("Measure1-Sum"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + measureSumCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + MeasureCheck measureCountCheck = factory.createMeasureCheck(); + measureCountCheck.setName("MeasureCheck-Measure-Count"); + measureCountCheck.setDescription("Check that measure 'Measure-Count' exists"); + measureCountCheck.setMeasureName("Measure2-Count"); + + MeasureAttributeCheck measureCountAttributeCheck = factory.createMeasureAttributeCheck(); + measureCountAttributeCheck.setExpectedAggregator(AggregatorType.COUNT); + + measureCountCheck.getMeasureAttributeChecks().add(measureCountAttributeCheck); + + MeasureCheck measureCheckCalculatedMember1 = factory.createMeasureCheck(); + measureCheckCalculatedMember1.setName("MemberCheck-Calculated Member 1"); + measureCheckCalculatedMember1.setMeasureName("Calculated Member 1"); + measureCheckCalculatedMember1.setMeasureUniqueName("[Measures].[Calculated Member 1]"); + + + MeasureCheck measureCheckCalculatedMember2 = factory.createMeasureCheck(); + measureCheckCalculatedMember2.setName("MemberCheck-Calculated Member 2"); + measureCheckCalculatedMember2.setMeasureName("Calculated Member 2"); + measureCheckCalculatedMember2.setMeasureUniqueName("[Measures].[Calculated Member 2]"); + + // Create Level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("levelCheck for theLevel"); + levelCheck.setLevelName("theLevel"); + + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for theHierarchy"); + hierarchyCheck.setHierarchyName("theHierarchy"); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for theDimension"); + dimensionCheck.setDimensionName("theDimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube CalculatedMember with different colors"); + cubeCheck.setDescription("Check that cube 'Cube CalculatedMember with different colors' exists with its measures"); + cubeCheck.setCubeName("Cube CalculatedMember with different colors"); + cubeCheck.getMeasureChecks().add(measureSumCheck); + cubeCheck.getMeasureChecks().add(measureCountCheck); + cubeCheck.getMeasureChecks().add(measureCheckCalculatedMember1); + cubeCheck.getMeasureChecks().add(measureCheckCalculatedMember2); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Measure-Sum]"); + queryCheck1CellValueCheck.setExpectedValue("63"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Measure-Sum"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Measure-Sum"); + queryCheck1.setQuery("SELECT FROM [Cube CalculatedMember] WHERE ([Measures].[Measure1-Sum])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Measure-Count]"); + queryCheck2CellValueCheck.setExpectedValue("63"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Measure-Count"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Measure-Count"); + queryCheck2.setQuery("SELECT FROM [Cube CalculatedMember] WHERE ([Measures].[Measure2-Count])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[Calculated Member 1]"); + queryCheck3CellValueCheck.setExpectedValue("63"); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check Calculated Member 1"); + queryCheck3.setDescription("Verify MDX query returns Measure data for Calculated Member 1"); + queryCheck3.setQuery("SELECT FROM [Cube CalculatedMember] WHERE ([Measures].[Calculated Member 1])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + CellValueCheck queryCheck4CellValueCheck = factory.createCellValueCheck(); + queryCheck4CellValueCheck.setName("[Measures].[Calculated Member 2]"); + queryCheck4CellValueCheck.setExpectedValue("63"); + + QueryCheck queryCheck4 = factory.createQueryCheck(); + queryCheck4.setName("Measure Query Check Calculated Member 2"); + queryCheck4.setDescription("Verify MDX query returns Measure data for Calculated Member 2"); + queryCheck4.setQuery("SELECT FROM [Cube CalculatedMember] WHERE ([Measures].[Calculated Member 2])"); + queryCheck4.setQueryLanguage(QueryLanguage.MDX); + queryCheck4.setExpectedColumnCount(1); + queryCheck4.getCellChecks().add(queryCheck4CellValueCheck); + queryCheck4.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check Key"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check Value"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Cube Calculated Member Color catalog check"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Calculated Member Intro catalog check"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Calculated Member Intro' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Calculated Member Intro"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getQueryChecks().add(queryCheck4); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Calculated Member Intro"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Calculated Member Intro tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Calculated Member Intro"); + suite.setDescription("Check suite for the Daanse Tutorial - Calculated Member Intro"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/calculatedmember.property/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/property/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/calculatedmember.property/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/property/CheckSuiteSupplier.java new file mode 100644 index 00000000..35a8e929 --- /dev/null +++ b/instance/emf/tutorial/cube/calculatedmember.property/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/property/CheckSuiteSupplier.java @@ -0,0 +1,230 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.calculatedmember.property; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureSumCheck = factory.createMeasureCheck(); + measureSumCheck.setName("MeasureCheck-Measure-Sum"); + measureSumCheck.setDescription("Check that measure 'Measure-Sum' exists"); + measureSumCheck.setMeasureName("Measure-Sum"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + measureSumCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + + MeasureCheck measureCountCheck = factory.createMeasureCheck(); + measureCountCheck.setName("MeasureCheck-Measure-Count"); + measureCountCheck.setDescription("Check that measure 'Measure-Count' exists"); + measureCountCheck.setMeasureName("Measure-Count"); + + MeasureAttributeCheck measureCountAttributeCheck = factory.createMeasureAttributeCheck(); + measureCountAttributeCheck.setExpectedAggregator(AggregatorType.COUNT); + + measureCountCheck.getMeasureAttributeChecks().add(measureCountAttributeCheck); + + MeasureAttributeCheck calculatedMember1AttributeCheckFormat = factory.createMeasureAttributeCheck(); + calculatedMember1AttributeCheckFormat.setAttributeType(MeasureAttribute.FORMAT_STRING); + calculatedMember1AttributeCheckFormat.setExpectedValue("$#,##0.00"); + + MeasureCheck measureCheckCalculatedMember1 = factory.createMeasureCheck(); + measureCheckCalculatedMember1.setName("MemberCheck-Calculated Member 1"); + measureCheckCalculatedMember1.setMeasureName("Calculated Member 1"); + measureCheckCalculatedMember1.setMeasureUniqueName("[Measures].[Calculated Member 1]"); + measureCheckCalculatedMember1.getMeasureAttributeChecks().add(calculatedMember1AttributeCheckFormat); + + MeasureCheck measureCheckCalculatedMember2 = factory.createMeasureCheck(); + measureCheckCalculatedMember2.setName("MemberCheck-Calculated Member 2"); + measureCheckCalculatedMember2.setMeasureName("Calculated Member 2"); + measureCheckCalculatedMember2.setMeasureUniqueName("[Measures].[Calculated Member 2]"); + + // Create Level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("levelCheck for theLevel"); + levelCheck.setLevelName("theLevel"); + + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for theHierarchy"); + hierarchyCheck.setHierarchyName("theHierarchy"); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for theDimension"); + dimensionCheck.setDimensionName("theDimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube CalculatedMember with properties"); + cubeCheck.setDescription("Check that cube 'Cube CalculatedMember with properties' exists with its measures"); + cubeCheck.setCubeName("Cube CalculatedMember with properties"); + cubeCheck.getMeasureChecks().add(measureSumCheck); + cubeCheck.getMeasureChecks().add(measureCountCheck); + cubeCheck.getMeasureChecks().add(measureCheckCalculatedMember1); + cubeCheck.getMeasureChecks().add(measureCheckCalculatedMember2); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Measure-Sum]"); + queryCheck1CellValueCheck.setExpectedValue("84"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Measure-Sum"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Measure-Sum"); + queryCheck1.setQuery("SELECT FROM [Cube CalculatedMember with properties] WHERE ([Measures].[Measure-Sum])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Measure-Count]"); + queryCheck2CellValueCheck.setExpectedValue("84"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Measure-Count"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Measure-Count"); + queryCheck2.setQuery("SELECT FROM [Cube CalculatedMember with properties] WHERE ([Measures].[Measure-Count])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[Calculated Member 1]"); + queryCheck3CellValueCheck.setExpectedValue("84"); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check Calculated Member 1"); + queryCheck3.setDescription("Verify MDX query returns Measure data for Calculated Member 1"); + queryCheck3.setQuery("SELECT FROM [Cube CalculatedMember with properties] WHERE ([Measures].[Calculated Member 1])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + CellValueCheck queryCheck4CellValueCheck = factory.createCellValueCheck(); + queryCheck4CellValueCheck.setName("[Measures].[Calculated Member 2]"); + queryCheck4CellValueCheck.setExpectedValue("84"); + + QueryCheck queryCheck4 = factory.createQueryCheck(); + queryCheck4.setName("Measure Query Check Calculated Member 2"); + queryCheck4.setDescription("Verify MDX query returns Measure data for Calculated Member 2"); + queryCheck4.setQuery("SELECT FROM [Cube CalculatedMember with properties] WHERE ([Measures].[Calculated Member 2])"); + queryCheck4.setQueryLanguage(QueryLanguage.MDX); + queryCheck4.setExpectedColumnCount(1); + queryCheck4.getCellChecks().add(queryCheck4CellValueCheck); + queryCheck4.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check Key"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check Value"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Cube Calculated Member Property catalog check"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("\"Daanse Tutorial - Cube Calculated Member Property catalog check"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Cube Calculated Member Property' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Cube Calculated Member Property"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getQueryChecks().add(queryCheck4); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Cube Calculated Member Property"); + connectionCheck.setDescription("Connection check for \"Daanse Tutorial - Cube Calculated Member Property tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Cube Calculated Member Property"); + suite.setDescription("Check suite for the Daanse Tutorial - Cube Calculated Member Property"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/dimension.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/dimension/intro/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/dimension.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/dimension/intro/CheckSuiteSupplier.java new file mode 100644 index 00000000..663109f1 --- /dev/null +++ b/instance/emf/tutorial/cube/dimension.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/dimension/intro/CheckSuiteSupplier.java @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.dimension.intro; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck theMeasureCheck = factory.createMeasureCheck(); + theMeasureCheck.setName("MeasureCheck-theMeasure"); + theMeasureCheck.setDescription("Check that measure 'theMeasure' exists"); + theMeasureCheck.setMeasureName("theMeasure"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + theMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + // Create Level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("levelCheck for theLevel"); + levelCheck.setLevelName("theLevel"); + + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(false); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for theHierarchy"); + hierarchyCheck.setHierarchyName("theHierarchy"); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for theDimension"); + dimensionCheck.setDimensionName("theDimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-CubeWithSimpleDimension"); + cubeCheck.setDescription("Check that cube 'CubeWithSimpleDimension' exists with its measures"); + cubeCheck.setCubeName("CubeWithSimpleDimension"); + cubeCheck.getMeasureChecks().add(theMeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Measure-Sum]"); + queryCheck1CellValueCheck.setExpectedValue("378"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Measure-Sum"); + queryCheck1.setDescription("Verify MDX query returns Measure data for theMeasure"); + queryCheck1.setQuery("SELECT FROM [CubeWithSimpleDimension] WHERE ([Measures].[theMeasure])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check Key"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check Value"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Dimension Intro catalog check"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Dimension Intro catalog check"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Dimension Intro' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Cube Calculated Member Property"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Dimension Intro"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Dimension Intro tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Dimension Intro"); + suite.setDescription("Check suite for the Daanse Tutorial - Dimension Intro"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/hierarchy.hasall/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/hasall/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/hierarchy.hasall/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/hasall/CheckSuiteSupplier.java new file mode 100644 index 00000000..d4cf31d4 --- /dev/null +++ b/instance/emf/tutorial/cube/hierarchy.hasall/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/hasall/CheckSuiteSupplier.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.hierarchy.hasall; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck theMeasureCheck = factory.createMeasureCheck(); + theMeasureCheck.setName("MeasureCheck-theMeasure"); + theMeasureCheck.setDescription("Check that measure 'theMeasure' exists"); + theMeasureCheck.setMeasureName("theMeasure"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + theMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + // Create Level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("levelCheck for theLevel"); + levelCheck.setLevelName("theLevel"); + + HierarchyAttributeCheck hierarchyHasAllAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyHasAllAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyHasAllAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyHasAllCheck = factory.createHierarchyCheck(); + hierarchyHasAllCheck.setName("HierarchyCheck for Hierarchy - with HasAll"); + hierarchyHasAllCheck.setHierarchyName("Hierarchy - with HasAll"); + hierarchyHasAllCheck.getHierarchyAttributeChecks().add(hierarchyHasAllAttributeCheck); + hierarchyHasAllCheck.getLevelChecks().add(levelCheck); + + HierarchyAttributeCheck hierarchyHasAllAndNamesAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyHasAllAndNamesAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyHasAllAndNamesAttributeCheck.setExpectedBoolean(true); + + HierarchyAttributeCheck hierarchyHasAllAndNamesAttributeCheck1 = factory.createHierarchyAttributeCheck(); + hierarchyHasAllAndNamesAttributeCheck1.setAttributeType(HierarchyAttribute.ALL_MEMBER_NAME); + hierarchyHasAllAndNamesAttributeCheck1.setExpectedValue("theAllMemberName"); + + // Create hierarchy check + HierarchyCheck hierarchyHasAllAndNamesCheck = factory.createHierarchyCheck(); + hierarchyHasAllAndNamesCheck.setName("HierarchyCheck for Hierarchy - with HasAll and Names"); + hierarchyHasAllAndNamesCheck.setHierarchyName("Hierarchy - with HasAll and Names"); + hierarchyHasAllAndNamesCheck.getHierarchyAttributeChecks().add(hierarchyHasAllAndNamesAttributeCheck); + hierarchyHasAllAndNamesCheck.getHierarchyAttributeChecks().add(hierarchyHasAllAndNamesAttributeCheck1); + hierarchyHasAllAndNamesCheck.getLevelChecks().add(levelCheck); + + HierarchyAttributeCheck hierarchyWithoutHasAllAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyWithoutHasAllAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyWithoutHasAllAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyWithoutHasAllCheck = factory.createHierarchyCheck(); + hierarchyWithoutHasAllCheck.setName("HierarchyCheck for Hierarchy - Without HasAll"); + hierarchyWithoutHasAllCheck.setHierarchyName("Hierarchy - Without HasAll"); + hierarchyWithoutHasAllCheck.getHierarchyAttributeChecks().add(hierarchyWithoutHasAllAttributeCheck); + hierarchyWithoutHasAllCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for Dimension1"); + dimensionCheck.setDimensionName("Dimension1"); + dimensionCheck.getHierarchyChecks().add(hierarchyHasAllCheck); + dimensionCheck.getHierarchyChecks().add(hierarchyHasAllAndNamesCheck); + dimensionCheck.getHierarchyChecks().add(hierarchyWithoutHasAllCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-HasAll Cube"); + cubeCheck.setDescription("Check that cube 'HasAll Cube' exists hierarchy with has all true"); + cubeCheck.setCubeName("HasAll Cube"); + cubeCheck.getMeasureChecks().add(theMeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[theMeasure]"); + queryCheck1CellValueCheck.setExpectedValue("378"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Measure-Sum"); + queryCheck1.setDescription("Verify MDX query returns Measure data for theMeasure"); + queryCheck1.setQuery("SELECT FROM [HasAll Cube] WHERE ([Measures].[theMeasure])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check Key"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check Value"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Dimension Intro catalog check"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Dimension Intro catalog check"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Dimension Intro' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Cube Calculated Member Property"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Hierarchy Has All"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Hierarchy Has All tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Hierarchy Has All"); + suite.setDescription("Check suite for the Daanse Tutorial - Hierarchy Has All"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/hierarchy.query.join.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/join/base/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/hierarchy.query.join.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/join/base/CheckSuiteSupplier.java new file mode 100644 index 00000000..a12e784c --- /dev/null +++ b/instance/emf/tutorial/cube/hierarchy.query.join.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/join/base/CheckSuiteSupplier.java @@ -0,0 +1,227 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.hierarchy.query.join.base; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck theMeasureCheck = factory.createMeasureCheck(); + theMeasureCheck.setName("MeasureCheck-theMeasure"); + theMeasureCheck.setDescription("Check that measure 'theMeasure' exists"); + theMeasureCheck.setMeasureName("theMeasure"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + theMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + // Create Level check + LevelCheck levelTownCheck = factory.createLevelCheck(); + levelTownCheck.setName("levelCheck for Town"); + levelTownCheck.setLevelName("Town"); + + LevelCheck levelCountryCheck = factory.createLevelCheck(); + levelCountryCheck.setName("levelCheck for County"); + levelCountryCheck.setLevelName("County"); + + HierarchyAttributeCheck hierarchyTownHasAllAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyTownHasAllAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyTownHasAllAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyTownCheck = factory.createHierarchyCheck(); + hierarchyTownCheck.setName("HierarchyCheck for TownHierarchy"); + hierarchyTownCheck.setHierarchyName("TownHierarchy"); + hierarchyTownCheck.getHierarchyAttributeChecks().add(hierarchyTownHasAllAttributeCheck); + hierarchyTownCheck.getLevelChecks().add(levelTownCheck); + hierarchyTownCheck.getLevelChecks().add(levelCountryCheck); + + + // Create dimension check + DimensionCheck dimensionTownCheck = factory.createDimensionCheck(); + dimensionTownCheck.setName("DimensionCheck for Town"); + dimensionTownCheck.setDimensionName("Town"); + dimensionTownCheck.getHierarchyChecks().add(hierarchyTownCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube Query linked Tables"); + cubeCheck.setDescription("Check that cube 'Cube Query linked Tables' exists"); + cubeCheck.setCubeName("Cube Query linked Tables"); + cubeCheck.getMeasureChecks().add(theMeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionTownCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[theMeasure]"); + queryCheck1CellValueCheck.setExpectedValue("378"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check theMeasure"); + queryCheck1.setDescription("Verify MDX query returns Measure data for theMeasure"); + queryCheck1.setQuery("SELECT FROM [Cube Query linked Tables] WHERE ([Measures].[theMeasure])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckFactTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactTownId = factory.createDatabaseColumnCheck(); + columnCheckFactTownId.setName("Database Column Check TOWN_ID"); + columnCheckFactTownId.setColumnName("TOWN_ID"); + columnCheckFactTownId.getColumnAttributeChecks().add(columnAttributeCheckFactTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckFactValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check Value"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnAttributeCheckFactValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableFactCheck = factory.createDatabaseTableCheck(); + databaseTableFactCheck.setName("Database Table Fact Check"); + databaseTableFactCheck.setTableName("Fact"); + databaseTableFactCheck.getColumnChecks().add(columnCheckFactTownId); + databaseTableFactCheck.getColumnChecks().add(columnCheckFactValue); + + + DatabaseColumnAttributeCheck columnAttributeCheckTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownId = factory.createDatabaseColumnCheck(); + columnCheckTownId.setName("Database Column Check Town ID"); + columnCheckTownId.setColumnName("ID"); + columnCheckTownId.getColumnAttributeChecks().add(columnAttributeCheckTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckTownName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownName = factory.createDatabaseColumnCheck(); + columnCheckTownName.setName("Database Column Check Town Name"); + columnCheckTownName.setColumnName("NAME"); + columnCheckTownName.getColumnAttributeChecks().add(columnAttributeCheckTownName); + + DatabaseColumnAttributeCheck columnAttributeCheckTownCountryId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownCountryId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownCountryId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownCountryId = factory.createDatabaseColumnCheck(); + columnCheckTownCountryId.setName("Database Column Check Town Country Id"); + columnCheckTownCountryId.setColumnName("COUNTRY_ID"); + columnCheckTownCountryId.getColumnAttributeChecks().add(columnAttributeCheckTownCountryId); + + // Create Database Table Town Check + DatabaseTableCheck databaseTableTownCheck = factory.createDatabaseTableCheck(); + databaseTableTownCheck.setName("Database Table Town Check"); + databaseTableTownCheck.setTableName("Town"); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownId); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownName); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownCountryId); + + DatabaseColumnAttributeCheck columnAttributeCheckCountryId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckCountryId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckCountryId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckCountryId = factory.createDatabaseColumnCheck(); + columnCheckCountryId.setName("Database Column Check Country ID"); + columnCheckCountryId.setColumnName("ID"); + columnCheckCountryId.getColumnAttributeChecks().add(columnAttributeCheckCountryId); + + DatabaseColumnAttributeCheck columnAttributeCheckCountryName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckCountryName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckCountryName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckCountryName = factory.createDatabaseColumnCheck(); + columnCheckCountryName.setName("Database Column Check Country Name"); + columnCheckCountryName.setColumnName("NAME"); + columnCheckCountryName.getColumnAttributeChecks().add(columnAttributeCheckCountryName); + + // Create Database Table Check + DatabaseTableCheck databaseCountryCheck = factory.createDatabaseTableCheck(); + databaseCountryCheck.setName("Database Table Country Check"); + databaseCountryCheck.setTableName("Country"); + databaseCountryCheck.getColumnChecks().add(columnCheckCountryId); + databaseCountryCheck.getColumnChecks().add(columnCheckCountryName); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Hierarchy Query Join Base"); + databaseSchemaCheck.getTableChecks().add(databaseTableFactCheck); + databaseSchemaCheck.getTableChecks().add(databaseCountryCheck); + databaseSchemaCheck.getTableChecks().add(databaseTableTownCheck); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Hierarchy Query Join Base"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Hierarchy Query Join Base' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Hierarchy Query Join Base"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Hierarchy Query Join Base"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Hierarchy Query Join Base"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Hierarchy Query Join Base"); + suite.setDescription("Check suite for the Daanse Tutorial - Hierarchy Query Join Base"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/hierarchy.query.join.multi/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/join/multi/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/hierarchy.query.join.multi/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/join/multi/CheckSuiteSupplier.java new file mode 100644 index 00000000..145f38ab --- /dev/null +++ b/instance/emf/tutorial/cube/hierarchy.query.join.multi/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/join/multi/CheckSuiteSupplier.java @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.hierarchy.query.join.multi; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck theMeasureCheck = factory.createMeasureCheck(); + theMeasureCheck.setName("MeasureCheck-theMeasure"); + theMeasureCheck.setDescription("Check that measure 'theMeasure' exists"); + theMeasureCheck.setMeasureName("theMeasure"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + theMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + // Create Level check + LevelCheck levelTownCheck = factory.createLevelCheck(); + levelTownCheck.setName("levelCheck for Town"); + levelTownCheck.setLevelName("Town"); + + LevelCheck levelCountryCheck = factory.createLevelCheck(); + levelCountryCheck.setName("levelCheck for County"); + levelCountryCheck.setLevelName("County"); + + HierarchyAttributeCheck hierarchyTownHasAllAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyTownHasAllAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyTownHasAllAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyTownCheck = factory.createHierarchyCheck(); + hierarchyTownCheck.setName("HierarchyCheck for TownHierarchy"); + hierarchyTownCheck.setHierarchyName("TownHierarchy"); + hierarchyTownCheck.getHierarchyAttributeChecks().add(hierarchyTownHasAllAttributeCheck); + hierarchyTownCheck.getLevelChecks().add(levelTownCheck); + hierarchyTownCheck.getLevelChecks().add(levelCountryCheck); + + + // Create dimension check + DimensionCheck dimensionTownCheck = factory.createDimensionCheck(); + dimensionTownCheck.setName("DimensionCheck for Town"); + dimensionTownCheck.setDimensionName("Town"); + dimensionTownCheck.getHierarchyChecks().add(hierarchyTownCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube Query linked Tables"); + cubeCheck.setDescription("Check that cube 'Cube Query linked Tables' exists"); + cubeCheck.setCubeName("Cube Query linked Tables"); + cubeCheck.getMeasureChecks().add(theMeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionTownCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[theMeasure]"); + queryCheck1CellValueCheck.setExpectedValue("378"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check theMeasure"); + queryCheck1.setDescription("Verify MDX query returns Measure data for theMeasure"); + queryCheck1.setQuery("SELECT FROM [Cube Query linked Tables] WHERE ([Measures].[theMeasure])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckFactTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactTownId = factory.createDatabaseColumnCheck(); + columnCheckFactTownId.setName("Database Column Check TOWN_ID"); + columnCheckFactTownId.setColumnName("TOWN_ID"); + columnCheckFactTownId.getColumnAttributeChecks().add(columnAttributeCheckFactTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckFactValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check Value"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnAttributeCheckFactValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactTownId); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactValue); + + DatabaseColumnAttributeCheck columnAttributeCheckTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownId = factory.createDatabaseColumnCheck(); + columnCheckTownId.setName("Database Column Check Town ID"); + columnCheckTownId.setColumnName("ID"); + columnCheckTownId.getColumnAttributeChecks().add(columnAttributeCheckTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckTownName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownName = factory.createDatabaseColumnCheck(); + columnCheckTownName.setName("Database Column Check Town Name"); + columnCheckTownName.setColumnName("NAME"); + columnCheckTownName.getColumnAttributeChecks().add(columnAttributeCheckTownName); + + DatabaseColumnAttributeCheck columnAttributeCheckTownCountryId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownCountryId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownCountryId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownCountryId = factory.createDatabaseColumnCheck(); + columnCheckTownCountryId.setName("Database Column Check Town Country Id"); + columnCheckTownCountryId.setColumnName("COUNTRY_ID"); + columnCheckTownCountryId.getColumnAttributeChecks().add(columnAttributeCheckTownCountryId); + + // Create Database Table Town Check + DatabaseTableCheck databaseTableTownCheck = factory.createDatabaseTableCheck(); + databaseTableTownCheck.setName("Database Table Town Check"); + databaseTableTownCheck.setTableName("Town"); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownId); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownName); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownCountryId); + + DatabaseColumnAttributeCheck columnAttributeCheckCountryId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckCountryId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckCountryId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckCountryId = factory.createDatabaseColumnCheck(); + columnCheckCountryId.setName("Database Column Check Country ID"); + columnCheckCountryId.setColumnName("ID"); + columnCheckCountryId.getColumnAttributeChecks().add(columnAttributeCheckCountryId); + + DatabaseColumnAttributeCheck columnAttributeCheckCountryName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckCountryName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckCountryName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckCountryName = factory.createDatabaseColumnCheck(); + columnCheckCountryName.setName("Database Column Check Country Name"); + columnCheckCountryName.setColumnName("NAME"); + columnCheckCountryName.getColumnAttributeChecks().add(columnAttributeCheckCountryName); + + DatabaseColumnAttributeCheck columnAttributeCheckCountryContinentId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckCountryContinentId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckCountryContinentId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckCountryContinentId = factory.createDatabaseColumnCheck(); + columnCheckCountryContinentId.setName("Database Column Check Continent ID"); + columnCheckCountryContinentId.setColumnName("CONTINENT_ID"); + columnCheckCountryContinentId.getColumnAttributeChecks().add(columnAttributeCheckCountryContinentId); + + // Create Database Table Check + DatabaseTableCheck databaseTableCountryCheck = factory.createDatabaseTableCheck(); + databaseTableCountryCheck.setName("Database Table Country Check"); + databaseTableCountryCheck.setTableName("Country"); + databaseTableCountryCheck.getColumnChecks().add(columnCheckCountryId); + databaseTableCountryCheck.getColumnChecks().add(columnCheckCountryName); + databaseTableCountryCheck.getColumnChecks().add(columnCheckCountryContinentId); + + DatabaseColumnAttributeCheck columnAttributeCheckContinentId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckContinentId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckContinentId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckContinentId = factory.createDatabaseColumnCheck(); + columnCheckContinentId.setName("Database Column Check Country ID"); + columnCheckContinentId.setColumnName("ID"); + columnCheckContinentId.getColumnAttributeChecks().add(columnAttributeCheckContinentId); + + DatabaseColumnAttributeCheck columnAttributeCheckContinentName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckContinentName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckContinentName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckContinentName = factory.createDatabaseColumnCheck(); + columnCheckContinentName.setName("Database Column Check Continent Name"); + columnCheckContinentName.setColumnName("NAME"); + columnCheckContinentName.getColumnAttributeChecks().add(columnAttributeCheckCountryName); + + // Create Database Table Check + DatabaseTableCheck databaseTableContinentCheck = factory.createDatabaseTableCheck(); + databaseTableContinentCheck.setName("Database Table Continent Check"); + databaseTableContinentCheck.setTableName("Continent"); + databaseTableContinentCheck.getColumnChecks().add(columnCheckContinentId); + databaseTableContinentCheck.getColumnChecks().add(columnCheckContinentName); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Hierarchy Query Join Multi"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCountryCheck); + databaseSchemaCheck.getTableChecks().add(databaseTableTownCheck); + databaseSchemaCheck.getTableChecks().add(databaseTableContinentCheck); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Hierarchy Query Join Base"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Hierarchy Query Join Multi' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Hierarchy Query Join Multi"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Hierarchy Query Join Multi"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Hierarchy Query Join Multi"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Hierarchy Query Join Multi"); + suite.setDescription("Check suite for the Daanse Tutorial - Hierarchy Query Join Multi"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/hierarchy.query.table.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/base/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/hierarchy.query.table.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/base/CheckSuiteSupplier.java new file mode 100644 index 00000000..2ac5d3b8 --- /dev/null +++ b/instance/emf/tutorial/cube/hierarchy.query.table.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/base/CheckSuiteSupplier.java @@ -0,0 +1,194 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.hierarchy.query.table.base; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck theMeasureCheck = factory.createMeasureCheck(); + theMeasureCheck.setName("MeasureCheck-theMeasure"); + theMeasureCheck.setDescription("Check that measure 'theMeasure' exists"); + theMeasureCheck.setMeasureName("theMeasure"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + theMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + // Create Level check + LevelCheck levelTownCheck = factory.createLevelCheck(); + levelTownCheck.setName("levelCheck for Town"); + levelTownCheck.setLevelName("Town"); + + HierarchyAttributeCheck hierarchyTownHasAllAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyTownHasAllAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyTownHasAllAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyTownCheck = factory.createHierarchyCheck(); + hierarchyTownCheck.setName("HierarchyCheck for TownHierarchy"); + hierarchyTownCheck.setHierarchyName("TownHierarchy"); + hierarchyTownCheck.getHierarchyAttributeChecks().add(hierarchyTownHasAllAttributeCheck); + hierarchyTownCheck.getLevelChecks().add(levelTownCheck); + + // Create dimension check + DimensionCheck dimensionTownCheck = factory.createDimensionCheck(); + dimensionTownCheck.setName("DimensionCheck for Town"); + dimensionTownCheck.setDimensionName("Town"); + dimensionTownCheck.getHierarchyChecks().add(hierarchyTownCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube Query linked Tables"); + cubeCheck.setDescription("Check that cube 'Cube Query linked Tables' exists"); + cubeCheck.setCubeName("Cube Query linked Tables"); + cubeCheck.getMeasureChecks().add(theMeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionTownCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[theMeasure]"); + queryCheck1CellValueCheck.setExpectedValue("378"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check theMeasure"); + queryCheck1.setDescription("Verify MDX query returns Measure data for theMeasure"); + queryCheck1.setQuery("SELECT FROM [Cube Query linked Tables] WHERE ([Measures].[theMeasure])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckFactTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactTownId = factory.createDatabaseColumnCheck(); + columnCheckFactTownId.setName("Database Column Check TOWN_ID"); + columnCheckFactTownId.setColumnName("TOWN_ID"); + columnCheckFactTownId.getColumnAttributeChecks().add(columnAttributeCheckFactTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckFactValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check Value"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnAttributeCheckFactValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactTownId); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactValue); + + DatabaseColumnAttributeCheck columnAttributeCheckTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownId = factory.createDatabaseColumnCheck(); + columnCheckTownId.setName("Database Column Check Town ID"); + columnCheckTownId.setColumnName("ID"); + columnCheckTownId.getColumnAttributeChecks().add(columnAttributeCheckTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckTownName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownName = factory.createDatabaseColumnCheck(); + columnCheckTownName.setName("Database Column Check Town Name"); + columnCheckTownName.setColumnName("NAME"); + columnCheckTownName.getColumnAttributeChecks().add(columnAttributeCheckTownName); + + DatabaseColumnAttributeCheck columnAttributeCheckTownCountryId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownCountryId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownCountryId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownCountryId = factory.createDatabaseColumnCheck(); + columnCheckTownCountryId.setName("Database Column Check Town Country Id"); + columnCheckTownCountryId.setColumnName("COUNTRY_ID"); + columnCheckTownCountryId.getColumnAttributeChecks().add(columnAttributeCheckTownCountryId); + + // Create Database Table Town Check + DatabaseTableCheck databaseTableTownCheck = factory.createDatabaseTableCheck(); + databaseTableTownCheck.setName("Database Table Town Check"); + databaseTableTownCheck.setTableName("Town"); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownId); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownName); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownCountryId); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Hierarchy Query Join Multi"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableTownCheck); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Hierarchy Query Table Base"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Hierarchy Query Table Base' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Hierarchy Query Table Base"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Hierarchy Query Table Base"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Hierarchy Query Table Base"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Hierarchy Query Table Base"); + suite.setDescription("Check suite for the Daanse Tutorial - Hierarchy Query Table Base"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/hierarchy.query.table.multilevel.multitable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/multilevel/multitable/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/hierarchy.query.table.multilevel.multitable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/multilevel/multitable/CheckSuiteSupplier.java new file mode 100644 index 00000000..237b3085 --- /dev/null +++ b/instance/emf/tutorial/cube/hierarchy.query.table.multilevel.multitable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/multilevel/multitable/CheckSuiteSupplier.java @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.hierarchy.query.table.multilevel.multitable; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck theMeasureCheck = factory.createMeasureCheck(); + theMeasureCheck.setName("MeasureCheck-theMeasure"); + theMeasureCheck.setDescription("Check that measure 'theMeasure' exists"); + theMeasureCheck.setMeasureName("theMeasure"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + theMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + // Create Level check + LevelCheck levelTownCheck = factory.createLevelCheck(); + levelTownCheck.setName("levelCheck for Town"); + levelTownCheck.setLevelName("Town"); + + LevelCheck levelCountryCheck = factory.createLevelCheck(); + levelCountryCheck.setName("levelCheck for Country"); + levelCountryCheck.setLevelName("Country"); + + HierarchyAttributeCheck hierarchyTownHasAllAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyTownHasAllAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyTownHasAllAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyTownCheck = factory.createHierarchyCheck(); + hierarchyTownCheck.setName("HierarchyCheck for TownHierarchy"); + hierarchyTownCheck.setHierarchyName("TownHierarchy"); + hierarchyTownCheck.getHierarchyAttributeChecks().add(hierarchyTownHasAllAttributeCheck); + hierarchyTownCheck.getLevelChecks().add(levelTownCheck); + hierarchyTownCheck.getLevelChecks().add(levelCountryCheck); + + // Create dimension check + DimensionCheck dimensionTownCheck = factory.createDimensionCheck(); + dimensionTownCheck.setName("DimensionCheck for Town"); + dimensionTownCheck.setDimensionName("Town"); + dimensionTownCheck.getHierarchyChecks().add(hierarchyTownCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube Query linked Tables"); + cubeCheck.setDescription("Check that cube 'Cube Query linked Tables' exists"); + cubeCheck.setCubeName("Cube Query linked Tables"); + cubeCheck.getMeasureChecks().add(theMeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionTownCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[theMeasure]"); + queryCheck1CellValueCheck.setExpectedValue("378"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check theMeasure"); + queryCheck1.setDescription("Verify MDX query returns Measure data for theMeasure"); + queryCheck1.setQuery("SELECT FROM [Cube Query linked Tables] WHERE ([Measures].[theMeasure])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckFactTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactTownId = factory.createDatabaseColumnCheck(); + columnCheckFactTownId.setName("Database Column Check TOWN_ID"); + columnCheckFactTownId.setColumnName("TOWN_ID"); + columnCheckFactTownId.getColumnAttributeChecks().add(columnAttributeCheckFactTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckFactValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check Value"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnAttributeCheckFactValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactTownId); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactValue); + + DatabaseColumnAttributeCheck columnAttributeCheckTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownId = factory.createDatabaseColumnCheck(); + columnCheckTownId.setName("Database Column Check Town ID"); + columnCheckTownId.setColumnName("ID"); + columnCheckTownId.getColumnAttributeChecks().add(columnAttributeCheckTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckTownName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownName = factory.createDatabaseColumnCheck(); + columnCheckTownName.setName("Database Column Check Town Name"); + columnCheckTownName.setColumnName("NAME"); + columnCheckTownName.getColumnAttributeChecks().add(columnAttributeCheckTownName); + + DatabaseColumnAttributeCheck columnAttributeCheckTownCountryId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownCountryId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownCountryId.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownCountry = factory.createDatabaseColumnCheck(); + columnCheckTownCountry.setName("Database Column Check Town Country"); + columnCheckTownCountry.setColumnName("COUNTRY"); + columnCheckTownCountry.getColumnAttributeChecks().add(columnAttributeCheckTownCountryId); + + // Create Database Table Town Check + DatabaseTableCheck databaseTableTownCheck = factory.createDatabaseTableCheck(); + databaseTableTownCheck.setName("Database Table Town Check"); + databaseTableTownCheck.setTableName("Town"); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownId); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownName); + databaseTableTownCheck.getColumnChecks().add(columnCheckTownCountry); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Hierarchy Query Join Multi"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableTownCheck); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Hierarchy Query Table Multilevel Multitable"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Hierarchy Query Table Multilevel Multitable' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Hierarchy Query Table Multilevel Multitable"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Hierarchy Query Table Multilevel Multitable"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Hierarchy Query Table Multilevel Multitable"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Hierarchy Query Table Multilevel Multitable"); + suite.setDescription("Check suite for the Daanse Tutorial - Hierarchy Query Table Multilevel Multitable"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/hierarchy.query.table.multilevel.singletable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/multilevel/singletable/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/hierarchy.query.table.multilevel.singletable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/multilevel/singletable/CheckSuiteSupplier.java new file mode 100644 index 00000000..2890a5db --- /dev/null +++ b/instance/emf/tutorial/cube/hierarchy.query.table.multilevel.singletable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/query/table/multilevel/singletable/CheckSuiteSupplier.java @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.hierarchy.query.table.multilevel.singletable; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck theMeasureCheck = factory.createMeasureCheck(); + theMeasureCheck.setName("MeasureCheck-theMeasure"); + theMeasureCheck.setDescription("Check that measure 'theMeasure' exists"); + theMeasureCheck.setMeasureName("theMeasure"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + theMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + // Create Level check + LevelCheck levelTownCheck = factory.createLevelCheck(); + levelTownCheck.setName("levelCheck for Town"); + levelTownCheck.setLevelName("Town"); + + LevelCheck levelCountryCheck = factory.createLevelCheck(); + levelCountryCheck.setName("levelCheck for Country"); + levelCountryCheck.setLevelName("Country"); + + HierarchyAttributeCheck hierarchyTownHasAllAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyTownHasAllAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyTownHasAllAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyTownCheck = factory.createHierarchyCheck(); + hierarchyTownCheck.setName("HierarchyCheck for TownHierarchy"); + hierarchyTownCheck.setHierarchyName("TownHierarchy"); + hierarchyTownCheck.getHierarchyAttributeChecks().add(hierarchyTownHasAllAttributeCheck); + hierarchyTownCheck.getLevelChecks().add(levelTownCheck); + hierarchyTownCheck.getLevelChecks().add(levelCountryCheck); + + // Create dimension check + DimensionCheck dimensionTownCheck = factory.createDimensionCheck(); + dimensionTownCheck.setName("DimensionCheck for Town"); + dimensionTownCheck.setDimensionName("Town"); + dimensionTownCheck.getHierarchyChecks().add(hierarchyTownCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube Query linked Tables"); + cubeCheck.setDescription("Check that cube 'Cube Query linked Tables' exists"); + cubeCheck.setCubeName("Cube Query linked Tables"); + cubeCheck.getMeasureChecks().add(theMeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionTownCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[theMeasure]"); + queryCheck1CellValueCheck.setExpectedValue("378"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check theMeasure"); + queryCheck1.setDescription("Verify MDX query returns Measure data for theMeasure"); + queryCheck1.setQuery("SELECT FROM [Cube Query linked Tables] WHERE ([Measures].[theMeasure])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckFactTownId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactTownId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactTownId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactTownId = factory.createDatabaseColumnCheck(); + columnCheckFactTownId.setName("Database Column Check TOWN_ID"); + columnCheckFactTownId.setColumnName("TOWN_ID"); + columnCheckFactTownId.getColumnAttributeChecks().add(columnAttributeCheckFactTownId); + + DatabaseColumnAttributeCheck columnAttributeCheckFactValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check Value"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnAttributeCheckFactValue); + + DatabaseColumnAttributeCheck columnAttributeCheckTownCountryId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckTownCountryId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckTownCountryId.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownCountry = factory.createDatabaseColumnCheck(); + columnCheckTownCountry.setName("Database Column Check Town Country"); + columnCheckTownCountry.setColumnName("COUNTRY"); + columnCheckTownCountry.getColumnAttributeChecks().add(columnAttributeCheckTownCountryId); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactTownId); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactValue); + databaseTableCheckFact.getColumnChecks().add(columnCheckTownCountry); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Hierarchy Query Table Multilevel Singletable"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Hierarchy Query Table Multilevel Singletable"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Hierarchy Query Table Multilevel Singletable' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Hierarchy Query Table Multilevel Singletable"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Hierarchy Query Table Multilevel Singletable"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Hierarchy Query Table Multilevel Singletable"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Hierarchy Query Table Multilevel Singletable"); + suite.setDescription("Check suite for the Daanse Tutorial - Hierarchy Query Table Multilevel Singletable"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.aggregator.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/base/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/base/CheckSuiteSupplier.java new file mode 100644 index 00000000..acfc18b5 --- /dev/null +++ b/instance/emf/tutorial/cube/measure.aggregator.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/base/CheckSuiteSupplier.java @@ -0,0 +1,210 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.aggregator.base; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck sumMeasureCheck = factory.createMeasureCheck(); + sumMeasureCheck.setName("MeasureCheck-Sum of Value"); + sumMeasureCheck.setDescription("Check that measure 'Sum of Value' exists"); + sumMeasureCheck.setMeasureName("Sum of Value"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + sumMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + MeasureCheck maxMeasureCheck = factory.createMeasureCheck(); + maxMeasureCheck.setName("MeasureCheck-Max of Value"); + maxMeasureCheck.setDescription("Check that measure 'Max of Value' exists"); + maxMeasureCheck.setMeasureName("Max of Value"); + + MeasureAttributeCheck measureMaxAttributeCheck = factory.createMeasureAttributeCheck(); + measureMaxAttributeCheck.setExpectedAggregator(AggregatorType.MAX); + + maxMeasureCheck.getMeasureAttributeChecks().add(measureMaxAttributeCheck); + + MeasureCheck minMeasureCheck = factory.createMeasureCheck(); + minMeasureCheck.setName("MeasureCheck-Min of Value"); + minMeasureCheck.setDescription("Check that measure 'Min of Value' exists"); + minMeasureCheck.setMeasureName("Min of Value"); + + MeasureAttributeCheck measureMinAttributeCheck = factory.createMeasureAttributeCheck(); + measureMinAttributeCheck.setExpectedAggregator(AggregatorType.MIN); + + minMeasureCheck.getMeasureAttributeChecks().add(measureMinAttributeCheck); + + MeasureCheck avgMeasureCheck = factory.createMeasureCheck(); + minMeasureCheck.setName("MeasureCheck-Avg of Value"); + minMeasureCheck.setDescription("Check that measure 'Avg of Value' exists"); + minMeasureCheck.setMeasureName("Avg of Value"); + + MeasureAttributeCheck measureAvgAttributeCheck = factory.createMeasureAttributeCheck(); + measureAvgAttributeCheck.setExpectedAggregator(AggregatorType.AVG); + + avgMeasureCheck.getMeasureAttributeChecks().add(measureAvgAttributeCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MeasuresAggregatorsCube"); + cubeCheck.setDescription("Check that cube 'MeasuresAggregatorsCube' exists"); + cubeCheck.setCubeName("MeasuresAggregatorsCube"); + cubeCheck.getMeasureChecks().add(sumMeasureCheck); + cubeCheck.getMeasureChecks().add(maxMeasureCheck); + cubeCheck.getMeasureChecks().add(minMeasureCheck); + cubeCheck.getMeasureChecks().add(avgMeasureCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Sum of Value]"); + queryCheck1CellValueCheck.setExpectedValue("63"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Sum of Value"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Sum of Value"); + queryCheck1.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Sum of Value])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Max of Value]"); + queryCheck2CellValueCheck.setExpectedValue("42"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Max of Value"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Max of Value"); + queryCheck2.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Max of Value])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[Min of Value]"); + queryCheck3CellValueCheck.setExpectedValue("21"); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check Min of Value"); + queryCheck3.setDescription("Verify MDX query returns Measure data for Min of Value"); + queryCheck3.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Min of Value])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + CellValueCheck queryCheck4CellValueCheck = factory.createCellValueCheck(); + queryCheck4CellValueCheck.setName("[Measures].[Avg of Value]"); + queryCheck4CellValueCheck.setExpectedValue("31.5"); + + QueryCheck queryCheck4 = factory.createQueryCheck(); + queryCheck4.setName("Measure Query Check Avg of Value"); + queryCheck4.setDescription("Verify MDX query returns Measure data for Avg of Value"); + queryCheck4.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Avg of Value])"); + queryCheck4.setQueryLanguage(QueryLanguage.MDX); + queryCheck4.setExpectedColumnCount(1); + queryCheck4.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck4.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckFactKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactKey.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactKey = factory.createDatabaseColumnCheck(); + columnCheckFactKey.setName("Database Column Check KEY"); + columnCheckFactKey.setColumnName("KEY"); + columnCheckFactKey.getColumnAttributeChecks().add(columnAttributeCheckFactKey); + + DatabaseColumnAttributeCheck columnAttributeCheckFactValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check Value"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnAttributeCheckFactValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Aggregator Base"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Aggregator Base"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Aggregator Base' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Aggregator Base"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getQueryChecks().add(queryCheck4); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Aggregator Base"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Aggregator Base"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Aggregator Base"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Aggregator Base"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.aggregator.bit/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/bit/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.bit/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/bit/CheckSuiteSupplier.java new file mode 100644 index 00000000..04209dbb --- /dev/null +++ b/instance/emf/tutorial/cube/measure.aggregator.bit/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/bit/CheckSuiteSupplier.java @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.aggregator.bit; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal cube mapping. + * Checks that the catalog, cube, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck bitAggAndMeasureCheck = factory.createMeasureCheck(); + bitAggAndMeasureCheck.setName("MeasureCheck-BitAgg AND"); + bitAggAndMeasureCheck.setDescription("Check that measure 'BitAgg AND' exists"); + bitAggAndMeasureCheck.setMeasureName("BitAgg AND"); + + MeasureCheck bitAggOrMeasureCheck = factory.createMeasureCheck(); + bitAggOrMeasureCheck.setName("MeasureCheck-BitAgg OR"); + bitAggOrMeasureCheck.setDescription("Check that measure 'BitAgg OR' exists"); + bitAggOrMeasureCheck.setMeasureName("BitAgg OR"); + + MeasureCheck bitAggXOrMeasureCheck = factory.createMeasureCheck(); + bitAggXOrMeasureCheck.setName("MeasureCheck-BitAgg XOR"); + bitAggXOrMeasureCheck.setDescription("Check that measure 'BitAgg XOR' exists"); + bitAggXOrMeasureCheck.setMeasureName("BitAgg XOR"); + + MeasureCheck bitAggNAndMeasureCheck = factory.createMeasureCheck(); + bitAggNAndMeasureCheck.setName("MeasureCheck-BitAgg NAND"); + bitAggNAndMeasureCheck.setDescription("Check that measure 'BitAgg NAND' exists"); + bitAggNAndMeasureCheck.setMeasureName("BitAgg NAND"); + + + MeasureCheck bitAggNOrMeasureCheck = factory.createMeasureCheck(); + bitAggNOrMeasureCheck.setName("MeasureCheck-BitAgg NOR"); + bitAggNOrMeasureCheck.setDescription("Check that measure 'BitAgg NOR' exists"); + bitAggNOrMeasureCheck.setMeasureName("BitAgg NOR"); + + MeasureCheck bitAggNXOrMeasureCheck = factory.createMeasureCheck(); + bitAggNXOrMeasureCheck.setName("MeasureCheck-BitAgg NXOR"); + bitAggNXOrMeasureCheck.setDescription("Check that measure 'BitAgg NXOR' exists"); + bitAggNXOrMeasureCheck.setMeasureName("BitAgg NXOR"); + + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MeasuresAggregatorsCube"); + cubeCheck.setDescription("Check that cube 'MeasuresAggregatorsCube' exists"); + cubeCheck.setCubeName("MeasuresAggregatorsCube"); + cubeCheck.getMeasureChecks().add(bitAggAndMeasureCheck); + cubeCheck.getMeasureChecks().add(bitAggOrMeasureCheck); + cubeCheck.getMeasureChecks().add(bitAggXOrMeasureCheck); + cubeCheck.getMeasureChecks().add(bitAggNAndMeasureCheck); + cubeCheck.getMeasureChecks().add(bitAggNOrMeasureCheck); + cubeCheck.getMeasureChecks().add(bitAggNXOrMeasureCheck); + + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[BitAgg AND]"); + queryCheck1CellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check BitAgg AND"); + queryCheck1.setDescription("Verify MDX query returns Measure data for BitAgg AND"); + queryCheck1.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[BitAgg AND])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[BitAgg OR]"); + queryCheck2CellValueCheck.setExpectedValue("1"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check BitAgg OR"); + queryCheck2.setDescription("Verify MDX query returns Measure data for BitAgg OR"); + queryCheck2.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[BitAgg OR])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[BitAgg XOR]"); + queryCheck3CellValueCheck.setExpectedValue("1"); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check BitAgg XOR"); + queryCheck3.setDescription("Verify MDX query returns Measure data for BitAgg XOR"); + queryCheck3.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[BitAgg XOR])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + CellValueCheck queryCheck4CellValueCheck = factory.createCellValueCheck(); + queryCheck4CellValueCheck.setName("[Measures].[BitAgg NAND]"); + queryCheck4CellValueCheck.setExpectedValue("1"); + + QueryCheck queryCheck4 = factory.createQueryCheck(); + queryCheck4.setName("Measure Query Check BitAgg NAND"); + queryCheck4.setDescription("Verify MDX query returns Measure data for BitAgg NAND"); + queryCheck4.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[BitAgg NAND])"); + queryCheck4.setQueryLanguage(QueryLanguage.MDX); + queryCheck4.setExpectedColumnCount(1); + queryCheck4.getCellChecks().add(queryCheck4CellValueCheck); + queryCheck4.setEnabled(true); + + CellValueCheck queryCheck5CellValueCheck = factory.createCellValueCheck(); + queryCheck5CellValueCheck.setName("[Measures].[BitAgg NOR]"); + queryCheck5CellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck5 = factory.createQueryCheck(); + queryCheck5.setName("Measure Query Check BitAgg NOR"); + queryCheck5.setDescription("Verify MDX query returns Measure data for BitAgg NOR"); + queryCheck5.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[BitAgg NOR])"); + queryCheck5.setQueryLanguage(QueryLanguage.MDX); + queryCheck5.setExpectedColumnCount(1); + queryCheck5.getCellChecks().add(queryCheck5CellValueCheck); + queryCheck5.setEnabled(true); + + CellValueCheck queryCheck6CellValueCheck = factory.createCellValueCheck(); + queryCheck6CellValueCheck.setName("[Measures].[BitAgg NXOR]"); + queryCheck6CellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck6 = factory.createQueryCheck(); + queryCheck6.setName("Measure Query Check BitAgg NXOR"); + queryCheck6.setDescription("Verify MDX query returns Measure data for BitAgg NXOR"); + queryCheck6.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[BitAgg NXOR])"); + queryCheck6.setQueryLanguage(QueryLanguage.MDX); + queryCheck6.setExpectedColumnCount(1); + queryCheck6.getCellChecks().add(queryCheck6CellValueCheck); + queryCheck6.setEnabled(true); + + DatabaseColumnAttributeCheck columnAttributeCheckFactKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckFactKey = factory.createDatabaseColumnCheck(); + columnCheckFactKey.setName("Database Column Check KEY"); + columnCheckFactKey.setColumnName("KEY"); + columnCheckFactKey.getColumnAttributeChecks().add(columnAttributeCheckFactKey); + + DatabaseColumnAttributeCheck columnAttributeCheckFactValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckFactValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckFactValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check Value"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnAttributeCheckFactValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Aggregator Bit"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Aggregator Base"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Aggregator Bit' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Aggregator Bit"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getQueryChecks().add(queryCheck4); + catalogCheck.getQueryChecks().add(queryCheck5); + catalogCheck.getQueryChecks().add(queryCheck6); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Aggregator Bit"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Aggregator Bit"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Aggregator Bit"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Aggregator Bit"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.aggregator.nth/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/nth/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.nth/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/nth/CheckSuiteSupplier.java new file mode 100644 index 00000000..f4f71b19 --- /dev/null +++ b/instance/emf/tutorial/cube/measure.aggregator.nth/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/nth/CheckSuiteSupplier.java @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.aggregator.nth; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the nth aggregator cube mapping. + * Checks that the catalog, cube, and NthAgg measures exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure checks for NthAgg1 through NthAgg7 + MeasureCheck nthAgg1MeasureCheck = factory.createMeasureCheck(); + nthAgg1MeasureCheck.setName("MeasureCheck-NthAgg1"); + nthAgg1MeasureCheck.setDescription("Check that measure 'NthAgg1' exists"); + nthAgg1MeasureCheck.setMeasureName("NthAgg1"); + + MeasureCheck nthAgg2MeasureCheck = factory.createMeasureCheck(); + nthAgg2MeasureCheck.setName("MeasureCheck-NthAgg2"); + nthAgg2MeasureCheck.setDescription("Check that measure 'NthAgg2' exists"); + nthAgg2MeasureCheck.setMeasureName("NthAgg2"); + + MeasureCheck nthAgg3MeasureCheck = factory.createMeasureCheck(); + nthAgg3MeasureCheck.setName("MeasureCheck-NthAgg3"); + nthAgg3MeasureCheck.setDescription("Check that measure 'NthAgg3' exists"); + nthAgg3MeasureCheck.setMeasureName("NthAgg3"); + + MeasureCheck nthAgg4MeasureCheck = factory.createMeasureCheck(); + nthAgg4MeasureCheck.setName("MeasureCheck-NthAgg4"); + nthAgg4MeasureCheck.setDescription("Check that measure 'NthAgg4' exists"); + nthAgg4MeasureCheck.setMeasureName("NthAgg4"); + + MeasureCheck nthAgg5MeasureCheck = factory.createMeasureCheck(); + nthAgg5MeasureCheck.setName("MeasureCheck-NthAgg5"); + nthAgg5MeasureCheck.setDescription("Check that measure 'NthAgg5' exists"); + nthAgg5MeasureCheck.setMeasureName("NthAgg5"); + + MeasureCheck nthAgg6MeasureCheck = factory.createMeasureCheck(); + nthAgg6MeasureCheck.setName("MeasureCheck-NthAgg6"); + nthAgg6MeasureCheck.setDescription("Check that measure 'NthAgg6' exists"); + nthAgg6MeasureCheck.setMeasureName("NthAgg6"); + + MeasureCheck nthAgg7MeasureCheck = factory.createMeasureCheck(); + nthAgg7MeasureCheck.setName("MeasureCheck-NthAgg7"); + nthAgg7MeasureCheck.setDescription("Check that measure 'NthAgg7' exists"); + nthAgg7MeasureCheck.setMeasureName("NthAgg7"); + + // Create cube check with all measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MeasuresAggregatorsCube"); + cubeCheck.setDescription("Check that cube 'MeasuresAggregatorsCube' exists"); + cubeCheck.setCubeName("MeasuresAggregatorsCube"); + cubeCheck.getMeasureChecks().add(nthAgg1MeasureCheck); + cubeCheck.getMeasureChecks().add(nthAgg2MeasureCheck); + cubeCheck.getMeasureChecks().add(nthAgg3MeasureCheck); + cubeCheck.getMeasureChecks().add(nthAgg4MeasureCheck); + cubeCheck.getMeasureChecks().add(nthAgg5MeasureCheck); + cubeCheck.getMeasureChecks().add(nthAgg6MeasureCheck); + cubeCheck.getMeasureChecks().add(nthAgg7MeasureCheck); + + // Create query checks for each NthAgg measure + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[NthAgg1]"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check NthAgg1"); + queryCheck1.setDescription("Verify MDX query returns Measure data for NthAgg1"); + queryCheck1.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[NthAgg1])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[NthAgg2]"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check NthAgg2"); + queryCheck2.setDescription("Verify MDX query returns Measure data for NthAgg2"); + queryCheck2.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[NthAgg2])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[NthAgg3]"); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check NthAgg3"); + queryCheck3.setDescription("Verify MDX query returns Measure data for NthAgg3"); + queryCheck3.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[NthAgg3])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + CellValueCheck queryCheck4CellValueCheck = factory.createCellValueCheck(); + queryCheck4CellValueCheck.setName("[Measures].[NthAgg4]"); + + QueryCheck queryCheck4 = factory.createQueryCheck(); + queryCheck4.setName("Measure Query Check NthAgg4"); + queryCheck4.setDescription("Verify MDX query returns Measure data for NthAgg4"); + queryCheck4.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[NthAgg4])"); + queryCheck4.setQueryLanguage(QueryLanguage.MDX); + queryCheck4.setExpectedColumnCount(1); + queryCheck4.getCellChecks().add(queryCheck4CellValueCheck); + queryCheck4.setEnabled(true); + + CellValueCheck queryCheck5CellValueCheck = factory.createCellValueCheck(); + queryCheck5CellValueCheck.setName("[Measures].[NthAgg5]"); + + QueryCheck queryCheck5 = factory.createQueryCheck(); + queryCheck5.setName("Measure Query Check NthAgg5"); + queryCheck5.setDescription("Verify MDX query returns Measure data for NthAgg5"); + queryCheck5.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[NthAgg5])"); + queryCheck5.setQueryLanguage(QueryLanguage.MDX); + queryCheck5.setExpectedColumnCount(1); + queryCheck5.getCellChecks().add(queryCheck5CellValueCheck); + queryCheck5.setEnabled(true); + + CellValueCheck queryCheck6CellValueCheck = factory.createCellValueCheck(); + queryCheck6CellValueCheck.setName("[Measures].[NthAgg6]"); + + QueryCheck queryCheck6 = factory.createQueryCheck(); + queryCheck6.setName("Measure Query Check NthAgg6"); + queryCheck6.setDescription("Verify MDX query returns Measure data for NthAgg6"); + queryCheck6.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[NthAgg6])"); + queryCheck6.setQueryLanguage(QueryLanguage.MDX); + queryCheck6.setExpectedColumnCount(1); + queryCheck6.getCellChecks().add(queryCheck6CellValueCheck); + queryCheck6.setEnabled(true); + + CellValueCheck queryCheck7CellValueCheck = factory.createCellValueCheck(); + queryCheck7CellValueCheck.setName("[Measures].[NthAgg7]"); + + QueryCheck queryCheck7 = factory.createQueryCheck(); + queryCheck7.setName("Measure Query Check NthAgg7"); + queryCheck7.setDescription("Verify MDX query returns Measure data for NthAgg7"); + queryCheck7.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[NthAgg7])"); + queryCheck7.setQueryLanguage(QueryLanguage.MDX); + queryCheck7.setExpectedColumnCount(1); + queryCheck7.getCellChecks().add(queryCheck7CellValueCheck); + queryCheck7.setEnabled(true); + + // Create database column checks for the Fact table + DatabaseColumnAttributeCheck columnAttributeCheckId = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckId.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckId.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckId = factory.createDatabaseColumnCheck(); + columnCheckId.setName("Database Column Check ID"); + columnCheckId.setColumnName("ID"); + columnCheckId.getColumnAttributeChecks().add(columnAttributeCheckId); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + DatabaseColumnAttributeCheck columnAttributeCheckName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckName = factory.createDatabaseColumnCheck(); + columnCheckName.setName("Database Column Check NAME"); + columnCheckName.setColumnName("NAME"); + columnCheckName.getColumnAttributeChecks().add(columnAttributeCheckName); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckId); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + databaseTableCheckFact.getColumnChecks().add(columnCheckName); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Aggregator Nth"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Aggregator Nth"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Aggregator Nth' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Aggregator Nth"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getQueryChecks().add(queryCheck4); + catalogCheck.getQueryChecks().add(queryCheck5); + catalogCheck.getQueryChecks().add(queryCheck6); + catalogCheck.getQueryChecks().add(queryCheck7); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Aggregator Nth"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Aggregator Nth"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Aggregator Nth"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Aggregator Nth"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.aggregator.percentile/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/percentile/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.percentile/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/percentile/CheckSuiteSupplier.java new file mode 100644 index 00000000..1e7e2ba7 --- /dev/null +++ b/instance/emf/tutorial/cube/measure.aggregator.percentile/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/percentile/CheckSuiteSupplier.java @@ -0,0 +1,327 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.aggregator.percentile; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the percentile aggregator cube mapping. + * Checks that the catalog, cube, and percentile measures exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure checks for all percentile measures + MeasureCheck percentileDisc025MeasureCheck = factory.createMeasureCheck(); + percentileDisc025MeasureCheck.setName("MeasureCheck-Percentile disc 0.25"); + percentileDisc025MeasureCheck.setDescription("Check that measure 'Percentile disc 0.25' exists"); + percentileDisc025MeasureCheck.setMeasureName("Percentile disc 0.25"); + + MeasureCheck percentileCont025MeasureCheck = factory.createMeasureCheck(); + percentileCont025MeasureCheck.setName("MeasureCheck-Percentile cont 0.25"); + percentileCont025MeasureCheck.setDescription("Check that measure 'Percentile cont 0.25' exists"); + percentileCont025MeasureCheck.setMeasureName("Percentile cont 0.25"); + + MeasureCheck percentileDisc042MeasureCheck = factory.createMeasureCheck(); + percentileDisc042MeasureCheck.setName("MeasureCheck-Percentile disc 0.42"); + percentileDisc042MeasureCheck.setDescription("Check that measure 'Percentile disc 0.42' exists"); + percentileDisc042MeasureCheck.setMeasureName("Percentile disc 0.42"); + + MeasureCheck percentileCont042MeasureCheck = factory.createMeasureCheck(); + percentileCont042MeasureCheck.setName("MeasureCheck-Percentile cont 0.42"); + percentileCont042MeasureCheck.setDescription("Check that measure 'Percentile cont 0.42' exists"); + percentileCont042MeasureCheck.setMeasureName("Percentile cont 0.42"); + + MeasureCheck percentileDisc05MeasureCheck = factory.createMeasureCheck(); + percentileDisc05MeasureCheck.setName("MeasureCheck-Percentile disc 0.5"); + percentileDisc05MeasureCheck.setDescription("Check that measure 'Percentile disc 0.5' exists"); + percentileDisc05MeasureCheck.setMeasureName("Percentile disc 0.5"); + + MeasureCheck percentileCont05MeasureCheck = factory.createMeasureCheck(); + percentileCont05MeasureCheck.setName("MeasureCheck-Percentile cont 0.5"); + percentileCont05MeasureCheck.setDescription("Check that measure 'Percentile cont 0.5' exists"); + percentileCont05MeasureCheck.setMeasureName("Percentile cont 0.5"); + + MeasureCheck percentileDisc075MeasureCheck = factory.createMeasureCheck(); + percentileDisc075MeasureCheck.setName("MeasureCheck-Percentile disc 0.75"); + percentileDisc075MeasureCheck.setDescription("Check that measure 'Percentile disc 0.75' exists"); + percentileDisc075MeasureCheck.setMeasureName("Percentile disc 0.75"); + + MeasureCheck percentileCont075MeasureCheck = factory.createMeasureCheck(); + percentileCont075MeasureCheck.setName("MeasureCheck-Percentile cont 0.75"); + percentileCont075MeasureCheck.setDescription("Check that measure 'Percentile cont 0.75' exists"); + percentileCont075MeasureCheck.setMeasureName("Percentile cont 0.75"); + + MeasureCheck percentileDisc100MeasureCheck = factory.createMeasureCheck(); + percentileDisc100MeasureCheck.setName("MeasureCheck-Percentile disc 1.00"); + percentileDisc100MeasureCheck.setDescription("Check that measure 'Percentile disc 1.00' exists"); + percentileDisc100MeasureCheck.setMeasureName("Percentile disc 1.00"); + + MeasureCheck percentileCont100MeasureCheck = factory.createMeasureCheck(); + percentileCont100MeasureCheck.setName("MeasureCheck-Percentile cont 1.00"); + percentileCont100MeasureCheck.setDescription("Check that measure 'Percentile cont 1.00' exists"); + percentileCont100MeasureCheck.setMeasureName("Percentile cont 1.00"); + + // Create level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for Level"); + levelCheck.setLevelName("Level"); + + // Create hierarchy attribute check for hasAll + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for Hierarchy"); + hierarchyCheck.setHierarchyName("Hierarchy"); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for Dim"); + dimensionCheck.setDimensionName("Dim"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with all measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MeasuresAggregatorsCube"); + cubeCheck.setDescription("Check that cube 'MeasuresAggregatorsCube' exists"); + cubeCheck.setCubeName("MeasuresAggregatorsCube"); + cubeCheck.getMeasureChecks().add(percentileDisc025MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileCont025MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileDisc042MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileCont042MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileDisc05MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileCont05MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileDisc075MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileCont075MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileDisc100MeasureCheck); + cubeCheck.getMeasureChecks().add(percentileCont100MeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query checks for each percentile measure + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Percentile disc 0.25]"); + queryCheck1CellValueCheck.setExpectedValue(""); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Percentile disc 0.25"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Percentile disc 0.25"); + queryCheck1.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile disc 0.25])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Percentile cont 0.25]"); + queryCheck2CellValueCheck.setExpectedValue(""); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Percentile cont 0.25"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Percentile cont 0.25"); + queryCheck2.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile cont 0.25])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[Percentile disc 0.42]"); + queryCheck3CellValueCheck.setExpectedValue(""); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check Percentile disc 0.42"); + queryCheck3.setDescription("Verify MDX query returns Measure data for Percentile disc 0.42"); + queryCheck3.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile disc 0.42])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + CellValueCheck queryCheck4CellValueCheck = factory.createCellValueCheck(); + queryCheck4CellValueCheck.setName("[Measures].[Percentile cont 0.42]"); + + QueryCheck queryCheck4 = factory.createQueryCheck(); + queryCheck4.setName("Measure Query Check Percentile cont 0.42"); + queryCheck4.setDescription("Verify MDX query returns Measure data for Percentile cont 0.42"); + queryCheck4.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile cont 0.42])"); + queryCheck4.setQueryLanguage(QueryLanguage.MDX); + queryCheck4.setExpectedColumnCount(1); + queryCheck4.getCellChecks().add(queryCheck4CellValueCheck); + queryCheck4.setEnabled(true); + + CellValueCheck queryCheck5CellValueCheck = factory.createCellValueCheck(); + queryCheck5CellValueCheck.setName("[Measures].[Percentile disc 0.5]"); + + QueryCheck queryCheck5 = factory.createQueryCheck(); + queryCheck5.setName("Measure Query Check Percentile disc 0.5"); + queryCheck5.setDescription("Verify MDX query returns Measure data for Percentile disc 0.5"); + queryCheck5.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile disc 0.5])"); + queryCheck5.setQueryLanguage(QueryLanguage.MDX); + queryCheck5.setExpectedColumnCount(1); + queryCheck5.getCellChecks().add(queryCheck5CellValueCheck); + queryCheck5.setEnabled(true); + + CellValueCheck queryCheck6CellValueCheck = factory.createCellValueCheck(); + queryCheck6CellValueCheck.setName("[Measures].[Percentile cont 0.5]"); + + QueryCheck queryCheck6 = factory.createQueryCheck(); + queryCheck6.setName("Measure Query Check Percentile cont 0.5"); + queryCheck6.setDescription("Verify MDX query returns Measure data for Percentile cont 0.5"); + queryCheck6.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile cont 0.5])"); + queryCheck6.setQueryLanguage(QueryLanguage.MDX); + queryCheck6.setExpectedColumnCount(1); + queryCheck6.getCellChecks().add(queryCheck6CellValueCheck); + queryCheck6.setEnabled(true); + + CellValueCheck queryCheck7CellValueCheck = factory.createCellValueCheck(); + queryCheck7CellValueCheck.setName("[Measures].[Percentile disc 0.75]"); + + QueryCheck queryCheck7 = factory.createQueryCheck(); + queryCheck7.setName("Measure Query Check Percentile disc 0.75"); + queryCheck7.setDescription("Verify MDX query returns Measure data for Percentile disc 0.75"); + queryCheck7.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile disc 0.75])"); + queryCheck7.setQueryLanguage(QueryLanguage.MDX); + queryCheck7.setExpectedColumnCount(1); + queryCheck7.getCellChecks().add(queryCheck7CellValueCheck); + queryCheck7.setEnabled(true); + + CellValueCheck queryCheck8CellValueCheck = factory.createCellValueCheck(); + queryCheck8CellValueCheck.setName("[Measures].[Percentile cont 0.75]"); + + QueryCheck queryCheck8 = factory.createQueryCheck(); + queryCheck8.setName("Measure Query Check Percentile cont 0.75"); + queryCheck8.setDescription("Verify MDX query returns Measure data for Percentile cont 0.75"); + queryCheck8.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile cont 0.75])"); + queryCheck8.setQueryLanguage(QueryLanguage.MDX); + queryCheck8.setExpectedColumnCount(1); + queryCheck8.getCellChecks().add(queryCheck8CellValueCheck); + queryCheck8.setEnabled(true); + + CellValueCheck queryCheck9CellValueCheck = factory.createCellValueCheck(); + queryCheck9CellValueCheck.setName("[Measures].[Percentile disc 1.00]"); + + QueryCheck queryCheck9 = factory.createQueryCheck(); + queryCheck9.setName("Measure Query Check Percentile disc 1.00"); + queryCheck9.setDescription("Verify MDX query returns Measure data for Percentile disc 1.00"); + queryCheck9.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile disc 1.00])"); + queryCheck9.setQueryLanguage(QueryLanguage.MDX); + queryCheck9.setExpectedColumnCount(1); + queryCheck9.getCellChecks().add(queryCheck9CellValueCheck); + queryCheck9.setEnabled(true); + + CellValueCheck queryCheck10CellValueCheck = factory.createCellValueCheck(); + queryCheck10CellValueCheck.setName("[Measures].[Percentile cont 1.00]"); + + QueryCheck queryCheck10 = factory.createQueryCheck(); + queryCheck10.setName("Measure Query Check Percentile cont 1.00"); + queryCheck10.setDescription("Verify MDX query returns Measure data for Percentile cont 1.00"); + queryCheck10.setQuery("SELECT FROM [MeasuresAggregatorsCube] WHERE ([Measures].[Percentile cont 1.00])"); + queryCheck10.setQueryLanguage(QueryLanguage.MDX); + queryCheck10.setExpectedColumnCount(1); + queryCheck10.getCellChecks().add(queryCheck10CellValueCheck); + queryCheck10.setEnabled(true); + + // Create database column checks for the Fact table + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Aggregator Percentile"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Aggregator Percentile"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Aggregator Percentile' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Aggregator Percentile"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getQueryChecks().add(queryCheck4); + catalogCheck.getQueryChecks().add(queryCheck5); + catalogCheck.getQueryChecks().add(queryCheck6); + catalogCheck.getQueryChecks().add(queryCheck7); + catalogCheck.getQueryChecks().add(queryCheck8); + catalogCheck.getQueryChecks().add(queryCheck9); + catalogCheck.getQueryChecks().add(queryCheck10); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Aggregator Percentile"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Aggregator Percentile"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Aggregator Percentile"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Aggregator Percentile"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.aggregator.textagg/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/textagg/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.textagg/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/textagg/CheckSuiteSupplier.java new file mode 100644 index 00000000..99116522 --- /dev/null +++ b/instance/emf/tutorial/cube/measure.aggregator.textagg/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/textagg/CheckSuiteSupplier.java @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.aggregator.textagg; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the text aggregator cube mapping. + * Checks that the catalog, cube, and text aggregation measures exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure checks + MeasureCheck sumOfValueMeasureCheck = factory.createMeasureCheck(); + sumOfValueMeasureCheck.setName("MeasureCheck-Sum of Value"); + sumOfValueMeasureCheck.setDescription("Check that measure 'Sum of Value' exists"); + sumOfValueMeasureCheck.setMeasureName("Sum of Value"); + + MeasureAttributeCheck measureSumAttributeCheck = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck.setExpectedAggregator(AggregatorType.SUM); + + sumOfValueMeasureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck); + + MeasureCheck commentMeasureCheck = factory.createMeasureCheck(); + commentMeasureCheck.setName("MeasureCheck-Comment"); + commentMeasureCheck.setDescription("Check that measure 'Comment' exists"); + commentMeasureCheck.setMeasureName("Comment"); + + // Create level checks for Town dimension + LevelCheck levelContinentCheck = factory.createLevelCheck(); + levelContinentCheck.setName("LevelCheck for Continent"); + levelContinentCheck.setLevelName("Continent"); + + LevelCheck levelCountryCheck = factory.createLevelCheck(); + levelCountryCheck.setName("LevelCheck for Country"); + levelCountryCheck.setLevelName("Country"); + + LevelCheck levelTownCheck = factory.createLevelCheck(); + levelTownCheck.setName("LevelCheck for Town"); + levelTownCheck.setLevelName("Town"); + + // Create hierarchy check for Town dimension + HierarchyCheck hierarchyTownCheck = factory.createHierarchyCheck(); + hierarchyTownCheck.setName("HierarchyCheck for TownHierarchy"); + hierarchyTownCheck.setHierarchyName("TownHierarchy"); + hierarchyTownCheck.getLevelChecks().add(levelContinentCheck); + hierarchyTownCheck.getLevelChecks().add(levelCountryCheck); + hierarchyTownCheck.getLevelChecks().add(levelTownCheck); + + // Create dimension check for Town + DimensionCheck dimensionTownCheck = factory.createDimensionCheck(); + dimensionTownCheck.setName("DimensionCheck for Town"); + dimensionTownCheck.setDimensionName("Town"); + dimensionTownCheck.getHierarchyChecks().add(hierarchyTownCheck); + + // Create level checks for Time dimension + LevelCheck levelYearCheck = factory.createLevelCheck(); + levelYearCheck.setName("LevelCheck for Year"); + levelYearCheck.setLevelName("Year"); + + LevelCheck levelMonthCheck = factory.createLevelCheck(); + levelMonthCheck.setName("LevelCheck for Month"); + levelMonthCheck.setLevelName("Month"); + + // Create hierarchy check for Time dimension + HierarchyCheck hierarchyTimeCheck = factory.createHierarchyCheck(); + hierarchyTimeCheck.setName("HierarchyCheck for TimeHierarchy"); + hierarchyTimeCheck.setHierarchyName("TimeHierarchy"); + hierarchyTimeCheck.getLevelChecks().add(levelYearCheck); + hierarchyTimeCheck.getLevelChecks().add(levelMonthCheck); + + // Create dimension check for Time + DimensionCheck dimensionTimeCheck = factory.createDimensionCheck(); + dimensionTimeCheck.setName("DimensionCheck for Time"); + dimensionTimeCheck.setDimensionName("Time"); + dimensionTimeCheck.getHierarchyChecks().add(hierarchyTimeCheck); + + // Create cube check with all measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MeasuresTextAggregatorsCube"); + cubeCheck.setDescription("Check that cube 'MeasuresTextAggregatorsCube' exists"); + cubeCheck.setCubeName("MeasuresTextAggregatorsCube"); + cubeCheck.getMeasureChecks().add(sumOfValueMeasureCheck); + cubeCheck.getMeasureChecks().add(commentMeasureCheck); + cubeCheck.getDimensionChecks().add(dimensionTownCheck); + cubeCheck.getDimensionChecks().add(dimensionTimeCheck); + + // Create query checks for each measure + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Sum of Value]"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Sum of Value"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Sum of Value"); + queryCheck1.setQuery("SELECT FROM [MeasuresTextAggregatorsCube] WHERE ([Measures].[Sum of Value])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Comment]"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Comment"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Comment"); + queryCheck2.setQuery("SELECT FROM [MeasuresTextAggregatorsCube] WHERE ([Measures].[Comment])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + // Create database column checks for the Fact table + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + DatabaseColumnAttributeCheck columnAttributeCheckCountry = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckCountry.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckCountry.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckCountry = factory.createDatabaseColumnCheck(); + columnCheckCountry.setName("Database Column Check COUNTRY"); + columnCheckCountry.setColumnName("COUNTRY"); + columnCheckCountry.getColumnAttributeChecks().add(columnAttributeCheckCountry); + + DatabaseColumnAttributeCheck columnAttributeCheckContinent = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckContinent.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckContinent.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckContinent = factory.createDatabaseColumnCheck(); + columnCheckContinent.setName("Database Column Check CONTINENT"); + columnCheckContinent.setColumnName("CONTINENT"); + columnCheckContinent.getColumnAttributeChecks().add(columnAttributeCheckContinent); + + DatabaseColumnAttributeCheck columnAttributeCheckYear = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckYear.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckYear.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckYear = factory.createDatabaseColumnCheck(); + columnCheckYear.setName("Database Column Check YEAR"); + columnCheckYear.setColumnName("YEAR"); + columnCheckYear.getColumnAttributeChecks().add(columnAttributeCheckYear); + + DatabaseColumnAttributeCheck columnAttributeCheckMonth = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckMonth.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckMonth.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckMonth = factory.createDatabaseColumnCheck(); + columnCheckMonth.setName("Database Column Check MONTH"); + columnCheckMonth.setColumnName("MONTH"); + columnCheckMonth.getColumnAttributeChecks().add(columnAttributeCheckMonth); + + DatabaseColumnAttributeCheck columnAttributeCheckMonthName = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckMonthName.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckMonthName.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckMonthName = factory.createDatabaseColumnCheck(); + columnCheckMonthName.setName("Database Column Check MONTH_NAME"); + columnCheckMonthName.setColumnName("MONTH_NAME"); + columnCheckMonthName.getColumnAttributeChecks().add(columnAttributeCheckMonthName); + + DatabaseColumnAttributeCheck columnAttributeCheckUser = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckUser.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckUser.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckUser = factory.createDatabaseColumnCheck(); + columnCheckUser.setName("Database Column Check USER"); + columnCheckUser.setColumnName("USER"); + columnCheckUser.getColumnAttributeChecks().add(columnAttributeCheckUser); + + DatabaseColumnAttributeCheck columnAttributeCheckComment = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckComment.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckComment.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckComment = factory.createDatabaseColumnCheck(); + columnCheckComment.setName("Database Column Check COMMENT"); + columnCheckComment.setColumnName("COMMENT"); + columnCheckComment.getColumnAttributeChecks().add(columnAttributeCheckComment); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + databaseTableCheckFact.getColumnChecks().add(columnCheckCountry); + databaseTableCheckFact.getColumnChecks().add(columnCheckContinent); + databaseTableCheckFact.getColumnChecks().add(columnCheckYear); + databaseTableCheckFact.getColumnChecks().add(columnCheckMonth); + databaseTableCheckFact.getColumnChecks().add(columnCheckMonthName); + databaseTableCheckFact.getColumnChecks().add(columnCheckUser); + databaseTableCheckFact.getColumnChecks().add(columnCheckComment); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Aggregator Text Agg"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Aggregator Text Agg"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Aggregator Text Agg' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Aggregator Text Agg"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Aggregator Text Agg"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Aggregator Text Agg"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Aggregator Text Agg"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Aggregator Text Agg"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.datatype/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/datatype/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.datatype/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/datatype/CheckSuiteSupplier.java new file mode 100644 index 00000000..6425d590 --- /dev/null +++ b/instance/emf/tutorial/cube/measure.datatype/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/datatype/CheckSuiteSupplier.java @@ -0,0 +1,168 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.datatype; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DataType; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the measure datatype cube mapping. + * Checks that the catalog, cube, and measures with different data types exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check for "Measure - Datatype Integer" with DATA_TYPE attribute check + MeasureAttributeCheck integerDataTypeAttributeCheck = factory.createMeasureAttributeCheck(); + integerDataTypeAttributeCheck.setName("Measure Attribute Check DATA_TYPE INTEGER"); + integerDataTypeAttributeCheck.setAttributeType(MeasureAttribute.DATA_TYPE); + integerDataTypeAttributeCheck.setExpectedDataType(DataType.INTEGER); + + MeasureAttributeCheck measureSumAttributeCheck1 = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck1.setExpectedAggregator(AggregatorType.SUM); + + MeasureCheck measureIntegerCheck = factory.createMeasureCheck(); + measureIntegerCheck.setName("MeasureCheck-Measure - Datatype Integer"); + measureIntegerCheck.setDescription("Check that measure 'Measure - Datatype Integer' exists with INTEGER data type"); + measureIntegerCheck.setMeasureName("Measure - Datatype Integer"); + measureIntegerCheck.getMeasureAttributeChecks().add(integerDataTypeAttributeCheck); + measureIntegerCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck1); + + // Create measure check for "Measure - Datatype Numeric" with DATA_TYPE attribute check + MeasureAttributeCheck numericDataTypeAttributeCheck = factory.createMeasureAttributeCheck(); + numericDataTypeAttributeCheck.setName("Measure Attribute Check DATA_TYPE NUMERIC"); + numericDataTypeAttributeCheck.setAttributeType(MeasureAttribute.DATA_TYPE); + numericDataTypeAttributeCheck.setExpectedDataType(DataType.NUMERIC); + + MeasureAttributeCheck measureSumAttributeCheck2 = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck2.setExpectedAggregator(AggregatorType.SUM); + + MeasureCheck measureNumericCheck = factory.createMeasureCheck(); + measureNumericCheck.setName("MeasureCheck-Measure - Datatype Numeric"); + measureNumericCheck.setDescription("Check that measure 'Measure - Datatype Numeric' exists with NUMERIC data type"); + measureNumericCheck.setMeasureName("Measure - Datatype Numeric"); + measureNumericCheck.getMeasureAttributeChecks().add(numericDataTypeAttributeCheck); + measureNumericCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck1); + + // Create cube check with all measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MeasuresDatatypeCube"); + cubeCheck.setDescription("Check that cube 'MeasuresDatatypeCube' exists"); + cubeCheck.setCubeName("MeasuresDatatypeCube"); + cubeCheck.getMeasureChecks().add(measureIntegerCheck); + cubeCheck.getMeasureChecks().add(measureNumericCheck); + + // Create query checks for each measure + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Measure - Datatype Integer]"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Datatype Integer"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Measure - Datatype Integer"); + queryCheck1.setQuery("SELECT FROM [MeasuresDatatypeCube] WHERE ([Measures].[Measure - Datatype Integer])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Measure - Datatype Numeric]"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Datatype Numeric"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Measure - Datatype Numeric"); + queryCheck2.setQuery("SELECT FROM [MeasuresDatatypeCube] WHERE ([Measures].[Measure - Datatype Numeric])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + // Create database column checks for the Fact table + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Datatype"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Datatype"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Datatype' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Datatype"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Datatype"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Datatype"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Datatype"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Datatype"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.format/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/format/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.format/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/format/CheckSuiteSupplier.java new file mode 100644 index 00000000..18e72348 --- /dev/null +++ b/instance/emf/tutorial/cube/measure.format/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/format/CheckSuiteSupplier.java @@ -0,0 +1,200 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.format; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttribute; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the measure format cube mapping. + * Checks that the catalog, cube, and measures with different format strings exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check for "Format #,##0.00" with FORMAT_STRING attribute check + MeasureAttributeCheck formatTwoDecimalsAttributeCheck = factory.createMeasureAttributeCheck(); + formatTwoDecimalsAttributeCheck.setName("Measure Attribute Check FORMAT_STRING #,##0.00"); + formatTwoDecimalsAttributeCheck.setAttributeType(MeasureAttribute.FORMAT_STRING); + formatTwoDecimalsAttributeCheck.setExpectedValue("#,##0.00"); + + MeasureAttributeCheck measureSumAttributeCheck1 = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck1.setExpectedAggregator(AggregatorType.SUM); + + MeasureCheck measureTwoDecimalsCheck = factory.createMeasureCheck(); + measureTwoDecimalsCheck.setName("MeasureCheck-Format #,##0.00"); + measureTwoDecimalsCheck.setDescription("Check that measure 'Format #,##0.00' exists with format string '#,##0.00'"); + measureTwoDecimalsCheck.setMeasureName("Format #,##0.00"); + measureTwoDecimalsCheck.getMeasureAttributeChecks().add(formatTwoDecimalsAttributeCheck); + measureTwoDecimalsCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck1); + + // Create measure check for "Format #,##0" with FORMAT_STRING attribute check + MeasureAttributeCheck formatNoDecimalsAttributeCheck = factory.createMeasureAttributeCheck(); + formatNoDecimalsAttributeCheck.setName("Measure Attribute Check FORMAT_STRING #,##0"); + formatNoDecimalsAttributeCheck.setAttributeType(MeasureAttribute.FORMAT_STRING); + formatNoDecimalsAttributeCheck.setExpectedValue("#,##0"); + + MeasureAttributeCheck measureSumAttributeCheck2 = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck2.setExpectedAggregator(AggregatorType.SUM); + + MeasureCheck measureNoDecimalsCheck = factory.createMeasureCheck(); + measureNoDecimalsCheck.setName("MeasureCheck-Format #,##0"); + measureNoDecimalsCheck.setDescription("Check that measure 'Format #,##0' exists with format string '#,##0'"); + measureNoDecimalsCheck.setMeasureName("Format #,##0"); + measureNoDecimalsCheck.getMeasureAttributeChecks().add(formatNoDecimalsAttributeCheck); + measureNoDecimalsCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck2); + + // Create measure check for "Format #,##0." with FORMAT_STRING attribute check + MeasureAttributeCheck formatOneDecimalAttributeCheck = factory.createMeasureAttributeCheck(); + formatOneDecimalAttributeCheck.setName("Measure Attribute Check FORMAT_STRING #,##0."); + formatOneDecimalAttributeCheck.setAttributeType(MeasureAttribute.FORMAT_STRING); + formatOneDecimalAttributeCheck.setExpectedValue("#,##0."); + + MeasureAttributeCheck measureSumAttributeCheck3 = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck3.setExpectedAggregator(AggregatorType.SUM); + + MeasureCheck measureOneDecimalCheck = factory.createMeasureCheck(); + measureOneDecimalCheck.setName("MeasureCheck-Format #,##0."); + measureOneDecimalCheck.setDescription("Check that measure 'Format #,##0.' exists with format string '#,##0.'"); + measureOneDecimalCheck.setMeasureName("Format #,##0."); + measureOneDecimalCheck.getMeasureAttributeChecks().add(formatOneDecimalAttributeCheck); + measureOneDecimalCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck3); + + // Create cube check with all measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MeasuresFormatCube"); + cubeCheck.setDescription("Check that cube 'MeasuresFormatCube' exists"); + cubeCheck.setCubeName("MeasuresFormatCube"); + cubeCheck.getMeasureChecks().add(measureTwoDecimalsCheck); + cubeCheck.getMeasureChecks().add(measureNoDecimalsCheck); + cubeCheck.getMeasureChecks().add(measureOneDecimalCheck); + + // Create query checks for each measure + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Format #,##0.00]"); + queryCheck1CellValueCheck.setExpectedValue("63.00"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Format #,##0.00"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Format #,##0.00"); + queryCheck1.setQuery("SELECT FROM [MeasuresFormatCube] WHERE ([Measures].[Format #,##0.00])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Format #,##0]"); + queryCheck2CellValueCheck.setExpectedValue("63.000"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Format #,##0"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Format #,##0"); + queryCheck2.setQuery("SELECT FROM [MeasuresFormatCube] WHERE ([Measures].[Format #,##0])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[Format #,##0.]"); + queryCheck3CellValueCheck.setExpectedValue(""); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check Format #,##0."); + queryCheck3.setDescription("Verify MDX query returns Measure data for Format #,##0."); + queryCheck3.setQuery("SELECT FROM [MeasuresFormatCube] WHERE ([Measures].[Format #,##0.])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + // Create database column checks for the Fact table + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Format"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Format"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Format' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Format"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Format"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Format"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Format"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Format"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.group/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/group/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.group/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/group/CheckSuiteSupplier.java new file mode 100644 index 00000000..40204a5e --- /dev/null +++ b/instance/emf/tutorial/cube/measure.group/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/group/CheckSuiteSupplier.java @@ -0,0 +1,163 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.group; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the measure group cube mapping. + * Checks that the catalog, cube, and measures organized in groups exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure checks for "Group Alphabetic" measure group + MeasureCheck measureACheck = factory.createMeasureCheck(); + measureACheck.setName("MeasureCheck-Measure A"); + measureACheck.setDescription("Check that measure 'Measure A' exists"); + measureACheck.setMeasureName("Measure A"); + + MeasureCheck measureBCheck = factory.createMeasureCheck(); + measureBCheck.setName("MeasureCheck-Measure B"); + measureBCheck.setDescription("Check that measure 'Measure B' exists"); + measureBCheck.setMeasureName("Measure B"); + + // Create measure check for "Group Other" measure group + MeasureCheck measure1Check = factory.createMeasureCheck(); + measure1Check.setName("MeasureCheck-Measure 1"); + measure1Check.setDescription("Check that measure 'Measure 1' exists"); + measure1Check.setMeasureName("Measure 1"); + + // Create cube check with all measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MeasureGroupCube"); + cubeCheck.setDescription("Check that cube 'MeasureGroupCube' exists"); + cubeCheck.setCubeName("MeasureGroupCube"); + cubeCheck.getMeasureChecks().add(measureACheck); + cubeCheck.getMeasureChecks().add(measureBCheck); + cubeCheck.getMeasureChecks().add(measure1Check); + + // Create query checks for each measure + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Measure A]"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure Query Check Measure A"); + queryCheck1.setDescription("Verify MDX query returns Measure data for Measure A"); + queryCheck1.setQuery("SELECT FROM [MeasureGroupCube] WHERE ([Measures].[Measure A])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Measure B]"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check Measure B"); + queryCheck2.setDescription("Verify MDX query returns Measure data for Measure B"); + queryCheck2.setQuery("SELECT FROM [MeasureGroupCube] WHERE ([Measures].[Measure B])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheck3CellValueCheck = factory.createCellValueCheck(); + queryCheck3CellValueCheck.setName("[Measures].[Measure 1]"); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Measure Query Check Measure 1"); + queryCheck3.setDescription("Verify MDX query returns Measure data for Measure 1"); + queryCheck3.setQuery("SELECT FROM [MeasureGroupCube] WHERE ([Measures].[Measure 1])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheck3CellValueCheck); + queryCheck3.setEnabled(true); + + // Create database column checks for the Fact table + DatabaseColumnAttributeCheck columnAttributeCheckKey = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckKey.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckKey.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnAttributeCheckKey); + + DatabaseColumnAttributeCheck columnAttributeCheckValue = factory.createDatabaseColumnAttributeCheck(); + columnAttributeCheckValue.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAttributeCheckValue.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnAttributeCheckValue); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Group"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Group"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Group' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Group"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Group"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Group"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Group"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Group"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/cube/measure.multiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/multiple/CheckSuiteSupplier.java b/instance/emf/tutorial/cube/measure.multiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/multiple/CheckSuiteSupplier.java new file mode 100644 index 00000000..d0d4c4f1 --- /dev/null +++ b/instance/emf/tutorial/cube/measure.multiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/multiple/CheckSuiteSupplier.java @@ -0,0 +1,181 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.measure.multiple; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the measure multiple tutorial. + * Checks that the catalog, cube, and multiple measures exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure checks for three measures + MeasureCheck measureCheck1 = factory.createMeasureCheck(); + measureCheck1.setName("MeasureCheck-Sum of Value1"); + measureCheck1.setDescription("Check that measure 'Sum of Value1' exists"); + measureCheck1.setMeasureName("Sum of Value1"); + + MeasureCheck measureCheck2 = factory.createMeasureCheck(); + measureCheck2.setName("MeasureCheck-Sum of Value2"); + measureCheck2.setDescription("Check that measure 'Sum of Value2' exists"); + measureCheck2.setMeasureName("Sum of Value2"); + + MeasureCheck measureCheck3 = factory.createMeasureCheck(); + measureCheck3.setName("MeasureCheck-Sum of Value3"); + measureCheck3.setDescription("Check that measure 'Sum of Value3' exists"); + measureCheck3.setMeasureName("Sum of Value3"); + + // Create cube check with measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-MultipleMeasuresCube"); + cubeCheck.setDescription("Check that cube 'MultipleMeasuresCube' exists"); + cubeCheck.setCubeName("MultipleMeasuresCube"); + cubeCheck.getMeasureChecks().add(measureCheck1); + cubeCheck.getMeasureChecks().add(measureCheck2); + cubeCheck.getMeasureChecks().add(measureCheck3); + + // Create query checks for each measure + CellValueCheck queryCheckCellValueCheck1 = factory.createCellValueCheck(); + queryCheckCellValueCheck1.setName("[Measures].[Sum of Value1]"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Sum of Value1 Query Check"); + queryCheck1.setDescription("Verify MDX query returns Sum of Value1 data"); + queryCheck1.setQuery("SELECT FROM [MultipleMeasuresCube] WHERE ([Measures].[Sum of Value1])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheckCellValueCheck1); + queryCheck1.setEnabled(true); + + CellValueCheck queryCheckCellValueCheck2 = factory.createCellValueCheck(); + queryCheckCellValueCheck2.setName("[Measures].[Sum of Value2]"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Sum of Value2 Query Check"); + queryCheck2.setDescription("Verify MDX query returns Sum of Value2 data"); + queryCheck2.setQuery("SELECT FROM [MultipleMeasuresCube] WHERE ([Measures].[Sum of Value2])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheckCellValueCheck2); + queryCheck2.setEnabled(true); + + CellValueCheck queryCheckCellValueCheck3 = factory.createCellValueCheck(); + queryCheckCellValueCheck3.setName("[Measures].[Sum of Value3]"); + + QueryCheck queryCheck3 = factory.createQueryCheck(); + queryCheck3.setName("Sum of Value3 Query Check"); + queryCheck3.setDescription("Verify MDX query returns Sum of Value3 data"); + queryCheck3.setQuery("SELECT FROM [MultipleMeasuresCube] WHERE ([Measures].[Sum of Value3])"); + queryCheck3.setQueryLanguage(QueryLanguage.MDX); + queryCheck3.setExpectedColumnCount(1); + queryCheck3.getCellChecks().add(queryCheckCellValueCheck3); + queryCheck3.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValue1TypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValue1TypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValue1TypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue1 = factory.createDatabaseColumnCheck(); + columnCheckValue1.setName("Database Column Check VALUE1"); + columnCheckValue1.setColumnName("VALUE1"); + columnCheckValue1.getColumnAttributeChecks().add(columnValue1TypeCheck); + + DatabaseColumnAttributeCheck columnValue2TypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValue2TypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValue2TypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue2 = factory.createDatabaseColumnCheck(); + columnCheckValue2.setName("Database Column Check VALUE2"); + columnCheckValue2.setColumnName("VALUE2"); + columnCheckValue2.getColumnAttributeChecks().add(columnValue2TypeCheck); + + DatabaseColumnAttributeCheck columnValue3TypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValue3TypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValue3TypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue3 = factory.createDatabaseColumnCheck(); + columnCheckValue3.setName("Database Column Check VALUE3"); + columnCheckValue3.setColumnName("VALUE3"); + columnCheckValue3.getColumnAttributeChecks().add(columnValue3TypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue1); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue2); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue3); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Multiple"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Multiple"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Multiple' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Multiple"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getQueryChecks().add(queryCheck3); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Multiple"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Multiple"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Multiple"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Multiple"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/database/column/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/column/CheckSuiteSupplier.java b/instance/emf/tutorial/database/column/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/column/CheckSuiteSupplier.java new file mode 100644 index 00000000..4ccbe4c2 --- /dev/null +++ b/instance/emf/tutorial/database/column/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/column/CheckSuiteSupplier.java @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.database.column; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the database column tutorial. + * Checks that the catalog and database schema with various column types exist and are properly configured. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create database column checks for "ColumnWithDescription" + DatabaseColumnAttributeCheck columnWithDescriptionTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnWithDescriptionTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnWithDescriptionTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckWithDescription = factory.createDatabaseColumnCheck(); + columnCheckWithDescription.setName("Database Column Check ColumnWithDescription"); + columnCheckWithDescription.setColumnName("ColumnWithDescription"); + columnCheckWithDescription.getColumnAttributeChecks().add(columnWithDescriptionTypeCheck); + + // Create database column checks for "ColumnVarchar" + DatabaseColumnAttributeCheck columnVarcharTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnVarcharTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnVarcharTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckVarchar = factory.createDatabaseColumnCheck(); + columnCheckVarchar.setName("Database Column Check ColumnVarchar"); + columnCheckVarchar.setColumnName("ColumnVarchar"); + columnCheckVarchar.getColumnAttributeChecks().add(columnVarcharTypeCheck); + + // Create database column checks for "ColumnDecimal" + DatabaseColumnAttributeCheck columnDecimalTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDecimalTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDecimalTypeCheck.setExpectedValue("DECIMAL"); + + DatabaseColumnCheck columnCheckDecimal = factory.createDatabaseColumnCheck(); + columnCheckDecimal.setName("Database Column Check ColumnDecimal"); + columnCheckDecimal.setColumnName("ColumnDecimal"); + columnCheckDecimal.getColumnAttributeChecks().add(columnDecimalTypeCheck); + + // Create database column checks for "ColumnNumeric" + DatabaseColumnAttributeCheck columnNumericTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnNumericTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnNumericTypeCheck.setExpectedValue("NUMERIC"); + + DatabaseColumnCheck columnCheckNumeric = factory.createDatabaseColumnCheck(); + columnCheckNumeric.setName("Database Column Check ColumnNumeric"); + columnCheckNumeric.setColumnName("ColumnNumeric"); + columnCheckNumeric.getColumnAttributeChecks().add(columnNumericTypeCheck); + + // Create database column checks for "ColumnFloat" + DatabaseColumnAttributeCheck columnFloatTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFloatTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFloatTypeCheck.setExpectedValue("FLOAT"); + + DatabaseColumnCheck columnCheckFloat = factory.createDatabaseColumnCheck(); + columnCheckFloat.setName("Database Column Check ColumnFloat"); + columnCheckFloat.setColumnName("ColumnFloat"); + columnCheckFloat.getColumnAttributeChecks().add(columnFloatTypeCheck); + + // Create database column checks for "ColumnReal" + DatabaseColumnAttributeCheck columnRealTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnRealTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnRealTypeCheck.setExpectedValue("REAL"); + + DatabaseColumnCheck columnCheckReal = factory.createDatabaseColumnCheck(); + columnCheckReal.setName("Database Column Check ColumnReal"); + columnCheckReal.setColumnName("ColumnReal"); + columnCheckReal.getColumnAttributeChecks().add(columnRealTypeCheck); + + // Create database column checks for "ColumnDouble" + DatabaseColumnAttributeCheck columnDoubleTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDoubleTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDoubleTypeCheck.setExpectedValue("DOUBLE"); + + DatabaseColumnCheck columnCheckDouble = factory.createDatabaseColumnCheck(); + columnCheckDouble.setName("Database Column Check ColumnDouble"); + columnCheckDouble.setColumnName("ColumnDouble"); + columnCheckDouble.getColumnAttributeChecks().add(columnDoubleTypeCheck); + + // Create database column checks for "ColumnInteger" + DatabaseColumnAttributeCheck columnIntegerTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnIntegerTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnIntegerTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckInteger = factory.createDatabaseColumnCheck(); + columnCheckInteger.setName("Database Column Check ColumnInteger"); + columnCheckInteger.setColumnName("ColumnInteger"); + columnCheckInteger.getColumnAttributeChecks().add(columnIntegerTypeCheck); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheck = factory.createDatabaseTableCheck(); + databaseTableCheck.setName("Database Table TableWithColumnTypes Check"); + databaseTableCheck.setTableName("TableWithColumnTypes"); + databaseTableCheck.getColumnChecks().add(columnCheckWithDescription); + databaseTableCheck.getColumnChecks().add(columnCheckVarchar); + databaseTableCheck.getColumnChecks().add(columnCheckDecimal); + databaseTableCheck.getColumnChecks().add(columnCheckNumeric); + databaseTableCheck.getColumnChecks().add(columnCheckFloat); + databaseTableCheck.getColumnChecks().add(columnCheckReal); + databaseTableCheck.getColumnChecks().add(columnCheckDouble); + databaseTableCheck.getColumnChecks().add(columnCheckInteger); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Database Column"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheck); + + // Create catalog check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Database Column"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Database Column' exists with database schema"); + catalogCheck.setCatalogName("Daanse Tutorial - Database Column"); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Database Column"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Database Column"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Database Column"); + suite.setDescription("Check suite for the Daanse Tutorial - Database Column"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/database/expressioncolumn/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/expressioncolumn/CheckSuiteSupplier.java b/instance/emf/tutorial/database/expressioncolumn/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/expressioncolumn/CheckSuiteSupplier.java new file mode 100644 index 00000000..3456c87f --- /dev/null +++ b/instance/emf/tutorial/database/expressioncolumn/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/expressioncolumn/CheckSuiteSupplier.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.database.expressioncolumn; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the database expression column tutorial. + * Checks that the catalog and database schema with SQL expression columns exist and are properly configured. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create database column check for "column1" (physical column) + DatabaseColumnCheck columnCheck1 = factory.createDatabaseColumnCheck(); + columnCheck1.setName("Database Column Check column1"); + columnCheck1.setColumnName("column1"); + + // Create database column check for "SqlExpressionColumn" (computed column) + // Note: SQL expression columns are computed dynamically and may not be visible + // in the database metadata in the same way as physical columns + DatabaseColumnCheck columnCheckSqlExpression = factory.createDatabaseColumnCheck(); + columnCheckSqlExpression.setName("Database Column Check SqlExpressionColumn"); + columnCheckSqlExpression.setColumnName("SqlExpressionColumn"); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheck = factory.createDatabaseTableCheck(); + databaseTableCheck.setName("Database Table TableWithExpressionColumn Check"); + databaseTableCheck.setTableName("TableWithExpressionColumn"); + databaseTableCheck.getColumnChecks().add(columnCheck1); + databaseTableCheck.getColumnChecks().add(columnCheckSqlExpression); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Database Expression Column"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheck); + + // Create catalog check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Database Expression Column"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Database Expression Column' exists with database schema"); + catalogCheck.setCatalogName("Daanse Tutorial - Database Expression Column"); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Database Expression Column"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Database Expression Column"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Database Expression Column"); + suite.setDescription("Check suite for the Daanse Tutorial - Database Expression Column"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/database/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/inlinetable/CheckSuiteSupplier.java b/instance/emf/tutorial/database/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/inlinetable/CheckSuiteSupplier.java new file mode 100644 index 00000000..ec07b086 --- /dev/null +++ b/instance/emf/tutorial/database/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/inlinetable/CheckSuiteSupplier.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.database.inlinetable; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the database inline table tutorial. + * Checks that the catalog and database schema with inline table exist and are properly configured. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create database column checks for "KEY" column + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + // Create database column checks for "VALUE" column + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + // Create Database Table Check for inline table "FACT" + DatabaseTableCheck databaseTableCheck = factory.createDatabaseTableCheck(); + databaseTableCheck.setName("Database Inline Table FACT Check"); + databaseTableCheck.setTableName("FACT"); + databaseTableCheck.getColumnChecks().add(columnCheckKey); + databaseTableCheck.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Database Inline Table"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheck); + + // Create catalog check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Database Inline Table"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Database Inline Table' exists with database schema"); + catalogCheck.setCatalogName("Daanse Tutorial - Database Inline Table"); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Database Inline Table"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Database Inline Table"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Database Inline Table"); + suite.setDescription("Check suite for the Daanse Tutorial - Database Inline Table"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/database/intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/intro/CheckSuiteSupplier.java b/instance/emf/tutorial/database/intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/intro/CheckSuiteSupplier.java new file mode 100644 index 00000000..7adf6d98 --- /dev/null +++ b/instance/emf/tutorial/database/intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/intro/CheckSuiteSupplier.java @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.database.intro; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the database intro tutorial. + * Checks that the catalog and basic database schema structure exist and are properly configured. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create database column check for "ColumnOne" + DatabaseColumnAttributeCheck columnOneTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnOneTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnOneTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckOne = factory.createDatabaseColumnCheck(); + columnCheckOne.setName("Database Column Check ColumnOne"); + columnCheckOne.setColumnName("ColumnOne"); + columnCheckOne.getColumnAttributeChecks().add(columnOneTypeCheck); + + // Create Database Table Check for "TableOne" + DatabaseTableCheck databaseTableCheck = factory.createDatabaseTableCheck(); + databaseTableCheck.setName("Database Table TableOne Check"); + databaseTableCheck.setTableName("TableOne"); + databaseTableCheck.getColumnChecks().add(columnCheckOne); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Database Intro"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheck); + + // Create catalog check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Database Intro"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Database Intro' exists with database schema"); + catalogCheck.setCatalogName("Daanse Tutorial - Database Intro"); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Database Intro"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Database Intro"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Database Intro"); + suite.setDescription("Check suite for the Daanse Tutorial - Database Intro"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/database/schema/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/schema/CheckSuiteSupplier.java b/instance/emf/tutorial/database/schema/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/schema/CheckSuiteSupplier.java new file mode 100644 index 00000000..1e31d4a5 --- /dev/null +++ b/instance/emf/tutorial/database/schema/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/schema/CheckSuiteSupplier.java @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.database.schema; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the database schema tutorial. + * Checks that the catalog with multiple database schemas exists and is properly configured. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create database column check for "theColumn" in default schema + DatabaseColumnAttributeCheck columnDefaultTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDefaultTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDefaultTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckDefault = factory.createDatabaseColumnCheck(); + columnCheckDefault.setName("Database Column Check theColumn (Default Schema)"); + columnCheckDefault.setColumnName("theColumn"); + columnCheckDefault.getColumnAttributeChecks().add(columnDefaultTypeCheck); + + // Create Database Table Check for "theTable" in default schema + DatabaseTableCheck databaseTableCheckDefault = factory.createDatabaseTableCheck(); + databaseTableCheckDefault.setName("Database Table theTable Check (Default Schema)"); + databaseTableCheckDefault.setTableName("theTable"); + databaseTableCheckDefault.getColumnChecks().add(columnCheckDefault); + + // Create Database Schema Check for default schema (without name) + DatabaseSchemaCheck databaseSchemaCheckDefault = factory.createDatabaseSchemaCheck(); + databaseSchemaCheckDefault.setName("Database Schema Check (Default)"); + databaseSchemaCheckDefault.setDescription("Database Schema Check for default schema without name"); + databaseSchemaCheckDefault.getTableChecks().add(databaseTableCheckDefault); + + // Create database column check for "theColumn" in "foo" schema + DatabaseColumnAttributeCheck columnFooTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFooTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFooTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckFoo = factory.createDatabaseColumnCheck(); + columnCheckFoo.setName("Database Column Check theColumn (Schema foo)"); + columnCheckFoo.setColumnName("theColumn"); + columnCheckFoo.getColumnAttributeChecks().add(columnFooTypeCheck); + + // Create Database Table Check for "theTable" in "foo" schema + DatabaseTableCheck databaseTableCheckFoo = factory.createDatabaseTableCheck(); + databaseTableCheckFoo.setName("Database Table theTable Check (Schema foo)"); + databaseTableCheckFoo.setTableName("theTable"); + databaseTableCheckFoo.getColumnChecks().add(columnCheckFoo); + + // Create Database Schema Check for "foo" schema (with name) + DatabaseSchemaCheck databaseSchemaCheckFoo = factory.createDatabaseSchemaCheck(); + databaseSchemaCheckFoo.setName("Database Schema Check (foo)"); + databaseSchemaCheckFoo.setDescription("Database Schema Check for named schema 'foo'"); + databaseSchemaCheckFoo.getTableChecks().add(databaseTableCheckFoo); + + // Create catalog check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Database Schema"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Database Schema' exists with multiple database schemas"); + catalogCheck.setCatalogName("Daanse Tutorial - Database Schema"); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheckDefault); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheckFoo); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Database Schema"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Database Schema"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Database Schema"); + suite.setDescription("Check suite for the Daanse Tutorial - Database Schema"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/database/sqlview/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/sqlview/CheckSuiteSupplier.java b/instance/emf/tutorial/database/sqlview/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/sqlview/CheckSuiteSupplier.java new file mode 100644 index 00000000..a2a446b5 --- /dev/null +++ b/instance/emf/tutorial/database/sqlview/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/sqlview/CheckSuiteSupplier.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.database.sqlview; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the database SQL view tutorial. + * Checks that the catalog and database schema with SQL view exist and are properly configured. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create database column check for "ColumnOne" + DatabaseColumnAttributeCheck columnOneTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnOneTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnOneTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckOne = factory.createDatabaseColumnCheck(); + columnCheckOne.setName("Database Column Check ColumnOne"); + columnCheckOne.setColumnName("ColumnOne"); + columnCheckOne.getColumnAttributeChecks().add(columnOneTypeCheck); + + // Create Database Table Check for SQL view "sqlview" + // Note: SqlView is a virtual table based on SQL statements, not a physical table + DatabaseTableCheck databaseTableCheck = factory.createDatabaseTableCheck(); + databaseTableCheck.setName("Database SQL View sqlview Check"); + databaseTableCheck.setTableName("sqlview"); + databaseTableCheck.getColumnChecks().add(columnCheckOne); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Database SQL View"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheck); + + // Create catalog check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Database SQL View"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Database SQL View' exists with database schema"); + catalogCheck.setCatalogName("Daanse Tutorial - Database SQL View"); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Database SQL View"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Database SQL View"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Database SQL View"); + suite.setDescription("Check suite for the Daanse Tutorial - Database SQL View"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/database/table/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/table/CheckSuiteSupplier.java b/instance/emf/tutorial/database/table/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/table/CheckSuiteSupplier.java new file mode 100644 index 00000000..05440038 --- /dev/null +++ b/instance/emf/tutorial/database/table/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/database/table/CheckSuiteSupplier.java @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.database.table; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the database table tutorial. + * Checks that the catalog and database schema with different table types exist and are properly configured. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create database column check for PhysicalTable "TableOne" + DatabaseColumnAttributeCheck columnPhysicalTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnPhysicalTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnPhysicalTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckPhysical = factory.createDatabaseColumnCheck(); + columnCheckPhysical.setName("Database Column Check ColumnOne (PhysicalTable)"); + columnCheckPhysical.setColumnName("ColumnOne"); + columnCheckPhysical.getColumnAttributeChecks().add(columnPhysicalTypeCheck); + + // Create Database Table Check for PhysicalTable "TableOne" + DatabaseTableCheck physicalTableCheck = factory.createDatabaseTableCheck(); + physicalTableCheck.setName("Database Physical Table TableOne Check"); + physicalTableCheck.setTableName("TableOne"); + physicalTableCheck.getColumnChecks().add(columnCheckPhysical); + + // Create database column check for ViewTable "ViewOne" + DatabaseColumnAttributeCheck columnViewTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnViewTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnViewTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckView = factory.createDatabaseColumnCheck(); + columnCheckView.setName("Database Column Check ColumnOne (ViewTable)"); + columnCheckView.setColumnName("ColumnOne"); + columnCheckView.getColumnAttributeChecks().add(columnViewTypeCheck); + + // Create Database Table Check for ViewTable "ViewOne" + DatabaseTableCheck viewTableCheck = factory.createDatabaseTableCheck(); + viewTableCheck.setName("Database View Table ViewOne Check"); + viewTableCheck.setTableName("ViewOne"); + viewTableCheck.getColumnChecks().add(columnCheckView); + + // Create database column check for SystemTable "TableOne" + DatabaseColumnAttributeCheck columnSystemTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnSystemTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnSystemTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckSystem = factory.createDatabaseColumnCheck(); + columnCheckSystem.setName("Database Column Check ColumnOne (SystemTable)"); + columnCheckSystem.setColumnName("ColumnOne"); + columnCheckSystem.getColumnAttributeChecks().add(columnSystemTypeCheck); + + // Create Database Table Check for SystemTable "TableOne" + DatabaseTableCheck systemTableCheck = factory.createDatabaseTableCheck(); + systemTableCheck.setName("Database System Table TableOne Check"); + systemTableCheck.setTableName("TableOne"); + systemTableCheck.getColumnChecks().add(columnCheckSystem); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Database Table"); + databaseSchemaCheck.getTableChecks().add(physicalTableCheck); + databaseSchemaCheck.getTableChecks().add(viewTableCheck); + databaseSchemaCheck.getTableChecks().add(systemTableCheck); + + // Create catalog check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Database Table"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Database Table' exists with database schema"); + catalogCheck.setCatalogName("Daanse Tutorial - Database Table"); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Database Table"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Database Table"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Database Table"); + suite.setDescription("Check suite for the Daanse Tutorial - Database Table"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/dimension/optimisationwithlevelattribute/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/dimension/optimisationwithlevelattribute/CheckSuiteSupplier.java b/instance/emf/tutorial/dimension/optimisationwithlevelattribute/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/dimension/optimisationwithlevelattribute/CheckSuiteSupplier.java new file mode 100644 index 00000000..765bcdbc --- /dev/null +++ b/instance/emf/tutorial/dimension/optimisationwithlevelattribute/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/dimension/optimisationwithlevelattribute/CheckSuiteSupplier.java @@ -0,0 +1,258 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.dimension.optimisationwithlevelattribute; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the dimension optimisation with level attribute tutorial. + * Checks that the catalog, cube, and dimension with level attribute optimization exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure"); + measureCheck.setDescription("Check that measure 'Measure' exists"); + measureCheck.setMeasureName("Measure"); + + // Create level checks + LevelCheck levelH1Level1Check = factory.createLevelCheck(); + levelH1Level1Check.setName("LevelCheck for H1_Level1"); + levelH1Level1Check.setLevelName("H1_Level1"); + + LevelCheck levelH1Level2Check = factory.createLevelCheck(); + levelH1Level2Check.setName("LevelCheck for H1_Level2"); + levelH1Level2Check.setLevelName("H1_Level2"); + + // Create hierarchy attribute check for hasAll + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check for Hierarchy1 + HierarchyCheck hierarchyCheck1 = factory.createHierarchyCheck(); + hierarchyCheck1.setName("HierarchyCheck for Hierarchy1 (Dim1)"); + hierarchyCheck1.setHierarchyName("Hierarchy1"); + hierarchyCheck1.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck1.getLevelChecks().add(levelH1Level1Check); + hierarchyCheck1.getLevelChecks().add(levelH1Level2Check); + + // Create dimension check for Dim1 + DimensionCheck dimensionCheck1 = factory.createDimensionCheck(); + dimensionCheck1.setName("DimensionCheck for Dim1"); + dimensionCheck1.setDimensionName("Dim1"); + dimensionCheck1.getHierarchyChecks().add(hierarchyCheck1); + + // Create level checks for Dim2 (reusing the same level definitions) + LevelCheck levelH1Level1Check2 = factory.createLevelCheck(); + levelH1Level1Check2.setName("LevelCheck for H1_Level1 (Dim2)"); + levelH1Level1Check2.setLevelName("H1_Level1"); + + LevelCheck levelH1Level2Check2 = factory.createLevelCheck(); + levelH1Level2Check2.setName("LevelCheck for H1_Level2 (Dim2)"); + levelH1Level2Check2.setLevelName("H1_Level2"); + + // Create hierarchy attribute check for hasAll (Dim2) + HierarchyAttributeCheck hierarchyAttributeCheck2 = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck2.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck2.setExpectedBoolean(true); + + // Create hierarchy check for Hierarchy1 (for Dim2) + HierarchyCheck hierarchyCheck2 = factory.createHierarchyCheck(); + hierarchyCheck2.setName("HierarchyCheck for Hierarchy1 (Dim2)"); + hierarchyCheck2.setHierarchyName("Hierarchy1"); + hierarchyCheck2.getHierarchyAttributeChecks().add(hierarchyAttributeCheck2); + hierarchyCheck2.getLevelChecks().add(levelH1Level1Check2); + hierarchyCheck2.getLevelChecks().add(levelH1Level2Check2); + + // Create dimension check for Dim2 + DimensionCheck dimensionCheck2 = factory.createDimensionCheck(); + dimensionCheck2.setName("DimensionCheck for Dim2"); + dimensionCheck2.setDimensionName("Dim2"); + dimensionCheck2.getHierarchyChecks().add(hierarchyCheck2); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck1); + cubeCheck.getDimensionChecks().add(dimensionCheck2); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure]"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnDimKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDimKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDimKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckDimKey = factory.createDatabaseColumnCheck(); + columnCheckDimKey.setName("Database Column Check DIM_KEY"); + columnCheckDimKey.setColumnName("DIM_KEY"); + columnCheckDimKey.getColumnAttributeChecks().add(columnDimKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckDimKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create database column checks for H1_L1 table + DatabaseColumnAttributeCheck columnH1L1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH1L1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH1L1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckH1L1Key = factory.createDatabaseColumnCheck(); + columnCheckH1L1Key.setName("Database Column Check KEY (H1_L1)"); + columnCheckH1L1Key.setColumnName("KEY"); + columnCheckH1L1Key.getColumnAttributeChecks().add(columnH1L1KeyTypeCheck); + + DatabaseColumnAttributeCheck columnH1L1NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH1L1NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH1L1NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckH1L1Name = factory.createDatabaseColumnCheck(); + columnCheckH1L1Name.setName("Database Column Check NAME (H1_L1)"); + columnCheckH1L1Name.setColumnName("NAME"); + columnCheckH1L1Name.getColumnAttributeChecks().add(columnH1L1NameTypeCheck); + + DatabaseTableCheck databaseTableCheckH1L1 = factory.createDatabaseTableCheck(); + databaseTableCheckH1L1.setName("Database Table H1_L1 Check"); + databaseTableCheckH1L1.setTableName("H1_L1"); + databaseTableCheckH1L1.getColumnChecks().add(columnCheckH1L1Key); + databaseTableCheckH1L1.getColumnChecks().add(columnCheckH1L1Name); + + // Create database column checks for HX_L2 table + DatabaseColumnAttributeCheck columnHXL2KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnHXL2KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnHXL2KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckHXL2Key = factory.createDatabaseColumnCheck(); + columnCheckHXL2Key.setName("Database Column Check KEY (HX_L2)"); + columnCheckHXL2Key.setColumnName("KEY"); + columnCheckHXL2Key.getColumnAttributeChecks().add(columnHXL2KeyTypeCheck); + + DatabaseColumnAttributeCheck columnHXL2NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnHXL2NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnHXL2NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckHXL2Name = factory.createDatabaseColumnCheck(); + columnCheckHXL2Name.setName("Database Column Check NAME (HX_L2)"); + columnCheckHXL2Name.setColumnName("NAME"); + columnCheckHXL2Name.getColumnAttributeChecks().add(columnHXL2NameTypeCheck); + + DatabaseColumnAttributeCheck columnH1L1KeyFKTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH1L1KeyFKTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH1L1KeyFKTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckH1L1KeyFK = factory.createDatabaseColumnCheck(); + columnCheckH1L1KeyFK.setName("Database Column Check H1L1_KEY (HX_L2)"); + columnCheckH1L1KeyFK.setColumnName("H1L1_KEY"); + columnCheckH1L1KeyFK.getColumnAttributeChecks().add(columnH1L1KeyFKTypeCheck); + + DatabaseColumnAttributeCheck columnH2L1KeyFKTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnH2L1KeyFKTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnH2L1KeyFKTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckH2L1KeyFK = factory.createDatabaseColumnCheck(); + columnCheckH2L1KeyFK.setName("Database Column Check H2L1_KEY (HX_L2)"); + columnCheckH2L1KeyFK.setColumnName("H2L1_KEY"); + columnCheckH2L1KeyFK.getColumnAttributeChecks().add(columnH2L1KeyFKTypeCheck); + + DatabaseTableCheck databaseTableCheckHXL2 = factory.createDatabaseTableCheck(); + databaseTableCheckHXL2.setName("Database Table HX_L2 Check"); + databaseTableCheckHXL2.setTableName("HX_L2"); + databaseTableCheckHXL2.getColumnChecks().add(columnCheckHXL2Key); + databaseTableCheckHXL2.getColumnChecks().add(columnCheckHXL2Name); + databaseTableCheckHXL2.getColumnChecks().add(columnCheckH1L1KeyFK); + databaseTableCheckHXL2.getColumnChecks().add(columnCheckH2L1KeyFK); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Dimension Optimisation With Level Attribute"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckH1L1); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckHXL2); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Dimension Optimisation With Level Attribute"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Dimension Optimisation With Level Attribute' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Dimension Optimisation With Level Attribute"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Dimension Optimisation With Level Attribute"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Dimension Optimisation With Level Attribute"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Dimension Optimisation With Level Attribute"); + suite.setDescription("Check suite for the Daanse Tutorial - Dimension Optimisation With Level Attribute"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/dimension/timedimension/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/dimension/timedimension/CheckSuiteSupplier.java b/instance/emf/tutorial/dimension/timedimension/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/dimension/timedimension/CheckSuiteSupplier.java new file mode 100644 index 00000000..1c1124ba --- /dev/null +++ b/instance/emf/tutorial/dimension/timedimension/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/dimension/timedimension/CheckSuiteSupplier.java @@ -0,0 +1,253 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.dimension.timedimension; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the time dimension tutorial. + * Checks that the catalog, cube, and time dimension with temporal levels exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + + MeasureAttributeCheck measureSumAttributeCheck1 = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck1.setExpectedAggregator(AggregatorType.SUM); + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure-Sum"); + measureCheck.setDescription("Check that measure 'Measure-Sum' exists"); + measureCheck.setMeasureName("Measure-Sum"); + measureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck1); + + // Create level checks for Time dimension + LevelCheck levelYearsCheck = factory.createLevelCheck(); + levelYearsCheck.setName("LevelCheck for Years"); + levelYearsCheck.setLevelName("Years"); + + LevelCheck levelQuartersCheck = factory.createLevelCheck(); + levelQuartersCheck.setName("LevelCheck for Quarters"); + levelQuartersCheck.setLevelName("Quarters"); + + LevelCheck levelMonthsCheck = factory.createLevelCheck(); + levelMonthsCheck.setName("LevelCheck for Months"); + levelMonthsCheck.setLevelName("Months"); + + LevelCheck levelWeekCheck = factory.createLevelCheck(); + levelWeekCheck.setName("LevelCheck for Week"); + levelWeekCheck.setLevelName("Week"); + + LevelCheck levelDayCheck = factory.createLevelCheck(); + levelDayCheck.setName("LevelCheck for Day"); + levelDayCheck.setLevelName("Day"); + + // Create hierarchy attribute check for hasAll + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(true); + + HierarchyAttributeCheck hierarchyAllMemberNameCheck = factory.createHierarchyAttributeCheck(); + hierarchyAllMemberNameCheck.setAttributeType(HierarchyAttribute.ALL_MEMBER_NAME); + hierarchyAllMemberNameCheck.setExpectedValue("All Years"); + + // Create hierarchy check for Time dimension + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for Time"); + hierarchyCheck.setHierarchyName("Time"); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAllMemberNameCheck); + hierarchyCheck.getLevelChecks().add(levelYearsCheck); + hierarchyCheck.getLevelChecks().add(levelQuartersCheck); + hierarchyCheck.getLevelChecks().add(levelMonthsCheck); + hierarchyCheck.getLevelChecks().add(levelWeekCheck); + hierarchyCheck.getLevelChecks().add(levelDayCheck); + + // Create dimension check for Time + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for Time"); + dimensionCheck.setDimensionName("Time"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-CubeTimeDimension"); + cubeCheck.setDescription("Check that cube 'CubeTimeDimension' exists"); + cubeCheck.setCubeName("CubeTimeDimension"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure-Sum]"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [CubeTimeDimension] WHERE ([Measures].[Measure-Sum])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnDateKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDateKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDateKeyTypeCheck.setExpectedValue("TIMESTAMP"); + + DatabaseColumnCheck columnCheckDateKey = factory.createDatabaseColumnCheck(); + columnCheckDateKey.setName("Database Column Check DATE_KEY"); + columnCheckDateKey.setColumnName("DATE_KEY"); + columnCheckDateKey.getColumnAttributeChecks().add(columnDateKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseColumnAttributeCheck columnYearIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnYearIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnYearIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckYearId = factory.createDatabaseColumnCheck(); + columnCheckYearId.setName("Database Column Check YEAR_ID"); + columnCheckYearId.setColumnName("YEAR_ID"); + columnCheckYearId.getColumnAttributeChecks().add(columnYearIdTypeCheck); + + DatabaseColumnAttributeCheck columnQtrIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnQtrIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnQtrIdTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckQtrId = factory.createDatabaseColumnCheck(); + columnCheckQtrId.setName("Database Column Check QTR_ID"); + columnCheckQtrId.setColumnName("QTR_ID"); + columnCheckQtrId.getColumnAttributeChecks().add(columnQtrIdTypeCheck); + + DatabaseColumnAttributeCheck columnQtrNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnQtrNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnQtrNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckQtrName = factory.createDatabaseColumnCheck(); + columnCheckQtrName.setName("Database Column Check QTR_NAME"); + columnCheckQtrName.setColumnName("QTR_NAME"); + columnCheckQtrName.getColumnAttributeChecks().add(columnQtrNameTypeCheck); + + DatabaseColumnAttributeCheck columnMonthIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMonthIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMonthIdTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckMonthId = factory.createDatabaseColumnCheck(); + columnCheckMonthId.setName("Database Column Check MONTH_ID"); + columnCheckMonthId.setColumnName("MONTH_ID"); + columnCheckMonthId.getColumnAttributeChecks().add(columnMonthIdTypeCheck); + + DatabaseColumnAttributeCheck columnMonthNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMonthNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMonthNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckMonthName = factory.createDatabaseColumnCheck(); + columnCheckMonthName.setName("Database Column Check MONTH_NAME"); + columnCheckMonthName.setColumnName("MONTH_NAME"); + columnCheckMonthName.getColumnAttributeChecks().add(columnMonthNameTypeCheck); + + DatabaseColumnAttributeCheck columnWeekInMonthTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnWeekInMonthTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnWeekInMonthTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckWeekInMonth = factory.createDatabaseColumnCheck(); + columnCheckWeekInMonth.setName("Database Column Check WEEK_IN_MONTH"); + columnCheckWeekInMonth.setColumnName("WEEK_IN_MONTH"); + columnCheckWeekInMonth.getColumnAttributeChecks().add(columnWeekInMonthTypeCheck); + + DatabaseColumnAttributeCheck columnDayInMonthTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDayInMonthTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDayInMonthTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckDayInMonth = factory.createDatabaseColumnCheck(); + columnCheckDayInMonth.setName("Database Column Check DAY_IN_MONTH"); + columnCheckDayInMonth.setColumnName("DAY_IN_MONTH"); + columnCheckDayInMonth.getColumnAttributeChecks().add(columnDayInMonthTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckDateKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + databaseTableCheckFact.getColumnChecks().add(columnCheckYearId); + databaseTableCheckFact.getColumnChecks().add(columnCheckQtrId); + databaseTableCheckFact.getColumnChecks().add(columnCheckQtrName); + databaseTableCheckFact.getColumnChecks().add(columnCheckMonthId); + databaseTableCheckFact.getColumnChecks().add(columnCheckMonthName); + databaseTableCheckFact.getColumnChecks().add(columnCheckWeekInMonth); + databaseTableCheckFact.getColumnChecks().add(columnCheckDayInMonth); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Dimension Time Dimension"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Dimension Time Dimension"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Dimension Time Dimension' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Dimension Time Dimension"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Dimension Time Dimension"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Dimension Time Dimension"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Dimension Time Dimension"); + suite.setDescription("Check suite for the Daanse Tutorial - Dimension Time Dimension"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/formatter/cell/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/formatter/cell/CheckSuiteSupplier.java b/instance/emf/tutorial/formatter/cell/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/formatter/cell/CheckSuiteSupplier.java new file mode 100644 index 00000000..73140766 --- /dev/null +++ b/instance/emf/tutorial/formatter/cell/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/formatter/cell/CheckSuiteSupplier.java @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.formatter.cell; + +import org.eclipse.daanse.olap.check.model.check.AggregatorType; +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the formatter cell tutorial. + * Checks that the catalog, cube, and measure with cell formatter exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + MeasureAttributeCheck measureSumAttributeCheck1 = factory.createMeasureAttributeCheck(); + measureSumAttributeCheck1.setExpectedAggregator(AggregatorType.SUM); + + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure1"); + measureCheck.setDescription("Check that measure 'Measure1' exists with cell formatter"); + measureCheck.setMeasureName("Measure1"); + measureCheck.getMeasureAttributeChecks().add(measureSumAttributeCheck1); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-CubeOneNumericMeasureDifferentDataTypes"); + cubeCheck.setDescription("Check that cube 'CubeOneNumericMeasureDifferentDataTypes' exists"); + cubeCheck.setCubeName("CubeOneNumericMeasureDifferentDataTypes"); + cubeCheck.getMeasureChecks().add(measureCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1]"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [CubeOneNumericMeasureDifferentDataTypes] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Formatter Cell"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Formatter Cell"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Formatter Cell' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Formatter Cell"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Formatter Cell"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Formatter Cell"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Formatter Cell"); + suite.setDescription("Check suite for the Daanse Tutorial - Formatter Cell"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/function/logic/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/function/logic/CheckSuiteSupplier.java b/instance/emf/tutorial/function/logic/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/function/logic/CheckSuiteSupplier.java new file mode 100644 index 00000000..2d7c3c4b --- /dev/null +++ b/instance/emf/tutorial/function/logic/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/function/logic/CheckSuiteSupplier.java @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.function.logic; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the function logic tutorial. + * Checks that the catalog, cube, measures, and calculated members with logic functions exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure checks + MeasureCheck measureCheckSum = factory.createMeasureCheck(); + measureCheckSum.setName("MeasureCheck-Measure-Sum"); + measureCheckSum.setDescription("Check that measure 'Measure-Sum' exists"); + measureCheckSum.setMeasureName("Measure-Sum"); + + MeasureCheck measureCheckCount = factory.createMeasureCheck(); + measureCheckCount.setName("MeasureCheck-Measure-Count"); + measureCheckCount.setDescription("Check that measure 'Measure-Count' exists"); + measureCheckCount.setMeasureName("Measure-Count"); + + // Create cube check with measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube logic functions"); + cubeCheck.setDescription("Check that cube 'Cube logic functions' exists"); + cubeCheck.setCubeName("Cube logic functions"); + cubeCheck.getMeasureChecks().add(measureCheckSum); + cubeCheck.getMeasureChecks().add(measureCheckCount); + + // Create query check for Measure-Sum + CellValueCheck queryCheckCellValueCheckSum = factory.createCellValueCheck(); + queryCheckCellValueCheckSum.setName("[Measures].[Measure-Sum]"); + + QueryCheck queryCheckSum = factory.createQueryCheck(); + queryCheckSum.setName("Measure-Sum Query Check"); + queryCheckSum.setDescription("Verify MDX query returns Measure-Sum data"); + queryCheckSum.setQuery("SELECT FROM [Cube logic functions] WHERE ([Measures].[Measure-Sum])"); + queryCheckSum.setQueryLanguage(QueryLanguage.MDX); + queryCheckSum.setExpectedColumnCount(1); + queryCheckSum.getCellChecks().add(queryCheckCellValueCheckSum); + queryCheckSum.setEnabled(true); + + // Create query check for Measure-Count + CellValueCheck queryCheckCellValueCheckCount = factory.createCellValueCheck(); + queryCheckCellValueCheckCount.setName("[Measures].[Measure-Count]"); + + QueryCheck queryCheckCount = factory.createQueryCheck(); + queryCheckCount.setName("Measure-Count Query Check"); + queryCheckCount.setDescription("Verify MDX query returns Measure-Count data"); + queryCheckCount.setQuery("SELECT FROM [Cube logic functions] WHERE ([Measures].[Measure-Count])"); + queryCheckCount.setQueryLanguage(QueryLanguage.MDX); + queryCheckCount.setExpectedColumnCount(1); + queryCheckCount.getCellChecks().add(queryCheckCellValueCheckCount); + queryCheckCount.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Function Logic"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Function Logic"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Function Logic' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Function Logic"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheckSum); + catalogCheck.getQueryChecks().add(queryCheckCount); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Function Logic"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Function Logic"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Function Logic"); + suite.setDescription("Check suite for the Daanse Tutorial - Function Logic"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/hierarchy/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/inlinetable/CheckSuiteSupplier.java b/instance/emf/tutorial/hierarchy/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/inlinetable/CheckSuiteSupplier.java new file mode 100644 index 00000000..1cc2f304 --- /dev/null +++ b/instance/emf/tutorial/hierarchy/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/inlinetable/CheckSuiteSupplier.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.hierarchy.inlinetable; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the hierarchy inline table tutorial. + * Checks that the catalog, cube, measure, and hierarchy with inline table exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure1"); + measureCheck.setDescription("Check that measure 'Measure1' exists"); + measureCheck.setMeasureName("Measure1"); + + // Create level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for Level1"); + levelCheck.setLevelName("Level1"); + + // Create hierarchy attribute check for hasAll + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for Hierarchy1"); + hierarchyCheck.setHierarchyName("Hierarchy1"); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for Dimension1"); + dimensionCheck.setDimensionName("Dimension1"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1]"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnDimKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDimKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDimKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckDimKey = factory.createDatabaseColumnCheck(); + columnCheckDimKey.setName("Database Column Check DIM_KEY"); + columnCheckDimKey.setColumnName("DIM_KEY"); + columnCheckDimKey.getColumnAttributeChecks().add(columnDimKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckDimKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create database column checks for HT inline table + DatabaseColumnAttributeCheck columnHTKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnHTKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnHTKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckHTKey = factory.createDatabaseColumnCheck(); + columnCheckHTKey.setName("Database Column Check KEY (HT)"); + columnCheckHTKey.setColumnName("KEY"); + columnCheckHTKey.getColumnAttributeChecks().add(columnHTKeyTypeCheck); + + DatabaseColumnAttributeCheck columnHTValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnHTValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnHTValueTypeCheck.setExpectedValue("NUMERIC"); + + DatabaseColumnCheck columnCheckHTValue = factory.createDatabaseColumnCheck(); + columnCheckHTValue.setName("Database Column Check VALUE (HT)"); + columnCheckHTValue.setColumnName("VALUE"); + columnCheckHTValue.getColumnAttributeChecks().add(columnHTValueTypeCheck); + + DatabaseColumnAttributeCheck columnHTNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnHTNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnHTNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckHTName = factory.createDatabaseColumnCheck(); + columnCheckHTName.setName("Database Column Check NAME (HT)"); + columnCheckHTName.setColumnName("NAME"); + columnCheckHTName.getColumnAttributeChecks().add(columnHTNameTypeCheck); + + DatabaseTableCheck databaseTableCheckHT = factory.createDatabaseTableCheck(); + databaseTableCheckHT.setName("Database Table HT Check"); + databaseTableCheckHT.setTableName("HT"); + databaseTableCheckHT.getColumnChecks().add(columnCheckHTKey); + databaseTableCheckHT.getColumnChecks().add(columnCheckHTValue); + databaseTableCheckHT.getColumnChecks().add(columnCheckHTName); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Inline Table"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckHT); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Inline Table"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Inline Table' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Inline Table"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Inline Table"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Inline Table"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Inline Table"); + suite.setDescription("Check suite for the Daanse Tutorial - Inline Table"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/hierarchy/uniquekeylevelname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/uniquekeylevelname/CheckSuiteSupplier.java b/instance/emf/tutorial/hierarchy/uniquekeylevelname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/uniquekeylevelname/CheckSuiteSupplier.java new file mode 100644 index 00000000..715d34ad --- /dev/null +++ b/instance/emf/tutorial/hierarchy/uniquekeylevelname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/uniquekeylevelname/CheckSuiteSupplier.java @@ -0,0 +1,313 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.hierarchy.uniquekeylevelname; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the unique key level name hierarchy tutorial. + * Checks that the catalog, cube, measure, and hierarchy with unique key level name optimization exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure"); + measureCheck.setDescription("Check that measure 'Measure' exists"); + measureCheck.setMeasureName("Measure"); + + // Create level checks for Automotive dimension + LevelCheck levelMakeCheck = factory.createLevelCheck(); + levelMakeCheck.setName("LevelCheck for Make"); + levelMakeCheck.setLevelName("Make"); + + LevelCheck levelModelCheck = factory.createLevelCheck(); + levelModelCheck.setName("LevelCheck for Model"); + levelModelCheck.setLevelName("Model"); + + LevelCheck levelManufacturingPlantCheck = factory.createLevelCheck(); + levelManufacturingPlantCheck.setName("LevelCheck for ManufacturingPlant"); + levelManufacturingPlantCheck.setLevelName("ManufacturingPlant"); + + LevelCheck levelVehicleCheck = factory.createLevelCheck(); + levelVehicleCheck.setName("LevelCheck for Vehicle Identification Number"); + levelVehicleCheck.setLevelName("Vehicle Identification Number"); + + LevelCheck levelLicensePlateCheck = factory.createLevelCheck(); + levelLicensePlateCheck.setName("LevelCheck for LicensePlateNum"); + levelLicensePlateCheck.setLevelName("LicensePlateNum"); + + // Create hierarchy attribute check for hasAll + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check for Automotive dimension + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for Automotive"); + hierarchyCheck.setHierarchyName("Automotive"); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck.getLevelChecks().add(levelMakeCheck); + hierarchyCheck.getLevelChecks().add(levelModelCheck); + hierarchyCheck.getLevelChecks().add(levelManufacturingPlantCheck); + hierarchyCheck.getLevelChecks().add(levelVehicleCheck); + hierarchyCheck.getLevelChecks().add(levelLicensePlateCheck); + + // Create dimension check for Automotive + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for Automotive"); + dimensionCheck.setDimensionName("Automotive"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure]"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for AUTOMOTIVE_DIM table + DatabaseColumnAttributeCheck columnAutoDimIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnAutoDimIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnAutoDimIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckAutoDimId = factory.createDatabaseColumnCheck(); + columnCheckAutoDimId.setName("Database Column Check AUTO_DIM_ID"); + columnCheckAutoDimId.setColumnName("AUTO_DIM_ID"); + columnCheckAutoDimId.getColumnAttributeChecks().add(columnAutoDimIdTypeCheck); + + DatabaseColumnAttributeCheck columnMakeIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMakeIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMakeIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckMakeId = factory.createDatabaseColumnCheck(); + columnCheckMakeId.setName("Database Column Check MAKE_ID"); + columnCheckMakeId.setColumnName("MAKE_ID"); + columnCheckMakeId.getColumnAttributeChecks().add(columnMakeIdTypeCheck); + + DatabaseColumnAttributeCheck columnMakeTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMakeTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMakeTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckMake = factory.createDatabaseColumnCheck(); + columnCheckMake.setName("Database Column Check MAKE"); + columnCheckMake.setColumnName("MAKE"); + columnCheckMake.getColumnAttributeChecks().add(columnMakeTypeCheck); + + DatabaseColumnAttributeCheck columnModelIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnModelIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnModelIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckModelId = factory.createDatabaseColumnCheck(); + columnCheckModelId.setName("Database Column Check MODEL_ID"); + columnCheckModelId.setColumnName("MODEL_ID"); + columnCheckModelId.getColumnAttributeChecks().add(columnModelIdTypeCheck); + + DatabaseColumnAttributeCheck columnModelTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnModelTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnModelTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckModel = factory.createDatabaseColumnCheck(); + columnCheckModel.setName("Database Column Check MODEL"); + columnCheckModel.setColumnName("MODEL"); + columnCheckModel.getColumnAttributeChecks().add(columnModelTypeCheck); + + DatabaseColumnAttributeCheck columnPlantIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnPlantIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnPlantIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckPlantId = factory.createDatabaseColumnCheck(); + columnCheckPlantId.setName("Database Column Check PLANT_ID"); + columnCheckPlantId.setColumnName("PLANT_ID"); + columnCheckPlantId.getColumnAttributeChecks().add(columnPlantIdTypeCheck); + + DatabaseColumnAttributeCheck columnPlantTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnPlantTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnPlantTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckPlant = factory.createDatabaseColumnCheck(); + columnCheckPlant.setName("Database Column Check PLANT"); + columnCheckPlant.setColumnName("PLANT"); + columnCheckPlant.getColumnAttributeChecks().add(columnPlantTypeCheck); + + DatabaseColumnAttributeCheck columnPlantStateIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnPlantStateIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnPlantStateIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckPlantStateId = factory.createDatabaseColumnCheck(); + columnCheckPlantStateId.setName("Database Column Check PLANT_STATE_ID"); + columnCheckPlantStateId.setColumnName("PLANT_STATE_ID"); + columnCheckPlantStateId.getColumnAttributeChecks().add(columnPlantStateIdTypeCheck); + + DatabaseColumnAttributeCheck columnPlantCityIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnPlantCityIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnPlantCityIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckPlantCityId = factory.createDatabaseColumnCheck(); + columnCheckPlantCityId.setName("Database Column Check PLANT_CITY_ID"); + columnCheckPlantCityId.setColumnName("PLANT_CITY_ID"); + columnCheckPlantCityId.getColumnAttributeChecks().add(columnPlantCityIdTypeCheck); + + DatabaseColumnAttributeCheck columnVehicleIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnVehicleIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnVehicleIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckVehicleId = factory.createDatabaseColumnCheck(); + columnCheckVehicleId.setName("Database Column Check VEHICLE_ID"); + columnCheckVehicleId.setColumnName("VEHICLE_ID"); + columnCheckVehicleId.getColumnAttributeChecks().add(columnVehicleIdTypeCheck); + + DatabaseColumnAttributeCheck columnColorIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnColorIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnColorIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckColorId = factory.createDatabaseColumnCheck(); + columnCheckColorId.setName("Database Column Check COLOR_ID"); + columnCheckColorId.setColumnName("COLOR_ID"); + columnCheckColorId.getColumnAttributeChecks().add(columnColorIdTypeCheck); + + DatabaseColumnAttributeCheck columnTrimIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTrimIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTrimIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTrimId = factory.createDatabaseColumnCheck(); + columnCheckTrimId.setName("Database Column Check TRIM_ID"); + columnCheckTrimId.setColumnName("TRIM_ID"); + columnCheckTrimId.getColumnAttributeChecks().add(columnTrimIdTypeCheck); + + DatabaseColumnAttributeCheck columnLicenseIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLicenseIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLicenseIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLicenseId = factory.createDatabaseColumnCheck(); + columnCheckLicenseId.setName("Database Column Check LICENSE_ID"); + columnCheckLicenseId.setColumnName("LICENSE_ID"); + columnCheckLicenseId.getColumnAttributeChecks().add(columnLicenseIdTypeCheck); + + DatabaseColumnAttributeCheck columnLicenseTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLicenseTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLicenseTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckLicense = factory.createDatabaseColumnCheck(); + columnCheckLicense.setName("Database Column Check LICENSE"); + columnCheckLicense.setColumnName("LICENSE"); + columnCheckLicense.getColumnAttributeChecks().add(columnLicenseTypeCheck); + + DatabaseColumnAttributeCheck columnLicenseStateIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLicenseStateIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLicenseStateIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLicenseStateId = factory.createDatabaseColumnCheck(); + columnCheckLicenseStateId.setName("Database Column Check LICENSE_STATE_ID"); + columnCheckLicenseStateId.setColumnName("LICENSE_STATE_ID"); + columnCheckLicenseStateId.getColumnAttributeChecks().add(columnLicenseStateIdTypeCheck); + + DatabaseColumnAttributeCheck columnPriceTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnPriceTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnPriceTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckPrice = factory.createDatabaseColumnCheck(); + columnCheckPrice.setName("Database Column Check PRICE"); + columnCheckPrice.setColumnName("PRICE"); + columnCheckPrice.getColumnAttributeChecks().add(columnPriceTypeCheck); + + // Create Database Table Check + DatabaseTableCheck databaseTableCheckAutomotiveDim = factory.createDatabaseTableCheck(); + databaseTableCheckAutomotiveDim.setName("Database Table AUTOMOTIVE_DIM Check"); + databaseTableCheckAutomotiveDim.setTableName("AUTOMOTIVE_DIM"); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckAutoDimId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckMakeId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckMake); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckModelId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckModel); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckPlantId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckPlant); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckPlantStateId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckPlantCityId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckVehicleId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckColorId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckTrimId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckLicenseId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckLicense); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckLicenseStateId); + databaseTableCheckAutomotiveDim.getColumnChecks().add(columnCheckPrice); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Unique Key Level Name"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckAutomotiveDim); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Unique Key Level Name"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Unique Key Level Name' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Unique Key Level Name"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Unique Key Level Name"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Unique Key Level Name"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Unique Key Level Name"); + suite.setDescription("Check suite for the Daanse Tutorial - Unique Key Level Name"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/hierarchy/view/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/view/CheckSuiteSupplier.java b/instance/emf/tutorial/hierarchy/view/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/view/CheckSuiteSupplier.java new file mode 100644 index 00000000..1788c1fc --- /dev/null +++ b/instance/emf/tutorial/hierarchy/view/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/hierarchy/view/CheckSuiteSupplier.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.hierarchy.view; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the unique key level name hierarchy tutorial. + * Checks that the catalog, cube, measure, and hierarchy with unique key level name optimization exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure1"); + measureCheck.setDescription("Check that measure 'Measure1' exists"); + measureCheck.setMeasureName("Measure1"); + + // Create level checks + LevelCheck level1Check = factory.createLevelCheck(); + level1Check.setName("LevelCheck for Level1"); + level1Check.setLevelName("Level1"); + + // Create hierarchy attribute check for hasAll + HierarchyAttributeCheck hierarchyAttributeCheck = factory.createHierarchyAttributeCheck(); + hierarchyAttributeCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyAttributeCheck.setExpectedBoolean(true); + + // Create hierarchy check for Automotive dimension + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for Hierarchy"); + hierarchyCheck.setHierarchyName("Hierarchy"); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAttributeCheck); + hierarchyCheck.getLevelChecks().add(level1Check); + + // Create dimension check for Automotive + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for Dimension"); + dimensionCheck.setDimensionName("Dimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1]"); + queryCheckCellValueCheck.setExpectedValue("63"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnDimKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDimKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDimKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckDimKey = factory.createDatabaseColumnCheck(); + columnCheckDimKey.setName("Database Column Check DIM_KEY"); + columnCheckDimKey.setColumnName("DIM_KEY"); + columnCheckDimKey.getColumnAttributeChecks().add(columnDimKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckDimKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckHTKey = factory.createDatabaseColumnCheck(); + columnCheckHTKey.setName("Database Column Check KEY"); + columnCheckHTKey.setColumnName("KEY"); + columnCheckHTKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckHTName = factory.createDatabaseColumnCheck(); + columnCheckHTName.setName("Database Column Check NAME"); + columnCheckHTName.setColumnName("NAME"); + columnCheckHTName.getColumnAttributeChecks().add(columnNameTypeCheck); + + DatabaseColumnAttributeCheck columnHTValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnHTValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnHTValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckHTValue = factory.createDatabaseColumnCheck(); + columnCheckHTValue.setName("Database Column Check VALUE"); + columnCheckHTValue.setColumnName("VALUE"); + columnCheckHTValue.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseTableCheck databaseTableCheckHT = factory.createDatabaseTableCheck(); + databaseTableCheckHT.setName("Database Table HT Check"); + databaseTableCheckHT.setTableName("HT"); + databaseTableCheckHT.getColumnChecks().add(columnCheckHTKey); + databaseTableCheckHT.getColumnChecks().add(columnCheckHTName); + databaseTableCheckHT.getColumnChecks().add(columnCheckHTValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Hierarchy View"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckHT); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Hierarchy View"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Hierarchy View' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - Hierarchy View"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Hierarchy View"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Hierarchy View"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Hierarchy View"); + suite.setDescription("Check suite for the Daanse Tutorial - Hierarchy View"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/kpi/all/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/all/CheckSuiteSupplier.java b/instance/emf/tutorial/kpi/all/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/all/CheckSuiteSupplier.java new file mode 100644 index 00000000..e189528e --- /dev/null +++ b/instance/emf/tutorial/kpi/all/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/all/CheckSuiteSupplier.java @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.kpi.all; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.KPIAttribute; +import org.eclipse.daanse.olap.check.model.check.KPIAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.KPICheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the unique key level name hierarchy tutorial. + * Checks that the catalog, cube, measure, and hierarchy with unique key level name optimization exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureSumCheck = factory.createMeasureCheck(); + measureSumCheck.setName("MeasureCheck-Measure1-Sum"); + measureSumCheck.setDescription("Check that measure 'Measure1-Sum' exists"); + measureSumCheck.setMeasureName("Measure1-Sum"); + + MeasureCheck measureCountCheck = factory.createMeasureCheck(); + measureCountCheck.setName("MeasureCheck-Measure2-Count"); + measureCountCheck.setDescription("Check that measure 'Measure2-Count' exists"); + measureCountCheck.setMeasureName("Measure2-Count"); + + KPIAttributeCheck kpiAttributeValueCheck = factory.createKPIAttributeCheck(); + kpiAttributeValueCheck.setAttributeType(KPIAttribute.VALUE); + kpiAttributeValueCheck.setExpectedValue("[Measures].[CalculatedValue]"); + + KPIAttributeCheck kpiAttributeGoalCheck = factory.createKPIAttributeCheck(); + kpiAttributeGoalCheck.setAttributeType(KPIAttribute.GOAL); + kpiAttributeGoalCheck.setExpectedValue("[Measures].[CalculatedGoal]"); + + KPIAttributeCheck kpiAttributeStatusCheck = factory.createKPIAttributeCheck(); + kpiAttributeStatusCheck.setAttributeType(KPIAttribute.STATUS); + kpiAttributeStatusCheck.setExpectedValue("[Measures].[CalculatedStatus]"); + + KPIAttributeCheck kpiAttributeTrendCheck = factory.createKPIAttributeCheck(); + kpiAttributeTrendCheck.setAttributeType(KPIAttribute.TREND); + kpiAttributeTrendCheck.setExpectedValue("[Measures].[CalculatedTrend]"); + + KPIAttributeCheck kpiAttributeWeightCheck = factory.createKPIAttributeCheck(); + kpiAttributeWeightCheck.setAttributeType(KPIAttribute.WEIGHT); + kpiAttributeWeightCheck.setExpectedValue("[Measures].[CalculatedValue]"); + + KPIAttributeCheck kpiAttributeCurrentTimeMemberCheck = factory.createKPIAttributeCheck(); + kpiAttributeCurrentTimeMemberCheck.setAttributeType(KPIAttribute.CURRENT_TIME_MEMBER); + kpiAttributeCurrentTimeMemberCheck.setExpectedValue("[Measures].[CalculatedValue]"); + + KPIAttributeCheck kpiAttributeDisplayFolderCheck = factory.createKPIAttributeCheck(); + kpiAttributeDisplayFolderCheck.setAttributeType(KPIAttribute.DISPLAY_FOLDER); + kpiAttributeDisplayFolderCheck.setExpectedValue("Kpi1Folder1\\Kpi1Folder2"); + + KPIAttributeCheck kpiAttributeStatusGraphicCheck = factory.createKPIAttributeCheck(); + kpiAttributeStatusGraphicCheck.setAttributeType(KPIAttribute.STATUS_GRAPHIC); + kpiAttributeStatusGraphicCheck.setExpectedValue("Cylinder"); + + KPIAttributeCheck kpiAttributeTrendGraphicCheck = factory.createKPIAttributeCheck(); + kpiAttributeTrendGraphicCheck.setAttributeType(KPIAttribute.TREND_GRAPHIC); + kpiAttributeTrendGraphicCheck.setExpectedValue("Smiley Face"); + + // Create level checks + KPICheck kpiCheck = factory.createKPICheck(); + kpiCheck.setName("kpi Check for Kpi1"); + kpiCheck.setKpiName("Kpi1"); + kpiCheck.getKpiAttributeChecks().add(kpiAttributeValueCheck); + kpiCheck.getKpiAttributeChecks().add(kpiAttributeGoalCheck); + kpiCheck.getKpiAttributeChecks().add(kpiAttributeStatusCheck); + kpiCheck.getKpiAttributeChecks().add(kpiAttributeTrendCheck); + kpiCheck.getKpiAttributeChecks().add(kpiAttributeWeightCheck); + kpiCheck.getKpiAttributeChecks().add(kpiAttributeCurrentTimeMemberCheck); + kpiCheck.getKpiAttributeChecks().add(kpiAttributeDisplayFolderCheck); + kpiCheck.getKpiAttributeChecks().add(kpiAttributeStatusGraphicCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-CubeKPI"); + cubeCheck.setDescription("Check that cube 'CubeKPI' exists"); + cubeCheck.setCubeName("CubeKPI"); + cubeCheck.getMeasureChecks().add(measureSumCheck); + cubeCheck.getMeasureChecks().add(measureCountCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1-Sum]"); + queryCheckCellValueCheck.setExpectedValue("63"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [CubeKPI] WHERE ([Measures].[Measure1-Sum])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + CellValueCheck queryCheckCellValueCheck2 = factory.createCellValueCheck(); + queryCheckCellValueCheck2.setName("[Measures].[Measure2-Count]"); + queryCheckCellValueCheck2.setExpectedValue("2"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure Query Check"); + queryCheck2.setDescription("Verify MDX query returns Measure data"); + queryCheck2.setQuery("SELECT FROM [CubeKPI] WHERE ([Measures].[Measure2-Count])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheckCellValueCheck2); + queryCheck2.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnDimKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDimKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDimKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckDimKey = factory.createDatabaseColumnCheck(); + columnCheckDimKey.setName("Database Column Check DIM_KEY"); + columnCheckDimKey.setColumnName("DIM_KEY"); + columnCheckDimKey.getColumnAttributeChecks().add(columnDimKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseColumnAttributeCheck columnValueNumerucTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueNumerucTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueNumerucTypeCheck.setExpectedValue("NUMERIC"); + + DatabaseColumnCheck columnCheckValueNumeric = factory.createDatabaseColumnCheck(); + columnCheckValueNumeric.setName("Database Column Check VALUE"); + columnCheckValueNumeric.setColumnName("VALUE_NUMERIC"); + columnCheckValueNumeric.getColumnAttributeChecks().add(columnValueNumerucTypeCheck); + + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckDimKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + databaseTableCheckFact.getColumnChecks().add(columnCheckValueNumeric); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - KPI All"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - KPI All"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - KPI All' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - KPI All"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - KPI All"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - KPI All"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - KPI All"); + suite.setDescription("Check suite for the Daanse Tutorial - KPI All"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/kpi/intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/intro/CheckSuiteSupplier.java b/instance/emf/tutorial/kpi/intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/intro/CheckSuiteSupplier.java new file mode 100644 index 00000000..7a40d7a8 --- /dev/null +++ b/instance/emf/tutorial/kpi/intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/intro/CheckSuiteSupplier.java @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.kpi.intro; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.KPIAttribute; +import org.eclipse.daanse.olap.check.model.check.KPIAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.KPICheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the KPI intro tutorial. + * Checks that the catalog, cube, measure, and KPIs exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureSumCheck = factory.createMeasureCheck(); + measureSumCheck.setName("MeasureCheck-Measure1-Sum"); + measureSumCheck.setDescription("Check that measure 'Measure1-Sum' exists"); + measureSumCheck.setMeasureName("Measure1-Sum"); + + // Create KPI1 attribute check (value only) + KPIAttributeCheck kpi1ValueCheck = factory.createKPIAttributeCheck(); + kpi1ValueCheck.setAttributeType(KPIAttribute.VALUE); + kpi1ValueCheck.setExpectedValue("[Measures].[Measure1-Sum]"); + + // Create KPI1 check + KPICheck kpi1Check = factory.createKPICheck(); + kpi1Check.setName("KPI Check for Kpi1"); + kpi1Check.setDescription("Check KPI 'Kpi1' with value only"); + kpi1Check.setKpiName("Kpi1"); + kpi1Check.getKpiAttributeChecks().add(kpi1ValueCheck); + + // Create KPI2 attribute check (value) + KPIAttributeCheck kpi2ValueCheck = factory.createKPIAttributeCheck(); + kpi2ValueCheck.setAttributeType(KPIAttribute.VALUE); + kpi2ValueCheck.setExpectedValue("[Measures].[Measure1-Sum]"); + + // Create KPI2 check + KPICheck kpi2Check = factory.createKPICheck(); + kpi2Check.setName("KPI Check for Kpi2"); + kpi2Check.setDescription("Check KPI 'Kpi2' with parent reference"); + kpi2Check.setKpiName("Kpi2"); + kpi2Check.getKpiAttributeChecks().add(kpi2ValueCheck); + + // Create KPI3 attribute checks (value and display folder) + KPIAttributeCheck kpi3ValueCheck = factory.createKPIAttributeCheck(); + kpi3ValueCheck.setAttributeType(KPIAttribute.VALUE); + kpi3ValueCheck.setExpectedValue("[Measures].[Measure1-Sum]"); + + KPIAttributeCheck kpi3DisplayFolderCheck = factory.createKPIAttributeCheck(); + kpi3DisplayFolderCheck.setAttributeType(KPIAttribute.DISPLAY_FOLDER); + kpi3DisplayFolderCheck.setExpectedValue("theDisplayFolder\\otherDisplayFolder"); + + // Create KPI3 check + KPICheck kpi3Check = factory.createKPICheck(); + kpi3Check.setName("KPI Check for Kpi3"); + kpi3Check.setDescription("Check KPI 'Kpi3' with display folder"); + kpi3Check.setKpiName("Kpi3"); + kpi3Check.getKpiAttributeChecks().add(kpi3ValueCheck); + kpi3Check.getKpiAttributeChecks().add(kpi3DisplayFolderCheck); + + // Create cube check with measure and KPI checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube Kpi"); + cubeCheck.setDescription("Check that cube 'Cube Kpi' exists"); + cubeCheck.setCubeName("Cube Kpi"); + cubeCheck.getMeasureChecks().add(measureSumCheck); + cubeCheck.getKpiChecks().add(kpi1Check); + cubeCheck.getKpiChecks().add(kpi2Check); + cubeCheck.getKpiChecks().add(kpi3Check); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1-Sum]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube Kpi] WHERE ([Measures].[Measure1-Sum])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - KPI Intro"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - KPI Intro"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - KPI Intro' exists with its cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - KPI Intro"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - KPI Intro"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - KPI Intro"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - KPI Intro"); + suite.setDescription("Check suite for the Daanse Tutorial - KPI Intro"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/kpi/parent.ring/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/parent/ring/CheckSuiteSupplier.java b/instance/emf/tutorial/kpi/parent.ring/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/parent/ring/CheckSuiteSupplier.java new file mode 100644 index 00000000..a1e44ad6 --- /dev/null +++ b/instance/emf/tutorial/kpi/parent.ring/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/parent/ring/CheckSuiteSupplier.java @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.kpi.parent.ring; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.KPIAttribute; +import org.eclipse.daanse.olap.check.model.check.KPIAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.KPICheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the KPI parent ring tutorial. + * Checks that the catalog, cube, measure, and KPIs with circular parent relationships exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureSumCheck = factory.createMeasureCheck(); + measureSumCheck.setName("MeasureCheck-Measure1-Sum"); + measureSumCheck.setDescription("Check that measure 'Measure1-Sum' exists"); + measureSumCheck.setMeasureName("Measure1-Sum"); + + // Create KPI1 attribute check (value) + KPIAttributeCheck kpi1ValueCheck = factory.createKPIAttributeCheck(); + kpi1ValueCheck.setAttributeType(KPIAttribute.VALUE); + kpi1ValueCheck.setExpectedValue("[Measures].[Measure1-Sum]"); + + // Create KPI1 check + KPICheck kpi1Check = factory.createKPICheck(); + kpi1Check.setName("KPI Check for Kpi1"); + kpi1Check.setDescription("Check KPI 'Kpi1' with parent Kpi3 (circular reference)"); + kpi1Check.setKpiName("Kpi1"); + kpi1Check.getKpiAttributeChecks().add(kpi1ValueCheck); + + // Create KPI2 attribute check (value) + KPIAttributeCheck kpi2ValueCheck = factory.createKPIAttributeCheck(); + kpi2ValueCheck.setAttributeType(KPIAttribute.VALUE); + kpi2ValueCheck.setExpectedValue("[Measures].[Measure1-Sum]"); + + // Create KPI2 check + KPICheck kpi2Check = factory.createKPICheck(); + kpi2Check.setName("KPI Check for Kpi2"); + kpi2Check.setDescription("Check KPI 'Kpi2' with parent Kpi1"); + kpi2Check.setKpiName("Kpi2"); + kpi2Check.getKpiAttributeChecks().add(kpi2ValueCheck); + + // Create KPI3 attribute check (value) + KPIAttributeCheck kpi3ValueCheck = factory.createKPIAttributeCheck(); + kpi3ValueCheck.setAttributeType(KPIAttribute.VALUE); + kpi3ValueCheck.setExpectedValue("[Measures].[Measure1-Sum]"); + + // Create KPI3 check + KPICheck kpi3Check = factory.createKPICheck(); + kpi3Check.setName("KPI Check for Kpi3"); + kpi3Check.setDescription("Check KPI 'Kpi3' with parent Kpi1 (creates circular reference)"); + kpi3Check.setKpiName("Kpi3"); + kpi3Check.getKpiAttributeChecks().add(kpi3ValueCheck); + + // Create cube check with measure and KPI checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube Kpi"); + cubeCheck.setDescription("Check that cube 'Cube Kpi' exists"); + cubeCheck.setCubeName("Cube Kpi"); + cubeCheck.getMeasureChecks().add(measureSumCheck); + cubeCheck.getKpiChecks().add(kpi1Check); + cubeCheck.getKpiChecks().add(kpi2Check); + cubeCheck.getKpiChecks().add(kpi3Check); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1-Sum]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube Kpi] WHERE ([Measures].[Measure1-Sum])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - KPI Parent Ring"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - KPI Parent Ring"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - KPI Parent Ring' exists with circular KPI parent relationships"); + catalogCheck.setCatalogName("Daanse Tutorial - KPI Parent Ring"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - KPI Parent Ring"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - KPI Parent Ring"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - KPI Parent Ring"); + suite.setDescription("Check suite for the Daanse Tutorial - KPI Parent Ring (circular parent references)"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/kpi/virtualcube/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/virtualcube/CheckSuiteSupplier.java b/instance/emf/tutorial/kpi/virtualcube/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/virtualcube/CheckSuiteSupplier.java new file mode 100644 index 00000000..eee1748f --- /dev/null +++ b/instance/emf/tutorial/kpi/virtualcube/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/kpi/virtualcube/CheckSuiteSupplier.java @@ -0,0 +1,235 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.kpi.virtualcube; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.KPIAttribute; +import org.eclipse.daanse.olap.check.model.check.KPIAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.KPICheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the KPI virtual cube tutorial. + * Checks that the catalog, physical cubes, virtual cube, measures, calculated members, and KPIs exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure checks for Cube1 + MeasureCheck measureCube1Check = factory.createMeasureCheck(); + measureCube1Check.setName("MeasureCheck-MeasureCube1"); + measureCube1Check.setDescription("Check that measure 'MeasureCube1' exists"); + measureCube1Check.setMeasureName("MeasureCube1"); + + // Create dimension check for Cube1 + DimensionCheck dimensionCube1Check = factory.createDimensionCheck(); + dimensionCube1Check.setName("DimensionCheck-Cube1Dimension1"); + dimensionCube1Check.setDescription("Check that dimension 'Cube1Dimension1' exists"); + dimensionCube1Check.setDimensionName("Cube1Dimension1"); + + // Create Cube1 check + CubeCheck cube1Check = factory.createCubeCheck(); + cube1Check.setName("CubeCheck-Cube1"); + cube1Check.setDescription("Check that cube 'Cube1' exists"); + cube1Check.setCubeName("Cube1"); + cube1Check.getMeasureChecks().add(measureCube1Check); + cube1Check.getDimensionChecks().add(dimensionCube1Check); + + // Create measure checks for Cube2 + MeasureCheck measureCube2Check = factory.createMeasureCheck(); + measureCube2Check.setName("MeasureCheck-MeasureCube2"); + measureCube2Check.setDescription("Check that measure 'MeasureCube2' exists"); + measureCube2Check.setMeasureName("MeasureCube2"); + + // Create dimension check for Cube2 + DimensionCheck dimensionCube2Check = factory.createDimensionCheck(); + dimensionCube2Check.setName("DimensionCheck-Cube2Dimension1"); + dimensionCube2Check.setDescription("Check that dimension 'Cube2Dimension1' exists"); + dimensionCube2Check.setDimensionName("Cube2Dimension1"); + + // Create Cube2 check + CubeCheck cube2Check = factory.createCubeCheck(); + cube2Check.setName("CubeCheck-Cube2"); + cube2Check.setDescription("Check that cube 'Cube2' exists"); + cube2Check.setCubeName("Cube2"); + cube2Check.getMeasureChecks().add(measureCube2Check); + cube2Check.getDimensionChecks().add(dimensionCube2Check); + + // Create measure checks for Virtual Cube (includes measures from both physical cubes) + MeasureCheck vCubeMeasure1Check = factory.createMeasureCheck(); + vCubeMeasure1Check.setName("MeasureCheck-MeasureCube1"); + vCubeMeasure1Check.setDescription("Check that measure 'MeasureCube1' exists in virtual cube"); + vCubeMeasure1Check.setMeasureName("MeasureCube1"); + + MeasureCheck vCubeMeasure2Check = factory.createMeasureCheck(); + vCubeMeasure2Check.setName("MeasureCheck-MeasureCube2"); + vCubeMeasure2Check.setDescription("Check that measure 'MeasureCube2' exists in virtual cube"); + vCubeMeasure2Check.setMeasureName("MeasureCube2"); + + // Create calculated member checks + MeasureCheck calculatedValueCheck = factory.createMeasureCheck(); + calculatedValueCheck.setName("MeasureCheck-CalculatedValue"); + calculatedValueCheck.setDescription("Check that calculated member 'CalculatedValue' exists"); + calculatedValueCheck.setMeasureName("CalculatedValue"); + + MeasureCheck calculatedTrendCheck = factory.createMeasureCheck(); + calculatedTrendCheck.setName("MeasureCheck-CalculatedTrend"); + calculatedTrendCheck.setDescription("Check that calculated member 'CalculatedTrend' exists"); + calculatedTrendCheck.setMeasureName("CalculatedTrend"); + + // Create KPI attribute checks + KPIAttributeCheck kpiValueCheck = factory.createKPIAttributeCheck(); + kpiValueCheck.setAttributeType(KPIAttribute.VALUE); + kpiValueCheck.setExpectedValue("[Measures].[CalculatedValue]"); + + KPIAttributeCheck kpiTrendCheck = factory.createKPIAttributeCheck(); + kpiTrendCheck.setAttributeType(KPIAttribute.TREND); + kpiTrendCheck.setExpectedValue("[Measures].[CalculatedTrend]"); + + KPIAttributeCheck kpiDisplayFolderCheck = factory.createKPIAttributeCheck(); + kpiDisplayFolderCheck.setAttributeType(KPIAttribute.DISPLAY_FOLDER); + kpiDisplayFolderCheck.setExpectedValue("Kpi1Folder1\\Kpi1Folder3"); + + // Create KPI check + KPICheck kpiCheck = factory.createKPICheck(); + kpiCheck.setName("KPI Check for Kpi1"); + kpiCheck.setDescription("Check KPI 'Kpi1' in virtual cube with calculated members"); + kpiCheck.setKpiName("Kpi1"); + kpiCheck.getKpiAttributeChecks().add(kpiValueCheck); + kpiCheck.getKpiAttributeChecks().add(kpiTrendCheck); + kpiCheck.getKpiAttributeChecks().add(kpiDisplayFolderCheck); + + // Create dimension checks for Virtual Cube + DimensionCheck vCubeDimension1Check = factory.createDimensionCheck(); + vCubeDimension1Check.setName("DimensionCheck-Cube1Dimension1"); + vCubeDimension1Check.setDescription("Check that dimension 'Cube1Dimension1' exists in virtual cube"); + vCubeDimension1Check.setDimensionName("Cube1Dimension1"); + + DimensionCheck vCubeDimension2Check = factory.createDimensionCheck(); + vCubeDimension2Check.setName("DimensionCheck-Cube2Dimension1"); + vCubeDimension2Check.setDescription("Check that dimension 'Cube2Dimension1' exists in virtual cube"); + vCubeDimension2Check.setDimensionName("Cube2Dimension1"); + + // Create Virtual Cube check + CubeCheck vCubeCheck = factory.createCubeCheck(); + vCubeCheck.setName("CubeCheck-Cube1Cube2Kpi"); + vCubeCheck.setDescription("Check that virtual cube 'Cube1Cube2Kpi' exists with KPI"); + vCubeCheck.setCubeName("Cube1Cube2Kpi"); + vCubeCheck.getMeasureChecks().add(vCubeMeasure1Check); + vCubeCheck.getMeasureChecks().add(vCubeMeasure2Check); + vCubeCheck.getMeasureChecks().add(calculatedValueCheck); + vCubeCheck.getMeasureChecks().add(calculatedTrendCheck); + vCubeCheck.getKpiChecks().add(kpiCheck); + vCubeCheck.getDimensionChecks().add(vCubeDimension1Check); + vCubeCheck.getDimensionChecks().add(vCubeDimension2Check); + + // Create query check for virtual cube + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[CalculatedValue]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Virtual Cube Query Check"); + queryCheck.setDescription("Verify MDX query returns calculated member data"); + queryCheck.setQuery("SELECT FROM [Cube1Cube2Kpi] WHERE ([Measures].[CalculatedValue])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseColumnAttributeCheck columnValueNumericTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueNumericTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueNumericTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValueNumeric = factory.createDatabaseColumnCheck(); + columnCheckValueNumeric.setName("Database Column Check VALUE_NUMERIC"); + columnCheckValueNumeric.setColumnName("VALUE_NUMERIC"); + columnCheckValueNumeric.getColumnAttributeChecks().add(columnValueNumericTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + databaseTableCheckFact.getColumnChecks().add(columnCheckValueNumeric); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - KPI Virtual Cube"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with all cube checks + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - KPI Virtual Cube"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - KPI Virtual Cube' exists with physical and virtual cubes"); + catalogCheck.setCatalogName("Daanse Tutorial - KPI Virtual Cube"); + catalogCheck.getCubeChecks().add(cube1Check); + catalogCheck.getCubeChecks().add(cube2Check); + catalogCheck.getCubeChecks().add(vCubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - KPI Virtual Cube"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - KPI Virtual Cube"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - KPI Virtual Cube"); + suite.setDescription("Check suite for the Daanse Tutorial - KPI Virtual Cube with calculated members"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/level/expressions/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/expressions/CheckSuiteSupplier.java b/instance/emf/tutorial/level/expressions/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/expressions/CheckSuiteSupplier.java new file mode 100644 index 00000000..a91fa786 --- /dev/null +++ b/instance/emf/tutorial/level/expressions/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/expressions/CheckSuiteSupplier.java @@ -0,0 +1,178 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.level.expressions; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelAttribute; +import org.eclipse.daanse.olap.check.model.check.LevelAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the level expressions tutorial. + * Checks that the catalog, cube, dimension, hierarchy, levels with SQL expression columns, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure"); + measureCheck.setDescription("Check that measure 'Measure' exists"); + measureCheck.setMeasureName("Measure"); + + //LevelAttributeCheck levelAttributeCheck = factory.createLevelAttributeCheck(); + //levelAttributeCheck.setAttributeType(LevelAttribute.LEVEL_TYPE); + + // Create level checks + LevelCheck level1Check = factory.createLevelCheck(); + level1Check.setName("LevelCheck-Level1"); + level1Check.setDescription("Check that level 'Level1' exists with expression-based name column"); + level1Check.setLevelName("Level1"); + //level1Check.getLevelAttributeChecks().add(levelAttributeCheck); + + LevelCheck level2Check = factory.createLevelCheck(); + level2Check.setName("LevelCheck-Level2"); + level2Check.setDescription("Check that level 'Level2' exists with expression-based column, caption, and ordinal"); + level2Check.setLevelName("Level2"); + + // Create hierarchy attribute check + HierarchyAttributeCheck hasAllCheck = factory.createHierarchyAttributeCheck(); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedValue("true"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-HierarchyWithHasAll"); + hierarchyCheck.setDescription("Check that hierarchy 'HierarchyWithHasAll' exists with two levels"); + hierarchyCheck.setHierarchyName("HierarchyWithHasAll"); + hierarchyCheck.getLevelChecks().add(level1Check); + hierarchyCheck.getLevelChecks().add(level2Check); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-Dimension"); + dimensionCheck.setDescription("Check that dimension 'Dimension' exists with hierarchy"); + dimensionCheck.setDimensionName("Dimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnKey1TypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKey1TypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKey1TypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey1 = factory.createDatabaseColumnCheck(); + columnCheckKey1.setName("Database Column Check KEY1"); + columnCheckKey1.setColumnName("KEY1"); + columnCheckKey1.getColumnAttributeChecks().add(columnKey1TypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey1); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Level Expressions"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Level Expressions"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Level Expressions' exists with expression-based level definitions"); + catalogCheck.setCatalogName("Daanse Tutorial - Level Expressions"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Level Expressions"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Level Expressions"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Level Expressions"); + suite.setDescription("Check suite for the Daanse Tutorial - Level Expressions with SQL expression-based columns"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/level/ifblankname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifblankname/CheckSuiteSupplier.java b/instance/emf/tutorial/level/ifblankname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifblankname/CheckSuiteSupplier.java new file mode 100644 index 00000000..26fb2107 --- /dev/null +++ b/instance/emf/tutorial/level/ifblankname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifblankname/CheckSuiteSupplier.java @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.level.ifblankname; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the level if blank name tutorial. + * Checks that the catalog, cube, dimension, hierarchy, levels with HideMemberIf.IF_BLANK_NAME attribute, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure1"); + measureCheck.setDescription("Check that measure 'Measure1' exists"); + measureCheck.setMeasureName("Measure1"); + + // Create level checks + LevelCheck level1Check = factory.createLevelCheck(); + level1Check.setName("LevelCheck-Level1"); + level1Check.setDescription("Check that level 'Level1' exists"); + level1Check.setLevelName("Level1"); + + LevelCheck level2Check = factory.createLevelCheck(); + level2Check.setName("LevelCheck-Level2"); + level2Check.setDescription("Check that level 'Level2' exists with HideMemberIf.IF_BLANK_NAME"); + level2Check.setLevelName("Level2"); + + // Create hierarchy attribute check + HierarchyAttributeCheck hasAllCheck = factory.createHierarchyAttributeCheck(); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedValue("true"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-Hierarchy1"); + hierarchyCheck.setDescription("Check that hierarchy 'Hierarchy1' exists with two levels"); + hierarchyCheck.setHierarchyName("Hierarchy1"); + hierarchyCheck.getLevelChecks().add(level1Check); + hierarchyCheck.getLevelChecks().add(level2Check); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-DimensionMembersHiddenIfBlankName"); + dimensionCheck.setDescription("Check that dimension 'DimensionMembersHiddenIfBlankName' exists with hierarchy"); + dimensionCheck.setDimensionName("DimensionMembersHiddenIfBlankName"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-HiddenMembersIfBlankName"); + cubeCheck.setDescription("Check that cube 'HiddenMembersIfBlankName' exists"); + cubeCheck.setCubeName("HiddenMembersIfBlankName"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [HiddenMembersIfBlankName] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnDimKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDimKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDimKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckDimKey = factory.createDatabaseColumnCheck(); + columnCheckDimKey.setName("Database Column Check DIM_KEY"); + columnCheckDimKey.setColumnName("DIM_KEY"); + columnCheckDimKey.getColumnAttributeChecks().add(columnDimKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckDimKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create database column checks for Level_1 table + DatabaseColumnAttributeCheck columnLevel1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel1Key = factory.createDatabaseColumnCheck(); + columnCheckLevel1Key.setName("Database Column Check KEY"); + columnCheckLevel1Key.setColumnName("KEY"); + columnCheckLevel1Key.getColumnAttributeChecks().add(columnLevel1KeyTypeCheck); + + DatabaseColumnAttributeCheck columnLevel1NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel1NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel1NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckLevel1Name = factory.createDatabaseColumnCheck(); + columnCheckLevel1Name.setName("Database Column Check NAME"); + columnCheckLevel1Name.setColumnName("NAME"); + columnCheckLevel1Name.getColumnAttributeChecks().add(columnLevel1NameTypeCheck); + + DatabaseTableCheck databaseTableCheckLevel1 = factory.createDatabaseTableCheck(); + databaseTableCheckLevel1.setName("Database Table Level_1 Check"); + databaseTableCheckLevel1.setTableName("Level_1"); + databaseTableCheckLevel1.getColumnChecks().add(columnCheckLevel1Key); + databaseTableCheckLevel1.getColumnChecks().add(columnCheckLevel1Name); + + // Create database column checks for Level_2_NULL table + DatabaseColumnAttributeCheck columnLevel2KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel2Key = factory.createDatabaseColumnCheck(); + columnCheckLevel2Key.setName("Database Column Check KEY"); + columnCheckLevel2Key.setColumnName("KEY"); + columnCheckLevel2Key.getColumnAttributeChecks().add(columnLevel2KeyTypeCheck); + + DatabaseColumnAttributeCheck columnLevel2NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckLevel2Name = factory.createDatabaseColumnCheck(); + columnCheckLevel2Name.setName("Database Column Check NAME"); + columnCheckLevel2Name.setColumnName("NAME"); + columnCheckLevel2Name.getColumnAttributeChecks().add(columnLevel2NameTypeCheck); + + DatabaseColumnAttributeCheck columnLevel2L1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2L1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2L1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel2L1Key = factory.createDatabaseColumnCheck(); + columnCheckLevel2L1Key.setName("Database Column Check L1_KEY"); + columnCheckLevel2L1Key.setColumnName("L1_KEY"); + columnCheckLevel2L1Key.getColumnAttributeChecks().add(columnLevel2L1KeyTypeCheck); + + DatabaseTableCheck databaseTableCheckLevel2Null = factory.createDatabaseTableCheck(); + databaseTableCheckLevel2Null.setName("Database Table Level_2_NULL Check"); + databaseTableCheckLevel2Null.setTableName("Level_2_NULL"); + databaseTableCheckLevel2Null.getColumnChecks().add(columnCheckLevel2Key); + databaseTableCheckLevel2Null.getColumnChecks().add(columnCheckLevel2Name); + databaseTableCheckLevel2Null.getColumnChecks().add(columnCheckLevel2L1Key); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Level If Blank Name"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckLevel1); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckLevel2Null); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Level If Blank Name"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Level If Blank Name' exists with HideMemberIf.IF_BLANK_NAME level"); + catalogCheck.setCatalogName("Daanse Tutorial - Level If Blank Name"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Level If Blank Name"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Level If Blank Name"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Level If Blank Name"); + suite.setDescription("Check suite for the Daanse Tutorial - Level If Blank Name with HideMemberIf.IF_BLANK_NAME attribute"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/level/ifblanknamemultiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifblanknamemultiple/CheckSuiteSupplier.java b/instance/emf/tutorial/level/ifblanknamemultiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifblanknamemultiple/CheckSuiteSupplier.java new file mode 100644 index 00000000..f108c4b5 --- /dev/null +++ b/instance/emf/tutorial/level/ifblanknamemultiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifblanknamemultiple/CheckSuiteSupplier.java @@ -0,0 +1,266 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.level.ifblanknamemultiple; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the level if blank name multiple tutorial. + * Checks that the catalog, cube, dimension, hierarchy, multiple levels with HideMemberIf.IF_BLANK_NAME attribute, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure"); + measureCheck.setDescription("Check that measure 'Measure' exists"); + measureCheck.setMeasureName("Measure"); + + // Create level checks + LevelCheck level1Check = factory.createLevelCheck(); + level1Check.setName("LevelCheck-Level1"); + level1Check.setDescription("Check that level 'Level1' exists"); + level1Check.setLevelName("Level1"); + + LevelCheck level2Check = factory.createLevelCheck(); + level2Check.setName("LevelCheck-Level2"); + level2Check.setDescription("Check that level 'Level2' exists with HideMemberIf.IF_BLANK_NAME"); + level2Check.setLevelName("Level2"); + + LevelCheck level3Check = factory.createLevelCheck(); + level3Check.setName("LevelCheck-Level3"); + level3Check.setDescription("Check that level 'Level3' exists with HideMemberIf.IF_BLANK_NAME"); + level3Check.setLevelName("Level3"); + + // Create hierarchy attribute check + HierarchyAttributeCheck hasAllCheck = factory.createHierarchyAttributeCheck(); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedValue("true"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-Hierarchy1"); + hierarchyCheck.setDescription("Check that hierarchy 'Hierarchy1' exists with three levels"); + hierarchyCheck.setHierarchyName("Hierarchy1"); + hierarchyCheck.getLevelChecks().add(level1Check); + hierarchyCheck.getLevelChecks().add(level2Check); + hierarchyCheck.getLevelChecks().add(level3Check); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-DimensionMembersHiddenMultipleLevels"); + dimensionCheck.setDescription("Check that dimension 'DimensionMembersHiddenMultipleLevels' exists with hierarchy"); + dimensionCheck.setDimensionName("DimensionMembersHiddenMultipleLevels"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-HiddenMembersMultipleLevels"); + cubeCheck.setDescription("Check that cube 'HiddenMembersMultipleLevels' exists"); + cubeCheck.setCubeName("HiddenMembersMultipleLevels"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [HiddenMembersMultipleLevels] WHERE ([Measures].[Measure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact_Multiple table + DatabaseColumnAttributeCheck columnDimKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDimKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDimKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckDimKey = factory.createDatabaseColumnCheck(); + columnCheckDimKey.setName("Database Column Check DIM_KEY"); + columnCheckDimKey.setColumnName("DIM_KEY"); + columnCheckDimKey.getColumnAttributeChecks().add(columnDimKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFactMultiple = factory.createDatabaseTableCheck(); + databaseTableCheckFactMultiple.setName("Database Table Fact_Multiple Check"); + databaseTableCheckFactMultiple.setTableName("Fact_Multiple"); + databaseTableCheckFactMultiple.getColumnChecks().add(columnCheckDimKey); + databaseTableCheckFactMultiple.getColumnChecks().add(columnCheckValue); + + // Create database column checks for Level_1_Multiple table + DatabaseColumnAttributeCheck columnLevel1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel1Key = factory.createDatabaseColumnCheck(); + columnCheckLevel1Key.setName("Database Column Check KEY"); + columnCheckLevel1Key.setColumnName("KEY"); + columnCheckLevel1Key.getColumnAttributeChecks().add(columnLevel1KeyTypeCheck); + + DatabaseColumnAttributeCheck columnLevel1NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel1NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel1NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckLevel1Name = factory.createDatabaseColumnCheck(); + columnCheckLevel1Name.setName("Database Column Check NAME"); + columnCheckLevel1Name.setColumnName("NAME"); + columnCheckLevel1Name.getColumnAttributeChecks().add(columnLevel1NameTypeCheck); + + DatabaseTableCheck databaseTableCheckLevel1Multiple = factory.createDatabaseTableCheck(); + databaseTableCheckLevel1Multiple.setName("Database Table Level_1_Multiple Check"); + databaseTableCheckLevel1Multiple.setTableName("Level_1_Multiple"); + databaseTableCheckLevel1Multiple.getColumnChecks().add(columnCheckLevel1Key); + databaseTableCheckLevel1Multiple.getColumnChecks().add(columnCheckLevel1Name); + + // Create database column checks for Level_2_Multiple table + DatabaseColumnAttributeCheck columnLevel2KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel2Key = factory.createDatabaseColumnCheck(); + columnCheckLevel2Key.setName("Database Column Check KEY"); + columnCheckLevel2Key.setColumnName("KEY"); + columnCheckLevel2Key.getColumnAttributeChecks().add(columnLevel2KeyTypeCheck); + + DatabaseColumnAttributeCheck columnLevel2NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckLevel2Name = factory.createDatabaseColumnCheck(); + columnCheckLevel2Name.setName("Database Column Check NAME"); + columnCheckLevel2Name.setColumnName("NAME"); + columnCheckLevel2Name.getColumnAttributeChecks().add(columnLevel2NameTypeCheck); + + DatabaseColumnAttributeCheck columnLevel2L1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2L1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2L1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel2L1Key = factory.createDatabaseColumnCheck(); + columnCheckLevel2L1Key.setName("Database Column Check L1_KEY"); + columnCheckLevel2L1Key.setColumnName("L1_KEY"); + columnCheckLevel2L1Key.getColumnAttributeChecks().add(columnLevel2L1KeyTypeCheck); + + DatabaseTableCheck databaseTableCheckLevel2Multiple = factory.createDatabaseTableCheck(); + databaseTableCheckLevel2Multiple.setName("Database Table Level_2_Multiple Check"); + databaseTableCheckLevel2Multiple.setTableName("Level_2_Multiple"); + databaseTableCheckLevel2Multiple.getColumnChecks().add(columnCheckLevel2Key); + databaseTableCheckLevel2Multiple.getColumnChecks().add(columnCheckLevel2Name); + databaseTableCheckLevel2Multiple.getColumnChecks().add(columnCheckLevel2L1Key); + + // Create database column checks for Level_3_Multiple table + DatabaseColumnAttributeCheck columnLevel3KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel3KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel3KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel3Key = factory.createDatabaseColumnCheck(); + columnCheckLevel3Key.setName("Database Column Check KEY"); + columnCheckLevel3Key.setColumnName("KEY"); + columnCheckLevel3Key.getColumnAttributeChecks().add(columnLevel3KeyTypeCheck); + + DatabaseColumnAttributeCheck columnLevel3NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel3NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel3NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckLevel3Name = factory.createDatabaseColumnCheck(); + columnCheckLevel3Name.setName("Database Column Check NAME"); + columnCheckLevel3Name.setColumnName("NAME"); + columnCheckLevel3Name.getColumnAttributeChecks().add(columnLevel3NameTypeCheck); + + DatabaseColumnAttributeCheck columnLevel3L2KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel3L2KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel3L2KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel3L2Key = factory.createDatabaseColumnCheck(); + columnCheckLevel3L2Key.setName("Database Column Check L2_KEY"); + columnCheckLevel3L2Key.setColumnName("L2_KEY"); + columnCheckLevel3L2Key.getColumnAttributeChecks().add(columnLevel3L2KeyTypeCheck); + + DatabaseTableCheck databaseTableCheckLevel3Multiple = factory.createDatabaseTableCheck(); + databaseTableCheckLevel3Multiple.setName("Database Table Level_3_Multiple Check"); + databaseTableCheckLevel3Multiple.setTableName("Level_3_Multiple"); + databaseTableCheckLevel3Multiple.getColumnChecks().add(columnCheckLevel3Key); + databaseTableCheckLevel3Multiple.getColumnChecks().add(columnCheckLevel3Name); + databaseTableCheckLevel3Multiple.getColumnChecks().add(columnCheckLevel3L2Key); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Level If Blank Name Multiple"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFactMultiple); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckLevel1Multiple); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckLevel2Multiple); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckLevel3Multiple); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Level If Blank Name Multiple"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Level If Blank Name Multiple' exists with multiple HideMemberIf.IF_BLANK_NAME levels"); + catalogCheck.setCatalogName("Daanse Tutorial - Level If Blank Name Multiple"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Level If Blank Name Multiple"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Level If Blank Name Multiple"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Level If Blank Name Multiple"); + suite.setDescription("Check suite for the Daanse Tutorial - Level If Blank Name Multiple with multiple HideMemberIf.IF_BLANK_NAME levels"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/level/ifparentsname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifparentsname/CheckSuiteSupplier.java b/instance/emf/tutorial/level/ifparentsname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifparentsname/CheckSuiteSupplier.java new file mode 100644 index 00000000..e4234b74 --- /dev/null +++ b/instance/emf/tutorial/level/ifparentsname/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/ifparentsname/CheckSuiteSupplier.java @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.level.ifparentsname; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the level if parents name tutorial. + * Checks that the catalog, cube, dimension, hierarchy, levels with HideMemberIf.IF_PARENTS_NAME attribute, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure1"); + measureCheck.setDescription("Check that measure 'Measure1' exists"); + measureCheck.setMeasureName("Measure1"); + + // Create level checks + LevelCheck level1Check = factory.createLevelCheck(); + level1Check.setName("LevelCheck-Level1"); + level1Check.setDescription("Check that level 'Level1' exists"); + level1Check.setLevelName("Level1"); + + LevelCheck level2Check = factory.createLevelCheck(); + level2Check.setName("LevelCheck-Level2"); + level2Check.setDescription("Check that level 'Level2' exists with HideMemberIf.IF_PARENTS_NAME"); + level2Check.setLevelName("Level2"); + + // Create hierarchy attribute check + HierarchyAttributeCheck hasAllCheck = factory.createHierarchyAttributeCheck(); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedValue("true"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-Hierarchy1"); + hierarchyCheck.setDescription("Check that hierarchy 'Hierarchy1' exists with two levels"); + hierarchyCheck.setHierarchyName("Hierarchy1"); + hierarchyCheck.getLevelChecks().add(level1Check); + hierarchyCheck.getLevelChecks().add(level2Check); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-DimensionMembersHiddenIfBlankName"); + dimensionCheck.setDescription("Check that dimension 'DimensionMembersHiddenIfBlankName' exists with hierarchy"); + dimensionCheck.setDimensionName("DimensionMembersHiddenIfBlankName"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure1]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure1])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnDimKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDimKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDimKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckDimKey = factory.createDatabaseColumnCheck(); + columnCheckDimKey.setName("Database Column Check DIM_KEY"); + columnCheckDimKey.setColumnName("DIM_KEY"); + columnCheckDimKey.getColumnAttributeChecks().add(columnDimKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckDimKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create database column checks for Level_1 table + DatabaseColumnAttributeCheck columnLevel1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel1Key = factory.createDatabaseColumnCheck(); + columnCheckLevel1Key.setName("Database Column Check KEY"); + columnCheckLevel1Key.setColumnName("KEY"); + columnCheckLevel1Key.getColumnAttributeChecks().add(columnLevel1KeyTypeCheck); + + DatabaseColumnAttributeCheck columnLevel1NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel1NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel1NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckLevel1Name = factory.createDatabaseColumnCheck(); + columnCheckLevel1Name.setName("Database Column Check NAME"); + columnCheckLevel1Name.setColumnName("NAME"); + columnCheckLevel1Name.getColumnAttributeChecks().add(columnLevel1NameTypeCheck); + + DatabaseTableCheck databaseTableCheckLevel1 = factory.createDatabaseTableCheck(); + databaseTableCheckLevel1.setName("Database Table Level_1 Check"); + databaseTableCheckLevel1.setTableName("Level_1"); + databaseTableCheckLevel1.getColumnChecks().add(columnCheckLevel1Key); + databaseTableCheckLevel1.getColumnChecks().add(columnCheckLevel1Name); + + // Create database column checks for Level_2 table + DatabaseColumnAttributeCheck columnLevel2KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel2Key = factory.createDatabaseColumnCheck(); + columnCheckLevel2Key.setName("Database Column Check KEY"); + columnCheckLevel2Key.setColumnName("KEY"); + columnCheckLevel2Key.getColumnAttributeChecks().add(columnLevel2KeyTypeCheck); + + DatabaseColumnAttributeCheck columnLevel2NameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2NameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2NameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckLevel2Name = factory.createDatabaseColumnCheck(); + columnCheckLevel2Name.setName("Database Column Check NAME"); + columnCheckLevel2Name.setColumnName("NAME"); + columnCheckLevel2Name.getColumnAttributeChecks().add(columnLevel2NameTypeCheck); + + DatabaseColumnAttributeCheck columnLevel2L1KeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnLevel2L1KeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnLevel2L1KeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckLevel2L1Key = factory.createDatabaseColumnCheck(); + columnCheckLevel2L1Key.setName("Database Column Check L1_KEY"); + columnCheckLevel2L1Key.setColumnName("L1_KEY"); + columnCheckLevel2L1Key.getColumnAttributeChecks().add(columnLevel2L1KeyTypeCheck); + + DatabaseTableCheck databaseTableCheckLevel2 = factory.createDatabaseTableCheck(); + databaseTableCheckLevel2.setName("Database Table Level_2 Check"); + databaseTableCheckLevel2.setTableName("Level_2"); + databaseTableCheckLevel2.getColumnChecks().add(columnCheckLevel2Key); + databaseTableCheckLevel2.getColumnChecks().add(columnCheckLevel2Name); + databaseTableCheckLevel2.getColumnChecks().add(columnCheckLevel2L1Key); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Level If Parents Name"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckLevel1); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckLevel2); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Level If Parents Name"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Level If Parents Name' exists with HideMemberIf.IF_PARENTS_NAME level"); + catalogCheck.setCatalogName("Daanse Tutorial - Level If Parents Name"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Level If Parents Name"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Level If Parents Name"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Level If Parents Name"); + suite.setDescription("Check suite for the Daanse Tutorial - Level If Parents Name with HideMemberIf.IF_PARENTS_NAME attribute"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/level/smallintasbooleantype/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/smallintasbooleantype/CheckSuiteSupplier.java b/instance/emf/tutorial/level/smallintasbooleantype/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/smallintasbooleantype/CheckSuiteSupplier.java new file mode 100644 index 00000000..7f0b1af1 --- /dev/null +++ b/instance/emf/tutorial/level/smallintasbooleantype/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/smallintasbooleantype/CheckSuiteSupplier.java @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.level.smallintasbooleantype; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the level small int as boolean type tutorial. + * Checks that the catalog, cube, dimension, hierarchy, level using SMALLINT column as boolean type, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure"); + measureCheck.setDescription("Check that measure 'Measure' exists"); + measureCheck.setMeasureName("Measure"); + + // Create level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-_Level"); + levelCheck.setDescription("Check that level '_Level' exists with SMALLINT column as boolean type"); + levelCheck.setLevelName("_Level"); + + // Create hierarchy attribute check + HierarchyAttributeCheck hasAllCheck = factory.createHierarchyAttributeCheck(); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedValue("true"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-HierarchyWithHasAll"); + hierarchyCheck.setDescription("Check that hierarchy 'HierarchyWithHasAll' exists with level"); + hierarchyCheck.setHierarchyName("HierarchyWithHasAll"); + hierarchyCheck.getLevelChecks().add(levelCheck); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-Dimension"); + dimensionCheck.setDescription("Check that dimension 'Dimension' exists with hierarchy"); + dimensionCheck.setDimensionName("Dimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseColumnAttributeCheck columnFlagTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFlagTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFlagTypeCheck.setExpectedValue("SMALLINT"); + + DatabaseColumnCheck columnCheckFlag = factory.createDatabaseColumnCheck(); + columnCheckFlag.setName("Database Column Check FLAG"); + columnCheckFlag.setColumnName("FLAG"); + columnCheckFlag.getColumnAttributeChecks().add(columnFlagTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + databaseTableCheckFact.getColumnChecks().add(columnCheckFlag); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Level Small Int As Boolean Type"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Level Small Int As Boolean Type"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Level Small Int As Boolean Type' exists with SMALLINT as boolean level"); + catalogCheck.setCatalogName("Daanse Tutorial - Level Small Int As Boolean Type"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Level Small Int As Boolean Type"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Level Small Int As Boolean Type"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Level Small Int As Boolean Type"); + suite.setDescription("Check suite for the Daanse Tutorial - Level Small Int As Boolean Type using SMALLINT column as boolean"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/level/unique/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/unique/CheckSuiteSupplier.java b/instance/emf/tutorial/level/unique/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/unique/CheckSuiteSupplier.java new file mode 100644 index 00000000..827bd027 --- /dev/null +++ b/instance/emf/tutorial/level/unique/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/level/unique/CheckSuiteSupplier.java @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.level.unique; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the level unique tutorial. + * Checks that the catalog, cube, dimension, hierarchy, levels with unique and non-unique members, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure"); + measureCheck.setDescription("Check that measure 'Measure' exists"); + measureCheck.setMeasureName("Measure"); + + // Create level checks + LevelCheck buildingLevelCheck = factory.createLevelCheck(); + buildingLevelCheck.setName("LevelCheck-Building"); + buildingLevelCheck.setDescription("Check that level 'Building' exists with unique members"); + buildingLevelCheck.setLevelName("Building"); + + LevelCheck roomLevelCheck = factory.createLevelCheck(); + roomLevelCheck.setName("LevelCheck-Room"); + roomLevelCheck.setDescription("Check that level 'Room' exists with non-unique members"); + roomLevelCheck.setLevelName("Room"); + + // Create hierarchy attribute check + HierarchyAttributeCheck hasAllCheck = factory.createHierarchyAttributeCheck(); + hasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hasAllCheck.setExpectedValue("true"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-Hierarchy"); + hierarchyCheck.setDescription("Check that hierarchy 'Hierarchy' exists with two levels"); + hierarchyCheck.setHierarchyName("Hierarchy"); + hierarchyCheck.getLevelChecks().add(buildingLevelCheck); + hierarchyCheck.getLevelChecks().add(roomLevelCheck); + hierarchyCheck.getHierarchyAttributeChecks().add(hasAllCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-Dimension"); + dimensionCheck.setDescription("Check that dimension 'Dimension' exists with hierarchy"); + dimensionCheck.setDimensionName("Dimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-NotUniqueLevelsMembers"); + cubeCheck.setDescription("Check that cube 'NotUniqueLevelsMembers' exists"); + cubeCheck.setCubeName("NotUniqueLevelsMembers"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure data"); + queryCheck.setQuery("SELECT FROM [NotUniqueLevelsMembers] WHERE ([Measures].[Measure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnBuildingTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnBuildingTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnBuildingTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckBuilding = factory.createDatabaseColumnCheck(); + columnCheckBuilding.setName("Database Column Check BUILDING"); + columnCheckBuilding.setColumnName("BUILDING"); + columnCheckBuilding.getColumnAttributeChecks().add(columnBuildingTypeCheck); + + DatabaseColumnAttributeCheck columnRoomTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnRoomTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnRoomTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckRoom = factory.createDatabaseColumnCheck(); + columnCheckRoom.setName("Database Column Check ROOM"); + columnCheckRoom.setColumnName("ROOM"); + columnCheckRoom.getColumnAttributeChecks().add(columnRoomTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckBuilding); + databaseTableCheckFact.getColumnChecks().add(columnCheckRoom); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Level with not unique members"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Level with not unique members"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Level with not unique members' exists with unique and non-unique levels"); + catalogCheck.setCatalogName("Daanse Tutorial - Level with not unique members"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Level with not unique members"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Level with not unique members"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Level with not unique members"); + suite.setDescription("Check suite for the Daanse Tutorial - Level with unique and non-unique members"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/measure/expression/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/expression/CheckSuiteSupplier.java b/instance/emf/tutorial/measure/expression/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/expression/CheckSuiteSupplier.java new file mode 100644 index 00000000..186a02ea --- /dev/null +++ b/instance/emf/tutorial/measure/expression/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/expression/CheckSuiteSupplier.java @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.measure.expression; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the measure expression tutorial. + * Checks that the catalog, cube, measures with SQL expression columns, and database schema exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure checks + MeasureCheck measure1Check = factory.createMeasureCheck(); + measure1Check.setName("MeasureCheck-Measure1-Sum"); + measure1Check.setDescription("Check that measure 'Measure1-Sum' exists with SQL expression"); + measure1Check.setMeasureName("Measure1-Sum"); + + MeasureCheck measure2Check = factory.createMeasureCheck(); + measure2Check.setName("MeasureCheck-Measure2-Sum"); + measure2Check.setDescription("Check that measure 'Measure2-Sum' exists with SQL expression"); + measure2Check.setMeasureName("Measure2-Sum"); + + // Create cube check with measure checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube With MeasureExpression"); + cubeCheck.setDescription("Check that cube 'Cube With MeasureExpression' exists"); + cubeCheck.setCubeName("Cube With MeasureExpression"); + cubeCheck.getMeasureChecks().add(measure1Check); + cubeCheck.getMeasureChecks().add(measure2Check); + + // Create query check for Measure1-Sum + CellValueCheck queryCheck1CellValueCheck = factory.createCellValueCheck(); + queryCheck1CellValueCheck.setName("[Measures].[Measure1-Sum]"); + queryCheck1CellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck1 = factory.createQueryCheck(); + queryCheck1.setName("Measure1 Query Check"); + queryCheck1.setDescription("Verify MDX query returns Measure1-Sum data"); + queryCheck1.setQuery("SELECT FROM [Cube With MeasureExpression] WHERE ([Measures].[Measure1-Sum])"); + queryCheck1.setQueryLanguage(QueryLanguage.MDX); + queryCheck1.setExpectedColumnCount(1); + queryCheck1.getCellChecks().add(queryCheck1CellValueCheck); + queryCheck1.setEnabled(true); + + // Create query check for Measure2-Sum + CellValueCheck queryCheck2CellValueCheck = factory.createCellValueCheck(); + queryCheck2CellValueCheck.setName("[Measures].[Measure2-Sum]"); + queryCheck2CellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck2 = factory.createQueryCheck(); + queryCheck2.setName("Measure2 Query Check"); + queryCheck2.setDescription("Verify MDX query returns Measure2-Sum data"); + queryCheck2.setQuery("SELECT FROM [Cube With MeasureExpression] WHERE ([Measures].[Measure2-Sum])"); + queryCheck2.setQueryLanguage(QueryLanguage.MDX); + queryCheck2.setExpectedColumnCount(1); + queryCheck2.getCellChecks().add(queryCheck2CellValueCheck); + queryCheck2.setEnabled(true); + + // Create database column checks for FACT table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseColumnAttributeCheck columnValueNumericTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueNumericTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueNumericTypeCheck.setExpectedValue("NUMERIC"); + + DatabaseColumnCheck columnCheckValueNumeric = factory.createDatabaseColumnCheck(); + columnCheckValueNumeric.setName("Database Column Check VALUE_NUMERIC"); + columnCheckValueNumeric.setColumnName("VALUE_NUMERIC"); + columnCheckValueNumeric.getColumnAttributeChecks().add(columnValueNumericTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table FACT Check"); + databaseTableCheckFact.setTableName("FACT"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + databaseTableCheckFact.getColumnChecks().add(columnCheckValueNumeric); + + // Create database column checks for MEASURE_TABLE table + DatabaseColumnAttributeCheck columnIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckId = factory.createDatabaseColumnCheck(); + columnCheckId.setName("Database Column Check ID"); + columnCheckId.setColumnName("ID"); + columnCheckId.getColumnAttributeChecks().add(columnIdTypeCheck); + + DatabaseColumnAttributeCheck columnMeasureTableValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMeasureTableValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMeasureTableValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckMeasureTableValue = factory.createDatabaseColumnCheck(); + columnCheckMeasureTableValue.setName("Database Column Check VALUE"); + columnCheckMeasureTableValue.setColumnName("VALUE"); + columnCheckMeasureTableValue.getColumnAttributeChecks().add(columnMeasureTableValueTypeCheck); + + DatabaseColumnAttributeCheck columnFlagTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFlagTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFlagTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFlag = factory.createDatabaseColumnCheck(); + columnCheckFlag.setName("Database Column Check FLAG"); + columnCheckFlag.setColumnName("FLAG"); + columnCheckFlag.getColumnAttributeChecks().add(columnFlagTypeCheck); + + DatabaseTableCheck databaseTableCheckMeasureTable = factory.createDatabaseTableCheck(); + databaseTableCheckMeasureTable.setName("Database Table MEASURE_TABLE Check"); + databaseTableCheckMeasureTable.setTableName("MEASURE_TABLE"); + databaseTableCheckMeasureTable.getColumnChecks().add(columnCheckId); + databaseTableCheckMeasureTable.getColumnChecks().add(columnCheckMeasureTableValue); + databaseTableCheckMeasureTable.getColumnChecks().add(columnCheckFlag); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Expression"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckMeasureTable); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Expression"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Expression' exists with SQL expression-based measures"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Expression"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck1); + catalogCheck.getQueryChecks().add(queryCheck2); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Expression"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Expression"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Expression"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Expression with SQL expression columns"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/measure/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/inlinetable/CheckSuiteSupplier.java b/instance/emf/tutorial/measure/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/inlinetable/CheckSuiteSupplier.java new file mode 100644 index 00000000..e21dafe5 --- /dev/null +++ b/instance/emf/tutorial/measure/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/inlinetable/CheckSuiteSupplier.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.measure.inlinetable; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the measure inline table tutorial. + * Checks that the catalog, cube, and measure using inline table exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure-Sum"); + measureCheck.setDescription("Check that measure 'Measure-Sum' exists using inline table"); + measureCheck.setMeasureName("Measure-Sum"); + + // Create cube check with measure check + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists with inline table"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure-Sum]"); + queryCheckCellValueCheck.setExpectedValue("100.5"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure-Sum data from inline table"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[Measure-Sum])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create catalog check with cube check + // Note: No database schema check needed as this uses InlineTable with embedded data + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Inline Table"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Inline Table' exists with inline table data"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Inline Table"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Inline Table"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Inline Table"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Inline Table"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Inline Table with embedded data"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/measure/inlinetablewithphysical/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/inlinetablewithphysical/CheckSuiteSupplier.java b/instance/emf/tutorial/measure/inlinetablewithphysical/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/inlinetablewithphysical/CheckSuiteSupplier.java new file mode 100644 index 00000000..32bb5235 --- /dev/null +++ b/instance/emf/tutorial/measure/inlinetablewithphysical/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/measure/inlinetablewithphysical/CheckSuiteSupplier.java @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.measure.inlinetablewithphysical; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the measure inline table with physical tutorial. + * Checks that the catalog, cube, measure, dimension, hierarchy, levels combining inline table and physical table exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-Measure-Sum"); + measureCheck.setDescription("Check that measure 'Measure-Sum' exists using inline table"); + measureCheck.setMeasureName("Measure-Sum"); + + // Create level checks + LevelCheck levelCountryCheck = factory.createLevelCheck(); + levelCountryCheck.setName("LevelCheck-Country"); + levelCountryCheck.setDescription("Check that level 'Country' exists using inline table"); + levelCountryCheck.setLevelName("Country"); + + LevelCheck levelTownCheck = factory.createLevelCheck(); + levelTownCheck.setName("LevelCheck-Town"); + levelTownCheck.setDescription("Check that level 'Town' exists using physical table"); + levelTownCheck.setLevelName("Town"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-Hierarchy"); + hierarchyCheck.setDescription("Check that hierarchy 'Hierarchy' exists with country and town levels"); + hierarchyCheck.setHierarchyName("Hierarchy"); + hierarchyCheck.getLevelChecks().add(levelCountryCheck); + hierarchyCheck.getLevelChecks().add(levelTownCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-Dimension"); + dimensionCheck.setDescription("Check that dimension 'Dimension' exists with hierarchy"); + dimensionCheck.setDimensionName("Dimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-CubeTwoLevelsInlineAndPhysicalTable"); + cubeCheck.setDescription("Check that cube 'CubeTwoLevelsInlineAndPhysicalTable' exists"); + cubeCheck.setCubeName("CubeTwoLevelsInlineAndPhysicalTable"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[Measure-Sum]"); + queryCheckCellValueCheck.setExpectedValue("601.5"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns Measure-Sum data from inline table (sum of 100.5 + 200.5 + 300.5)"); + queryCheck.setQuery("SELECT FROM [CubeTwoLevelsInlineAndPhysicalTable] WHERE ([Measures].[Measure-Sum])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for TOWN physical table + DatabaseColumnAttributeCheck columnTownKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTownKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTownKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownKey = factory.createDatabaseColumnCheck(); + columnCheckTownKey.setName("Database Column Check KEY"); + columnCheckTownKey.setColumnName("KEY"); + columnCheckTownKey.getColumnAttributeChecks().add(columnTownKeyTypeCheck); + + DatabaseColumnAttributeCheck columnTownCountryKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTownCountryKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTownCountryKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownCountryKey = factory.createDatabaseColumnCheck(); + columnCheckTownCountryKey.setName("Database Column Check KEY_COUNTRY"); + columnCheckTownCountryKey.setColumnName("KEY_COUNTRY"); + columnCheckTownCountryKey.getColumnAttributeChecks().add(columnTownCountryKeyTypeCheck); + + DatabaseColumnAttributeCheck columnTownNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTownNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTownNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownName = factory.createDatabaseColumnCheck(); + columnCheckTownName.setName("Database Column Check NAME"); + columnCheckTownName.setColumnName("NAME"); + columnCheckTownName.getColumnAttributeChecks().add(columnTownNameTypeCheck); + + DatabaseTableCheck databaseTableCheckTown = factory.createDatabaseTableCheck(); + databaseTableCheckTown.setName("Database Table TOWN Check"); + databaseTableCheckTown.setTableName("TOWN"); + databaseTableCheckTown.getColumnChecks().add(columnCheckTownKey); + databaseTableCheckTown.getColumnChecks().add(columnCheckTownCountryKey); + databaseTableCheckTown.getColumnChecks().add(columnCheckTownName); + + // Create Database Schema Check (only for physical table TOWN, not for inline tables) + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Measure Inline Table With Physical (physical table TOWN only)"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckTown); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Measure Inline Table With Physical"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Measure Inline Table With Physical' exists with combined inline and physical tables"); + catalogCheck.setCatalogName("Daanse Tutorial - Measure Inline Table With Physical"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Measure Inline Table With Physical"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Measure Inline Table With Physical"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Measure Inline Table With Physical"); + suite.setDescription("Check suite for the Daanse Tutorial - Measure Inline Table With Physical combining inline and physical tables"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/member/identifier/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/identifier/CheckSuiteSupplier.java b/instance/emf/tutorial/member/identifier/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/identifier/CheckSuiteSupplier.java new file mode 100644 index 00000000..5e052f7f --- /dev/null +++ b/instance/emf/tutorial/member/identifier/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/identifier/CheckSuiteSupplier.java @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.member.identifier; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the member identifier tutorial. + * Checks that the catalog, cube, dimension, hierarchy, levels with various member identifier formats, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-theMeasure"); + measureCheck.setDescription("Check that measure 'theMeasure' exists"); + measureCheck.setMeasureName("theMeasure"); + + // Create level checks + LevelCheck level1Check = factory.createLevelCheck(); + level1Check.setName("LevelCheck-level1"); + level1Check.setDescription("Check that level 'level1' exists"); + level1Check.setLevelName("level1"); + + LevelCheck level2Check = factory.createLevelCheck(); + level2Check.setName("LevelCheck-level2"); + level2Check.setDescription("Check that level 'level2' exists"); + level2Check.setLevelName("level2"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-Hierarchy"); + hierarchyCheck.setDescription("Check that hierarchy 'Hierarchy' exists with two levels"); + hierarchyCheck.setHierarchyName("Hierarchy"); + hierarchyCheck.getLevelChecks().add(level1Check); + hierarchyCheck.getLevelChecks().add(level2Check); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-Dimension"); + dimensionCheck.setDescription("Check that dimension 'Dimension' exists with hierarchy"); + dimensionCheck.setDimensionName("Dimension"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube"); + cubeCheck.setDescription("Check that cube 'Cube' exists"); + cubeCheck.setCubeName("Cube"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[theMeasure]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns theMeasure data"); + queryCheck.setQuery("SELECT FROM [Cube] WHERE ([Measures].[theMeasure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnKey1TypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKey1TypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKey1TypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey1 = factory.createDatabaseColumnCheck(); + columnCheckKey1.setName("Database Column Check KEY1"); + columnCheckKey1.setColumnName("KEY1"); + columnCheckKey1.getColumnAttributeChecks().add(columnKey1TypeCheck); + + DatabaseColumnAttributeCheck columnKey2TypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKey2TypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKey2TypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckKey2 = factory.createDatabaseColumnCheck(); + columnCheckKey2.setName("Database Column Check KEY2"); + columnCheckKey2.setColumnName("KEY2"); + columnCheckKey2.getColumnAttributeChecks().add(columnKey2TypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey1); + databaseTableCheckFact.getColumnChecks().add(columnCheckKey2); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Member Identifier"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Member Identifier"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Member Identifier' exists with member identifier configurations"); + catalogCheck.setCatalogName("Daanse Tutorial - Member Identifier"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Member Identifier"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Member Identifier"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Member Identifier"); + suite.setDescription("Check suite for the Daanse Tutorial - Member Identifier with various identifier formats"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/member/property.geo/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/property/geo/CheckSuiteSupplier.java b/instance/emf/tutorial/member/property.geo/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/property/geo/CheckSuiteSupplier.java new file mode 100644 index 00000000..0e48ea3f --- /dev/null +++ b/instance/emf/tutorial/member/property.geo/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/property/geo/CheckSuiteSupplier.java @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.member.property.geo; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the member property geo tutorial. + * Checks that the catalog, cube, dimension, hierarchy, level with geographic member properties, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-TotalValue"); + measureCheck.setDescription("Check that measure 'TotalValue' exists"); + measureCheck.setMeasureName("TotalValue"); + + // Create level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-Location"); + levelCheck.setDescription("Check that level 'Location' exists with geographic member properties"); + levelCheck.setLevelName("Location"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-LocationHierarchy"); + hierarchyCheck.setDescription("Check that hierarchy 'LocationHierarchy' exists with location level"); + hierarchyCheck.setHierarchyName("LocationHierarchy"); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-Location"); + dimensionCheck.setDescription("Check that dimension 'Location' exists with hierarchy"); + dimensionCheck.setDimensionName("Location"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Geographic Analysis"); + cubeCheck.setDescription("Check that cube 'Geographic Analysis' exists"); + cubeCheck.setCubeName("Geographic Analysis"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[TotalValue]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns TotalValue data"); + queryCheck.setQuery("SELECT FROM [Geographic Analysis] WHERE ([Measures].[TotalValue])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnFactMemberIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFactMemberIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFactMemberIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactMemberId = factory.createDatabaseColumnCheck(); + columnCheckFactMemberId.setName("Database Column Check MEMBER_ID"); + columnCheckFactMemberId.setColumnName("MEMBER_ID"); + columnCheckFactMemberId.getColumnAttributeChecks().add(columnFactMemberIdTypeCheck); + + DatabaseColumnAttributeCheck columnFactValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFactValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFactValueTypeCheck.setExpectedValue("DECIMAL"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check VALUE"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnFactValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactMemberId); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactValue); + + // Create database column checks for Member table + DatabaseColumnAttributeCheck columnMemberIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMemberIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMemberIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckMemberId = factory.createDatabaseColumnCheck(); + columnCheckMemberId.setName("Database Column Check ID"); + columnCheckMemberId.setColumnName("ID"); + columnCheckMemberId.getColumnAttributeChecks().add(columnMemberIdTypeCheck); + + DatabaseColumnAttributeCheck columnMemberNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMemberNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMemberNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckMemberName = factory.createDatabaseColumnCheck(); + columnCheckMemberName.setName("Database Column Check NAME"); + columnCheckMemberName.setColumnName("NAME"); + columnCheckMemberName.getColumnAttributeChecks().add(columnMemberNameTypeCheck); + + DatabaseColumnAttributeCheck columnMemberLocationTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMemberLocationTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMemberLocationTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckMemberLocation = factory.createDatabaseColumnCheck(); + columnCheckMemberLocation.setName("Database Column Check LOCATION"); + columnCheckMemberLocation.setColumnName("LOCATION"); + columnCheckMemberLocation.getColumnAttributeChecks().add(columnMemberLocationTypeCheck); + + DatabaseColumnAttributeCheck columnMemberLatitudeTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMemberLatitudeTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMemberLatitudeTypeCheck.setExpectedValue("DECIMAL"); + + DatabaseColumnCheck columnCheckMemberLatitude = factory.createDatabaseColumnCheck(); + columnCheckMemberLatitude.setName("Database Column Check LATITUDE"); + columnCheckMemberLatitude.setColumnName("LATITUDE"); + columnCheckMemberLatitude.getColumnAttributeChecks().add(columnMemberLatitudeTypeCheck); + + DatabaseColumnAttributeCheck columnMemberLongitudeTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMemberLongitudeTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMemberLongitudeTypeCheck.setExpectedValue("DECIMAL"); + + DatabaseColumnCheck columnCheckMemberLongitude = factory.createDatabaseColumnCheck(); + columnCheckMemberLongitude.setName("Database Column Check LONGITUDE"); + columnCheckMemberLongitude.setColumnName("LONGITUDE"); + columnCheckMemberLongitude.getColumnAttributeChecks().add(columnMemberLongitudeTypeCheck); + + DatabaseColumnAttributeCheck columnMemberDescriptionTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnMemberDescriptionTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnMemberDescriptionTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckMemberDescription = factory.createDatabaseColumnCheck(); + columnCheckMemberDescription.setName("Database Column Check DESCRIPTION"); + columnCheckMemberDescription.setColumnName("DESCRIPTION"); + columnCheckMemberDescription.getColumnAttributeChecks().add(columnMemberDescriptionTypeCheck); + + DatabaseTableCheck databaseTableCheckMember = factory.createDatabaseTableCheck(); + databaseTableCheckMember.setName("Database Table Member Check"); + databaseTableCheckMember.setTableName("Member"); + databaseTableCheckMember.getColumnChecks().add(columnCheckMemberId); + databaseTableCheckMember.getColumnChecks().add(columnCheckMemberName); + databaseTableCheckMember.getColumnChecks().add(columnCheckMemberLocation); + databaseTableCheckMember.getColumnChecks().add(columnCheckMemberLatitude); + databaseTableCheckMember.getColumnChecks().add(columnCheckMemberLongitude); + databaseTableCheckMember.getColumnChecks().add(columnCheckMemberDescription); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Member Properties with Geographic Data"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckMember); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Member Properties with Geographic Data"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Member Properties with Geographic Data' exists with geographic member properties"); + catalogCheck.setCatalogName("Daanse Tutorial - Member Properties with Geographic Data"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Member Properties with Geographic Data"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Member Properties with Geographic Data"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Member Properties with Geographic Data"); + suite.setDescription("Check suite for the Daanse Tutorial - Member Properties with Geographic Data"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/member/property.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/property/intro/CheckSuiteSupplier.java b/instance/emf/tutorial/member/property.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/property/intro/CheckSuiteSupplier.java new file mode 100644 index 00000000..85b853f7 --- /dev/null +++ b/instance/emf/tutorial/member/property.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/member/property/intro/CheckSuiteSupplier.java @@ -0,0 +1,184 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.member.property.intro; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CellValueCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.model.check.QueryCheck; +import org.eclipse.daanse.olap.check.model.check.QueryLanguage; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the member property intro tutorial. + * Checks that the catalog, cube, dimension, hierarchy, level with member property, and measure exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-theMeasure"); + measureCheck.setDescription("Check that measure 'theMeasure' exists"); + measureCheck.setMeasureName("theMeasure"); + + // Create level check + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck-Town"); + levelCheck.setDescription("Check that level 'Town' exists with member property 'Capital'"); + levelCheck.setLevelName("Town"); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck-TownHierarchy"); + hierarchyCheck.setDescription("Check that hierarchy 'TownHierarchy' exists with town level"); + hierarchyCheck.setHierarchyName("TownHierarchy"); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck-Town"); + dimensionCheck.setDescription("Check that dimension 'Town' exists with hierarchy"); + dimensionCheck.setDimensionName("Town"); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-Cube Query linked Tables"); + cubeCheck.setDescription("Check that cube 'Cube Query linked Tables' exists"); + cubeCheck.setCubeName("Cube Query linked Tables"); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create query check + CellValueCheck queryCheckCellValueCheck = factory.createCellValueCheck(); + queryCheckCellValueCheck.setName("[Measures].[theMeasure]"); + queryCheckCellValueCheck.setExpectedValue("0"); + + QueryCheck queryCheck = factory.createQueryCheck(); + queryCheck.setName("Measure Query Check"); + queryCheck.setDescription("Verify MDX query returns theMeasure data"); + queryCheck.setQuery("SELECT FROM [Cube Query linked Tables] WHERE ([Measures].[theMeasure])"); + queryCheck.setQueryLanguage(QueryLanguage.MDX); + queryCheck.setExpectedColumnCount(1); + queryCheck.getCellChecks().add(queryCheckCellValueCheck); + queryCheck.setEnabled(true); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnFactTownIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFactTownIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFactTownIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactTownId = factory.createDatabaseColumnCheck(); + columnCheckFactTownId.setName("Database Column Check TOWN_ID"); + columnCheckFactTownId.setColumnName("TOWN_ID"); + columnCheckFactTownId.getColumnAttributeChecks().add(columnFactTownIdTypeCheck); + + DatabaseColumnAttributeCheck columnFactValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnFactValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnFactValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckFactValue = factory.createDatabaseColumnCheck(); + columnCheckFactValue.setName("Database Column Check VALUE"); + columnCheckFactValue.setColumnName("VALUE"); + columnCheckFactValue.getColumnAttributeChecks().add(columnFactValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactTownId); + databaseTableCheckFact.getColumnChecks().add(columnCheckFactValue); + + // Create database column checks for Town table + DatabaseColumnAttributeCheck columnTownIdTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTownIdTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTownIdTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckTownId = factory.createDatabaseColumnCheck(); + columnCheckTownId.setName("Database Column Check ID"); + columnCheckTownId.setColumnName("ID"); + columnCheckTownId.getColumnAttributeChecks().add(columnTownIdTypeCheck); + + DatabaseColumnAttributeCheck columnTownNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTownNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTownNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownName = factory.createDatabaseColumnCheck(); + columnCheckTownName.setName("Database Column Check NAME"); + columnCheckTownName.setColumnName("NAME"); + columnCheckTownName.getColumnAttributeChecks().add(columnTownNameTypeCheck); + + DatabaseColumnAttributeCheck columnTownCapitalTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTownCapitalTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTownCapitalTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckTownCapital = factory.createDatabaseColumnCheck(); + columnCheckTownCapital.setName("Database Column Check CAPITAL"); + columnCheckTownCapital.setColumnName("CAPITAL"); + columnCheckTownCapital.getColumnAttributeChecks().add(columnTownCapitalTypeCheck); + + DatabaseTableCheck databaseTableCheckTown = factory.createDatabaseTableCheck(); + databaseTableCheckTown.setName("Database Table Town Check"); + databaseTableCheckTown.setTableName("Town"); + databaseTableCheckTown.getColumnChecks().add(columnCheckTownId); + databaseTableCheckTown.getColumnChecks().add(columnCheckTownName); + databaseTableCheckTown.getColumnChecks().add(columnCheckTownCapital); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for Daanse Tutorial - Level Member Property Intro"); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckTown); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("Daanse Tutorial - Level Member Property Intro"); + catalogCheck.setDescription("Check that catalog 'Daanse Tutorial - Level Member Property Intro' exists with member properties"); + catalogCheck.setCatalogName("Daanse Tutorial - Level Member Property Intro"); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getQueryChecks().add(queryCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check Daanse Tutorial - Level Member Property Intro"); + connectionCheck.setDescription("Connection check for Daanse Tutorial - Level Member Property Intro"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Daanse Tutorial - Level Member Property Intro"); + suite.setDescription("Check suite for the Daanse Tutorial - Level Member Property Intro with Capital member property"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/namedset/all/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/namedset/CheckSuiteSupplier.java b/instance/emf/tutorial/namedset/all/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/namedset/CheckSuiteSupplier.java new file mode 100644 index 00000000..7c912119 --- /dev/null +++ b/instance/emf/tutorial/namedset/all/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/namedset/CheckSuiteSupplier.java @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.namedset; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.NamedSetAttribute; +import org.eclipse.daanse.olap.check.model.check.NamedSetAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.NamedSetCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the namedset tutorial mapping. + * Checks that the catalog, cube, measure, and named sets exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Namedset All"; + private static final String CUBE_NAME = "Cube"; + private static final String MEASURE_NAME = "Measure1"; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + MEASURE_NAME); + measureCheck.setDescription("Check that measure '" + MEASURE_NAME + "' exists"); + measureCheck.setMeasureName(MEASURE_NAME); + + // Create named set checks + NamedSetCheck namedSetCheck1 = createNamedSetCheck( + "NsWithFolderDimension1", + "Check NamedSet with folder using Dimension1", + "TopCount([Dimension1].[Level2].MEMBERS, 5, [Measures].[Measure1])", + "Folder1" + ); + + NamedSetCheck namedSetCheck2 = createNamedSetCheck( + "NsWithoutFolderDimension1", + "Check NamedSet without folder using Dimension1", + "TopCount([Dimension1].[Level2].MEMBERS, 5, [Measures].[Measure1])", + null + ); + + NamedSetCheck namedSetCheck3 = createNamedSetCheck( + "NSInCubeWithFolder", + "Check NamedSet with folder in Cube level", + "{([Dimension1].[Level2].[A], [Dimension2].[Level2].[A]), ([Dimension1].[Level2].[B], [Dimension2].[Level2].[B])}", + "Folder2" + ); + + NamedSetCheck namedSetCheck4 = createNamedSetCheck( + "NSInCubeWithoutFolder", + "Check NamedSet without folder in Cube level", + "{([Dimension1].[Level2].[A], [Dimension2].[Level2].[A]), ([Dimension1].[Level2].[B], [Dimension2].[Level2].[B])}", + null + ); + + // Create cube check with measure and named set checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_NAME); + cubeCheck.setDescription("Check that cube '" + CUBE_NAME + "' exists with its measures and named sets"); + cubeCheck.setCubeName(CUBE_NAME); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getNamedSetChecks().add(namedSetCheck1); + cubeCheck.getNamedSetChecks().add(namedSetCheck2); + cubeCheck.getNamedSetChecks().add(namedSetCheck3); + cubeCheck.getNamedSetChecks().add(namedSetCheck4); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName("CatalogCheck-" + CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with its cubes"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("NamedsetConnectionCheck"); + connectionCheck.setDescription("Connection check for namedset tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("NamedsetSuite"); + suite.setDescription("Check suite for the namedset mapping tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a NamedSetCheck with the specified properties. + * + * @param name the name of the named set + * @param description the description of the check + * @param expression the expected MDX expression/formula + * @param displayFolder the expected display folder (can be null) + * @return the configured NamedSetCheck + */ + private NamedSetCheck createNamedSetCheck(String name, String description, String expression, String displayFolder) { + NamedSetCheck namedSetCheck = factory.createNamedSetCheck(); + namedSetCheck.setName("NamedSetCheck-" + name); + namedSetCheck.setDescription(description); + namedSetCheck.setNamedSetName(name); + + // Check expression/formula + NamedSetAttributeCheck expressionCheck = factory.createNamedSetAttributeCheck(); + expressionCheck.setAttributeType(NamedSetAttribute.EXPRESSION); + expressionCheck.setExpectedValue(expression); + namedSetCheck.getNamedSetAttributeChecks().add(expressionCheck); + + // Check display folder if specified + if (displayFolder != null) { + NamedSetAttributeCheck displayFolderCheck = factory.createNamedSetAttributeCheck(); + displayFolderCheck.setAttributeType(NamedSetAttribute.DISPLAY_FOLDER); + displayFolderCheck.setExpectedValue(displayFolder); + namedSetCheck.getNamedSetAttributeChecks().add(displayFolderCheck); + } + + return namedSetCheck; + } +} diff --git a/instance/emf/tutorial/parentchild/link/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/link/CheckSuiteSupplier.java b/instance/emf/tutorial/parentchild/link/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/link/CheckSuiteSupplier.java new file mode 100644 index 00000000..66c760b8 --- /dev/null +++ b/instance/emf/tutorial/parentchild/link/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/link/CheckSuiteSupplier.java @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.parentchild.link; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelAttribute; +import org.eclipse.daanse.olap.check.model.check.LevelAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the parent-child hierarchy with link tutorial. + * Checks that the catalog, cube, measure, parent-child hierarchy, and closure table exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Parent Child Link"; + private static final String CUBE_NAME = "Cube"; + private static final String MEASURE_NAME = "Value"; + private static final String DIMENSION_NAME = "Dimension"; + private static final String HIERARCHY_NAME = "Hierarchy"; + private static final String LEVEL_NAME = "Name"; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + MEASURE_NAME); + measureCheck.setDescription("Check that measure '" + MEASURE_NAME + "' exists"); + measureCheck.setMeasureName(MEASURE_NAME); + + // Create level check with unique members attribute + LevelAttributeCheck levelUniqueCheck = factory.createLevelAttributeCheck(); + levelUniqueCheck.setAttributeType(LevelAttribute.IS_UNIQUE); + levelUniqueCheck.setExpectedBoolean(true); + + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for " + LEVEL_NAME); + levelCheck.setLevelName(LEVEL_NAME); + levelCheck.getLevelAttributeChecks().add(levelUniqueCheck); + + // Create hierarchy check for parent-child hierarchy + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for " + HIERARCHY_NAME); + hierarchyCheck.setHierarchyName(HIERARCHY_NAME); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + DIMENSION_NAME); + dimensionCheck.setDimensionName(DIMENSION_NAME); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_NAME); + cubeCheck.setDescription("Check that cube '" + CUBE_NAME + "' exists with parent-child hierarchy"); + cubeCheck.setCubeName(CUBE_NAME); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckName = factory.createDatabaseColumnCheck(); + columnCheckName.setName("Database Column Check NAME"); + columnCheckName.setColumnName("NAME"); + columnCheckName.getColumnAttributeChecks().add(columnNameTypeCheck); + + DatabaseColumnAttributeCheck columnParentTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnParentTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnParentTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckParent = factory.createDatabaseColumnCheck(); + columnCheckParent.setName("Database Column Check PARENT"); + columnCheckParent.setColumnName("PARENT"); + columnCheckParent.getColumnAttributeChecks().add(columnParentTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckName); + databaseTableCheckFact.getColumnChecks().add(columnCheckParent); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create database column checks for Closure table + DatabaseColumnAttributeCheck columnClosureNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnClosureNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnClosureNameTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckClosureName = factory.createDatabaseColumnCheck(); + columnCheckClosureName.setName("Database Column Check Closure NAME"); + columnCheckClosureName.setColumnName("NAME"); + columnCheckClosureName.getColumnAttributeChecks().add(columnClosureNameTypeCheck); + + DatabaseColumnAttributeCheck columnClosureParentTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnClosureParentTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnClosureParentTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckClosureParent = factory.createDatabaseColumnCheck(); + columnCheckClosureParent.setName("Database Column Check Closure PARENT"); + columnCheckClosureParent.setColumnName("PARENT"); + columnCheckClosureParent.getColumnAttributeChecks().add(columnClosureParentTypeCheck); + + DatabaseColumnAttributeCheck columnDistanceTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDistanceTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDistanceTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckDistance = factory.createDatabaseColumnCheck(); + columnCheckDistance.setName("Database Column Check DISTANCE"); + columnCheckDistance.setColumnName("DISTANCE"); + columnCheckDistance.getColumnAttributeChecks().add(columnDistanceTypeCheck); + + DatabaseTableCheck databaseTableCheckClosure = factory.createDatabaseTableCheck(); + databaseTableCheckClosure.setName("Database Table Closure Check"); + databaseTableCheckClosure.setTableName("Closure"); + databaseTableCheckClosure.getColumnChecks().add(columnCheckClosureName); + databaseTableCheckClosure.getColumnChecks().add(columnCheckClosureParent); + databaseTableCheckClosure.getColumnChecks().add(columnCheckDistance); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckClosure); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with parent-child hierarchy"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for parent-child hierarchy with link tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Parent Child Link Suite"); + suite.setDescription("Check suite for the parent-child hierarchy with link mapping tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/parentchild/minimal/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/minimal/CheckSuiteSupplier.java b/instance/emf/tutorial/parentchild/minimal/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/minimal/CheckSuiteSupplier.java new file mode 100644 index 00000000..794514fc --- /dev/null +++ b/instance/emf/tutorial/parentchild/minimal/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/minimal/CheckSuiteSupplier.java @@ -0,0 +1,185 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.parentchild.minimal; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelAttribute; +import org.eclipse.daanse.olap.check.model.check.LevelAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal parent-child hierarchy tutorial. + * Checks that the catalog, cube, measure, and minimal parent-child hierarchy exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Parent Child Minimal"; + private static final String CUBE_NAME = "Cube"; + private static final String MEASURE_NAME = "Measure1"; + private static final String DIMENSION_NAME = "Dimension1"; + private static final String HIERARCHY_NAME = "Hierarchy1"; + private static final String LEVEL_NAME = "Level"; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + MEASURE_NAME); + measureCheck.setDescription("Check that measure '" + MEASURE_NAME + "' exists"); + measureCheck.setMeasureName(MEASURE_NAME); + + // Create level check with unique members attribute + LevelAttributeCheck levelUniqueCheck = factory.createLevelAttributeCheck(); + levelUniqueCheck.setAttributeType(LevelAttribute.IS_UNIQUE); + levelUniqueCheck.setExpectedBoolean(true); + + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for " + LEVEL_NAME); + levelCheck.setLevelName(LEVEL_NAME); + levelCheck.getLevelAttributeChecks().add(levelUniqueCheck); + + // Create hierarchy attribute check for hasAll + HierarchyAttributeCheck hierarchyHasAllCheck = factory.createHierarchyAttributeCheck(); + hierarchyHasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyHasAllCheck.setExpectedBoolean(true); + + // Create hierarchy check for parent-child hierarchy + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for " + HIERARCHY_NAME); + hierarchyCheck.setHierarchyName(HIERARCHY_NAME); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyHasAllCheck); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + DIMENSION_NAME); + dimensionCheck.setDimensionName(DIMENSION_NAME); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_NAME); + cubeCheck.setDescription("Check that cube '" + CUBE_NAME + "' exists with minimal parent-child hierarchy"); + cubeCheck.setCubeName(CUBE_NAME); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create database column checks for Fact table + DatabaseColumnAttributeCheck columnDimKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnDimKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnDimKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckDimKey = factory.createDatabaseColumnCheck(); + columnCheckDimKey.setName("Database Column Check DIM_KEY"); + columnCheckDimKey.setColumnName("DIM_KEY"); + columnCheckDimKey.getColumnAttributeChecks().add(columnDimKeyTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckFact = factory.createDatabaseTableCheck(); + databaseTableCheckFact.setName("Database Table Fact Check"); + databaseTableCheckFact.setTableName("Fact"); + databaseTableCheckFact.getColumnChecks().add(columnCheckDimKey); + databaseTableCheckFact.getColumnChecks().add(columnCheckValue); + + // Create database column checks for Hier_One_Top_Member table + DatabaseColumnAttributeCheck columnKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckKey = factory.createDatabaseColumnCheck(); + columnCheckKey.setName("Database Column Check KEY"); + columnCheckKey.setColumnName("KEY"); + columnCheckKey.getColumnAttributeChecks().add(columnKeyTypeCheck); + + DatabaseColumnAttributeCheck columnNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckName = factory.createDatabaseColumnCheck(); + columnCheckName.setName("Database Column Check NAME"); + columnCheckName.setColumnName("NAME"); + columnCheckName.getColumnAttributeChecks().add(columnNameTypeCheck); + + DatabaseColumnAttributeCheck columnParentKeyTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnParentKeyTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnParentKeyTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckParentKey = factory.createDatabaseColumnCheck(); + columnCheckParentKey.setName("Database Column Check PARENT_KEY"); + columnCheckParentKey.setColumnName("PARENT_KEY"); + columnCheckParentKey.getColumnAttributeChecks().add(columnParentKeyTypeCheck); + + DatabaseTableCheck databaseTableCheckHierarchy = factory.createDatabaseTableCheck(); + databaseTableCheckHierarchy.setName("Database Table Hier_One_Top_Member Check"); + databaseTableCheckHierarchy.setTableName("Hier_One_Top_Member"); + databaseTableCheckHierarchy.getColumnChecks().add(columnCheckKey); + databaseTableCheckHierarchy.getColumnChecks().add(columnCheckName); + databaseTableCheckHierarchy.getColumnChecks().add(columnCheckParentKey); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckFact); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckHierarchy); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with minimal parent-child hierarchy"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for minimal parent-child hierarchy tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Parent Child Minimal Suite"); + suite.setDescription("Check suite for the minimal parent-child hierarchy mapping tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/parentchild/nullparent/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/nullparent/CheckSuiteSupplier.java b/instance/emf/tutorial/parentchild/nullparent/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/nullparent/CheckSuiteSupplier.java new file mode 100644 index 00000000..8ecc8571 --- /dev/null +++ b/instance/emf/tutorial/parentchild/nullparent/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/nullparent/CheckSuiteSupplier.java @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.parentchild.nullparent; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelAttribute; +import org.eclipse.daanse.olap.check.model.check.LevelAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the parent-child hierarchy with null parent value tutorial. + * Checks that the catalog, cube, measure, and parent-child hierarchy with nullParentValue exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Parent Child Null Parent"; + private static final String CUBE_NAME = "Cube"; + private static final String MEASURE_NAME = "Value"; + private static final String DIMENSION_NAME = "Dimension"; + private static final String HIERARCHY_NAME = "Hierarchy"; + private static final String LEVEL_NAME = "Name"; + private static final String ALL_MEMBER_NAME = "All"; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + MEASURE_NAME); + measureCheck.setDescription("Check that measure '" + MEASURE_NAME + "' exists"); + measureCheck.setMeasureName(MEASURE_NAME); + + // Create level check with unique members attribute + LevelAttributeCheck levelUniqueCheck = factory.createLevelAttributeCheck(); + levelUniqueCheck.setAttributeType(LevelAttribute.IS_UNIQUE); + levelUniqueCheck.setExpectedBoolean(true); + + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for " + LEVEL_NAME); + levelCheck.setLevelName(LEVEL_NAME); + levelCheck.getLevelAttributeChecks().add(levelUniqueCheck); + + // Create hierarchy attribute checks + HierarchyAttributeCheck hierarchyHasAllCheck = factory.createHierarchyAttributeCheck(); + hierarchyHasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyHasAllCheck.setExpectedBoolean(true); + + HierarchyAttributeCheck hierarchyAllMemberNameCheck = factory.createHierarchyAttributeCheck(); + hierarchyAllMemberNameCheck.setAttributeType(HierarchyAttribute.ALL_MEMBER_NAME); + hierarchyAllMemberNameCheck.setExpectedValue(ALL_MEMBER_NAME); + + // Create hierarchy check for parent-child hierarchy + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for " + HIERARCHY_NAME); + hierarchyCheck.setHierarchyName(HIERARCHY_NAME); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyHasAllCheck); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAllMemberNameCheck); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + DIMENSION_NAME); + dimensionCheck.setDimensionName(DIMENSION_NAME); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_NAME); + cubeCheck.setDescription("Check that cube '" + CUBE_NAME + "' exists with parent-child hierarchy with null parent value"); + cubeCheck.setCubeName(CUBE_NAME); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create database column checks for Parent table + DatabaseColumnAttributeCheck columnNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckName = factory.createDatabaseColumnCheck(); + columnCheckName.setName("Database Column Check NAME"); + columnCheckName.setColumnName("NAME"); + columnCheckName.getColumnAttributeChecks().add(columnNameTypeCheck); + + DatabaseColumnAttributeCheck columnParentTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnParentTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnParentTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckParent = factory.createDatabaseColumnCheck(); + columnCheckParent.setName("Database Column Check PARENT"); + columnCheckParent.setColumnName("PARENT"); + columnCheckParent.getColumnAttributeChecks().add(columnParentTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckParent = factory.createDatabaseTableCheck(); + databaseTableCheckParent.setName("Database Table Parent Check"); + databaseTableCheckParent.setTableName("Parent"); + databaseTableCheckParent.getColumnChecks().add(columnCheckName); + databaseTableCheckParent.getColumnChecks().add(columnCheckParent); + databaseTableCheckParent.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckParent); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with parent-child hierarchy with null parent value"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for parent-child hierarchy with null parent value tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Parent Child Null Parent Suite"); + suite.setDescription("Check suite for the parent-child hierarchy with null parent value mapping tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/parentchild/parentasleaf/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/parentasleaf/CheckSuiteSupplier.java b/instance/emf/tutorial/parentchild/parentasleaf/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/parentasleaf/CheckSuiteSupplier.java new file mode 100644 index 00000000..38f1a232 --- /dev/null +++ b/instance/emf/tutorial/parentchild/parentasleaf/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/parentchild/parentasleaf/CheckSuiteSupplier.java @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.parentchild.parentasleaf; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttribute; +import org.eclipse.daanse.olap.check.model.check.HierarchyAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelAttribute; +import org.eclipse.daanse.olap.check.model.check.LevelAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the parent-child hierarchy with parent as leaf enabled tutorial. + * Checks that the catalog, cube, measure, and parent-child hierarchy with parentAsLeafEnable exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Parent Child Parent As Leaf"; + private static final String CUBE_NAME = "Cube"; + private static final String MEASURE_NAME = "Value"; + private static final String DIMENSION_NAME = "Dimension"; + private static final String HIERARCHY_NAME = "Hierarchy"; + private static final String LEVEL_NAME = "Name"; + private static final String ALL_MEMBER_NAME = "All"; + + @Override + public OlapCheckSuite get() { + // Create measure check + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + MEASURE_NAME); + measureCheck.setDescription("Check that measure '" + MEASURE_NAME + "' exists"); + measureCheck.setMeasureName(MEASURE_NAME); + + // Create level check with unique members attribute + LevelAttributeCheck levelUniqueCheck = factory.createLevelAttributeCheck(); + levelUniqueCheck.setAttributeType(LevelAttribute.IS_UNIQUE); + levelUniqueCheck.setExpectedBoolean(true); + + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for " + LEVEL_NAME); + levelCheck.setLevelName(LEVEL_NAME); + levelCheck.getLevelAttributeChecks().add(levelUniqueCheck); + + // Create hierarchy attribute checks + HierarchyAttributeCheck hierarchyHasAllCheck = factory.createHierarchyAttributeCheck(); + hierarchyHasAllCheck.setAttributeType(HierarchyAttribute.HAS_ALL); + hierarchyHasAllCheck.setExpectedBoolean(true); + + HierarchyAttributeCheck hierarchyAllMemberNameCheck = factory.createHierarchyAttributeCheck(); + hierarchyAllMemberNameCheck.setAttributeType(HierarchyAttribute.ALL_MEMBER_NAME); + hierarchyAllMemberNameCheck.setExpectedValue(ALL_MEMBER_NAME); + + // Create hierarchy check for parent-child hierarchy + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for " + HIERARCHY_NAME); + hierarchyCheck.setHierarchyName(HIERARCHY_NAME); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyHasAllCheck); + hierarchyCheck.getHierarchyAttributeChecks().add(hierarchyAllMemberNameCheck); + hierarchyCheck.getLevelChecks().add(levelCheck); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + DIMENSION_NAME); + dimensionCheck.setDimensionName(DIMENSION_NAME); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create cube check with measure and dimension checks + CubeCheck cubeCheck = factory.createCubeCheck(); + cubeCheck.setName("CubeCheck-" + CUBE_NAME); + cubeCheck.setDescription("Check that cube '" + CUBE_NAME + "' exists with parent-child hierarchy with parent as leaf"); + cubeCheck.setCubeName(CUBE_NAME); + cubeCheck.getMeasureChecks().add(measureCheck); + cubeCheck.getDimensionChecks().add(dimensionCheck); + + // Create database column checks for Parent table + DatabaseColumnAttributeCheck columnNameTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnNameTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnNameTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckName = factory.createDatabaseColumnCheck(); + columnCheckName.setName("Database Column Check NAME"); + columnCheckName.setColumnName("NAME"); + columnCheckName.getColumnAttributeChecks().add(columnNameTypeCheck); + + DatabaseColumnAttributeCheck columnParentTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnParentTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnParentTypeCheck.setExpectedValue("VARCHAR"); + + DatabaseColumnCheck columnCheckParent = factory.createDatabaseColumnCheck(); + columnCheckParent.setName("Database Column Check PARENT"); + columnCheckParent.setColumnName("PARENT"); + columnCheckParent.getColumnAttributeChecks().add(columnParentTypeCheck); + + DatabaseColumnAttributeCheck columnValueTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnValueTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnValueTypeCheck.setExpectedValue("INTEGER"); + + DatabaseColumnCheck columnCheckValue = factory.createDatabaseColumnCheck(); + columnCheckValue.setName("Database Column Check VALUE"); + columnCheckValue.setColumnName("VALUE"); + columnCheckValue.getColumnAttributeChecks().add(columnValueTypeCheck); + + DatabaseTableCheck databaseTableCheckParent = factory.createDatabaseTableCheck(); + databaseTableCheckParent.setName("Database Table Parent Check"); + databaseTableCheckParent.setTableName("Parent"); + databaseTableCheckParent.getColumnChecks().add(columnCheckName); + databaseTableCheckParent.getColumnChecks().add(columnCheckParent); + databaseTableCheckParent.getColumnChecks().add(columnCheckValue); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check"); + databaseSchemaCheck.setDescription("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.getTableChecks().add(databaseTableCheckParent); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with parent-child hierarchy with parent as leaf"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheck); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for parent-child hierarchy with parent as leaf tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Parent Child Parent As Leaf Suite"); + suite.setDescription("Check suite for the parent-child hierarchy with parent as leaf mapping tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } +} diff --git a/instance/emf/tutorial/virtualcube/calculatedmember/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/calculatedmember/CheckSuiteSupplier.java b/instance/emf/tutorial/virtualcube/calculatedmember/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/calculatedmember/CheckSuiteSupplier.java new file mode 100644 index 00000000..382fa56e --- /dev/null +++ b/instance/emf/tutorial/virtualcube/calculatedmember/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/calculatedmember/CheckSuiteSupplier.java @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.virtualcube.calculatedmember; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.MemberCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the virtual cube calculated member tutorial. + * Checks that the catalog with two physical cubes (Cube1, Cube2) and one virtual cube (Cube1Cube2), + * their measures, calculated members, and dimensions exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Virtual Cube Calculated Member"; + + // Cube names + private static final String CUBE1_NAME = "Cube1"; + private static final String CUBE2_NAME = "Cube2"; + private static final String VIRTUAL_CUBE_NAME = "Cube1Cube2"; + + // Measure names + private static final String MEASURE_CUBE1 = "MeasureCube1"; + private static final String MEASURE_CUBE2 = "MeasureCube2"; + + // Calculated member names + private static final String CALC_MEMBER_SUM_CUB1 = "Sum_Cub1"; + private static final String CALC_MEMBER_SUM_CUB2 = "Sum_Cub2"; + private static final String CALC_MEMBER_SUM_CUB = "Sum_Cub"; + + // Dimension names + private static final String DIMENSION_CUBE1 = "Cube1Dimension1"; + private static final String DIMENSION_CUBE2 = "Cube2Dimension1"; + + @Override + public OlapCheckSuite get() { + // Create dimension checks + DimensionCheck dimCheckCube1Dimension1 = createDimensionCheck(DIMENSION_CUBE1); + DimensionCheck dimCheckCube2Dimension1 = createDimensionCheck(DIMENSION_CUBE2); + + // Create measure checks + MeasureCheck measureCheckCube1 = createMeasureCheck(MEASURE_CUBE1); + MeasureCheck measureCheckCube2 = createMeasureCheck(MEASURE_CUBE2); + + // Create calculated member checks for Cube1 + MeasureCheck calcMemberCheckSumCub1 = createCalculatedMemberCheck(CALC_MEMBER_SUM_CUB1); + + // Create calculated member checks for Cube2 + MeasureCheck calcMemberCheckSumCub2 = createCalculatedMemberCheck(CALC_MEMBER_SUM_CUB2); + + // Create calculated member checks for Virtual Cube + MeasureCheck calcMemberCheckSumCub = createCalculatedMemberCheck(CALC_MEMBER_SUM_CUB); + + // Create cube check for Cube1 + CubeCheck cubeCheckCube1 = factory.createCubeCheck(); + cubeCheckCube1.setName("CubeCheck-" + CUBE1_NAME); + cubeCheckCube1.setDescription("Check that cube '" + CUBE1_NAME + "' exists"); + cubeCheckCube1.setCubeName(CUBE1_NAME); + cubeCheckCube1.getMeasureChecks().add(measureCheckCube1); + cubeCheckCube1.getDimensionChecks().add(dimCheckCube1Dimension1); + cubeCheckCube1.getMeasureChecks().add(calcMemberCheckSumCub1); + + // Create cube check for Cube2 + CubeCheck cubeCheckCube2 = factory.createCubeCheck(); + cubeCheckCube2.setName("CubeCheck-" + CUBE2_NAME); + cubeCheckCube2.setDescription("Check that cube '" + CUBE2_NAME + "' exists"); + cubeCheckCube2.setCubeName(CUBE2_NAME); + cubeCheckCube2.getMeasureChecks().add(measureCheckCube2); + cubeCheckCube2.getDimensionChecks().add(dimCheckCube2Dimension1); + cubeCheckCube2.getMeasureChecks().add(calcMemberCheckSumCub2); + + // Create cube check for Virtual Cube + CubeCheck cubeCheckVirtualCube = factory.createCubeCheck(); + cubeCheckVirtualCube.setName("CubeCheck-" + VIRTUAL_CUBE_NAME); + cubeCheckVirtualCube.setDescription("Check that virtual cube '" + VIRTUAL_CUBE_NAME + "' exists"); + cubeCheckVirtualCube.setCubeName(VIRTUAL_CUBE_NAME); + cubeCheckVirtualCube.getMeasureChecks().add(measureCheckCube1); + cubeCheckVirtualCube.getMeasureChecks().add(measureCheckCube2); + cubeCheckVirtualCube.getDimensionChecks().add(dimCheckCube1Dimension1); + cubeCheckVirtualCube.getDimensionChecks().add(dimCheckCube2Dimension1); + cubeCheckVirtualCube.getMeasureChecks().add(calcMemberCheckSumCub1); + cubeCheckVirtualCube.getMeasureChecks().add(calcMemberCheckSumCub2); + cubeCheckVirtualCube.getMeasureChecks().add(calcMemberCheckSumCub); + + // Create database table and column checks + DatabaseTableCheck tableCheckFact = createTableCheck("Fact", + createColumnCheck("KEY", "VARCHAR"), + createColumnCheck("VALUE", "INTEGER") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for virtual cube calculated member tutorial"); + databaseSchemaCheck.getTableChecks().add(tableCheckFact); + + // Create catalog check with all cube checks + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes, measures, and calculated members"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckCube1); + catalogCheck.getCubeChecks().add(cubeCheckCube2); + catalogCheck.getCubeChecks().add(cubeCheckVirtualCube); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for virtual cube calculated member tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Virtual Cube Calculated Member Suite"); + suite.setDescription("Check suite for the virtual cube calculated member tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + return dimensionCheck; + } + + /** + * Creates a CalculatedMemberCheck with the specified name. + * + * @param calculatedMemberName the name of the calculated member + * @return the configured CalculatedMemberCheck + */ + private MeasureCheck createCalculatedMemberCheck(String calculatedMemberName) { + MeasureCheck calculatedMemberCheck = factory.createMeasureCheck(); + calculatedMemberCheck.setName("CalculatedMemberCheck-" + calculatedMemberName); + calculatedMemberCheck.setDescription("Check that calculated member '" + calculatedMemberName + "' exists"); + calculatedMemberCheck.setMeasureName(calculatedMemberName); + return calculatedMemberCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/tutorial/virtualcube/dimensions/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/dimensions/CheckSuiteSupplier.java b/instance/emf/tutorial/virtualcube/dimensions/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/dimensions/CheckSuiteSupplier.java new file mode 100644 index 00000000..5602293a --- /dev/null +++ b/instance/emf/tutorial/virtualcube/dimensions/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/dimensions/CheckSuiteSupplier.java @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.virtualcube.dimensions; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the virtual cube dimensions tutorial. + * Checks that the catalog with two physical cubes (Cube1, Cube2) and one virtual cube (Cube1Cube2), + * their measures, and dimensions exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Virtual Cube Dimensions"; + + // Cube names + private static final String CUBE1_NAME = "Cube1"; + private static final String CUBE2_NAME = "Cube2"; + private static final String VIRTUAL_CUBE_NAME = "Cube1Cube2"; + + // Measure names + private static final String MEASURE_CUBE1 = "MeasureCube1"; + private static final String MEASURE_CUBE2 = "MeasureCube2"; + + // Dimension names + private static final String DIMENSION_CUBE1 = "Cube1Dimension1"; + private static final String DIMENSION_CUBE2 = "Cube2Dimension1"; + + @Override + public OlapCheckSuite get() { + // Create dimension checks + DimensionCheck dimCheckCube1Dimension1 = createDimensionCheck(DIMENSION_CUBE1); + DimensionCheck dimCheckCube2Dimension1 = createDimensionCheck(DIMENSION_CUBE2); + + // Create measure checks + MeasureCheck measureCheckCube1 = createMeasureCheck(MEASURE_CUBE1); + MeasureCheck measureCheckCube2 = createMeasureCheck(MEASURE_CUBE2); + + // Create cube check for Cube1 + CubeCheck cubeCheckCube1 = factory.createCubeCheck(); + cubeCheckCube1.setName("CubeCheck-" + CUBE1_NAME); + cubeCheckCube1.setDescription("Check that cube '" + CUBE1_NAME + "' exists"); + cubeCheckCube1.setCubeName(CUBE1_NAME); + cubeCheckCube1.getMeasureChecks().add(measureCheckCube1); + cubeCheckCube1.getDimensionChecks().add(dimCheckCube1Dimension1); + + // Create cube check for Cube2 + CubeCheck cubeCheckCube2 = factory.createCubeCheck(); + cubeCheckCube2.setName("CubeCheck-" + CUBE2_NAME); + cubeCheckCube2.setDescription("Check that cube '" + CUBE2_NAME + "' exists"); + cubeCheckCube2.setCubeName(CUBE2_NAME); + cubeCheckCube2.getMeasureChecks().add(measureCheckCube2); + cubeCheckCube2.getDimensionChecks().add(dimCheckCube2Dimension1); + + // Create cube check for Virtual Cube + CubeCheck cubeCheckVirtualCube = factory.createCubeCheck(); + cubeCheckVirtualCube.setName("CubeCheck-" + VIRTUAL_CUBE_NAME); + cubeCheckVirtualCube.setDescription("Check that virtual cube '" + VIRTUAL_CUBE_NAME + "' exists"); + cubeCheckVirtualCube.setCubeName(VIRTUAL_CUBE_NAME); + cubeCheckVirtualCube.getMeasureChecks().add(measureCheckCube1); + cubeCheckVirtualCube.getMeasureChecks().add(measureCheckCube2); + cubeCheckVirtualCube.getDimensionChecks().add(dimCheckCube1Dimension1); + cubeCheckVirtualCube.getDimensionChecks().add(dimCheckCube2Dimension1); + + // Create database table and column checks + DatabaseTableCheck tableCheckFact = createTableCheck("Fact", + createColumnCheck("KEY", "VARCHAR"), + createColumnCheck("VALUE", "INTEGER") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for virtual cube dimensions tutorial"); + databaseSchemaCheck.getTableChecks().add(tableCheckFact); + + // Create catalog check with all cube checks + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes, measures, and dimensions"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckCube1); + catalogCheck.getCubeChecks().add(cubeCheckCube2); + catalogCheck.getCubeChecks().add(cubeCheckVirtualCube); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for virtual cube dimensions tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Virtual Cube Dimensions Suite"); + suite.setDescription("Check suite for the virtual cube dimensions tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + return dimensionCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/tutorial/virtualcube/min/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/min/CheckSuiteSupplier.java b/instance/emf/tutorial/virtualcube/min/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/min/CheckSuiteSupplier.java new file mode 100644 index 00000000..f2e07545 --- /dev/null +++ b/instance/emf/tutorial/virtualcube/min/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/min/CheckSuiteSupplier.java @@ -0,0 +1,193 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.virtualcube.min; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the minimal virtual cube tutorial. + * Checks that the catalog with two physical cubes (Cube1, Cube2) and one virtual cube (VirtualCubeMeasureOnly), + * their measures, and calculated members exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Virtual Cube Minimal"; + + // Cube names + private static final String CUBE1_NAME = "Cube1"; + private static final String CUBE2_NAME = "Cube2"; + private static final String VIRTUAL_CUBE_NAME = "VirtualCubeMeasureOnly"; + + // Measure names + private static final String MEASURE_C1 = "C1-Measure-Sum"; + private static final String MEASURE_C2 = "C2-Measure-Sum"; + + // Calculated member name + private static final String CALC_MEMBER_CALCULATION1 = "Calculation1"; + + @Override + public OlapCheckSuite get() { + // Create measure checks + MeasureCheck measureCheckC1 = createMeasureCheck(MEASURE_C1); + MeasureCheck measureCheckC2 = createMeasureCheck(MEASURE_C2); + + // Create calculated member check + MeasureCheck calcMemberCheckCalculation1 = createCalculatedMemberCheck(CALC_MEMBER_CALCULATION1); + + // Create cube check for Cube1 + CubeCheck cubeCheckCube1 = factory.createCubeCheck(); + cubeCheckCube1.setName("CubeCheck-" + CUBE1_NAME); + cubeCheckCube1.setDescription("Check that cube '" + CUBE1_NAME + "' exists"); + cubeCheckCube1.setCubeName(CUBE1_NAME); + cubeCheckCube1.getMeasureChecks().add(measureCheckC1); + + // Create cube check for Cube2 + CubeCheck cubeCheckCube2 = factory.createCubeCheck(); + cubeCheckCube2.setName("CubeCheck-" + CUBE2_NAME); + cubeCheckCube2.setDescription("Check that cube '" + CUBE2_NAME + "' exists"); + cubeCheckCube2.setCubeName(CUBE2_NAME); + cubeCheckCube2.getMeasureChecks().add(measureCheckC2); + + // Create cube check for Virtual Cube + CubeCheck cubeCheckVirtualCube = factory.createCubeCheck(); + cubeCheckVirtualCube.setName("CubeCheck-" + VIRTUAL_CUBE_NAME); + cubeCheckVirtualCube.setDescription("Check that virtual cube '" + VIRTUAL_CUBE_NAME + "' exists"); + cubeCheckVirtualCube.setCubeName(VIRTUAL_CUBE_NAME); + cubeCheckVirtualCube.getMeasureChecks().add(measureCheckC1); + cubeCheckVirtualCube.getMeasureChecks().add(measureCheckC2); + cubeCheckVirtualCube.getMeasureChecks().add(calcMemberCheckCalculation1); + + // Create database table and column checks for C1_Fact + DatabaseTableCheck tableCheckC1Fact = createTableCheck("C1_Fact", + createColumnCheck("KEY", "VARCHAR"), + createColumnCheck("VALUE", "INTEGER") + ); + + // Create database table and column checks for C2_Fact + DatabaseTableCheck tableCheckC2Fact = createTableCheck("C2_Fact", + createColumnCheck("KEY", "VARCHAR"), + createColumnCheck("VALUE", "INTEGER") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for minimal virtual cube tutorial"); + databaseSchemaCheck.getTableChecks().add(tableCheckC1Fact); + databaseSchemaCheck.getTableChecks().add(tableCheckC2Fact); + + // Create catalog check with all cube checks + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes, measures, and calculated members"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckCube1); + catalogCheck.getCubeChecks().add(cubeCheckCube2); + catalogCheck.getCubeChecks().add(cubeCheckVirtualCube); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for minimal virtual cube tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Virtual Cube Minimal Suite"); + suite.setDescription("Check suite for the minimal virtual cube tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a CalculatedMemberCheck with the specified name. + * + * @param calculatedMemberName the name of the calculated member + * @return the configured CalculatedMemberCheck + */ + private MeasureCheck createCalculatedMemberCheck(String calculatedMemberName) { + MeasureCheck calculatedMemberCheck = factory.createMeasureCheck(); + calculatedMemberCheck.setName("CalculatedMemberCheck-" + calculatedMemberName); + calculatedMemberCheck.setDescription("Check that calculated member '" + calculatedMemberName + "' exists"); + calculatedMemberCheck.setMeasureName(calculatedMemberName); + return calculatedMemberCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/tutorial/virtualcube/unvisiblereferencecubes/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/unvisiblereferencecubes/CheckSuiteSupplier.java b/instance/emf/tutorial/virtualcube/unvisiblereferencecubes/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/unvisiblereferencecubes/CheckSuiteSupplier.java new file mode 100644 index 00000000..9161c1df --- /dev/null +++ b/instance/emf/tutorial/virtualcube/unvisiblereferencecubes/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/virtualcube/unvisiblereferencecubes/CheckSuiteSupplier.java @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.virtualcube.unvisiblereferencecubes; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the virtual cube with invisible reference cubes tutorial. + * Checks that the catalog with two invisible physical cubes (Cube1, Cube2) and one visible virtual cube (Cube1Cube2), + * their measures, and dimensions exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Virtual Cube Unvisible Reference Cubes"; + + // Cube names + private static final String CUBE1_NAME = "Cube1"; + private static final String CUBE2_NAME = "Cube2"; + private static final String VIRTUAL_CUBE_NAME = "Cube1Cube2"; + + // Measure names + private static final String MEASURE_CUBE1 = "MeasureCube1"; + private static final String MEASURE_CUBE2 = "MeasureCube2"; + + // Dimension names + private static final String DIMENSION_CUBE1 = "Cube1Dimension1"; + private static final String DIMENSION_CUBE2 = "Cube2Dimension1"; + + @Override + public OlapCheckSuite get() { + // Create dimension checks + DimensionCheck dimCheckCube1Dimension1 = createDimensionCheck(DIMENSION_CUBE1); + DimensionCheck dimCheckCube2Dimension1 = createDimensionCheck(DIMENSION_CUBE2); + + // Create measure checks + MeasureCheck measureCheckCube1 = createMeasureCheck(MEASURE_CUBE1); + MeasureCheck measureCheckCube2 = createMeasureCheck(MEASURE_CUBE2); + + // Create cube check for Cube1 (invisible) + CubeCheck cubeCheckCube1 = factory.createCubeCheck(); + cubeCheckCube1.setName("CubeCheck-" + CUBE1_NAME); + cubeCheckCube1.setDescription("Check that cube '" + CUBE1_NAME + "' exists (invisible)"); + cubeCheckCube1.setCubeName(CUBE1_NAME); + cubeCheckCube1.getMeasureChecks().add(measureCheckCube1); + cubeCheckCube1.getDimensionChecks().add(dimCheckCube1Dimension1); + + // Create cube check for Cube2 (invisible) + CubeCheck cubeCheckCube2 = factory.createCubeCheck(); + cubeCheckCube2.setName("CubeCheck-" + CUBE2_NAME); + cubeCheckCube2.setDescription("Check that cube '" + CUBE2_NAME + "' exists (invisible)"); + cubeCheckCube2.setCubeName(CUBE2_NAME); + cubeCheckCube2.getMeasureChecks().add(measureCheckCube2); + cubeCheckCube2.getDimensionChecks().add(dimCheckCube2Dimension1); + + // Create cube check for Virtual Cube + CubeCheck cubeCheckVirtualCube = factory.createCubeCheck(); + cubeCheckVirtualCube.setName("CubeCheck-" + VIRTUAL_CUBE_NAME); + cubeCheckVirtualCube.setDescription("Check that virtual cube '" + VIRTUAL_CUBE_NAME + "' exists"); + cubeCheckVirtualCube.setCubeName(VIRTUAL_CUBE_NAME); + cubeCheckVirtualCube.getMeasureChecks().add(measureCheckCube1); + cubeCheckVirtualCube.getMeasureChecks().add(measureCheckCube2); + cubeCheckVirtualCube.getDimensionChecks().add(dimCheckCube1Dimension1); + cubeCheckVirtualCube.getDimensionChecks().add(dimCheckCube2Dimension1); + + // Create database table and column checks + DatabaseTableCheck tableCheckFact = createTableCheck("Fact", + createColumnCheck("KEY", "VARCHAR"), + createColumnCheck("VALUE", "INTEGER") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for virtual cube with invisible reference cubes tutorial"); + databaseSchemaCheck.getTableChecks().add(tableCheckFact); + + // Create catalog check with all cube checks + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with all cubes, measures, and dimensions"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckCube1); + catalogCheck.getCubeChecks().add(cubeCheckCube2); + catalogCheck.getCubeChecks().add(cubeCheckVirtualCube); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for virtual cube with invisible reference cubes tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Virtual Cube Unvisible Reference Cubes Suite"); + suite.setDescription("Check suite for the virtual cube with invisible reference cubes tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DimensionCheck with the specified name. + * + * @param dimensionName the name of the dimension + * @return the configured DimensionCheck + */ + private DimensionCheck createDimensionCheck(String dimensionName) { + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + dimensionName); + dimensionCheck.setDimensionName(dimensionName); + return dimensionCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/tutorial/writeback/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/inlinetable/CheckSuiteSupplier.java b/instance/emf/tutorial/writeback/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/inlinetable/CheckSuiteSupplier.java new file mode 100644 index 00000000..8522cd9e --- /dev/null +++ b/instance/emf/tutorial/writeback/inlinetable/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/inlinetable/CheckSuiteSupplier.java @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.writeback.inlinetable; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the writeback inline table tutorial. + * Checks that the catalog with cube C, its measures (Measure1, Measure2), + * dimension D1 with hierarchy and levels, and writeback functionality exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Writeback Inline Table"; + + // Cube name + private static final String CUBE_NAME = "C"; + + // Measure names + private static final String MEASURE1 = "Measure1"; + private static final String MEASURE2 = "Measure2"; + + // Dimension name + private static final String DIMENSION_D1 = "D1"; + + // Hierarchy name + private static final String HIERARCHY_NAME = "HierarchyWithHasAll"; + + // Level names + private static final String LEVEL_L1 = "L1"; + private static final String LEVEL_L2 = "L2"; + + @Override + public OlapCheckSuite get() { + // Create level checks + LevelCheck levelCheckL1 = createLevelCheck(LEVEL_L1); + LevelCheck levelCheckL2 = createLevelCheck(LEVEL_L2); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for " + HIERARCHY_NAME); + hierarchyCheck.setHierarchyName(HIERARCHY_NAME); + hierarchyCheck.getLevelChecks().add(levelCheckL1); + hierarchyCheck.getLevelChecks().add(levelCheckL2); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + DIMENSION_D1); + dimensionCheck.setDimensionName(DIMENSION_D1); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create measure checks + MeasureCheck measureCheck1 = createMeasureCheck(MEASURE1); + MeasureCheck measureCheck2 = createMeasureCheck(MEASURE2); + + // Create cube check for C + CubeCheck cubeCheckC = factory.createCubeCheck(); + cubeCheckC.setName("CubeCheck-" + CUBE_NAME); + cubeCheckC.setDescription("Check that cube '" + CUBE_NAME + "' exists"); + cubeCheckC.setCubeName(CUBE_NAME); + cubeCheckC.getMeasureChecks().add(measureCheck1); + cubeCheckC.getMeasureChecks().add(measureCheck2); + cubeCheckC.getDimensionChecks().add(dimensionCheck); + + // Create database table and column checks for FACT inline table + DatabaseTableCheck tableCheckFact = createTableCheck("FACT", + createColumnCheck("VAL", "INTEGER"), + createColumnCheck("VAL1", "INTEGER"), + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for L1 table + DatabaseTableCheck tableCheckL1 = createTableCheck("L1", + createColumnCheck("L1", "VARCHAR"), + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for L2 table + DatabaseTableCheck tableCheckL2 = createTableCheck("L2", + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for FACTWB table + DatabaseTableCheck tableCheckFactWB = createTableCheck("FACTWB", + createColumnCheck("VAL", "INTEGER"), + createColumnCheck("VAL1", "INTEGER"), + createColumnCheck("L2", "VARCHAR"), + createColumnCheck("ID", "VARCHAR"), + createColumnCheck("USER", "VARCHAR") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for writeback inline table tutorial"); + databaseSchemaCheck.getTableChecks().add(tableCheckFact); + databaseSchemaCheck.getTableChecks().add(tableCheckL1); + databaseSchemaCheck.getTableChecks().add(tableCheckL2); + databaseSchemaCheck.getTableChecks().add(tableCheckFactWB); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with cube, measures, dimension, and writeback functionality"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckC); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for writeback inline table tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Writeback Inline Table Suite"); + suite.setDescription("Check suite for the writeback inline table tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a LevelCheck with the specified name. + * + * @param levelName the name of the level + * @return the configured LevelCheck + */ + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for " + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/tutorial/writeback/table/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/table/CheckSuiteSupplier.java b/instance/emf/tutorial/writeback/table/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/table/CheckSuiteSupplier.java new file mode 100644 index 00000000..bc9ef197 --- /dev/null +++ b/instance/emf/tutorial/writeback/table/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/table/CheckSuiteSupplier.java @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.writeback.table; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the writeback table tutorial. + * Checks that the catalog with cube C, its measures (Measure1, Measure2), + * dimension D1 with hierarchy and levels, and writeback functionality exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Writeback Table"; + + // Cube name + private static final String CUBE_NAME = "C"; + + // Measure names + private static final String MEASURE1 = "Measure1"; + private static final String MEASURE2 = "Measure2"; + + // Dimension name + private static final String DIMENSION_D1 = "D1"; + + // Hierarchy name + private static final String HIERARCHY_NAME = "HierarchyWithHasAll"; + + // Level names + private static final String LEVEL_L1 = "L1"; + private static final String LEVEL_L2 = "L2"; + + @Override + public OlapCheckSuite get() { + // Create level checks + LevelCheck levelCheckL1 = createLevelCheck(LEVEL_L1); + LevelCheck levelCheckL2 = createLevelCheck(LEVEL_L2); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for " + HIERARCHY_NAME); + hierarchyCheck.setHierarchyName(HIERARCHY_NAME); + hierarchyCheck.getLevelChecks().add(levelCheckL1); + hierarchyCheck.getLevelChecks().add(levelCheckL2); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + DIMENSION_D1); + dimensionCheck.setDimensionName(DIMENSION_D1); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create measure checks + MeasureCheck measureCheck1 = createMeasureCheck(MEASURE1); + MeasureCheck measureCheck2 = createMeasureCheck(MEASURE2); + + // Create cube check for C + CubeCheck cubeCheckC = factory.createCubeCheck(); + cubeCheckC.setName("CubeCheck-" + CUBE_NAME); + cubeCheckC.setDescription("Check that cube '" + CUBE_NAME + "' exists"); + cubeCheckC.setCubeName(CUBE_NAME); + cubeCheckC.getMeasureChecks().add(measureCheck1); + cubeCheckC.getMeasureChecks().add(measureCheck2); + cubeCheckC.getDimensionChecks().add(dimensionCheck); + + // Create database table and column checks for FACT table + DatabaseTableCheck tableCheckFact = createTableCheck("FACT", + createColumnCheck("VAL", "INTEGER"), + createColumnCheck("VAL1", "INTEGER"), + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for L1 table + DatabaseTableCheck tableCheckL1 = createTableCheck("L1", + createColumnCheck("L1", "VARCHAR"), + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for L2 table + DatabaseTableCheck tableCheckL2 = createTableCheck("L2", + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for FACTWB table + DatabaseTableCheck tableCheckFactWB = createTableCheck("FACTWB", + createColumnCheck("VAL", "INTEGER"), + createColumnCheck("VAL1", "INTEGER"), + createColumnCheck("L2", "VARCHAR"), + createColumnCheck("ID", "VARCHAR"), + createColumnCheck("USER", "VARCHAR") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for writeback table tutorial"); + databaseSchemaCheck.getTableChecks().add(tableCheckFact); + databaseSchemaCheck.getTableChecks().add(tableCheckL1); + databaseSchemaCheck.getTableChecks().add(tableCheckL2); + databaseSchemaCheck.getTableChecks().add(tableCheckFactWB); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with cube, measures, dimension, and writeback functionality"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckC); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for writeback table tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Writeback Table Suite"); + suite.setDescription("Check suite for the writeback table tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a LevelCheck with the specified name. + * + * @param levelName the name of the level + * @return the configured LevelCheck + */ + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for " + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/tutorial/writeback/view/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/view/CheckSuiteSupplier.java b/instance/emf/tutorial/writeback/view/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/view/CheckSuiteSupplier.java new file mode 100644 index 00000000..560d1d8e --- /dev/null +++ b/instance/emf/tutorial/writeback/view/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/view/CheckSuiteSupplier.java @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.writeback.view; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.DimensionCheck; +import org.eclipse.daanse.olap.check.model.check.HierarchyCheck; +import org.eclipse.daanse.olap.check.model.check.LevelCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the writeback view tutorial. + * Checks that the catalog with cube C, its measures (Measure1, Measure2), + * dimension D1 with hierarchy and levels, and writeback functionality exist and are accessible. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Writeback View"; + + // Cube name + private static final String CUBE_NAME = "C"; + + // Measure names + private static final String MEASURE1 = "Measure1"; + private static final String MEASURE2 = "Measure2"; + + // Dimension name + private static final String DIMENSION_D1 = "D1"; + + // Hierarchy name + private static final String HIERARCHY_NAME = "HierarchyWithHasAll"; + + // Level names + private static final String LEVEL_L1 = "L1"; + private static final String LEVEL_L2 = "L2"; + + @Override + public OlapCheckSuite get() { + // Create level checks + LevelCheck levelCheckL1 = createLevelCheck(LEVEL_L1); + LevelCheck levelCheckL2 = createLevelCheck(LEVEL_L2); + + // Create hierarchy check + HierarchyCheck hierarchyCheck = factory.createHierarchyCheck(); + hierarchyCheck.setName("HierarchyCheck for " + HIERARCHY_NAME); + hierarchyCheck.setHierarchyName(HIERARCHY_NAME); + hierarchyCheck.getLevelChecks().add(levelCheckL1); + hierarchyCheck.getLevelChecks().add(levelCheckL2); + + // Create dimension check + DimensionCheck dimensionCheck = factory.createDimensionCheck(); + dimensionCheck.setName("DimensionCheck for " + DIMENSION_D1); + dimensionCheck.setDimensionName(DIMENSION_D1); + dimensionCheck.getHierarchyChecks().add(hierarchyCheck); + + // Create measure checks + MeasureCheck measureCheck1 = createMeasureCheck(MEASURE1); + MeasureCheck measureCheck2 = createMeasureCheck(MEASURE2); + + // Create cube check for C + CubeCheck cubeCheckC = factory.createCubeCheck(); + cubeCheckC.setName("CubeCheck-" + CUBE_NAME); + cubeCheckC.setDescription("Check that cube '" + CUBE_NAME + "' exists"); + cubeCheckC.setCubeName(CUBE_NAME); + cubeCheckC.getMeasureChecks().add(measureCheck1); + cubeCheckC.getMeasureChecks().add(measureCheck2); + cubeCheckC.getDimensionChecks().add(dimensionCheck); + + // Create database table and column checks for FACT sql view + DatabaseTableCheck tableCheckFact = createTableCheck("FACT", + createColumnCheck("VAL", "INTEGER"), + createColumnCheck("VAL1", "INTEGER"), + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for L1 table + DatabaseTableCheck tableCheckL1 = createTableCheck("L1", + createColumnCheck("L1", "VARCHAR"), + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for L2 table + DatabaseTableCheck tableCheckL2 = createTableCheck("L2", + createColumnCheck("L2", "VARCHAR") + ); + + // Create database table and column checks for FACTWB table + DatabaseTableCheck tableCheckFactWB = createTableCheck("FACTWB", + createColumnCheck("VAL", "INTEGER"), + createColumnCheck("VAL1", "INTEGER"), + createColumnCheck("L2", "VARCHAR"), + createColumnCheck("ID", "VARCHAR"), + createColumnCheck("USER", "VARCHAR") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for writeback view tutorial"); + databaseSchemaCheck.getTableChecks().add(tableCheckFact); + databaseSchemaCheck.getTableChecks().add(tableCheckL1); + databaseSchemaCheck.getTableChecks().add(tableCheckL2); + databaseSchemaCheck.getTableChecks().add(tableCheckFactWB); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with cube, measures, dimension, and writeback functionality"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckC); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for writeback view tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Writeback View Suite"); + suite.setDescription("Check suite for the writeback view tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a LevelCheck with the specified name. + * + * @param levelName the name of the level + * @return the configured LevelCheck + */ + private LevelCheck createLevelCheck(String levelName) { + LevelCheck levelCheck = factory.createLevelCheck(); + levelCheck.setName("LevelCheck for " + levelName); + levelCheck.setLevelName(levelName); + return levelCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +} diff --git a/instance/emf/tutorial/writeback/withoutdimension/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/withoutdimension/CheckSuiteSupplier.java b/instance/emf/tutorial/writeback/withoutdimension/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/withoutdimension/CheckSuiteSupplier.java new file mode 100644 index 00000000..9f59355c --- /dev/null +++ b/instance/emf/tutorial/writeback/withoutdimension/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/writeback/withoutdimension/CheckSuiteSupplier.java @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation. + * + * This program and the accompanying materials are made + * available under the terms of the Eclipse Public License 2.0 + * which is available at https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * + */ +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.writeback.withoutdimension; + +import org.eclipse.daanse.olap.check.model.check.CatalogCheck; +import org.eclipse.daanse.olap.check.model.check.CubeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttribute; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnAttributeCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseColumnCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseSchemaCheck; +import org.eclipse.daanse.olap.check.model.check.DatabaseTableCheck; +import org.eclipse.daanse.olap.check.model.check.MeasureCheck; +import org.eclipse.daanse.olap.check.model.check.OlapCheckFactory; +import org.eclipse.daanse.olap.check.model.check.OlapCheckSuite; +import org.eclipse.daanse.olap.check.model.check.OlapConnectionCheck; +import org.eclipse.daanse.olap.check.runtime.api.OlapCheckSuiteSupplier; +import org.osgi.service.component.annotations.Component; + +/** + * Provides a check suite for the writeback without dimension tutorial. + * Checks that the catalog with cube C, its measures (Measure1, Measure2), + * and writeback functionality exist and are accessible. + * This tutorial demonstrates writeback without dimension constraints. + */ +@Component(service = OlapCheckSuiteSupplier.class) +public class CheckSuiteSupplier implements OlapCheckSuiteSupplier { + + private static final OlapCheckFactory factory = OlapCheckFactory.eINSTANCE; + + private static final String CATALOG_NAME = "Daanse Tutorial - Writeback Without Dimension"; + + // Cube name + private static final String CUBE_NAME = "C"; + + // Measure names + private static final String MEASURE1 = "Measure1"; + private static final String MEASURE2 = "Measure2"; + + @Override + public OlapCheckSuite get() { + // Create measure checks + MeasureCheck measureCheck1 = createMeasureCheck(MEASURE1); + MeasureCheck measureCheck2 = createMeasureCheck(MEASURE2); + + // Create cube check for C (without dimensions) + CubeCheck cubeCheckC = factory.createCubeCheck(); + cubeCheckC.setName("CubeCheck-" + CUBE_NAME); + cubeCheckC.setDescription("Check that cube '" + CUBE_NAME + "' exists without dimensions"); + cubeCheckC.setCubeName(CUBE_NAME); + cubeCheckC.getMeasureChecks().add(measureCheck1); + cubeCheckC.getMeasureChecks().add(measureCheck2); + + // Create database table and column checks for FACT table + DatabaseTableCheck tableCheckFact = createTableCheck("FACT", + createColumnCheck("VAL", "INTEGER"), + createColumnCheck("VAL1", "INTEGER"), + createColumnCheck("VALUE", "VARCHAR") + ); + + // Create database table and column checks for FACTWB table + DatabaseTableCheck tableCheckFactWB = createTableCheck("FACTWB", + createColumnCheck("VAL", "INTEGER"), + createColumnCheck("VAL1", "INTEGER"), + createColumnCheck("VALUE", "VARCHAR"), + createColumnCheck("ID", "VARCHAR"), + createColumnCheck("USER", "VARCHAR") + ); + + // Create Database Schema Check + DatabaseSchemaCheck databaseSchemaCheck = factory.createDatabaseSchemaCheck(); + databaseSchemaCheck.setName("Database Schema Check for " + CATALOG_NAME); + databaseSchemaCheck.setDescription("Database Schema Check for writeback without dimension tutorial"); + databaseSchemaCheck.getTableChecks().add(tableCheckFact); + databaseSchemaCheck.getTableChecks().add(tableCheckFactWB); + + // Create catalog check with cube check + CatalogCheck catalogCheck = factory.createCatalogCheck(); + catalogCheck.setName(CATALOG_NAME); + catalogCheck.setDescription("Check that catalog '" + CATALOG_NAME + "' exists with cube, measures, and writeback functionality"); + catalogCheck.setCatalogName(CATALOG_NAME); + catalogCheck.getCubeChecks().add(cubeCheckC); + catalogCheck.getDatabaseSchemaChecks().add(databaseSchemaCheck); + + // Create connection check (uses default connection) + OlapConnectionCheck connectionCheck = factory.createOlapConnectionCheck(); + connectionCheck.setName("Connection Check " + CATALOG_NAME); + connectionCheck.setDescription("Connection check for writeback without dimension tutorial"); + connectionCheck.getCatalogChecks().add(catalogCheck); + + // Create suite containing the connection check + OlapCheckSuite suite = factory.createOlapCheckSuite(); + suite.setName("Writeback Without Dimension Suite"); + suite.setDescription("Check suite for the writeback without dimension tutorial"); + suite.getConnectionChecks().add(connectionCheck); + + return suite; + } + + /** + * Creates a MeasureCheck with the specified name. + * + * @param measureName the name of the measure + * @return the configured MeasureCheck + */ + private MeasureCheck createMeasureCheck(String measureName) { + MeasureCheck measureCheck = factory.createMeasureCheck(); + measureCheck.setName("MeasureCheck-" + measureName); + measureCheck.setDescription("Check that measure '" + measureName + "' exists"); + measureCheck.setMeasureName(measureName); + return measureCheck; + } + + /** + * Creates a DatabaseColumnCheck with the specified name and type. + * + * @param columnName the name of the column + * @param columnType the expected type of the column + * @return the configured DatabaseColumnCheck + */ + private DatabaseColumnCheck createColumnCheck(String columnName, String columnType) { + DatabaseColumnAttributeCheck columnTypeCheck = factory.createDatabaseColumnAttributeCheck(); + columnTypeCheck.setAttributeType(DatabaseColumnAttribute.TYPE); + columnTypeCheck.setExpectedValue(columnType); + + DatabaseColumnCheck columnCheck = factory.createDatabaseColumnCheck(); + columnCheck.setName("Database Column Check " + columnName); + columnCheck.setColumnName(columnName); + columnCheck.getColumnAttributeChecks().add(columnTypeCheck); + + return columnCheck; + } + + /** + * Creates a DatabaseTableCheck with the specified name and column checks. + * + * @param tableName the name of the table + * @param columnChecks the column checks to add to the table check + * @return the configured DatabaseTableCheck + */ + private DatabaseTableCheck createTableCheck(String tableName, DatabaseColumnCheck... columnChecks) { + DatabaseTableCheck tableCheck = factory.createDatabaseTableCheck(); + tableCheck.setName("Database Table Check " + tableName); + tableCheck.setTableName(tableName); + for (DatabaseColumnCheck columnCheck : columnChecks) { + tableCheck.getColumnChecks().add(columnCheck); + } + return tableCheck; + } +}