org.eclipse.osbp.xtext.datamartdsl/xtend-gen/org/eclipse/osbp/xtext/datamartdsl/jvmmodel/DatamartDSLJvmModelInferrer.java

/**
 * Copyright (c) 2013, 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
 */
package org.eclipse.osbp.xtext.datamartdsl.jvmmodel;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.inject.Inject;
import mondrian.rolap.RolapConnection;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.osbp.bpm.api.IBPMEngine;
import org.eclipse.osbp.bpm.api.IBPMTaskClient;
import org.eclipse.osbp.core.api.persistence.IPersistenceService;
import org.eclipse.osbp.dsl.common.datatypes.IDto;
import org.eclipse.osbp.dsl.common.xtext.extensions.AnnotationExtension;
import org.eclipse.osbp.dsl.entity.xtext.extensions.ModelExtensions;
import org.eclipse.osbp.dsl.entity.xtext.extensions.NamingExtensions;
import org.eclipse.osbp.dsl.semantic.common.types.LAttribute;
import org.eclipse.osbp.dsl.semantic.common.types.LDataType;
import org.eclipse.osbp.dsl.semantic.common.types.LKeyAndValue;
import org.eclipse.osbp.dsl.semantic.common.types.LScalarType;
import org.eclipse.osbp.dsl.semantic.entity.LBean;
import org.eclipse.osbp.dsl.semantic.entity.LBeanAttribute;
import org.eclipse.osbp.dsl.semantic.entity.LEntity;
import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute;
import org.eclipse.osbp.dsl.semantic.entity.LEntityFeature;
import org.eclipse.osbp.dsl.semantic.entity.LEntityReference;
import org.eclipse.osbp.preferences.EnumDatabaseVendor;
import org.eclipse.osbp.ui.api.datamart.DatamartFilter;
import org.eclipse.osbp.ui.api.datamart.DatamartPrimary;
import org.eclipse.osbp.ui.api.datamart.IDataMart;
import org.eclipse.osbp.ui.api.metadata.IDSLMetadataService;
import org.eclipse.osbp.ui.api.user.IUser;
import org.eclipse.osbp.ui.api.useraccess.IUserAccessService;
import org.eclipse.osbp.utils.common.EntityUtils;
import org.eclipse.osbp.utils.entityhelper.DataType;
import org.eclipse.osbp.xtext.cubedsl.CubeDimension;
import org.eclipse.osbp.xtext.cubedsl.CubeDimensionUsage;
import org.eclipse.osbp.xtext.cubedsl.CubeHierarchy;
import org.eclipse.osbp.xtext.cubedsl.CubeLevel;
import org.eclipse.osbp.xtext.cubedsl.CubePackage;
import org.eclipse.osbp.xtext.cubedsl.CubeTypeEntity;
import org.eclipse.osbp.xtext.datamart.common.ACubeDatamart;
import org.eclipse.osbp.xtext.datamart.common.AEntityDatamart;
import org.eclipse.osbp.xtext.datamart.common.ATaskDatamart;
import org.eclipse.osbp.xtext.datamart.common.DatamartDefinitionUtil;
import org.eclipse.osbp.xtext.datamart.common.DatamartDtoMapper;
import org.eclipse.osbp.xtext.datamart.common.olap.DerivedCellSet;
import org.eclipse.osbp.xtext.datamartdsl.Addition;
import org.eclipse.osbp.xtext.datamartdsl.AxisEnum;
import org.eclipse.osbp.xtext.datamartdsl.ConditionalExpression;
import org.eclipse.osbp.xtext.datamartdsl.Conjunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAggregation;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationFunctionInterface;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAttribute;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAttributeBase;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAxis;
import org.eclipse.osbp.xtext.datamartdsl.DatamartColumn;
import org.eclipse.osbp.xtext.datamartdsl.DatamartCondition;
import org.eclipse.osbp.xtext.datamartdsl.DatamartCube;
import org.eclipse.osbp.xtext.datamartdsl.DatamartCubeAxis;
import org.eclipse.osbp.xtext.datamartdsl.DatamartCubeElement;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDSLFactory;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDefineDerivedMeasure;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDerivedMeasure;
import org.eclipse.osbp.xtext.datamartdsl.DatamartElement;
import org.eclipse.osbp.xtext.datamartdsl.DatamartEntity;
import org.eclipse.osbp.xtext.datamartdsl.DatamartFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartFunctionIntParameter;
import org.eclipse.osbp.xtext.datamartdsl.DatamartFunctionInterface;
import org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy;
import org.eclipse.osbp.xtext.datamartdsl.DatamartMeasure;
import org.eclipse.osbp.xtext.datamartdsl.DatamartMember;
import org.eclipse.osbp.xtext.datamartdsl.DatamartMemberTuple;
import org.eclipse.osbp.xtext.datamartdsl.DatamartNavigation;
import org.eclipse.osbp.xtext.datamartdsl.DatamartOrder;
import org.eclipse.osbp.xtext.datamartdsl.DatamartOwner;
import org.eclipse.osbp.xtext.datamartdsl.DatamartPackage;
import org.eclipse.osbp.xtext.datamartdsl.DatamartParameterFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartReference;
import org.eclipse.osbp.xtext.datamartdsl.DatamartReferenceBase;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetAggregation;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetAggregationFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetFunctionInterface;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetParameterFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetTuple;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSlicer;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSource;
import org.eclipse.osbp.xtext.datamartdsl.DatamartTask;
import org.eclipse.osbp.xtext.datamartdsl.DatamartTaskFilter;
import org.eclipse.osbp.xtext.datamartdsl.Disjunction;
import org.eclipse.osbp.xtext.datamartdsl.Division;
import org.eclipse.osbp.xtext.datamartdsl.Expression;
import org.eclipse.osbp.xtext.datamartdsl.Multiplication;
import org.eclipse.osbp.xtext.datamartdsl.Subtraction;
import org.eclipse.osbp.xtext.datamartdsl.util.DatamartAttributeUtil;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.common.types.JvmAnnotationReference;
import org.eclipse.xtext.common.types.JvmDeclaredType;
import org.eclipse.xtext.common.types.JvmField;
import org.eclipse.xtext.common.types.JvmFormalParameter;
import org.eclipse.xtext.common.types.JvmGenericType;
import org.eclipse.xtext.common.types.JvmMember;
import org.eclipse.xtext.common.types.JvmOperation;
import org.eclipse.xtext.common.types.JvmTypeReference;
import org.eclipse.xtext.common.types.JvmVisibility;
import org.eclipse.xtext.common.types.util.TypeReferences;
import org.eclipse.xtext.naming.IQualifiedNameProvider;
import org.eclipse.xtext.naming.QualifiedName;
import org.eclipse.xtext.xbase.compiler.output.ITreeAppendable;
import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer;
import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor;
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ListExtensions;
import org.eclipse.xtext.xbase.lib.Pair;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.eclipse.xtext.xbase.lib.StringExtensions;
import org.junit.Test;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.component.annotations.ReferenceCardinality;
import org.osgi.service.component.annotations.ReferencePolicy;
import org.slf4j.Logger;

/**
 * <p>Infers a JVM model from the source model.</p>
 * 
 * <p>The JVM model should contain all elements that would appear in the Java code
 * which is generated from the source model. Other models link against the JVM model rather than the source model.</p>
 */
@SuppressWarnings("all")
public class DatamartDSLJvmModelInferrer extends AbstractModelInferrer {
  /**
   * convenience API to build and initialize JVM types and their members.
   */
  @Inject
  @Extension
  private JvmTypesBuilder _jvmTypesBuilder;
  
  @Inject
  @Extension
  private IQualifiedNameProvider _iQualifiedNameProvider;
  
  @Inject
  @Extension
  private NamingExtensions _namingExtensions;
  
  @Inject
  @Extension
  private TypeReferences _typeReferences;
  
  @Inject
  @Extension
  private AnnotationExtension _annotationExtension;
  
  @Inject
  @Extension
  private ModelExtensions _modelExtensions;
  
  @Inject
  @Extension
  private DataType dtType;
  
  private HashMap<String, Integer> sqlAliasCounter = CollectionLiterals.<String, Integer>newHashMap();
  
  private HashMap<String, DatamartAttributeBase> sqlFilterMap = CollectionLiterals.<String, DatamartAttributeBase>newHashMap();
  
  private HashMap<String, LEntity> idMap = CollectionLiterals.<String, LEntity>newHashMap();
  
  private String datamartDtoMapper = ((String) null);
  
  private boolean ignoreEntityGrouping = false;
  
  private boolean sqlHasAggregate = false;
  
  private boolean sqlHasOrder = false;
  
  public static String pckgName = null;
  
  private String binderClassName = "";
  
  private int defaultColumnWeight = 500;
  
  public void generatePckgName(final DatamartPackage pckg, final IJvmDeclaredTypeAcceptor acceptor) {
    DatamartDSLJvmModelInferrer.pckgName = pckg.getName();
  }
  
