@Test
  public void testPopulateCategories_MultipleCategoriesAggregationTypesAndFormatMasks()
      throws ModelerException {
    ModelerWorkspaceHelper helper = new ModelerWorkspaceHelper(LOCALE);
    LogicalModel logicalModel = workspace.getLogicalModel(ModelerPerspective.REPORTING);
    helper.autoModelFlat(workspace);
    helper.autoModelRelationalFlat(workspace);
    spiceUpRelationalModel(workspace.getRelationalModel());
    helper.populateCategories(workspace);

    List<AvailableTable> tablesList = workspace.getAvailableTables().getAsAvailableTablesList();

    List<Category> categories = logicalModel.getCategories();
    assertEquals(2, categories.size());
    assertEquals(
        tablesList.get(0).getAvailableFields().size(),
        categories.get(0).getLogicalColumns().size());
    System.out.println(logicalModel.getLogicalTables().get(0).getLogicalColumns().size());

    assertEquals(1, categories.get(1).getLogicalColumns().size());

    for (int i = 0; i < categories.size(); i++) {

      for (LogicalColumn lCol : categories.get(i).getLogicalColumns()) {
        FieldMetaData orig = null;
        for (FieldMetaData fieldMetaData : workspace.getRelationalModel().getCategories().get(i)) {
          if (lCol.getId().equals(fieldMetaData.getLogicalColumn().getId())) {
            orig = fieldMetaData;
            break;
          }
        }
        assertNotNull(orig);
        assertEquals(orig.getDefaultAggregation(), lCol.getAggregationType());
        if (orig.getFormat().equals("NONE")) {
          if (orig.getLogicalColumn().getDataType() == DataType.NUMERIC) {
            assertTrue(((String) lCol.getProperty("mask")).indexOf("#") > -1);
          } else {
            assertTrue(lCol.getProperty("mask") == null);
          }
        } else {
          assertEquals(orig.getFormat(), lCol.getProperty("mask"));
        }
      }
    }
  }
  @Test
  public void testPopulateCategories() throws ModelerException {
    ModelerWorkspaceHelper helper = new ModelerWorkspaceHelper(LOCALE);
    LogicalModel logicalModel = workspace.getDomain().getLogicalModels().get(0);
    List<AvailableTable> tablesList = workspace.getAvailableTables().getAsAvailableTablesList();

    int fields = tablesList.get(0).getAvailableFields().size();
    helper.autoModelFlat(workspace);
    helper.autoModelRelationalFlat(workspace);
    helper.populateCategories(workspace);

    List<Category> categories = logicalModel.getCategories();

    assertEquals(1, categories.size());
    assertEquals(fields, tablesList.get(0).getAvailableFields().size());
    System.out.println(logicalModel.getLogicalTables().get(0).getLogicalColumns().size());
    assertEquals(
        tablesList.get(0).getAvailableFields().size(),
        categories.get(0).getLogicalColumns().size());

    for (LogicalColumn lCol : categories.get(0).getLogicalColumns()) {
      FieldMetaData orig = null;
      for (FieldMetaData fieldMetaData : workspace.getRelationalModel().getCategories().get(0)) {
        if (lCol.getId().equals(fieldMetaData.getLogicalColumn().getId())) {
          orig = fieldMetaData;
          break;
        }
      }
      assertNotNull(orig);
      assertEquals(orig.getDefaultAggregation(), lCol.getAggregationType());
      if (orig.getFormat().equals("NONE")) {
        if (orig.getLogicalColumn().getDataType() == DataType.NUMERIC) {
          assertTrue("#".equals(lCol.getProperty("mask")));
        } else {
          assertTrue(lCol.getProperty("mask") == null);
        }
      } else {
        assertEquals(orig.getFormat(), lCol.getProperty("mask"));
      }
    }
  }
