Java Code Examples for org.pentaho.metadata.model.concept.types.AggregationType

The following examples show how to use org.pentaho.metadata.model.concept.types.AggregationType. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
protected void addOrderBy( Query query, Category category, String columnId, String aggregation, Order.Type orderType )
  throws PentahoMetadataException {

  if ( category == null ) {
    throw new PentahoMetadataException( Messages.getErrorString( "QueryXmlHelper.ERROR_0016_BUSINESS_CATEGORY_NULL" ) ); //$NON-NLS-1$ 
  }

  LogicalColumn column = category.findLogicalColumn( columnId );
  if ( column == null ) {
    throw new PentahoMetadataException( Messages.getErrorString(
        "QueryXmlHelper.ERROR_0013_BUSINESS_COL_NOT_FOUND", category.getId(), columnId ) ); //$NON-NLS-1$ 
  }

  // this code verifies the aggregation setting provided is a
  // valid option
  AggregationType aggsetting = null;
  if ( aggregation != null ) {
    AggregationType setting = AggregationType.valueOf( aggregation.toUpperCase() );
    if ( ( column.getAggregationType() == setting ) || column.getAggregationList() != null
        && column.getAggregationList().contains( setting ) ) {
      aggsetting = setting;
    }
  }

  query.getOrders().add( new Order( new Selection( category, column, aggsetting ), orderType ) );
}
 
Example 2
private int convertAggType( AggregationType type ) {
  switch ( type ) {
    case NONE:
      return GroupByMeta.TYPE_GROUP_NONE;
    case AVERAGE:
      return GroupByMeta.TYPE_GROUP_AVERAGE;
    case SUM:
      return GroupByMeta.TYPE_GROUP_SUM;
    case COUNT:
      return GroupByMeta.TYPE_GROUP_COUNT_ALL;
    case COUNT_DISTINCT:
      return GroupByMeta.TYPE_GROUP_COUNT_DISTINCT;
    case MINIMUM:
      return GroupByMeta.TYPE_GROUP_MIN;
    case MAXIMUM:
      return GroupByMeta.TYPE_GROUP_MAX;
    default:
      return GroupByMeta.TYPE_GROUP_NONE;
  }
}
 
Example 3
/**
 * In this test we try to see to it :<br>
 * - that the formula engine picks the 2 specified columns from 2 different business tables<br>
 * - that we calculate the sum of the multiplication <br>
 */
@Test
public void testMultiTableColumnFormulasAggregate() throws Exception {
  LogicalColumn quantityOrdered = getOrdersModel().findLogicalColumn( "BC_ORDER_DETAILS_QUANTITYORDERED" );
  Assert.assertNotNull( "Expected to find the business column 'quantity ordered'", quantityOrdered );
  LogicalColumn buyPrice = getOrdersModel().findLogicalColumn( "BC_PRODUCTS_BUYPRICE" );
  Assert.assertNotNull( "Expected to find the business column 'buy price'", buyPrice );

  // let's remove the aggregations of the quantity ordered...
  //
  AggregationType qaBackup = quantityOrdered.getAggregationType();
  AggregationType paBackup = buyPrice.getAggregationType();
  quantityOrdered.setAggregationType( AggregationType.NONE );
  buyPrice.setAggregationType( AggregationType.NONE );

  // This changes the expected result...
  //
  String formula = "SUM( [BT_ORDER_DETAILS.BC_ORDER_DETAILS_QUANTITYORDERED] * [BT_PRODUCTS.BC_PRODUCTS_BUYPRICE] )";
  String sql = "SUM( BT_ORDER_DETAILS.QUANTITYORDERED  *  BT_PRODUCTS.BUYPRICE )";

  handleFormula( getOrdersModel(), "Hypersonic", formula, sql );

  // Set it back to the way it was for further testing.
  quantityOrdered.setAggregationType( qaBackup );
  buyPrice.setAggregationType( paBackup );
}
 
Example 4
/**
 * In this test we try to test :<br>
 * - if the formula engine picks the 2 specified columns from 2 different business tables<br>
 * - if we calculate the multiplication of the sums <br>
 */
