org.eclipse.osbp.xtext.datamartdsl/src/org/eclipse/osbp/xtext/datamartdsl/DatamartDSL.xtext

/**
 *                                                                            
 *  Copyright (c) 2015 - 2016 - Loetz GmbH&Co.KG, 69115 Heidelberg, Germany 
 *                                                                            
 *  All rights reserved. This program and the accompanying materials           
 *  are made available under the terms of the Eclipse Public License 2.0        
 *  which accompanies this distribution, and is available at                  
 *  https://www.eclipse.org/legal/epl-2.0/                                 
 *                                 
 *  SPDX-License-Identifier: EPL-2.0                                 
 *                                                                            
 *  Contributors:                                                      
 * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 * 	   Jörg Riegel - ongoing development
 * 
 */
grammar org.eclipse.osbp.xtext.datamartdsl.DatamartDSL with org.eclipse.osbp.xtext.oxtype.OXtype

import "http://osbp.eclipse.org/xtext/datamartdsl/DatamartDSL" as datamart

import "http://osbp.eclipse.org/xtext/cubedsl/CubeDSL" as cube
import "http://osbp.eclipse.org/dsl/common/types/v1" as types
import "http://osbp.eclipse.org/dsl/entity/v1" as entity
import "http://www.eclipse.org/emf/2002/Ecore" as ecore

DatamartModel returns datamart::DatamartModel:
	importSection=XImportSection?  
	packages+=DatamartPackage*;

DatamartPackage returns datamart::DatamartPackage:
	{datamart::DatamartPackage} 'package' name=QualifiedName 
	('{' (definitions+=DatamartDefinition)* '}' )?;

DatamartDefinition returns datamart::DatamartDefinition:
	'datamart' name=ID (description?='description' descriptionValue=TRANSLATABLESTRING)? 
	(
		(showCaption?='showFilterCaptions')? & 
		('numberOfMultiSelectionRows' numMultiRows=INT)? &
		(rowLimitSet?='fetchSize' fetchSize=INT)?
	)
	'using' source=DatamartSource;  

DatamartSource returns datamart::DatamartSource:
	DatamartCube | DatamartEntity | DatamartTask;
	
DatamartTask returns datamart::DatamartTask:
	'task' taskQuery=TaskQueryTopicEnum 
	('columns' '{' columns+=DatamartColumn* '}')?  
	('conditions' '{' conditions+=DatamartCondition* '}')? ;

DatamartColumn returns datamart::DatamartColumn:
	'column' columnRef=TaskQueryColumnEnum;
	
DatamartTaskFilter returns datamart::DatamartTaskFilter:
	'filter' filterRef=TaskFilterEnum;
		
DatamartCube returns datamart::DatamartCube:
	'cube' cubeRef=[cube::CubeType]  (nonEmpty?='nonempty')?	
	'{' axisslicer+=DatamartCubeElement* '}';
 
DatamartReference returns datamart::DatamartReference:
	'join' ref=[entity::LEntityReference];

DatamartEntity returns datamart::DatamartEntity:
	'entity' entityRef=[entity::LEntity] (tracking?='tracking')? ('{'
		('navigation' '{' navigations+=DatamartNavigation* '}')? 
		('attributes' '{' attributes+=DatamartAttribute* '}' | suppressAttributes?='suppressAttributes' )? 
		('conditions' '{' conditions+=DatamartCondition* '}')?
		('ordering' '{' ordering+=DatamartOrder* '}')?
	'}')?;

DatamartNavigation returns datamart::DatamartNavigation:
	DatamartOwner | DatamartMember;
	
DatamartOwner returns datamart::DatamartOwner:
	'many2one' joinRef=DatamartReference 'to' datamartEntity=DatamartEntity;
	
DatamartMember returns datamart::DatamartMember:
	'one2many' joinRef=DatamartReference 'to' datamartEntity=DatamartEntity;

DatamartAxis returns datamart::DatamartAxis:
	'axis' name=AxisEnum;
	 
DatamartAttributeBase returns datamart::DatamartAttributeBase:
	'attribute' attributeRef=[entity::LEntityAttribute];

DatamartReferenceBase returns datamart::DatamartReferenceBase:
	'reference' referenceRef=[entity::LEntityReference];

DatamartAttribute returns datamart::DatamartAttribute:
	'attribute' attributeRef=[entity::LEntityAttribute] 
	(aliased?='alias' aliasName=TRANSLATABLEID)? 
	axis=DatamartAxis 
	(hasColumnWeight?='columnWeight' columnWeight=INT)?
	(
		(aggregated?='aggregate' aggregate=SqlAggregationEnum)? & 
		(scaled?='scale' scale=ValueScaleEnum)? &
		(distinct?='distinct')?
	);

