Ignore:
Timestamp:
02/04/10 21:56:24 (2 years ago)
Author:
kasper
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/MetaModelHelper.java

    r886 r887  
    4444import org.eobjects.metamodel.util.ObjectComparator; 
    4545 
    46  
    4746/** 
    4847 * This class contains various helper functionality to common tasks involving 
    … …  
    6766         * list of tables and columns are included 
    6867         */ 
    69         public static Table[] getTables(List<Table> tableList, List<Column> columnList) { 
     68        public static Table[] getTables(List<? extends Table> tableList, 
     69                        List<? extends Column> columnList) { 
    7070                HashSet<Table> set = new HashSet<Table>(); 
    7171                set.addAll(tableList); 
    … …  
    103103         */ 
    104104        public static Column[] getTableColumns(Table table, List<Column> columns) { 
    105                 return getTableColumns(table, columns.toArray(new Column[columns.size()])); 
     105                return getTableColumns(table, columns 
     106                                .toArray(new Column[columns.size()])); 
    106107        } 
    107108 
    … …  
    129130        } 
    130131 
    131         public static DataSet getCarthesianProduct(DataSet[] fromDataSets, List<FilterItem> whereItems) { 
    132                 return getCarthesianProduct(fromDataSets, whereItems.toArray(new FilterItem[whereItems.size()])); 
    133         } 
    134  
    135         public static DataSet getCarthesianProduct(DataSet[] fromDataSets, FilterItem... filterItems) { 
     132        public static DataSet getCarthesianProduct(DataSet[] fromDataSets, 
     133                        List<FilterItem> whereItems) { 
     134                return getCarthesianProduct(fromDataSets, whereItems 
     135                                .toArray(new FilterItem[whereItems.size()])); 
     136        } 
     137 
     138        public static DataSet getCarthesianProduct(DataSet[] fromDataSets, 
     139                        FilterItem... filterItems) { 
    136140                // First check if carthesian product is even nescesary 
    137141                if (fromDataSets.length == 1) { 
    … …  
    156160                                        Object[] values = fromDataSet.getRow().getValues(); 
    157161                                        Object[] row = new Object[selectItems.size()]; 
    158                                         System.arraycopy(values, 0, row, selectItemOffset, values.length); 
     162                                        System.arraycopy(values, 0, row, selectItemOffset, 
     163                                                        values.length); 
    159164                                        data.add(row); 
    160165                                } 
    … …  
    171176                                        for (int j = 0; j < fromDataRows.size(); j++) { 
    172177                                                Object[] newRow = fromDataRows.get(j); 
    173                                                 System.arraycopy(newRow, 0, originalRow, selectItemOffset, newRow.length); 
     178                                                System.arraycopy(newRow, 0, originalRow, 
     179                                                                selectItemOffset, newRow.length); 
    174180                                                data.add(i + j, originalRow.clone()); 
    175181                                        } 
    … …  
    179185                } 
    180186 
    181                 SelectItem[] finalSelectItems = selectItems.toArray(new SelectItem[selectItems.size()]); 
     187                SelectItem[] finalSelectItems = selectItems 
     188                                .toArray(new SelectItem[selectItems.size()]); 
    182189                for (Iterator<Object[]> it = data.iterator(); it.hasNext();) { 
    183190                        Object[] objects = it.next(); 
    … …  
    193200        } 
    194201 
    195         public static DataSet getFiltered(DataSet dataSet, List<FilterItem> filterItems) { 
    196                 return getFiltered(dataSet, filterItems.toArray(new FilterItem[filterItems.size()])); 
    197         } 
    198  
    199         public static DataSet getFiltered(DataSet dataSet, FilterItem... filterItems) { 
     202        public static DataSet getFiltered(DataSet dataSet, 
     203                        List<FilterItem> filterItems) { 
     204                return getFiltered(dataSet, filterItems 
     205                                .toArray(new FilterItem[filterItems.size()])); 
     206        } 
     207 
     208        public static DataSet getFiltered(DataSet dataSet, 
     209                        FilterItem... filterItems) { 
    200210                if (filterItems.length == 0) { 
    201211                        return dataSet; 
    … …  
    219229        } 
    220230 
    221         public static DataSet getSelection(List<SelectItem> selectItems, DataSet dataSet) { 
    222                 return getSelection(selectItems.toArray(new SelectItem[selectItems.size()]), dataSet); 
     231        public static DataSet getSelection(List<SelectItem> selectItems, 
     232                        DataSet dataSet) { 
     233                return getSelection(selectItems.toArray(new SelectItem[selectItems 
     234                                .size()]), dataSet); 
    223235        } 
    224236 
    … …  
    233245                                        SelectItem selectItem = selectItems[i]; 
    234246                                        if (selectItem.getSubQuerySelectItem() != null) { 
    235                                                 resultRow[i] = row.getValue(selectItem.getSubQuerySelectItem()); 
     247                                                resultRow[i] = row.getValue(selectItem 
     248                                                                .getSubQuerySelectItem()); 
    236249                                        } else { 
    237250                                                resultRow[i] = row.getValue(selectItem); 
    … …  
    246259        } 
    247260 
    248         public static DataSet getGrouped(List<SelectItem> selectItems, DataSet dataSet, List<GroupByItem> groupByItems) { 
    249                 return getGrouped(selectItems.toArray(new SelectItem[selectItems.size()]), dataSet, groupByItems 
    250                                 .toArray(new GroupByItem[groupByItems.size()])); 
    251         } 
    252  
    253         public static DataSet getGrouped(SelectItem[] selectItems, DataSet dataSet, GroupByItem[] groupByItems) { 
     261        public static DataSet getGrouped(List<SelectItem> selectItems, 
     262                        DataSet dataSet, List<GroupByItem> groupByItems) { 
     263                return getGrouped(selectItems 
     264                                .toArray(new SelectItem[selectItems.size()]), dataSet, 
     265                                groupByItems.toArray(new GroupByItem[groupByItems.size()])); 
     266        } 
     267 
     268        public static DataSet getGrouped(SelectItem[] selectItems, DataSet dataSet, 
     269                        GroupByItem[] groupByItems) { 
    254270                DataSet result = dataSet; 
    255271                if (groupByItems != null && groupByItems.length > 0) { 
    … …  
    262278 
    263279                        // Creates a list of SelectItems that have functions 
    264                         List<SelectItem> functionItems = getFunctionSelectItems(Arrays.asList(selectItems)); 
     280                        List<SelectItem> functionItems = getFunctionSelectItems(Arrays 
     281                                        .asList(selectItems)); 
    265282 
    266283                        // Loop through the dataset and identify groups 
    … …  
    300317                                                objects.add(""); 
    301318                                        } else { 
    302                                                 throw new IllegalArgumentException("Expression function not supported: " + item); 
     319                                                throw new IllegalArgumentException( 
     320                                                                "Expression function not supported: " + item); 
    303321                                        } 
    304322                                } 
    … …  
    309327 
    310328                        // Loop through the groups to generate aggregates 
    311                         for (Entry<Row, Map<SelectItem, List<Object>>> entry : uniqueRows.entrySet()) { 
     329                        for (Entry<Row, Map<SelectItem, List<Object>>> entry : uniqueRows 
     330                                        .entrySet()) { 
    312331                                Row row = entry.getKey(); 
    313332                                Map<SelectItem, List<Object>> functionInput = entry.getValue(); 
    … …  
    326345                                                List<Object> objects = functionInput.get(item); 
    327346                                                if (objects != null) { 
    328                                                         Object functionResult = item.getFunction().evaluate(objects.toArray()); 
     347                                                        Object functionResult = item.getFunction() 
     348                                                                        .evaluate(objects.toArray()); 
    329349                                                        resultRow[i] = functionResult; 
    330350                                                } else { 
    331351                                                        if (item.getFunction() != null) { 
    332                                                                 _log.error("No function input found for SelectItem: " + item); 
     352                                                                _log 
     353                                                                                .error("No function input found for SelectItem: " 
     354                                                                                                + item); 
    333355                                                        } 
    334356                                                } 
    … …  
    343365        } 
    344366 
    345         public static DataSet getAggregated(List<SelectItem> resultSelectItems, DataSet dataSet) { 
     367        public static DataSet getAggregated(List<SelectItem> resultSelectItems, 
     368                        DataSet dataSet) { 
    346369                List<SelectItem> functionItems = getFunctionSelectItems(resultSelectItems); 
    347370                if (functionItems.isEmpty()) { 
    348371                        return dataSet; 
    349372                } else { 
    350                         SelectItem[] resultSelectItemsArray = resultSelectItems.toArray(new SelectItem[resultSelectItems.size()]); 
     373                        SelectItem[] resultSelectItemsArray = resultSelectItems 
     374                                        .toArray(new SelectItem[resultSelectItems.size()]); 
    351375                        Map<SelectItem, List<Object>> functionInput = new HashMap<SelectItem, List<Object>>(); 
    352376                        for (SelectItem item : functionItems) { 
    … …  
    366390                                        Column column = item.getColumn(); 
    367391                                        if (column != null) { 
    368                                                 Object value = inputRow.getValue(new SelectItem(column)); 
     392                                                Object value = inputRow 
     393                                                                .getValue(new SelectItem(column)); 
    369394                                                objects.add(value); 
    370395                                        } else if (SelectItem.isCountAllItem(item)) { 
    … …  
    373398                                                objects.add(""); 
    374399                                        } else { 
    375                                                 throw new IllegalArgumentException("Expression function not supported: " + item); 
     400                                                throw new IllegalArgumentException( 
     401                                                                "Expression function not supported: " + item); 
    376402                                        } 
    377403                                } 
    … …  
    382408                                        Object[] values = new Object[resultSelectItemsArray.length]; 
    383409                                        for (int i = 0; i < resultSelectItemsArray.length; i++) { 
    384                                                 Object value = inputRow.getValue(resultSelectItemsArray[i]); 
     410                                                Object value = inputRow 
     411                                                                .getValue(resultSelectItemsArray[i]); 
    385412                                                if (value != null) { 
    386413                                                        values[i] = value; 
    … …  
    414441                                        Row row = resultRows.get(i); 
    415442                                        Object[] values = row.getValues(); 
    416                                         for (Entry<SelectItem, Object> entry : functionResult.entrySet()) { 
     443                                        for (Entry<SelectItem, Object> entry : functionResult 
     444                                                        .entrySet()) { 
    417445                                                SelectItem item = entry.getKey(); 
    418446                                                int itemIndex = row.indexOf(item); 
    … …  
    429457        } 
    430458 
    431         public static List<SelectItem> getFunctionSelectItems(List<SelectItem> selectItems) { 
     459        public static List<SelectItem> getFunctionSelectItems( 
     460                        List<SelectItem> selectItems) { 
    432461                List<SelectItem> result = new ArrayList<SelectItem>(); 
    433462                for (SelectItem selectItem : selectItems) { 
    … …  
    442471        } 
    443472 
    444         public static DataSet getOrdered(DataSet dataSet, List<OrderByItem> orderByItems) { 
    445                 return getOrdered(dataSet, orderByItems.toArray(new OrderByItem[orderByItems.size()])); 
    446         } 
    447  
    448         public static DataSet getOrdered(DataSet dataSet, final OrderByItem... orderByItems) { 
     473        public static DataSet getOrdered(DataSet dataSet, 
     474                        List<OrderByItem> orderByItems) { 
     475                return getOrdered(dataSet, orderByItems 
     476                                .toArray(new OrderByItem[orderByItems.size()])); 
     477        } 
     478 
     479        public static DataSet getOrdered(DataSet dataSet, 
     480                        final OrderByItem... orderByItems) { 
    449481                if (orderByItems != null && orderByItems.length != 0) { 
    450482                        final int[] sortIndexes = new int[orderByItems.length]; 
    … …  
    456488                        List<Object[]> data = dataSet.toObjectArrays(); 
    457489 
    458                         final Comparator<Object> valueComparator = ObjectComparator.getComparator(); 
     490                        final Comparator<Object> valueComparator = ObjectComparator 
     491                                        .getComparator(); 
    459492 
    460493                        Collections.sort(data, new Comparator<Object[]>() { 
    … …  
    463496                                                Object sortObj1 = o1[sortIndexes[i]]; 
    464497                                                Object sortObj2 = o2[sortIndexes[i]]; 
    465                                                 int compare = valueComparator.compare(sortObj1, sortObj2); 
     498                                                int compare = valueComparator.compare(sortObj1, 
     499                                                                sortObj2); 
    466500                                                if (compare != 0) { 
    467501                                                        OrderByItem orderByItem = orderByItems[i]; 
    … …  
    516550                        result.addAll(getTableFromItems(rightSide)); 
    517551                } else { 
    518                         throw new IllegalStateException("FromItem was neither of Table type, SubQuery type or Join type: " + item); 
     552                        throw new IllegalStateException( 
     553                                        "FromItem was neither of Table type, SubQuery type or Join type: " 
     554                                                        + item); 
    519555                } 
    520556                return result; 
    … …  
    533569         *             if less or more than one Row is returned from the query 
    534570         */ 
    535         public static Row executeSingleRowQuery(DataContext dataContext, Query query) throws MetaModelException { 
     571        public static Row executeSingleRowQuery(DataContext dataContext, Query query) 
     572                        throws MetaModelException { 
    536573                DataSet dataSet = dataContext.executeQuery(query); 
    537574                boolean next = dataSet.next(); 
    538575                if (!next) { 
    539                         throw new MetaModelException("No rows returned from query: " + query); 
     576                        throw new MetaModelException("No rows returned from query: " 
     577                                        + query); 
    540578                } 
    541579                Row row = dataSet.getRow(); 
    542580                next = dataSet.next(); 
    543581                if (next) { 
    544                         throw new MetaModelException("More than one row returned from query: " + query); 
     582                        throw new MetaModelException( 
     583                                        "More than one row returned from query: " + query); 
    545584                } 
    546585                dataSet.close(); 
    … …  
    559598         * @return the left joined result dataset 
    560599         */ 
    561         public static DataSet getLeftJoin(DataSet ds1, DataSet ds2, FilterItem[] onConditions) { 
     600        public static DataSet getLeftJoin(DataSet ds1, DataSet ds2, 
     601                        FilterItem[] onConditions) { 
    562602                if (ds1 == null) { 
    563603                        throw new IllegalArgumentException("Left DataSet cannot be null"); 
    … …  
    583623 
    584624                        List<Object[]> carthesianRows = getCarthesianProduct( 
    585                                         new DataSet[] { new DataSet(ds1rows), new DataSet(si2, ds2data) }, onConditions).toObjectArrays(); 
     625                                        new DataSet[] { new DataSet(ds1rows), 
     626                                                        new DataSet(si2, ds2data) }, onConditions) 
     627                                        .toObjectArrays(); 
    586628                        if (carthesianRows.size() > 0) { 
    587629                                resultRows.addAll(carthesianRows); 
    … …  
    609651         * @return the right joined result dataset 
    610652         */ 
    611         public static DataSet getRightJoin(DataSet ds1, DataSet ds2, FilterItem[] onConditions) { 
     653        public static DataSet getRightJoin(DataSet ds1, DataSet ds2, 
     654                        FilterItem[] onConditions) { 
    612655                SelectItem[] ds1selects = ds1.getSelectItems(); 
    613656                SelectItem[] ds2selects = ds2.getSelectItems(); 
    614                 SelectItem[] leftOrderedSelects = new SelectItem[ds1selects.length + ds2selects.length]; 
    615                 System.arraycopy(ds1selects, 0, leftOrderedSelects, 0, ds1selects.length); 
    616                 System.arraycopy(ds2selects, 0, leftOrderedSelects, ds1selects.length, ds2selects.length); 
     657                SelectItem[] leftOrderedSelects = new SelectItem[ds1selects.length 
     658                                + ds2selects.length]; 
     659                System.arraycopy(ds1selects, 0, leftOrderedSelects, 0, 
     660                                ds1selects.length); 
     661                System.arraycopy(ds2selects, 0, leftOrderedSelects, ds1selects.length, 
     662                                ds2selects.length); 
    617663 
    618664                // We will reuse the left join algorithm (but switch the datasets 
    … …  
    645691        } 
    646692 
    647         public static Column[] getColumnsByType(Column[] columns, ColumnType columnType) { 
     693        public static Column[] getColumnsByType(Column[] columns, 
     694                        ColumnType columnType) { 
    648695                ArrayList<Column> result = new ArrayList<Column>(); 
    649696                for (Column column : columns) { 
Note: See TracChangeset for help on using the changeset viewer.