@Test
public void testMultiTableColumnFormulasAggregate2() throws Exception {
  LogicalColumn quantityOrdered = getOrdersModel().findLogicalColumn( "BC_ORDER_DETAILS_QUANTITYORDERED" );
  Assert.assertNotNull( "Expected to find the business column 'quantity ordered'", quantityOrdered );
  LogicalColumn buyPrice = getOrdersModel().findLogicalColumn( "BC_PRODUCTS_BUYPRICE" );
  Assert.assertNotNull( "Expected to find the business column 'buy price'", buyPrice );

  // let's enable the aggregations of the quantity ordered...
  //
  AggregationType qaBackup = quantityOrdered.getAggregationType();
  AggregationType paBackup = buyPrice.getAggregationType();
  quantityOrdered.setAggregationType( AggregationType.SUM );
  buyPrice.setAggregationType( AggregationType.SUM );

  // This changes the expected result...
  //
  String formula = "[BT_ORDER_DETAILS.BC_ORDER_DETAILS_QUANTITYORDERED] * [BT_PRODUCTS.BC_PRODUCTS_BUYPRICE]";
  String sql = "SUM(BT_ORDER_DETAILS.QUANTITYORDERED)  *  SUM(BT_PRODUCTS.BUYPRICE)";

  handleFormula( getOrdersModel(), "Hypersonic", formula, sql );

  // Set it back to the way it was for further testing.
  quantityOrdered.setAggregationType( qaBackup );
  buyPrice.setAggregationType( paBackup );
}
 
Example 5
private AggregationType getAggregationType( AggType type ) {
  if ( type == null ) {
    return null;
  }
  switch ( type ) {
    case COUNT:
      return AggregationType.COUNT;
    case COUNT_DISTINCT:
      return AggregationType.COUNT_DISTINCT;
    case AVERAGE:
      return AggregationType.AVERAGE;
    case MAX:
      return AggregationType.MAXIMUM;
    case MIN:
      return AggregationType.MINIMUM;
    case SUM:
      return AggregationType.SUM;
    default:
      return AggregationType.NONE;
  }
}
 
Example 6
private AggregationType getAggregationType( AggType type ) {
  if ( type == null ) {
    return null;
  }
  switch ( type ) {
    case COUNT:
      return AggregationType.COUNT;
    case COUNT_DISTINCT:
      return AggregationType.COUNT_DISTINCT;
    case AVERAGE:
      return AggregationType.AVERAGE;
    case MAX:
      return AggregationType.MAXIMUM;
    case MIN:
      return AggregationType.MINIMUM;
    case SUM:
      return AggregationType.SUM;
    default:
      return AggregationType.NONE;
  }
}
 
Example 7
protected AggType convertNewThinAggregationType( AggregationType aggregationType ) {
  if ( aggregationType == null ) {
    return AggType.NONE;
  }

  switch ( aggregationType ) {
    case COUNT:
      return AggType.COUNT;
    case COUNT_DISTINCT:
      return AggType.COUNT_DISTINCT;
    case AVERAGE:
      return AggType.AVERAGE;
    case MINIMUM:
      return AggType.MIN;
    case MAXIMUM:
      return AggType.MAX;
    case SUM:
      return AggType.SUM;
    case NONE:
    default:
      return AggType.NONE;
  }
}
 
Example 8
/**
 * @param value
 * @param type
 * @return
 */
public Object getValue( final Object value, final Class type, final DataAttributeContext context ) {
  if ( value == null ) {
    return null;
  }

  if ( value instanceof AggregationType == false ) {
    return null;
  }

  if ( AggregationType.class.equals( type ) ) {
    return value;
  }

  if ( type == null || Object.class.equals( type ) ) {
    return value;
  }

  if ( AggregationType.NONE.equals( value ) ) {
    return "none";
  } else if ( AggregationType.SUM.equals( value ) ) {
    return "sum";
  } else if ( AggregationType.AVERAGE.equals( value ) ) {
    return "average";
  } else if ( AggregationType.COUNT.equals( value ) ) {
    return "count";
  } else if ( AggregationType.COUNT_DISTINCT.equals( value ) ) {
    return "count_distinct";
  } else if ( AggregationType.MINIMUM.equals( value ) ) {
    return "minimum";
  } else if ( AggregationType.MAXIMUM.equals( value ) ) {
    return "maximum";
  } else {
    return null;
  }

}
 
