public JsonObject formatDataSetGroup(DataSetGroup dataSetGroup) throws JsonException { if (dataSetGroup == null) { return null; } JsonObject dataSetGroupJson = Json.createObject(); dataSetGroupJson.put(COLUMNGROUP, formatColumnGroup(dataSetGroup.getColumnGroup())); dataSetGroupJson.put(GROUPFUNCTIONS, formatGroupFunctions(dataSetGroup.getGroupFunctions())); dataSetGroupJson.put(SELECTEDINTERVALS, formatSelectedIntervals(dataSetGroup.getSelectedIntervalList())); dataSetGroupJson.put(JOIN, dataSetGroup.isJoin() ? "true" : "false"); return dataSetGroupJson; }
@Override public boolean filter(DataSetGroup op) { ColumnGroup cg = op.getColumnGroup(); if (cg == null) { throw new RuntimeException("Group ops require a pivot column to be specified."); } if (!op.isSelect()) { throw new RuntimeException("Group intervals not specified."); } // Avoid duplicates for (DataSetGroup next : lookupCurrent.getOperationList(DataSetGroup.class)) { if (op.equals(next)) { return false; } } // The interval selection op. must be added right before the first existing group op. DataSetGroup clone = op.cloneInstance(); //clone.getGroupFunctions().clear(); int idx = lookupCurrent.getFirstGroupOpIndex(0, null, null); _filter(idx < 0 ? 0 : idx, clone, false); return true; }
@Override protected void beforeDataSetLookup() { DataSetGroup group = dataSetHandler.getCurrentDataSetLookup().getLastGroupOp(); if (group != null && (group.getAggregationFunctions().isEmpty() || group.getColumnGroup() != null || group.getGroupFunctions().size() < 2)) { group.setColumnGroup(null); GroupFunction minFunction = group.getGroupFunctions().get(0); minFunction.setFunction(AggregateFunctionType.MIN); GroupFunction maxFunction = minFunction.cloneInstance(); maxFunction.setFunction(AggregateFunctionType.MAX); group.addGroupFunction(maxFunction); } }
private GroupOpFilter(DataSetGroup op, boolean drillDown) { this.groupOp = op; this.drillDown = drillDown; this.groupFunctions = new ArrayList<>(op.getGroupFunctions()); this.intervalList = new ArrayList<>(op.getSelectedIntervalList()); }
public T join() { DataSetGroup gOp = (DataSetGroup) getCurrentOp(); if (gOp == null || gOp.getColumnGroup() == null) { throw new RuntimeException("group() must be called first."); } gOp.setJoin(true); return (T) this; }
@Test public void testMultipleColumns() { DataSetLookup lookup = MULTIPLE_COLUMNS.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); ColumnGroup cg = groupOp.getColumnGroup(); assertNull(cg); assertEquals(groupOp.getGroupFunctions().size(), MULTIPLE_COLUMNS.getMinColumns()); for (int i = 0; i < MULTIPLE_COLUMNS.getMinColumns(); i++) { GroupFunction gf = groupOp.getGroupFunction(METADATA.getColumnId(i)); assertNotNull(gf); assertEquals(gf.getSourceId(), METADATA.getColumnId(i)); assertEquals(gf.getColumnId(), METADATA.getColumnId(i)); assertNull(gf.getFunction()); } }
protected void _appendIntervalSelection(DataSetGroup intervalSel, Select _query) { if (intervalSel != null && intervalSel.isSelect()) { ColumnGroup cg = intervalSel.getColumnGroup(); List<Interval> intervalList = intervalSel.getSelectedIntervalList();
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 boolean groupColumnMustBeIncluded(DataSetGroup groupOp) { if (groupOp != null) { ColumnGroup cg = groupOp.getColumnGroup(); if (cg != null) { for (GroupFunction gf : groupOp.getGroupFunctions()) { if (cg.getSourceId().equals(gf.getSourceId()) && gf.getFunction() == null) { return false; } } for (GroupFunction gf : groupOp.getGroupFunctions()) { if (!cg.getSourceId().equals(gf.getSourceId()) && gf.getFunction() == null) { return true; } } } } return false; }
private DataSet _buildDataSet(InternalContext context) { DataSetOp lastOp = context.lastOperation; DataSetIndexNode index = context.index; DataSet dataSet = context.dataSet; if (lastOp instanceof DataSetGroup) { DataSetGroup gOp = (DataSetGroup) lastOp; ColumnGroup columnGroup = gOp.getColumnGroup(); if (columnGroup == null) { boolean hasAggregations = !gOp.getAggregationFunctions().isEmpty(); return _buildDataSet(context, gOp.getGroupFunctions(), hasAggregations); } else { if (gOp.isSelect() && gOp.getGroupFunctions().isEmpty()) { return dataSet.trim(index.getRows()); } else { return _buildDataSet(context, gOp); } } } if (lastOp instanceof DataSetFilter) { return dataSet.trim(index.getRows()); } if (lastOp instanceof DataSetSort) { return _filterDataSet(dataSet, index.getRows()); } return dataSet; }
protected void _appendGroupBy(DataSetGroup groupOp) { ColumnGroup cg = groupOp.getColumnGroup(); String sourceId = cg.getSourceId(); String dbColumnId = _columnFromMetadata(metadata, sourceId); for (GroupFunction gf : groupOp.getGroupFunctions()) { if (!sourceId.equals(gf.getSourceId()) && gf.getFunction() == null) { postProcessing = true; for (GroupFunction gf : groupOp.getGroupFunctions()) { if (gf.getFunction() == null && !gf.getSourceId().equalsIgnoreCase(cg.getSourceId())) { String dbGfId = _columnFromMetadata(metadata, gf.getSourceId()); DataSetGroup postGroup = groupOp.cloneInstance(); GroupFunction gf = postGroup.getGroupFunction(sourceId); if (gf != null) { String targetId = _getTargetColumnId(gf); postGroup.getColumnGroup().setSourceId(targetId); postGroup.getColumnGroup().setColumnId(targetId); for (GroupFunction pgf : postGroup.getGroupFunctions()) { AggregateFunctionType pft = pgf.getFunction(); pgf.setSourceId(_getTargetColumnId(pgf));
public int getFirstGroupOpIndex(int fromIndex, String columnId, Boolean onlySelections) { for (int i = fromIndex; i < operationList.size(); i++) { DataSetOp op = operationList.get(i); if (DataSetOpType.GROUP.equals(op.getType())) { DataSetGroup groupOp = (DataSetGroup) op; ColumnGroup cg = groupOp.getColumnGroup(); boolean hasSelections = groupOp.isSelect(); boolean matchColumn = columnId == null || (cg != null && cg.getColumnId().equals(columnId)); boolean matchSelections = onlySelections == null || (onlySelections && hasSelections) || (!onlySelections && !hasSelections); if (matchColumn && matchSelections) { return i; } } } return -1; }
groupOp.setColumnGroup(null); groupOp.getGroupFunctions().remove(0); for (GroupFunction groupFunction : groupOp.getGroupFunctions()) { groupFunction.setFunction(null); groupOp.setColumnGroup(new ColumnGroup(columnId, columnId)); if (lookupConstraints.isGroupColumn()) { if (groupOp.getGroupFunctions().size() > 1) { groupOp.getGroupFunctions().remove(0); groupOp.getGroupFunctions().add(0, groupFunction); if (isFirstGroupOpDateBased()) { view.setGroupByDateEnabled(true); ColumnGroup columnGroup = getFirstGroupOp().getColumnGroup(); groupDateEditor.init(columnGroup);
public List<GroupFunction> getFirstGroupFunctions() { List<DataSetGroup> groupOpList = dataSetLookup.getOperationList(DataSetGroup.class); if (groupOpList.isEmpty()) { return null; } return groupOpList.get(0).getGroupFunctions(); }
public T asc() { DataSetGroup gOp = (DataSetGroup) getCurrentOp(); if (gOp == null || gOp.getColumnGroup() == null) { throw new RuntimeException("group() must be called first."); } ColumnGroup columnGroup = gOp.getColumnGroup(); columnGroup.setAscendingOrder(true); return (T) this; }
public DataSetGroup parseDataSetGroup(JsonObject dataSetGroupJson) { if (dataSetGroupJson == null) { return null; } DataSetGroup dataSetGroup = new DataSetGroup(); dataSetGroup.setColumnGroup(null); JsonObject value = dataSetGroupJson.getObject(COLUMNGROUP); if (value != null) { dataSetGroup.setColumnGroup(parseColumnGroup(value)); } List<GroupFunction> groupFunctions = parseGroupFunctions(dataSetGroupJson.getArray(GROUPFUNCTIONS)); if (groupFunctions != null) { dataSetGroup.getGroupFunctions().addAll( groupFunctions ); } dataSetGroup.setSelectedIntervalList(parseSelectedIntervals(dataSetGroupJson.getArray(keySet(SELECTEDINTERVALS)))); dataSetGroup.setJoin(dataSetGroupJson.getBoolean(JOIN)); return dataSetGroup; }
protected boolean group(DataSetGroup op, InternalContext context) { checkGroupOp(context.dataSet, op); // Group by the specified column (if any). ColumnGroup columnGroup = op.getColumnGroup(); // No real group requested. Only function calculations on the data set. if (columnGroup == null) return true; // Nested groups are only supported on the presence of an interval selection or group join operation. DataSetGroup lastGroupOp = context.getLastGroupOp(); if (lastGroupOp != null && !lastGroupOp.isSelect() && !op.isJoin()) { return false; } // Create a root or nested group. DataSetGroupIndex groupIndex = null; if (context.lastGroupIndex == null) groupIndex = singleGroup(op, context); else groupIndex = nestedGroup(op, context.lastGroupIndex, context); // Select the group intervals (if any) groupIndex = selectIntervals(op, groupIndex); // Index the group context.index(op, groupIndex); return true; }
protected DataSetGroupIndex selectIntervals(DataSetGroup groupOp, DataSetGroupIndex groupIndex) { List<Interval> intervalList = groupOp.getSelectedIntervalList(); if (intervalList != null && !intervalList.isEmpty()) { // Look for an existing selection index. DataSetGroupIndex selectionIndex = groupIndex.getSelectionIndex(intervalList); if (selectionIndex != null) return selectionIndex; // Create a brand new selection index. List<DataSetIntervalIndex> intervalIdxs = groupIndex.getIntervalIndexes(intervalList); if (intervalIdxs.isEmpty()) { intervalIdxs = new ArrayList<DataSetIntervalIndex>(); for (Interval interval : intervalList) { intervalIdxs.add(new DataSetIntervalIndex(groupIndex, interval)); } } //if (intervalIdxs.size() == 1) return intervalIdxs.get(0); return groupIndex.indexSelection(intervalList, intervalIdxs); } return groupIndex; }
protected void _appendOrderGroupBy(DataSetGroup groupOp, DataSetSort sortOp, boolean post) { List<SortColumn> _columns = new ArrayList<>(); List<ColumnSort> sortList = sortOp.getColumnSortList(); ColumnGroup cg = groupOp.getColumnGroup(); boolean sortPost = post; if (post) { GroupFunction gf = groupOp.getGroupFunction(cs.getColumnId());
protected void _select(DataSetGroup op, List<Interval> intervalList) { GroupOpFilter groupOpFilter = new GroupOpFilter(op, true); op.setSelectedIntervalList(intervalList); String columnId = op.getColumnGroup().getColumnId(); if (!_groupOpsSelected.containsKey(columnId)) { _groupOpsSelected.put(columnId, new ArrayList<>()); } _groupOpsSelected.get(columnId).add(groupOpFilter); }