DatamartCondition returns datamart::DatamartCondition:
	'condition' condition=DatamartDisjunction;

DatamartOrder returns datamart::DatamartOrder:
	'order' orderBy=[entity::LEntityAttribute] orderHow=OrderEnum (hasColumnWeight?='columnWeight' columnWeight=INT)?;

DatamartDisjunction returns datamart::Expression: 
	DatamartConjunction (({datamart::Disjunction.left=current} 'or') right=DatamartConjunction)*;

DatamartConjunction returns datamart::Expression: 
	DatamartConditionalExpression (({datamart::Conjunction.left=current} 'and') right=DatamartConditionalExpression)*;
	
DatamartConditionalExpression returns datamart::Expression:
	DatamartOperand (({datamart::ConditionalExpression.left=current} operator=OperatorEnum) right=DatamartOperand)*;

DatamartOperand returns datamart::Expression: 
	DatamartValue | '(' DatamartDisjunction ')';

DatamartValue returns datamart::Expression: 
	numberValue=Number|stringValue=STRING|((filtered?='filtered' (optional?='optional')?) | selected?='selected' | ranged?='ranged' | unreferenced?='unreferenced')|DatamartTaskFilter|DatamartColumn|DatamartAttributeBase|DatamartReferenceBase;

DatamartCubeElement returns datamart::DatamartCubeElement:
	DatamartCubeAxis|DatamartSlicer|DatamartDefineDerivedMeasure;
	
DatamartDefineDerivedMeasure returns datamart::DatamartDefineDerivedMeasure:
	'derive' name=TRANSLATABLEID 'from' derivedElement+=DatamartAddition*;

DatamartAddition returns datamart::Expression: 
	DatamartMultiplication (({datamart::Addition.left=current} '+'| {datamart::Subtraction.left=current} '-') right=DatamartMultiplication)*;

DatamartMultiplication returns datamart::Expression: 
	DatamartPrimary (({datamart::Multiplication.left=current} '*' | {datamart::Division.left=current} '/') right=DatamartPrimary)*;
	
DatamartPrimary returns datamart::Expression: 
	DatamartNumberOrElement | '(' DatamartAddition ')';

DatamartNumberOrElement returns datamart::Expression: 
	value=Number | DatamartMeasure | DatamartDerivedMeasure | DatamartMemberTuple | DatamartAggregation;
	
DatamartMemberTuple returns datamart::Expression:
	((function=DatamartFunction | function = DatamartParameterFunction) 'of')? hierarchy=DatamartHierarchy ({datamart::DatamartMemberTuple.left = current} 'over' right=DatamartMeasure);
	
DatamartFunction returns datamart::DatamartFunction:
	function=FunctionEnum;

DatamartParameterFunction returns datamart::DatamartParameterFunction:
	function=ParameterFunctionEnum '(' parameter=DatamartFunctionIntParameter ')';
	
DatamartFunctionIntParameter returns datamart::DatamartFunctionIntParameter:
	value=INT;
	
DatamartSetFunction returns datamart::DatamartSetFunction:
	setFunction=SetFunctionEnum;
	
DatamartSetParameterFunction returns datamart::DatamartSetParameterFunction:
	setFunction=SetParameterFunctionEnum '(' parameter=DatamartFunctionIntParameter ')';
		
DatamartSetAggregationFunction returns datamart::DatamartSetAggregationFunction:
	aggregation=SetAggregationEnum '(' parameter=DatamartFunctionIntParameter ')';

DatamartSetTuple returns datamart::Expression:
	(setFunction = DatamartSetFunction | setFunction = DatamartSetParameterFunction) ({datamart::DatamartSetTuple.left = current} 'of' right=DatamartHierarchy);
	
DatamartAggregationFunction returns datamart::DatamartAggregationFunction:
	aggregation=AggregationEnum;

DatamartAggregation returns datamart::Expression:
	aggregation=DatamartAggregationFunction 'of' (set=DatamartSetTuple | set=DatamartHierarchy) ({datamart::DatamartAggregation.left = current} 'over' right=DatamartMeasure);
	
DatamartSetAggregation returns datamart::Expression:
	aggregation=DatamartSetAggregationFunction 'of' (set=DatamartSetTuple | set=DatamartHierarchy) ({datamart::DatamartSetAggregation.left = current} 'over' right=DatamartMeasure);

DatamartSlicer returns datamart::DatamartSlicer:
	'slicer' element=DatamartElement;

DatamartCubeAxis returns datamart::DatamartCubeAxis:
	 {datamart::DatamartCubeAxis} axis=DatamartAxis '{' elements+=DatamartElement* '}';

DatamartElement returns datamart::DatamartElement:
	DatamartHierarchy|DatamartMeasure|DatamartDerivedMeasure|DatamartSetAggregation;