Example 9
public IMetadataDomainRepository getMetadataDomainRepository( final String domainId,
                                                              final ResourceManager resourceManager,
                                                              final ResourceKey contextKey,
                                                              final String xmiFile )
  throws ReportDataFactoryException {
  try {
    final InputStream stream = createStream( resourceManager, contextKey, xmiFile );
    try {
      final InMemoryMetadataDomainRepository repo = new InMemoryMetadataDomainRepository();
      final XmiParser parser = new XmiParser();
      final Domain domain = parser.parseXmi( stream );
      // add a couple of agg types to the quantity ordered physical column
      final IPhysicalTable table =
        ( (SqlPhysicalModel) domain.getPhysicalModels().get( 0 ) ).getPhysicalTables().get( 7 );
      final IPhysicalColumn col = table.getPhysicalColumns().get( 3 );
      final List<AggregationType> list = new ArrayList<AggregationType>();
      list.add( AggregationType.SUM );
      list.add( AggregationType.AVERAGE );
      col.setAggregationList( list );
      domain.setId( domainId );
      repo.storeDomain( domain, true );
      return repo;
    } finally {
      stream.close();
    }
  } catch ( final Exception e ) {
    throw new ReportDataFactoryException( "The Specified XMI File is invalid: " + xmiFile, e );
  }
}
 
Example 10
public AggregationType getActiveAggregationType() {
  if ( getAggregationType() == null ) {
    AggregationType aggType = logicalColumn.getAggregationType();
    if ( aggType == null ) {
      return AggregationType.NONE;
    } else {
      return aggType;
    }
  } else {
    return getAggregationType();
  }
}
 
Example 11
public PropertyTypeRegistry() {
  // load these from a spring config file?
  addPropertyType( String.class );
  addPropertyType( LocalizedString.class );
  addPropertyType( DataType.class );
  addPropertyType( TargetTableType.class );
  addPropertyType( TargetColumnType.class );
  addPropertyType( AggregationType.class );

  // this is for agg lists,
  // we will need another way to express lists
  addPropertyType( List.class );

  addPropertyType( Alignment.class );
  addPropertyType( Color.class );
  addPropertyType( ColumnWidth.class );
  addPropertyType( FieldType.class );
  addPropertyType( Font.class );
  addPropertyType( TableType.class );
  addPropertyType( RowLevelSecurity.class );
  addPropertyType( Security.class );
  addPropertyType( Double.class );
  addPropertyType( Boolean.class );
  addPropertyType( Date.class );

  // note that URL is not GWT compatible, we'll need to figure out what to do with this
  // once we move towards a fully supported thin client metadata editor
  addPropertyType( URL.class );

}
 
Example 12
public static String convertToMondrian( AggregationType aggregationType ) {
  String typeDesc = null;
  switch ( aggregationType ) {
    case NONE:
      typeDesc = "none"; //$NON-NLS-1$
      break;
    case SUM:
      typeDesc = "sum"; //$NON-NLS-1$
      break;
    case AVERAGE:
      typeDesc = "avg"; //$NON-NLS-1$
      break;
    case COUNT:
      typeDesc = "count"; //$NON-NLS-1$
      break;
    case COUNT_DISTINCT:
      typeDesc = "distinct count"; //$NON-NLS-1$
      break;
    case MINIMUM:
      typeDesc = "min"; //$NON-NLS-1$
      break;
    case MAXIMUM:
      typeDesc = "max"; //$NON-NLS-1$
      break;
  }
  return typeDesc;
}
 
