public String getGroupKey(ColumnGroup columnGroup) { return columnGroup.getSourceId() + "_" + columnGroup.getStrategy().toString() + "_" + columnGroup.getIntervalSize() + "_" + columnGroup.getMaxIntervals() + "_" + columnGroup.areEmptyIntervalsAllowed() + "_" + columnGroup.isAscendingOrder() + (columnGroup.getFirstMonthOfYear() != null ? "_" + columnGroup.getFirstMonthOfYear() : "") + (columnGroup.getFirstDayOfWeek() != null ? "_" + columnGroup.getFirstDayOfWeek() : ""); }
public String toString() { StringBuilder out = new StringBuilder(super.toString()); if (columnGroup != null) out.append(" column=").append(columnGroup.getColumnId()); if (selectKey != null) out.append(" select=").append(selectKey); return out.toString(); } }
public ColumnGroup parseColumnGroup( JsonObject columnGroupJson ) { if (columnGroupJson == null) { return null; } ColumnGroup columnGroup = new ColumnGroup(); columnGroup.setSourceId(columnGroupJson.getString(keySet(SOURCE))); columnGroup.setColumnId(columnGroupJson.getString(keySet(COLUMN))); columnGroup.setStrategy(GroupStrategy.getByName(columnGroupJson.getString(GROUPSTRATEGY))); columnGroup.setMaxIntervals(columnGroupJson.getNumber(MAXINTERVALS, -1).intValue()); columnGroup.setIntervalSize(columnGroupJson.getString(INTERVALSIZE)); columnGroup.setEmptyIntervalsAllowed(columnGroupJson.getBoolean(EMPTYINTERVALS)); columnGroup.setAscendingOrder(columnGroupJson.getBoolean(ASCENDING)); columnGroup.setFirstMonthOfYear(Month.getByName(columnGroupJson.getString(FIRSTMONTHOFYEAR))); columnGroup.setFirstDayOfWeek(DayOfWeek.getByName(columnGroupJson.getString(FIRSTDAYOFWEEK))); return columnGroup; }
protected DateIntervalType calculateDateInterval(ColumnGroup cg) { if (dateIntervalType != null) { return dateIntervalType; } if (GroupStrategy.DYNAMIC.equals(cg.getStrategy())) { Date[] limits = calculateDateLimits(cg.getSourceId()); if (limits != null) { dateIntervalType = intervalBuilderDynamicDate.calculateIntervalSize(limits[0], limits[1], cg); return dateIntervalType; } } dateIntervalType = DateIntervalType.getByName(cg.getIntervalSize()); return dateIntervalType; }
protected boolean isDynamicDateGroup(DataSetGroup groupOp) { ColumnGroup cg = groupOp.getColumnGroup(); if (!ColumnType.DATE.equals(metadata.getColumnType(cg.getSourceId()))) { return false; } if (!GroupStrategy.DYNAMIC.equals(cg.getStrategy())) { return false; } return true; }
if (dataSetGroup.getColumnGroup() != null) { if (dataSetGroup.getColumnGroup().getIntervalSize() != null) { filterParams.add(new QueryParam(dataSetGroup.getColumnGroup().getSourceId(), "group", Arrays.asList(dataSetGroup.getColumnGroup().getColumnId(), dataSetGroup.getColumnGroup().getIntervalSize(), dataSetGroup.getColumnGroup().getMaxIntervals()))); } else { filterParams.add(new QueryParam(dataSetGroup.getColumnGroup().getSourceId(), "group", Arrays.asList(dataSetGroup.getColumnGroup().getColumnId())));
public IntervalList build(DataSetHandler handler, ColumnGroup columnGroup) { IntervalDateRangeList results = new IntervalDateRangeList(columnGroup); DataSet dataSet = handler.getDataSet(); List values = dataSet.getColumnById(columnGroup.getSourceId()).getValues(); if (values.isEmpty()) { return results; sortOp.addSortColumn(new ColumnSort(columnGroup.getSourceId(), SortOrder.ASCENDING)); DataSetHandler sortResults = handler.sort(sortOp); List<Integer> sortedRows = sortResults.getRows(); results.setIntervalType(columnGroup.getIntervalSize()); results.setMinValue(minDate); results.setMaxValue(maxDate); boolean asc = columnGroup.isAscendingOrder(); if (!asc) Collections.reverse( results );
if (cg != null && ColumnType.DATE.equals(metadata.getColumnType(cg.getSourceId()))) { dateGroupColumn = column; dateIncludeEmptyIntervals = cg.areEmptyIntervalsAllowed(); IntervalBuilder intervalBuilder = intervalBuilderLocator.lookup(ColumnType.DATE, dateGroupColumn.getColumnGroup().getStrategy()); IntervalList intervalList = intervalBuilder.build(dateGroupColumn); if (intervalList.size() > dataSet.getRowCount() && dataSet.getRowCountNonTrimmed() < 0) {
protected void checkGroupOp(DataSet dataSet, DataSetGroup op) { ColumnGroup cg = op.getColumnGroup(); if (cg != null) { String id = cg.getSourceId(); if (dataSet.getColumnById(id) == null) { throw new IllegalArgumentException("Group column specified not found in the data set: " + id); } } }
@Test public void testTwoColumns() { DataSetLookup lookup = TWO_COLUMNS_GROUPED.newDataSetLookup(METADATA); assertEquals(lookup.getDataSetUUID(), "test"); List<DataSetOp> opList = lookup.getOperationList(); assertEquals(opList.size(), 1); List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class); assertEquals(groupList.size(), 1); DataSetGroup groupOp = groupList.get(0); assertNotNull(groupOp); assertEquals(groupOp.getGroupFunctions().size(), 2); ColumnGroup cg = groupOp.getColumnGroup(); assertNotNull(groupOp); assertEquals(cg.getSourceId(), OFFICE); assertEquals(cg.getColumnId(), OFFICE); assertEquals(cg.getStrategy(), GroupStrategy.DYNAMIC); GroupFunction gf1 = groupOp.getGroupFunction(OFFICE); assertNotNull(gf1); assertNull(gf1.getFunction()); assertEquals(gf1.getSourceId(), OFFICE); assertEquals(gf1.getColumnId(), OFFICE); GroupFunction gf2 = groupOp.getGroupFunction(AMOUNT); assertNotNull(gf2); assertNotNull(gf2.getFunction()); assertEquals(gf2.getSourceId(), AMOUNT); assertEquals(gf2.getColumnId(), AMOUNT); } @Test
@Test public void testEnableFixedMode() { presenter.init(new ColumnGroup("col", "col", DYNAMIC, 15, CENTURY.toString())); reset(view); when(view.getFixedModeValue()).thenReturn(true); presenter.onFixedStrategyChanged(); verify(changeEvent).fire(any(DataSetGroupDateChanged.class)); ColumnGroup result = presenter.getColumnGroup(); assertEquals(result.getStrategy(), FIXED); verify(view).setFirstMonthVisibility(true); verify(view, never()).setMaxIntervalsVisibility(true); verify(view, never()).setFirstDayVisibility(true); }
public T firstDay(DayOfWeek dayOfWeek) { DataSetGroup gOp = (DataSetGroup) getCurrentOp(); if (gOp == null || gOp.getColumnGroup() == null) { throw new RuntimeException("group() must be called first."); } ColumnGroup columnGroup = gOp.getColumnGroup(); if (!GroupStrategy.FIXED.equals(columnGroup.getStrategy())) { throw new RuntimeException("A fixed group is required."); } if (!DateIntervalType.DAY_OF_WEEK.equals(DateIntervalType.getByName(columnGroup.getIntervalSize()))) { throw new RuntimeException("A fixed DAY_OF_WEEK date group is required."); } columnGroup.setFirstDayOfWeek(dayOfWeek); return (T) this; }
public T firstMonth(Month month) { DataSetGroup gOp = (DataSetGroup) getCurrentOp(); if (gOp == null || gOp.getColumnGroup() == null) { throw new RuntimeException("group() must be called first."); } ColumnGroup columnGroup = gOp.getColumnGroup(); if (!GroupStrategy.FIXED.equals(columnGroup.getStrategy())) { throw new RuntimeException("A fixed group is required."); } if (!DateIntervalType.MONTH.equals(DateIntervalType.getByName(columnGroup.getIntervalSize()))) { throw new RuntimeException("A fixed MONTH date group is required."); } columnGroup.setFirstMonthOfYear(month); return (T) this; }
protected void _appendGroupBy(DataSetGroup groupOp) { ColumnGroup cg = groupOp.getColumnGroup(); String sourceId = cg.getSourceId(); String dbColumnId = _columnFromMetadata(metadata, sourceId); ColumnType columnType = metadata.getColumnType(dbColumnId); if (gf.getFunction() == null && !gf.getSourceId().equalsIgnoreCase(cg.getSourceId())) { String dbGfId = _columnFromMetadata(metadata, gf.getSourceId()); _query.groupBy(SQLFactory.column(dbGfId)); if (gf != null) { String targetId = _getTargetColumnId(gf); postGroup.getColumnGroup().setSourceId(targetId); postGroup.getColumnGroup().setColumnId(targetId);
public DateIntervalType calculateIntervalSize(Date minDate, Date maxDate, ColumnGroup columnGroup) { DateIntervalType intervalType = DateIntervalType.getByName(columnGroup.getIntervalSize()); if (intervalType == null) { intervalType = YEAR; int maxIntervals = columnGroup.getMaxIntervals(); if (maxIntervals < 1) maxIntervals = 15; for (DateIntervalType type : values()) { if (!StringUtils.isBlank(columnGroup.getIntervalSize())) { intervalSize = getByName(columnGroup.getIntervalSize());
public IntervalList(ColumnGroup columnGroup) { super(); this.columnGroup = columnGroup; this.intervalType = columnGroup.getIntervalSize(); }
if (sourceId != null && sourceId.equals(columnGroup.getSourceId()) && columnFunction == null) { DataColumnImpl column = new DataColumnImpl(columnId, ColumnType.LABEL); column.setColumnGroup(columnGroup); if (intervalIdx.getRows().isEmpty() && !columnGroup.areEmptyIntervalsAllowed()) { continue; AggregateFunctionType columnFunction = groupFunction.getFunction(); if (sourceId != null && sourceId.equals(columnGroup.getSourceId()) && columnFunction == null) { result.setValueAt(row, j, intervalIdx.getName()); } else {
public IntervalListMonth(ColumnGroup columnGroup) { super(columnGroup); intervalMap = new HashMap<Integer, Interval>(); Month firstMonth = columnGroup.getFirstMonthOfYear(); int monthIndex = firstMonth.getIndex(); Month[] months = Month.getAll(); for (int i = 0; i < months.length; i++) { Month month = months[monthIndex-1]; Interval interval = new Interval(Integer.toString(month.getIndex()), i); interval.setType(columnGroup.getIntervalSize()); this.add(interval); intervalMap.put(monthIndex-1, interval); monthIndex = Month.nextIndex(monthIndex); } }
protected void _filter(int index, DataSetGroup op, boolean drillDown) { ColumnGroup cgroup = op.getColumnGroup(); String columnId = cgroup.getColumnId(); if (!_groupOpsAdded.containsKey(columnId)) _groupOpsAdded.put(columnId, new ArrayList<>()); List<GroupOpFilter> filterOps = _groupOpsAdded.get(columnId); // When adding an external filter, look first if it exists an existing filter already. if (!drillDown) { for (GroupOpFilter filterOp : filterOps) { if (!filterOp.drillDown && filterOp.groupOp.getColumnGroup().equals(cgroup)) { filterOp.groupOp.getSelectedIntervalList().clear(); filterOp.groupOp.getSelectedIntervalList().addAll(op.getSelectedIntervalList()); return; } } } GroupOpFilter groupOpFilter = new GroupOpFilter(op, drillDown); filterOps.add(groupOpFilter); lookupCurrent.addOperation(index, op); }
public ColumnGroup cloneInstance() { ColumnGroup clone = new ColumnGroup(); clone.columnId = columnId; clone.sourceId = sourceId; clone.strategy = strategy; clone.maxIntervals = maxIntervals; clone.intervalSize = intervalSize; clone.emptyIntervals = emptyIntervals; clone.ascendingOrder = ascendingOrder; clone.firstDayOfWeek = firstDayOfWeek; clone.firstMonthOfYear = firstMonthOfYear; return clone; }