DatamartDerivedMeasure returns datamart::DatamartDerivedMeasure:
	'derived' derivedRef=[datamart::DatamartDefineDerivedMeasure] (scaled?='scale' scale=ValueScaleEnum)?;
	
DatamartMeasure returns datamart::DatamartMeasure:
	'measure' measureRef=[cube::CubeMeasure] (scaled?='scale' scale=ValueScaleEnum)?;

DatamartHierarchy returns datamart::DatamartHierarchy:
	'hierarchy' hierarchyRef=[cube::CubeHierarchy] 
	(level = DatamartHierarchyLevelType)?
			((defaultMember?='default') | 
			(allMember?='condensed') |
			(allLevels?='exploded') |
			(all?='detailed'))?
	(except?='except' exceptRef=[cube::CubeLevel])? 
	(ordered?='orderBy' orderRef=(DatamartMeasure|DatamartDerivedMeasure) (descending?='descending')?)?;
	
DatamartHierarchyLevelType returns datamart::DatamartHierarchyLevel:
	DatamartHierarchyLevelSingle | DatamartHierarchyLevelMultiple;
	
DatamartHierarchyLevelSingle returns datamart::DatamartHierarchyLevelSingle:
	'level' levelRef=[cube::CubeLevel] (filtered?='filtered'| selected?='selected')? (sorted?='sorted')?;
	
DatamartHierarchyLevelMultiple returns datamart::DatamartHierarchyLevelMultiple:
	{datamart::DatamartHierarchyLevelMultiple} 'hierarchize' (post?='post')? '{'
		levels +=(DatamartHierarchyLevelSingle)*
	'}';

TRANSLATABLESTRING:
	STRING;
	
TRANSLATABLEID:
	ID;

enum AxisEnum returns datamart::AxisEnum:
	 DEFAULT='default' | COLUMNS='columns' | ROWS='rows' | PAGES='pages' | CHAPTERS='chapters' | SECTIONS='sections'  /* | AXIS(<index>)*/;
	 
enum FunctionEnum returns datamart::FunctionEnum:
	PREVMEMBER='previous' | NEXTMEMBER='next' | FIRSTCHILD='first' | LASTCHILD='last';
	
enum ParameterFunctionEnum returns datamart::ParameterFunctionEnum:
	LAG='lag' | LEAD='lead';
	 
enum SetFunctionEnum returns datamart::SetFunctionEnum:
	YTD='year-to-date' | PERIODSTODATE='periods' /*| ALLMEMBERS='all' | ASCENDANTS='ascendants'*/;
	
enum SetParameterFunctionEnum returns datamart::SetParameterFunctionEnum:
	TAIL='tail' | HEAD='head';	
	
enum SetAggregationEnum returns datamart::SetAggregationEnum:
	TOPCOUNT='topcount' | TOPSUM='topsummation' | TOPPERCENT='toppercentage' | BOTTOMCOUNT='bottomcount' | BOTTOMSUM='bottomsummation' | BOTTOMPERCENT='bottompercentage';

enum AggregationEnum returns datamart::AggregationEnum:
	AVG='average' | SUM='summation' | AGGREGATE='aggregate' | STDDEV='deviation';
	
enum OperatorEnum returns datamart::OperatorEnum:
	EQUALS='=' | LESS='<' | GREATER=">" | LESSEQUAL='<=' | GREATEREQUAL='>=' | LIKE='like';

enum SqlAggregationEnum returns datamart::SqlAggregationEnum:
	AVG='average' | SUM='summation' | COUNT='count';
	
enum ValueScaleEnum returns datamart::ValueScaleEnum:
	AXIS='group1' | AXIS2='group2' | AXIS3='group3' | AXIS4='group4' | AXIS5='group5' | AXIS6='group6' | AXIS7='group7' | AXIS8='group8' | AXIS9='group9';
	
enum TaskQueryTopicEnum returns datamart::TaskQueryTopicEnum:
	Q1='BusinessAdministrator' | Q2='PotentialOwner' | Q3='Recipient' | Q4='TaskInitiator' | Q5='TaskStakeholder' | Q6='ExcludedOwner';

enum TaskQueryColumnEnum returns datamart::TaskQueryColumnEnum:
	P1='Name' | P2='Priority' | P3='Status' | P4='Subject' | P5='Description' | P6='ExpirationTime' | P7='CreatedOn' | P8='CreatedBy' | P9='ActivationTime' | 
	P10='ActualOwner' | P11='TaskId' | P12 = 'ProcessId' | P13='ProcessInstanceId' | P14='ProcessSessionId';
	
enum TaskFilterEnum returns datamart::TaskFilterEnum:
	F1='Groups' | F2='Users';

enum OrderEnum returns datamart::OrderEnum:
	ASC='ascending' | DESC='descending';