Ejemplo n.º 1
0
 public DimensionMetaData createDimensionWithName(String dimName) {
   DimensionMetaData dimension = new DimensionMetaData(dimName);
   dimension.setExpanded(true);
   HierarchyMetaData hierarchy = createHierarchyForParentWithNode(dimension, null);
   hierarchy.setParent(dimension);
   hierarchy.setExpanded(true);
   dimension.add(hierarchy);
   return dimension;
 }
Ejemplo n.º 2
0
 public DimensionMetaData createDimensionFromNode(ColumnBackedNode obj) {
   DimensionMetaData dimension = new DimensionMetaData(obj.getName());
   dimension.setExpanded(true);
   HierarchyMetaData hierarchy = createHierarchyForParentWithNode(dimension, obj);
   hierarchy.setParent(dimension);
   hierarchy.setExpanded(true);
   dimension.add(hierarchy);
   return dimension;
 }
Ejemplo n.º 3
0
 public HierarchyMetaData createHierarchyForParentWithNode(
     DimensionMetaData parent, ColumnBackedNode obj) {
   HierarchyMetaData hier = new HierarchyMetaData(obj.getName());
   hier.setParent(parent);
   hier.setExpanded(true);
   if (obj != null) {
     LevelMetaData level = createLevelForParentWithNode(hier, obj);
     hier.add(level);
   }
   return hier;
 }
Ejemplo n.º 4
0
  public DimensionMetaData createDimensionFromAvailableTable(AvailableTable tbl) {
    DimensionMetaData dimension = new DimensionMetaData(tbl.getName());
    dimension.setExpanded(true);
    HierarchyMetaData hierarchy = new HierarchyMetaData(tbl.getName());

    hierarchy.setExpanded(true);
    for (AvailableField field : tbl.getChildren()) {
      ColumnBackedNode node = this.createColumnBackedNode(field, ModelerPerspective.ANALYSIS);
      LevelMetaData level = createLevelForParentWithNode(hierarchy, node);
      hierarchy.add(level);
    }

    hierarchy.setParent(dimension);
    hierarchy.setExpanded(true);
    dimension.add(hierarchy);
    return dimension;
  }