Example 13
@Test
public void testQueryExecutionWithAggregationsAndConstraints() throws Exception {

  List<String> users = new ArrayList<String>();
  users.add( "suzy" );
  List<String> roles = new ArrayList<String>();
  roles.add( "Authenticated" );
  int defaultAcls = 31;
  InlineEtlModelGenerator gen =
      new InlineEtlModelGenerator( "testmodel", csvFilesPath, "example.csv", true,
          ",", "\"", true, users, roles, defaultAcls, "joe" );

  Domain domain = gen.generate();

  LogicalModel model = domain.getLogicalModels().get( 0 );
  Category category = model.getCategories().get( 0 );
  category.getLogicalColumns().get( 1 ).setDataType( DataType.NUMERIC );
  category.getLogicalColumns().get( 1 ).setAggregationType( AggregationType.SUM );
  Query query = new Query( domain, model );

  query.getSelections().add( new Selection( category, category.getLogicalColumns().get( 3 ), null ) );
  query.getSelections().add( new Selection( category, category.getLogicalColumns().get( 1 ), null ) );
  query.getConstraints().add( new Constraint( CombinationType.AND, "[bc_testmodel.bc_1_Data2] > 4.0" ) );
  query.getOrders().add(
      new Order( new Selection( category, category.getLogicalColumns().get( 3 ), null ), Order.Type.DESC ) );

  InlineEtlQueryExecutor executor = new InlineEtlQueryExecutor();
  IPentahoResultSet resultset = executor.executeQuery( query, csvFilesPath, null );

  Assert.assertEquals( 2, resultset.getRowCount() );
  Assert.assertEquals( 2, resultset.getColumnCount() );
  Assert.assertEquals( "bc_3_Data4", resultset.getMetaData().getColumnHeaders()[0][0] );
  Assert.assertEquals( "bc_1_Data2", resultset.getMetaData().getColumnHeaders()[0][1] );

  Assert.assertEquals( "String Value", resultset.getValueAt( 0, 0 ) );
  Assert.assertEquals( "Bigger String Value", resultset.getValueAt( 1, 0 ) );

  Assert.assertEquals( 19.5, resultset.getValueAt( 0, 1 ) );
  Assert.assertEquals( 5.7, resultset.getValueAt( 1, 1 ) );
}
 
Example 14
private LogicalTable createLogicalTable( String tblId, LogicalModel model, Category mainCat ) throws Exception {

    LogicalTable rtn = new LogicalTable();
    rtn.setId( "bt_" + tblId );
    rtn.setProperty( SqlPhysicalTable.TARGET_TABLE, "pt_" + tblId ); //$NON-NLS-1$
    createBusinessKeyColumn( tblId, "keya", rtn, mainCat ); // 0
    createBusinessKeyColumn( tblId, "keyb", rtn, mainCat ); // 1
    createBusinessKeyColumn( tblId, "keyc", rtn, mainCat ); // 2
    createBusinessKeyColumn( tblId, "keyd", rtn, mainCat ); // 3
    createBusinessKeyColumn( tblId, "keye", rtn, mainCat ); // 4
    createBusinessKeyColumn( tblId, "keyf", rtn, mainCat ); // 5
    createBusinessKeyColumn( tblId, "keyg", rtn, mainCat ); // 6
    createBusinessKeyColumn( tblId, "keyh", rtn, mainCat ); // 7
    createBusinessKeyColumn( tblId, "keyi", rtn, mainCat ); // 8
    createBusinessKeyColumn( tblId, "keyj", rtn, mainCat ); // 9
    createBusinessKeyColumn( tblId, "keyk", rtn, mainCat ); // 10
    createBusinessKeyColumn( tblId, "keyl", rtn, mainCat ); // 11

    LogicalColumn bcs1 = new LogicalColumn();
    bcs1.setId( "bcs_" + tblId );
    bcs1.setProperty( SqlPhysicalColumn.TARGET_COLUMN, "pc_" + tblId ); //$NON-NLS-1$
    bcs1.setProperty( IPhysicalColumn.AGGREGATIONTYPE_PROPERTY, AggregationType.SUM );
    bcs1.setLogicalTable( rtn );
    rtn.addLogicalColumn( bcs1 );
    mainCat.addLogicalColumn( bcs1 );
    model.addLogicalTable( rtn );
    return rtn;

  }
 
Example 15
private static IPhysicalColumn importPhysicalColumnDefinition( ValueMetaInterface v, SqlPhysicalTable physicalTable,
                                                               String locale,
                                                               final ImportStrategy importStrategy ) {
   // The name of the column in the database
  //
  String columnName = v.getName();

  // The field type?
  //
  FieldType fieldType = FieldType.guessFieldType( v.getName() );

  // Create a physical column.
  //
  SqlPhysicalColumn physicalColumn = new SqlPhysicalColumn( physicalTable );
  physicalColumn.setId( v.getName() );
  physicalColumn.setTargetColumn( columnName );
  physicalColumn.setFieldType( fieldType );
  physicalColumn.setAggregationType( AggregationType.NONE );

  // Set the localized name...
  //
  String niceName = beautifyName( importStrategy.displayName( v ) );
  physicalColumn.setName( new LocalizedString( locale, niceName ) );

  // Set the parent concept to the base concept...
  // physicalColumn.getConcept().setParentInterface(schemaMeta.findConcept(
  // Settings.getConceptNameBase()));

  // The data type...
  DataType dataType = getDataType( v );
  physicalColumn.setDataType( dataType );

  if ( null != v.getConversionMask() ) {
    physicalColumn.setProperty( "source_mask", v.getConversionMask() );
  }

  if ( null != v.getDecimalSymbol() ) {
    physicalColumn.setProperty( "source_decimalSymbol", v.getDecimalSymbol() );
  }

  if ( null != v.getGroupingSymbol() ) {
    physicalColumn.setProperty( "source_groupingSymbol", v.getGroupingSymbol() );
  }

  if ( null != v.getCurrencySymbol() ) {
    physicalColumn.setProperty( "source_currencySymbol", v.getCurrencySymbol() );
  }

  return physicalColumn;
}
 
