diff --git a/instance/emf/serializer/pom.xml b/instance/emf/serializer/pom.xml index 18ef2282..4d749b00 100644 --- a/instance/emf/serializer/pom.xml +++ b/instance/emf/serializer/pom.xml @@ -23,9 +23,9 @@ 6.2.0 - 2.30.0 - 2.36.0 - 2.37.0 + 2.44.0 + 2.41.0 + 2.39.0 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..633bc240 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 @@ -32,12 +32,20 @@ import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.concurrent.atomic.AtomicInteger; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; import org.eclipse.daanse.rolap.mapping.model.provider.CatalogMappingSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiPackage; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmPackage; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.util.EdmResourceFactoryImpl; +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.xmla.csdl.model.provider.OlapTSchemaSupplier; import org.eclipse.daanse.rolap.mapping.model.AbstractElement; import org.eclipse.daanse.rolap.mapping.model.Catalog; import org.eclipse.daanse.rolap.mapping.model.Documentation; @@ -52,6 +60,7 @@ import org.eclipse.emf.ecore.EStructuralFeature; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.emf.ecore.xmi.XMLResource; import org.gecko.emf.osgi.annotation.require.RequireEMF; @@ -112,20 +121,26 @@ public static void beforeAll() throws IOException { @Test @Order(1) public void writePopulation(@InjectBundleContext BundleContext bc, - @InjectService(cardinality = 1, filter = "(" + EMFNamespaces.EMF_MODEL_NAME + "=" - + RolapMappingPackage.eNAME + ")") ResourceSet resourceSet, - @InjectService ServiceAware mappingSuppiersSA) - throws SQLException, InterruptedException, IOException { + @InjectService(cardinality = 1, filter = "(" + EMFNamespaces.EMF_MODEL_NAME + "=" + + RolapMappingPackage.eNAME + ")") ResourceSet resourceSet, + @InjectService ServiceAware mappingSuppiersSA, + @InjectService ServiceAware checkSuiteSuppliersSA, + @InjectService ServiceAware tSchemaSupplierSA) + throws SQLException, InterruptedException, IOException { try { List> srs = mappingSuppiersSA.getServiceReferences(); + List> chrs = checkSuiteSuppliersSA.getServiceReferences(); + List tss = tSchemaSupplierSA.getServices(); StringBuilder parentReadme = new StringBuilder(); parentReadme.append(TEXT); // Create combined ZIP directory structure Path zipDir = Files.createDirectories(tempDir.resolve("cubeserver/tutorial/zip")); + Path checkZipDir = Files.createDirectories(tempDir.resolve("cubeserver/checkSuite/zip")); ZipOutputStream combinedZos = new ZipOutputStream(new FileOutputStream(zipDir.resolve("all-tutorials.zip").toFile())); + ZipOutputStream combinedCheckSuiteZos = new ZipOutputStream(new FileOutputStream(checkZipDir.resolve("all-check-suites.zip").toFile())); srs.sort((o1, o2) -> { Object s1 = o1.getProperty("number"); @@ -141,8 +156,20 @@ public void writePopulation(@InjectBundleContext BundleContext bc, CatalogMappingSupplier catalogMappingSupplier = mappingSuppiersSA.getService(sr); parentReadme.append("\n"); + String name = catalogMappingSupplier.getClass().getPackageName(); + Optional oOlapTSchemaSupplier = tss.stream().filter(s -> name.equals(s.getClass().getPackageName())).findFirst(); + serializeCatalog(resourceSet, parentReadme, catalogMappingSupplier, oOlapTSchemaSupplier, sr.getProperties(), combinedZos); + } catch (Exception e) { + e.printStackTrace(); + } + } + + for (ServiceReference chs : chrs) { + + try { + OlapCheckSuiteSupplier catalogMappingSupplier = checkSuiteSuppliersSA.getService(chs); - serializeCatalog(resourceSet, parentReadme, catalogMappingSupplier, sr.getProperties(), combinedZos); + serializeCheckSuite(resourceSet, catalogMappingSupplier, combinedCheckSuiteZos); } catch (Exception e) { e.printStackTrace(); } @@ -150,6 +177,7 @@ public void writePopulation(@InjectBundleContext BundleContext bc, // Close combined ZIP combinedZos.close(); + combinedCheckSuiteZos.close(); Path rootReadmeFile = Files.createFile(tempDir.resolve("index.md")); Files.writeString(rootReadmeFile, parentReadme); @@ -159,10 +187,65 @@ public void writePopulation(@InjectBundleContext BundleContext bc, } + @Test + public void test() throws IOException { + org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.calculatedmember.color.TSchemaSupplier supplier = new org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.calculatedmember.color.TSchemaSupplier(); + String csdl = serializeToXml(supplier.get()); + System.out.println(csdl); + } + 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 { + CatalogMappingSupplier catalogMappingSupplier, Optional oOlapTSchemaSupplier, Dictionary dictionary, ZipOutputStream combinedZos) throws IOException { String name = catalogMappingSupplier.getClass().getPackageName(); name = name.substring(46); @@ -256,6 +339,26 @@ private void serializeCatalog(ResourceSet resourceSet, StringBuilder parentReadm combinedZos.write(baos.toByteArray()); combinedZos.closeEntry(); + if (oOlapTSchemaSupplier.isPresent()) { + resourceSet.getPackageRegistry().put(EdmPackage.eNS_URI, EdmPackage.eINSTANCE); + resourceSet.getPackageRegistry().put(BiPackage.eNS_URI, BiPackage.eINSTANCE); + Resource resource = resourceSet.createResource(URI.createURI("csdl.xmi")); + resource.getContents().add(oOlapTSchemaSupplier.get().get()); + ByteArrayOutputStream baosCsdl = new ByteArrayOutputStream(); + resource.save(baosCsdl, options); + + ZipEntry tschemaEntry = new ZipEntry(name + "/csdl/csdl.xmi"); + zos.putNextEntry(tschemaEntry); + zos.write(baosCsdl.toByteArray()); + zos.closeEntry(); + + // Add to combined ZIP + ZipEntry tschemaCombinedEntry = new ZipEntry(name + "/csdl/csdl.xmi"); + combinedZos.putNextEntry(tschemaCombinedEntry); + combinedZos.write(baosCsdl.toByteArray()); + combinedZos.closeEntry(); + } + Files.createDirectories(zipDir); for (Documentation documentation : docs) { @@ -628,6 +731,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; @@ -647,4 +819,30 @@ public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOEx } }); } + + private String serializeToXml(EObject eObject) throws IOException { + ResourceSetImpl resourceSet = new ResourceSetImpl(); + + // Register the EDM resource factory that respects ExtendedMetaData + resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put("xml", new EdmResourceFactoryImpl()); + + // Register packages + resourceSet.getPackageRegistry().put(EdmPackage.eNS_URI, EdmPackage.eINSTANCE); + resourceSet.getPackageRegistry().put(BiPackage.eNS_URI, BiPackage.eINSTANCE); + Resource resource = resourceSet.createResource(URI.createURI("temp.xml")); + resource.getContents().add(eObject); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + Map options = new HashMap<>(); + options.put(XMLResource.OPTION_ENCODING, "UTF-8"); + options.put(XMLResource.OPTION_FORMATTED, Boolean.TRUE); + options.put(XMLResource.OPTION_SCHEMA_LOCATION, Boolean.TRUE); + + resource.save(baos, options); + + resource.getContents().clear(); + resourceSet.getResources().remove(resource); + + return baos.toString("UTF-8"); + } } diff --git a/instance/emf/serializer/test.bndrun b/instance/emf/serializer/test.bndrun index d590a36b..c5873a39 100644 --- a/instance/emf/serializer/test.bndrun +++ b/instance/emf/serializer/test.bndrun @@ -126,7 +126,7 @@ bnd.identity;id='org.eclipse.daanse.rolap.mapping.instance.emf.complex.expressivenames',\ bnd.identity;id='org.eclipse.daanse.rolap.mapping.instance.emf.complex.population.jena',\ bnd.identity;id='org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.level.unique',\ - bnd.identity;id='org.eclipse.daanse.rolap.mapping.instance.emf.complex.foodmart' + bnd.identity;id='org.eclipse.daanse.rolap.mapping.instance.emf.complex.foodmart',\ bnd.identity;id='org.eclipse.daanse.rolap.mapping.instance.emf.complex.steelwheels',\ bnd.identity;id='org.eclipse.daanse.rolap.mapping.instance.emf.complex.parcel' # -runbundles is calculated by the bnd-resolver-maven-plugin @@ -148,8 +148,10 @@ org.eclipse.daanse.olap.check.runtime;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.rolap.mapping.instance.emf.complex.expressivenames;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.rolap.mapping.instance.emf.complex.foodmart;version='[0.0.1,0.0.2)',\ + org.eclipse.daanse.rolap.mapping.instance.emf.complex.parcel;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.rolap.mapping.instance.emf.complex.population.jena;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.rolap.mapping.instance.emf.complex.school;version='[0.0.1,0.0.2)',\ + org.eclipse.daanse.rolap.mapping.instance.emf.complex.steelwheels;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.rolap.mapping.instance.emf.serializer;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.rolap.mapping.instance.emf.serializer-tests;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.access.cataloggrand;version='[0.0.1,0.0.2)',\ @@ -228,9 +230,15 @@ org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.writeback.withoutdimension;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.rolap.mapping.model;version='[0.0.1,0.0.2)',\ org.eclipse.daanse.sql.guard.api;version='[0.0.1,0.0.2)',\ - org.eclipse.emf.common;version='[2.30.0,2.30.1)',\ - org.eclipse.emf.ecore;version='[2.36.0,2.36.1)',\ - org.eclipse.emf.ecore.xmi;version='[2.37.0,2.37.1)',\ + org.eclipse.daanse.xmla.csdl.model.provider;version='[0.0.1,0.0.2)',\ + org.eclipse.daanse.xmla.csdl.model.v2.an;version='[0.0.1,0.0.2)',\ + org.eclipse.daanse.xmla.csdl.model.v2.bi;version='[0.0.1,0.0.2)',\ + org.eclipse.daanse.xmla.csdl.model.v2.cg;version='[0.0.1,0.0.2)',\ + org.eclipse.daanse.xmla.csdl.model.v2.edm;version='[0.0.1,0.0.2)',\ + org.eclipse.emf.common;version='[2.44.0,2.44.1)',\ + org.eclipse.emf.ecore;version='[2.41.0,2.41.1)',\ + org.eclipse.emf.ecore.xmi;version='[2.39.0,2.39.1)',\ + org.eclipse.fennec.emf.osgi.api;version='[1.0.0,1.0.1)',\ org.gecko.emf.osgi.component;version='[6.2.0,6.2.1)',\ org.opentest4j;version='[1.3.0,1.3.1)',\ org.osgi.service.cm;version='[1.6.1,1.6.2)',\ diff --git a/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/TSchemaSupplier.java b/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/TSchemaSupplier.java new file mode 100644 index 00000000..83df8e9d --- /dev/null +++ b/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/TSchemaSupplier.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.color; + +import org.eclipse.daanse.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Cube Calculated Member Color"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("Cube CalculatedMember with different colors"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTheHierarchy = edmFactory.createEntitySetType(); + entitySetTheHierarchy.setName("theHierarchy"); + entitySetTheHierarchy.setEntityType("Model.theHierarchy"); + + TEntitySet biEntitySetTheHierarchy = biFactory.createTEntitySet(); + biEntitySetTheHierarchy.setCaption("theHierarchy"); + + entitySetTheHierarchy.setBiEntitySet(biEntitySetTheHierarchy); + + container.getEntitySet().add(entitySetTheHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("Measure-Sum"); + entitySet1.setEntityType("Model.Measure-Sum"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("Measure-Sum"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + EntitySetType entitySet2 = edmFactory.createEntitySetType(); + entitySet2.setName("Measure-Count"); + entitySet2.setEntityType("Model.Measure-Count"); + + TEntitySet biEntitySet2 = biFactory.createTEntitySet(); + biEntitySet2.setCaption("Measure-Count"); + entitySet2.setBiEntitySet(biEntitySet2); + + container.getEntitySet().add(entitySet2); + + EntitySetType entitySet3 = edmFactory.createEntitySetType(); + entitySet3.setName("Calculated_Member1"); + entitySet3.setEntityType("Model.Calculated_Member1"); + + TEntitySet biEntitySet3 = biFactory.createTEntitySet(); + biEntitySet3.setCaption("Calculated Member 1"); + entitySet3.setBiEntitySet(biEntitySet3); + + container.getEntitySet().add(entitySet3); + + EntitySetType entitySet4 = edmFactory.createEntitySetType(); + entitySet4.setName("Calculated_Member2"); + entitySet4.setEntityType("Model.Calculated_Member2"); + + TEntitySet biEntitySet4 = biFactory.createTEntitySet(); + biEntitySet4.setCaption("Calculated Member 2"); + entitySet4.setBiEntitySet(biEntitySet4); + + container.getEntitySet().add(entitySet4); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theHierarchyType = edmFactory.createTEntityType(); + theHierarchyType.setName("theHierarchy"); + + TLevel tLevel = biFactory.createTLevel(); + tLevel.setName("theLevel"); + tLevel.setCaption("theLevel"); + tLevel.setReferenceName("[theDimension].[theHierarchy].[theLevel]"); + + THierarchy theHierarchyTHierarchy = biFactory.createTHierarchy(); + theHierarchyTHierarchy.setCaption("theHierarchy"); + theHierarchyTHierarchy.setName("theHierarchy"); + theHierarchyTHierarchy.setReferenceName("[theDimension].[theHierarchy]"); + theHierarchyTHierarchy.getLevel().add(tLevel); + + TEntityType theHierarchyTEntityType = biFactory.createTEntityType(); + theHierarchyTEntityType.setContents("theHierarchy"); + theHierarchyTEntityType.getHierarchy().add(theHierarchyTHierarchy); + + theHierarchyType.setBiEntityType(theHierarchyTEntityType); + + TEntityProperty theHierarchyProperty = edmFactory.createTEntityProperty(); + theHierarchyProperty.setName("theHierarchy"); + theHierarchyProperty.setType("String"); + theHierarchyProperty.setNullable(false); + + theHierarchyType.getProperty().add(theHierarchyProperty); + + schema.getEntityType().add(theHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureSumType = edmFactory.createTEntityType(); + measureSumType.setName("Measure-Sum"); + + TEntityType biMeasureSumType = biFactory.createTEntityType(); + biMeasureSumType.setContents("Measure-Sum"); + measureSumType.setBiEntityType(biMeasureSumType); + + TEntityProperty measureSumProperty = edmFactory.createTEntityProperty(); + measureSumProperty.setName("Measure-Sum"); + measureSumProperty.setType("Int32"); + measureSumProperty.setNullable(false); + + TMeasure biMeasureSumMeasure = biFactory.createTMeasure(); + biMeasureSumMeasure.setCaption("Measure-Sum"); + biMeasureSumMeasure.setHidden(false); + biMeasureSumMeasure.setReferenceName("[measures].[Measure-Sum]"); + measureSumProperty.setBiMeasure(biMeasureSumMeasure); + + measureSumType.getProperty().add(measureSumProperty); + + schema.getEntityType().add(measureSumType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureCountType = edmFactory.createTEntityType(); + measureCountType.setName("Measure-Count"); + + TEntityType biMeasureCountType = biFactory.createTEntityType(); + biMeasureCountType.setContents("Measure-Count"); + measureCountType.setBiEntityType(biMeasureSumType); + + TEntityProperty measureCountProperty = edmFactory.createTEntityProperty(); + measureCountProperty.setName("Measure-Count"); + measureCountProperty.setType("Int32"); + measureCountProperty.setNullable(false); + + TMeasure biMeasureCountMeasure = biFactory.createTMeasure(); + biMeasureCountMeasure.setCaption("Measure-Count"); + biMeasureCountMeasure.setHidden(false); + biMeasureCountMeasure.setReferenceName("[measures].[Measure-Count]"); + + measureCountProperty.setBiMeasure(biMeasureCountMeasure); + + measureCountType.getProperty().add(measureCountProperty); + + schema.getEntityType().add(measureCountType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType calculatedMember1Type = edmFactory.createTEntityType(); + calculatedMember1Type.setName("Calculated_Member1"); + + TEntityType biCalculatedMember1Type = biFactory.createTEntityType(); + biCalculatedMember1Type.setContents("Calculated_Member1"); + calculatedMember1Type.setBiEntityType(biCalculatedMember1Type); + + TEntityProperty calculatedMember1Property = edmFactory.createTEntityProperty(); + calculatedMember1Property.setName("Calculated_Member1"); + calculatedMember1Property.setType("Int32"); + calculatedMember1Property.setNullable(false); + + TMeasure biMeasureCalculatedMember1 = biFactory.createTMeasure(); + biMeasureCalculatedMember1.setCaption("Calculated Member 1"); + biMeasureCalculatedMember1.setHidden(false); + biMeasureCalculatedMember1.setReferenceName("[measures].[Calculated Member 1]"); + + calculatedMember1Property.setBiMeasure(biMeasureCalculatedMember1); + + calculatedMember1Type.getProperty().add(calculatedMember1Property); + + schema.getEntityType().add(calculatedMember1Type); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType calculatedMember2Type = edmFactory.createTEntityType(); + calculatedMember2Type.setName("Calculated_Member2"); + + TEntityType biCalculatedMember2Type = biFactory.createTEntityType(); + biCalculatedMember2Type.setContents("Calculated_Member2"); + calculatedMember1Type.setBiEntityType(biCalculatedMember1Type); + + TEntityProperty calculatedMember2Property = edmFactory.createTEntityProperty(); + calculatedMember2Property.setName("Calculated_Member2"); + calculatedMember2Property.setType("Int32"); + calculatedMember2Property.setNullable(false); + + TMeasure biMeasureCalculatedMember2 = biFactory.createTMeasure(); + biMeasureCalculatedMember2.setCaption("Calculated Member 2"); + biMeasureCalculatedMember2.setHidden(false); + biMeasureCalculatedMember2.setReferenceName("[measures].[Calculated Member 2]"); + + calculatedMember2Property.setBiMeasure(biMeasureCalculatedMember2); + + calculatedMember2Type.getProperty().add(calculatedMember2Property); + + schema.getEntityType().add(calculatedMember2Type); + + return schema; + } + +} diff --git a/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/package-info.java b/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/package-info.java new file mode 100644 index 00000000..f7c3da60 --- /dev/null +++ b/instance/emf/tutorial/cube/calculatedmember.color/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/color/package-info.java @@ -0,0 +1,15 @@ +/* + * 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: + * + */ +@org.osgi.annotation.bundle.Export +@org.osgi.annotation.versioning.Version("0.0.1") +package org.eclipse.daanse.rolap.mapping.instance.emf.tutorial.cube.calculatedmember.color; diff --git a/instance/emf/tutorial/cube/calculatedmember.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/intro/TSchemaSupplier.java b/instance/emf/tutorial/cube/calculatedmember.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/intro/TSchemaSupplier.java new file mode 100644 index 00000000..fcac49ce --- /dev/null +++ b/instance/emf/tutorial/cube/calculatedmember.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/intro/TSchemaSupplier.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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Calculated Member Intro"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("Cube CalculatedMember"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTheHierarchy = edmFactory.createEntitySetType(); + entitySetTheHierarchy.setName("theHierarchy"); + entitySetTheHierarchy.setEntityType("Model.theHierarchy"); + + TEntitySet biEntitySetTheHierarchy = biFactory.createTEntitySet(); + biEntitySetTheHierarchy.setCaption("theHierarchy"); + + entitySetTheHierarchy.setBiEntitySet(biEntitySetTheHierarchy); + + container.getEntitySet().add(entitySetTheHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("Measure1-Sum"); + entitySet1.setEntityType("Model.Measure1-Sum"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("Measure1-Sum"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + EntitySetType entitySet2 = edmFactory.createEntitySetType(); + entitySet2.setName("Measure2-Count"); + entitySet2.setEntityType("Model.Measure2-Count"); + + TEntitySet biEntitySet2 = biFactory.createTEntitySet(); + biEntitySet2.setCaption("Measure2-Count"); + entitySet2.setBiEntitySet(biEntitySet2); + + container.getEntitySet().add(entitySet2); + + EntitySetType entitySet3 = edmFactory.createEntitySetType(); + entitySet3.setName("Calculated_Member1"); + entitySet3.setEntityType("Model.Calculated_Member1"); + + TEntitySet biEntitySet3 = biFactory.createTEntitySet(); + biEntitySet3.setCaption("Calculated Member 1"); + entitySet3.setBiEntitySet(biEntitySet3); + + container.getEntitySet().add(entitySet3); + + EntitySetType entitySet4 = edmFactory.createEntitySetType(); + entitySet4.setName("Calculated_Member2"); + entitySet4.setEntityType("Model.Calculated_Member2"); + + TEntitySet biEntitySet4 = biFactory.createTEntitySet(); + biEntitySet4.setCaption("Calculated Member 2"); + entitySet4.setBiEntitySet(biEntitySet4); + + container.getEntitySet().add(entitySet4); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theHierarchyType = edmFactory.createTEntityType(); + theHierarchyType.setName("theHierarchy"); + + TLevel tLevel = biFactory.createTLevel(); + tLevel.setName("theLevel"); + tLevel.setCaption("theLevel"); + tLevel.setReferenceName("[theDimension].[theHierarchy].[theLevel]"); + + THierarchy theHierarchyTHierarchy = biFactory.createTHierarchy(); + theHierarchyTHierarchy.setCaption("theHierarchy"); + theHierarchyTHierarchy.setName("theHierarchy"); + theHierarchyTHierarchy.setReferenceName("[theDimension].[theHierarchy]"); + theHierarchyTHierarchy.getLevel().add(tLevel); + + TEntityType theHierarchyTEntityType = biFactory.createTEntityType(); + theHierarchyTEntityType.setContents("theHierarchy"); + theHierarchyTEntityType.getHierarchy().add(theHierarchyTHierarchy); + + theHierarchyType.setBiEntityType(theHierarchyTEntityType); + + TEntityProperty theHierarchyProperty = edmFactory.createTEntityProperty(); + theHierarchyProperty.setName("theHierarchy"); + theHierarchyProperty.setType("String"); + theHierarchyProperty.setNullable(false); + + theHierarchyType.getProperty().add(theHierarchyProperty); + + schema.getEntityType().add(theHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureSumType = edmFactory.createTEntityType(); + measureSumType.setName("Measure1-Sum"); + + TEntityType biMeasureSumType = biFactory.createTEntityType(); + biMeasureSumType.setContents("Measure1-Sum"); + measureSumType.setBiEntityType(biMeasureSumType); + + TEntityProperty measureSumProperty = edmFactory.createTEntityProperty(); + measureSumProperty.setName("Measure1-Sum"); + measureSumProperty.setType("Int32"); + measureSumProperty.setNullable(false); + + TMeasure biMeasureSumMeasure = biFactory.createTMeasure(); + biMeasureSumMeasure.setCaption("Measure1-Sum"); + biMeasureSumMeasure.setHidden(false); + biMeasureSumMeasure.setReferenceName("[measures].[Measure1-Sum]"); + measureSumProperty.setBiMeasure(biMeasureSumMeasure); + + measureSumType.getProperty().add(measureSumProperty); + + schema.getEntityType().add(measureSumType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureCountType = edmFactory.createTEntityType(); + measureCountType.setName("Measure2-Count"); + + TEntityType biMeasureCountType = biFactory.createTEntityType(); + biMeasureCountType.setContents("Measure2-Count"); + measureCountType.setBiEntityType(biMeasureSumType); + + TEntityProperty measureCountProperty = edmFactory.createTEntityProperty(); + measureCountProperty.setName("Measure2-Count"); + measureCountProperty.setType("Int32"); + measureCountProperty.setNullable(false); + + TMeasure biMeasureCountMeasure = biFactory.createTMeasure(); + biMeasureCountMeasure.setCaption("Measure2-Count"); + biMeasureCountMeasure.setHidden(false); + biMeasureCountMeasure.setReferenceName("[measures].[Measure2-Count]"); + + measureCountProperty.setBiMeasure(biMeasureCountMeasure); + + measureCountType.getProperty().add(measureCountProperty); + + schema.getEntityType().add(measureCountType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType calculatedMember1Type = edmFactory.createTEntityType(); + calculatedMember1Type.setName("Calculated_Member1"); + + TEntityType biCalculatedMember1Type = biFactory.createTEntityType(); + biCalculatedMember1Type.setContents("Calculated_Member1"); + calculatedMember1Type.setBiEntityType(biCalculatedMember1Type); + + TEntityProperty calculatedMember1Property = edmFactory.createTEntityProperty(); + calculatedMember1Property.setName("Calculated_Member1"); + calculatedMember1Property.setType("Int32"); + calculatedMember1Property.setNullable(false); + + TMeasure biMeasureCalculatedMember1 = biFactory.createTMeasure(); + biMeasureCalculatedMember1.setCaption("Calculated Member 1"); + biMeasureCalculatedMember1.setHidden(false); + biMeasureCalculatedMember1.setReferenceName("[measures].[Calculated Member 1]"); + + calculatedMember1Property.setBiMeasure(biMeasureCalculatedMember1); + + calculatedMember1Type.getProperty().add(calculatedMember1Property); + + schema.getEntityType().add(calculatedMember1Type); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType calculatedMember2Type = edmFactory.createTEntityType(); + calculatedMember2Type.setName("Calculated_Member2"); + + TEntityType biCalculatedMember2Type = biFactory.createTEntityType(); + biCalculatedMember2Type.setContents("Calculated_Member2"); + calculatedMember1Type.setBiEntityType(biCalculatedMember1Type); + + TEntityProperty calculatedMember2Property = edmFactory.createTEntityProperty(); + calculatedMember2Property.setName("Calculated_Member2"); + calculatedMember2Property.setType("Int32"); + calculatedMember2Property.setNullable(false); + + TMeasure biMeasureCalculatedMember2 = biFactory.createTMeasure(); + biMeasureCalculatedMember2.setCaption("Calculated Member 2"); + biMeasureCalculatedMember2.setHidden(false); + biMeasureCalculatedMember2.setReferenceName("[measures].[Calculated Member 2]"); + + calculatedMember2Property.setBiMeasure(biMeasureCalculatedMember2); + + calculatedMember2Type.getProperty().add(calculatedMember2Property); + + schema.getEntityType().add(calculatedMember2Type); + + return schema; + } + +} diff --git a/instance/emf/tutorial/cube/calculatedmember.property/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/property/TSchemaSupplier.java b/instance/emf/tutorial/cube/calculatedmember.property/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/property/TSchemaSupplier.java new file mode 100644 index 00000000..1ab6a735 --- /dev/null +++ b/instance/emf/tutorial/cube/calculatedmember.property/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/calculatedmember/property/TSchemaSupplier.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.property; + +import org.eclipse.daanse.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Cube Calculated Member Property"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("Cube CalculatedMember with properties"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTheHierarchy = edmFactory.createEntitySetType(); + entitySetTheHierarchy.setName("theHierarchy"); + entitySetTheHierarchy.setEntityType("Model.theHierarchy"); + + TEntitySet biEntitySetTheHierarchy = biFactory.createTEntitySet(); + biEntitySetTheHierarchy.setCaption("theHierarchy"); + + entitySetTheHierarchy.setBiEntitySet(biEntitySetTheHierarchy); + + container.getEntitySet().add(entitySetTheHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("Measure1-Sum"); + entitySet1.setEntityType("Model.Measure1-Sum"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("Measure1-Sum"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + EntitySetType entitySet2 = edmFactory.createEntitySetType(); + entitySet2.setName("Measure2-Count"); + entitySet2.setEntityType("Model.Measure2-Count"); + + TEntitySet biEntitySet2 = biFactory.createTEntitySet(); + biEntitySet2.setCaption("Measure2-Count"); + entitySet2.setBiEntitySet(biEntitySet2); + + container.getEntitySet().add(entitySet2); + + EntitySetType entitySet3 = edmFactory.createEntitySetType(); + entitySet3.setName("Calculated_Member1"); + entitySet3.setEntityType("Model.Calculated_Member1"); + + TEntitySet biEntitySet3 = biFactory.createTEntitySet(); + biEntitySet3.setCaption("Calculated Member 1"); + entitySet3.setBiEntitySet(biEntitySet3); + + container.getEntitySet().add(entitySet3); + + EntitySetType entitySet4 = edmFactory.createEntitySetType(); + entitySet4.setName("Calculated_Member2"); + entitySet4.setEntityType("Model.Calculated_Member2"); + + TEntitySet biEntitySet4 = biFactory.createTEntitySet(); + biEntitySet4.setCaption("Calculated Member 2"); + entitySet4.setBiEntitySet(biEntitySet4); + + container.getEntitySet().add(entitySet4); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theHierarchyType = edmFactory.createTEntityType(); + theHierarchyType.setName("theHierarchy"); + + TLevel tLevel = biFactory.createTLevel(); + tLevel.setName("theLevel"); + tLevel.setCaption("theLevel"); + tLevel.setReferenceName("[theDimension].[theHierarchy].[theLevel]"); + + THierarchy theHierarchyTHierarchy = biFactory.createTHierarchy(); + theHierarchyTHierarchy.setCaption("theHierarchy"); + theHierarchyTHierarchy.setName("theHierarchy"); + theHierarchyTHierarchy.setReferenceName("[theDimension].[theHierarchy]"); + theHierarchyTHierarchy.getLevel().add(tLevel); + + TEntityType theHierarchyTEntityType = biFactory.createTEntityType(); + theHierarchyTEntityType.setContents("theHierarchy"); + theHierarchyTEntityType.getHierarchy().add(theHierarchyTHierarchy); + + theHierarchyType.setBiEntityType(theHierarchyTEntityType); + + TEntityProperty theHierarchyProperty = edmFactory.createTEntityProperty(); + theHierarchyProperty.setName("theHierarchy"); + theHierarchyProperty.setType("String"); + theHierarchyProperty.setNullable(false); + + theHierarchyType.getProperty().add(theHierarchyProperty); + + schema.getEntityType().add(theHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureSumType = edmFactory.createTEntityType(); + measureSumType.setName("Measure1-Sum"); + + TEntityType biMeasureSumType = biFactory.createTEntityType(); + biMeasureSumType.setContents("Measure1-Sum"); + measureSumType.setBiEntityType(biMeasureSumType); + + TEntityProperty measureSumProperty = edmFactory.createTEntityProperty(); + measureSumProperty.setName("Measure1-Sum"); + measureSumProperty.setType("Int32"); + measureSumProperty.setNullable(false); + + TMeasure biMeasureSumMeasure = biFactory.createTMeasure(); + biMeasureSumMeasure.setCaption("Measure1-Sum"); + biMeasureSumMeasure.setHidden(false); + biMeasureSumMeasure.setReferenceName("[measures].[Measure1-Sum]"); + measureSumProperty.setBiMeasure(biMeasureSumMeasure); + + measureSumType.getProperty().add(measureSumProperty); + + schema.getEntityType().add(measureSumType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureCountType = edmFactory.createTEntityType(); + measureCountType.setName("Measure2-Count"); + + TEntityType biMeasureCountType = biFactory.createTEntityType(); + biMeasureCountType.setContents("Measure2-Count"); + measureCountType.setBiEntityType(biMeasureSumType); + + TEntityProperty measureCountProperty = edmFactory.createTEntityProperty(); + measureCountProperty.setName("Measure2-Count"); + measureCountProperty.setType("Int32"); + measureCountProperty.setNullable(false); + + TMeasure biMeasureCountMeasure = biFactory.createTMeasure(); + biMeasureCountMeasure.setCaption("Measure2-Count"); + biMeasureCountMeasure.setHidden(false); + biMeasureCountMeasure.setReferenceName("[measures].[Measure2-Count]"); + + measureCountProperty.setBiMeasure(biMeasureCountMeasure); + + measureCountType.getProperty().add(measureCountProperty); + + schema.getEntityType().add(measureCountType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType calculatedMember1Type = edmFactory.createTEntityType(); + calculatedMember1Type.setName("Calculated_Member1"); + + TEntityType biCalculatedMember1Type = biFactory.createTEntityType(); + biCalculatedMember1Type.setContents("Calculated_Member1"); + calculatedMember1Type.setBiEntityType(biCalculatedMember1Type); + + TEntityProperty calculatedMember1Property = edmFactory.createTEntityProperty(); + calculatedMember1Property.setName("Calculated_Member1"); + calculatedMember1Property.setType("Int32"); + calculatedMember1Property.setNullable(false); + + TMeasure biMeasureCalculatedMember1 = biFactory.createTMeasure(); + biMeasureCalculatedMember1.setCaption("Calculated Member 1"); + biMeasureCalculatedMember1.setHidden(false); + biMeasureCalculatedMember1.setReferenceName("[measures].[Calculated Member 1]"); + + calculatedMember1Property.setBiMeasure(biMeasureCalculatedMember1); + + calculatedMember1Type.getProperty().add(calculatedMember1Property); + + schema.getEntityType().add(calculatedMember1Type); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType calculatedMember2Type = edmFactory.createTEntityType(); + calculatedMember2Type.setName("Calculated_Member2"); + + TEntityType biCalculatedMember2Type = biFactory.createTEntityType(); + biCalculatedMember2Type.setContents("Calculated_Member2"); + calculatedMember1Type.setBiEntityType(biCalculatedMember1Type); + + TEntityProperty calculatedMember2Property = edmFactory.createTEntityProperty(); + calculatedMember2Property.setName("Calculated_Member2"); + calculatedMember2Property.setType("Int32"); + calculatedMember2Property.setNullable(false); + + TMeasure biMeasureCalculatedMember2 = biFactory.createTMeasure(); + biMeasureCalculatedMember2.setCaption("Calculated Member 2"); + biMeasureCalculatedMember2.setHidden(false); + biMeasureCalculatedMember2.setReferenceName("[measures].[Calculated Member 2]"); + + calculatedMember2Property.setBiMeasure(biMeasureCalculatedMember2); + + calculatedMember2Type.getProperty().add(calculatedMember2Property); + + schema.getEntityType().add(calculatedMember2Type); + + return schema; + } + +} diff --git a/instance/emf/tutorial/cube/dimension.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/dimension/intro/TSchemaSupplier.java b/instance/emf/tutorial/cube/dimension.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/dimension/intro/TSchemaSupplier.java new file mode 100644 index 00000000..5802a331 --- /dev/null +++ b/instance/emf/tutorial/cube/dimension.intro/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/dimension/intro/TSchemaSupplier.java @@ -0,0 +1,126 @@ +/* + * 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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Dimension Intro"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("CubeWithSimpleDimension"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTheHierarchy = edmFactory.createEntitySetType(); + entitySetTheHierarchy.setName("theHierarchy"); + entitySetTheHierarchy.setEntityType("Model.theHierarchy"); + + TEntitySet biEntitySetTheHierarchy = biFactory.createTEntitySet(); + biEntitySetTheHierarchy.setCaption("theHierarchy"); + + entitySetTheHierarchy.setBiEntitySet(biEntitySetTheHierarchy); + + container.getEntitySet().add(entitySetTheHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("theMeasure"); + entitySet1.setEntityType("Model.theMeasure"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("theMeasure"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theHierarchyType = edmFactory.createTEntityType(); + theHierarchyType.setName("theHierarchy"); + + TLevel tLevel = biFactory.createTLevel(); + tLevel.setName("theLevel"); + tLevel.setCaption("theLevel"); + tLevel.setReferenceName("[theDimension].[theHierarchy].[theLevel]"); + + THierarchy theHierarchyTHierarchy = biFactory.createTHierarchy(); + theHierarchyTHierarchy.setCaption("theHierarchy"); + theHierarchyTHierarchy.setName("theHierarchy"); + theHierarchyTHierarchy.setReferenceName("[theDimension].[theHierarchy]"); + theHierarchyTHierarchy.getLevel().add(tLevel); + + TEntityType theHierarchyTEntityType = biFactory.createTEntityType(); + theHierarchyTEntityType.setContents("theHierarchy"); + theHierarchyTEntityType.getHierarchy().add(theHierarchyTHierarchy); + + theHierarchyType.setBiEntityType(theHierarchyTEntityType); + + TEntityProperty theHierarchyProperty = edmFactory.createTEntityProperty(); + theHierarchyProperty.setName("theHierarchy"); + theHierarchyProperty.setType("String"); + theHierarchyProperty.setNullable(false); + + theHierarchyType.getProperty().add(theHierarchyProperty); + + schema.getEntityType().add(theHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theMeasureType = edmFactory.createTEntityType(); + theMeasureType.setName("theMeasure"); + + TEntityType biTheMeasureType = biFactory.createTEntityType(); + biTheMeasureType.setContents("theMeasure"); + theMeasureType.setBiEntityType(biTheMeasureType); + + TEntityProperty theMeasureProperty = edmFactory.createTEntityProperty(); + theMeasureProperty.setName("theMeasure"); + theMeasureProperty.setType("Int32"); + theMeasureProperty.setNullable(false); + + TMeasure biTheMeasureMeasure = biFactory.createTMeasure(); + biTheMeasureMeasure.setCaption("theMeasure"); + biTheMeasureMeasure.setHidden(false); + biTheMeasureMeasure.setReferenceName("[measures].[theMeasure]"); + theMeasureProperty.setBiMeasure(biTheMeasureMeasure); + + theMeasureType.getProperty().add(theMeasureProperty); + + schema.getEntityType().add(theMeasureType); + + return schema; + } + +} diff --git a/instance/emf/tutorial/cube/hierarchy.hasall/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/hasall/TSchemaSupplier.java b/instance/emf/tutorial/cube/hierarchy.hasall/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/hasall/TSchemaSupplier.java new file mode 100644 index 00000000..80db06f5 --- /dev/null +++ b/instance/emf/tutorial/cube/hierarchy.hasall/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/hierarchy/hasall/TSchemaSupplier.java @@ -0,0 +1,206 @@ +/* + * 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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Hierarchy Has All"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("HasAll Cube"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetHierarchyWithHasAll = edmFactory.createEntitySetType(); + entitySetHierarchyWithHasAll.setName("HierarchyWithHasAll"); + entitySetHierarchyWithHasAll.setEntityType("Model.HierarchyWithHasAll"); + + TEntitySet biEntitySetHierarchyWithHasAll = biFactory.createTEntitySet(); + biEntitySetHierarchyWithHasAll.setCaption("HierarchyWithHasAll"); + + entitySetHierarchyWithHasAll.setBiEntitySet(biEntitySetHierarchyWithHasAll); + + container.getEntitySet().add(entitySetHierarchyWithHasAll); + + EntitySetType entitySetHierarchyWithHasAllAndNames = edmFactory.createEntitySetType(); + entitySetHierarchyWithHasAllAndNames.setName("HierarchyWithHasAllAndNames"); + entitySetHierarchyWithHasAllAndNames.setEntityType("Model.HierarchyWithHasAllAndNames"); + + TEntitySet biEntitySetHierarchyWithHasAllAndNames = biFactory.createTEntitySet(); + biEntitySetHierarchyWithHasAllAndNames.setCaption("HierarchyWithHasAllAndNames"); + + entitySetHierarchyWithHasAllAndNames.setBiEntitySet(biEntitySetHierarchyWithHasAllAndNames); + + container.getEntitySet().add(entitySetHierarchyWithHasAllAndNames); + + EntitySetType entitySetHierarchyWithoutHasAll = edmFactory.createEntitySetType(); + entitySetHierarchyWithoutHasAll.setName("HierarchyWithoutHasAll"); + entitySetHierarchyWithoutHasAll.setEntityType("Model.HierarchyWithoutHasAll"); + + TEntitySet biEntitySetHierarchyWithoutHasAll = biFactory.createTEntitySet(); + biEntitySetHierarchyWithoutHasAll.setCaption("HierarchyWithoutHasAll"); + + entitySetHierarchyWithoutHasAll.setBiEntitySet(biEntitySetHierarchyWithoutHasAll); + + container.getEntitySet().add(entitySetHierarchyWithoutHasAll); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("theMeasure"); + entitySet1.setEntityType("Model.theMeasure"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("theMeasure"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType hierarchyWithHasAllType = edmFactory.createTEntityType(); + hierarchyWithHasAllType.setName("HierarchyWithHasAll"); + + TLevel tLevel = biFactory.createTLevel(); + tLevel.setName("theLevel"); + tLevel.setCaption("theLevel"); + tLevel.setReferenceName("[Dimension1].[Hierarchy - with HasAll].[theLevel]"); + + THierarchy hierarchyWithHasAllTHierarchy = biFactory.createTHierarchy(); + hierarchyWithHasAllTHierarchy.setCaption("Hierarchy - with HasAll"); + hierarchyWithHasAllTHierarchy.setName("HierarchyWithHasAll"); + hierarchyWithHasAllTHierarchy.setReferenceName("[Dimension1].[Hierarchy - with HasAll]"); + hierarchyWithHasAllTHierarchy.getLevel().add(tLevel); + + TEntityType hierarchyWithHasAllTEntityType = biFactory.createTEntityType(); + hierarchyWithHasAllTEntityType.setContents("HierarchyWithHasAll"); + hierarchyWithHasAllTEntityType.getHierarchy().add(hierarchyWithHasAllTHierarchy); + + hierarchyWithHasAllType.setBiEntityType(hierarchyWithHasAllTEntityType); + + TEntityProperty hierarchyWithHasAllProperty = edmFactory.createTEntityProperty(); + hierarchyWithHasAllProperty.setName("HierarchyWithHasAll"); + hierarchyWithHasAllProperty.setType("String"); + hierarchyWithHasAllProperty.setNullable(false); + + hierarchyWithHasAllType.getProperty().add(hierarchyWithHasAllProperty); + + schema.getEntityType().add(hierarchyWithHasAllType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType hierarchyWithHasAllAndNamesType = edmFactory.createTEntityType(); + hierarchyWithHasAllAndNamesType.setName("HierarchyWithHasAll"); + + TLevel tLevel1 = biFactory.createTLevel(); + tLevel1.setName("theLevelAndName"); + tLevel1.setCaption("theLevelAndName"); + tLevel1.setReferenceName("[Dimension1].[Hierarchy - with HasAll and Names].[theLevel]"); + + THierarchy hierarchyWithHasAllAndNamesTHierarchy = biFactory.createTHierarchy(); + hierarchyWithHasAllAndNamesTHierarchy.setCaption("Hierarchy - with HasAll and Names"); + hierarchyWithHasAllAndNamesTHierarchy.setName("HierarchyWithHasAllAndNames"); + hierarchyWithHasAllAndNamesTHierarchy.setReferenceName("[Dimension1].[Hierarchy - with HasAll and Names]"); + hierarchyWithHasAllAndNamesTHierarchy.getLevel().add(tLevel1); + + TEntityType hierarchyWithHasAllAndNamesTEntityType = biFactory.createTEntityType(); + hierarchyWithHasAllAndNamesTEntityType.setContents("HierarchyWithHasAllAndNames"); + hierarchyWithHasAllAndNamesTEntityType.getHierarchy().add(hierarchyWithHasAllAndNamesTHierarchy); + + hierarchyWithHasAllAndNamesType.setBiEntityType(hierarchyWithHasAllAndNamesTEntityType); + + TEntityProperty hierarchyWithHasAllAndNamesProperty = edmFactory.createTEntityProperty(); + hierarchyWithHasAllAndNamesProperty.setName("HierarchyWithHasAllAndNames"); + hierarchyWithHasAllAndNamesProperty.setType("String"); + hierarchyWithHasAllAndNamesProperty.setNullable(false); + + hierarchyWithHasAllAndNamesType.getProperty().add(hierarchyWithHasAllAndNamesProperty); + + schema.getEntityType().add(hierarchyWithHasAllAndNamesType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType hierarchyWithoutHasAllType = edmFactory.createTEntityType(); + hierarchyWithHasAllType.setName("HierarchyWithoutHasAll"); + + TLevel tLevel2 = biFactory.createTLevel(); + tLevel2.setName("theLevelWithoutHasAll"); + tLevel2.setCaption("theLevel"); + tLevel2.setReferenceName("[Dimension1].[Hierarchy - Without HasAll].[theLevel]"); + + THierarchy hierarchyWithoutHasAllTHierarchy = biFactory.createTHierarchy(); + hierarchyWithoutHasAllTHierarchy.setCaption("Hierarchy - Without HasAll"); + hierarchyWithoutHasAllTHierarchy.setName("HierarchyWithoutHasAll"); + hierarchyWithoutHasAllTHierarchy.setReferenceName("[Dimension1].[Hierarchy - Without HasAll]"); + hierarchyWithoutHasAllTHierarchy.getLevel().add(tLevel); + + TEntityType hierarchyWithoutHasAllTEntityType = biFactory.createTEntityType(); + hierarchyWithoutHasAllTEntityType.setContents("HierarchyWithHasAll"); + hierarchyWithoutHasAllTEntityType.getHierarchy().add(hierarchyWithoutHasAllTHierarchy); + + hierarchyWithoutHasAllType.setBiEntityType(hierarchyWithoutHasAllTEntityType); + + TEntityProperty hierarchyWithoutHasAllProperty = edmFactory.createTEntityProperty(); + hierarchyWithoutHasAllProperty.setName("HierarchyWithoutHasAll"); + hierarchyWithoutHasAllProperty.setType("String"); + hierarchyWithoutHasAllProperty.setNullable(false); + + hierarchyWithoutHasAllType.getProperty().add(hierarchyWithHasAllProperty); + + schema.getEntityType().add(hierarchyWithoutHasAllType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theMeasureType = edmFactory.createTEntityType(); + theMeasureType.setName("theMeasure"); + + TEntityType biTheMeasureType = biFactory.createTEntityType(); + biTheMeasureType.setContents("theMeasure"); + theMeasureType.setBiEntityType(biTheMeasureType); + + TEntityProperty theMeasureProperty = edmFactory.createTEntityProperty(); + theMeasureProperty.setName("theMeasure"); + theMeasureProperty.setType("Int32"); + theMeasureProperty.setNullable(false); + + TMeasure biTheMeasureMeasure = biFactory.createTMeasure(); + biTheMeasureMeasure.setCaption("theMeasure"); + biTheMeasureMeasure.setHidden(false); + biTheMeasureMeasure.setReferenceName("[measures].[theMeasure]"); + theMeasureProperty.setBiMeasure(biTheMeasureMeasure); + + theMeasureType.getProperty().add(theMeasureProperty); + + schema.getEntityType().add(theMeasureType); + + return schema; + } + +} 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/TSchemaSupplier.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/TSchemaSupplier.java new file mode 100644 index 00000000..3b2c5cf4 --- /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/TSchemaSupplier.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.cube.hierarchy.query.join.base; + +import org.eclipse.daanse.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityKeyElement; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TPropertyRef; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Hierarchy Query Join Base"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("Cube Query linked Tables"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTownHierarchy = edmFactory.createEntitySetType(); + entitySetTownHierarchy.setName("TownHierarchy"); + entitySetTownHierarchy.setEntityType("Model.TownHierarchy"); + + TEntitySet biEntitySetTownHierarchy = biFactory.createTEntitySet(); + biEntitySetTownHierarchy.setCaption("TownHierarchy"); + + entitySetTownHierarchy.setBiEntitySet(biEntitySetTownHierarchy); + + container.getEntitySet().add(entitySetTownHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("theMeasure"); + entitySet1.setEntityType("Model.theMeasure"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("theMeasure"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType townHierarchyType = edmFactory.createTEntityType(); + townHierarchyType.setName("TownHierarchy"); + + TLevel tLevelTown = biFactory.createTLevel(); + tLevelTown.setName("Town"); + tLevelTown.setCaption("Town"); + tLevelTown.setReferenceName("[Town].[TownHierarchy].[Town]"); + + TLevel tLevelCountry = biFactory.createTLevel(); + tLevelCountry.setName("County"); + tLevelCountry.setCaption("County"); + tLevelCountry.setReferenceName("[Town].[TownHierarchy].[County]"); + + THierarchy townHierarchyTHierarchy = biFactory.createTHierarchy(); + townHierarchyTHierarchy.setCaption("TownHierarchy"); + townHierarchyTHierarchy.setName("TownHierarchy"); + townHierarchyTHierarchy.setReferenceName("[Town].[TownHierarchy]"); + townHierarchyTHierarchy.getLevel().add(tLevelTown); + townHierarchyTHierarchy.getLevel().add(tLevelCountry); + + TEntityType townHierarchyTEntityType = biFactory.createTEntityType(); + townHierarchyTEntityType.setContents("TownHierarchy"); + townHierarchyTEntityType.getHierarchy().add(townHierarchyTHierarchy); + + townHierarchyType.setBiEntityType(townHierarchyTEntityType); + + TEntityProperty factTownIdProperty = edmFactory.createTEntityProperty(); + factTownIdProperty.setName("Fact.TOWN_ID"); + factTownIdProperty.setType("Int32"); + factTownIdProperty.setNullable(false); + + TPropertyRef factTownIdPropertyRef = edmFactory.createTPropertyRef(); + factTownIdPropertyRef.setName("Fact.TOWN_ID"); + + TEntityKeyElement key = edmFactory.createTEntityKeyElement(); + key.getPropertyRef().add(factTownIdPropertyRef); + + TEntityProperty townIdProperty = edmFactory.createTEntityProperty(); + townIdProperty.setName("Town.ID"); + townIdProperty.setType("Int32"); + townIdProperty.setNullable(false); + + TEntityProperty townNameProperty = edmFactory.createTEntityProperty(); + townNameProperty.setName("Town.NAME"); + townNameProperty.setType("String"); + townNameProperty.setNullable(false); + + TEntityProperty countryIdProperty = edmFactory.createTEntityProperty(); + countryIdProperty.setName("Country.ID"); + countryIdProperty.setType("Int32"); + countryIdProperty.setNullable(false); + + TEntityProperty countryNameProperty = edmFactory.createTEntityProperty(); + countryNameProperty.setName("Country.NAME"); + countryNameProperty.setType("String"); + countryNameProperty.setNullable(false); + + townHierarchyType.getProperty().add(factTownIdProperty); + townHierarchyType.getProperty().add(townIdProperty); + townHierarchyType.getProperty().add(townNameProperty); + townHierarchyType.getProperty().add(countryIdProperty); + townHierarchyType.getProperty().add(countryNameProperty); + + schema.getEntityType().add(townHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theMeasureType = edmFactory.createTEntityType(); + theMeasureType.setName("theMeasure"); + + TEntityType biTheMeasureType = biFactory.createTEntityType(); + biTheMeasureType.setContents("theMeasure"); + theMeasureType.setBiEntityType(biTheMeasureType); + + TEntityProperty theMeasureProperty = edmFactory.createTEntityProperty(); + theMeasureProperty.setName("Fact.VALUE"); + theMeasureProperty.setType("Int32"); + theMeasureProperty.setNullable(false); + + TMeasure biTheMeasureMeasure = biFactory.createTMeasure(); + biTheMeasureMeasure.setCaption("theMeasure"); + biTheMeasureMeasure.setHidden(false); + biTheMeasureMeasure.setReferenceName("[measures].[theMeasure]"); + theMeasureProperty.setBiMeasure(biTheMeasureMeasure); + + theMeasureType.getProperty().add(theMeasureProperty); + + schema.getEntityType().add(theMeasureType); + + return schema; + } + +} 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/TSchemaSupplier.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/TSchemaSupplier.java new file mode 100644 index 00000000..505c00db --- /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/TSchemaSupplier.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.cube.hierarchy.query.join.multi; + +import org.eclipse.daanse.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityKeyElement; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TPropertyRef; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Hierarchy Query Join Multi"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("Cube Query linked Tables"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTownHierarchy = edmFactory.createEntitySetType(); + entitySetTownHierarchy.setName("TownHierarchy"); + entitySetTownHierarchy.setEntityType("Model.TownHierarchy"); + + TEntitySet biEntitySetTownHierarchy = biFactory.createTEntitySet(); + biEntitySetTownHierarchy.setCaption("TownHierarchy"); + + entitySetTownHierarchy.setBiEntitySet(biEntitySetTownHierarchy); + + container.getEntitySet().add(entitySetTownHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("theMeasure"); + entitySet1.setEntityType("Model.theMeasure"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("theMeasure"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType townHierarchyType = edmFactory.createTEntityType(); + townHierarchyType.setName("TownHierarchy"); + + TLevel tLevelTown = biFactory.createTLevel(); + tLevelTown.setName("Town"); + tLevelTown.setCaption("Town"); + tLevelTown.setReferenceName("[Continent - Country - Town].[TownHierarchy].[Town]"); + + TLevel tLevelCountry = biFactory.createTLevel(); + tLevelCountry.setName("County"); + tLevelCountry.setCaption("County"); + tLevelCountry.setReferenceName("[Continent - Country - Town].[TownHierarchy].[County]"); + + TLevel tLevelContinent = biFactory.createTLevel(); + tLevelContinent.setName("Continent"); + tLevelContinent.setCaption("Continent"); + tLevelContinent.setReferenceName("[Continent - Country - Town].[TownHierarchy].[Continent]"); + + THierarchy townHierarchyTHierarchy = biFactory.createTHierarchy(); + townHierarchyTHierarchy.setCaption("TownHierarchy"); + townHierarchyTHierarchy.setName("TownHierarchy"); + townHierarchyTHierarchy.setReferenceName("[Continent - Country - Town].[TownHierarchy]"); + townHierarchyTHierarchy.getLevel().add(tLevelTown); + townHierarchyTHierarchy.getLevel().add(tLevelCountry); + townHierarchyTHierarchy.getLevel().add(tLevelContinent); + + TEntityType townHierarchyTEntityType = biFactory.createTEntityType(); + townHierarchyTEntityType.setContents("TownHierarchy"); + townHierarchyTEntityType.getHierarchy().add(townHierarchyTHierarchy); + + townHierarchyType.setBiEntityType(townHierarchyTEntityType); + + TEntityProperty factTownIdProperty = edmFactory.createTEntityProperty(); + factTownIdProperty.setName("Fact.TOWN_ID"); + factTownIdProperty.setType("Int32"); + factTownIdProperty.setNullable(false); + + TPropertyRef factTownIdPropertyRef = edmFactory.createTPropertyRef(); + factTownIdPropertyRef.setName("Fact.TOWN_ID"); + + TEntityKeyElement key = edmFactory.createTEntityKeyElement(); + key.getPropertyRef().add(factTownIdPropertyRef); + + TEntityProperty townIdProperty = edmFactory.createTEntityProperty(); + townIdProperty.setName("Town.ID"); + townIdProperty.setType("Int32"); + townIdProperty.setNullable(false); + + TEntityProperty townNameProperty = edmFactory.createTEntityProperty(); + townNameProperty.setName("Town.NAME"); + townNameProperty.setType("String"); + townNameProperty.setNullable(false); + + TEntityProperty countryIdProperty = edmFactory.createTEntityProperty(); + countryIdProperty.setName("Country.ID"); + countryIdProperty.setType("Int32"); + countryIdProperty.setNullable(false); + + TEntityProperty countryNameProperty = edmFactory.createTEntityProperty(); + countryNameProperty.setName("Country.NAME"); + countryNameProperty.setType("String"); + countryNameProperty.setNullable(false); + + TEntityProperty continentIdProperty = edmFactory.createTEntityProperty(); + continentIdProperty.setName("Continent.ID"); + continentIdProperty.setType("Int32"); + continentIdProperty.setNullable(false); + + TEntityProperty continentNameProperty = edmFactory.createTEntityProperty(); + continentNameProperty.setName("Continent.NAME"); + continentNameProperty.setType("String"); + continentNameProperty.setNullable(false); + + townHierarchyType.getProperty().add(factTownIdProperty); + townHierarchyType.getProperty().add(townIdProperty); + townHierarchyType.getProperty().add(townNameProperty); + townHierarchyType.getProperty().add(countryIdProperty); + townHierarchyType.getProperty().add(countryNameProperty); + townHierarchyType.getProperty().add(continentIdProperty); + townHierarchyType.getProperty().add(continentNameProperty); + + schema.getEntityType().add(townHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theMeasureType = edmFactory.createTEntityType(); + theMeasureType.setName("theMeasure"); + + TEntityType biTheMeasureType = biFactory.createTEntityType(); + biTheMeasureType.setContents("theMeasure"); + theMeasureType.setBiEntityType(biTheMeasureType); + + TEntityProperty theMeasureProperty = edmFactory.createTEntityProperty(); + theMeasureProperty.setName("Fact.VALUE"); + theMeasureProperty.setType("Int32"); + theMeasureProperty.setNullable(false); + + TMeasure biTheMeasureMeasure = biFactory.createTMeasure(); + biTheMeasureMeasure.setCaption("theMeasure"); + biTheMeasureMeasure.setHidden(false); + biTheMeasureMeasure.setReferenceName("[measures].[theMeasure]"); + theMeasureProperty.setBiMeasure(biTheMeasureMeasure); + + theMeasureType.getProperty().add(theMeasureProperty); + + schema.getEntityType().add(theMeasureType); + + return schema; + } + +} 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/TSchemaSupplier.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/TSchemaSupplier.java new file mode 100644 index 00000000..97c75ce9 --- /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/TSchemaSupplier.java @@ -0,0 +1,146 @@ +/* + * 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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityKeyElement; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TPropertyRef; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Hierarchy Query Table Base"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("Cube Query linked Tables"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTownHierarchy = edmFactory.createEntitySetType(); + entitySetTownHierarchy.setName("TownHierarchy"); + entitySetTownHierarchy.setEntityType("Model.TownHierarchy"); + + TEntitySet biEntitySetTownHierarchy = biFactory.createTEntitySet(); + biEntitySetTownHierarchy.setCaption("TownHierarchy"); + + entitySetTownHierarchy.setBiEntitySet(biEntitySetTownHierarchy); + + container.getEntitySet().add(entitySetTownHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("theMeasure"); + entitySet1.setEntityType("Model.theMeasure"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("theMeasure"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType townHierarchyType = edmFactory.createTEntityType(); + townHierarchyType.setName("TownHierarchy"); + + TLevel tLevelTown = biFactory.createTLevel(); + tLevelTown.setName("Town"); + tLevelTown.setCaption("Town"); + tLevelTown.setReferenceName("[Town].[TownHierarchy].[Town]"); + + THierarchy townHierarchyTHierarchy = biFactory.createTHierarchy(); + townHierarchyTHierarchy.setCaption("TownHierarchy"); + townHierarchyTHierarchy.setName("TownHierarchy"); + townHierarchyTHierarchy.setReferenceName("[Town].[TownHierarchy]"); + townHierarchyTHierarchy.getLevel().add(tLevelTown); + + TEntityType townHierarchyTEntityType = biFactory.createTEntityType(); + townHierarchyTEntityType.setContents("TownHierarchy"); + townHierarchyTEntityType.getHierarchy().add(townHierarchyTHierarchy); + + townHierarchyType.setBiEntityType(townHierarchyTEntityType); + + TEntityProperty factTownIdProperty = edmFactory.createTEntityProperty(); + factTownIdProperty.setName("Fact.TOWN_ID"); + factTownIdProperty.setType("Int32"); + factTownIdProperty.setNullable(false); + + TPropertyRef factTownIdPropertyRef = edmFactory.createTPropertyRef(); + factTownIdPropertyRef.setName("Fact.TOWN_ID"); + + TEntityKeyElement key = edmFactory.createTEntityKeyElement(); + key.getPropertyRef().add(factTownIdPropertyRef); + + TEntityProperty townIdProperty = edmFactory.createTEntityProperty(); + townIdProperty.setName("Town.ID"); + townIdProperty.setType("Int32"); + townIdProperty.setNullable(false); + + TEntityProperty townNameProperty = edmFactory.createTEntityProperty(); + townNameProperty.setName("Town.NAME"); + townNameProperty.setType("String"); + townNameProperty.setNullable(false); + + townHierarchyType.getProperty().add(factTownIdProperty); + townHierarchyType.getProperty().add(townIdProperty); + townHierarchyType.getProperty().add(townNameProperty); + + schema.getEntityType().add(townHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theMeasureType = edmFactory.createTEntityType(); + theMeasureType.setName("theMeasure"); + + TEntityType biTheMeasureType = biFactory.createTEntityType(); + biTheMeasureType.setContents("theMeasure"); + theMeasureType.setBiEntityType(biTheMeasureType); + + TEntityProperty theMeasureProperty = edmFactory.createTEntityProperty(); + theMeasureProperty.setName("Fact.VALUE"); + theMeasureProperty.setType("Int32"); + theMeasureProperty.setNullable(false); + + TMeasure biTheMeasureMeasure = biFactory.createTMeasure(); + biTheMeasureMeasure.setCaption("theMeasure"); + biTheMeasureMeasure.setHidden(false); + biTheMeasureMeasure.setReferenceName("[measures].[theMeasure]"); + theMeasureProperty.setBiMeasure(biTheMeasureMeasure); + + theMeasureType.getProperty().add(theMeasureProperty); + + schema.getEntityType().add(theMeasureType); + + return schema; + } + +} 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/TSchemaSupplier.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/TSchemaSupplier.java new file mode 100644 index 00000000..90d46cef --- /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/TSchemaSupplier.java @@ -0,0 +1,157 @@ +/* + * 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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityKeyElement; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TPropertyRef; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Hierarchy Query Table Multilevel Multitable"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("Cube Query linked Tables"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTownHierarchy = edmFactory.createEntitySetType(); + entitySetTownHierarchy.setName("TownHierarchy"); + entitySetTownHierarchy.setEntityType("Model.TownHierarchy"); + + TEntitySet biEntitySetTownHierarchy = biFactory.createTEntitySet(); + biEntitySetTownHierarchy.setCaption("TownHierarchy"); + + entitySetTownHierarchy.setBiEntitySet(biEntitySetTownHierarchy); + + container.getEntitySet().add(entitySetTownHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("theMeasure"); + entitySet1.setEntityType("Model.theMeasure"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("theMeasure"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType townHierarchyType = edmFactory.createTEntityType(); + townHierarchyType.setName("TownHierarchy"); + + TLevel tLevelTown = biFactory.createTLevel(); + tLevelTown.setName("Town"); + tLevelTown.setCaption("Town"); + tLevelTown.setReferenceName("[Town].[TownHierarchy].[Town]"); + + TLevel tLevelCountry = biFactory.createTLevel(); + tLevelCountry.setName("Country"); + tLevelCountry.setCaption("Country"); + tLevelCountry.setReferenceName("[Town].[TownHierarchy].[Country]"); + + THierarchy townHierarchyTHierarchy = biFactory.createTHierarchy(); + townHierarchyTHierarchy.setCaption("TownHierarchy"); + townHierarchyTHierarchy.setName("TownHierarchy"); + townHierarchyTHierarchy.setReferenceName("[Town].[TownHierarchy]"); + townHierarchyTHierarchy.getLevel().add(tLevelTown); + + TEntityType townHierarchyTEntityType = biFactory.createTEntityType(); + townHierarchyTEntityType.setContents("TownHierarchy"); + townHierarchyTEntityType.getHierarchy().add(townHierarchyTHierarchy); + + townHierarchyType.setBiEntityType(townHierarchyTEntityType); + + TEntityProperty factTownIdProperty = edmFactory.createTEntityProperty(); + factTownIdProperty.setName("Fact.TOWN_ID"); + factTownIdProperty.setType("Int32"); + factTownIdProperty.setNullable(false); + + TPropertyRef factTownIdPropertyRef = edmFactory.createTPropertyRef(); + factTownIdPropertyRef.setName("Fact.TOWN_ID"); + + TEntityKeyElement key = edmFactory.createTEntityKeyElement(); + key.getPropertyRef().add(factTownIdPropertyRef); + + TEntityProperty townIdProperty = edmFactory.createTEntityProperty(); + townIdProperty.setName("Town.ID"); + townIdProperty.setType("Int32"); + townIdProperty.setNullable(false); + + TEntityProperty townNameProperty = edmFactory.createTEntityProperty(); + townNameProperty.setName("Town.NAME"); + townNameProperty.setType("String"); + townNameProperty.setNullable(false); + + TEntityProperty townCountryProperty = edmFactory.createTEntityProperty(); + townCountryProperty.setName("Town.COUNTRY"); + townCountryProperty.setType("String"); + townCountryProperty.setNullable(false); + + townHierarchyType.getProperty().add(factTownIdProperty); + townHierarchyType.getProperty().add(townIdProperty); + townHierarchyType.getProperty().add(townNameProperty); + townHierarchyType.getProperty().add(townCountryProperty); + + schema.getEntityType().add(townHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theMeasureType = edmFactory.createTEntityType(); + theMeasureType.setName("theMeasure"); + + TEntityType biTheMeasureType = biFactory.createTEntityType(); + biTheMeasureType.setContents("theMeasure"); + theMeasureType.setBiEntityType(biTheMeasureType); + + TEntityProperty theMeasureProperty = edmFactory.createTEntityProperty(); + theMeasureProperty.setName("Fact.VALUE"); + theMeasureProperty.setType("Int32"); + theMeasureProperty.setNullable(false); + + TMeasure biTheMeasureMeasure = biFactory.createTMeasure(); + biTheMeasureMeasure.setCaption("theMeasure"); + biTheMeasureMeasure.setHidden(false); + biTheMeasureMeasure.setReferenceName("[measures].[theMeasure]"); + theMeasureProperty.setBiMeasure(biTheMeasureMeasure); + + theMeasureType.getProperty().add(theMeasureProperty); + + schema.getEntityType().add(theMeasureType); + + return schema; + } + +} 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/TSchemaSupplier.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/TSchemaSupplier.java new file mode 100644 index 00000000..18f5c92b --- /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/TSchemaSupplier.java @@ -0,0 +1,146 @@ +/* + * 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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityKeyElement; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TPropertyRef; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Hierarchy Query Table Multilevel Singletable"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("Cube Query linked Tables"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetTownHierarchy = edmFactory.createEntitySetType(); + entitySetTownHierarchy.setName("TownHierarchy"); + entitySetTownHierarchy.setEntityType("Model.TownHierarchy"); + + TEntitySet biEntitySetTownHierarchy = biFactory.createTEntitySet(); + biEntitySetTownHierarchy.setCaption("TownHierarchy"); + + entitySetTownHierarchy.setBiEntitySet(biEntitySetTownHierarchy); + + container.getEntitySet().add(entitySetTownHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("theMeasure"); + entitySet1.setEntityType("Model.theMeasure"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("theMeasure"); + entitySet1.setBiEntitySet(biEntitySet1); + + container.getEntitySet().add(entitySet1); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType townHierarchyType = edmFactory.createTEntityType(); + townHierarchyType.setName("TownHierarchy"); + + TLevel tLevelTown = biFactory.createTLevel(); + tLevelTown.setName("Town"); + tLevelTown.setCaption("Town"); + tLevelTown.setReferenceName("[Town].[TownHierarchy].[Town]"); + + TLevel tLevelCountry = biFactory.createTLevel(); + tLevelCountry.setName("Country"); + tLevelCountry.setCaption("Country"); + tLevelCountry.setReferenceName("[Town].[TownHierarchy].[Country]"); + + THierarchy townHierarchyTHierarchy = biFactory.createTHierarchy(); + townHierarchyTHierarchy.setCaption("TownHierarchy"); + townHierarchyTHierarchy.setName("TownHierarchy"); + townHierarchyTHierarchy.setReferenceName("[Town].[TownHierarchy]"); + townHierarchyTHierarchy.getLevel().add(tLevelTown); + townHierarchyTHierarchy.getLevel().add(tLevelCountry); + + TEntityType townHierarchyTEntityType = biFactory.createTEntityType(); + townHierarchyTEntityType.setContents("TownHierarchy"); + townHierarchyTEntityType.getHierarchy().add(townHierarchyTHierarchy); + + townHierarchyType.setBiEntityType(townHierarchyTEntityType); + + TEntityProperty factKeyProperty = edmFactory.createTEntityProperty(); + factKeyProperty.setName("Fact.KEY"); + factKeyProperty.setType("Int32"); + factKeyProperty.setNullable(false); + + TPropertyRef factTownIdPropertyRef = edmFactory.createTPropertyRef(); + factTownIdPropertyRef.setName("Fact.KEY"); + + TEntityKeyElement key = edmFactory.createTEntityKeyElement(); + key.getPropertyRef().add(factTownIdPropertyRef); + + TEntityProperty facktCountryProperty = edmFactory.createTEntityProperty(); + facktCountryProperty.setName("Fact.COUNTRY"); + facktCountryProperty.setType("String"); + facktCountryProperty.setNullable(false); + + townHierarchyType.getProperty().add(factKeyProperty); + townHierarchyType.getProperty().add(facktCountryProperty); + + schema.getEntityType().add(townHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType theMeasureType = edmFactory.createTEntityType(); + theMeasureType.setName("theMeasure"); + + TEntityType biTheMeasureType = biFactory.createTEntityType(); + biTheMeasureType.setContents("theMeasure"); + theMeasureType.setBiEntityType(biTheMeasureType); + + TEntityProperty theMeasureProperty = edmFactory.createTEntityProperty(); + theMeasureProperty.setName("Fact.VALUE"); + theMeasureProperty.setType("Int32"); + theMeasureProperty.setNullable(false); + + TMeasure biTheMeasureMeasure = biFactory.createTMeasure(); + biTheMeasureMeasure.setCaption("theMeasure"); + biTheMeasureMeasure.setHidden(false); + biTheMeasureMeasure.setReferenceName("[measures].[theMeasure]"); + theMeasureProperty.setBiMeasure(biTheMeasureMeasure); + + theMeasureType.getProperty().add(theMeasureProperty); + + schema.getEntityType().add(theMeasureType); + + return schema; + } + +} 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/TSchemaSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.base/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/base/TSchemaSupplier.java new file mode 100644 index 00000000..3e976e20 --- /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/TSchemaSupplier.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.cube.measure.aggregator.base; + +import org.eclipse.daanse.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityKeyElement; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TPropertyRef; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Measure Aggregator Base"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("MeasuresAggregatorsCube"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("Sum_of_Value"); + entitySet1.setEntityType("Model.Sum_of_Value"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("Sum of Value"); + entitySet1.setBiEntitySet(biEntitySet1); + + EntitySetType entitySet2 = edmFactory.createEntitySetType(); + entitySet2.setName("Max_of_Value"); + entitySet2.setEntityType("Model.Max_of_Value"); + + TEntitySet biEntitySet2 = biFactory.createTEntitySet(); + biEntitySet2.setCaption("Max of Value"); + entitySet2.setBiEntitySet(biEntitySet2); + + EntitySetType entitySet3 = edmFactory.createEntitySetType(); + entitySet3.setName("Min_of_Value"); + entitySet3.setEntityType("Model.Min_of_Value"); + + TEntitySet biEntitySet3 = biFactory.createTEntitySet(); + biEntitySet3.setCaption("Min of Value"); + entitySet3.setBiEntitySet(biEntitySet3); + + EntitySetType entitySet4 = edmFactory.createEntitySetType(); + entitySet4.setName("Avg_of_Value"); + entitySet4.setEntityType("Model.Avg_of_Value"); + + TEntitySet biEntitySet4 = biFactory.createTEntitySet(); + biEntitySet4.setCaption("Avg of Value"); + entitySet4.setBiEntitySet(biEntitySet4); + + container.getEntitySet().add(entitySet1); + container.getEntitySet().add(entitySet2); + container.getEntitySet().add(entitySet3); + container.getEntitySet().add(entitySet4); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType sumOfValueType = edmFactory.createTEntityType(); + sumOfValueType.setName("Sum_of_Value"); + + TEntityType biSumOfValueType = biFactory.createTEntityType(); + biSumOfValueType.setContents("Sum_of_Value"); + sumOfValueType.setBiEntityType(biSumOfValueType); + + TEntityProperty sumOfValueProperty = edmFactory.createTEntityProperty(); + sumOfValueProperty.setName("Fact.VALUE"); + sumOfValueProperty.setType("Int32"); + sumOfValueProperty.setNullable(false); + + TMeasure biSumOfValueMeasure = biFactory.createTMeasure(); + biSumOfValueMeasure.setCaption("Sum of Value"); + biSumOfValueMeasure.setHidden(false); + biSumOfValueMeasure.setReferenceName("[measures].[Sum of Value]"); + sumOfValueProperty.setBiMeasure(biSumOfValueMeasure); + + sumOfValueType.getProperty().add(sumOfValueProperty); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType maxOfValueType = edmFactory.createTEntityType(); + maxOfValueType.setName("Max_of_Value"); + + TEntityType biMaxOfValueType = biFactory.createTEntityType(); + biMaxOfValueType.setContents("Max_of_Value"); + maxOfValueType.setBiEntityType(biMaxOfValueType); + + TEntityProperty maxOfValueProperty = edmFactory.createTEntityProperty(); + maxOfValueProperty.setName("Fact.VALUE"); + maxOfValueProperty.setType("Int32"); + maxOfValueProperty.setNullable(false); + + TMeasure biMaxOfValueMeasure = biFactory.createTMeasure(); + biMaxOfValueMeasure.setCaption("Max of Value"); + biMaxOfValueMeasure.setHidden(false); + biMaxOfValueMeasure.setReferenceName("[measures].[Max of Value]"); + maxOfValueProperty.setBiMeasure(biMaxOfValueMeasure); + + maxOfValueType.getProperty().add(maxOfValueProperty); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType minOfValueType = edmFactory.createTEntityType(); + minOfValueType.setName("Min_of_Value"); + + TEntityType biMinOfValueType = biFactory.createTEntityType(); + biMinOfValueType.setContents("Min_of_Value"); + minOfValueType.setBiEntityType(biMinOfValueType); + + TEntityProperty minOfValueProperty = edmFactory.createTEntityProperty(); + minOfValueProperty.setName("Fact.VALUE"); + minOfValueProperty.setType("Int32"); + minOfValueProperty.setNullable(false); + + TMeasure biMinOfValueMeasure = biFactory.createTMeasure(); + biMinOfValueMeasure.setCaption("Min of Value"); + biMinOfValueMeasure.setHidden(false); + biMinOfValueMeasure.setReferenceName("[measures].[Min of Value]"); + minOfValueProperty.setBiMeasure(biMinOfValueMeasure); + + minOfValueType.getProperty().add(minOfValueProperty); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType avgOfValueType = edmFactory.createTEntityType(); + avgOfValueType.setName("Avg_of_Value"); + + TEntityType biAvgOfValueType = biFactory.createTEntityType(); + biAvgOfValueType.setContents("Avg_of_Value"); + avgOfValueType.setBiEntityType(biMinOfValueType); + + TEntityProperty avgOfValueProperty = edmFactory.createTEntityProperty(); + avgOfValueProperty.setName("Fact.VALUE"); + avgOfValueProperty.setType("Int32"); + avgOfValueProperty.setNullable(false); + + TMeasure biAvgOfValueMeasure = biFactory.createTMeasure(); + biAvgOfValueMeasure.setCaption("Avg of Value"); + biAvgOfValueMeasure.setHidden(false); + biAvgOfValueMeasure.setReferenceName("[measures].[Avg of Value]"); + avgOfValueProperty.setBiMeasure(biAvgOfValueMeasure); + + avgOfValueType.getProperty().add(avgOfValueProperty); + + schema.getEntityType().add(sumOfValueType); + schema.getEntityType().add(maxOfValueType); + schema.getEntityType().add(minOfValueType); + schema.getEntityType().add(avgOfValueType); + + return schema; + } + +} 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/TSchemaSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.bit/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/bit/TSchemaSupplier.java new file mode 100644 index 00000000..8422be0b --- /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/TSchemaSupplier.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.cube.measure.aggregator.bit; + +import org.eclipse.daanse.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Measure Aggregator Bit"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("MeasuresAggregatorsCube"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("BitAggAND"); + entitySet1.setEntityType("Model.BitAggAND"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("BitAgg AND"); + entitySet1.setBiEntitySet(biEntitySet1); + + EntitySetType entitySet2 = edmFactory.createEntitySetType(); + entitySet2.setName("BitAggOR"); + entitySet2.setEntityType("Model.BitAggOR"); + + TEntitySet biEntitySet2 = biFactory.createTEntitySet(); + biEntitySet2.setCaption("BitAgg OR"); + entitySet2.setBiEntitySet(biEntitySet2); + + EntitySetType entitySet3 = edmFactory.createEntitySetType(); + entitySet3.setName("BitAggXOR"); + entitySet3.setEntityType("Model.BitAggXOR"); + + TEntitySet biEntitySet3 = biFactory.createTEntitySet(); + biEntitySet3.setCaption("BitAgg XOR"); + entitySet3.setBiEntitySet(biEntitySet3); + + EntitySetType entitySet4 = edmFactory.createEntitySetType(); + entitySet4.setName("BitAggNAND"); + entitySet4.setEntityType("Model.BitAggNAND"); + + TEntitySet biEntitySet4 = biFactory.createTEntitySet(); + biEntitySet4.setCaption("BitAgg NAND"); + entitySet4.setBiEntitySet(biEntitySet4); + + EntitySetType entitySet5 = edmFactory.createEntitySetType(); + entitySet5.setName("BitAggNOR"); + entitySet5.setEntityType("Model.BitAggNOR"); + + TEntitySet biEntitySet5 = biFactory.createTEntitySet(); + biEntitySet5.setCaption("BitAgg NOR"); + entitySet5.setBiEntitySet(biEntitySet5); + + EntitySetType entitySet6 = edmFactory.createEntitySetType(); + entitySet6.setName("BitAggNXOR"); + entitySet6.setEntityType("Model.BitAggNXOR"); + + TEntitySet biEntitySet6 = biFactory.createTEntitySet(); + biEntitySet6.setCaption("BitAgg NXOR"); + entitySet6.setBiEntitySet(biEntitySet6); + + container.getEntitySet().add(entitySet1); + container.getEntitySet().add(entitySet2); + container.getEntitySet().add(entitySet3); + container.getEntitySet().add(entitySet4); + container.getEntitySet().add(entitySet5); + container.getEntitySet().add(entitySet6); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType bitAggANDType = edmFactory.createTEntityType(); + bitAggANDType.setName("BitAggAND"); + + TEntityType biBitAggANDType = biFactory.createTEntityType(); + biBitAggANDType.setContents("BitAggAND"); + bitAggANDType.setBiEntityType(biBitAggANDType); + + TEntityProperty bitAggANDProperty = edmFactory.createTEntityProperty(); + bitAggANDProperty.setName("Fact.VALUE"); + bitAggANDProperty.setType("Int32"); + bitAggANDProperty.setNullable(false); + + TMeasure biBitAggANDMeasure = biFactory.createTMeasure(); + biBitAggANDMeasure.setCaption("BitAgg AND"); + biBitAggANDMeasure.setHidden(false); + biBitAggANDMeasure.setReferenceName("[measures].[BitAgg AND]"); + bitAggANDProperty.setBiMeasure(biBitAggANDMeasure); + + bitAggANDType.getProperty().add(bitAggANDProperty); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType bitAggORType = edmFactory.createTEntityType(); + bitAggORType.setName("BitAggOR"); + + TEntityType biBitAggORType = biFactory.createTEntityType(); + biBitAggORType.setContents("BitAgg OR"); + bitAggORType.setBiEntityType(biBitAggORType); + + TEntityProperty bitAggORProperty = edmFactory.createTEntityProperty(); + bitAggORProperty.setName("Fact.VALUE"); + bitAggORProperty.setType("Int32"); + bitAggORProperty.setNullable(false); + + TMeasure biBitAggORMeasure = biFactory.createTMeasure(); + biBitAggORMeasure.setCaption("BitAgg OR"); + biBitAggORMeasure.setHidden(false); + biBitAggORMeasure.setReferenceName("[measures].[BitAgg OR]"); + bitAggORProperty.setBiMeasure(biBitAggORMeasure); + + bitAggORType.getProperty().add(bitAggORProperty); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType bitAggXORType = edmFactory.createTEntityType(); + bitAggXORType.setName("BitAggXOR"); + + TEntityType biBitAggXORType = biFactory.createTEntityType(); + biBitAggXORType.setContents("BitAggXOR"); + bitAggXORType.setBiEntityType(biBitAggXORType); + + TEntityProperty bitAggXORProperty = edmFactory.createTEntityProperty(); + bitAggXORProperty.setName("Fact.VALUE"); + bitAggXORProperty.setType("Int32"); + bitAggXORProperty.setNullable(false); + + TMeasure biBitAggXORMeasure = biFactory.createTMeasure(); + biBitAggXORMeasure.setCaption("BitAgg XOR"); + biBitAggXORMeasure.setHidden(false); + biBitAggXORMeasure.setReferenceName("[measures].[BitAgg XOR]"); + bitAggXORProperty.setBiMeasure(biBitAggXORMeasure); + + bitAggXORType.getProperty().add(bitAggXORProperty); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType bitAggNANDType = edmFactory.createTEntityType(); + bitAggNANDType.setName("BitAggNAND"); + + TEntityType biBitAggNANDType = biFactory.createTEntityType(); + biBitAggNANDType.setContents("BitAggNAND"); + bitAggNANDType.setBiEntityType(biBitAggXORType); + + TEntityProperty bitAggNANDProperty = edmFactory.createTEntityProperty(); + bitAggNANDProperty.setName("Fact.VALUE"); + bitAggNANDProperty.setType("Int32"); + bitAggNANDProperty.setNullable(false); + + TMeasure biBitAggNANDMeasure = biFactory.createTMeasure(); + biBitAggNANDMeasure.setCaption("BitAgg NAND"); + biBitAggNANDMeasure.setHidden(false); + biBitAggNANDMeasure.setReferenceName("[measures].[BitAgg NAND]"); + bitAggNANDProperty.setBiMeasure(biBitAggNANDMeasure); + + bitAggNANDType.getProperty().add(bitAggNANDProperty); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType bitAggNORType = edmFactory.createTEntityType(); + bitAggNORType.setName("BitAggNOR"); + + TEntityType biBitAggNORType = biFactory.createTEntityType(); + biBitAggNORType.setContents("BitAggNOR"); + bitAggNORType.setBiEntityType(biBitAggNORType); + + TEntityProperty bitAggNORProperty = edmFactory.createTEntityProperty(); + bitAggNORProperty.setName("Fact.VALUE"); + bitAggNORProperty.setType("Int32"); + bitAggNORProperty.setNullable(false); + + TMeasure biBitAggNORMeasure = biFactory.createTMeasure(); + biBitAggNORMeasure.setCaption("BitAgg NOR"); + biBitAggNORMeasure.setHidden(false); + biBitAggNORMeasure.setReferenceName("[measures].[BitAgg NOR]"); + bitAggNORProperty.setBiMeasure(biBitAggNORMeasure); + + bitAggNORType.getProperty().add(bitAggNORProperty); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType bitAggNXORType = edmFactory.createTEntityType(); + bitAggNXORType.setName("BitAggNXOR"); + + TEntityType biBitAggNXORType = biFactory.createTEntityType(); + biBitAggNXORType.setContents("BitAggNXOR"); + bitAggNXORType.setBiEntityType(biBitAggNORType); + + TEntityProperty bitAggNXORProperty = edmFactory.createTEntityProperty(); + bitAggNXORProperty.setName("Fact.VALUE"); + bitAggNXORProperty.setType("Int32"); + bitAggNXORProperty.setNullable(false); + + TMeasure biBitAggNXORMeasure = biFactory.createTMeasure(); + biBitAggNXORMeasure.setCaption("BitAgg NXOR"); + biBitAggNXORMeasure.setHidden(false); + biBitAggNXORMeasure.setReferenceName("[measures].[BitAgg NXOR]"); + bitAggNXORProperty.setBiMeasure(biBitAggNXORMeasure); + + bitAggNXORType.getProperty().add(bitAggNXORProperty); + + schema.getEntityType().add(bitAggANDType); + schema.getEntityType().add(bitAggORType); + schema.getEntityType().add(bitAggXORType); + schema.getEntityType().add(bitAggNANDType); + schema.getEntityType().add(bitAggNORType); + schema.getEntityType().add(bitAggNXORType); + schema.getEntityType().add(bitAggNXORType); + + return schema; + } + +} 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/TSchemaSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.nth/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/nth/TSchemaSupplier.java new file mode 100644 index 00000000..fe6bad94 --- /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/TSchemaSupplier.java @@ -0,0 +1,320 @@ +/* + * 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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityKeyElement; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TPropertyRef; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Measure Aggregator Nth"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("MeasuresAggregatorsCube"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetHierarchy = edmFactory.createEntitySetType(); + entitySetHierarchy.setName("Hierarchy"); + entitySetHierarchy.setEntityType("Model.Hierarchy"); + + TEntitySet biEntitySetHierarchy = biFactory.createTEntitySet(); + biEntitySetHierarchy.setCaption("Hierarchy"); + + entitySetHierarchy.setBiEntitySet(biEntitySetHierarchy); + + container.getEntitySet().add(entitySetHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("NthAgg1"); + entitySet1.setEntityType("Model.NthAgg1"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("NthAgg1"); + entitySet1.setBiEntitySet(biEntitySet1); + + EntitySetType entitySet2 = edmFactory.createEntitySetType(); + entitySet2.setName("NthAgg2"); + entitySet2.setEntityType("Model.NthAgg2"); + + TEntitySet biEntitySet2 = biFactory.createTEntitySet(); + biEntitySet2.setCaption("NthAgg2"); + entitySet2.setBiEntitySet(biEntitySet2); + + EntitySetType entitySet3 = edmFactory.createEntitySetType(); + entitySet3.setName("NthAgg3"); + entitySet3.setEntityType("Model.NthAgg3"); + + TEntitySet biEntitySet3 = biFactory.createTEntitySet(); + biEntitySet3.setCaption("NthAgg3"); + entitySet3.setBiEntitySet(biEntitySet3); + + EntitySetType entitySet4 = edmFactory.createEntitySetType(); + entitySet4.setName("NthAgg4"); + entitySet4.setEntityType("Model.NthAgg4"); + + TEntitySet biEntitySet4 = biFactory.createTEntitySet(); + biEntitySet4.setCaption("NthAgg4"); + entitySet4.setBiEntitySet(biEntitySet4); + + EntitySetType entitySet5 = edmFactory.createEntitySetType(); + entitySet5.setName("NthAgg5"); + entitySet5.setEntityType("Model.NthAgg5"); + + TEntitySet biEntitySet5 = biFactory.createTEntitySet(); + biEntitySet5.setCaption("NthAgg5"); + entitySet5.setBiEntitySet(biEntitySet5); + + EntitySetType entitySet6 = edmFactory.createEntitySetType(); + entitySet6.setName("NthAgg6"); + entitySet6.setEntityType("Model.NthAgg6"); + + TEntitySet biEntitySet6 = biFactory.createTEntitySet(); + biEntitySet6.setCaption("NthAgg6"); + entitySet6.setBiEntitySet(biEntitySet6); + + EntitySetType entitySet7 = edmFactory.createEntitySetType(); + entitySet7.setName("NthAgg7"); + entitySet7.setEntityType("Model.NthAgg7"); + + TEntitySet biEntitySet7 = biFactory.createTEntitySet(); + biEntitySet7.setCaption("NthAgg7"); + entitySet7.setBiEntitySet(biEntitySet7); + + container.getEntitySet().add(entitySet1); + container.getEntitySet().add(entitySet2); + container.getEntitySet().add(entitySet3); + container.getEntitySet().add(entitySet4); + container.getEntitySet().add(entitySet5); + container.getEntitySet().add(entitySet6); + container.getEntitySet().add(entitySet7); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType townHierarchyType = edmFactory.createTEntityType(); + townHierarchyType.setName("Hierarchy"); + + TLevel tLevelValue = biFactory.createTLevel(); + tLevelValue.setName("Value"); + tLevelValue.setCaption("Value"); + tLevelValue.setReferenceName("[Dim].[Hierarchy].[Value]"); + + THierarchy hierarchyTHierarchy = biFactory.createTHierarchy(); + hierarchyTHierarchy.setCaption("Hierarchy"); + hierarchyTHierarchy.setName("Hierarchy"); + hierarchyTHierarchy.setReferenceName("[Dim].[Hierarchy]"); + hierarchyTHierarchy.getLevel().add(tLevelValue); + + TEntityType hierarchyTEntityType = biFactory.createTEntityType(); + hierarchyTEntityType.setContents("Hierarchy"); + hierarchyTEntityType.getHierarchy().add(hierarchyTHierarchy); + + townHierarchyType.setBiEntityType(hierarchyTEntityType); + + TEntityProperty factKeyProperty = edmFactory.createTEntityProperty(); + factKeyProperty.setName("Fact.KEY"); + factKeyProperty.setType("Int32"); + factKeyProperty.setNullable(false); + + TPropertyRef factTownIdPropertyRef = edmFactory.createTPropertyRef(); + factTownIdPropertyRef.setName("Fact.KEY"); + + TEntityKeyElement key = edmFactory.createTEntityKeyElement(); + key.getPropertyRef().add(factTownIdPropertyRef); + + TEntityProperty facktCountryProperty = edmFactory.createTEntityProperty(); + facktCountryProperty.setName("Fact.COUNTRY"); + facktCountryProperty.setType("String"); + facktCountryProperty.setNullable(false); + + townHierarchyType.getProperty().add(factKeyProperty); + townHierarchyType.getProperty().add(facktCountryProperty); + + schema.getEntityType().add(townHierarchyType); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType nthAgg1Type = edmFactory.createTEntityType(); + nthAgg1Type.setName("NthAgg1"); + + TEntityType biNthAgg1Type = biFactory.createTEntityType(); + biNthAgg1Type.setContents("NthAgg1"); + nthAgg1Type.setBiEntityType(biNthAgg1Type); + + TEntityProperty nthAgg1Property = edmFactory.createTEntityProperty(); + nthAgg1Property.setName("Fact.VALUE"); + nthAgg1Property.setType("Int32"); + nthAgg1Property.setNullable(false); + + TMeasure biNthAgg1Measure = biFactory.createTMeasure(); + biNthAgg1Measure.setCaption("NthAgg1"); + biNthAgg1Measure.setHidden(false); + biNthAgg1Measure.setReferenceName("[measures].[NthAgg1]"); + nthAgg1Property.setBiMeasure(biNthAgg1Measure); + + nthAgg1Type.getProperty().add(nthAgg1Property); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType nthAgg2Type = edmFactory.createTEntityType(); + nthAgg2Type.setName("NthAgg2"); + + TEntityType biNthAgg2Type = biFactory.createTEntityType(); + biNthAgg2Type.setContents("NthAgg2"); + nthAgg2Type.setBiEntityType(biNthAgg2Type); + + TEntityProperty nthAgg2Property = edmFactory.createTEntityProperty(); + nthAgg2Property.setName("Fact.VALUE"); + nthAgg2Property.setType("Int32"); + nthAgg2Property.setNullable(false); + + TMeasure biNthAgg2Measure = biFactory.createTMeasure(); + biNthAgg2Measure.setCaption("NthAgg2"); + biNthAgg2Measure.setHidden(false); + biNthAgg2Measure.setReferenceName("[measures].[NthAgg2]"); + nthAgg2Property.setBiMeasure(biNthAgg2Measure); + + nthAgg2Type.getProperty().add(nthAgg2Property); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType nthAgg3Type = edmFactory.createTEntityType(); + nthAgg3Type.setName("NthAgg3"); + + TEntityType biNthAgg3Type = biFactory.createTEntityType(); + biNthAgg3Type.setContents("NthAgg3"); + nthAgg3Type.setBiEntityType(biNthAgg3Type); + + TEntityProperty nthAgg3Property = edmFactory.createTEntityProperty(); + nthAgg3Property.setName("Fact.VALUE"); + nthAgg3Property.setType("Int32"); + nthAgg3Property.setNullable(false); + + TMeasure biNthAgg3Measure = biFactory.createTMeasure(); + biNthAgg3Measure.setCaption("NthAgg3"); + biNthAgg3Measure.setHidden(false); + biNthAgg3Measure.setReferenceName("[measures].[NthAgg3]"); + nthAgg3Property.setBiMeasure(biNthAgg3Measure); + + nthAgg3Type.getProperty().add(nthAgg3Property); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType nthAgg4Type = edmFactory.createTEntityType(); + nthAgg4Type.setName("NthAgg4"); + + TEntityType biNthAgg4Type = biFactory.createTEntityType(); + biNthAgg4Type.setContents("NthAgg4"); + nthAgg4Type.setBiEntityType(biNthAgg4Type); + + TEntityProperty nthAgg4Property = edmFactory.createTEntityProperty(); + nthAgg4Property.setName("Fact.VALUE"); + nthAgg4Property.setType("Int32"); + nthAgg4Property.setNullable(false); + + TMeasure biNthAgg4Measure = biFactory.createTMeasure(); + biNthAgg4Measure.setCaption("NthAgg4"); + biNthAgg4Measure.setHidden(false); + biNthAgg4Measure.setReferenceName("[measures].[NthAgg4]"); + nthAgg4Property.setBiMeasure(biNthAgg4Measure); + + nthAgg4Type.getProperty().add(nthAgg4Property); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType nthAgg5Type = edmFactory.createTEntityType(); + nthAgg5Type.setName("NthAgg5"); + + TEntityType biNthAgg5Type = biFactory.createTEntityType(); + biNthAgg5Type.setContents("NthAgg5"); + nthAgg5Type.setBiEntityType(biNthAgg5Type); + + TEntityProperty nthAgg5Property = edmFactory.createTEntityProperty(); + nthAgg5Property.setName("Fact.VALUE"); + nthAgg5Property.setType("Int32"); + nthAgg5Property.setNullable(false); + + TMeasure biNthAgg5Measure = biFactory.createTMeasure(); + biNthAgg5Measure.setCaption("NthAgg5"); + biNthAgg5Measure.setHidden(false); + biNthAgg5Measure.setReferenceName("[measures].[NthAgg5]"); + nthAgg5Property.setBiMeasure(biNthAgg5Measure); + + nthAgg5Type.getProperty().add(nthAgg5Property); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType nthAgg6Type = edmFactory.createTEntityType(); + nthAgg6Type.setName("NthAgg5"); + + TEntityType biNthAgg6Type = biFactory.createTEntityType(); + biNthAgg6Type.setContents("NthAgg6"); + nthAgg6Type.setBiEntityType(biNthAgg6Type); + + TEntityProperty nthAgg6Property = edmFactory.createTEntityProperty(); + nthAgg6Property.setName("Fact.VALUE"); + nthAgg6Property.setType("Int32"); + nthAgg6Property.setNullable(false); + + TMeasure biNthAgg6Measure = biFactory.createTMeasure(); + biNthAgg6Measure.setCaption("NthAgg6"); + biNthAgg6Measure.setHidden(false); + biNthAgg6Measure.setReferenceName("[measures].[NthAgg6]"); + nthAgg6Property.setBiMeasure(biNthAgg6Measure); + + nthAgg6Type.getProperty().add(nthAgg6Property); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType nthAgg7Type = edmFactory.createTEntityType(); + nthAgg7Type.setName("NthAgg5"); + + TEntityType biNthAgg7Type = biFactory.createTEntityType(); + biNthAgg7Type.setContents("NthAgg7"); + nthAgg7Type.setBiEntityType(biNthAgg7Type); + + TEntityProperty nthAgg7Property = edmFactory.createTEntityProperty(); + nthAgg7Property.setName("Fact.VALUE"); + nthAgg7Property.setType("Int32"); + nthAgg7Property.setNullable(false); + + TMeasure biNthAgg7Measure = biFactory.createTMeasure(); + biNthAgg7Measure.setCaption("NthAgg7"); + biNthAgg7Measure.setHidden(false); + biNthAgg7Measure.setReferenceName("[measures].[NthAgg7]"); + nthAgg7Property.setBiMeasure(biNthAgg7Measure); + + nthAgg7Type.getProperty().add(nthAgg7Property); + + schema.getEntityType().add(nthAgg1Type); + schema.getEntityType().add(nthAgg2Type); + schema.getEntityType().add(nthAgg3Type); + schema.getEntityType().add(nthAgg4Type); + schema.getEntityType().add(nthAgg5Type); + schema.getEntityType().add(nthAgg6Type); + schema.getEntityType().add(nthAgg7Type); + + return schema; + } + +} 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/TSchemaSupplier.java b/instance/emf/tutorial/cube/measure.aggregator.percentile/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/aggregator/percentile/TSchemaSupplier.java new file mode 100644 index 00000000..94bf816c --- /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/TSchemaSupplier.java @@ -0,0 +1,234 @@ +/* + * 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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.THierarchy; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TLevel; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityKeyElement; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TPropertyRef; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Measure Aggregator Percentile"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("MeasuresAggregatorsCube"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySetHierarchy = edmFactory.createEntitySetType(); + entitySetHierarchy.setName("Hierarchy"); + entitySetHierarchy.setEntityType("Model.Hierarchy"); + + TEntitySet biEntitySetHierarchy = biFactory.createTEntitySet(); + biEntitySetHierarchy.setCaption("Hierarchy"); + + entitySetHierarchy.setBiEntitySet(biEntitySetHierarchy); + + container.getEntitySet().add(entitySetHierarchy); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("PercentileDisc025"); + entitySet1.setEntityType("Model.PercentileDisc025"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("Percentile disc 0.25"); + entitySet1.setBiEntitySet(biEntitySet1); + + EntitySetType entitySet2 = edmFactory.createEntitySetType(); + entitySet2.setName("PercentileCont025"); + entitySet2.setEntityType("Model.PercentileCont025"); + + TEntitySet biEntitySet2 = biFactory.createTEntitySet(); + biEntitySet2.setCaption("Percentile cont 0.25"); + entitySet2.setBiEntitySet(biEntitySet2); + + EntitySetType entitySet3 = edmFactory.createEntitySetType(); + entitySet3.setName("PercentileDisc042"); + entitySet3.setEntityType("Model.PercentileDisc042"); + + TEntitySet biEntitySet3 = biFactory.createTEntitySet(); + biEntitySet3.setCaption("Percentile disc 0.42"); + entitySet3.setBiEntitySet(biEntitySet3); + + EntitySetType entitySet4 = edmFactory.createEntitySetType(); + entitySet4.setName("PercentileCont042"); + entitySet4.setEntityType("Model.PercentileCont042"); + + TEntitySet biEntitySet4 = biFactory.createTEntitySet(); + biEntitySet4.setCaption("Percentile cont 0.42"); + entitySet4.setBiEntitySet(biEntitySet4); + + EntitySetType entitySet5 = edmFactory.createEntitySetType(); + entitySet5.setName("PercentileDisc05"); + entitySet5.setEntityType("Model.PercentileDisc05"); + + TEntitySet biEntitySet5 = biFactory.createTEntitySet(); + biEntitySet5.setCaption("Percentile disc 0.5"); + entitySet5.setBiEntitySet(biEntitySet5); + + EntitySetType entitySet6 = edmFactory.createEntitySetType(); + entitySet6.setName("PercentileCont05"); + entitySet6.setEntityType("Model.PercentileCont05"); + + TEntitySet biEntitySet6 = biFactory.createTEntitySet(); + biEntitySet6.setCaption("Percentile cont 0.5"); + entitySet6.setBiEntitySet(biEntitySet6); + + EntitySetType entitySet7 = edmFactory.createEntitySetType(); + entitySet7.setName("PercentileDisc075"); + entitySet7.setEntityType("Model.PercentileDisc075"); + + TEntitySet biEntitySet7 = biFactory.createTEntitySet(); + biEntitySet7.setCaption("Percentile disc 0.75"); + entitySet7.setBiEntitySet(biEntitySet7); + + EntitySetType entitySet8 = edmFactory.createEntitySetType(); + entitySet8.setName("PercentileCont075"); + entitySet8.setEntityType("Model.PercentileCont075"); + + TEntitySet biEntitySet8 = biFactory.createTEntitySet(); + biEntitySet8.setCaption("Percentile cont 0.75"); + entitySet8.setBiEntitySet(biEntitySet8); + + EntitySetType entitySet9 = edmFactory.createEntitySetType(); + entitySet9.setName("PercentileDisc100"); + entitySet9.setEntityType("Model.PercentileDisc100"); + + TEntitySet biEntitySet9 = biFactory.createTEntitySet(); + biEntitySet9.setCaption("Percentile disc 1.00"); + entitySet9.setBiEntitySet(biEntitySet9); + + EntitySetType entitySet10 = edmFactory.createEntitySetType(); + entitySet10.setName("PercentileCont100"); + entitySet10.setEntityType("Model.PercentileCont100"); + + TEntitySet biEntitySet10 = biFactory.createTEntitySet(); + biEntitySet10.setCaption("Percentile cont 1.00"); + entitySet10.setBiEntitySet(biEntitySet10); + + container.getEntitySet().add(entitySet1); + container.getEntitySet().add(entitySet2); + container.getEntitySet().add(entitySet3); + container.getEntitySet().add(entitySet4); + container.getEntitySet().add(entitySet5); + container.getEntitySet().add(entitySet6); + container.getEntitySet().add(entitySet7); + container.getEntitySet().add(entitySet8); + container.getEntitySet().add(entitySet9); + container.getEntitySet().add(entitySet10); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType hierarchyType = edmFactory.createTEntityType(); + hierarchyType.setName("Hierarchy"); + + TLevel tLevelLevel = biFactory.createTLevel(); + tLevelLevel.setName("Level"); + tLevelLevel.setCaption("Level"); + tLevelLevel.setReferenceName("[Dim].[Hierarchy].[Level]"); + + THierarchy hierarchyTHierarchy = biFactory.createTHierarchy(); + hierarchyTHierarchy.setCaption("Hierarchy"); + hierarchyTHierarchy.setName("Hierarchy"); + hierarchyTHierarchy.setReferenceName("[Dim].[Hierarchy]"); + hierarchyTHierarchy.getLevel().add(tLevelLevel); + + TEntityType hierarchyTEntityType = biFactory.createTEntityType(); + hierarchyTEntityType.setContents("Hierarchy"); + hierarchyTEntityType.getHierarchy().add(hierarchyTHierarchy); + + hierarchyType.setBiEntityType(hierarchyTEntityType); + + TEntityProperty factIdProperty = edmFactory.createTEntityProperty(); + factIdProperty.setName("Fact.ID"); + factIdProperty.setType("Int32"); + factIdProperty.setNullable(false); + + TPropertyRef factIdPropertyRef = edmFactory.createTPropertyRef(); + factIdPropertyRef.setName("Fact.ID"); + + TEntityKeyElement key = edmFactory.createTEntityKeyElement(); + key.getPropertyRef().add(factIdPropertyRef); + + TEntityProperty facktLevelProperty = edmFactory.createTEntityProperty(); + facktLevelProperty.setName("Fact.LEVEL"); + facktLevelProperty.setType("String"); + facktLevelProperty.setNullable(false); + + hierarchyType.getProperty().add(factIdProperty); + hierarchyType.getProperty().add(facktLevelProperty); + + schema.getEntityType().add(hierarchyType); + + createTEntityType(schema, "PercentileDisc025", "Percentile disc 0.25", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileCont025", "Percentile cont 0.25", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileDisc042", "Percentile disc 0.42", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileCont042", "Percentile cont 0.42", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileDisc05", "Percentile disc 0.5", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileCont05", "Percentile cont 0.5", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileDisc075", "Percentile disc 0.75", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileCont075", "Percentile cont 0.75", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileDisc100", "Percentile disc 1.00", "Fact.VALUE", "Int32", false); + createTEntityType(schema, "PercentileCont100", "Percentile cont 1.00", "Fact.VALUE", "Int32", false); + + return schema; + } + + private void createTEntityType(TSchema schema, String name, String caption, String edmEntityPropertyName, String edmEntityPropertyType, boolean nullable) { + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType edmEntityType = edmFactory.createTEntityType(); + edmEntityType.setName(name); + + TEntityType biEntityType = biFactory.createTEntityType(); + biEntityType.setContents(name); + edmEntityType.setBiEntityType(biEntityType); + + TEntityProperty edmEntityProperty = edmFactory.createTEntityProperty(); + edmEntityProperty.setName(edmEntityPropertyName); + edmEntityProperty.setType(edmEntityPropertyType); + edmEntityProperty.setNullable(nullable); + + TMeasure biMeasure = biFactory.createTMeasure(); + biMeasure.setCaption(caption); + biMeasure.setHidden(false); + biMeasure.setReferenceName("[measures].[" + caption + "]"); + edmEntityProperty.setBiMeasure(biMeasure); + + edmEntityType.getProperty().add(edmEntityProperty); + + schema.getEntityType().add(edmEntityType); + } + +} diff --git a/instance/emf/tutorial/cube/measure.multiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/multiple/TSchemaSupplier.java b/instance/emf/tutorial/cube/measure.multiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/multiple/TSchemaSupplier.java new file mode 100644 index 00000000..08418f1d --- /dev/null +++ b/instance/emf/tutorial/cube/measure.multiple/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/measure/multiple/TSchemaSupplier.java @@ -0,0 +1,140 @@ +/* + * 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.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Cube Minimal"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("MinimalCube"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySet1 = edmFactory.createEntitySetType(); + entitySet1.setName("Sum of Value1"); + entitySet1.setEntityType("Model.Sum of Value1"); + + EntitySetType entitySet2 = edmFactory.createEntitySetType(); + entitySet2.setName("Sum of Value2"); + entitySet2.setEntityType("Model.Sum of Value2"); + + EntitySetType entitySet3 = edmFactory.createEntitySetType(); + entitySet3.setName("Sum of Value3"); + entitySet3.setEntityType("Model.Sum of Value3"); + + TEntitySet biEntitySet1 = biFactory.createTEntitySet(); + biEntitySet1.setCaption("Sum of Value1"); + entitySet1.setBiEntitySet(biEntitySet1); + + TEntitySet biEntitySet2 = biFactory.createTEntitySet(); + biEntitySet2.setCaption("Sum of Value2"); + entitySet2.setBiEntitySet(biEntitySet2); + + TEntitySet biEntitySet3 = biFactory.createTEntitySet(); + biEntitySet3.setCaption("Sum of Value3"); + entitySet3.setBiEntitySet(biEntitySet3); + + container.getEntitySet().add(entitySet1); + container.getEntitySet().add(entitySet2); + container.getEntitySet().add(entitySet3); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureSumValue1Type = edmFactory.createTEntityType(); + measureSumValue1Type.setName("Sum of Value1"); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureSumValue2Type = edmFactory.createTEntityType(); + measureSumValue2Type.setName("Sum of Value2"); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureSumValue3Type = edmFactory.createTEntityType(); + measureSumValue3Type.setName("Sum of Value3"); + + TEntityType biMeasureSumValue1Type = biFactory.createTEntityType(); + biMeasureSumValue1Type.setContents("Sum of Value1"); + measureSumValue1Type.setBiEntityType(biMeasureSumValue1Type); + + TEntityType biMeasureSumValue2Type = biFactory.createTEntityType(); + biMeasureSumValue2Type.setContents("Sum of Value2"); + measureSumValue2Type.setBiEntityType(biMeasureSumValue2Type); + + TEntityType biMeasureSumValue3Type = biFactory.createTEntityType(); + biMeasureSumValue3Type.setContents("Sum of Value3"); + measureSumValue3Type.setBiEntityType(biMeasureSumValue3Type); + + TEntityProperty value1Property = edmFactory.createTEntityProperty(); + value1Property.setName("VALUE1"); + value1Property.setType("Int32"); + value1Property.setNullable(false); + + TEntityProperty value2Property = edmFactory.createTEntityProperty(); + value2Property.setName("VALUE2"); + value2Property.setType("Int32"); + value2Property.setNullable(false); + + TEntityProperty value3Property = edmFactory.createTEntityProperty(); + value3Property.setName("VALUE3"); + value3Property.setType("Int32"); + value3Property.setNullable(false); + + TMeasure biValue1Measure = biFactory.createTMeasure(); + biValue1Measure.setCaption("VALUE1"); + biValue1Measure.setHidden(false); + value1Property.setBiMeasure(biValue1Measure); + + TMeasure biValue2Measure = biFactory.createTMeasure(); + biValue2Measure.setCaption("VALUE2"); + biValue2Measure.setHidden(false); + value2Property.setBiMeasure(biValue2Measure); + + TMeasure biValue3Measure = biFactory.createTMeasure(); + biValue3Measure.setCaption("VALUE3"); + biValue3Measure.setHidden(false); + value3Property.setBiMeasure(biValue3Measure); + + + measureSumValue1Type.getProperty().add(value1Property); + measureSumValue2Type.getProperty().add(value2Property); + measureSumValue3Type.getProperty().add(value3Property); + + schema.getEntityType().add(measureSumValue1Type); + schema.getEntityType().add(measureSumValue2Type); + schema.getEntityType().add(measureSumValue3Type); + + return schema; + } + +} diff --git a/instance/emf/tutorial/cube/minimal/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/minimal/TSchemaSupplier.java b/instance/emf/tutorial/cube/minimal/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/minimal/TSchemaSupplier.java new file mode 100644 index 00000000..9dedc6a4 --- /dev/null +++ b/instance/emf/tutorial/cube/minimal/src/main/java/org/eclipse/daanse/rolap/mapping/instance/emf/tutorial/cube/minimal/TSchemaSupplier.java @@ -0,0 +1,83 @@ +/* + * 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.minimal; + +import org.eclipse.daanse.xmla.csdl.model.provider.OlapTSchemaSupplier; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.BiFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityContainer; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntitySet; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TEntityType; +import org.eclipse.daanse.xmla.csdl.model.v2.bi.TMeasure; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EdmFactory; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntityContainerType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.EntitySetType; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityProperty; +import org.eclipse.daanse.xmla.csdl.model.v2.edm.TSchema; +import org.osgi.service.component.annotations.Component; + +@Component(service = OlapTSchemaSupplier.class) +public class TSchemaSupplier implements OlapTSchemaSupplier { + private static EdmFactory edmFactory = EdmFactory.eINSTANCE; + private static BiFactory biFactory = BiFactory.eINSTANCE; + + @Override + public TSchema get() { + TSchema schema = edmFactory.createTSchema(); + schema.setNamespace("Model"); + schema.setAlias("Model"); + + EntityContainerType container = edmFactory.createEntityContainerType(); + container.setName("Daanse Tutorial - Cube Minimal"); + + TEntityContainer biContainer = biFactory.createTEntityContainer(); + biContainer.setCaption("MinimalCube"); + biContainer.setCulture("de-DE"); + container.setBiEntityContainer(biContainer); + + EntitySetType entitySet = edmFactory.createEntitySetType(); + entitySet.setName("Measure-Sum"); + entitySet.setEntityType("Model.Measure-Sum"); + + TEntitySet biEntitySet = biFactory.createTEntitySet(); + biEntitySet.setCaption("Measure-Sum"); + entitySet.setBiEntitySet(biEntitySet); + + container.getEntitySet().add(entitySet); + + schema.getEntityContainer().add(container); + + org.eclipse.daanse.xmla.csdl.model.v2.edm.TEntityType measureSumType = edmFactory.createTEntityType(); + measureSumType.setName("Measure-Sum"); + + TEntityType biMeasureSumType = biFactory.createTEntityType(); + biMeasureSumType.setContents("Measure-Sum"); + measureSumType.setBiEntityType(biMeasureSumType); + + TEntityProperty valueProperty = edmFactory.createTEntityProperty(); + valueProperty.setName("VALUE"); + valueProperty.setType("Int32"); + valueProperty.setNullable(false); + + TMeasure biValueMeasure = biFactory.createTMeasure(); + biValueMeasure.setCaption("VALUE"); + biValueMeasure.setHidden(false); + valueProperty.setBiMeasure(biValueMeasure); + + measureSumType.getProperty().add(valueProperty); + + schema.getEntityType().add(measureSumType); + + return schema; + } + +} diff --git a/instance/pom.xml b/instance/pom.xml index fccd4c2f..10c52222 100644 --- a/instance/pom.xml +++ b/instance/pom.xml @@ -44,5 +44,11 @@ 0.0.1-SNAPSHOT compile + + org.eclipse.daanse + org.eclipse.daanse.xmla.csdl.model.provider + 0.0.1-SNAPSHOT + compile + diff --git a/model/test.bndrun b/model/test.bndrun index d5f70939..22ae7489 100644 --- a/model/test.bndrun +++ b/model/test.bndrun @@ -79,6 +79,7 @@ org.gecko.emf.json;version='[1.5.1,1.5.2)',\ org.gecko.emf.osgi.component;version='[6.2.0,6.2.1)',\ org.opentest4j;version='[1.3.0,1.3.1)',\ + org.osgi.service.cm;version='[1.6.1,1.6.2)',\ org.osgi.service.component;version='[1.5.1,1.5.2)',\ org.osgi.test.common;version='[1.3.0,1.3.1)',\ org.osgi.test.junit5;version='[1.3.0,1.3.1)',\ diff --git a/verifyer/basic/test.bndrun b/verifyer/basic/test.bndrun index 6a1d0ba4..1ff51ecf 100644 --- a/verifyer/basic/test.bndrun +++ b/verifyer/basic/test.bndrun @@ -49,7 +49,7 @@ junit-platform-engine;version='[1.12.2,1.12.3)',\ junit-platform-launcher;version='[1.12.2,1.12.3)',\ net.bytebuddy.byte-buddy;version='[1.17.5,1.17.6)',\ - org.apache.aries.spifly.dynamic.framework.extension;version='[1.3.7,1.3.8)',\ + org.apache.aries.spifly.dynamic.bundle;version='[1.3.7,1.3.8)',\ org.apache.felix.configadmin;version='[1.9.26,1.9.27)',\ org.apache.felix.scr;version='[2.2.10,2.2.11)',\ org.eclipse.daanse.jdbc.db.api;version='[0.0.1,0.0.2)',\