Ejemplo n.º 5
0
  // this method signature is intended to provide a simpler path for unit testing the upConvert
  // method on its own
  protected void setDomain(Domain d, boolean upConvertDesired) {
    this.domain = d;
    this.setModelIsChanging(true);
    this.setRelationalModelIsChanging(true);
    this.model.getDimensions().clear();
    this.model.getMeasures().clear();
    this.relationalModel.getCategories().clear();
    this.availableTables.clear();

    if (upConvertDesired) {
      upConvertLegacyModel();
    }
    List<IAvailableItem> items = new ArrayList<IAvailableItem>();
    for (IPhysicalTable table : domain.getPhysicalModels().get(0).getPhysicalTables()) {
      Boolean isFact = (Boolean) table.getProperty("FACT_TABLE");
      items.add(new AvailableTable(table, isFact == null ? false : isFact.booleanValue()));
    }

    availableTables.setChildren(items);

    fireTablesChanged();

    LogicalModel lModel = domain.getLogicalModels().get(0);

    setModelName(lModel.getName(workspaceHelper.getLocale()));
    setRelationalModelName(lModel.getName(workspaceHelper.getLocale()));

    // Set the type of modeling session. This will propagate to the UI
    if (supportsOlap(domain)) {
      this.setModellingMode(ModelerMode.ANALYSIS_AND_REPORTING);
    } else {
      this.setModellingMode(ModelerMode.REPORTING_ONLY);
    }

    lModel = getLogicalModel(ModelerPerspective.ANALYSIS);
    List<OlapDimension> theDimensions = null;
    if (lModel != null) {
      theDimensions = (List) lModel.getProperty(LogicalModel.PROPERTY_OLAP_DIMS); // $NON-NLS-1$
    }
    if (theDimensions != null) {
      Iterator<OlapDimension> theDimensionItr = theDimensions.iterator();
      while (theDimensionItr.hasNext()) {
        OlapDimension theDimension = theDimensionItr.next();

        DimensionMetaData theDimensionMD =
            new DimensionMetaData(theDimension.getName(), theDimension.getType());
        theDimensionMD.setTimeDimension(theDimension.isTimeDimension());
        List<OlapHierarchy> theHierarchies = (List) theDimension.getHierarchies();
        Iterator<OlapHierarchy> theHierarchiesItr = theHierarchies.iterator();
        while (theHierarchiesItr.hasNext()) {
          OlapHierarchy theHierarchy = theHierarchiesItr.next();
          HierarchyMetaData theHierarchyMD = new HierarchyMetaData(theHierarchy.getName());

          List<OlapHierarchyLevel> theLevels = theHierarchy.getHierarchyLevels();
          Iterator<OlapHierarchyLevel> theLevelsItr = theLevels.iterator();
          while (theLevelsItr.hasNext()) {
            OlapHierarchyLevel theLevel = theLevelsItr.next();
            LevelMetaData theLevelMD = new LevelMetaData(theHierarchyMD, theLevel.getName());

            theLevelMD.setParent(theHierarchyMD);

            theLevelMD.setUniqueMembers(theLevel.isHavingUniqueMembers());
            if (theDimensionMD.isTimeDimension()) {
              TimeRole role = TimeRole.fromMondrianAttributeValue(theLevel.getLevelType());
              if (role != null) {
                theLevelMD.setDataRole(role);
              }
            }

            // Make sure we're dealing with the OLAP copy. Note that duplicated columns will have an
            // OLAP_[0-9]+ at the
            // end
            String refID;
            LogicalColumn olapCol;

            olapCol = theLevel.getReferenceColumn();
            if (olapCol != null) {
              refID = olapCol.getId();
              if (!refID.endsWith(BaseModelerWorkspaceHelper.OLAP_SUFFIX)
                  && !refID.contains(BaseModelerWorkspaceHelper.OLAP_SUFFIX + "_")) {
                olapCol = ModelerConversionUtil.findCorrespondingOlapColumn(olapCol, lModel);
                theLevel.setReferenceColumn(olapCol);
              }
              theLevelMD.setLogicalColumn(olapCol);
            }

            olapCol = theLevel.getReferenceOrdinalColumn();
            if (olapCol != null) {
              refID = olapCol.getId();
              if (!refID.endsWith(BaseModelerWorkspaceHelper.OLAP_SUFFIX)
                  && !refID.contains(BaseModelerWorkspaceHelper.OLAP_SUFFIX + "_")) {
                olapCol = ModelerConversionUtil.findCorrespondingOlapColumn(olapCol, lModel);
                theLevel.setReferenceOrdinalColumn(olapCol);
              }
              theLevelMD.setLogicalOrdinalColumn(olapCol);
            }

            olapCol = theLevel.getReferenceCaptionColumn();
            if (olapCol != null) {
              refID = olapCol.getId();
              if (!refID.endsWith(BaseModelerWorkspaceHelper.OLAP_SUFFIX)
                  && !refID.contains(BaseModelerWorkspaceHelper.OLAP_SUFFIX + "_")) {
                olapCol = ModelerConversionUtil.findCorrespondingOlapColumn(olapCol, lModel);
                theLevel.setReferenceCaptionColumn(olapCol);
              }
              theLevelMD.setLogicalCaptionColumn(olapCol);
            }
            // get any logicalColumns and turn them into member properties
            if (theLevel.getLogicalColumns() != null && theLevel.getLogicalColumns().size() > 0) {
              for (LogicalColumn lc : theLevel.getLogicalColumns()) {
                // BISERVER-11578 - Protect against null lc's in the collection. We still need to
                // investigate why this can happen in the model.
                if (lc == null) {
                  continue;
                }

                if (!lc.getId().endsWith(BaseModelerWorkspaceHelper.OLAP_SUFFIX)
                    && !lc.getId().contains(BaseModelerWorkspaceHelper.OLAP_SUFFIX + "_")) {
                  // not pointing to the olap col
                  lc = ModelerConversionUtil.findCorrespondingOlapColumn(lc, lModel);
                }
                MemberPropertyMetaData memberProp =
                    new MemberPropertyMetaData(theLevelMD, lc.getName(workspaceHelper.getLocale()));
                memberProp.setLogicalColumn(lc);
                memberProp.setDescription(lc.getDescription(workspaceHelper.getLocale()));
                theLevelMD.add(memberProp);
              }
            }
            List<OlapAnnotation> annotations = theLevel.getAnnotations();
            if (annotations != null) {
              for (OlapAnnotation anno : annotations) {
                IMemberAnnotation annoMeta = MemberAnnotationFactory.create(anno);
                theLevelMD.getMemberAnnotations().put(anno.getName(), annoMeta);
              }
            }
            theHierarchyMD.add(theLevelMD);
          }

          theHierarchyMD.setParent(theDimensionMD);
          theDimensionMD.add(theHierarchyMD);
        }
        this.model.getDimensions().add(theDimensionMD);
      }
    }
    List<OlapCube> theCubes = null;
    if (lModel != null) {
      theCubes = (List) lModel.getProperty(LogicalModel.PROPERTY_OLAP_CUBES); // $NON-NLS-1$
    }
    if (theCubes != null) {
      Iterator<OlapCube> theCubeItr = theCubes.iterator();
      while (theCubeItr.hasNext()) {
        OlapCube theCube = theCubeItr.next();

        List<OlapMeasure> theMeasures = theCube.getOlapMeasures();
        Iterator<OlapMeasure> theMeasuresItr = theMeasures.iterator();
        while (theMeasuresItr.hasNext()) {
          OlapMeasure theMeasure = theMeasuresItr.next();

          MeasureMetaData theMeasureMD = new MeasureMetaData(workspaceHelper.getLocale());

          if (theMeasure.getName() == null || theMeasure.getName().length() == 0) {
            theMeasureMD.setName(
                theMeasure.getLogicalColumn().getName(workspaceHelper.getLocale()));
          } else {
            theMeasureMD.setName(theMeasure.getName());
          }
          theMeasureMD.setFormat(
              (String) theMeasure.getLogicalColumn().getProperty("mask")); // $NON-NLS-1$
          theMeasureMD.setDefaultAggregation(theMeasure.getLogicalColumn().getAggregationType());
          String possibleMeasureName = theMeasure.getLogicalColumn().getId();
          if (!theMeasure
                  .getLogicalColumn()
                  .getId()
                  .endsWith(BaseModelerWorkspaceHelper.OLAP_SUFFIX)
              && !theMeasure
                  .getLogicalColumn()
                  .getId()
                  .contains(BaseModelerWorkspaceHelper.OLAP_SUFFIX + "_")) {
            // change the backing column to the olap version
            LogicalColumn olapCol =
                ModelerConversionUtil.findCorrespondingOlapColumn(
                    theMeasure.getLogicalColumn(), lModel);
            theMeasure.setLogicalColumn(olapCol);
          }

          // BISERVER-6077 - Mondrian exporter uses logical column names as measure names, make sure
          // they get set
          // properly
          LogicalColumn lCol = theMeasure.getLogicalColumn();
          Set<String> locales = lCol.getName().getLocales();
          String[] stringLocals = locales.toArray(new String[] {});
          if (stringLocals != null && stringLocals.length > 0) {
            if (theMeasure.getName() == null || theMeasure.getName().trim().length() == 0) {
              theMeasure.setName(possibleMeasureName);
            }
            lCol.setName(new LocalizedString(stringLocals[0], theMeasure.getName()));
          }

          theMeasureMD.setLogicalColumn(lCol);
          this.model.getMeasures().add(theMeasureMD);
        }
      }
    }

    lModel = this.getLogicalModel(ModelerPerspective.REPORTING);
    int i = 1;
    for (Category cat : lModel.getCategories()) {
      String catName =
          BaseModelerWorkspaceHelper.getCleanCategoryName(
              cat.getName(workspaceHelper.getLocale()), this, i++);
      CategoryMetaData catMeta = new CategoryMetaData(catName);
      for (LogicalColumn col : cat.getLogicalColumns()) {
        LogicalTable table = col.getLogicalTable();

        if (!table.getLogicalColumns().contains(col)) {
          table.addLogicalColumn(col);
        }

        Object formatMask = col.getProperty("mask");
        String colName = col.getName(workspaceHelper.getLocale());
        AggregationType aggType = col.getAggregationType();

        FieldMetaData field =
            new FieldMetaData(
                catMeta,
                colName,
                formatMask == null ? null : formatMask.toString(),
                colName,
                workspaceHelper.getLocale());
        if (aggType != null) {
          field.setDefaultAggregation(aggType);
        } else {
          field.setDefaultAggregation(AggregationType.NONE);
        }
        field.setLogicalColumn(col);

        catMeta.add(field);
      }
      this.getRelationalModel().getCategories().add(catMeta);
    }

    this.setModelIsChanging(false, true);
    this.setRelationalModelIsChanging(false, true);
  }