  /**
   * <p>infer method dispatches the neccessary routines to build fields, setter, getter, constructors and methods of the generated code.</p>
   */
  protected void _infer(final DatamartPackage datamart, final IJvmDeclaredTypeAcceptor acceptor, final boolean isPreIndexingPhase) {
    this.generatePckgName(datamart, acceptor);
    JvmGenericType cls = this._jvmTypesBuilder.toClass(datamart, datamart.getName().toString().concat("TestClass"));
    cls.setSimpleName(StringExtensions.toFirstUpper(cls.getSimpleName()));
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      JvmAnnotationReference _annotationRef = this._annotationTypesBuilder.annotationRef(SuppressWarnings.class, "serial");
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef);
      it.setPackageName(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).toString());
      this.toTestCalls(it, datamart);
      this._jvmTypesBuilder.setFileHeader(it, this._jvmTypesBuilder.getDocumentation(datamart));
    };
    acceptor.<JvmGenericType>accept(cls, _function);
    String _string = this._iQualifiedNameProvider.getFullyQualifiedName(datamart).toString();
    String _plus = (_string + ".");
    String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
    String _plus_1 = (_plus + _firstUpper);
    String _plus_2 = (_plus_1 + "ServiceBinder");
    this.binderClassName = _plus_2;
    cls = this._jvmTypesBuilder.toClass(datamart, datamart.getName().toString().concat("ServiceBinder"));
    cls.setSimpleName(StringExtensions.toFirstUpper(cls.getSimpleName()));
    final Procedure1<JvmGenericType> _function_1 = (JvmGenericType it) -> {
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      JvmAnnotationReference _annotationRef = this._annotationTypesBuilder.annotationRef(SuppressWarnings.class, "serial");
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef);
      EList<JvmAnnotationReference> _annotations_1 = it.getAnnotations();
      JvmAnnotationReference _annotationRef_1 = this._annotationTypesBuilder.annotationRef(Component.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_1, _annotationRef_1);
      it.setPackageName(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).toString());
      this._jvmTypesBuilder.setFileHeader(it, this._jvmTypesBuilder.getDocumentation(datamart));
      this.toBinderFields(it, datamart);
      this.toBinderOperations(it, datamart);
    };
    acceptor.<JvmGenericType>accept(cls, _function_1);
    EList<DatamartDefinition> _definitions = datamart.getDefinitions();
    for (final DatamartDefinition definition : _definitions) {
      QualifiedName _fullyQualifiedName = this._iQualifiedNameProvider.getFullyQualifiedName(definition);
      String _plus_3 = (_fullyQualifiedName + IDataMart.DATAMART_CLASS_POSTFIX);
      final Procedure1<JvmGenericType> _function_2 = (JvmGenericType it) -> {
        EList<JvmAnnotationReference> _annotations = it.getAnnotations();
        JvmAnnotationReference _annotationRef = this._annotationTypesBuilder.annotationRef(SuppressWarnings.class, "serial");
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef);
        it.setPackageName(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).toString());
        DatamartSource _source = definition.getSource();
        if ((_source instanceof DatamartEntity)) {
          EList<JvmTypeReference> _superTypes = it.getSuperTypes();
          JvmTypeReference _typeRef = this._typeReferenceBuilder.typeRef(AEntityDatamart.class);
          this._jvmTypesBuilder.<JvmTypeReference>operator_add(_superTypes, _typeRef);
        }
        DatamartSource _source_1 = definition.getSource();
        if ((_source_1 instanceof DatamartCube)) {
          EList<JvmTypeReference> _superTypes_1 = it.getSuperTypes();
          JvmTypeReference _typeRef_1 = this._typeReferenceBuilder.typeRef(ACubeDatamart.class);
          this._jvmTypesBuilder.<JvmTypeReference>operator_add(_superTypes_1, _typeRef_1);
        }
        DatamartSource _source_2 = definition.getSource();
        if ((_source_2 instanceof DatamartTask)) {
          EList<JvmTypeReference> _superTypes_2 = it.getSuperTypes();
          JvmTypeReference _typeRef_2 = this._typeReferenceBuilder.typeRef(ATaskDatamart.class);
          this._jvmTypesBuilder.<JvmTypeReference>operator_add(_superTypes_2, _typeRef_2);
        }
        this.toFields(it, definition);
        this.toGetterSetter(it, definition);
        this.toOperations(it, definition, datamart);
      };
      acceptor.<JvmGenericType>accept(this._jvmTypesBuilder.toClass(definition, _plus_3), _function_2);
    }
  }
  
  public void toTestCalls(final JvmGenericType type, final DatamartPackage datamart) {
    JvmOperation operation = null;
    EList<DatamartDefinition> _definitions = datamart.getDefinitions();
    for (final DatamartDefinition definition : _definitions) {
      {
        final Procedure1<JvmOperation> _function = (JvmOperation it) -> {
          EList<JvmAnnotationReference> _annotations = it.getAnnotations();
          JvmAnnotationReference _annotationRef = this._annotationTypesBuilder.annotationRef(Test.class);
          this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef);
          final Procedure1<ITreeAppendable> _function_1 = (ITreeAppendable it_1) -> {
            StringConcatenation _builder = new StringConcatenation();
            String _allTestcalls = this.getAllTestcalls(definition);
            _builder.append(_allTestcalls);
            it_1.append(_builder);
          };
          this._jvmTypesBuilder.setBody(it, _function_1);
        };
        operation = this._jvmTypesBuilder.toMethod(definition, "test".concat(definition.getName()), this._typeReferenceBuilder.typeRef(Void.TYPE), _function);
        EList<JvmMember> _members = type.getMembers();
        this._jvmTypesBuilder.<JvmOperation>operator_add(_members, operation);
      }
    }
  }
  
  public String getAllTestcalls(final DatamartDefinition definition) {
    String body = "";
    StringConcatenation _builder = new StringConcatenation();
    _builder.append(body);
    _builder.newLineIfNotEmpty();
    String _name = definition.getName();
    _builder.append(_name);
    _builder.append("Datamart ");
    String _firstLower = StringExtensions.toFirstLower(definition.getName());
    _builder.append(_firstLower);
    _builder.append("Datamart = new ");
    String _name_1 = definition.getName();
    _builder.append(_name_1);
    _builder.append("Datamart();");
    _builder.newLineIfNotEmpty();
    String _firstLower_1 = StringExtensions.toFirstLower(definition.getName());
    _builder.append(_firstLower_1);
    _builder.append("Datamart.setUser(new User(\"");
    _builder.append(IUserAccessService.ADMINISTRATOR);
    _builder.append("\"));");
    _builder.newLineIfNotEmpty();
    _builder.append(body);
    String _firstLower_2 = StringExtensions.toFirstLower(definition.getName());
    _builder.append(_firstLower_2);
    _builder.append("Datamart.Test");
    String _name_2 = definition.getName();
    _builder.append(_name_2);
    _builder.append("();");
    _builder.newLineIfNotEmpty();
    body = _builder.toString();
    return body;
  }
  
  public void toBinderFields(final JvmDeclaredType type, final DatamartPackage datamart) {
    JvmField field = null;
    final Procedure1<JvmField> _function = (JvmField it) -> {
      final Procedure1<ITreeAppendable> _function_1 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("org.slf4j.LoggerFactory.getLogger(\"servicebinder\")");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setInitializer(it, _function_1);
    };
    field = this._jvmTypesBuilder.toField(datamart, "log", this._typeReferenceBuilder.typeRef(Logger.class), _function);
    field.setStatic(true);
    field.setVisibility(JvmVisibility.PRIVATE);
    EList<JvmMember> _members = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members, field);
    field = this._jvmTypesBuilder.toField(datamart, "persistenceService", this._typeReferenceBuilder.typeRef(IPersistenceService.class));
    field.setStatic(true);
    field.setVisibility(JvmVisibility.PRIVATE);
    EList<JvmMember> _members_1 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_1, field);
    field = this._jvmTypesBuilder.toField(datamart, "bpmEngine", this._typeReferenceBuilder.typeRef(IBPMEngine.class));
    field.setStatic(true);
    field.setVisibility(JvmVisibility.PRIVATE);
    EList<JvmMember> _members_2 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_2, field);
    field = this._jvmTypesBuilder.toField(datamart, "userAccessService", this._typeReferenceBuilder.typeRef(IUserAccessService.class));
    field.setStatic(true);
    field.setVisibility(JvmVisibility.PRIVATE);
    EList<JvmMember> _members_3 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_3, field);
    field = this._jvmTypesBuilder.toField(datamart, "dslMetadataService", this._typeReferenceBuilder.typeRef(IDSLMetadataService.class));
    field.setStatic(true);
    field.setVisibility(JvmVisibility.PRIVATE);
    EList<JvmMember> _members_4 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_4, field);
    field = this._jvmTypesBuilder.toField(datamart, "taskClient", this._typeReferenceBuilder.typeRef(IBPMTaskClient.class));
    field.setStatic(true);
    field.setVisibility(JvmVisibility.PRIVATE);
    EList<JvmMember> _members_5 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_5, field);
  }
  
  public void toBinderOperations(final JvmDeclaredType type, final DatamartPackage datamart) {
    EList<JvmMember> _members = type.getMembers();
    final Procedure1<JvmOperation> _function = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setStatic(true);
      final Procedure1<ITreeAppendable> _function_1 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return persistenceService;");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_1);
    };
    JvmOperation _method = this._jvmTypesBuilder.toMethod(datamart, "getPersistenceService", this._typeReferenceBuilder.typeRef(IPersistenceService.class), _function);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members, _method);
    EList<JvmMember> _members_1 = type.getMembers();
    final Procedure1<JvmOperation> _function_1 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setStatic(true);
      final Procedure1<ITreeAppendable> _function_2 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return bpmEngine;");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_2);
    };
    JvmOperation _method_1 = this._jvmTypesBuilder.toMethod(datamart, "getBpmEngine", this._typeReferenceBuilder.typeRef(IBPMEngine.class), _function_1);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_1, _method_1);
    EList<JvmMember> _members_2 = type.getMembers();
    final Procedure1<JvmOperation> _function_2 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setStatic(true);
      final Procedure1<ITreeAppendable> _function_3 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return userAccessService;");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_3);
    };
    JvmOperation _method_2 = this._jvmTypesBuilder.toMethod(datamart, "getUserAccessService", this._typeReferenceBuilder.typeRef(IUserAccessService.class), _function_2);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_2, _method_2);
    EList<JvmMember> _members_3 = type.getMembers();
    final Procedure1<JvmOperation> _function_3 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setStatic(true);
      final Procedure1<ITreeAppendable> _function_4 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return dslMetadataService;");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_4);
    };
    JvmOperation _method_3 = this._jvmTypesBuilder.toMethod(datamart, "getDSLMetadataService", this._typeReferenceBuilder.typeRef(IDSLMetadataService.class), _function_3);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_3, _method_3);
    EList<JvmMember> _members_4 = type.getMembers();
    final Procedure1<JvmOperation> _function_4 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setStatic(true);
      final Procedure1<ITreeAppendable> _function_5 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return taskClient;");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_5);
    };
    JvmOperation _method_4 = this._jvmTypesBuilder.toMethod(datamart, "getTaskClient", this._typeReferenceBuilder.typeRef(IBPMTaskClient.class), _function_4);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_4, _method_4);
    EList<JvmMember> _members_5 = type.getMembers();
    final Procedure1<JvmOperation> _function_5 = (JvmOperation it) -> {
      JvmAnnotationReference annotationRef = this._annotationTypesBuilder.annotationRef(Reference.class);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "cardinality", ReferenceCardinality.MANDATORY);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "policy", ReferencePolicy.STATIC);
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, annotationRef);
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "persistenceService", this._typeReferenceBuilder.typeRef(IPersistenceService.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_6 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".persistenceService = persistenceService;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart PersistenceService bound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_6);
    };
    JvmOperation _method_5 = this._jvmTypesBuilder.toMethod(datamart, "bindPersistenceMethod", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_5);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_5, _method_5);
    EList<JvmMember> _members_6 = type.getMembers();
    final Procedure1<JvmOperation> _function_6 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "persistenceService", this._typeReferenceBuilder.typeRef(IPersistenceService.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_7 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".persistenceService = null;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart PersistenceService unbound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_7);
    };
    JvmOperation _method_6 = this._jvmTypesBuilder.toMethod(datamart, "unbindPersistenceMethod", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_6);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_6, _method_6);
    EList<JvmMember> _members_7 = type.getMembers();
    final Procedure1<JvmOperation> _function_7 = (JvmOperation it) -> {
      JvmAnnotationReference annotationRef = this._annotationTypesBuilder.annotationRef(Reference.class);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "cardinality", ReferenceCardinality.OPTIONAL);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "policy", ReferencePolicy.DYNAMIC);
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, annotationRef);
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "bpmEngine", this._typeReferenceBuilder.typeRef(IBPMEngine.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_8 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".bpmEngine = bpmEngine;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart BPMEngine bound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_8);
    };
    JvmOperation _method_7 = this._jvmTypesBuilder.toMethod(datamart, "bindBPMMethod", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_7);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_7, _method_7);
    EList<JvmMember> _members_8 = type.getMembers();
    final Procedure1<JvmOperation> _function_8 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "bpmEngine", this._typeReferenceBuilder.typeRef(IBPMEngine.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_9 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".bpmEngine = null;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart BPMEngine unbound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_9);
    };
    JvmOperation _method_8 = this._jvmTypesBuilder.toMethod(datamart, "unbindBPMMethod", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_8);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_8, _method_8);
    EList<JvmMember> _members_9 = type.getMembers();
    final Procedure1<JvmOperation> _function_9 = (JvmOperation it) -> {
      JvmAnnotationReference annotationRef = this._annotationTypesBuilder.annotationRef(Reference.class);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "cardinality", ReferenceCardinality.MANDATORY);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "policy", ReferencePolicy.STATIC);
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, annotationRef);
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "userAccessService", this._typeReferenceBuilder.typeRef(IUserAccessService.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_10 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".userAccessService = userAccessService;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart UserAccessService bound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_10);
    };
    JvmOperation _method_9 = this._jvmTypesBuilder.toMethod(datamart, "bindUserAccessMethod", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_9);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_9, _method_9);
    EList<JvmMember> _members_10 = type.getMembers();
    final Procedure1<JvmOperation> _function_10 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "userAccessService", this._typeReferenceBuilder.typeRef(IUserAccessService.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_11 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".userAccessService = null;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart UserAccessService unbound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_11);
    };
    JvmOperation _method_10 = this._jvmTypesBuilder.toMethod(datamart, "unbindUserAccessMethod", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_10);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_10, _method_10);
    EList<JvmMember> _members_11 = type.getMembers();
    final Procedure1<JvmOperation> _function_11 = (JvmOperation it) -> {
      JvmAnnotationReference annotationRef = this._annotationTypesBuilder.annotationRef(Reference.class);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "cardinality", ReferenceCardinality.MANDATORY);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "policy", ReferencePolicy.STATIC);
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, annotationRef);
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "dslMetadataService", this._typeReferenceBuilder.typeRef(IDSLMetadataService.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_12 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".dslMetadataService = dslMetadataService;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart DSLMetadataService bound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_12);
    };
    JvmOperation _method_11 = this._jvmTypesBuilder.toMethod(datamart, "bindDSLMetadataService", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_11);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_11, _method_11);
    EList<JvmMember> _members_12 = type.getMembers();
    final Procedure1<JvmOperation> _function_12 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "dslMetadataService", this._typeReferenceBuilder.typeRef(IDSLMetadataService.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_13 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".dslMetadataService = null;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart DSLMetadataService unbound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_13);
    };
    JvmOperation _method_12 = this._jvmTypesBuilder.toMethod(datamart, "unbindDSLMetadataService", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_12);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_12, _method_12);
    EList<JvmMember> _members_13 = type.getMembers();
    final Procedure1<JvmOperation> _function_13 = (JvmOperation it) -> {
      JvmAnnotationReference annotationRef = this._annotationTypesBuilder.annotationRef(Reference.class);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "cardinality", ReferenceCardinality.OPTIONAL);
      this._annotationExtension.addAnnAttr(annotationRef, datamart, "policy", ReferencePolicy.DYNAMIC);
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, annotationRef);
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "taskClient", this._typeReferenceBuilder.typeRef(IBPMTaskClient.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_14 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".taskClient = taskClient;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart BPMTaskClient bound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_14);
    };
    JvmOperation _method_13 = this._jvmTypesBuilder.toMethod(datamart, "bindTaskClient", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_13);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_13, _method_13);
    EList<JvmMember> _members_14 = type.getMembers();
    final Procedure1<JvmOperation> _function_14 = (JvmOperation it) -> {
      it.setVisibility(JvmVisibility.PUBLIC);
      it.setSynchronized(true);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(datamart, "taskClient", this._typeReferenceBuilder.typeRef(IBPMTaskClient.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_15 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
        String _plus = (_firstUpper + "ServiceBinder");
        _builder.append(_plus);
        _builder.append(".taskClient = null;");
        _builder.newLineIfNotEmpty();
        _builder.append("log.debug(\"Datamart BPMTaskClient unbound\");");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_15);
    };
    JvmOperation _method_14 = this._jvmTypesBuilder.toMethod(datamart, "unbindTaskClient", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_14);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_14, _method_14);
  }
  
  /**
   * <p>build the class variables for each datamart definition.</p>
   */
  public void toFields(final JvmDeclaredType type, final DatamartDefinition definition) {
    final HashMap<String, LAttribute> typesMap = CollectionLiterals.<String, LAttribute>newHashMap();
    final HashMap<String, LEntity> entityMap = CollectionLiterals.<String, LEntity>newHashMap();
    JvmField field = null;
    final Procedure1<JvmField> _function = (JvmField it) -> {
      final Procedure1<ITreeAppendable> _function_1 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("org.slf4j.LoggerFactory.getLogger(\"datamarts\")");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setInitializer(it, _function_1);
    };
    field = this._jvmTypesBuilder.toField(definition, "log", this._typeReferenceBuilder.typeRef(Logger.class), _function);
    field.setStatic(true);
    field.setVisibility(JvmVisibility.PRIVATE);
    EList<JvmMember> _members = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members, field);
    field = this._jvmTypesBuilder.toField(definition, "user", this._typeReferenceBuilder.typeRef(IUser.class));
    field.setVisibility(JvmVisibility.PRIVATE);
    EList<JvmMember> _members_1 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_1, field);
    DatamartSource _source = definition.getSource();
    if ((_source instanceof DatamartCube)) {
      final Procedure1<JvmField> _function_1 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_2 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("\"");
          String _createMDXStatement = this.createMDXStatement(definition);
          _builder.append(_createMDXStatement);
          _builder.append("\"");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_2);
      };
      field = this._jvmTypesBuilder.toField(definition, "statement", this._typeReferenceBuilder.typeRef(String.class), _function_1);
      EList<JvmMember> _members_2 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_2, field);
      final Procedure1<JvmField> _function_2 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_3 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("null");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_3);
      };
      field = this._jvmTypesBuilder.toField(definition, "connection", this._typeReferenceBuilder.typeRef(RolapConnection.class), _function_2);
      EList<JvmMember> _members_3 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_3, field);
      final Procedure1<JvmField> _function_3 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_4 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("new DatamartDtoMapper()");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_4);
      };
      field = this._jvmTypesBuilder.toField(definition, "datamartDtoMapper", this._typeReferenceBuilder.typeRef(DatamartDtoMapper.class), _function_3);
      EList<JvmMember> _members_4 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_4, field);
    }
    DatamartSource _source_1 = definition.getSource();
    if ((_source_1 instanceof DatamartEntity)) {
      final Procedure1<JvmField> _function_4 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_5 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("new HashMap<String, Map<String, String>>()");
          DatamartSource _source_2 = definition.getSource();
          String _createFilterAttributeProperties = this.createFilterAttributeProperties(((DatamartEntity) _source_2));
          _builder.append(_createFilterAttributeProperties);
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_5);
      };
      field = this._jvmTypesBuilder.toField(definition, "dateFilterAttributeProperties", 
        this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
          this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
            this._typeReferenceBuilder.typeRef(String.class))), _function_4);
      field.setVisibility(JvmVisibility.PRIVATE);
      EList<JvmMember> _members_5 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_5, field);
      final Procedure1<JvmField> _function_5 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_6 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("\"");
          DatamartSource _source_2 = definition.getSource();
          String _createSQLStatements = this.createSQLStatements(definition, ((DatamartEntity) _source_2), typesMap, entityMap);
          _builder.append(_createSQLStatements);
          _builder.append("\"");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_6);
      };
      field = this._jvmTypesBuilder.toField(definition, "statement", 
        this._typeReferenceBuilder.typeRef(String.class), _function_5);
      EList<JvmMember> _members_6 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_6, field);
      final Procedure1<JvmField> _function_6 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_7 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append(this.datamartDtoMapper);
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_7);
      };
      field = this._jvmTypesBuilder.toField(definition, "datamartDtoMapper", this._typeReferenceBuilder.typeRef(DatamartDtoMapper.class), _function_6);
      EList<JvmMember> _members_7 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_7, field);
      final Procedure1<JvmField> _function_7 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_8 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("null");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_8);
      };
      field = this._jvmTypesBuilder.toField(definition, "connection", this._typeReferenceBuilder.typeRef(Connection.class), _function_7);
      EList<JvmMember> _members_8 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_8, field);
      final Procedure1<JvmField> _function_8 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_9 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("new HashMap<Integer,ArrayList<String>>() ");
          String _createAxisMap = this.createAxisMap(definition, entityMap);
          _builder.append(_createAxisMap);
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_9);
      };
      field = this._jvmTypesBuilder.toField(definition, "axisMap", 
        this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(Integer.class), 
          this._typeReferenceBuilder.typeRef(ArrayList.class, this._typeReferenceBuilder.typeRef(String.class))), _function_8);
      EList<JvmMember> _members_9 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_9, field);
      final Procedure1<JvmField> _function_9 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_10 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("new HashMap<String,String>() ");
          String _createAliasMap = this.createAliasMap(definition, entityMap);
          _builder.append(_createAliasMap);
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_10);
      };
      field = this._jvmTypesBuilder.toField(definition, "aliasMap", 
        this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
          this._typeReferenceBuilder.typeRef(String.class)), _function_9);
      EList<JvmMember> _members_10 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_10, field);
    }
    DatamartSource _source_2 = definition.getSource();
    if ((_source_2 instanceof DatamartTask)) {
      final Procedure1<JvmField> _function_10 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_11 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("new HashMap<Integer,ArrayList<String>>() ");
          String _createAxisMap = this.createAxisMap(definition, entityMap);
          _builder.append(_createAxisMap);
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_11);
      };
      field = this._jvmTypesBuilder.toField(definition, "axisMap", 
        this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(Integer.class), 
          this._typeReferenceBuilder.typeRef(ArrayList.class, this._typeReferenceBuilder.typeRef(String.class))), _function_10);
      EList<JvmMember> _members_11 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_11, field);
      final Procedure1<JvmField> _function_11 = (JvmField it) -> {
        final Procedure1<ITreeAppendable> _function_12 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("new DatamartDtoMapper()");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setInitializer(it, _function_12);
      };
      field = this._jvmTypesBuilder.toField(definition, "datamartDtoMapper", this._typeReferenceBuilder.typeRef(DatamartDtoMapper.class), _function_11);
      EList<JvmMember> _members_12 = type.getMembers();
      this._jvmTypesBuilder.<JvmField>operator_add(_members_12, field);
    }
    final Procedure1<JvmField> _function_12 = (JvmField it) -> {
      final Procedure1<ITreeAppendable> _function_13 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("new HashMap<String,EType>() ");
        String _createIdMap = this.createIdMap(definition);
        _builder.append(_createIdMap);
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setInitializer(it, _function_13);
    };
    field = this._jvmTypesBuilder.toField(definition, "idMap", 
      this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
        this._typeReferenceBuilder.typeRef(IDataMart.EType.class)), _function_12);
    EList<JvmMember> _members_13 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_13, field);
    final Procedure1<JvmField> _function_13 = (JvmField it) -> {
      final Procedure1<ITreeAppendable> _function_14 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("new ArrayList<DatamartPrimary<?>>() ");
        String _createPrimaryList = this.createPrimaryList(definition);
        _builder.append(_createPrimaryList);
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setInitializer(it, _function_14);
    };
    field = this._jvmTypesBuilder.toField(definition, "primaryList", 
      this._typeReferenceBuilder.typeRef(ArrayList.class, 
        this._typeReferences.getTypeForName(DatamartPrimary.class, definition, this._typeReferenceBuilder.wildcard())), _function_13);
    EList<JvmMember> _members_14 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_14, field);
    final Procedure1<JvmField> _function_14 = (JvmField it) -> {
      final Procedure1<ITreeAppendable> _function_15 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("new HashMap<String,EType>() ");
        String _createTypesMaps = this.createTypesMaps(definition, typesMap);
        _builder.append(_createTypesMaps);
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setInitializer(it, _function_15);
    };
    field = this._jvmTypesBuilder.toField(definition, "typesMap", 
      this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
        this._typeReferenceBuilder.typeRef(IDataMart.EType.class)), _function_14);
    EList<JvmMember> _members_15 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_15, field);
    final Procedure1<JvmField> _function_15 = (JvmField it) -> {
      final Procedure1<ITreeAppendable> _function_16 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("new HashMap<String, String>() ");
        String _createTypesProps = this.createTypesProps(definition, typesMap);
        _builder.append(_createTypesProps);
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setInitializer(it, _function_16);
    };
    field = this._jvmTypesBuilder.toField(definition, "typesProp", 
      this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
        this._typeReferenceBuilder.typeRef(String.class)), _function_15);
    EList<JvmMember> _members_16 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_16, field);
    final Procedure1<JvmField> _function_16 = (JvmField it) -> {
      final Procedure1<ITreeAppendable> _function_17 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("new HashMap<String,String>()");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setInitializer(it, _function_17);
    };
    field = this._jvmTypesBuilder.toField(definition, "resultAttributes", 
      this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
        this._typeReferenceBuilder.typeRef(String.class)), _function_16);
    EList<JvmMember> _members_17 = type.getMembers();
    this._jvmTypesBuilder.<JvmField>operator_add(_members_17, field);
  }
  
  /**
   * <p>build the getters and setters from class variables of datamart definition.</p>
   */
  public void toGetterSetter(final JvmDeclaredType type, final DatamartDefinition definition) {
    JvmOperation operation = null;
    operation = this._jvmTypesBuilder.toGetter(definition, "idMap", 
      this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
        this._typeReferenceBuilder.typeRef(IDataMart.EType.class)));
    operation.setVisibility(JvmVisibility.PUBLIC);
    EList<JvmMember> _members = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members, operation);
    operation = this._jvmTypesBuilder.toGetter(definition, "primaryList", 
      this._typeReferenceBuilder.typeRef(List.class, 
        this._typeReferences.getTypeForName(DatamartPrimary.class, definition, this._typeReferenceBuilder.wildcard())));
    operation.setVisibility(JvmVisibility.PUBLIC);
    EList<JvmMember> _members_1 = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_1, operation);
    if (((definition.getSource() instanceof DatamartEntity) || (definition.getSource() instanceof DatamartTask))) {
      operation = this._jvmTypesBuilder.toGetter(definition, "axisMap", 
        this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(Integer.class), 
          this._typeReferenceBuilder.typeRef(ArrayList.class, this._typeReferenceBuilder.typeRef(String.class))));
      operation.setVisibility(JvmVisibility.PUBLIC);
      EList<JvmMember> _members_2 = type.getMembers();
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_2, operation);
    }
    DatamartSource _source = definition.getSource();
    if ((_source instanceof DatamartEntity)) {
      operation = this._jvmTypesBuilder.toGetter(definition, "aliasMap", 
        this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
          this._typeReferenceBuilder.typeRef(String.class)));
      operation.setVisibility(JvmVisibility.PUBLIC);
      EList<JvmMember> _members_3 = type.getMembers();
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_3, operation);
    }
    operation = this._jvmTypesBuilder.toGetter(definition, "typesProp", 
      this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
        this._typeReferenceBuilder.typeRef(String.class)));
    operation.setVisibility(JvmVisibility.PUBLIC);
    EList<JvmMember> _members_4 = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_4, operation);
    operation = this._jvmTypesBuilder.toGetter(definition, "user", this._typeReferenceBuilder.typeRef(IUser.class));
    operation.setVisibility(JvmVisibility.PUBLIC);
    EList<JvmMember> _members_5 = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_5, operation);
    operation = this._jvmTypesBuilder.toSetter(definition, "user", this._typeReferenceBuilder.typeRef(IUser.class));
    operation.setVisibility(JvmVisibility.PUBLIC);
    EList<JvmMember> _members_6 = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_6, operation);
  }
  
  /**
   * <p>build the methods separately for cube, entity and task or SQL and MDX respective.</p>
   */
  public void toOperations(final JvmDeclaredType type, final DatamartDefinition definition, final DatamartPackage datamart) {
    JvmOperation operation = null;
    final Procedure1<JvmOperation> _function = (JvmOperation it) -> {
      final Procedure1<ITreeAppendable> _function_1 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return new ArrayList<DatamartFilter>() ");
        String _createFilterMap = this.createFilterMap(definition);
        _builder.append(_createFilterMap);
        _builder.append(";");
        _builder.newLineIfNotEmpty();
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_1);
    };
    operation = this._jvmTypesBuilder.toMethod(definition, "initializeFilterMap", 
      this._typeReferenceBuilder.typeRef(ArrayList.class, this._typeReferenceBuilder.typeRef(DatamartFilter.class)), _function);
    operation.setVisibility(JvmVisibility.PROTECTED);
    EList<JvmMember> _members = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members, operation);
    final Procedure1<JvmOperation> _function_1 = (JvmOperation it) -> {
      final Procedure1<ITreeAppendable> _function_2 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return \"");
        String _createPrimaryFilterId = this.createPrimaryFilterId(definition);
        _builder.append(_createPrimaryFilterId);
        _builder.append("\";");
        _builder.newLineIfNotEmpty();
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_2);
    };
    operation = this._jvmTypesBuilder.toMethod(definition, "getPrimaryFilterId", this._typeReferenceBuilder.typeRef(String.class), _function_1);
    operation.setVisibility(JvmVisibility.PUBLIC);
    EList<JvmMember> _members_1 = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_1, operation);
    final Procedure1<JvmOperation> _function_2 = (JvmOperation it) -> {
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      JvmAnnotationReference _annotationRef = this._annotationTypesBuilder.annotationRef(Override.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef);
      final Procedure1<ITreeAppendable> _function_3 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        {
          DatamartSource _source = definition.getSource();
          if ((_source instanceof DatamartCube)) {
            _builder.append("try {");
            _builder.newLine();
            _builder.append("\t");
            _builder.append(this.binderClassName, "\t");
            _builder.append(".getPersistenceService().clearCubeCache(");
            _builder.append(this.binderClassName, "\t");
            _builder.append(".getPersistenceService().getMondrianConnection(getPersistenceUnit(), \"");
            DatamartSource _source_1 = definition.getSource();
            EObject _eContainer = ((DatamartCube) _source_1).getCubeRef().eContainer();
            QualifiedName _fullyQualifiedName = this._iQualifiedNameProvider.getFullyQualifiedName(((CubePackage) _eContainer));
            _builder.append(_fullyQualifiedName, "\t");
            _builder.append("\"), \"");
            DatamartSource _source_2 = definition.getSource();
            String _name = ((DatamartCube) _source_2).getCubeRef().getName();
            _builder.append(_name, "\t");
            _builder.append("\");");
            _builder.newLineIfNotEmpty();
            _builder.append("} catch (SQLException e) {");
            _builder.newLine();
            _builder.append("\t");
            _builder.append("log.error(\"{}\", e);");
            _builder.newLine();
            _builder.append("};");
            _builder.newLine();
            _builder.append("\t\t\t\t");
          }
        }
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_3);
    };
    operation = this._jvmTypesBuilder.toMethod(definition, "clearCache", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_2);
    EList<JvmMember> _members_2 = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_2, operation);
    final Procedure1<JvmOperation> _function_3 = (JvmOperation it) -> {
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      JvmAnnotationReference _annotationRef = this._annotationTypesBuilder.annotationRef(Override.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(definition, "attributeName", this._typeReferenceBuilder.typeRef(String.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_4 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return resultAttributes.get(attributeName);");
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_4);
    };
    operation = this._jvmTypesBuilder.toMethod(definition, "getResultAttribute", this._typeReferenceBuilder.typeRef(String.class), _function_3);
    EList<JvmMember> _members_3 = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_3, operation);
    final Procedure1<JvmOperation> _function_4 = (JvmOperation it) -> {
      final Procedure1<ITreeAppendable> _function_5 = (ITreeAppendable it_1) -> {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("return typesMap;");
        _builder.newLine();
        it_1.append(_builder);
      };
      this._jvmTypesBuilder.setBody(it, _function_5);
    };
    operation = this._jvmTypesBuilder.toMethod(definition, "getTypesMap", 
      this._typeReferenceBuilder.typeRef(Map.class, this._typeReferenceBuilder.typeRef(String.class), 
        this._typeReferenceBuilder.typeRef(IDataMart.EType.class)), _function_4);
    operation.setVisibility(JvmVisibility.PUBLIC);
    EList<JvmMember> _members_4 = type.getMembers();
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members_4, operation);
    DatamartSource _source = definition.getSource();
    if ((_source instanceof DatamartTask)) {
      EList<JvmMember> _members_5 = type.getMembers();
      final Procedure1<JvmOperation> _function_5 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_6 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("return null;");
          _builder.newLine();
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setBody(it, _function_6);
      };
      JvmOperation _method = this._jvmTypesBuilder.toMethod(definition, "getPersistenceUnit", this._typeReferenceBuilder.typeRef(String.class), _function_5);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_5, _method);
      EList<JvmMember> _members_6 = type.getMembers();
      final Procedure1<JvmOperation> _function_6 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_7 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("return null;");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setBody(it, _function_7);
      };
      JvmOperation _method_1 = this._jvmTypesBuilder.toMethod(definition, "connect", this._typeReferenceBuilder.typeRef(Connection.class), _function_6);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_6, _method_1);
      EList<JvmMember> _members_7 = type.getMembers();
      final Procedure1<JvmOperation> _function_7 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_8 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setBody(it, _function_8);
      };
      JvmOperation _method_2 = this._jvmTypesBuilder.toMethod(definition, "disconnect", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_7);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_7, _method_2);
      final Procedure1<JvmOperation> _function_8 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_9 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("for (DatamartFilter filter : getFilters()) {");
          _builder.newLine();
          _builder.append("\t");
          _builder.append("filter.clearData();");
          _builder.newLine();
          _builder.append("\t");
          _builder.append("if (filter.getName().equals(\"Groups\")) {");
          _builder.newLine();
          _builder.append("\t\t");
          _builder.append("for(String grp : ");
          _builder.append(this.binderClassName, "\t\t");
          _builder.append(".getBpmEngine().getGroups()) {");
          _builder.newLineIfNotEmpty();
          _builder.append("\t\t\t");
          _builder.append("filter.addItem(grp, true);");
          _builder.newLine();
          _builder.append("\t\t");
          _builder.append("}");
          _builder.newLine();
          _builder.append("\t");
          _builder.append("}");
          _builder.newLine();
          _builder.append("\t");
          _builder.append("if (filter.getName().equals(\"Users\")) {");
          _builder.newLine();
          _builder.append("\t\t");
          _builder.append("for(String usr : ");
          _builder.append(this.binderClassName, "\t\t");
          _builder.append(".getBpmEngine().getUsers()) {");
          _builder.newLineIfNotEmpty();
          _builder.append("\t\t\t");
          _builder.append("filter.addItem(usr, true);");
          _builder.newLine();
          _builder.append("\t\t");
          _builder.append("}");
          _builder.newLine();
          _builder.append("\t");
          _builder.append("}");
          _builder.newLine();
          _builder.append("}");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setBody(it, _function_9);
      };
      operation = this._jvmTypesBuilder.toMethod(definition, "renderFilters", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_8);
      EList<JvmMember> _members_8 = type.getMembers();
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_8, operation);
      EList<JvmMember> _members_9 = type.getMembers();
      final Procedure1<JvmOperation> _function_9 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_10 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("if(user != null) {");
          _builder.newLine();
          _builder.append("\t");
          _builder.append("List<BPMTaskSummary> tasks = ");
          String _firstUpper = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
          String _plus = (_firstUpper + "ServiceBinder");
          _builder.append(_plus, "\t");
          _builder.append(".getTaskClient().getUserTaskList(user, false);");
          _builder.newLineIfNotEmpty();
          _builder.append("\t");
          _builder.append("if (tasks == null || tasks.size() == 0) {");
          _builder.newLine();
          _builder.append("\t\t");
          _builder.append("tasks = ");
          String _firstUpper_1 = StringExtensions.toFirstUpper(this._iQualifiedNameProvider.getFullyQualifiedName(datamart).getLastSegment());
          String _plus_1 = (_firstUpper_1 + "ServiceBinder");
          _builder.append(_plus_1, "\t\t");
          _builder.append(".getTaskClient().getUserTaskList(user, true);");
          _builder.newLineIfNotEmpty();
          _builder.append("\t");
          _builder.append("}");
          _builder.newLine();
          _builder.append("\t");
          _builder.append("return (new DerivedCellSet(new SqlCellSet(tasks, getAxisMap()), null,");
          _builder.newLine();
          _builder.append("\t\t");
          _builder.append(this.binderClassName, "\t\t");
          _builder.append(".getDSLMetadataService(),");
          _builder.newLineIfNotEmpty();
          _builder.append("\t\t");
          _builder.append("user));");
          _builder.newLine();
          _builder.append("}");
          _builder.newLine();
          _builder.append("return null;");
          _builder.newLine();
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setBody(it, _function_10);
      };
      JvmOperation _method_3 = this._jvmTypesBuilder.toMethod(definition, "getResults", this._typeReferenceBuilder.typeRef(DerivedCellSet.class), _function_9);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_9, _method_3);
      EList<JvmMember> _members_10 = type.getMembers();
      final Procedure1<JvmOperation> _function_10 = (JvmOperation it) -> {
        EList<JvmFormalParameter> _parameters = it.getParameters();
        JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(definition, "client", this._typeReferenceBuilder.typeRef(IBPMTaskClient.class));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        EList<JvmFormalParameter> _parameters_1 = it.getParameters();
        JvmFormalParameter _parameter_1 = this._jvmTypesBuilder.toParameter(definition, "taskId", this._typeReferenceBuilder.typeRef(Long.class));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters_1, _parameter_1);
        final Procedure1<ITreeAppendable> _function_11 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("List<BPMTaskSummary> myTasks = new ArrayList<>(); ");
          _builder.newLine();
          _builder.append("myTasks.add(client.getUserTask(taskId, user));");
          _builder.newLine();
          _builder.append("return (new DerivedCellSet(new SqlCellSet(myTasks, getAxisMap()), null,");
          _builder.newLine();
          _builder.append("\t");
          _builder.append(this.binderClassName, "\t");
          _builder.append(".getDSLMetadataService(), user));");
          it_1.append(_builder);
        };
        this._jvmTypesBuilder.setBody(it, _function_11);
      };
      JvmOperation _method_4 = this._jvmTypesBuilder.toMethod(definition, "getResultsByTaskId", this._typeReferenceBuilder.typeRef(DerivedCellSet.class), _function_10);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_10, _method_4);
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("Test");
      String _name = definition.getName();
      _builder.append(_name);
      final Procedure1<JvmOperation> _function_11 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_12 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_1 = new StringConcatenation();
          _builder_1.append("renderFilters();");
          _builder_1.newLine();
          _builder_1.append("org.junit.Assert.assertNotNull(getResults());");
          it_1.append(_builder_1);
        };
        this._jvmTypesBuilder.setBody(it, _function_12);
      };
      operation = this._jvmTypesBuilder.toMethod(definition, _builder.toString(), this._typeReferenceBuilder.typeRef(String.class), _function_11);
      operation.setReturnType(this._typeReferenceBuilder.typeRef(Void.TYPE));
      JvmAnnotationReference annRef = this._annotationTypesBuilder.annotationRef(Test.class);
      operation.getAnnotations().add(annRef);
      EList<JvmMember> _members_11 = type.getMembers();
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_11, operation);
    }
    DatamartSource _source_1 = definition.getSource();
    if ((_source_1 instanceof DatamartCube)) {
      DatamartSource _source_2 = definition.getSource();
      CubeTypeEntity _cubeTypeEntity = ((DatamartCube) _source_2).getCubeRef().getCubeTypeEntity();
      boolean _tripleNotEquals = (_cubeTypeEntity != null);
      if (_tripleNotEquals) {
        DatamartSource _source_3 = definition.getSource();
        final LEntity entity = ((DatamartCube) _source_3).getCubeRef().getCubeTypeEntity().getEntityRef().getEntityValue();
        EList<JvmMember> _members_12 = type.getMembers();
        final Procedure1<JvmOperation> _function_12 = (JvmOperation it) -> {
          final Procedure1<ITreeAppendable> _function_13 = (ITreeAppendable it_1) -> {
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append("return \"");
            String _persistenceUnit = ((LEntity) entity).getPersistenceUnit();
            _builder_1.append(_persistenceUnit);
            _builder_1.append("\";");
            _builder_1.newLineIfNotEmpty();
            it_1.append(_builder_1);
          };
          this._jvmTypesBuilder.setBody(it, _function_13);
        };
        JvmOperation _method_5 = this._jvmTypesBuilder.toMethod(definition, "getPersistenceUnit", this._typeReferenceBuilder.typeRef(String.class), _function_12);
        this._jvmTypesBuilder.<JvmOperation>operator_add(_members_12, _method_5);
        EList<JvmMember> _members_13 = type.getMembers();
        final Procedure1<JvmOperation> _function_13 = (JvmOperation it) -> {
          final Procedure1<ITreeAppendable> _function_14 = (ITreeAppendable it_1) -> {
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append("if (connection == null) {   \t\t\t");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("try {");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("connection = ");
            _builder_1.append(this.binderClassName, "\t\t");
            _builder_1.append(".getPersistenceService().getMondrianConnection(getPersistenceUnit(), \"");
            DatamartSource _source_4 = definition.getSource();
            EObject _eContainer = ((DatamartCube) _source_4).getCubeRef().eContainer();
            QualifiedName _fullyQualifiedName = this._iQualifiedNameProvider.getFullyQualifiedName(((CubePackage) _eContainer));
            _builder_1.append(_fullyQualifiedName, "\t\t");
            _builder_1.append("\");");
            _builder_1.newLineIfNotEmpty();
            _builder_1.append("\t\t");
            _builder_1.append(this.binderClassName, "\t\t");
            _builder_1.append(".getPersistenceService().registerPersistenceUnit(getPersistenceUnit(), ");
            QualifiedName _fullyQualifiedName_1 = this._iQualifiedNameProvider.getFullyQualifiedName(((LEntity) entity));
            _builder_1.append(_fullyQualifiedName_1, "\t\t");
            _builder_1.append(".class);");
            _builder_1.newLineIfNotEmpty();
            _builder_1.append("\t");
            _builder_1.append("} catch (SQLException e) {");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("log.error(\"{}\", e);");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("return (connection);");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("}");
            _builder_1.newLine();
            _builder_1.append("}");
            _builder_1.newLine();
            _builder_1.append("return (connection);");
            it_1.append(_builder_1);
          };
          this._jvmTypesBuilder.setBody(it, _function_14);
        };
        JvmOperation _method_6 = this._jvmTypesBuilder.toMethod(definition, "connect", this._typeReferenceBuilder.typeRef(RolapConnection.class), _function_13);
        this._jvmTypesBuilder.<JvmOperation>operator_add(_members_13, _method_6);
        EList<JvmMember> _members_14 = type.getMembers();
        final Procedure1<JvmOperation> _function_14 = (JvmOperation it) -> {
          final Procedure1<ITreeAppendable> _function_15 = (ITreeAppendable it_1) -> {
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append("if (connection != null) {");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("connection.close();");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("connection = null;");
            _builder_1.newLine();
            _builder_1.append("}");
            it_1.append(_builder_1);
          };
          this._jvmTypesBuilder.setBody(it, _function_15);
        };
        JvmOperation _method_7 = this._jvmTypesBuilder.toMethod(definition, "disconnect", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_14);
        this._jvmTypesBuilder.<JvmOperation>operator_add(_members_14, _method_7);
        final Procedure1<JvmOperation> _function_15 = (JvmOperation it) -> {
          final Procedure1<ITreeAppendable> _function_16 = (ITreeAppendable it_1) -> {
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append("connect();");
            _builder_1.newLine();
            _builder_1.append("if (connection != null) {");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("for (DatamartFilter filter : getFilters()) {");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("filter.clearData();");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("DerivedCellSet cellSet = new DerivedCellSet(");
            _builder_1.append(this.binderClassName, "\t\t");
            _builder_1.append(".getPersistenceService().sendQuery(connection,getVendorSql(filter)),");
            _builder_1.newLineIfNotEmpty();
            _builder_1.append("\t\t\t");
            _builder_1.append(this.binderClassName, "\t\t\t");
            _builder_1.append(".getDSLMetadataService(),");
            _builder_1.newLineIfNotEmpty();
            _builder_1.append("\t\t\t");
            _builder_1.append("user);");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("List<DerivedAxis> axes = cellSet.getAxes();");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("DerivedAxis columnsAxis = axes.get(Axis.COLUMNS.ordinal());");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("for (DerivedPosition position : columnsAxis.getPositions()) {");
            _builder_1.newLine();
            _builder_1.append("\t\t\t");
            _builder_1.append("DerivedMember measure = position.getMembers().get(0);");
            _builder_1.newLine();
            _builder_1.append("\t\t\t");
            _builder_1.append("filter.addOlapItem(measure.getHierarchy().getName(), measure.getUniqueName());");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("}");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("}");
            _builder_1.newLine();
            _builder_1.append("}");
            _builder_1.newLine();
            _builder_1.append("disconnect();");
            it_1.append(_builder_1);
          };
          this._jvmTypesBuilder.setBody(it, _function_16);
        };
        operation = this._jvmTypesBuilder.toMethod(definition, "renderFilters", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_15);
        EList<JvmMember> _members_15 = type.getMembers();
        this._jvmTypesBuilder.<JvmOperation>operator_add(_members_15, operation);
        final Procedure1<JvmOperation> _function_16 = (JvmOperation it) -> {
          final Procedure1<ITreeAppendable> _function_17 = (ITreeAppendable it_1) -> {
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append("String filteredStatement = statement;");
            _builder_1.newLine();
            _builder_1.append("computeConditions();");
            _builder_1.newLine();
            _builder_1.append("for (DatamartFilter filter : getFilters()) {");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("if(filter.getCondition() != null) {");
            _builder_1.newLine();
            _builder_1.append("\t\t");
            _builder_1.append("filteredStatement = filteredStatement.replace(filter.getDecoratedName(), filter.getCondition().replace(\"\'\",\"\"));");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("}");
            _builder_1.newLine();
            _builder_1.append("}");
            _builder_1.newLine();
            _builder_1.append("filteredStatement = filteredStatement.replace(\"<empty>,\",\"\").replace(\",<empty>\",\"\").replace(\"<empty>\",\"\");");
            _builder_1.newLine();
            _builder_1.append("log.debug(\"");
            String _name_1 = definition.getName();
            _builder_1.append(_name_1);
            _builder_1.append(":\"+filteredStatement);");
            _builder_1.newLineIfNotEmpty();
            _builder_1.append("return filteredStatement;");
            it_1.append(_builder_1);
          };
          this._jvmTypesBuilder.setBody(it, _function_17);
        };
        operation = this._jvmTypesBuilder.toMethod(definition, "applyFilters", this._typeReferenceBuilder.typeRef(String.class), _function_16);
        EList<JvmMember> _members_16 = type.getMembers();
        this._jvmTypesBuilder.<JvmOperation>operator_add(_members_16, operation);
        EList<JvmMember> _members_17 = type.getMembers();
        final Procedure1<JvmOperation> _function_17 = (JvmOperation it) -> {
          EList<JvmFormalParameter> _parameters = it.getParameters();
          JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(definition, "operativeDtoClass", this._typeReferenceBuilder.typeRef(Class.class));
          this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
          EList<JvmFormalParameter> _parameters_1 = it.getParameters();
          JvmFormalParameter _parameter_1 = this._jvmTypesBuilder.toParameter(definition, "operativeDtos", 
            this._typeReferenceBuilder.typeRef(List.class, this._typeReferenceBuilder.typeRef(IDto.class)));
          this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters_1, _parameter_1);
          final Procedure1<ITreeAppendable> _function_18 = (ITreeAppendable it_1) -> {
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append("DerivedCellSet derivedCellSet = null;");
            _builder_1.newLine();
            _builder_1.append("connect();");
            _builder_1.newLine();
            _builder_1.append("if (connection != null) {");
            _builder_1.newLine();
            _builder_1.append("\t");
            _builder_1.append("derivedCellSet = new DerivedCellSet(");
            _builder_1.append(this.binderClassName, "\t");
            _builder_1.append(".getPersistenceService().sendQuery(connection, applyFilters()),");
            _builder_1.newLineIfNotEmpty();
            _builder_1.append("\t\t\t");
            _builder_1.append(this.binderClassName, "\t\t\t");
            _builder_1.append(".getDSLMetadataService(),");
            _builder_1.newLineIfNotEmpty();
            _builder_1.append("\t\t\t");
            _builder_1.append("user);");
            _builder_1.newLine();
            _builder_1.append("}");
            _builder_1.newLine();
            _builder_1.append("disconnect();");
            _builder_1.newLine();
            _builder_1.append("return derivedCellSet;");
            it_1.append(_builder_1);
          };
          this._jvmTypesBuilder.setBody(it, _function_18);
        };
        JvmOperation _method_8 = this._jvmTypesBuilder.toMethod(definition, "getResults", this._typeReferenceBuilder.typeRef(DerivedCellSet.class), _function_17);
        this._jvmTypesBuilder.<JvmOperation>operator_add(_members_17, _method_8);
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append("Test");
        String _name_1 = definition.getName();
        _builder_1.append(_name_1);
        final Procedure1<JvmOperation> _function_18 = (JvmOperation it) -> {
          final Procedure1<ITreeAppendable> _function_19 = (ITreeAppendable it_1) -> {
            StringConcatenation _builder_2 = new StringConcatenation();
            _builder_2.append("renderFilters();");
            _builder_2.newLine();
            _builder_2.append("org.junit.Assert.assertNotNull(getResults(null, null));");
            it_1.append(_builder_2);
          };
          this._jvmTypesBuilder.setBody(it, _function_19);
        };
        operation = this._jvmTypesBuilder.toMethod(definition, _builder_1.toString(), this._typeReferenceBuilder.typeRef(String.class), _function_18);
        operation.setReturnType(this._typeReferenceBuilder.typeRef(Void.TYPE));
        JvmAnnotationReference annRef_1 = this._annotationTypesBuilder.annotationRef(Test.class);
        operation.getAnnotations().add(annRef_1);
        EList<JvmMember> _members_18 = type.getMembers();
        this._jvmTypesBuilder.<JvmOperation>operator_add(_members_18, operation);
      }
    }
    DatamartSource _source_4 = definition.getSource();
    if ((_source_4 instanceof DatamartEntity)) {
      EList<JvmMember> _members_19 = type.getMembers();
      final Procedure1<JvmOperation> _function_19 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_20 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append("return \"");
          DatamartSource _source_5 = definition.getSource();
          LEntity _entityRef = null;
          if (((DatamartEntity) _source_5)!=null) {
            _entityRef=((DatamartEntity) _source_5).getEntityRef();
          }
          String _persistenceUnit = null;
          if (_entityRef!=null) {
            _persistenceUnit=_entityRef.getPersistenceUnit();
          }
          _builder_2.append(_persistenceUnit);
          _builder_2.append("\";");
          _builder_2.newLineIfNotEmpty();
          it_1.append(_builder_2);
        };
        this._jvmTypesBuilder.setBody(it, _function_20);
      };
      JvmOperation _method_9 = this._jvmTypesBuilder.toMethod(definition, "getPersistenceUnit", this._typeReferenceBuilder.typeRef(String.class), _function_19);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_19, _method_9);
      EList<JvmMember> _members_20 = type.getMembers();
      final Procedure1<JvmOperation> _function_20 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_21 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append("if (connection == null) {   \t\t\t");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("try {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("connection = ");
          _builder_2.append(this.binderClassName, "\t\t");
          _builder_2.append(".getPersistenceService().getPersistenceUnitConnection(getPersistenceUnit());");
          _builder_2.newLineIfNotEmpty();
          _builder_2.append("\t\t");
          _builder_2.append(this.binderClassName, "\t\t");
          _builder_2.append(".getPersistenceService().registerPersistenceUnit(getPersistenceUnit(), ");
          DatamartSource _source_5 = definition.getSource();
          LEntity _entityRef = null;
          if (((DatamartEntity) _source_5)!=null) {
            _entityRef=((DatamartEntity) _source_5).getEntityRef();
          }
          QualifiedName _fullyQualifiedName = null;
          if (_entityRef!=null) {
            _fullyQualifiedName=this._iQualifiedNameProvider.getFullyQualifiedName(_entityRef);
          }
          _builder_2.append(_fullyQualifiedName, "\t\t");
          _builder_2.append(".class);");
          _builder_2.newLineIfNotEmpty();
          _builder_2.append("\t");
          _builder_2.append("} catch (SQLException e) {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("log.error(\"{}\", e);");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("return (connection);");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("return (connection);");
          it_1.append(_builder_2);
        };
        this._jvmTypesBuilder.setBody(it, _function_21);
      };
      JvmOperation _method_10 = this._jvmTypesBuilder.toMethod(definition, "connect", this._typeReferenceBuilder.typeRef(Connection.class), _function_20);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_20, _method_10);
      EList<JvmMember> _members_21 = type.getMembers();
      final Procedure1<JvmOperation> _function_21 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_22 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append("if (connection != null) {   \t\t\t");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("try {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("connection.close();");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("connection = null;");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("} catch (SQLException e) {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("log.error(\"{}\", e);");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("}");
          it_1.append(_builder_2);
        };
        this._jvmTypesBuilder.setBody(it, _function_22);
      };
      JvmOperation _method_11 = this._jvmTypesBuilder.toMethod(definition, "disconnect", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_21);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_21, _method_11);
      EList<JvmMember> _members_22 = type.getMembers();
      final Procedure1<JvmOperation> _function_22 = (JvmOperation it) -> {
        EList<JvmFormalParameter> _parameters = it.getParameters();
        JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(definition, "filteredStatement", this._typeReferenceBuilder.typeRef(String.class));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        EList<JvmFormalParameter> _parameters_1 = it.getParameters();
        JvmFormalParameter _parameter_1 = this._jvmTypesBuilder.toParameter(definition, "condition", this._typeReferenceBuilder.typeRef(String.class));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters_1, _parameter_1);
        final Procedure1<ITreeAppendable> _function_23 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append("int index = filteredStatement.indexOf(\"order by\");");
          _builder_2.newLine();
          _builder_2.append("if(index > -1) {");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("return filteredStatement.substring(0, index-1) + condition + filteredStatement.substring(index-1); ");
          _builder_2.newLine();
          _builder_2.append("} else {");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("return filteredStatement + condition;");
          _builder_2.newLine();
          _builder_2.append("}");
          it_1.append(_builder_2);
        };
        this._jvmTypesBuilder.setBody(it, _function_23);
      };
      JvmOperation _method_12 = this._jvmTypesBuilder.toMethod(definition, "insertCondition", this._typeReferenceBuilder.typeRef(String.class), _function_22);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_22, _method_12);
      final Procedure1<JvmOperation> _function_23 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_24 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append("connect();");
          _builder_2.newLine();
          _builder_2.append("if (connection != null) {");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("for (DatamartFilter filter : getFilters()) {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("if((DatamartFilter.FilterType.BY_ID != filter.getType()) && (DatamartFilter.FilterType.BETWEEN != filter.getType()) && (DatamartFilter.FilterType.BETWEEN_DATE != filter.getType())) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("ResultSet rs = null;");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("try {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("rs = connection.createStatement().executeQuery(getVendorSql(filter));");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("if (rs != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("while (rs.next()) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t");
          _builder_2.append("int type = rs.getMetaData().getColumnType(1);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t");
          _builder_2.append("switch (type) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.DATE:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t    ");
          _builder_2.append("Date date = rs.getDate(1);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t    ");
          _builder_2.append("if (date != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t");
          _builder_2.append("if (user == null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t\t");
          _builder_2.append("filter.addItem(date.toString(), getVendorToDateSQLMethod()+\"(\'\"+date.toString().replace(\".0\",\"\")+\"\',\'YYYY-MM-DD HH24:MI:SS\')\", false);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t");
          _builder_2.append("} else {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t\t");
          _builder_2.append("filter.addItem(SimpleDateFormatter.getFormat(\"LONGDATE\", user.getLocale()).format(date), getVendorToDateSQLMethod()+\"(\'\"+date.toString().replace(\".0\",\"\")+\"\',\'YYYY-MM-DD HH24:MI:SS\')\", false);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.TIMESTAMP:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("Timestamp timestamp = rs.getTimestamp(1);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("if (timestamp != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t");
          _builder_2.append("if (user == null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t\t");
          _builder_2.append("filter.addItem(timestamp.toString(), getVendorToTimestampSQLMethod()+\"(\'\"+timestamp.toString().replace(\".0\",\"\")+\"\',\'YYYY-MM-DD HH24:MI:SS\')\", false);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t");
          _builder_2.append("} else {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t\t");
          _builder_2.append("filter.addItem(SimpleDateFormatter.getFormat(\"LONGDATE\", user.getLocale()).format(timestamp), getVendorToTimestampSQLMethod()+\"(\'\"+timestamp.toString().replace(\".0\",\"\")+\"\',\'YYYY-MM-DD HH24:MI:SS\')\", false);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.DECIMAL:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("BigDecimal bigDecimal = rs.getBigDecimal(1);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("if (bigDecimal != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t\t");
          _builder_2.append("filter.addItem(bigDecimal.toPlainString(), bigDecimal.toPlainString(), false);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.NUMERIC:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.DOUBLE:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("filter.addItem(Double.toString(rs.getDouble(1)), Double.toString(rs.getDouble(1)), false);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.INTEGER:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.BIGINT:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("filter.addItem(Integer.toString(rs.getInt(1)), Integer.toString(rs.getInt(1)), false);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.FLOAT:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("filter.addItem(Float.toString(rs.getFloat(1)), Float.toString(rs.getFloat(1)), false);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.CHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.NCHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.NVARCHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t \t\t\t");
          _builder_2.append("case java.sql.Types.VARCHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t\t\t");
          _builder_2.append("case java.sql.Types.LONGVARCHAR: ");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t\t\t\t\t\t");
          _builder_2.append("filter.addItem(rs.getString(1), rs.getString(1), true);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t\t\t\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("} catch (SQLException e) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("log.error(\"{}\", e);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("} finally {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("try {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("rs.close();");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("} catch (java.sql.SQLException e) {}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("disconnect();");
          it_1.append(_builder_2);
        };
        this._jvmTypesBuilder.setBody(it, _function_24);
      };
      operation = this._jvmTypesBuilder.toMethod(definition, "renderFilters", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_23);
      EList<JvmMember> _members_23 = type.getMembers();
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_23, operation);
      final Procedure1<JvmOperation> _function_24 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_25 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append("String filteredStatement = statement;");
          _builder_2.newLine();
          _builder_2.append("computeConditions();");
          _builder_2.newLine();
          _builder_2.append("for (DatamartFilter filter : getFilters()) {");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("if (DatamartFilter.FilterType.BY_ID == filter.getType()) {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("if(filter.getCondition() != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("if\t(!filteredStatement.toLowerCase().contains(\" where \")) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("if\t((\" \"+filter.getCondition()).toLowerCase().contains(\"where \")) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("filteredStatement = insertCondition(filteredStatement, \" \"+filter.getCondition());");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("else {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("filteredStatement = insertCondition(filteredStatement, \" where \"+filter.getCondition());");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("else {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("if\t(filter.getCondition().trim().toLowerCase().startsWith(\"and \") ||");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t ");
          _builder_2.append("filter.getCondition().trim().toLowerCase().startsWith(\"or \") ) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("filteredStatement = insertCondition(filteredStatement, filter.getCondition());");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("else {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("filteredStatement = insertCondition(filteredStatement, \" and \"+filter.getCondition());");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("else {");
          _builder_2.newLine();
          _builder_2.append("\t   \t");
          _builder_2.append("filteredStatement = filteredStatement.replace(filter.getDecoratedName(), filter.getCondition());");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("log.debug(\"");
          String _name_2 = definition.getName();
          _builder_2.append(_name_2);
          _builder_2.append(":\"+filteredStatement);");
          _builder_2.newLineIfNotEmpty();
          _builder_2.append("return filteredStatement;");
          it_1.append(_builder_2);
        };
        this._jvmTypesBuilder.setBody(it, _function_25);
      };
      operation = this._jvmTypesBuilder.toMethod(definition, "applyFilters", this._typeReferenceBuilder.typeRef(String.class), _function_24);
      EList<JvmMember> _members_24 = type.getMembers();
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_24, operation);
      EList<JvmMember> _members_25 = type.getMembers();
      final Procedure1<JvmOperation> _function_25 = (JvmOperation it) -> {
        EList<JvmFormalParameter> _parameters = it.getParameters();
        JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(definition, "operativeDtoClass", this._typeReferenceBuilder.typeRef(Class.class));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        EList<JvmFormalParameter> _parameters_1 = it.getParameters();
        JvmFormalParameter _parameter_1 = this._jvmTypesBuilder.toParameter(definition, "operativeDtos", 
          this._typeReferenceBuilder.typeRef(List.class, this._typeReferenceBuilder.typeRef(IDto.class)));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters_1, _parameter_1);
        final Procedure1<ITreeAppendable> _function_26 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append("ResultSet rs = null;");
          _builder_2.newLine();
          _builder_2.append("SqlCellSet cellSet = null;");
          _builder_2.newLine();
          _builder_2.append("java.sql.ResultSetMetaData metaData = null;");
          _builder_2.newLine();
          _builder_2.append("// --- if filler text is enabled ---");
          _builder_2.newLine();
          _builder_2.append("if\t(fFillerTextEnabled) {");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("// --- try to generate filler text ---");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("rs = generateFillerTextResultSet();");
          _builder_2.newLine();
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("// --- if no result set is generated by now ---");
          _builder_2.newLine();
          _builder_2.append("connect();");
          _builder_2.newLine();
          _builder_2.append("if (rs == null) {");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("if (connection != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("String query = applyFilters();");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("if (query.length()>0) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("try {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("rs = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY).executeQuery(query);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("} catch (SQLException e) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("log.error(\"Query: \"+query);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("log.error(\"{}\", e);");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("if (rs != null) {");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("try {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("cellSet = new SqlCellSet(rs, getAxisMap(), getIdMap(), getAliasMap(), datamartDtoMapper, operativeDtoClass, operativeDtos, getPrimaryList(), ");
          _builder_2.append(this.binderClassName, "\t\t");
          _builder_2.append(".getUserAccessService());");
          _builder_2.newLineIfNotEmpty();
          _builder_2.append("\t\t");
          _builder_2.append("registerFirstLine(rs, user);");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("metaData = rs.getMetaData();");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("rs.close();");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("catch (java.sql.SQLException e) {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("try {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("log.error(\"Statement: \"+rs.getStatement().toString());");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("} catch (SQLException e1) {}");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("log.error(\"{}\", e);");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("return (new DerivedCellSet(cellSet,");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("metaData,");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append(this.binderClassName, "\t\t");
          _builder_2.append(".getDSLMetadataService(), user));");
          _builder_2.newLineIfNotEmpty();
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("disconnect();");
          _builder_2.newLine();
          _builder_2.append("return null;");
          it_1.append(_builder_2);
        };
        this._jvmTypesBuilder.setBody(it, _function_26);
      };
      JvmOperation _method_13 = this._jvmTypesBuilder.toMethod(definition, "getResults", this._typeReferenceBuilder.typeRef(DerivedCellSet.class), _function_25);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_25, _method_13);
      EList<JvmMember> _members_26 = type.getMembers();
      final Procedure1<JvmOperation> _function_26 = (JvmOperation it) -> {
        EList<JvmFormalParameter> _parameters = it.getParameters();
        JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(definition, "rs", this._typeReferenceBuilder.typeRef(ResultSet.class));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        EList<JvmFormalParameter> _parameters_1 = it.getParameters();
        JvmFormalParameter _parameter_1 = this._jvmTypesBuilder.toParameter(definition, "user", this._typeReferenceBuilder.typeRef(IUser.class));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters_1, _parameter_1);
        EList<JvmTypeReference> _exceptions = it.getExceptions();
        JvmTypeReference _typeRef = this._typeReferenceBuilder.typeRef(SQLException.class);
        this._jvmTypesBuilder.<JvmTypeReference>operator_add(_exceptions, _typeRef);
        final Procedure1<ITreeAppendable> _function_27 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append("if (rs != null && rs.first()) {");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("for (int column = 1; column <= rs.getMetaData().getColumnCount(); column++) {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("int type = rs.getMetaData().getColumnType(column);");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("switch (type) {");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.DATE:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("if(rs.getDate(column) != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("if (user == null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("resultAttributes.put(rs.getMetaData().getColumnName(column), rs.getDate(column).toString());");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("} else {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("resultAttributes.put(rs.getMetaData().getColumnName(column),");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t\t\t");
          _builder_2.append("SimpleDateFormatter.getFormat(\"LONGDATE\", user.getLocale()).format(rs.getDate(column)));");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.TIMESTAMP:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("if(rs.getTimestamp(column) != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("if (user == null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("resultAttributes.put(rs.getMetaData().getColumnName(column), rs.getTimestamp(column).toString());");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("} else {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("resultAttributes.put(rs.getMetaData().getColumnName(column), SimpleDateFormatter");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t\t\t");
          _builder_2.append(".getFormat(\"LONGDATE\", user.getLocale()).format(rs.getTimestamp(column)));");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.DECIMAL:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("if(rs.getBigDecimal(column) != null) {");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t");
          _builder_2.append("resultAttributes.put(rs.getMetaData().getColumnName(column),");
          _builder_2.newLine();
          _builder_2.append("\t\t\t\t\t");
          _builder_2.append("rs.getBigDecimal(column).toPlainString());");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.NUMERIC:");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.DOUBLE:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("resultAttributes.put(rs.getMetaData().getColumnName(column), Double.toString(rs.getDouble(column)));");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.FLOAT:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("resultAttributes.put(rs.getMetaData().getColumnName(column), Float.toString(rs.getFloat(column)));");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.CHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.NCHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.NVARCHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.VARCHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("case java.sql.Types.LONGVARCHAR:");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("resultAttributes.put(rs.getMetaData().getColumnName(column), rs.getString(column));");
          _builder_2.newLine();
          _builder_2.append("\t\t\t");
          _builder_2.append("break;");
          _builder_2.newLine();
          _builder_2.append("\t\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("\t");
          _builder_2.append("}");
          _builder_2.newLine();
          _builder_2.append("}");
          _builder_2.newLine();
          it_1.append(_builder_2);
        };
        this._jvmTypesBuilder.setBody(it, _function_27);
      };
      JvmOperation _method_14 = this._jvmTypesBuilder.toMethod(definition, "registerFirstLine", this._typeReferenceBuilder.typeRef(Void.TYPE), _function_26);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_26, _method_14);
      StringConcatenation _builder_2 = new StringConcatenation();
      _builder_2.append("Test");
      String _name_2 = definition.getName();
      _builder_2.append(_name_2);
      final Procedure1<JvmOperation> _function_27 = (JvmOperation it) -> {
        final Procedure1<ITreeAppendable> _function_28 = (ITreeAppendable it_1) -> {
          StringConcatenation _builder_3 = new StringConcatenation();
          _builder_3.append("renderFilters();");
          _builder_3.newLine();
          _builder_3.append("org.junit.Assert.assertNotNull(getResults(null, null));");
          it_1.append(_builder_3);
        };
        this._jvmTypesBuilder.setBody(it, _function_28);
      };
      operation = this._jvmTypesBuilder.toMethod(definition, _builder_2.toString(), this._typeReferenceBuilder.typeRef(String.class), _function_27);
      operation.setReturnType(this._typeReferenceBuilder.typeRef(Void.TYPE));
      JvmAnnotationReference annRef_2 = this._annotationTypesBuilder.annotationRef(Test.class);
      operation.getAnnotations().add(annRef_2);
      EList<JvmMember> _members_27 = type.getMembers();
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_27, operation);
    }
  }
  
  public String createFilterAttributeProperties(final DatamartEntity entity) {
    String text = "";
    EList<DatamartCondition> _conditions = entity.getConditions();
    for (final DatamartCondition condition : _conditions) {
      Expression _condition = condition.getCondition();
      boolean _tripleNotEquals = (_condition != null);
      if (_tripleNotEquals) {
        Expression _condition_1 = condition.getCondition();
        if ((_condition_1 instanceof ConditionalExpression)) {
          Expression _condition_2 = condition.getCondition();
          Expression element = ((ConditionalExpression) _condition_2).getRight();
          Expression _condition_3 = condition.getCondition();
          Expression leftConditionalExpr = ((ConditionalExpression) _condition_3).getLeft();
          if ((leftConditionalExpr instanceof DatamartAttributeBase)) {
            Expression _condition_4 = condition.getCondition();
            Expression _left = ((ConditionalExpression) _condition_4).getLeft();
            DatamartAttributeBase attribute = ((DatamartAttributeBase) _left);
            boolean _isRanged = element.isRanged();
            if (_isRanged) {
              boolean _isDate = this._modelExtensions.getDatatype(attribute.getAttributeRef()).isDate();
              if (_isDate) {
                if (((attribute.getAttributeRef().getProperties() != null) && 
                  (!attribute.getAttributeRef().getProperties().isEmpty()))) {
                  StringConcatenation _builder = new StringConcatenation();
                  _builder.append("{{");
                  _builder.newLine();
                  _builder.append("\t");
                  _builder.append("put(\"");
                  String _attributeName = this.getAttributeName(attribute, entity);
                  _builder.append(_attributeName, "\t");
                  _builder.append("\", new HashMap<String, String>() {{");
                  text = _builder.toString();
                  EList<LKeyAndValue> _properties = attribute.getAttributeRef().getProperties();
                  for (final LKeyAndValue property : _properties) {
                    StringConcatenation _builder_1 = new StringConcatenation();
                    _builder_1.append(text);
                    _builder_1.newLineIfNotEmpty();
                    _builder_1.append("\t\t");
                    _builder_1.append("put(\"");
                    String _key = property.getKey();
                    _builder_1.append(_key, "\t\t");
                    _builder_1.append("\", \"");
                    String _value = property.getValue();
                    _builder_1.append(_value, "\t\t");
                    _builder_1.append("\");");
                    text = _builder_1.toString();
                  }
                  StringConcatenation _builder_2 = new StringConcatenation();
                  _builder_2.append(text);
                  _builder_2.newLineIfNotEmpty();
                  _builder_2.append("\t");
                  _builder_2.append("}});");
                  _builder_2.newLine();
                  _builder_2.append("}}");
                  text = _builder_2.toString();
                }
              }
            }
          }
        }
      }
    }
    EList<DatamartNavigation> _navigations = entity.getNavigations();
    for (final DatamartNavigation navigation : _navigations) {
      {
        if ((navigation instanceof DatamartMember)) {
          StringConcatenation _builder_3 = new StringConcatenation();
          _builder_3.append(text);
          _builder_3.newLineIfNotEmpty();
          String _createFilterAttributeProperties = this.createFilterAttributeProperties(((DatamartMember) navigation).getDatamartEntity());
          _builder_3.append(_createFilterAttributeProperties);
          text = _builder_3.toString();
        }
        if ((navigation instanceof DatamartOwner)) {
          StringConcatenation _builder_4 = new StringConcatenation();
          _builder_4.append(text);
          _builder_4.newLineIfNotEmpty();
          String _createFilterAttributeProperties_1 = this.createFilterAttributeProperties(((DatamartOwner) navigation).getDatamartEntity());
          _builder_4.append(_createFilterAttributeProperties_1);
          text = _builder_4.toString();
        }
      }
    }
    return text;
  }
  
  /**
   * <p>build the id map as lookup for primary key oriented applications.</p>
   */
  public String createIdMap(final DatamartDefinition definition) {
    String listTxt = "";
    Set<String> _keySet = this.idMap.keySet();
    for (final String idColumn : _keySet) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(listTxt);
      _builder.newLineIfNotEmpty();
      _builder.append("\t\t");
      _builder.append("put(\"");
      _builder.append(idColumn, "\t\t");
      _builder.append("\", EType.");
      LEntityAttribute _primaryKeyAttribute = this.idMap.get(idColumn).getPrimaryKeyAttribute();
      IDataMart.EType _basicType = this.dtType.getBasicType(((LEntityAttribute) _primaryKeyAttribute));
      _builder.append(_basicType, "\t\t");
      _builder.append(");");
      listTxt = _builder.toString();
    }
    StringConcatenation _builder_1 = new StringConcatenation();
    _builder_1.append("{{");
    _builder_1.newLine();
    _builder_1.append("\t");
    _builder_1.append(listTxt, "\t");
    _builder_1.newLineIfNotEmpty();
    _builder_1.append("}}");
    listTxt = _builder_1.toString();
    return listTxt;
  }
  
  public String createPrimaryList(final DatamartDefinition definition) {
    String listTxt = "";
    Set<String> _keySet = this.idMap.keySet();
    for (final String idColumn : _keySet) {
      {
        String typeName = "";
        LScalarType _idAttributeType = this.idMap.get(idColumn).getIdAttributeType();
        if ((_idAttributeType instanceof LDataType)) {
          LScalarType _idAttributeType_1 = this.idMap.get(idColumn).getIdAttributeType();
          JvmTypeReference _jvmTypeReference = ((LDataType) _idAttributeType_1).getJvmTypeReference();
          boolean _tripleNotEquals = (_jvmTypeReference != null);
          if (_tripleNotEquals) {
            LScalarType _idAttributeType_2 = this.idMap.get(idColumn).getIdAttributeType();
            typeName = ((LDataType) _idAttributeType_2).getJvmTypeReference().getType().getSimpleName();
          } else {
            LScalarType _idAttributeType_3 = this.idMap.get(idColumn).getIdAttributeType();
            typeName = ((LDataType) _idAttributeType_3).getName();
          }
          StringConcatenation _builder = new StringConcatenation();
          _builder.append(listTxt);
          _builder.newLineIfNotEmpty();
          _builder.append("\t\t");
          _builder.append("add(new DatamartPrimary<");
          _builder.append(typeName, "\t\t");
          _builder.append(">(\"");
          _builder.append(idColumn, "\t\t");
          _builder.append("\", \"");
          String _name = this.idMap.get(idColumn).getPrimaryKeyAttribute().getName();
          _builder.append(_name, "\t\t");
          _builder.append("\", \"");
          QualifiedName _fullyQualifiedName = this._iQualifiedNameProvider.getFullyQualifiedName(this.idMap.get(idColumn));
          _builder.append(_fullyQualifiedName, "\t\t");
          _builder.append("\"));");
          listTxt = _builder.toString();
        }
      }
    }
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("{{");
    _builder.newLine();
    _builder.append("\t");
    _builder.append(listTxt, "\t");
    _builder.newLineIfNotEmpty();
    _builder.append("}}");
    listTxt = _builder.toString();
    return listTxt;
  }
  
  public String addPrimaryFilters(final DatamartDefinition definition) {
    String listTxt = "";
    Set<String> _keySet = this.idMap.keySet();
    for (final String idColumn : _keySet) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(listTxt);
      _builder.newLineIfNotEmpty();
      _builder.append("add(new DatamartFilter(");
      _builder.append(this.binderClassName);
      _builder.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.BY_ID, \"");
      String _name = this.idMap.get(idColumn).getName();
      _builder.append(_name);
      _builder.append(".");
      String _name_1 = this.idMap.get(idColumn).getPrimaryKeyAttribute().getName();
      _builder.append(_name_1);
      _builder.append("\",\"\"));");
      listTxt = _builder.toString();
    }
    return listTxt;
  }
  
  /**
   * <p>build the types map as lookup for datatypes.</p>
   */
  public String createTypesMaps(final DatamartDefinition definition, final HashMap<String, LAttribute> typesMap) {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("{{");
    _builder.newLine();
    _builder.append("\t");
    String _createTypesMap = this.createTypesMap(definition, typesMap);
    _builder.append(_createTypesMap, "\t");
    _builder.newLineIfNotEmpty();
    _builder.append("}}");
    String listTxt = _builder.toString();
    return listTxt;
  }
  
  /**
   * <p>build the types map as lookup for datatypes.</p>
   */
  public String createTypesProps(final DatamartDefinition definition, final HashMap<String, LAttribute> typesMap) {
    String listTxt = "";
    Set<String> _keySet = typesMap.keySet();
    for (final String attribute : _keySet) {
      boolean _isEmpty = typesMap.get(attribute).getProperties().isEmpty();
      boolean _not = (!_isEmpty);
      if (_not) {
        String attributeName = attribute.split("\\.")[1];
        StringConcatenation _builder = new StringConcatenation();
        _builder.append(listTxt);
        _builder.newLineIfNotEmpty();
        _builder.append("put(\"");
        _builder.append(attributeName);
        _builder.append("\", \"");
        String _value = typesMap.get(attribute).getProperties().get(0).getValue();
        _builder.append(_value);
        _builder.append("\");");
        listTxt = _builder.toString();
      }
    }
    StringConcatenation _builder_1 = new StringConcatenation();
    _builder_1.append("{{");
    _builder_1.newLine();
    _builder_1.append("\t");
    _builder_1.append(listTxt, "\t");
    _builder_1.newLineIfNotEmpty();
    _builder_1.append("}}");
    listTxt = _builder_1.toString();
    return listTxt;
  }
  
  /**
   * <p>build the types map as lookup for datatypes according to authorization roles.</p>
   */
  public String createTypesMap(final DatamartDefinition definition, final HashMap<String, LAttribute> typesMap) {
    String listTxt = "";
    Set<String> _keySet = typesMap.keySet();
    for (final String attribute : _keySet) {
      {
        final IDataMart.EType type = this.dtType.getBasicType(typesMap.get(attribute));
        StringConcatenation _builder = new StringConcatenation();
        _builder.append(listTxt);
        _builder.newLineIfNotEmpty();
        _builder.append("put(\"");
        _builder.append(attribute);
        _builder.append("\", EType.");
        String _string = type.toString();
        _builder.append(_string);
        _builder.append(");");
        listTxt = _builder.toString();
      }
    }
    return listTxt;
  }
  
  /**
   * <p>build the axis map.</p>
   */
  public String createAxisMap(final DatamartDefinition definition, final Map<String, LEntity> entityMap) {
    String text = "";
    HashMap<Integer, Map<String, Integer>> map = CollectionLiterals.<Integer, Map<String, Integer>>newHashMap();
    DatamartSource _source = definition.getSource();
    boolean _tripleNotEquals = (_source != null);
    if (_tripleNotEquals) {
      DatamartSource _source_1 = definition.getSource();
      if ((_source_1 instanceof DatamartEntity)) {
        DatamartSource _source_2 = definition.getSource();
        this.createAxisMap(((DatamartEntity) _source_2), map);
      }
      DatamartSource _source_3 = definition.getSource();
      if ((_source_3 instanceof DatamartTask)) {
        DatamartSource _source_4 = definition.getSource();
        this.createAxisMap(((DatamartTask) _source_4), map);
      }
    }
    Set<Integer> _keySet = map.keySet();
    for (final Integer axisNumber : _keySet) {
      {
        if (((definition.getSource() instanceof DatamartEntity) && ((axisNumber).intValue() == AxisEnum.COLUMNS_VALUE))) {
          if ((!this.ignoreEntityGrouping)) {
            Collection<LEntity> _values = entityMap.values();
            for (final LEntity entityRef : _values) {
              {
                String idColumn = DatamartDefinitionUtil.getEntityIdAliasName(entityRef);
                if ((idColumn != null)) {
                  map.get(axisNumber).put(idColumn, Integer.valueOf(0));
                }
              }
            }
          }
        }
        final Function<Map.Entry<String, Integer>, String> _function = (Map.Entry<String, Integer> it) -> {
          String _key = it.getKey();
          String _plus = ("add(\"" + _key);
          return (_plus + "\");");
        };
        String listTxt = map.get(axisNumber).entrySet().stream().sorted(Map.Entry.<String, Integer>comparingByValue().reversed()).<String>map(_function).collect(Collectors.joining("\n", "{{\n", "\n}}"));
        StringConcatenation _builder = new StringConcatenation();
        _builder.append(text);
        _builder.newLineIfNotEmpty();
        _builder.append("\t");
        _builder.append("put(");
        _builder.append(axisNumber, "\t");
        _builder.append(",new ArrayList<String>() ");
        _builder.append(listTxt, "\t");
        _builder.append(");");
        text = _builder.toString();
      }
    }
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("{{");
    _builder.newLine();
    _builder.append("\t");
    _builder.append(text, "\t");
    _builder.newLineIfNotEmpty();
    _builder.append("}}");
    text = _builder.toString();
    return text;
  }
  
  /**
   * <p>creates an axis map for tasks.</p>
   */
  public void createAxisMap(final DatamartTask task, final Map<Integer, Map<String, Integer>> map) {
    this.idMap.clear();
    EList<DatamartColumn> _columns = task.getColumns();
    for (final DatamartColumn column : _columns) {
      {
        int axisNumber = 0;
        String name = column.getColumnRef().getLiteral();
        boolean found = false;
        Set<Integer> _keySet = map.keySet();
        for (final Integer axNum : _keySet) {
          if (((axNum).intValue() == axisNumber)) {
            map.get(axNum).put(name, Integer.valueOf(this.defaultColumnWeight));
            found = true;
          }
        }
        if ((!found)) {
          HashMap<String, Integer> columns = CollectionLiterals.<String, Integer>newHashMap();
          columns.put(name, Integer.valueOf(this.defaultColumnWeight));
          map.put(Integer.valueOf(axisNumber), columns);
        }
      }
    }
  }
  
  public void recursAxisMap(final LScalarType type, final DatamartAttribute attribute, final Map<Integer, Map<String, Integer>> map, final int axisNumber) {
    if ((type instanceof LBean)) {
      LBean bean = ((LBean) type);
      List<LBeanAttribute> _allAttributes = bean.getAllAttributes();
      for (final LBeanAttribute attr : _allAttributes) {
        LScalarType _type = attr.getType();
        if ((_type instanceof LBean)) {
          this.recursAxisMap(attr.getType(), attribute, map, axisNumber);
        } else {
          this.addAxisAttribute(attr.getName(), Integer.valueOf(this.defaultColumnWeight), map, axisNumber);
        }
      }
    } else {
      int weight = this.defaultColumnWeight;
      boolean _isHasColumnWeight = attribute.isHasColumnWeight();
      if (_isHasColumnWeight) {
        weight = attribute.getColumnWeight();
      }
      this.addAxisAttribute(DatamartAttributeUtil.getAliasedAttributeName(attribute), Integer.valueOf(weight), map, axisNumber);
    }
  }
  
  public Map<String, Integer> addAxisAttribute(final String name, final Integer weight, final Map<Integer, Map<String, Integer>> map, final int axisNumber) {
    Map<String, Integer> _xblockexpression = null;
    {
      boolean found = false;
      Set<Integer> _keySet = map.keySet();
      for (final Integer axNum : _keySet) {
        if (((axNum).intValue() == axisNumber)) {
          map.get(axNum).put(name, weight);
          found = true;
        }
      }
      Map<String, Integer> _xifexpression = null;
      if ((!found)) {
        Map<String, Integer> _xblockexpression_1 = null;
        {
          HashMap<String, Integer> columns = CollectionLiterals.<String, Integer>newHashMap();
          columns.put(name, weight);
          _xblockexpression_1 = map.put(Integer.valueOf(axisNumber), columns);
        }
        _xifexpression = _xblockexpression_1;
      }
      _xblockexpression = _xifexpression;
    }
    return _xblockexpression;
  }
  
  /**
   * <p>recursively create an axis map for entities.</p>
   */
  public void createAxisMap(final DatamartEntity entity, final Map<Integer, Map<String, Integer>> map) {
    ArrayList<DatamartAttribute> entityAttributes = this.entityAttributes(entity);
    for (final DatamartAttribute attribute : entityAttributes) {
      {
        int axisNumber = (-1);
        int _value = attribute.getAxis().getName().getValue();
        boolean _equals = (_value == (-1));
        if (_equals) {
          axisNumber = 0;
        } else {
          axisNumber = attribute.getAxis().getName().getValue();
        }
        LScalarType _type = attribute.getAttributeRef().getType();
        LScalarType type = ((LScalarType) _type);
        this.recursAxisMap(type, attribute, map, axisNumber);
      }
    }
    EList<DatamartNavigation> _navigations = entity.getNavigations();
    for (final DatamartNavigation navigation : _navigations) {
      this.createAxisMap(navigation.getDatamartEntity(), map);
    }
  }
  
  /**
   * <p>build the alias map.</p>
   */
  public String createAliasMap(final DatamartDefinition definition, final Map<String, LEntity> entityMap) {
    HashMap<String, String> aliases = CollectionLiterals.<String, String>newHashMap();
    if (((definition.getSource() != null) && (definition.getSource() instanceof DatamartEntity))) {
      DatamartSource _source = definition.getSource();
      this.createAliasMap(((DatamartEntity) _source), aliases);
    }
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("{{");
    _builder.newLine();
    _builder.append("\t");
    final Function1<Map.Entry<String, String>, String> _function = (Map.Entry<String, String> it) -> {
      StringConcatenation _builder_1 = new StringConcatenation();
      _builder_1.append("put(\"");
      String _key = it.getKey();
      _builder_1.append(_key);
      _builder_1.append("\",\"");
      String _value = it.getValue();
      _builder_1.append(_value);
      _builder_1.append("\");");
      return _builder_1.toString();
    };
    String _join = IterableExtensions.join(IterableExtensions.<Map.Entry<String, String>, String>map(aliases.entrySet(), _function), "\n");
    _builder.append(_join, "\t");
    _builder.newLineIfNotEmpty();
    _builder.append("}}");
    String text = _builder.toString();
    return text;
  }
  
  public void recursAliasMap(final LScalarType type, final DatamartAttribute attribute, final Map<String, String> map) {
    if ((type instanceof LBean)) {
      LBean bean = ((LBean) type);
      List<LBeanAttribute> _allAttributes = bean.getAllAttributes();
      for (final LBeanAttribute attr : _allAttributes) {
        LScalarType _type = attr.getType();
        if ((_type instanceof LBean)) {
          this.recursAliasMap(attr.getType(), attribute, map);
        } else {
          map.put(attr.getName(), this._iQualifiedNameProvider.getFullyQualifiedName(attr).toString());
        }
      }
    } else {
      String _aliasedAttributeName = DatamartAttributeUtil.getAliasedAttributeName(attribute);
      String _string = this._iQualifiedNameProvider.getFullyQualifiedName(attribute.getAttributeRef().getEntity()).toString();
      String _plus = (_string + ".");
      String _name = attribute.getAttributeRef().getName();
      String _plus_1 = (_plus + _name);
      map.put(_aliasedAttributeName, _plus_1);
    }
  }
  
  /**
   * <p>recursively create an alias map for entities.</p>
   */
  public void createAliasMap(final DatamartEntity entity, final Map<String, String> map) {
    ArrayList<DatamartAttribute> entityAttributes = this.entityAttributes(entity);
    for (final DatamartAttribute attribute : entityAttributes) {
      {
        LScalarType _type = attribute.getAttributeRef().getType();
        LScalarType type = ((LScalarType) _type);
        this.recursAliasMap(type, attribute, map);
      }
    }
    EList<DatamartNavigation> _navigations = entity.getNavigations();
    for (final DatamartNavigation navigation : _navigations) {
      this.createAliasMap(navigation.getDatamartEntity(), map);
    }
  }
  
  public LScalarType getAttributeType(final DatamartAttribute prop) {
    return prop.getAttributeRef().getType();
  }
  
  /**
   * <p>build a map for the filters contained in a datamart depending on a cube.</p>
   */
  public String createFilterMap(final DatamartDefinition definition) {
    String text = "";
    DatamartSource _source = definition.getSource();
    boolean _tripleNotEquals = (_source != null);
    if (_tripleNotEquals) {
      DatamartSource _source_1 = definition.getSource();
      if ((_source_1 instanceof DatamartCube)) {
        DatamartSource _source_2 = definition.getSource();
        DatamartCube cube = ((DatamartCube) _source_2);
        EList<DatamartCubeElement> _axisslicer = cube.getAxisslicer();
        for (final DatamartCubeElement axisslicer : _axisslicer) {
          {
            if (((axisslicer instanceof DatamartCubeAxis) && (((DatamartCubeAxis) axisslicer).getElements() != null))) {
              EList<DatamartElement> _elements = ((DatamartCubeAxis) axisslicer).getElements();
              for (final DatamartElement element : _elements) {
                if ((element instanceof DatamartSetAggregation)) {
                  DatamartSetAggregation setAggregation = ((DatamartSetAggregation) element);
                  Expression _set = setAggregation.getSet();
                  if ((_set instanceof DatamartHierarchy)) {
                    Expression _set_1 = setAggregation.getSet();
                    DatamartHierarchy hierarchy = ((DatamartHierarchy) _set_1);
                    String _createHierarchyFilter = this.createHierarchyFilter(hierarchy, definition);
                    String _plus = (text + _createHierarchyFilter);
                    text = _plus;
                  } else {
                    Expression _set_2 = setAggregation.getLeft().getSet();
                    if ((_set_2 instanceof DatamartHierarchy)) {
                      Expression _set_3 = setAggregation.getLeft().getSet();
                      DatamartHierarchy hierarchy_1 = ((DatamartHierarchy) _set_3);
                      String _createHierarchyFilter_1 = this.createHierarchyFilter(hierarchy_1, definition);
                      String _plus_1 = (text + _createHierarchyFilter_1);
                      text = _plus_1;
                    } else {
                      Expression _set_4 = setAggregation.getSet();
                      if ((_set_4 instanceof DatamartSetTuple)) {
                        Expression _set_5 = setAggregation.getSet();
                        DatamartHierarchy hierarchy_2 = ((DatamartSetTuple) _set_5).getRight();
                        String _createHierarchyFilter_2 = this.createHierarchyFilter(hierarchy_2, definition);
                        String _plus_2 = (text + _createHierarchyFilter_2);
                        text = _plus_2;
                      }
                    }
                  }
                } else {
                  if ((element instanceof DatamartHierarchy)) {
                    DatamartHierarchy hierarchy_3 = ((DatamartHierarchy) element);
                    String _createHierarchyFilter_3 = this.createHierarchyFilter(hierarchy_3, definition);
                    String _plus_3 = (text + _createHierarchyFilter_3);
                    text = _plus_3;
                  }
                }
              }
            }
            if (((axisslicer instanceof DatamartSlicer) && (((DatamartSlicer) axisslicer).getElement() != null))) {
              DatamartElement element_1 = ((DatamartSlicer) axisslicer).getElement();
              if ((element_1 instanceof DatamartHierarchy)) {
                DatamartHierarchy hierarchy_4 = ((DatamartHierarchy) element_1);
                String _createHierarchyFilter_4 = this.createHierarchyFilter(hierarchy_4, definition);
                String _plus_4 = (text + _createHierarchyFilter_4);
                text = _plus_4;
              }
            }
          }
        }
      }
      DatamartSource _source_3 = definition.getSource();
      if ((_source_3 instanceof DatamartEntity)) {
        DatamartSource _source_4 = definition.getSource();
        DatamartEntity entity = ((DatamartEntity) _source_4);
        text = this.createFiltermapCondition(entity, definition);
        String _addPrimaryFilters = this.addPrimaryFilters(definition);
        String _plus = (text + _addPrimaryFilters);
        text = _plus;
      }
      DatamartSource _source_5 = definition.getSource();
      if ((_source_5 instanceof DatamartTask)) {
        DatamartSource _source_6 = definition.getSource();
        DatamartTask task = ((DatamartTask) _source_6);
        String _createFiltermapCondition = this.createFiltermapCondition(task, definition);
        String _plus_1 = (text + _createFiltermapCondition);
        text = _plus_1;
      }
      int _length = text.length();
      boolean _greaterThan = (_length > 0);
      if (_greaterThan) {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("{{");
        _builder.newLine();
        _builder.append(text);
        _builder.newLineIfNotEmpty();
        _builder.append("}}");
        text = _builder.toString();
      }
    }
    return text;
  }
  
  public String createHierarchyFilter(final DatamartHierarchy hierarchy, final DatamartDefinition definition) {
    String text = "";
    String ordering = null;
    EObject _eContainer = hierarchy.getHierarchyRef().eContainer();
    if ((_eContainer instanceof CubeDimension)) {
      EObject _eContainer_1 = hierarchy.getHierarchyRef().eContainer();
      boolean _isTypeTime = ((CubeDimension) _eContainer_1).isTypeTime();
      if (_isTypeTime) {
        ordering = "DESC";
      }
    }
    boolean _isFiltered = hierarchy.isFiltered();
    if (_isFiltered) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(text);
      _builder.newLineIfNotEmpty();
      _builder.append("add(new DatamartFilter(");
      _builder.append(this.binderClassName);
      _builder.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.SINGLEHIERARCHY, \"");
      String _levelName = this.getLevelName(hierarchy, Boolean.valueOf(true), Boolean.valueOf(false), Boolean.valueOf(false), Boolean.valueOf(true));
      _builder.append(_levelName);
      _builder.append("\",\"");
      String _createMDXFilter = this.createMDXFilter(hierarchy, definition.getSource(), ordering, false);
      _builder.append(_createMDXFilter);
      _builder.append("\"));");
      _builder.newLineIfNotEmpty();
      text = _builder.toString();
    }
    boolean _isSelected = hierarchy.isSelected();
    if (_isSelected) {
      StringConcatenation _builder_1 = new StringConcatenation();
      _builder_1.append(text);
      _builder_1.newLineIfNotEmpty();
      _builder_1.append("add(new DatamartFilter(");
      _builder_1.append(this.binderClassName);
      _builder_1.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.MULTIPLEHIERARCHY, \"");
      String _levelName_1 = this.getLevelName(hierarchy, Boolean.valueOf(true), Boolean.valueOf(false), Boolean.valueOf(false), Boolean.valueOf(true));
      _builder_1.append(_levelName_1);
      _builder_1.append("\",\"");
      String _createMDXFilter_1 = this.createMDXFilter(hierarchy, definition.getSource(), ordering, false);
      _builder_1.append(_createMDXFilter_1);
      _builder_1.append("\"));");
      _builder_1.newLineIfNotEmpty();
      text = _builder_1.toString();
    }
    boolean _isExcept = hierarchy.isExcept();
    if (_isExcept) {
      StringConcatenation _builder_2 = new StringConcatenation();
      _builder_2.append(text);
      _builder_2.newLineIfNotEmpty();
      _builder_2.append("add(new DatamartFilter(");
      _builder_2.append(this.binderClassName);
      _builder_2.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.EXCEPT, \"");
      String _dimensionName = this.getDimensionName(hierarchy, Boolean.valueOf(true));
      String _plus = (_dimensionName + ".[");
      String _name = hierarchy.getExceptRef().getName();
      String _plus_1 = (_plus + _name);
      String _plus_2 = (_plus_1 + "]");
      _builder_2.append(_plus_2);
      _builder_2.append("\",\"");
      String _createMDXFilter_2 = this.createMDXFilter(hierarchy, definition.getSource(), ordering, true);
      _builder_2.append(_createMDXFilter_2);
      _builder_2.append("\"));");
      _builder_2.newLineIfNotEmpty();
      text = _builder_2.toString();
    }
    return text;
  }
  
  /**
   * <p>build a map for the filters contained in a datamart depending on entity.</p>
   */
  public String createPrimaryFilterId(final DatamartDefinition definition) {
    String text = "";
    if (((definition.getSource() != null) && (definition.getSource() instanceof DatamartEntity))) {
      DatamartSource _source = definition.getSource();
      DatamartEntity entity = ((DatamartEntity) _source);
      StringConcatenation _builder = new StringConcatenation();
      String _name = entity.getEntityRef().getName();
      _builder.append(_name);
      _builder.append(".");
      String _name_1 = entity.getEntityRef().getPrimaryKeyAttribute().getName();
      _builder.append(_name_1);
      text = _builder.toString();
    }
    return text;
  }
  
  /**
   * <p>build a map for the filters contained in a datamart depending on a task.</p>
   */
  public String createFiltermapCondition(final DatamartTask task, final DatamartDefinition definition) {
    String text = "";
    EList<DatamartCondition> _conditions = task.getConditions();
    for (final DatamartCondition condition : _conditions) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(text);
      _builder.newLineIfNotEmpty();
      String _createSQLFilter = this.createSQLFilter(condition, task, definition);
      _builder.append(_createSQLFilter);
      text = _builder.toString();
    }
    return text;
  }
  
  /**
   * <p>build the sql filter condition depending on an entity.</p>
   */
  public String createSQLFilter(final DatamartCondition condition, final DatamartTask task, final DatamartDefinition definition) {
    String text = "";
    Expression _condition = condition.getCondition();
    boolean _tripleNotEquals = (_condition != null);
    if (_tripleNotEquals) {
      Expression _condition_1 = condition.getCondition();
      if ((_condition_1 instanceof ConditionalExpression)) {
        Expression _condition_2 = condition.getCondition();
        Expression element = ((ConditionalExpression) _condition_2).getRight();
        Expression _condition_3 = condition.getCondition();
        Expression _left = ((ConditionalExpression) _condition_3).getLeft();
        if ((_left instanceof DatamartTaskFilter)) {
          Expression _condition_4 = condition.getCondition();
          Expression _left_1 = ((ConditionalExpression) _condition_4).getLeft();
          DatamartTaskFilter taskFilter = ((DatamartTaskFilter) _left_1);
          if ((element.isFiltered() || element.isSelected())) {
            StringConcatenation _builder = new StringConcatenation();
            String _literal = taskFilter.getFilterRef().getLiteral();
            _builder.append(_literal);
            String filter = _builder.toString();
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append(text);
            _builder_1.newLineIfNotEmpty();
            _builder_1.append("add(new DatamartFilter(");
            _builder_1.append(this.binderClassName);
            _builder_1.append(".getDSLMetadataService(), user, ");
            {
              boolean _isFiltered = element.isFiltered();
              if (_isFiltered) {
                _builder_1.append("DatamartFilter.FilterType.SINGLE");
              } else {
                boolean _isSelected = element.isSelected();
                if (_isSelected) {
                  _builder_1.append("DatamartFilter.FilterType.MULTIPLE");
                }
              }
            }
            _builder_1.append(", \"");
            String _literal_1 = taskFilter.getFilterRef().getLiteral();
            _builder_1.append(_literal_1);
            _builder_1.append("\",\"");
            _builder_1.append(filter);
            _builder_1.append("\"));");
            text = _builder_1.toString();
          }
        }
      }
    }
    return text;
  }
  
  /**
   * <p>build a map for the filters contained in a datamart depending on an entity.</p>
   */
  public String createFiltermapCondition(final DatamartEntity entity, final DatamartDefinition definition) {
    String text = "";
    EList<DatamartCondition> _conditions = entity.getConditions();
    for (final DatamartCondition condition : _conditions) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(text);
      _builder.newLineIfNotEmpty();
      String _createSQLFilter = this.createSQLFilter(condition, entity, definition);
      _builder.append(_createSQLFilter);
      text = _builder.toString();
    }
    EList<DatamartNavigation> _navigations = entity.getNavigations();
    for (final DatamartNavigation navigation : _navigations) {
      {
        if ((navigation instanceof DatamartMember)) {
          StringConcatenation _builder_1 = new StringConcatenation();
          _builder_1.append(text);
          _builder_1.newLineIfNotEmpty();
          String _createFiltermapCondition = this.createFiltermapCondition(((DatamartMember) navigation).getDatamartEntity(), definition);
          _builder_1.append(_createFiltermapCondition);
          text = _builder_1.toString();
        }
        if ((navigation instanceof DatamartOwner)) {
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append(text);
          _builder_2.newLineIfNotEmpty();
          String _createFiltermapCondition_1 = this.createFiltermapCondition(((DatamartOwner) navigation).getDatamartEntity(), definition);
          _builder_2.append(_createFiltermapCondition_1);
          text = _builder_2.toString();
        }
      }
    }
    return text;
  }
  
  /**
   * <p>build the sql filter condition depending on an entity.</p>
   */
  public String createSQLFilter(final DatamartCondition condition, final DatamartEntity entity, final DatamartDefinition definition) {
    String text = "";
    Expression _condition = condition.getCondition();
    boolean _tripleNotEquals = (_condition != null);
    if (_tripleNotEquals) {
      Expression _condition_1 = condition.getCondition();
      if ((_condition_1 instanceof ConditionalExpression)) {
        Expression _condition_2 = condition.getCondition();
        Expression element = ((ConditionalExpression) _condition_2).getRight();
        Expression _condition_3 = condition.getCondition();
        Expression leftCondExpr = ((ConditionalExpression) _condition_3).getLeft();
        if ((leftCondExpr instanceof DatamartAttributeBase)) {
          Expression _condition_4 = condition.getCondition();
          Expression _left = ((ConditionalExpression) _condition_4).getLeft();
          DatamartAttributeBase attribute = ((DatamartAttributeBase) _left);
          String filter = this.createSQLFilter(element, entity, attribute);
          boolean _isFiltered = element.isFiltered();
          if (_isFiltered) {
            StringConcatenation _builder = new StringConcatenation();
            _builder.append(text);
            _builder.append("add(new DatamartFilter(");
            _builder.append(this.binderClassName);
            _builder.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.SINGLE, \"");
            String _attributeName = this.getAttributeName(attribute, entity);
            _builder.append(_attributeName);
            _builder.append("\",\"");
            _builder.append(filter);
            _builder.append("\"));");
            text = _builder.toString();
          }
          boolean _isSelected = element.isSelected();
          if (_isSelected) {
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append(text);
            _builder_1.append("add(new DatamartFilter(");
            _builder_1.append(this.binderClassName);
            _builder_1.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.MULTIPLE, \"");
            String _attributeName_1 = this.getAttributeName(attribute, entity);
            _builder_1.append(_attributeName_1);
            _builder_1.append("\",\"");
            _builder_1.append(filter);
            _builder_1.append("\"));");
            text = _builder_1.toString();
          }
          boolean _isRanged = element.isRanged();
          if (_isRanged) {
            boolean _isDate = this._modelExtensions.getDatatype(attribute.getAttributeRef()).isDate();
            if (_isDate) {
              EList<LKeyAndValue> _properties = attribute.getAttributeRef().getProperties();
              boolean _tripleNotEquals_1 = (_properties != null);
              if (_tripleNotEquals_1) {
                StringConcatenation _builder_2 = new StringConcatenation();
                _builder_2.append(text);
                _builder_2.append("add(new DatamartFilter(");
                _builder_2.append(this.binderClassName);
                _builder_2.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.BETWEEN_DATE, dateFilterAttributeProperties.get(\"");
                String _attributeName_2 = this.getAttributeName(attribute, entity);
                _builder_2.append(_attributeName_2);
                _builder_2.append("\"), \"");
                String _attributeName_3 = this.getAttributeName(attribute, entity);
                _builder_2.append(_attributeName_3);
                _builder_2.append("\",\"\"));");
                text = _builder_2.toString();
              } else {
                StringConcatenation _builder_3 = new StringConcatenation();
                _builder_3.append(text);
                _builder_3.append("add(new DatamartFilter(");
                _builder_3.append(this.binderClassName);
                _builder_3.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.BETWEEN_DATE, \"");
                String _attributeName_4 = this.getAttributeName(attribute, entity);
                _builder_3.append(_attributeName_4);
                _builder_3.append("\",\"\"));");
                text = _builder_3.toString();
              }
            } else {
              StringConcatenation _builder_4 = new StringConcatenation();
              _builder_4.append(text);
              _builder_4.append("add(new DatamartFilter(");
              _builder_4.append(this.binderClassName);
              _builder_4.append(".getDSLMetadataService(), user, DatamartFilter.FilterType.BETWEEN, \"");
              String _attributeName_5 = this.getAttributeName(attribute, entity);
              _builder_4.append(_attributeName_5);
              _builder_4.append("\",\"\"));");
              text = _builder_4.toString();
            }
          }
        }
      }
    }
    return text;
  }
  
  public String createSQLFilter(final Expression element, final DatamartEntity entity, final DatamartAttributeBase attribute) {
    String tableName = this._namingExtensions.toTableName(entity.getEntityRef());
    boolean _hasSuperType = this.hasSuperType(entity);
    if (_hasSuperType) {
      tableName = this._namingExtensions.toTableName(entity.getEntityRef().getSuperType());
    }
    LScalarType type = attribute.getAttributeRef().getType();
    String filter = "";
    if ((type instanceof LDataType)) {
      if ((element.isOptional() && (!((LDataType)type).isDate()))) {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("select ");
        _builder.append(IDataMart.SQLFILTERNOTHING);
        _builder.append(" from ");
        _builder.append(EnumDatabaseVendor.ONE_ROW_ONE_COLUMN_TABLE);
        _builder.append(" union ");
        filter = _builder.toString();
      }
    }
    StringConcatenation _builder_1 = new StringConcatenation();
    _builder_1.append(filter);
    _builder_1.append("select distinct ");
    String _columnName = this._namingExtensions.toColumnName(attribute.getAttributeRef());
    _builder_1.append(_columnName);
    _builder_1.append(" as \\\"");
    String _aliasedAttributeName = DatamartAttributeUtil.getAliasedAttributeName(attribute);
    _builder_1.append(_aliasedAttributeName);
    _builder_1.append("\\\" from ");
    CharSequence _provideSchemaName = this.getProvideSchemaName(entity.getEntityRef().getPersistenceInfo().getSchemaName());
    _builder_1.append(_provideSchemaName);
    _builder_1.append(tableName);
    _builder_1.append(" order by 1");
    filter = _builder_1.toString();
    return filter;
  }
  
  /**
   * <p>build the mdx filter slice depending on a cube.</p>
   */
  public String createMDXFilter(final DatamartHierarchy hierarchy, final DatamartSource source, final String ordering, final boolean isExcept) {
    String filter = "select {} on columns,";
    if (((hierarchy.getLevelRef() != null) && (!isExcept))) {
      if ((ordering != null)) {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append(filter);
        _builder.append("Order(");
        String _levelName = this.getLevelName(hierarchy, Boolean.valueOf(true), Boolean.valueOf(false), Boolean.valueOf(false), Boolean.valueOf(true));
        _builder.append(_levelName);
        _builder.append(".members,[");
        String _hierarchyName = this.getHierarchyName(hierarchy);
        _builder.append(_hierarchyName);
        _builder.append("].CurrentMember.Properties(\\\"MEMBER_KEY\\\"),");
        _builder.append(ordering);
        _builder.append(") on rows");
        filter = _builder.toString();
      } else {
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append(filter);
        String _levelName_1 = this.getLevelName(hierarchy, Boolean.valueOf(true), Boolean.valueOf(false), Boolean.valueOf(false), Boolean.valueOf(true));
        _builder_1.append(_levelName_1);
        _builder_1.append(".members on rows");
        filter = _builder_1.toString();
      }
    }
    if (((hierarchy.getExceptRef() != null) && isExcept)) {
      if ((ordering != null)) {
        StringConcatenation _builder_2 = new StringConcatenation();
        _builder_2.append(filter);
        _builder_2.append("Order(");
        String _dimensionName = this.getDimensionName(hierarchy, Boolean.valueOf(true));
        String _plus = (_dimensionName + ".[");
        String _name = hierarchy.getExceptRef().getName();
        String _plus_1 = (_plus + _name);
        String _plus_2 = (_plus_1 + "]");
        _builder_2.append(_plus_2);
        _builder_2.append(".members,[");
        String _exceptHierarchyName = this.getExceptHierarchyName(hierarchy);
        _builder_2.append(_exceptHierarchyName);
        _builder_2.append("].CurrentMember.Properties(\\\"MEMBER_KEY\\\"),");
        _builder_2.append(ordering);
        _builder_2.append(") on rows");
        filter = _builder_2.toString();
      } else {
        StringConcatenation _builder_3 = new StringConcatenation();
        _builder_3.append(filter);
        String _dimensionName_1 = this.getDimensionName(hierarchy, Boolean.valueOf(true));
        String _plus_3 = (_dimensionName_1 + ".[");
        String _name_1 = hierarchy.getExceptRef().getName();
        String _plus_4 = (_plus_3 + _name_1);
        String _plus_5 = (_plus_4 + "]");
        _builder_3.append(_plus_5);
        _builder_3.append(".members on rows");
        filter = _builder_3.toString();
      }
    }
    if ((source instanceof DatamartCube)) {
      StringConcatenation _builder_4 = new StringConcatenation();
      _builder_4.append(filter);
      _builder_4.append(" from ");
      String _name_2 = ((DatamartCube) source).getCubeRef().getName();
      _builder_4.append(_name_2);
      filter = _builder_4.toString();
    }
    return filter;
  }
  
  /**
   * <p>helper to get a level name.</p>
   */
  public String getFilterAlias(final DatamartHierarchy level) {
    String text = "";
    CubeLevel _levelRef = level.getLevelRef();
    boolean _tripleNotEquals = (_levelRef != null);
    if (_tripleNotEquals) {
      StringConcatenation _builder = new StringConcatenation();
      String _dimensionName = this.getDimensionName(level, Boolean.valueOf(false));
      _builder.append(_dimensionName);
      String _firstUpper = StringExtensions.toFirstUpper(level.getLevelRef().getName());
      _builder.append(_firstUpper);
      text = _builder.toString();
    }
    return text;
  }
  
  /**
   * <p>mdx syntax part for aggregations on sets.</p>
   */
  public String createSetAggregation(final List<DatamartSetAggregation> usedSetAggregation, final Boolean nonEmpty) {
    String set = "";
    boolean firstTuple = true;
    for (final DatamartSetAggregation element : usedSetAggregation) {
      {
        if (firstTuple) {
          firstTuple = false;
        } else {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append(set);
          _builder.append(",");
          set = _builder.toString();
        }
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append(set);
        String _evaluateExpression = this.evaluateExpression(element, null);
        _builder_1.append(_evaluateExpression);
        set = _builder_1.toString();
      }
    }
    int _size = usedSetAggregation.size();
    boolean _greaterThan = (_size > 1);
    if (_greaterThan) {
      StringConcatenation _builder = new StringConcatenation();
      {
        if ((nonEmpty).booleanValue()) {
          _builder.append("Non Empty");
        }
      }
      _builder.append("{");
      _builder.append(set);
      _builder.append("}");
      set = _builder.toString();
    } else {
      int _size_1 = usedSetAggregation.size();
      boolean _greaterThan_1 = (_size_1 > 0);
      if (_greaterThan_1) {
        StringConcatenation _builder_1 = new StringConcatenation();
        {
          if ((nonEmpty).booleanValue()) {
            _builder_1.append("Non Empty ");
          }
        }
        _builder_1.append(set);
        set = _builder_1.toString();
      }
    }
    return set;
  }
  
  /**
   * <p>mdx syntax part for hierarchies.</p>
   */
  public String createHierarchies(final List<DatamartHierarchy> usedHierarchies, final Boolean nonEmpty) {
    String set = "";
    boolean firstTuple = true;
    for (final DatamartHierarchy element : usedHierarchies) {
      {
        if (firstTuple) {
          firstTuple = false;
        } else {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append(set);
          _builder.append(",");
          set = _builder.toString();
        }
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append(set);
        String _levelName = this.getLevelName(element, Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
        _builder_1.append(_levelName);
        set = _builder_1.toString();
      }
    }
    int _size = usedHierarchies.size();
    boolean _greaterThan = (_size > 1);
    if (_greaterThan) {
      StringConcatenation _builder = new StringConcatenation();
      {
        if ((nonEmpty).booleanValue()) {
          _builder.append("Non Empty");
        }
      }
      _builder.append("{");
      _builder.append(set);
      _builder.append("}");
      set = _builder.toString();
    } else {
      int _size_1 = usedHierarchies.size();
      boolean _greaterThan_1 = (_size_1 > 0);
      if (_greaterThan_1) {
        StringConcatenation _builder_1 = new StringConcatenation();
        {
          if ((nonEmpty).booleanValue()) {
            _builder_1.append("Non Empty ");
          }
        }
        _builder_1.append(set);
        set = _builder_1.toString();
      }
    }
    return set;
  }
  
  /**
   * <p>mdx syntax part for measures.</p>
   */
  public String createMeasures(final List<DatamartMeasure> usedMeasures, final List<DatamartDerivedMeasure> usedDerived, final Boolean nonEmpty) {
    String set = "";
    boolean firstTuple = true;
    for (final DatamartMeasure element : usedMeasures) {
      {
        if (firstTuple) {
          firstTuple = false;
        } else {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append(set);
          _builder.append(",");
          set = _builder.toString();
        }
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append(set);
        String _measureName = this.getMeasureName(element);
        _builder_1.append(_measureName);
        set = _builder_1.toString();
      }
    }
    for (final DatamartDerivedMeasure element_1 : usedDerived) {
      {
        if (firstTuple) {
          firstTuple = false;
        } else {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append(set);
          _builder.append(",");
          set = _builder.toString();
        }
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append(set);
        String _derivedMeasureName = this.getDerivedMeasureName(element_1);
        _builder_1.append(_derivedMeasureName);
        set = _builder_1.toString();
      }
    }
    int _size = usedMeasures.size();
    int _size_1 = usedDerived.size();
    int _plus = (_size + _size_1);
    boolean _greaterThan = (_plus > 1);
    if (_greaterThan) {
      StringConcatenation _builder = new StringConcatenation();
      {
        if ((nonEmpty).booleanValue()) {
          _builder.append("Non Empty");
        }
      }
      _builder.append("{");
      _builder.append(set);
      _builder.append("}");
      set = _builder.toString();
    } else {
      int _size_2 = usedMeasures.size();
      int _size_3 = usedDerived.size();
      int _plus_1 = (_size_2 + _size_3);
      boolean _greaterThan_1 = (_plus_1 > 0);
      if (_greaterThan_1) {
        StringConcatenation _builder_1 = new StringConcatenation();
        {
          if ((nonEmpty).booleanValue()) {
            _builder_1.append("Non Empty ");
          }
        }
        _builder_1.append(set);
        set = _builder_1.toString();
      }
    }
    return set;
  }
  
  /**
   * <p>the main function to build a mdx statement.</p>
   */
  public String createMDXStatement(final DatamartDefinition definition) {
    this.sqlAliasCounter.clear();
    this.sqlFilterMap.clear();
    this.ignoreEntityGrouping = false;
    this.sqlHasAggregate = false;
    this.sqlHasOrder = false;
    this.idMap.clear();
    DatamartSource _source = definition.getSource();
    DatamartCube cube = ((DatamartCube) _source);
    String body = "";
    String slice = "";
    String derived = "";
    boolean firstAxis = true;
    boolean firstSlice = true;
    boolean firstderived = true;
    EList<DatamartCubeElement> _axisslicer = cube.getAxisslicer();
    for (final DatamartCubeElement axisslicer : _axisslicer) {
      {
        if ((axisslicer instanceof DatamartCubeAxis)) {
          boolean crossJoinMeasure = false;
          boolean crossJoinHierarchy = false;
          boolean crossJoinSetAggregation = false;
          DatamartCubeAxis axis = ((DatamartCubeAxis) axisslicer);
          if (firstAxis) {
            firstAxis = false;
          } else {
            StringConcatenation _builder = new StringConcatenation();
            _builder.append(body);
            _builder.append(",");
            body = _builder.toString();
          }
          EList<DatamartElement> _elements = axis.getElements();
          boolean _tripleNotEquals = (_elements != null);
          if (_tripleNotEquals) {
            String set = "";
            final ArrayList<DatamartHierarchy> usedHierarchies = CollectionLiterals.<DatamartHierarchy>newArrayList();
            final ArrayList<DatamartMeasure> usedMeasures = CollectionLiterals.<DatamartMeasure>newArrayList();
            final ArrayList<DatamartDerivedMeasure> usedDerivedMeasure = CollectionLiterals.<DatamartDerivedMeasure>newArrayList();
            final ArrayList<DatamartSetAggregation> usedSetAggregation = CollectionLiterals.<DatamartSetAggregation>newArrayList();
            EList<DatamartElement> _elements_1 = axis.getElements();
            for (final DatamartElement element : _elements_1) {
              {
                if ((element instanceof DatamartSetAggregation)) {
                  if (((usedMeasures.size() > 0) || (usedDerivedMeasure.size() > 0))) {
                    if (crossJoinMeasure) {
                      StringConcatenation _builder_1 = new StringConcatenation();
                      _builder_1.append(set);
                      _builder_1.append(",");
                      set = _builder_1.toString();
                    }
                    StringConcatenation _builder_2 = new StringConcatenation();
                    {
                      boolean _isNonEmpty = cube.isNonEmpty();
                      if (_isNonEmpty) {
                        _builder_2.append("NonEmptyCrossjoin");
                      } else {
                        _builder_2.append("CrossJoin");
                      }
                    }
                    _builder_2.append("(");
                    _builder_2.append(set);
                    String _createMeasures = this.createMeasures(usedMeasures, usedDerivedMeasure, Boolean.valueOf(false));
                    _builder_2.append(_createMeasures);
                    set = _builder_2.toString();
                    if (crossJoinMeasure) {
                      StringConcatenation _builder_3 = new StringConcatenation();
                      _builder_3.append(set);
                      _builder_3.append(")");
                      set = _builder_3.toString();
                    }
                    usedMeasures.clear();
                    usedDerivedMeasure.clear();
                    crossJoinSetAggregation = true;
                  }
                  int _size = usedHierarchies.size();
                  boolean _greaterThan = (_size > 0);
                  if (_greaterThan) {
                    if (crossJoinHierarchy) {
                      StringConcatenation _builder_4 = new StringConcatenation();
                      _builder_4.append(set);
                      _builder_4.append(",");
                      set = _builder_4.toString();
                    }
                    StringConcatenation _builder_5 = new StringConcatenation();
                    {
                      boolean _isNonEmpty_1 = cube.isNonEmpty();
                      if (_isNonEmpty_1) {
                        _builder_5.append("NonEmptyCrossjoin");
                      } else {
                        _builder_5.append("CrossJoin");
                      }
                    }
                    _builder_5.append("(");
                    _builder_5.append(set);
                    String _createHierarchies = this.createHierarchies(usedHierarchies, Boolean.valueOf(false));
                    _builder_5.append(_createHierarchies);
                    set = _builder_5.toString();
                    if (crossJoinHierarchy) {
                      StringConcatenation _builder_6 = new StringConcatenation();
                      _builder_6.append(set);
                      _builder_6.append(")");
                      set = _builder_6.toString();
                    }
                    usedHierarchies.clear();
                    crossJoinSetAggregation = true;
                  }
                  DatamartSetAggregation setAggregation = ((DatamartSetAggregation) element);
                  usedSetAggregation.add(setAggregation);
                }
                if ((element instanceof DatamartHierarchy)) {
                  if (((usedMeasures.size() > 0) || (usedDerivedMeasure.size() > 0))) {
                    if (crossJoinMeasure) {
                      StringConcatenation _builder_7 = new StringConcatenation();
                      _builder_7.append(set);
                      _builder_7.append(",");
                      set = _builder_7.toString();
                    }
                    StringConcatenation _builder_8 = new StringConcatenation();
                    {
                      boolean _isNonEmpty_2 = cube.isNonEmpty();
                      if (_isNonEmpty_2) {
                        _builder_8.append("NonEmptyCrossjoin");
                      } else {
                        _builder_8.append("CrossJoin");
                      }
                    }
                    _builder_8.append("(");
                    _builder_8.append(set);
                    String _createMeasures_1 = this.createMeasures(usedMeasures, usedDerivedMeasure, Boolean.valueOf(false));
                    _builder_8.append(_createMeasures_1);
                    set = _builder_8.toString();
                    if (crossJoinMeasure) {
                      StringConcatenation _builder_9 = new StringConcatenation();
                      _builder_9.append(set);
                      _builder_9.append(")");
                      set = _builder_9.toString();
                    }
                    usedMeasures.clear();
                    usedDerivedMeasure.clear();
                    crossJoinMeasure = true;
                  }
                  int _size_1 = usedSetAggregation.size();
                  boolean _greaterThan_1 = (_size_1 > 0);
                  if (_greaterThan_1) {
                    if (crossJoinSetAggregation) {
                      StringConcatenation _builder_10 = new StringConcatenation();
                      _builder_10.append(set);
                      _builder_10.append(",");
                      set = _builder_10.toString();
                    }
                    StringConcatenation _builder_11 = new StringConcatenation();
                    {
                      boolean _isNonEmpty_3 = cube.isNonEmpty();
                      if (_isNonEmpty_3) {
                        _builder_11.append("NonEmptyCrossjoin");
                      } else {
                        _builder_11.append("CrossJoin");
                      }
                    }
                    _builder_11.append("(");
                    _builder_11.append(set);
                    String _createSetAggregation = this.createSetAggregation(usedSetAggregation, Boolean.valueOf(false));
                    _builder_11.append(_createSetAggregation);
                    set = _builder_11.toString();
                    if (crossJoinSetAggregation) {
                      StringConcatenation _builder_12 = new StringConcatenation();
                      _builder_12.append(set);
                      _builder_12.append(")");
                      set = _builder_12.toString();
                    }
                    usedSetAggregation.clear();
                    crossJoinSetAggregation = true;
                  }
                  DatamartHierarchy hierarchyLevel = ((DatamartHierarchy) element);
                  DatamartHierarchy lastHierarchy = IterableExtensions.<DatamartHierarchy>last(usedHierarchies);
                  if (((!crossJoinHierarchy) && ((lastHierarchy == null) || 
                    this.getHierarchyName(hierarchyLevel).equals(this.getHierarchyName(lastHierarchy))))) {
                    usedHierarchies.add(hierarchyLevel);
                  } else {
                    if (crossJoinHierarchy) {
                      StringConcatenation _builder_13 = new StringConcatenation();
                      _builder_13.append(set);
                      _builder_13.append(",");
                      set = _builder_13.toString();
                    }
                    StringConcatenation _builder_14 = new StringConcatenation();
                    {
                      boolean _isNonEmpty_4 = cube.isNonEmpty();
                      if (_isNonEmpty_4) {
                        _builder_14.append("NonEmptyCrossjoin");
                      } else {
                        _builder_14.append("CrossJoin");
                      }
                    }
                    _builder_14.append("(");
                    _builder_14.append(set);
                    String _createHierarchies_1 = this.createHierarchies(usedHierarchies, Boolean.valueOf(false));
                    _builder_14.append(_createHierarchies_1);
                    set = _builder_14.toString();
                    if (crossJoinHierarchy) {
                      StringConcatenation _builder_15 = new StringConcatenation();
                      _builder_15.append(set);
                      _builder_15.append(")");
                      set = _builder_15.toString();
                    }
                    usedHierarchies.clear();
                    usedHierarchies.add(hierarchyLevel);
                    crossJoinHierarchy = true;
                  }
                }
                if ((element instanceof DatamartMeasure)) {
                  int _size_2 = usedHierarchies.size();
                  boolean _greaterThan_2 = (_size_2 > 0);
                  if (_greaterThan_2) {
                    if (crossJoinMeasure) {
                      StringConcatenation _builder_16 = new StringConcatenation();
                      _builder_16.append(set);
                      _builder_16.append(",");
                      set = _builder_16.toString();
                    }
                    StringConcatenation _builder_17 = new StringConcatenation();
                    {
                      boolean _isNonEmpty_5 = cube.isNonEmpty();
                      if (_isNonEmpty_5) {
                        _builder_17.append("NonEmptyCrossjoin");
                      } else {
                        _builder_17.append("CrossJoin");
                      }
                    }
                    _builder_17.append("(");
                    _builder_17.append(set);
                    String _createHierarchies_2 = this.createHierarchies(usedHierarchies, Boolean.valueOf(false));
                    _builder_17.append(_createHierarchies_2);
                    set = _builder_17.toString();
                    if (crossJoinMeasure) {
                      StringConcatenation _builder_18 = new StringConcatenation();
                      _builder_18.append(set);
                      _builder_18.append(")");
                      set = _builder_18.toString();
                    }
                    usedHierarchies.clear();
                    crossJoinMeasure = true;
                  }
                  int _size_3 = usedSetAggregation.size();
                  boolean _greaterThan_3 = (_size_3 > 0);
                  if (_greaterThan_3) {
                    if (crossJoinSetAggregation) {
                      StringConcatenation _builder_19 = new StringConcatenation();
                      _builder_19.append(set);
                      _builder_19.append(",");
                      set = _builder_19.toString();
                    }
                    StringConcatenation _builder_20 = new StringConcatenation();
                    {
                      boolean _isNonEmpty_6 = cube.isNonEmpty();
                      if (_isNonEmpty_6) {
                        _builder_20.append("NonEmptyCrossjoin");
                      } else {
                        _builder_20.append("CrossJoin");
                      }
                    }
                    _builder_20.append("(");
                    _builder_20.append(set);
                    String _createSetAggregation_1 = this.createSetAggregation(usedSetAggregation, Boolean.valueOf(false));
                    _builder_20.append(_createSetAggregation_1);
                    set = _builder_20.toString();
                    if (crossJoinSetAggregation) {
                      StringConcatenation _builder_21 = new StringConcatenation();
                      _builder_21.append(set);
                      _builder_21.append(")");
                      set = _builder_21.toString();
                    }
                    usedSetAggregation.clear();
                    crossJoinSetAggregation = true;
                  }
                  DatamartMeasure measure = ((DatamartMeasure) element);
                  usedMeasures.add(measure);
                }
                if ((element instanceof DatamartDerivedMeasure)) {
                  int _size_4 = usedHierarchies.size();
                  boolean _greaterThan_4 = (_size_4 > 0);
                  if (_greaterThan_4) {
                    if (crossJoinMeasure) {
                      StringConcatenation _builder_22 = new StringConcatenation();
                      _builder_22.append(set);
                      _builder_22.append(",");
                      set = _builder_22.toString();
                    }
                    StringConcatenation _builder_23 = new StringConcatenation();
                    {
                      boolean _isNonEmpty_7 = cube.isNonEmpty();
                      if (_isNonEmpty_7) {
                        _builder_23.append("NonEmptyCrossjoin");
                      } else {
                        _builder_23.append("CrossJoin");
                      }
                    }
                    _builder_23.append("(");
                    _builder_23.append(set);
                    String _createHierarchies_3 = this.createHierarchies(usedHierarchies, Boolean.valueOf(false));
                    _builder_23.append(_createHierarchies_3);
                    set = _builder_23.toString();
                    if (crossJoinMeasure) {
                      StringConcatenation _builder_24 = new StringConcatenation();
                      _builder_24.append(set);
                      _builder_24.append(")");
                      set = _builder_24.toString();
                    }
                    usedHierarchies.clear();
                    crossJoinMeasure = true;
                  }
                  int _size_5 = usedSetAggregation.size();
                  boolean _greaterThan_5 = (_size_5 > 0);
                  if (_greaterThan_5) {
                    if (crossJoinSetAggregation) {
                      StringConcatenation _builder_25 = new StringConcatenation();
                      _builder_25.append(set);
                      _builder_25.append(",");
                      set = _builder_25.toString();
                    }
                    StringConcatenation _builder_26 = new StringConcatenation();
                    {
                      boolean _isNonEmpty_8 = cube.isNonEmpty();
                      if (_isNonEmpty_8) {
                        _builder_26.append("NonEmptyCrossjoin");
                      } else {
                        _builder_26.append("CrossJoin");
                      }
                    }
                    _builder_26.append("(");
                    _builder_26.append(set);
                    String _createSetAggregation_2 = this.createSetAggregation(usedSetAggregation, Boolean.valueOf(false));
                    _builder_26.append(_createSetAggregation_2);
                    set = _builder_26.toString();
                    if (crossJoinSetAggregation) {
                      StringConcatenation _builder_27 = new StringConcatenation();
                      _builder_27.append(set);
                      _builder_27.append(")");
                      set = _builder_27.toString();
                    }
                    usedSetAggregation.clear();
                    crossJoinSetAggregation = true;
                  }
                  DatamartDerivedMeasure measure_1 = ((DatamartDerivedMeasure) element);
                  usedDerivedMeasure.add(measure_1);
                }
              }
            }
            if (((crossJoinMeasure || crossJoinHierarchy) || crossJoinSetAggregation)) {
              StringConcatenation _builder_1 = new StringConcatenation();
              _builder_1.append(set);
              _builder_1.append(",");
              set = _builder_1.toString();
            }
            StringConcatenation _builder_2 = new StringConcatenation();
            _builder_2.append(set);
            String _createHierarchies = this.createHierarchies(usedHierarchies, 
              Boolean.valueOf((cube.isNonEmpty() && (!((crossJoinMeasure || crossJoinHierarchy) || crossJoinSetAggregation)))));
            _builder_2.append(_createHierarchies);
            set = _builder_2.toString();
            usedHierarchies.clear();
            StringConcatenation _builder_3 = new StringConcatenation();
            _builder_3.append(set);
            String _createMeasures = this.createMeasures(usedMeasures, usedDerivedMeasure, 
              Boolean.valueOf((cube.isNonEmpty() && (!((crossJoinMeasure || crossJoinHierarchy) || crossJoinSetAggregation)))));
            _builder_3.append(_createMeasures);
            set = _builder_3.toString();
            usedMeasures.clear();
            usedDerivedMeasure.clear();
            StringConcatenation _builder_4 = new StringConcatenation();
            _builder_4.append(set);
            String _createSetAggregation = this.createSetAggregation(usedSetAggregation, 
              Boolean.valueOf((cube.isNonEmpty() && (!((crossJoinMeasure || crossJoinHierarchy) || crossJoinSetAggregation)))));
            _builder_4.append(_createSetAggregation);
            set = _builder_4.toString();
            usedMeasures.clear();
            if (((crossJoinMeasure || crossJoinHierarchy) || crossJoinSetAggregation)) {
              StringConcatenation _builder_5 = new StringConcatenation();
              _builder_5.append(set);
              _builder_5.append(")");
              set = _builder_5.toString();
            }
            StringConcatenation _builder_6 = new StringConcatenation();
            _builder_6.append(body);
            _builder_6.append(set);
            _builder_6.append(" on ");
            AxisEnum _name = axis.getAxis().getName();
            _builder_6.append(_name);
            body = _builder_6.toString();
          }
        }
        if ((axisslicer instanceof DatamartSlicer)) {
          if (firstSlice) {
            firstSlice = false;
          } else {
            StringConcatenation _builder_7 = new StringConcatenation();
            _builder_7.append(slice);
            _builder_7.append(",");
            slice = _builder_7.toString();
          }
          DatamartElement element_1 = ((DatamartSlicer) axisslicer).getElement();
          if ((element_1 instanceof DatamartHierarchy)) {
            DatamartHierarchy hierarchyLevel = ((DatamartHierarchy) element_1);
            StringConcatenation _builder_8 = new StringConcatenation();
            _builder_8.append(slice);
            String _levelName = this.getLevelName(hierarchyLevel, Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true));
            _builder_8.append(_levelName);
            slice = _builder_8.toString();
          }
          if ((element_1 instanceof DatamartMeasure)) {
            StringConcatenation _builder_9 = new StringConcatenation();
            _builder_9.append(slice);
            String _measureName = this.getMeasureName(((DatamartMeasure) element_1));
            _builder_9.append(_measureName);
            slice = _builder_9.toString();
          }
        }
        if ((axisslicer instanceof DatamartDefineDerivedMeasure)) {
          if (firstderived) {
            firstderived = false;
          }
          DatamartDefineDerivedMeasure derivedMeasure = ((DatamartDefineDerivedMeasure) axisslicer);
          StringConcatenation _builder_10 = new StringConcatenation();
          _builder_10.append(derived);
          _builder_10.append(" member [Measures].[");
          String _name_1 = derivedMeasure.getName();
          _builder_10.append(_name_1);
          _builder_10.append("] as ");
          String _buildDerivedFormula = this.buildDerivedFormula(derivedMeasure);
          _builder_10.append(_buildDerivedFormula);
          derived = _builder_10.toString();
        }
      }
    }
    if ((!firstSlice)) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(" ");
      _builder.append("where (");
      _builder.append(slice, " ");
      _builder.append(")");
      slice = _builder.toString();
    }
    if ((!firstderived)) {
      StringConcatenation _builder_1 = new StringConcatenation();
      _builder_1.append("with");
      _builder_1.append(derived);
      _builder_1.append(" ");
      derived = _builder_1.toString();
    }
    StringConcatenation _builder_2 = new StringConcatenation();
    _builder_2.append(derived);
    _builder_2.append("select ");
    _builder_2.append(body);
    _builder_2.append(" from ");
    String _name = cube.getCubeRef().getName();
    _builder_2.append(_name);
    _builder_2.append(slice);
    return _builder_2.toString();
  }
  
  public boolean isCrossJoined(final DatamartDefinition definition) {
    DatamartSource _source = definition.getSource();
    boolean _not = (!(_source instanceof DatamartCube));
    if (_not) {
      return false;
    }
    DatamartSource _source_1 = definition.getSource();
    DatamartCube cube = ((DatamartCube) _source_1);
    boolean firstAxis = true;
    EList<DatamartCubeElement> _axisslicer = cube.getAxisslicer();
    for (final DatamartCubeElement axisslicer : _axisslicer) {
      if ((axisslicer instanceof DatamartCubeAxis)) {
        boolean crossJoinMeasure = false;
        boolean crossJoinHierarchy = false;
        boolean crossJoinSetAggregation = false;
        DatamartCubeAxis axis = ((DatamartCubeAxis) axisslicer);
        if (firstAxis) {
          firstAxis = false;
        }
        EList<DatamartElement> _elements = axis.getElements();
        boolean _tripleNotEquals = (_elements != null);
        if (_tripleNotEquals) {
          final ArrayList<DatamartHierarchy> usedHierarchies = CollectionLiterals.<DatamartHierarchy>newArrayList();
          final ArrayList<DatamartMeasure> usedMeasures = CollectionLiterals.<DatamartMeasure>newArrayList();
          final ArrayList<DatamartDerivedMeasure> usedDerivedMeasure = CollectionLiterals.<DatamartDerivedMeasure>newArrayList();
          final ArrayList<DatamartSetAggregation> usedSetAggregation = CollectionLiterals.<DatamartSetAggregation>newArrayList();
          EList<DatamartElement> _elements_1 = axis.getElements();
          for (final DatamartElement element : _elements_1) {
            {
              if ((element instanceof DatamartSetAggregation)) {
                if (((usedMeasures.size() > 0) || (usedDerivedMeasure.size() > 0))) {
                  usedMeasures.clear();
                  usedDerivedMeasure.clear();
                  crossJoinSetAggregation = true;
                }
                int _size = usedHierarchies.size();
                boolean _greaterThan = (_size > 0);
                if (_greaterThan) {
                  usedHierarchies.clear();
                  crossJoinSetAggregation = true;
                }
                DatamartSetAggregation setAggregation = ((DatamartSetAggregation) element);
                usedSetAggregation.add(setAggregation);
              }
              if ((element instanceof DatamartHierarchy)) {
                if (((usedMeasures.size() > 0) || (usedDerivedMeasure.size() > 0))) {
                  usedMeasures.clear();
                  usedDerivedMeasure.clear();
                  crossJoinMeasure = true;
                }
                int _size_1 = usedSetAggregation.size();
                boolean _greaterThan_1 = (_size_1 > 0);
                if (_greaterThan_1) {
                  usedSetAggregation.clear();
                  crossJoinSetAggregation = true;
                }
                DatamartHierarchy hierarchyLevel = ((DatamartHierarchy) element);
                DatamartHierarchy lastHierarchy = IterableExtensions.<DatamartHierarchy>last(usedHierarchies);
                if (((!crossJoinHierarchy) && ((lastHierarchy == null) || 
                  this.getHierarchyName(hierarchyLevel).equals(this.getHierarchyName(lastHierarchy))))) {
                  usedHierarchies.add(hierarchyLevel);
                } else {
                  usedHierarchies.clear();
                  usedHierarchies.add(hierarchyLevel);
                  crossJoinHierarchy = true;
                }
              }
              if ((element instanceof DatamartMeasure)) {
                int _size_2 = usedHierarchies.size();
                boolean _greaterThan_2 = (_size_2 > 0);
                if (_greaterThan_2) {
                  usedHierarchies.clear();
                  crossJoinMeasure = true;
                }
                int _size_3 = usedSetAggregation.size();
                boolean _greaterThan_3 = (_size_3 > 0);
                if (_greaterThan_3) {
                  usedSetAggregation.clear();
                  crossJoinSetAggregation = true;
                }
                DatamartMeasure measure = ((DatamartMeasure) element);
                usedMeasures.add(measure);
              }
              if ((element instanceof DatamartDerivedMeasure)) {
                int _size_4 = usedHierarchies.size();
                boolean _greaterThan_4 = (_size_4 > 0);
                if (_greaterThan_4) {
                  usedHierarchies.clear();
                  crossJoinMeasure = true;
                }
                int _size_5 = usedSetAggregation.size();
                boolean _greaterThan_5 = (_size_5 > 0);
                if (_greaterThan_5) {
                  usedSetAggregation.clear();
                  crossJoinSetAggregation = true;
                }
                DatamartDerivedMeasure measure_1 = ((DatamartDerivedMeasure) element);
                usedDerivedMeasure.add(measure_1);
              }
            }
          }
          usedMeasures.clear();
          usedDerivedMeasure.clear();
          usedMeasures.clear();
        }
        return ((crossJoinMeasure || crossJoinHierarchy) || crossJoinSetAggregation);
      }
    }
    return false;
  }
  
  /**
   * <p>mdx syntax part for hierarchy names. If a hierarchy itself has no name in the cube definition, the dimension name is used instead</p>
   */
  public String getHierarchyName(final DatamartHierarchy hierarchy) {
    String _xifexpression = null;
    String _name = hierarchy.getHierarchyRef().getName();
    boolean _tripleEquals = (_name == null);
    if (_tripleEquals) {
      EObject _eContainer = hierarchy.getHierarchyRef().eContainer();
      return ((CubeDimension) _eContainer).getName();
    } else {
      _xifexpression = hierarchy.getHierarchyRef().getName();
    }
    return _xifexpression;
  }
  
  /**
   * <p>mdx syntax part for hierarchy names of execpt keyword. If a hierarchy itself has no name in the cube definition, the dimension name is used instead</p>
   */
  public String getExceptHierarchyName(final DatamartHierarchy hierarchy) {
    String _xifexpression = null;
    String _name = hierarchy.getExceptRef().getName();
    boolean _tripleEquals = (_name == null);
    if (_tripleEquals) {
      EObject _eContainer = hierarchy.getExceptRef().eContainer();
      return ((CubeDimension) _eContainer).getName();
    } else {
      _xifexpression = hierarchy.getExceptRef().getName();
    }
    return _xifexpression;
  }
  
  /**
   * <p>mdx syntax part for derived measure expressions.</p>
   */
  public String buildDerivedFormula(final DatamartDefineDerivedMeasure derivedMeasure) {
    String formula = "";
    EList<Expression> _derivedElement = derivedMeasure.getDerivedElement();
    for (final Expression element : _derivedElement) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(formula);
      String _evaluateExpression = this.evaluateExpression(element, null);
      _builder.append(_evaluateExpression);
      formula = _builder.toString();
    }
    return "\'".concat(formula).concat("\'");
  }
  
  /**
   * <p>as the grammar makes use of expressions along an abstract syntax tree, we need this recursive dispatcher to synthesize resulting code.</p>
   */
  public String evaluateExpression(final Expression element, final DatamartEntity entity) {
    String evaluation = "";
    String _value = element.getValue();
    boolean _tripleNotEquals = (_value != null);
    if (_tripleNotEquals) {
      evaluation = element.getValue();
    }
    String _numberValue = element.getNumberValue();
    boolean _tripleNotEquals_1 = (_numberValue != null);
    if (_tripleNotEquals_1) {
      evaluation = element.getNumberValue();
    }
    String _stringValue = element.getStringValue();
    boolean _tripleNotEquals_2 = (_stringValue != null);
    if (_tripleNotEquals_2) {
      evaluation = "\'".concat(element.getStringValue()).concat("\'");
    }
    if (((element.isFiltered() || element.isSelected()) || element.isRanged())) {
      StringConcatenation _builder = new StringConcatenation();
      EObject _eContainer = element.eContainer();
      Expression _left = ((ConditionalExpression) _eContainer).getLeft();
      String _decorate = DatamartFilter.decorate(this.getAttributeName(((DatamartAttributeBase) _left), entity));
      _builder.append(_decorate);
      evaluation = _builder.toString();
    }
    boolean _isUnreferenced = element.isUnreferenced();
    if (_isUnreferenced) {
      EObject _eContainer_1 = element.eContainer();
      Expression leftConditionExpression = ((ConditionalExpression) _eContainer_1).getLeft();
      LEntityFeature entityF = null;
      if ((leftConditionExpression instanceof DatamartReferenceBase)) {
        EObject _eContainer_2 = element.eContainer();
        Expression _left_1 = ((ConditionalExpression) _eContainer_2).getLeft();
        entityF = ((DatamartReferenceBase) _left_1).getReferenceRef();
      } else {
        if ((leftConditionExpression instanceof DatamartAttributeBase)) {
          EObject _eContainer_3 = element.eContainer();
          Expression _left_2 = ((ConditionalExpression) _eContainer_3).getLeft();
          entityF = ((DatamartAttributeBase) _left_2).getAttributeRef();
        }
      }
      if ((entityF != null)) {
        StringConcatenation _builder_1 = new StringConcatenation();
        String _name = entityF.getEntity().getName();
        _builder_1.append(_name);
        _builder_1.append(".");
        String _columnName = this._namingExtensions.toColumnName(entityF);
        _builder_1.append(_columnName);
        _builder_1.append(" is null");
        evaluation = _builder_1.toString();
      }
    }
    DatamartFunctionInterface _function = element.getFunction();
    boolean _tripleNotEquals_3 = (_function != null);
    if (_tripleNotEquals_3) {
      DatamartFunctionInterface _function_1 = element.getFunction();
      if ((_function_1 instanceof DatamartFunction)) {
        StringConcatenation _builder_2 = new StringConcatenation();
        _builder_2.append(evaluation);
        String _levelName = this.getLevelName(element.getHierarchy(), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
        _builder_2.append(_levelName);
        _builder_2.append(".");
        DatamartFunctionInterface _function_2 = element.getFunction();
        String _name_1 = ((DatamartFunction) _function_2).getFunction().name();
        _builder_2.append(_name_1);
        evaluation = _builder_2.toString();
      }
      DatamartFunctionInterface _function_3 = element.getFunction();
      if ((_function_3 instanceof DatamartParameterFunction)) {
        StringConcatenation _builder_3 = new StringConcatenation();
        _builder_3.append(evaluation);
        String _levelName_1 = this.getLevelName(element.getHierarchy(), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
        _builder_3.append(_levelName_1);
        _builder_3.append(".");
        DatamartFunctionInterface _function_4 = element.getFunction();
        String _name_2 = ((DatamartParameterFunction) _function_4).getFunction().name();
        _builder_3.append(_name_2);
        _builder_3.append("(");
        DatamartFunctionInterface _function_5 = element.getFunction();
        int _value_1 = ((DatamartParameterFunction) _function_5).getParameter().getValue();
        _builder_3.append(_value_1);
        _builder_3.append(")");
        evaluation = _builder_3.toString();
      }
    }
    if (((element.getHierarchy() != null) && (element.getFunction() == null))) {
      StringConcatenation _builder_4 = new StringConcatenation();
      _builder_4.append(evaluation);
      String _levelName_2 = this.getLevelName(element.getHierarchy(), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
      _builder_4.append(_levelName_2);
      evaluation = _builder_4.toString();
    }
    if ((element instanceof DatamartSetTuple)) {
      DatamartSetFunctionInterface _setFunction = ((DatamartSetTuple) element).getLeft().getSetFunction();
      boolean _tripleNotEquals_4 = (_setFunction != null);
      if (_tripleNotEquals_4) {
        DatamartSetFunctionInterface _setFunction_1 = ((DatamartSetTuple) element).getLeft().getSetFunction();
        if ((_setFunction_1 instanceof DatamartSetFunction)) {
          StringConcatenation _builder_5 = new StringConcatenation();
          _builder_5.append(evaluation);
          DatamartSetFunctionInterface _setFunction_2 = ((DatamartSetTuple) element).getLeft().getSetFunction();
          String _name_3 = ((DatamartSetFunction) _setFunction_2).getSetFunction().name();
          _builder_5.append(_name_3);
          _builder_5.append("(");
          String _levelName_3 = this.getLevelName(((DatamartSetTuple) element).getRight(), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
          _builder_5.append(_levelName_3);
          _builder_5.append(")");
          evaluation = _builder_5.toString();
        }
        DatamartSetFunctionInterface _setFunction_3 = ((DatamartSetTuple) element).getLeft().getSetFunction();
        if ((_setFunction_3 instanceof DatamartSetParameterFunction)) {
          StringConcatenation _builder_6 = new StringConcatenation();
          _builder_6.append(evaluation);
          DatamartSetFunctionInterface _setFunction_4 = ((DatamartSetTuple) element).getLeft().getSetFunction();
          String _name_4 = ((DatamartSetParameterFunction) _setFunction_4).getSetFunction().name();
          _builder_6.append(_name_4);
          _builder_6.append("(");
          String _levelName_4 = this.getLevelName(((DatamartSetTuple) element).getRight(), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
          _builder_6.append(_levelName_4);
          _builder_6.append(",");
          DatamartSetFunctionInterface _setFunction_5 = ((DatamartSetTuple) element).getLeft().getSetFunction();
          DatamartFunctionIntParameter _parameter = ((DatamartSetParameterFunction) _setFunction_5).getParameter();
          int _value_2 = ((DatamartFunctionIntParameter) _parameter).getValue();
          _builder_6.append(_value_2);
          _builder_6.append(")");
          evaluation = _builder_6.toString();
        }
      }
    }
    if ((element instanceof DatamartMeasure)) {
      StringConcatenation _builder_7 = new StringConcatenation();
      String _measureName = this.getMeasureName(((DatamartMeasure) element));
      _builder_7.append(_measureName);
      evaluation = _builder_7.toString();
    }
    if ((element instanceof DatamartDerivedMeasure)) {
      StringConcatenation _builder_8 = new StringConcatenation();
      String _derivedMeasureName = this.getDerivedMeasureName(((DatamartDerivedMeasure) element));
      _builder_8.append(_derivedMeasureName);
      evaluation = _builder_8.toString();
    }
    if ((element instanceof DatamartHierarchy)) {
      StringConcatenation _builder_9 = new StringConcatenation();
      String _levelName_5 = this.getLevelName(((DatamartHierarchy) element), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
      _builder_9.append(_levelName_5);
      evaluation = _builder_9.toString();
    }
    if ((element instanceof DatamartAttributeBase)) {
      StringConcatenation _builder_10 = new StringConcatenation();
      String _attributeName = this.getAttributeName(((DatamartAttributeBase) element), entity);
      _builder_10.append(_attributeName);
      evaluation = _builder_10.toString();
    }
    if ((element instanceof Multiplication)) {
      StringConcatenation _builder_11 = new StringConcatenation();
      String _evaluateExpression = this.evaluateExpression(((Multiplication) element).getLeft(), entity);
      _builder_11.append(_evaluateExpression);
      evaluation = _builder_11.toString();
      StringConcatenation _builder_12 = new StringConcatenation();
      _builder_12.append(evaluation);
      _builder_12.append("*");
      evaluation = _builder_12.toString();
      StringConcatenation _builder_13 = new StringConcatenation();
      _builder_13.append(evaluation);
      String _evaluateExpression_1 = this.evaluateExpression(((Multiplication) element).getRight(), entity);
      _builder_13.append(_evaluateExpression_1);
      evaluation = _builder_13.toString();
    }
    if ((element instanceof Division)) {
      StringConcatenation _builder_14 = new StringConcatenation();
      String _evaluateExpression_2 = this.evaluateExpression(((Division) element).getLeft(), entity);
      _builder_14.append(_evaluateExpression_2);
      evaluation = _builder_14.toString();
      StringConcatenation _builder_15 = new StringConcatenation();
      _builder_15.append(evaluation);
      _builder_15.append("/");
      evaluation = _builder_15.toString();
      StringConcatenation _builder_16 = new StringConcatenation();
      _builder_16.append(evaluation);
      String _evaluateExpression_3 = this.evaluateExpression(((Division) element).getRight(), entity);
      _builder_16.append(_evaluateExpression_3);
      evaluation = _builder_16.toString();
    }
    if ((element instanceof Addition)) {
      StringConcatenation _builder_17 = new StringConcatenation();
      _builder_17.append("(");
      String _evaluateExpression_4 = this.evaluateExpression(((Addition) element).getLeft(), entity);
      _builder_17.append(_evaluateExpression_4);
      evaluation = _builder_17.toString();
      StringConcatenation _builder_18 = new StringConcatenation();
      _builder_18.append(evaluation);
      _builder_18.append("+");
      evaluation = _builder_18.toString();
      StringConcatenation _builder_19 = new StringConcatenation();
      _builder_19.append(evaluation);
      String _evaluateExpression_5 = this.evaluateExpression(((Addition) element).getRight(), entity);
      _builder_19.append(_evaluateExpression_5);
      _builder_19.append(")");
      evaluation = _builder_19.toString();
    }
    if ((element instanceof Subtraction)) {
      StringConcatenation _builder_20 = new StringConcatenation();
      _builder_20.append("(");
      String _evaluateExpression_6 = this.evaluateExpression(((Subtraction) element).getLeft(), entity);
      _builder_20.append(_evaluateExpression_6);
      evaluation = _builder_20.toString();
      StringConcatenation _builder_21 = new StringConcatenation();
      _builder_21.append(evaluation);
      _builder_21.append("-");
      evaluation = _builder_21.toString();
      StringConcatenation _builder_22 = new StringConcatenation();
      _builder_22.append(evaluation);
      String _evaluateExpression_7 = this.evaluateExpression(((Subtraction) element).getRight(), entity);
      _builder_22.append(_evaluateExpression_7);
      _builder_22.append(")");
      evaluation = _builder_22.toString();
    }
    if ((element instanceof Conjunction)) {
      StringConcatenation _builder_23 = new StringConcatenation();
      String _evaluateExpression_8 = this.evaluateExpression(((Conjunction) element).getLeft(), entity);
      _builder_23.append(_evaluateExpression_8);
      evaluation = _builder_23.toString();
      StringConcatenation _builder_24 = new StringConcatenation();
      _builder_24.append(evaluation);
      _builder_24.append(" and ");
      evaluation = _builder_24.toString();
      StringConcatenation _builder_25 = new StringConcatenation();
      _builder_25.append(evaluation);
      String _evaluateExpression_9 = this.evaluateExpression(((Conjunction) element).getRight(), entity);
      _builder_25.append(_evaluateExpression_9);
      evaluation = _builder_25.toString();
    }
    if ((element instanceof Disjunction)) {
      StringConcatenation _builder_26 = new StringConcatenation();
      _builder_26.append("(");
      String _evaluateExpression_10 = this.evaluateExpression(((Disjunction) element).getLeft(), entity);
      _builder_26.append(_evaluateExpression_10);
      evaluation = _builder_26.toString();
      StringConcatenation _builder_27 = new StringConcatenation();
      _builder_27.append(evaluation);
      _builder_27.append(" or ");
      evaluation = _builder_27.toString();
      StringConcatenation _builder_28 = new StringConcatenation();
      _builder_28.append(evaluation);
      String _evaluateExpression_11 = this.evaluateExpression(((Disjunction) element).getRight(), entity);
      _builder_28.append(_evaluateExpression_11);
      _builder_28.append(")");
      evaluation = _builder_28.toString();
    }
    if ((element instanceof ConditionalExpression)) {
      StringConcatenation _builder_29 = new StringConcatenation();
      String _evaluateExpression_12 = this.evaluateExpression(((ConditionalExpression) element).getLeft(), entity);
      _builder_29.append(_evaluateExpression_12);
      evaluation = _builder_29.toString();
      boolean optionalAllowed = true;
      Expression _left_3 = ((ConditionalExpression) element).getLeft();
      if ((_left_3 instanceof DatamartAttributeBase)) {
        Expression _left_4 = ((ConditionalExpression) element).getLeft();
        LScalarType type = ((DatamartAttributeBase) _left_4).getAttributeRef().getType();
        if ((type instanceof LDataType)) {
          boolean _isDate = ((LDataType)type).isDate();
          boolean _not = (!_isDate);
          optionalAllowed = _not;
        }
      }
      boolean _isSelected = ((ConditionalExpression) element).getRight().isSelected();
      if (_isSelected) {
        StringConcatenation _builder_30 = new StringConcatenation();
        _builder_30.append(evaluation);
        _builder_30.append(" in ");
        evaluation = _builder_30.toString();
        StringConcatenation _builder_31 = new StringConcatenation();
        _builder_31.append(evaluation);
        _builder_31.append("(");
        String _evaluateExpression_13 = this.evaluateExpression(((ConditionalExpression) element).getRight(), entity);
        _builder_31.append(_evaluateExpression_13);
        _builder_31.append(")");
        evaluation = _builder_31.toString();
      } else {
        boolean _isRanged = ((ConditionalExpression) element).getRight().isRanged();
        if (_isRanged) {
          StringConcatenation _builder_32 = new StringConcatenation();
          String _evaluateExpression_14 = this.evaluateExpression(((ConditionalExpression) element).getRight(), entity);
          _builder_32.append(_evaluateExpression_14);
          evaluation = _builder_32.toString();
        } else {
          boolean _isUnreferenced_1 = ((ConditionalExpression) element).getRight().isUnreferenced();
          if (_isUnreferenced_1) {
            StringConcatenation _builder_33 = new StringConcatenation();
            String _evaluateExpression_15 = this.evaluateExpression(((ConditionalExpression) element).getRight(), entity);
            _builder_33.append(_evaluateExpression_15);
            evaluation = _builder_33.toString();
          } else {
            StringConcatenation _builder_34 = new StringConcatenation();
            _builder_34.append(evaluation);
            _builder_34.append(" ");
            String _literal = ((ConditionalExpression) element).getOperator().getLiteral();
            _builder_34.append(_literal);
            _builder_34.append(" ");
            evaluation = _builder_34.toString();
            StringConcatenation _builder_35 = new StringConcatenation();
            _builder_35.append(evaluation);
            String _evaluateExpression_16 = this.evaluateExpression(((ConditionalExpression) element).getRight(), entity);
            _builder_35.append(_evaluateExpression_16);
            evaluation = _builder_35.toString();
          }
        }
      }
      if ((((ConditionalExpression) element).getRight().isOptional() && optionalAllowed)) {
        StringConcatenation _builder_36 = new StringConcatenation();
        _builder_36.append("(");
        String _evaluateExpression_17 = this.evaluateExpression(((ConditionalExpression) element).getRight(), entity);
        _builder_36.append(_evaluateExpression_17);
        _builder_36.append("=");
        _builder_36.append(IDataMart.SQLFILTERNOTHING);
        _builder_36.append(" or ");
        _builder_36.append(evaluation);
        _builder_36.append(")");
        evaluation = _builder_36.toString();
      }
    }
    if ((element instanceof DatamartMemberTuple)) {
      StringConcatenation _builder_37 = new StringConcatenation();
      _builder_37.append("(");
      String _evaluateExpression_18 = this.evaluateExpression(((DatamartMemberTuple) element).getRight(), entity);
      _builder_37.append(_evaluateExpression_18);
      evaluation = _builder_37.toString();
      StringConcatenation _builder_38 = new StringConcatenation();
      _builder_38.append(evaluation);
      _builder_38.append(",");
      evaluation = _builder_38.toString();
      StringConcatenation _builder_39 = new StringConcatenation();
      _builder_39.append(evaluation);
      String _evaluateExpression_19 = this.evaluateExpression(((DatamartMemberTuple) element).getLeft(), entity);
      _builder_39.append(_evaluateExpression_19);
      _builder_39.append(")");
      evaluation = _builder_39.toString();
    }
    if ((element instanceof DatamartAggregation)) {
      DatamartAggregationFunctionInterface _aggregation = ((DatamartAggregation) element).getLeft().getAggregation();
      boolean _tripleNotEquals_5 = (_aggregation != null);
      if (_tripleNotEquals_5) {
        DatamartAggregationFunctionInterface _aggregation_1 = ((DatamartAggregation) element).getLeft().getAggregation();
        if ((_aggregation_1 instanceof DatamartAggregationFunction)) {
          StringConcatenation _builder_40 = new StringConcatenation();
          DatamartAggregationFunctionInterface _aggregation_2 = ((DatamartAggregation) element).getLeft().getAggregation();
          String _name_5 = ((DatamartAggregationFunction) _aggregation_2).getAggregation().name();
          _builder_40.append(_name_5);
          _builder_40.append("(");
          evaluation = _builder_40.toString();
          Expression _set = ((DatamartAggregation) element).getLeft().getSet();
          if ((_set instanceof DatamartHierarchy)) {
            StringConcatenation _builder_41 = new StringConcatenation();
            _builder_41.append(evaluation);
            Expression _set_1 = ((DatamartAggregation) element).getLeft().getSet();
            String _levelName_6 = this.getLevelName(((DatamartHierarchy) _set_1), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
            _builder_41.append(_levelName_6);
            evaluation = _builder_41.toString();
          }
          Expression _set_2 = ((DatamartAggregation) element).getLeft().getSet();
          if ((_set_2 instanceof DatamartSetTuple)) {
            StringConcatenation _builder_42 = new StringConcatenation();
            _builder_42.append(evaluation);
            Expression _set_3 = ((DatamartAggregation) element).getLeft().getSet();
            String _evaluateExpression_20 = this.evaluateExpression(((DatamartSetTuple) _set_3), entity);
            _builder_42.append(_evaluateExpression_20);
            evaluation = _builder_42.toString();
          }
        }
      }
      StringConcatenation _builder_43 = new StringConcatenation();
      _builder_43.append(evaluation);
      _builder_43.append(",");
      evaluation = _builder_43.toString();
      StringConcatenation _builder_44 = new StringConcatenation();
      _builder_44.append(evaluation);
      String _evaluateExpression_21 = this.evaluateExpression(((DatamartAggregation) element).getRight(), entity);
      _builder_44.append(_evaluateExpression_21);
      _builder_44.append(")");
      evaluation = _builder_44.toString();
    }
    if ((element instanceof DatamartSetAggregation)) {
      DatamartAggregationFunctionInterface _aggregation_3 = ((DatamartSetAggregation) element).getLeft().getAggregation();
      boolean _tripleNotEquals_6 = (_aggregation_3 != null);
      if (_tripleNotEquals_6) {
        DatamartAggregationFunctionInterface _aggregation_4 = ((DatamartSetAggregation) element).getLeft().getAggregation();
        if ((_aggregation_4 instanceof DatamartSetAggregationFunction)) {
          StringConcatenation _builder_45 = new StringConcatenation();
          DatamartAggregationFunctionInterface _aggregation_5 = ((DatamartSetAggregation) element).getLeft().getAggregation();
          String _name_6 = ((DatamartSetAggregationFunction) _aggregation_5).getAggregation().name();
          _builder_45.append(_name_6);
          _builder_45.append("(");
          evaluation = _builder_45.toString();
          Expression _set_4 = ((DatamartSetAggregation) element).getLeft().getSet();
          if ((_set_4 instanceof DatamartHierarchy)) {
            StringConcatenation _builder_46 = new StringConcatenation();
            _builder_46.append(evaluation);
            Expression _set_5 = ((DatamartSetAggregation) element).getLeft().getSet();
            String _levelName_7 = this.getLevelName(((DatamartHierarchy) _set_5), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(true), Boolean.valueOf(false));
            _builder_46.append(_levelName_7);
            evaluation = _builder_46.toString();
          }
          Expression _set_6 = ((DatamartSetAggregation) element).getLeft().getSet();
          if ((_set_6 instanceof DatamartSetTuple)) {
            StringConcatenation _builder_47 = new StringConcatenation();
            _builder_47.append(evaluation);
            Expression _set_7 = ((DatamartSetAggregation) element).getLeft().getSet();
            String _evaluateExpression_22 = this.evaluateExpression(((DatamartSetTuple) _set_7), entity);
            _builder_47.append(_evaluateExpression_22);
            evaluation = _builder_47.toString();
          }
        }
      }
      StringConcatenation _builder_48 = new StringConcatenation();
      _builder_48.append(evaluation);
      _builder_48.append(",");
      DatamartAggregationFunctionInterface _aggregation_6 = ((DatamartSetAggregation) element).getLeft().getAggregation();
      DatamartFunctionIntParameter _parameter_1 = ((DatamartSetAggregationFunction) _aggregation_6).getParameter();
      int _value_3 = ((DatamartFunctionIntParameter) _parameter_1).getValue();
      _builder_48.append(_value_3);
      _builder_48.append(",");
      evaluation = _builder_48.toString();
      StringConcatenation _builder_49 = new StringConcatenation();
      _builder_49.append(evaluation);
      String _evaluateExpression_23 = this.evaluateExpression(((DatamartSetAggregation) element).getRight(), entity);
      _builder_49.append(_evaluateExpression_23);
      _builder_49.append(")");
      evaluation = _builder_49.toString();
    }
    return evaluation;
  }
  
  /**
   * <p>mdx syntax part for attribute names, full qualified and aliased>
   */
  public String getAttributeName(final DatamartAttributeBase attribute, final DatamartEntity entity) {
    if ((entity != null)) {
      StringConcatenation _builder = new StringConcatenation();
      String _entityAlias = this.getEntityAlias(entity);
      _builder.append(_entityAlias);
      _builder.append(".");
      String _columnName = this._namingExtensions.toColumnName(attribute.getAttributeRef());
      _builder.append(_columnName);
      return _builder.toString();
    } else {
      StringConcatenation _builder_1 = new StringConcatenation();
      EObject _eContainer = attribute.getAttributeRef().eContainer();
      String _name = ((LEntity) _eContainer).getName();
      _builder_1.append(_name);
      _builder_1.append(".");
      String _columnName_1 = this._namingExtensions.toColumnName(attribute.getAttributeRef());
      _builder_1.append(_columnName_1);
      return _builder_1.toString();
    }
  }
  
  /**
   * <p>mdx syntax part for measure names.</p>
   */
  public String getMeasureName(final DatamartMeasure measure) {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("[Measures].[");
    String _name = measure.getMeasureRef().getName();
    _builder.append(_name);
    _builder.append("]");
    return _builder.toString();
  }
  
  /**
   * <p>mdx syntax part for derived measure names.</p>
   */
  public String getDerivedMeasureName(final DatamartDerivedMeasure measure) {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("[Measures].[");
    String _name = measure.getDerivedRef().getName();
    _builder.append(_name);
    _builder.append("]");
    return _builder.toString();
  }
  
  /**
   * <p>mdx syntax part for dimension names.</p>
   */
  public String getDimensionName(final DatamartHierarchy hierarchy, final Boolean withBrackets) {
    String dim = "";
    EObject _eContainer = hierarchy.getHierarchyRef().eContainer();
    boolean _tripleNotEquals = (_eContainer != null);
    if (_tripleNotEquals) {
      String _name = hierarchy.getHierarchyRef().getName();
      boolean _tripleEquals = (_name == null);
      if (_tripleEquals) {
        StringConcatenation _builder = new StringConcatenation();
        {
          if ((withBrackets).booleanValue()) {
            _builder.append("[");
          }
        }
        EObject _eContainer_1 = hierarchy.getHierarchyRef().eContainer();
        String _name_1 = ((CubeDimension) _eContainer_1).getName();
        _builder.append(_name_1);
        {
          if ((withBrackets).booleanValue()) {
            _builder.append("]");
          }
        }
        dim = _builder.toString();
      } else {
        StringConcatenation _builder_1 = new StringConcatenation();
        {
          if ((withBrackets).booleanValue()) {
            _builder_1.append("[");
          }
        }
        String _name_2 = hierarchy.getHierarchyRef().getName();
        _builder_1.append(_name_2);
        {
          if ((withBrackets).booleanValue()) {
            _builder_1.append("]");
          }
        }
        dim = _builder_1.toString();
      }
    }
    return dim;
  }
  
  /**
   * <p>mdx syntax part for level names.</p>
   */
  public String getLevelName(final DatamartHierarchy hierarchy, final Boolean withBrackets, final Boolean withFiltermask, final Boolean withFunctions, final Boolean isFilter) {
    StringConcatenation _builder = new StringConcatenation();
    String _dimensionName = this.getDimensionName(hierarchy, withBrackets);
    _builder.append(_dimensionName);
    String text = _builder.toString();
    CubeLevel _levelRef = hierarchy.getLevelRef();
    boolean _tripleNotEquals = (_levelRef != null);
    if (_tripleNotEquals) {
      StringConcatenation _builder_1 = new StringConcatenation();
      _builder_1.append(text);
      _builder_1.append(".");
      text = _builder_1.toString();
      if ((hierarchy.isFiltered() && (withFiltermask).booleanValue())) {
        StringConcatenation _builder_2 = new StringConcatenation();
        _builder_2.append(DatamartFilter.FILTER_PLACEHOLDER);
        _builder_2.append(text);
        text = _builder_2.toString();
      }
      if ((hierarchy.isSelected() && (withFiltermask).booleanValue())) {
        StringConcatenation _builder_3 = new StringConcatenation();
        _builder_3.append(DatamartFilter.FILTER_PLACEHOLDER);
        _builder_3.append(text);
        text = _builder_3.toString();
      }
      if ((withBrackets).booleanValue()) {
        StringConcatenation _builder_4 = new StringConcatenation();
        _builder_4.append(text);
        _builder_4.append("[");
        text = _builder_4.toString();
      }
      StringConcatenation _builder_5 = new StringConcatenation();
      _builder_5.append(text);
      String _name = hierarchy.getLevelRef().getName();
      _builder_5.append(_name);
      text = _builder_5.toString();
      if ((withBrackets).booleanValue()) {
        StringConcatenation _builder_6 = new StringConcatenation();
        _builder_6.append(text);
        _builder_6.append("]");
        text = _builder_6.toString();
      }
      if ((hierarchy.isFiltered() && (withFiltermask).booleanValue())) {
        StringConcatenation _builder_7 = new StringConcatenation();
        _builder_7.append(text);
        _builder_7.append(DatamartFilter.FILTER_PLACEHOLDER);
        text = _builder_7.toString();
      }
      if ((hierarchy.isSelected() && (withFiltermask).booleanValue())) {
        StringConcatenation _builder_8 = new StringConcatenation();
        _builder_8.append(text);
        _builder_8.append(DatamartFilter.FILTER_PLACEHOLDER);
        text = _builder_8.toString();
      }
      if ((hierarchy.isFiltered() || hierarchy.isSelected())) {
        if ((hierarchy.isAll() && (withFunctions).booleanValue())) {
          StringConcatenation _builder_9 = new StringConcatenation();
          _builder_9.append(text);
          _builder_9.append(".Children");
          text = _builder_9.toString();
        }
      } else {
        if ((withFunctions).booleanValue()) {
          StringConcatenation _builder_10 = new StringConcatenation();
          _builder_10.append(text);
          _builder_10.append(".Members");
          text = _builder_10.toString();
        }
      }
    }
    CubeLevel _levelRef_1 = hierarchy.getLevelRef();
    boolean _tripleEquals = (_levelRef_1 == null);
    if (_tripleEquals) {
      if (((hierarchy.getHierarchyRef().eContainer() != null) && 
        (!((CubeDimension) hierarchy.getHierarchyRef().eContainer()).isTypeTime()))) {
        boolean _isAll = hierarchy.isAll();
        if (_isAll) {
          if ((hierarchy.isExcept() && (!(isFilter).booleanValue()))) {
            StringConcatenation _builder_11 = new StringConcatenation();
            _builder_11.append(text);
            _builder_11.append(".Children");
            text = _builder_11.toString();
          } else {
            StringConcatenation _builder_12 = new StringConcatenation();
            _builder_12.append(text);
            _builder_12.append(".Members");
            text = _builder_12.toString();
          }
        } else {
          if ((hierarchy.isAllMember() && hierarchy.getHierarchyRef().isAllMemberName())) {
            StringConcatenation _builder_13 = new StringConcatenation();
            _builder_13.append(text);
            _builder_13.append(".[");
            String _replaceAll = hierarchy.getHierarchyRef().getAllMemberNameValue().replaceAll("\"", "");
            _builder_13.append(_replaceAll);
            _builder_13.append("]");
            text = _builder_13.toString();
          } else {
            boolean _isAllLevels = hierarchy.isAllLevels();
            if (_isAllLevels) {
              StringConcatenation _builder_14 = new StringConcatenation();
              _builder_14.append(text);
              _builder_14.append(".AllMembers");
              text = _builder_14.toString();
            } else {
              if ((hierarchy.isDefaultMember() && hierarchy.getHierarchyRef().isDefaultMember())) {
                StringConcatenation _builder_15 = new StringConcatenation();
                _builder_15.append(text);
                _builder_15.append(".Defaultmember");
                text = _builder_15.toString();
              } else {
                boolean _isDefaultMember = hierarchy.getHierarchyRef().isDefaultMember();
                if (_isDefaultMember) {
                  StringConcatenation _builder_16 = new StringConcatenation();
                  _builder_16.append(text);
                  _builder_16.append(".Defaultmember");
                  text = _builder_16.toString();
                } else {
                  StringConcatenation _builder_17 = new StringConcatenation();
                  _builder_17.append(text);
                  _builder_17.append(".Members");
                  text = _builder_17.toString();
                }
              }
            }
          }
        }
      }
    }
    if ((hierarchy.isExcept() && (!(isFilter).booleanValue()))) {
      StringConcatenation _builder_18 = new StringConcatenation();
      _builder_18.append("Except(");
      _builder_18.append(text);
      _builder_18.append(",{");
      _builder_18.append(DatamartFilter.FILTER_PLACEHOLDER);
      String _dimensionName_1 = this.getDimensionName(hierarchy, Boolean.valueOf(true));
      _builder_18.append(_dimensionName_1);
      _builder_18.append(".");
      {
        if ((withBrackets).booleanValue()) {
          _builder_18.append("[");
        }
      }
      String _name_1 = hierarchy.getExceptRef().getName();
      _builder_18.append(_name_1);
      {
        if ((withBrackets).booleanValue()) {
          _builder_18.append("]");
        }
      }
      _builder_18.append(DatamartFilter.FILTER_PLACEHOLDER);
      _builder_18.append("})");
      text = _builder_18.toString();
    }
    boolean _isOrdered = hierarchy.isOrdered();
    if (_isOrdered) {
      DatamartElement _orderRef = hierarchy.getOrderRef();
      if ((_orderRef instanceof DatamartMeasure)) {
        StringConcatenation _builder_19 = new StringConcatenation();
        _builder_19.append("Order(");
        _builder_19.append(text);
        _builder_19.append(",");
        DatamartElement _orderRef_1 = hierarchy.getOrderRef();
        String _measureName = this.getMeasureName(((DatamartMeasure) _orderRef_1));
        _builder_19.append(_measureName);
        _builder_19.append(",");
        {
          boolean _isDescending = hierarchy.isDescending();
          if (_isDescending) {
            _builder_19.append("Desc");
          } else {
            _builder_19.append("Asc");
          }
        }
        _builder_19.append(")");
        text = _builder_19.toString();
      } else {
        StringConcatenation _builder_20 = new StringConcatenation();
        _builder_20.append("Order(");
        _builder_20.append(text);
        _builder_20.append(",");
        DatamartElement _orderRef_2 = hierarchy.getOrderRef();
        String _derivedMeasureName = this.getDerivedMeasureName(((DatamartDerivedMeasure) _orderRef_2));
        _builder_20.append(_derivedMeasureName);
        _builder_20.append(",");
        {
          boolean _isDescending_1 = hierarchy.isDescending();
          if (_isDescending_1) {
            _builder_20.append("Desc");
          } else {
            _builder_20.append("Asc");
          }
        }
        _builder_20.append(")");
        text = _builder_20.toString();
      }
    }
    StringConcatenation _builder_21 = new StringConcatenation();
    _builder_21.append(text);
    return _builder_21.toString();
  }
  
  /**
   * <p>helper for entity names.</p>
   */
  public String getEntityAlias(final DatamartEntity entity) {
    return this.getEntityAlias(entity.getEntityRef());
  }
  
  /**
   * <p>helper for entity names including aliases when used in recursive join relations.</p>
   */
  public String getEntityAlias(final LEntity entityRef) {
    String name = "";
    boolean _hasSuperType = this.hasSuperType(entityRef);
    if (_hasSuperType) {
      name = entityRef.getSuperType().getName();
    } else {
      name = entityRef.getName();
    }
    String alias = name;
    boolean _containsKey = this.sqlAliasCounter.containsKey(name);
    if (_containsKey) {
      Integer newId = this.sqlAliasCounter.get(name);
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(alias);
      {
        if (((newId).intValue() > 0)) {
          _builder.append(newId);
        }
      }
      alias = _builder.toString();
    }
    return alias;
  }
  
  /**
   * <p>helper for entity names including aliases when used in recursive join relations.</p>
   */
  public String entityAlias2(final DatamartEntity entity) {
    return this.entityAlias2(entity.getEntityRef());
  }
  
  public String entityAlias2(final LEntity entityRef) {
    String name = "";
    boolean _hasSuperType = this.hasSuperType(entityRef);
    if (_hasSuperType) {
      name = entityRef.getSuperType().getName();
    } else {
      name = entityRef.getName();
    }
    String alias = name;
    boolean _containsKey = this.sqlAliasCounter.containsKey(name);
    if (_containsKey) {
      Integer newId = this.sqlAliasCounter.get(name);
      this.sqlAliasCounter.put(name, Integer.valueOf(((newId).intValue() + 1)));
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(alias);
      _builder.append(((newId).intValue() + 1));
      alias = _builder.toString();
    } else {
      this.sqlAliasCounter.put(name, Integer.valueOf(0));
    }
    return alias;
  }
  
  /**
   * <p>main method to build sql statements bases on entities and roles.</p>
   */
  public String createSQLStatements(final DatamartDefinition definition, final DatamartEntity entity, final Map<String, LAttribute> typesMap, final Map<String, LEntity> entityMap) {
    return this.createSQLStatement(definition, typesMap, entityMap);
  }
  
  /**
   * <p>main method to build sql statements bases on entities and a role.</p>
   */
  public String createSQLStatement(final DatamartDefinition definition, final Map<String, LAttribute> typesMap, final Map<String, LEntity> entityMap) {
    this.sqlAliasCounter.clear();
    this.sqlFilterMap.clear();
    this.sqlHasAggregate = false;
    this.sqlHasOrder = false;
    ArrayList<String> groupingList = CollectionLiterals.<String>newArrayList();
    this.idMap.clear();
    this.ignoreEntityGrouping = false;
    HashMap<String, Pair<String, Integer>> attributes = CollectionLiterals.<String, Pair<String, Integer>>newHashMap();
    ArrayList<String> conditions = CollectionLiterals.<String>newArrayList();
    LinkedHashMap<String, Integer> orderings = CollectionLiterals.<String, Integer>newLinkedHashMap();
    DatamartSource _source = definition.getSource();
    DatamartEntity entity = ((DatamartEntity) _source);
    String used = this.createEntity(entity, null, null, entityMap, attributes, conditions, orderings, typesMap, groupingList);
    String select = this.createSelect(attributes, definition, entityMap);
    String condition = this.createCondition(conditions);
    String ordering = this.createOrdering(orderings);
    String grouping = this.createGrouping(groupingList);
    boolean _isEmpty = select.isEmpty();
    if (_isEmpty) {
      return "";
    }
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("select ");
    _builder.append(select);
    _builder.append(" from ");
    _builder.append(used);
    {
      int _size = conditions.size();
      boolean _greaterThan = (_size > 0);
      if (_greaterThan) {
        _builder.append(" where ");
        _builder.append(condition);
      }
    }
    {
      if (this.sqlHasAggregate) {
        _builder.append(" group by ");
        _builder.append(grouping);
      }
    }
    {
      if (this.sqlHasOrder) {
        _builder.append(" order by ");
        _builder.append(ordering);
      }
    }
    return _builder.toString();
  }
  
  /**
   * <p>sql syntax part for group by.</p>
   */
  public String createGrouping(final List<String> grouping) {
    String groupingString = "";
    for (final String groupBy : grouping) {
      StringConcatenation _builder = new StringConcatenation();
      {
        boolean _isEmpty = groupingString.isEmpty();
        boolean _not = (!_isEmpty);
        if (_not) {
          _builder.append(groupingString);
          _builder.append(",");
        }
      }
      _builder.append(groupBy);
      groupingString = _builder.toString();
    }
    return groupingString;
  }
  
  /**
   * <p>sql syntax part for where.</p>
   */
  public String createCondition(final ArrayList<String> conditions) {
    String conditionString = "";
    for (final String condition : conditions) {
      StringConcatenation _builder = new StringConcatenation();
      {
        boolean _isEmpty = conditionString.isEmpty();
        boolean _not = (!_isEmpty);
        if (_not) {
          _builder.append(conditionString);
          _builder.append(" and ");
        }
      }
      _builder.append("(");
      _builder.append(condition);
      _builder.append(")");
      conditionString = _builder.toString();
    }
    return conditionString;
  }
  
  /**
   * <p>sql syntax part for order.</p>
   */
  public String createOrdering(final Map<String, Integer> orderings) {
    int _size = orderings.size();
    boolean _greaterThan = (_size > 0);
    this.sqlHasOrder = _greaterThan;
    final Function<Map.Entry<String, Integer>, String> _function = (Map.Entry<String, Integer> it) -> {
      return it.getKey();
    };
    return orderings.entrySet().stream().sorted(Map.Entry.<String, Integer>comparingByValue().reversed()).<String>map(_function).collect(
      Collectors.joining(","));
  }
  
  /**
   * <p>sql syntax part for select.</p>
   */
  public String createSelect(final Map<String, Pair<String, Integer>> attributes, final DatamartDefinition definition, final Map<String, LEntity> entityMap) {
    String selectString = "";
    DatamartSource _source = definition.getSource();
    if ((_source instanceof DatamartEntity)) {
      DatamartSource _source_1 = definition.getSource();
      boolean _isSuppressAttributes = ((DatamartEntity) _source_1).isSuppressAttributes();
      boolean _not = (!_isSuppressAttributes);
      if (_not) {
        final Comparator<Map.Entry<String, Pair<String, Integer>>> _function = (Map.Entry<String, Pair<String, Integer>> e1, Map.Entry<String, Pair<String, Integer>> e2) -> {
          Integer _value = e2.getValue().getValue();
          Integer _value_1 = e1.getValue().getValue();
          return ((_value).intValue() - (_value_1).intValue());
        };
        final Function1<Map.Entry<String, Pair<String, Integer>>, String> _function_1 = (Map.Entry<String, Pair<String, Integer>> it) -> {
          String _key = it.getKey();
          String _plus = (_key + " as \\\"");
          String _key_1 = it.getValue().getKey();
          String _plus_1 = (_plus + _key_1);
          return (_plus_1 + "\\\"");
        };
        selectString = IterableExtensions.join(ListExtensions.<Map.Entry<String, Pair<String, Integer>>, String>map(IterableExtensions.<Map.Entry<String, Pair<String, Integer>>>sortWith(attributes.entrySet(), _function), _function_1), ",");
        StringConcatenation _builder = new StringConcatenation();
        _builder.append(selectString);
        selectString = _builder.toString();
      }
    }
    this.datamartDtoMapper = "new DatamartDtoMapper()";
    if ((definition != null)) {
      if ((!this.ignoreEntityGrouping)) {
        Collection<LEntity> _values = entityMap.values();
        for (final LEntity entityRef : _values) {
          {
            String entityName = "";
            boolean _hasSuperType = this.hasSuperType(entityRef);
            if (_hasSuperType) {
              entityName = entityRef.getSuperType().getName();
            } else {
              entityName = entityRef.getName();
            }
            String dtoFqn = EntityUtils.getDtoFQNForLEntity(entityRef);
            String idColumn = DatamartDefinitionUtil.getEntityIdAliasName(entityRef);
            LEntityAttribute _primaryKeyAttribute = entityRef.getPrimaryKeyAttribute();
            boolean _tripleNotEquals = (_primaryKeyAttribute != null);
            if (_tripleNotEquals) {
              StringConcatenation _builder_1 = new StringConcatenation();
              _builder_1.append(selectString);
              {
                boolean _isEmpty = selectString.isEmpty();
                boolean _not_1 = (!_isEmpty);
                if (_not_1) {
                  _builder_1.append(",");
                }
              }
              _builder_1.append(entityName);
              _builder_1.append(".");
              String _name = entityRef.getPrimaryKeyAttribute().getName();
              _builder_1.append(_name);
              _builder_1.append(" as \\\"");
              _builder_1.append(idColumn);
              _builder_1.append("\\\"");
              selectString = _builder_1.toString();
              boolean _hasSuperType_1 = this.hasSuperType(entityRef);
              if (_hasSuperType_1) {
                this.idMap.put(idColumn, entityRef.getSuperType());
              } else {
                this.idMap.put(idColumn, entityRef);
              }
              StringConcatenation _builder_2 = new StringConcatenation();
              _builder_2.append(this.datamartDtoMapper);
              _builder_2.newLineIfNotEmpty();
              _builder_2.append(".add(\"");
              _builder_2.append(dtoFqn);
              _builder_2.append("\", \"");
              String _name_1 = entityRef.getPrimaryKeyAttribute().getName();
              _builder_2.append(_name_1);
              _builder_2.append("\", EType.");
              IDataMart.EType _basicType = this.dtType.getBasicType(this.idMap.get(idColumn).getPrimaryKeyAttribute());
              _builder_2.append(_basicType);
              _builder_2.append(", \"");
              _builder_2.append(idColumn);
              _builder_2.append("\")");
              this.datamartDtoMapper = _builder_2.toString();
            }
          }
        }
      }
    }
    return selectString;
  }
  
  public boolean hasSuperType(final DatamartEntity entity) {
    return this.hasSuperType(entity.getEntityRef());
  }
  
  public boolean hasSuperType(final LEntity entityRef) {
    return (((entityRef.getSuperType() != null) && (!entityRef.getSuperType().isMappedSuperclass())) && 
      (!entityRef.getSuperType().equals(entityRef)));
  }
  
  /**
   * <p>recursive entity relation builder.</p>
   */
  public String createEntity(final DatamartEntity entity, final DatamartEntity parent, final DatamartNavigation parentNavigation, final Map<String, LEntity> entityMap, final Map<String, Pair<String, Integer>> attributes, final List<String> conditions, final LinkedHashMap<String, Integer> orderings, final Map<String, LAttribute> typesMap, final List<String> groupingList) {
    String body = "";
    String tableName = this._namingExtensions.toTableName(entity.getEntityRef());
    boolean _hasSuperType = this.hasSuperType(entity);
    if (_hasSuperType) {
      StringConcatenation _builder = new StringConcatenation();
      String _entityAlias = this.getEntityAlias(entity);
      _builder.append(_entityAlias);
      _builder.append(".disc=\'");
      String _tableName = this._namingExtensions.toTableName(entity.getEntityRef());
      _builder.append(_tableName);
      _builder.append("\' ");
      conditions.add(_builder.toString());
      tableName = this._namingExtensions.toTableName(entity.getEntityRef().getSuperType());
    }
    StringConcatenation _builder_1 = new StringConcatenation();
    _builder_1.append(body);
    CharSequence _provideSchemaName = this.getProvideSchemaName(entity.getEntityRef().getPersistenceInfo().getSchemaName());
    _builder_1.append(_provideSchemaName);
    _builder_1.append(tableName);
    _builder_1.append(" ");
    String _entityAlias2 = this.entityAlias2(entity);
    _builder_1.append(_entityAlias2);
    body = _builder_1.toString();
    if (((parent != null) && (parentNavigation != null))) {
      StringConcatenation _builder_2 = new StringConcatenation();
      _builder_2.append(" ");
      _builder_2.append("left join ");
      _builder_2.append(body, " ");
      String _createJoin = this.createJoin(entity, parent, parentNavigation);
      _builder_2.append(_createJoin, " ");
      body = _builder_2.toString();
    }
    boolean _hasSuperType_1 = this.hasSuperType(entity);
    if (_hasSuperType_1) {
      StringConcatenation _builder_3 = new StringConcatenation();
      _builder_3.append(body);
      _builder_3.append(" left join ");
      String _createSupertypeJoin = this.createSupertypeJoin(entity);
      _builder_3.append(_createSupertypeJoin);
      body = _builder_3.toString();
    }
    EList<DatamartNavigation> _navigations = entity.getNavigations();
    for (final DatamartNavigation navigation : _navigations) {
      {
        if ((navigation instanceof DatamartMember)) {
          StringConcatenation _builder_4 = new StringConcatenation();
          _builder_4.append(body);
          String _createEntity = this.createEntity(((DatamartMember) navigation).getDatamartEntity(), entity, navigation, entityMap, attributes, conditions, orderings, typesMap, groupingList);
          _builder_4.append(_createEntity);
          body = _builder_4.toString();
        }
        if ((navigation instanceof DatamartOwner)) {
          StringConcatenation _builder_5 = new StringConcatenation();
          _builder_5.append(body);
          String _createEntity_1 = this.createEntity(((DatamartOwner) navigation).getDatamartEntity(), entity, navigation, entityMap, attributes, conditions, orderings, typesMap, groupingList);
          _builder_5.append(_createEntity_1);
          body = _builder_5.toString();
        }
      }
    }
    entityMap.put(this.getEntityAlias(entity), entity.getEntityRef());
    if ((entity.getAttributes().isEmpty() && (!entity.isSuppressAttributes()))) {
      List<LEntityAttribute> _allAttributes = entity.getEntityRef().getAllAttributes();
      for (final LEntityAttribute attr : _allAttributes) {
        if (((((!attr.isId()) && (!attr.isUuid())) && (!attr.isVersion())) && (!attr.isTransient()))) {
          DatamartAttribute datamartAttr = DatamartDSLFactory.eINSTANCE.createDatamartAttribute();
          datamartAttr.setAttributeRef(attr);
          this.recurAttribute(entity, datamartAttr, false, "", Integer.valueOf(this.defaultColumnWeight), attributes, typesMap, groupingList);
        }
      }
    } else {
      EList<DatamartAttribute> _attributes = entity.getAttributes();
      for (final DatamartAttribute attribute : _attributes) {
        {
          int columnWeight = this.defaultColumnWeight;
          boolean _isHasColumnWeight = attribute.isHasColumnWeight();
          if (_isHasColumnWeight) {
            columnWeight = attribute.getColumnWeight();
          }
          this.recurAttribute(entity, attribute, attribute.isAggregated(), attribute.getAggregate().getName(), Integer.valueOf(columnWeight), attributes, typesMap, groupingList);
        }
      }
    }
    EList<DatamartCondition> _conditions = entity.getConditions();
    for (final DatamartCondition condition : _conditions) {
      conditions.add(this.evaluateExpression(condition.getCondition(), entity));
    }
    EList<DatamartOrder> _ordering = entity.getOrdering();
    for (final DatamartOrder order : _ordering) {
      {
        Integer columnWeight = null;
        boolean _isHasColumnWeight = order.isHasColumnWeight();
        if (_isHasColumnWeight) {
          columnWeight = Integer.valueOf(order.getColumnWeight());
        } else {
          columnWeight = Integer.valueOf(this.defaultColumnWeight);
        }
        String _entityAlias_1 = this.getEntityAlias(entity);
        String _plus = (_entityAlias_1 + ".");
        String _columnName = this._namingExtensions.toColumnName(order.getOrderBy());
        String _plus_1 = (_plus + _columnName);
        String _plus_2 = (_plus_1 + " ");
        String _name = order.getOrderHow().getName();
        String _plus_3 = (_plus_2 + _name);
        orderings.put(_plus_3, columnWeight);
      }
    }
    return body;
  }
  
  public void recurAttribute(final DatamartEntity entity, final DatamartAttribute datamartAttr, final boolean aggregated, final String aggregateName, final Integer columnWeight, final Map<String, Pair<String, Integer>> attributes, final Map<String, LAttribute> typesMap, final List<String> groupingList) {
    LEntityAttribute attr = datamartAttr.getAttributeRef();
    LScalarType type = attr.getType();
    if ((type instanceof LBean)) {
      LBean bean = ((LBean) type);
      List<LBeanAttribute> _allAttributes = bean.getAllAttributes();
      for (final LBeanAttribute battr : _allAttributes) {
        LScalarType _type = battr.getType();
        if ((_type instanceof LBean)) {
          this.recurAttribute(entity, battr, aggregated, aggregateName, columnWeight, attributes, typesMap, groupingList);
        } else {
          this.addAttribute(entity, battr, aggregated, aggregateName, columnWeight, attributes, typesMap, groupingList);
        }
      }
    } else {
      this.addAttribute(entity, datamartAttr, aggregated, aggregateName, columnWeight, attributes, typesMap, groupingList);
    }
  }
  
  private void recurAttribute(final DatamartEntity entity, final LAttribute attr, final boolean aggregated, final String aggregateName, final Integer columnWeight, final Map<String, Pair<String, Integer>> attributes, final Map<String, LAttribute> typesMap, final List<String> groupingList) {
    LScalarType type = attr.getType();
    if ((type instanceof LBean)) {
      LBean bean = ((LBean) type);
      List<LBeanAttribute> _allAttributes = bean.getAllAttributes();
      for (final LBeanAttribute battr : _allAttributes) {
        LScalarType _type = battr.getType();
        if ((_type instanceof LBean)) {
          this.recurAttribute(entity, battr, aggregated, aggregateName, columnWeight, attributes, typesMap, groupingList);
        } else {
          this.addAttribute(entity, battr, aggregated, aggregateName, columnWeight, attributes, typesMap, groupingList);
        }
      }
    } else {
      this.addAttribute(entity, attr, aggregated, aggregateName, columnWeight, attributes, typesMap, groupingList);
    }
  }
  
  public String aliasedColumnName(final LEntity entityRef, final LAttribute attr) {
    String name = "";
    boolean _hasSuperType = this.hasSuperType(entityRef);
    if (_hasSuperType) {
      boolean _contains = entityRef.getSuperType().getAllAttributes().contains(attr);
      if (_contains) {
        name = entityRef.getSuperType().getName();
      } else {
        name = entityRef.getName();
      }
    } else {
      name = entityRef.getName();
    }
    String alias = name;
    boolean _containsKey = this.sqlAliasCounter.containsKey(name);
    if (_containsKey) {
      Integer newId = this.sqlAliasCounter.get(name);
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(alias);
      {
        if (((newId).intValue() > 0)) {
          _builder.append(newId);
        }
      }
      alias = _builder.toString();
    }
    String _columnName = this._namingExtensions.toColumnName(attr);
    return ((alias + ".") + _columnName);
  }
  
  public void addAttribute(final DatamartEntity datamartEntity, final DatamartAttribute datamartAttr, final boolean aggregated, final String aggregateName, final Integer columnWeight, final Map<String, Pair<String, Integer>> attributes, final Map<String, LAttribute> typesMap, final List<String> groupingList) {
    LEntityAttribute attr = datamartAttr.getAttributeRef();
    this.addAttribute(datamartEntity, attr, DatamartAttributeUtil.getAliasedAttributeName(datamartAttr), aggregated, aggregateName, columnWeight, attributes, typesMap, groupingList);
  }
  
  public void addAttribute(final DatamartEntity datamartEntity, final LAttribute attr, final boolean aggregated, final String aggregateName, final Integer columnWeight, final Map<String, Pair<String, Integer>> attributes, final Map<String, LAttribute> typesMap, final List<String> groupingList) {
    StringConcatenation _builder = new StringConcatenation();
    String _name = null;
    if (attr!=null) {
      _name=attr.getName();
    }
    String _replace = null;
    if (_name!=null) {
      _replace=_name.replace("^", "");
    }
    _builder.append(_replace);
    String attributeName = _builder.toString();
    this.addAttribute(datamartEntity, attr, attributeName, aggregated, aggregateName, columnWeight, attributes, typesMap, groupingList);
  }
  
  private void addAttribute(final DatamartEntity datamartEntity, final LAttribute attr, final String attributeName, final boolean aggregated, final String aggregateName, final Integer columnWeight, final Map<String, Pair<String, Integer>> attributes, final Map<String, LAttribute> typesMap, final List<String> groupingList) {
    LEntity entity = datamartEntity.getEntityRef();
    String key = this.aliasedColumnName(entity, attr);
    String attrName = "";
    String typesAttr = "";
    boolean _hasSuperType = this.hasSuperType(entity);
    if (_hasSuperType) {
      boolean _contains = entity.getSuperType().getAllAttributes().contains(attr);
      if (_contains) {
        String _name = entity.getSuperType().getName();
        String _plus = (_name + ".");
        String _plus_1 = (_plus + attributeName);
        attrName = _plus_1;
        String _name_1 = entity.getSuperType().getName();
        String _plus_2 = (_name_1 + ".");
        String _plus_3 = (_plus_2 + attributeName);
        typesAttr = _plus_3;
      } else {
        String _name_2 = entity.getName();
        String _plus_4 = (_name_2 + ".");
        String _plus_5 = (_plus_4 + attributeName);
        attrName = _plus_5;
        String _name_3 = entity.getName();
        String _plus_6 = (_name_3 + ".");
        String _plus_7 = (_plus_6 + attributeName);
        typesAttr = _plus_7;
      }
    } else {
      String _name_4 = entity.getName();
      String _plus_8 = (_name_4 + ".");
      String _plus_9 = (_plus_8 + attributeName);
      attrName = _plus_9;
      String _name_5 = entity.getName();
      String _plus_10 = (_name_5 + ".");
      String _plus_11 = (_plus_10 + attributeName);
      typesAttr = _plus_11;
    }
    typesMap.put(typesAttr, attr);
    if (aggregated) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(aggregateName);
      _builder.append("(");
      _builder.append(key);
      _builder.append(")");
      key = _builder.toString();
      this.sqlHasAggregate = true;
      String _string = key.toString();
      Pair<String, Integer> _pair = new Pair<String, Integer>(attributeName, columnWeight);
      attributes.put(_string, _pair);
      this.ignoreEntityGrouping = true;
    } else {
      groupingList.add(key.toString());
      String _string_1 = key.toString();
      Pair<String, Integer> _pair_1 = new Pair<String, Integer>(attributeName, columnWeight);
      attributes.put(_string_1, _pair_1);
    }
  }
  
  public CharSequence getProvideSchemaName(final String schemaName) {
    StringConcatenation _builder = new StringConcatenation();
    {
      if (((schemaName != null) && (schemaName.length() > 0))) {
        _builder.append(schemaName);
        _builder.append(".");
      }
    }
    return _builder;
  }
  
  /**
   * <p>sql syntax part for joined relations.</p>
   */
  public String createJoin(final DatamartEntity entity, final DatamartEntity parent, final DatamartNavigation navigation) {
    String _xblockexpression = null;
    {
      String join = "";
      DatamartReference joinRef = navigation.getJoinRef();
      String _xifexpression = null;
      if ((joinRef instanceof DatamartReference)) {
        String _xblockexpression_1 = null;
        {
          String name = this._namingExtensions.toColumnName(joinRef.getRef());
          if ((navigation instanceof DatamartMember)) {
            List<LEntityReference> refs = ((DatamartMember)navigation).getDatamartEntity().getEntityRef().getAllReferences();
            for (final LEntityReference ref : refs) {
              if ((((ref.getType() != null) && ref.getType().equals(parent.getEntityRef())) && ref.getOpposite().getName().equals(joinRef.getRef().getName()))) {
                name = this._namingExtensions.toColumnName(ref);
              }
            }
            StringConcatenation _builder = new StringConcatenation();
            String _entityAlias = this.getEntityAlias(entity);
            _builder.append(_entityAlias);
            _builder.append(".");
            _builder.append(name);
            _builder.append("=");
            String _entityAlias_1 = this.getEntityAlias(parent);
            _builder.append(_entityAlias_1);
            _builder.append(".");
            String _idAttributeName = parent.getEntityRef().getIdAttributeName();
            _builder.append(_idAttributeName);
            join = _builder.toString();
          } else {
            if ((navigation instanceof DatamartOwner)) {
              StringConcatenation _builder_1 = new StringConcatenation();
              String _entityAlias_2 = this.getEntityAlias(entity);
              _builder_1.append(_entityAlias_2);
              _builder_1.append(".");
              String _idAttributeName_1 = entity.getEntityRef().getIdAttributeName();
              _builder_1.append(_idAttributeName_1);
              _builder_1.append("=");
              String _entityAlias_3 = this.getEntityAlias(parent);
              _builder_1.append(_entityAlias_3);
              _builder_1.append(".");
              _builder_1.append(name);
              join = _builder_1.toString();
            }
          }
          StringConcatenation _builder_2 = new StringConcatenation();
          _builder_2.append(" ");
          _builder_2.append("on(");
          _builder_2.append(join, " ");
          _builder_2.append(")");
          _xblockexpression_1 = join = _builder_2.toString();
        }
        _xifexpression = _xblockexpression_1;
      }
      _xblockexpression = _xifexpression;
    }
    return _xblockexpression;
  }
  
  public String createSupertypeJoin(final DatamartEntity entity) {
    String _xblockexpression = null;
    {
      String subTypeAlias = entity.getEntityRef().getName();
      boolean _containsKey = this.sqlAliasCounter.containsKey(entity.getEntityRef().getName());
      if (_containsKey) {
        Integer newId = this.sqlAliasCounter.get(entity.getEntityRef().getName());
        StringConcatenation _builder = new StringConcatenation();
        _builder.append(subTypeAlias);
        {
          if (((newId).intValue() > 0)) {
            _builder.append(newId);
          }
        }
        subTypeAlias = _builder.toString();
      }
      StringConcatenation _builder_1 = new StringConcatenation();
      _builder_1.append(subTypeAlias);
      _builder_1.append(".");
      String _idAttributeName = entity.getEntityRef().getIdAttributeName();
      _builder_1.append(_idAttributeName);
      _builder_1.append("=");
      String _entityAlias = this.getEntityAlias(entity.getEntityRef().getSuperType());
      _builder_1.append(_entityAlias);
      _builder_1.append(".");
      String _idAttributeName_1 = entity.getEntityRef().getSuperType().getIdAttributeName();
      _builder_1.append(_idAttributeName_1);
      String join = _builder_1.toString();
      StringConcatenation _builder_2 = new StringConcatenation();
      CharSequence _provideSchemaName = this.getProvideSchemaName(entity.getEntityRef().getPersistenceInfo().getSchemaName());
      _builder_2.append(_provideSchemaName);
      String _tableName = this._namingExtensions.toTableName(entity.getEntityRef());
      _builder_2.append(_tableName);
      _builder_2.append(" ");
      _builder_2.append(subTypeAlias);
      _builder_2.append(" on(");
      _builder_2.append(join);
      _builder_2.append(")");
      _xblockexpression = join = _builder_2.toString();
    }
    return _xblockexpression;
  }
  
  /**
   * get a set of entities used by the datamart
   */
  public Set<LEntity> findAllEntities(final DatamartDefinition datamart) {
    HashSet<LEntity> entities = new HashSet<LEntity>();
    DatamartSource _source = datamart.getSource();
    boolean _matched = false;
    if (_source instanceof DatamartEntity) {
      _matched=true;
      DatamartSource _source_1 = datamart.getSource();
      this.findAllEntites(((DatamartEntity) _source_1), entities);
    }
    if (!_matched) {
      if (_source instanceof DatamartCube) {
        _matched=true;
        DatamartSource _source_1 = datamart.getSource();
        this.findAllEntites(((DatamartCube) _source_1), entities);
      }
    }
    return entities;
  }
  
  /**
   * add all entities used by the datamart entity into the given set of entities
   */
  public void findAllEntites(final DatamartEntity datamartEntity, final Set<LEntity> entities) {
    entities.add(datamartEntity.getEntityRef());
    EList<DatamartNavigation> _navigations = datamartEntity.getNavigations();
    for (final DatamartNavigation navigation : _navigations) {
      this.findAllEntites(navigation.getDatamartEntity(), entities);
    }
  }
  
  /**
   * add all entities used by the datamart cube into the given set of entities
   */
  public void findAllEntites(final DatamartCube datamartCube, final Set<LEntity> entities) {
    entities.add(datamartCube.getCubeRef().getCubeTypeEntity().getEntityRef().getEntityValue());
    EList<CubeDimensionUsage> _dimensionUsages = datamartCube.getCubeRef().getCubeTypeEntity().getDimensionUsages();
    for (final CubeDimensionUsage dimensionUsage : _dimensionUsages) {
      EList<CubeHierarchy> _hierarchies = dimensionUsage.getSourceValue().getHierarchies();
      for (final CubeHierarchy hierarchy : _hierarchies) {
        entities.add(hierarchy.getCubeDimEntity().getEntityRef().getEntityValue());
      }
    }
  }
  
  public List<DatamartAttribute> allEntityAttributes(final DatamartDefinition datamart) {
    ArrayList<DatamartAttribute> attributes = CollectionLiterals.<DatamartAttribute>newArrayList();
    DatamartSource _source = datamart.getSource();
    if ((_source instanceof DatamartEntity)) {
      DatamartSource _source_1 = datamart.getSource();
      attributes = this.allEntityAttributes(((DatamartEntity) _source_1), "");
    }
    return attributes;
  }
  
  /**
   * add all entities used by the datamart entity into the given set of entities
   */
  public ArrayList<DatamartAttribute> allEntityAttributes(final DatamartEntity datamartEntity, final String refPrefix) {
    ArrayList<DatamartAttribute> _xblockexpression = null;
    {
      ArrayList<DatamartAttribute> entityAttributes = this.entityAttributes(datamartEntity);
      EList<DatamartNavigation> _navigations = datamartEntity.getNavigations();
      for (final DatamartNavigation navigation : _navigations) {
        this.allEntityAttributes(navigation.getDatamartEntity(), navigation.getJoinRef().getRef().getName());
      }
      LEntityAttribute primary = datamartEntity.getEntityRef().getPrimaryKeyAttribute();
      DatamartAttribute attribute = DatamartDSLFactory.eINSTANCE.createDatamartAttribute();
      attribute.setAttributeRef(primary);
      attribute.setAliased(true);
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(refPrefix);
      {
        if ((primary != null)) {
          {
            boolean _isEmpty = refPrefix.isEmpty();
            if (_isEmpty) {
              String _firstLower = StringExtensions.toFirstLower(primary.getName());
              _builder.append(_firstLower);
            } else {
              String _firstUpper = StringExtensions.toFirstUpper(primary.getName());
              _builder.append(_firstUpper);
            }
          }
        }
      }
      attribute.setAliasName(_builder.toString());
      entityAttributes.add(attribute);
      _xblockexpression = entityAttributes;
    }
    return _xblockexpression;
  }
  
  private ArrayList<DatamartAttribute> entityAttributes(final DatamartEntity entity) {
    ArrayList<DatamartAttribute> _xblockexpression = null;
    {
      ArrayList<DatamartAttribute> entityAttributes = CollectionLiterals.<DatamartAttribute>newArrayList();
      EList<DatamartAttribute> _attributes = entity.getAttributes();
      for (final DatamartAttribute attribute : _attributes) {
        entityAttributes.add(attribute);
      }
      if ((entityAttributes.isEmpty() && (!entity.isSuppressAttributes()))) {
        List<LEntityAttribute> _allAttributes = entity.getEntityRef().getAllAttributes();
        for (final LEntityAttribute attr : _allAttributes) {
          if (((((!attr.isId()) && (!attr.isUuid())) && (!attr.isVersion())) && (!attr.isTransient()))) {
            entityAttributes.add(this.createDatamartAttribute(attr));
          }
        }
      }
      _xblockexpression = entityAttributes;
    }
    return _xblockexpression;
  }
  
  private DatamartAttribute createDatamartAttribute(final LEntityAttribute attr) {
    DatamartAttribute _xblockexpression = null;
    {
      DatamartAttribute datamartAttr = DatamartDSLFactory.eINSTANCE.createDatamartAttribute();
      datamartAttr.setAttributeRef(attr);
      DatamartAxis datamartAxis = DatamartDSLFactory.eINSTANCE.createDatamartAxis();
      datamartAxis.setName(AxisEnum.COLUMNS);
      datamartAttr.setAxis(datamartAxis);
      _xblockexpression = datamartAttr;
    }
    return _xblockexpression;
  }
  
  public void infer(final EObject datamart, final IJvmDeclaredTypeAcceptor acceptor, final boolean isPreIndexingPhase) {
    if (datamart instanceof DatamartPackage) {
      _infer((DatamartPackage)datamart, acceptor, isPreIndexingPhase);
      return;
    } else if (datamart != null) {
      _infer(datamart, acceptor, isPreIndexingPhase);
      return;
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(datamart, acceptor, isPreIndexingPhase).toString());
    }
  }
}