public static DataSetLookup fromInstance(DataSetLookup orig, String serverTemplateId) { ConsoleDataSetLookup clone = new ConsoleDataSetLookup(); clone.setDataSetUUID(orig.getDataSetUUID()); clone.setRowOffset(orig.getRowOffset()); clone.setNumberOfRows(orig.getNumberOfRows()); for (DataSetOp dataSetOp : orig.getOperationList()) { clone.getOperationList().add(dataSetOp.cloneInstance()); } clone.setServerTemplateId(serverTemplateId); return clone; }
public LookupProcessor(SQLDataSetDef def, DataSetLookup lookup) { this.def = def; this.lookup = lookup; DataSetFilter dataSetFilter = def.getDataSetFilter(); if (dataSetFilter != null) { if (lookup == null) { this.lookup = new DataSetLookup(def.getUUID(), dataSetFilter); } else { this.lookup.addOperation(dataSetFilter); } } }
public void addColumnFilter(final ColumnFilter columnFilter) { if (getDataSetLookup().getFirstFilterOp() != null) { getDataSetLookup().getFirstFilterOp().addFilterColumn(columnFilter); } else { final DataSetFilter filter = new DataSetFilter(); filter.addFilterColumn(columnFilter); getDataSetLookup().addOperation(filter); } }
@Override public void limitDataSetRows(int offset, int rows) { int offsetBase = lookupBase.getRowOffset(); int rowsBase = lookupBase.getNumberOfRows(); lookupCurrent.setRowOffset(offsetBase + offset); // base 0 to all, 0 to 20 => offset=0, rows=20 // base 0 to 1, 0 to 20 => offset=0, rows=1 // base 50 to 51, 0 to 20 => offset=50, rows=20 // base 10 to 31, 20 to 10 => offset=30, rows=10 // base 10 to 31, 0 to 50 => offset=10, rows=31 if (rowsBase < 1 || rowsBase > rows) { lookupCurrent.setNumberOfRows(rows); } }
public DataSetLookup cloneInstance() { DataSetLookup clone = new DataSetLookup(); clone.setDataSetUUID(dataSetUUID); clone.setRowOffset(rowOffset); clone.setNumberOfRows(numberOfRows); for (DataSetOp dataSetOp : operationList) { clone.operationList.add(dataSetOp.cloneInstance()); } return clone; }
conn = ds.getConnection(); try { boolean skipCache = lookup != null && lookup.testMode(); metadata = _getDataSetMetadata(def, conn, skipCache); int totalRows = metadata.getNumberOfRows(); boolean trim = (lookup != null && (lookup.getNumberOfRows() > 0 || lookup.getRowOffset() > 0)); if (lookup == null || lookup.getOperationList().isEmpty()) { _query.limit(lookup.getNumberOfRows()).offset(lookup.getRowOffset()); int groupIdx = lookup.getFirstGroupOpIndex(0, null, false); if (groupIdx != -1) groupOp = lookup.getOperation(groupIdx); for (DataSetFilter filterOp : lookup.getOperationList(DataSetFilter.class)) { _appendFilterBy(metadata, def, filterOp, _query); List<DataSetGroup> intervalSelects = lookup.getFirstGroupOpSelections(); for (DataSetGroup intervalSelect : intervalSelects) { _appendIntervalSelection(intervalSelect, _query); DataSetSort sortOp = lookup.getFirstSortOp(); if (sortOp != null) { if (cg != null) { _query.limit(lookup.getNumberOfRows()).offset(lookup.getRowOffset());
public DataSetSort getFirstSortOp() { List<DataSetSort> ops = getOperationList(DataSetSort.class); if (ops.isEmpty()) { return null; } return ops.get(0); }
public String getDataSetUUID() { return dataSetLookup == null ? null : dataSetLookup.getDataSetUUID(); }
for (DataSetGroup next : lookupCurrent.getOperationList(DataSetGroup.class)) { if (op.equals(next)) { return false; int lastSelection = lookupCurrent.getLastGroupOpIndex(0, null, true) + 1; int targetGroup = lookupCurrent.getLastGroupOpIndex(lastSelection, cg.getColumnId(), false); DataSetGroup targetOp = lookupCurrent.getOperation(targetGroup); int latestGroup = lookupCurrent.getLastGroupOpIndex(targetGroup + 1, null, false); if (latestGroup == -1) { DataSetGroup clone = targetOp.cloneInstance();
final DataSetLookup dataSetLookup = settings.getDataSetLookup(); assertEquals("jbpmProcessInstancesWithVariables", dataSetLookup.getDataSetUUID()); assertEquals(PROCESS_INSTANCE_ID, settings.getTableDefaultSortColumnId()); settings.isFilterNotificationEnabled()); assertEquals(-1, dataSetLookup.getNumberOfRows()); assertEquals(0, dataSetLookup.getRowOffset()); assertNotNull(dataSetLookup.getFirstFilterOp()); final DataSetFilter firstFilterOp = dataSetLookup.getFirstFilterOp(); assertEquals(DataSetOpType.FILTER, firstFilterOp.getType()); ((CoreFunctionFilter) columnFilter).getParameters().get(0)); final DataSetGroup groupOp = dataSetLookup.getLastGroupOp(); assertEquals(DataSetOpType.GROUP, groupOp.getType());
public DataSet lookupDataSet(String uuid, DataSetLookup lookup) { if (StringUtils.isEmpty(uuid)) return null; // Get the target data set DataSetIndex dataSetIndex = dataSetOpEngine.getIndexRegistry().get(uuid); if (dataSetIndex == null) return null; DataSet dataSet = dataSetIndex.getDataSet(); if (lookup == null) return dataSet; // Apply the list of operations specified (if any). if (!lookup.getOperationList().isEmpty()) { dataSet = dataSetOpEngine.execute(uuid, lookup.getOperationList()); } // Trim the data set as requested. dataSet = dataSet.trim(lookup.getRowOffset(), lookup.getNumberOfRows()); return dataSet; }
public T group(String columnId, String newColumnId) { DataSetGroup gOp = new DataSetGroup(); gOp.setColumnGroup(new ColumnGroup(columnId, newColumnId)); dataSetLookup.addOperation(gOp); return (T) this; }
@Test public void lookupDataSetLogicalExprTest() throws Exception { DataSetLookup lookup = new DataSetLookup(); lookup.setDataSetUUID(""); when(dataSetDef.getUUID()).thenReturn(""); lookup.addOperation(filter);
private void updateFilterControls() { filterEditor.init(dataSetLookup.getFirstFilterOp(), metadata); }
public void callback(DataSetMetadata metatada) { // Push the data set to client if and only if the push feature is enabled, the data set is // pushable & the data set is smaller than the max push size defined. DataSetDef dsetDef = metatada.getDefinition(); int estimatedSize = metatada.getEstimatedSize() / 1000; boolean isPushable = dsetDef != null && dsetDef.isPushEnabled() && estimatedSize < dsetDef.getPushMaxSize(); if (pushRemoteDataSetEnabled && isPushable) { // Check if a push is already in progress. // (This is necessary in order to avoid repeating multiple push requests over the same data set). DataSetPushHandler pushHandler = pushRequestMap.get(request.getDataSetUUID()); if (pushHandler == null) { // Create a push handler. pushHandler = new DataSetPushHandler(metatada); // Send the lookup request to the server... DataSetLookup lookupSourceDataSet = new DataSetLookup(request.getDataSetUUID()); _lookupDataSet(lookupSourceDataSet, pushHandler); } // Register the lookup request into the current handler. pushHandler.registerLookup(request, listener); } // Lookup the remote data set otherwise. else { _lookupDataSet(request, listener); } }
public DataSet lookupDataSet(DataSetDef def, DataSetLookup lookup) { String uuid = def.getUUID(); if (StringUtils.isEmpty(uuid)) return null; boolean isRoot = (lookup == null || lookup.isEmpty()); // Be aware of filters on the data set definition DataSetFilter filter = def.getDataSetFilter(); if (filter != null) { if (lookup == null) lookup = new DataSetLookup(uuid, filter); else lookup.addOperation(0, filter); } // Lookup the data set (with any existing filters) DataSet dataSet = lookupDataSet(uuid, lookup); // Add the proper metadata to any root data set retrieval call if (dataSet != null && isRoot) { dataSet.setUUID(uuid); dataSet.setDefinition(def); } return dataSet; }
@Override public DataSetMetadata getDataSetMetadata(String uuid) { DataSetLookup lookup = new DataSetLookup(uuid); DataSet dataSet = lookupDataSet(lookup); if (dataSet == null) { return null; } return dataSet.getMetadata(); }
@Test public void testGetDisplayerSettings() { expectedDataSetUUID = DATASOURCE_UUID + SEPARATOR + SCHEMA + SEPARATOR + TABLE; DataSetLookup expectedLookup = new DataSetLookup(); expectedLookup.setDataSetUUID(expectedDataSetUUID); DataSet expectedSet = mock(DataSet.class); List<DataColumn> dataColumns = new ArrayList<>(); for (int i = 0; i < COLUMNS_COUNT; i++) { DataColumn dataColumn = mock(DataColumn.class); when(dataColumn.getId()).thenReturn(DATA_COLUMN + String.valueOf(i)); dataColumns.add(dataColumn); } when(expectedSet.getColumns()).thenReturn(dataColumns); when(dataSetManager.lookupDataSet(expectedLookup)).thenReturn(expectedSet); DisplayerSettings settings = dataManagementService.getDisplayerSettings(DATASOURCE_UUID, SCHEMA, TABLE); verify(dataSetDefRegistry, times(1)).registerDataSetDef(dataSetDefCaptor.capture()); verifyDataSetDef(dataSetDefCaptor.getValue()); verifySettings(settings); }
public void changeDataSetFilter(DataSetFilter filterOp) { filterSettings.getDataSetLookup().removeOperations(DataSetOpType.FILTER); if (filterOp != null) { filterSettings.getDataSetLookup().addOperation(0, filterOp); } }
public String buildUniqueColumnId(DataSetLookup lookup, GroupFunction column) { String targetId = column.getSourceId(); targetId = targetId == null ? column.getColumnId() : targetId; int lastGop = lookup.getLastGroupOpIndex(0); if (lastGop != -1) { DataSetGroup groupOp = lookup.getOperation(lastGop); List<GroupFunction> columnList = groupOp.getGroupFunctions(); String newColumnId = targetId; int counter = 1; while (true) { boolean unique = true; for (int i=0; i<columnList.size() && unique; i++) { GroupFunction gf = columnList.get(i); if (gf != column && newColumnId.equals(gf.getColumnId())) { newColumnId = targetId + "_" + (++counter); unique = false; } } if (unique) { return newColumnId; } } } return targetId; }