Example 16
public AliasedSelection( Category category, LogicalColumn column, AggregationType agg, String alias ) {
  super( category, column, agg );
  this.alias = alias;
}
 
Example 17
public Selection( Category category, LogicalColumn column, AggregationType aggregation ) {
  this.category = category;
  this.logicalColumn = column;
  this.aggregation = aggregation;
}
 
Example 18
public AggregationType getAggregationType() {
  return aggregation;
}
 
Example 19
public boolean hasAggregate() {
  // this selection is an aggregate if the business column is an aggregate and the agg type is not null
  return !AggregationType.NONE.equals( getActiveAggregationType() );
}
 
Example 20
protected void addSelectionFromXmlNode( Query query, Element selectionElement ) {

    NodeList viewnodes = selectionElement.getElementsByTagName( "view" ); //$NON-NLS-1$
    NodeList nodes = selectionElement.getElementsByTagName( "column" ); //$NON-NLS-1$
    if ( nodes.getLength() == 0 ) {
      // should throw exception here
      return;
    }
    String columnId = XMLHandler.getNodeValue( nodes.item( 0 ) );
    String viewId = null;
    Category category = null;
    if ( viewnodes.getLength() != 0 ) {
      // this is due to legacy reasons, the query doesn't really need the category.
      viewId = XMLHandler.getNodeValue( viewnodes.item( 0 ) );
      category = query.getLogicalModel().findCategory( viewId );
    }
    LogicalColumn column = null;
    if ( category != null ) {
      column = category.findLogicalColumn( columnId );
    } else {
      column = query.getLogicalModel().findLogicalColumnInCategories( columnId );
    }
    if ( column != null ) {
      AggregationType aggsetting = null;
      NodeList aggnodes = selectionElement.getElementsByTagName( "aggregation" ); //$NON-NLS-1$
      if ( aggnodes.getLength() > 0 ) {
        String aggvalue = XMLHandler.getNodeValue( aggnodes.item( 0 ) );
        AggregationType setting = AggregationType.valueOf( aggvalue.toUpperCase() );
        if ( setting == null ) {
          Messages.getErrorString( "QueryXmlHelper.ERROR_0011_AGG_NOT_RECOGNIZED", columnId, aggvalue ); //$NON-NLS-1$
        } else {
          // verify that the setting is one of the options for this business column
          if ( ( column.getAggregationType() == setting ) || column.getAggregationList() != null
              && column.getAggregationList().contains( setting ) ) {
            aggsetting = setting;
          } else {
            Messages.getErrorString( "QueryXmlHelper.ERROR_0012_INVALID_AGG_FOR_BUSINESS_COL", columnId, aggvalue ); //$NON-NLS-1$
          }
        }
      }

      query.getSelections().add( new Selection( category, column, aggsetting ) );
    } else {
      // print a warning message
      Messages.getErrorString( "QueryXmlHelper.ERROR_0013_BUSINESS_COL_NOT_FOUND", viewId, columnId ); //$NON-NLS-1$
    }
  }
 
