create olap modules - common

Signed-off-by: dbulahov <[email protected]>

Author: dbulahov

common/pom.xml

@@ -0,0 +1,50 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.daanse</groupId>
+		<artifactId>org.eclipse.daanse.olap</artifactId>
+		<version>${revision}</version>
+	</parent>
+	<artifactId>org.eclipse.daanse.olap.common</artifactId>
+	<packaging>jar</packaging>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.osgi</groupId>
+			<artifactId>org.osgi.service.metatype.annotations</artifactId>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.osgi</groupId>
+			<artifactId>org.osgi.namespace.unresolvable</artifactId>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>biz.aQute.bnd</groupId>
+			<artifactId>biz.aQute.bndlib</artifactId>
+			<version>${bnd.version}</version>
+		</dependency>		
+		<dependency>
+			<groupId>com.github.ben-manes.caffeine</groupId>
+			<artifactId>caffeine</artifactId>
+			<version>${caffeine.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.osgi</groupId>
+			<artifactId>org.osgi.service.metatype.annotations</artifactId>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.daanse</groupId>
+			<artifactId>org.eclipse.daanse.olap.api</artifactId>
+			<version>0.0.1-SNAPSHOT</version>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.daanse</groupId>
+			<artifactId>org.eclipse.daanse.olap.action.api</artifactId>
+			<version>0.0.1-SNAPSHOT</version>
+		</dependency>
+	</dependencies>
+</project>

common/src/main/java/org/eclipse/daanse/olap/calc/base/AbstractProfilingCalc.java

@@ -0,0 +1,103 @@
+/*
+* Copyright (c) 2023 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:
+*   SmartCity Jena - initial
+*   Stefan Bischof (bipolis.org) - initial
+*/
+package org.eclipse.daanse.olap.calc.base;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.eclipse.daanse.olap.api.Evaluator;
+import org.eclipse.daanse.olap.api.calc.profile.CalcEvaluationProfile;
+import org.eclipse.daanse.olap.api.calc.profile.CalculationProfile;
+import org.eclipse.daanse.olap.api.calc.profile.ProfilingCalc;
+import org.eclipse.daanse.olap.api.type.Type;
+import org.eclipse.daanse.olap.calc.base.profile.CalcEvaluationProfileR;
+import org.eclipse.daanse.olap.calc.base.profile.CalcProfileR;
+
+public abstract class AbstractProfilingCalc<T> implements ProfilingCalc<T> {
+
+	private Type type;
+
+	private Instant firstEvalStart = null;
+	private Instant lastEvalEnd = null;
+
+	private final List<CalcEvaluationProfile> evaluations = new ArrayList<CalcEvaluationProfile>();
+
+	/**
+	 * Abstract Implementation of {@link ProfilingCalc} that generated a
+	 * {@link CalculationProfile} while calling
+	 * {@link #evaluateWithProfile(Evaluator)))
+	 *
+	 * @param Type
+	 * @param name
+	 */
+	public AbstractProfilingCalc(Type type) {
+		this.type = type;
+	}
+
+	@Override
+	public T evaluateWithProfile(Evaluator evaluator) {
+		Instant startEval = Instant.now();
+		if (firstEvalStart == null) {
+			firstEvalStart = startEval;
+		}
+		final T evalResult = evaluate(evaluator);
+
+		Instant endEval = Instant.now();
+		lastEvalEnd = endEval;
+
+		profileEvaluation(startEval, endEval, evalResult);
+		return evalResult;
+	}
+
+	protected void profileEvaluation(Instant evaluationStart, Instant evaluationEnd, T evaluationResult) {
+
+		CalcEvaluationProfile evaluationProfile = new CalcEvaluationProfileR(evaluationStart, evaluationEnd,
+				evaluationResult, Map.of());
+		evaluations.add(evaluationProfile);
+
+	}
+
+	protected Map<String, Object> profilingProperties(Map<String, Object> properties) {
+		return properties;
+	}
+
+	public CalculationProfile getCalculationProfile() {
+		final List<CalculationProfile> childProfiles = getChildProfiles();
+		Map<String, Object> profilingProperties = profilingProperties(new HashMap<String, Object>());
+		return new CalcProfileR(this.getClass(), getType(), getResultStyle(), Optional.ofNullable(firstEvalStart),
+				Optional.ofNullable(lastEvalEnd), profilingProperties, evaluations, childProfiles);
+	}
+
+	List<CalculationProfile> getChildProfiles() {
+		return List.of();
+	}
+
+	@Override
+	public Type getType() {
+		return type;
+	}
+	
+	 protected void requiresType(Class<? extends Type> typeClass) {
+		Type type = getType();
+		if (!typeClass.isInstance(type)) {
+			throw new RuntimeException("Expecting Type " + typeClass + " but was " + type);
+		}
+
+	}
+
+}

common/src/main/java/org/eclipse/daanse/olap/calc/base/AbstractProfilingConstantCalc.java

@@ -0,0 +1,54 @@
+/*
+* Copyright (c) 2023 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:
+*   SmartCity Jena - initial
+*   Stefan Bischof (bipolis.org) - initial
+*/
+package org.eclipse.daanse.olap.calc.base;
+
+import java.util.List;
+
+import org.eclipse.daanse.olap.api.Evaluator;
+import org.eclipse.daanse.olap.api.calc.ConstantCalc;
+import org.eclipse.daanse.olap.api.calc.ResultStyle;
+import org.eclipse.daanse.olap.api.calc.profile.CalculationProfile;
+import org.eclipse.daanse.olap.api.element.Hierarchy;
+import org.eclipse.daanse.olap.api.type.Type;
+
+public abstract class AbstractProfilingConstantCalc<T> extends AbstractProfilingCalc<T> implements ConstantCalc<T> {
+
+	private T value;
+
+	public AbstractProfilingConstantCalc(T value, Type type) {
+		super(type);
+		this.value = value;
+	}
+
+	@Override
+	public T evaluate(Evaluator evaluator) {
+		return value;
+	}
+
+	@Override
+	public boolean dependsOn(Hierarchy hierarchy) {
+		return false;
+	}
+
+	@Override
+	public ResultStyle getResultStyle() {
+		return value == null ? ResultStyle.VALUE : ResultStyle.VALUE_NOT_NULL;
+	}
+
+	@Override
+	List<CalculationProfile> getChildProfiles() {
+		return List.of();
+	}
+
+}

common/src/main/java/org/eclipse/daanse/olap/calc/base/AbstractProfilingIteratorCalc.java

@@ -0,0 +1,52 @@
+/*
+* Copyright (c) 2023 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:
+*   SmartCity Jena - initial
+*   Stefan Bischof (bipolis.org) - initial
+*/
+
+package org.eclipse.daanse.olap.calc.base;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.Map;
+
+import org.eclipse.daanse.olap.api.type.Type;
+
+public abstract class AbstractProfilingIteratorCalc<T> extends AbstractProfilingCalc<T> {
+
+	public AbstractProfilingIteratorCalc(Type type) {
+		super(type);
+	}
+
+	private long elementCount;
+	private long elementSquaredCount;
+
+	@Override
+	protected void profileEvaluation(Instant evaluationStart, Instant evaluationEnd, T evaluationResult) {
+		super.profileEvaluation(evaluationStart, evaluationEnd, evaluationResult);
+		if (evaluationResult instanceof Collection c) {
+			long size = c.size();
+			elementCount += size;
+			elementSquaredCount += size * size;
+		}
+	}
+
+	@Override
+	protected Map<String, Object> profilingProperties(Map<String, Object> properties) {
+
+		// TODO: may be removed writer can calculate its won because has access to the
+		// objects
+		properties.put("elementCount", elementCount);
+		properties.put("elementSquaredCount", elementSquaredCount);
+		return properties;
+	}
+
+}

common/src/main/java/org/eclipse/daanse/olap/calc/base/AbstractProfilingNestedCalc.java

@@ -0,0 +1,86 @@
+/*
+* Copyright (c) 2023 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:
+*   SmartCity Jena - initial
+*   Stefan Bischof (bipolis.org) - initial
+*/
+package org.eclipse.daanse.olap.calc.base;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.eclipse.daanse.olap.api.calc.Calc;
+import org.eclipse.daanse.olap.api.calc.ResultStyle;
+import org.eclipse.daanse.olap.api.calc.profile.CalculationProfile;
+import org.eclipse.daanse.olap.api.calc.profile.ProfilingCalc;
+import org.eclipse.daanse.olap.api.element.Hierarchy;
+import org.eclipse.daanse.olap.api.type.Type;
+import org.eclipse.daanse.olap.calc.base.util.HirarchyDependsChecker;
+
+public abstract class AbstractProfilingNestedCalc<E> extends AbstractProfilingCalc<E>
+		implements Calc<E> {
+
+	private final Calc<?>[] childCalcs;
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * Holds the childCalcs witch are accessible using {@link #getChildCalcs()}.
+	 * Enhances its own {@link CalculationProfile} with the Children's
+	 * {@link CalculationProfile}.
+	 *
+	 * @param calcs Child {@link Calc}s that are needed to calculate this.
+	 */
+//	protected AbstractProfilingNestedCalc(Type type, C[] childCalcs) {
+//		super(type);
+//		this.childCalcs = childCalcs;
+//
+//	}
+
+	protected AbstractProfilingNestedCalc(Type type, Calc<?>... childCalcs) {
+		super(type);
+		this.childCalcs = childCalcs;
+	}
+
+	public Calc<?>[] getChildCalcs() {
+		return childCalcs;
+	}
+
+	public Calc<?> getChildCalc(int i) {
+		return childCalcs[i];
+	}
+
+	public <D extends Calc<?>> D getChildCalc(int i, Class<D> clazz) {
+		return childCalcs[i]  != null ? clazz.cast(childCalcs[i]) : null;
+	}
+
+	protected Calc<?> getFirstChildCalc() {
+		return getChildCalcs()[0];
+	}
+
+	@Override
+	public boolean dependsOn(Hierarchy hierarchy) {
+		return HirarchyDependsChecker.checkAnyDependsOnChilds(getChildCalcs(), hierarchy);
+	}
+
+	@Override
+	public ResultStyle getResultStyle() {
+		return ResultStyle.VALUE;
+	}
+
+	@Override
+	protected List<CalculationProfile> getChildProfiles() {
+		List<CalculationProfile> childProfiles = Stream.of(getChildCalcs()).filter(ProfilingCalc.class::isInstance)
+				.map(ProfilingCalc.class::cast).map(ProfilingCalc::getCalculationProfile).toList();
+
+		return childProfiles;
+	}
+
+}

common/src/main/java/org/eclipse/daanse/olap/calc/base/AbstractProfilingScalarCalc.java

@@ -0,0 +1,30 @@
+/*
+* Copyright (c) 2023 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:
+*   SmartCity Jena - initial
+*   Stefan Bischof (bipolis.org) - initial
+*/
+package org.eclipse.daanse.olap.calc.base;
+
+import org.eclipse.daanse.olap.api.calc.ResultStyle;
+import org.eclipse.daanse.olap.api.type.Type;
+
+public abstract class AbstractProfilingScalarCalc<T> extends AbstractProfilingCalc<T> {
+
+	public AbstractProfilingScalarCalc(Type type) {
+		super(type);
+	}
+
+	@Override
+	public ResultStyle getResultStyle() {
+		return ResultStyle.VALUE;
+	}
+
+}