Exemplo n.º 3
0
  public void refresh(Domain newDomain) throws ModelerException {

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

    availableTables.setChildren(items);

    setModelIsChanging(true);
    setRelationalModelIsChanging(true);

    // Set the type of modeling session. This will propigate to the UI
    if (supportsOlap(newDomain)) {
      this.setModellingMode(ModelerMode.ANALYSIS_AND_REPORTING);
    } else {
      this.setModellingMode(ModelerMode.REPORTING_ONLY);
      // clear out OLAP side of the existing model
      model.getDimensions().clear();
    }
    List<AvailableTable> tablesList = availableTables.getAsAvailableTablesList();

    fireTablesChanged();

    // replace the domain with the new domain, which
    // makes sure the physical and logical columns are accurate
    domain = newDomain;

    for (MeasureMetaData measure : model.getMeasures()) {
      boolean found = false;
      if (measure.getLogicalColumn() != null) {
        inner:
        for (AvailableTable table : tablesList) {
          for (AvailableField f : table.getAvailableFields()) {
            if (f.getPhysicalColumn()
                    .getId()
                    .equals(measure.getLogicalColumn().getPhysicalColumn().getId())
                && f.getPhysicalColumn()
                    .getPhysicalTable()
                    .getId()
                    .equals(
                        measure
                            .getLogicalColumn()
                            .getPhysicalColumn()
                            .getPhysicalTable()
                            .getId())) {
              // the physical column backing this measure is still available, set it to the new one
              measure.setLogicalColumn(
                  createColumnBackedNode(f, currentModelerPerspective).getLogicalColumn());
              found = true;
              break inner;
            }
          }
        }
        if (!found) {
          // the physical column that backed this measure no longer exists in the model.
          // therefore, we must invalidate it's logical column
          measure.setLogicalColumn(null);
        }
      }
    }

    try {
      for (DimensionMetaData dm : model.getDimensions()) {
        for (HierarchyMetaData hm : dm) {
          for (LevelMetaData lm : hm) {
            boolean found = false;
            if (lm.getLogicalColumn() != null) {
              inner:
              for (AvailableTable table : tablesList) {
                for (AvailableField f : table.getAvailableFields()) {
                  if (f.getPhysicalColumn()
                          .getId()
                          .equals(lm.getLogicalColumn().getPhysicalColumn().getId())
                      && f.getPhysicalColumn()
                          .getPhysicalTable()
                          .getId()
                          .equals(
                              lm.getLogicalColumn()
                                  .getPhysicalColumn()
                                  .getPhysicalTable()
                                  .getId())) {
                    // the physical column backing this level is still available, it is ok

                    lm.setLogicalColumn(
                        createColumnBackedNode(f, currentModelerPerspective).getLogicalColumn());
                    found = true;
                    break inner;
                  }
                }
              }
            }
            if (!found) {
              // the physical column that backed this level no longer exists in the model.
              // therefore, we must invalidate it's logical column
              lm.setLogicalColumn(null);
            }
          }
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }

    for (CategoryMetaData category : relationalModel.getCategories()) {
      for (FieldMetaData field : category) {
        boolean found = false;
        if (field.getLogicalColumn() != null) {
          inner:
          for (AvailableTable table : tablesList) {
            for (AvailableField f : table.getAvailableFields()) {
              if (f.getPhysicalColumn()
                      .getId()
                      .equals(field.getLogicalColumn().getPhysicalColumn().getId())
                  && f.getPhysicalColumn()
                      .getPhysicalTable()
                      .getId()
                      .equals(
                          field
                              .getLogicalColumn()
                              .getPhysicalColumn()
                              .getPhysicalTable()
                              .getId())) {

                // the physical column backing this field is still available, it is ok
                found = true;
                break inner;
              }
            }
          }
          if (!found) {
            // the physical column that backed this field no longer exists in the model.
            // therefore, we must invalidate it's logical column
            field.setLogicalColumn(null);
          }
        }
      }
    }

    // If the new model was previously "auto-modeled" we need to clean that now
    LogicalModel newLModel = getLogicalModel(ModelerPerspective.ANALYSIS);
    if (newLModel != null) {
      List<OlapDimension> theDimensions =
          (List) newLModel.getProperty("olap_dimensions"); // $NON-NLS-1$
      if (theDimensions != null) {
        theDimensions.clear();
      }
      List<OlapCube> theCubes = (List) newLModel.getProperty("olap_cubes"); // $NON-NLS-1$
      if (theCubes != null) {
        theCubes.clear();
      }
    }

    setModelIsChanging(false);
    setRelationalModelIsChanging(false);
  }