Example 21
public List<QueryConstraint> parseConstraints( Query query, Map<String, Object> parameters ) {
  List<QueryConstraint> constraints = new ArrayList<QueryConstraint>();
  for ( Constraint constraint : query.getConstraints() ) {
    QueryConstraint qc = new QueryConstraint();
    qc.orig = constraint;

    // parse out all the [] fields
    Pattern p = Pattern.compile( "\\[([^\\]]*)\\]" ); //$NON-NLS-1$
    Matcher m = p.matcher( constraint.getFormula() );
    StringBuffer sb = new StringBuffer();
    while ( m.find() ) {
      String match = m.group( 1 );
      if ( match.startsWith( "param:" ) ) { //$NON-NLS-1$
        String paramName = match.substring( 6 );
        Object paramValue = parameters.get( paramName );
        String openFormulaValue = ""; //$NON-NLS-1$
        if ( paramValue instanceof Boolean ) {
          // need to get and then render either true or false function.
          if ( ( (Boolean) paramValue ).booleanValue() ) {
            openFormulaValue = "TRUE()"; //$NON-NLS-1$
          } else {
            openFormulaValue = "FALSE()"; //$NON-NLS-1$
          }
        } else if ( paramValue instanceof Double ) {
          openFormulaValue = paramValue.toString();
        } else {
          // assume a string, string literal quote
          openFormulaValue = "\"" + paramValue + "\""; //$NON-NLS-1$ //$NON-NLS-2$
        }
        m.appendReplacement( sb, openFormulaValue );
      } else {
        String[] seg = match.split( "\\." ); //$NON-NLS-1$
        if ( seg != null && seg.length > 1 ) {
          Category cat = query.getLogicalModel().findCategory( seg[0] );
          LogicalColumn col = cat.findLogicalColumn( seg[1] );
          if ( col == null ) {
            logger.error( Messages.getErrorString(
                "InlineEtlQueryExecutor.ERROR_0001_FAILED_TO_LOCATE_COLUMN", seg[0], seg[1] ) ); //$NON-NLS-1$
          }
          String fieldName = (String) col.getProperty( InlineEtlPhysicalColumn.FIELD_NAME );
          AggregationType agg = null;
          if ( seg.length > 2 ) {
            agg = AggregationType.valueOf( seg[2].toUpperCase() );
          }
          Selection sel = new Selection( cat, col, agg );
          if ( !qc.selections.contains( sel ) ) {
            qc.selections.add( sel );
            if ( sel.getActiveAggregationType() != null && sel.getActiveAggregationType() != AggregationType.NONE ) {
              qc.groupby = true;
            }
          }
          // this may be different in the group by context.

          m.appendReplacement( sb, "[" + fieldName + "]" ); //$NON-NLS-1$ //$NON-NLS-2$
        } else {
          logger
              .error( Messages.getErrorString( "InlineEtlQueryExecutor.ERROR_0002_FAILED_TO_PARSE_FORMULA", match ) ); //$NON-NLS-1$
        }
      }
    }
    m.appendTail( sb );
    qc.formula = sb.toString();
    if ( logger.isDebugEnabled() ) {
      logger.debug( "PARSED FORMULA: " + qc.formula ); //$NON-NLS-1$
    }
    constraints.add( qc );
  }
  return constraints;
}
 
Example 22
public AggregationType getAggregationType() {
  return (AggregationType) getProperty( IPhysicalColumn.AGGREGATIONTYPE_PROPERTY );
}
 
Example 23
public void setAggregationType( AggregationType aggType ) {
  setProperty( IPhysicalColumn.AGGREGATIONTYPE_PROPERTY, aggType );
}
 
Example 24
@SuppressWarnings( "unchecked" )
public List<AggregationType> getAggregationList() {
  return (List<AggregationType>) getProperty( IPhysicalColumn.AGGREGATIONLIST_PROPERTY );
}
 
Example 25
public void setAggregationList( List<AggregationType> aggList ) {
  setProperty( IPhysicalColumn.AGGREGATIONLIST_PROPERTY, aggList );
}
 
Example 26
public AggregationType getAggregationType() {
  return (AggregationType) getProperty( IPhysicalColumn.AGGREGATIONTYPE_PROPERTY );
}
 
Example 27
public void setAggregationType( AggregationType aggType ) {
  setProperty( IPhysicalColumn.AGGREGATIONTYPE_PROPERTY, aggType );
}
 
Example 28
@SuppressWarnings( "unchecked" )
public List<AggregationType> getAggregationList() {
  return (List<AggregationType>) getProperty( IPhysicalColumn.AGGREGATIONLIST_PROPERTY );
}
 
Example 29
public void setAggregationList( List<AggregationType> aggList ) {
  setProperty( IPhysicalColumn.AGGREGATIONLIST_PROPERTY, aggList );
}
 
Example 30
public AggregationType getAggregationType() {
  return (AggregationType) getProperty( IPhysicalColumn.AGGREGATIONTYPE_PROPERTY );
}