Java DataSetLookup类代码示例

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
public void init(DataSetLookupConstraints lookupConstraints,
                 final DataSetLookup dataSetLookup) {
    this.dataSetLookup = dataSetLookup;
    this.lookupConstraints = lookupConstraints;
    this.view.clearAll();
    this.clientServices.getPublicDataSetDefs(new RemoteCallback<List<DataSetDef>>() {
        public void callback(List<DataSetDef> dataSetDefs) {
            showDataSetDefs(dataSetDefs);
            if (dataSetLookup != null && dataSetLookup.getDataSetUUID() != null) {
                fetchMetadata(dataSetLookup.getDataSetUUID(),
                              new RemoteCallback<DataSetMetadata>() {
                                  public void callback(DataSetMetadata metadata) {
                                      updateDataSetLookup();
                                  }
                              });
            }
        }
    });
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
List<String> getExistingDataColumnIds() {
    DataSet dataSet = displayerSettings.getDataSet();
    DataSetLookup dataSetLookup = displayerSettings.getDataSetLookup();

    List<String> columnIds = new ArrayList<String>();
    if (dataSet != null) {
        for (DataColumn dataColumn : dataSet.getColumns()) {
            columnIds.add(dataColumn.getId());
        }
    }
    else if (dataSetLookup != null) {
        int idx = dataSetLookup.getLastGroupOpIndex(0);
        if (idx != -1) {
            DataSetGroup groupOp = dataSetLookup.getOperation(idx);
            for (GroupFunction groupFunction : groupOp.getGroupFunctions()) {
                columnIds.add(groupFunction.getColumnId());
            }
        }
    }
    return columnIds;
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
@Test
public void testDeleteColumns() {
    DataSetLookup lookup = DataSetLookupFactory.newDataSetLookupBuilder()
            .dataset(POPULATION_UUID)
            .column("year")
            .column("population")
            .buildLookup();

    GroupFunction year = lookup.getLastGroupOp().getGroupFunction("year");
    presenter.init(DATA_MULTIPLE, lookup);

    reset(view);
    presenter.onColumnFunctionDeleted(new GroupFunctionDeletedEvent(year));

    verify(view).clearColumnList();
    verify(view, times(1)).addColumnEditor(any(ColumnFunctionEditor.class));
    verify(event).fire(any(DataSetLookupChangedEvent.class));
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
@Test
public void testDataSetSelected() {
    presenter.init(DATA_2D_FIXED, DataSetLookupFactory.newDataSetLookupBuilder()
            .dataset(POPULATION_UUID)
            .group("country")
            .column("country")
            .column("population", AggregateFunctionType.SUM)
            .buildLookup());

    when(view.getSelectedDataSetId()).thenReturn(REVENUE_UUID);
    presenter.onDataSetSelected();
    verify(event).fire(any(DataSetLookupChangedEvent.class));

    DataSetLookup newLookup = presenter.getDataSetLookup();
    assertEquals(newLookup.getDataSetUUID(), REVENUE_UUID);
    assertEquals(presenter.getFirstGroupColumnId(), "company");
    assertEquals(presenter.getFirstGroupFunctions().size(), 2);
    assertEquals(presenter.getFirstGroupFunctions().get(0).getSourceId(), "company");
    assertEquals(presenter.getFirstGroupFunctions().get(1).getSourceId(), "revenue");
    assertEquals(presenter.getFirstGroupFunctions().get(0).getFunction(), null);
    assertEquals(presenter.getFirstGroupFunctions().get(1).getFunction(), AggregateFunctionType.SUM);
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
private void _lookupDataSet(DataSetLookup request,
                            final DataSetReadyCallback listener) {
    try {
        dataSetLookupServices.call(
                new RemoteCallback<DataSet>() {
                    public void callback(DataSet result) {
                        if (result == null) {
                            listener.notFound();
                        } else {
                            listener.callback(result);
                        }
                    }
                },
                new ErrorCallback<Message>() {
                    @Override
                    public boolean error(Message message,
                                         Throwable throwable) {
                        return listener.onError(new ClientRuntimeError(throwable));
                    }
                })
                .lookupDataSet(request);
    } catch (Exception e) {
        listener.onError(new ClientRuntimeError(e));
    }
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
@Before
public void setup() throws Exception {
    super.setup();

    presenter = new DataSetEditorWorkflow(clientServices, validatorProvider, beanManager, saveRequestEvent,
            testDataSetEvent, cancelRequestEvent, view) {

    };
    presenter.dataSetDef = this.dataSetDef;

    when(dataSetDef.getUUID()).thenReturn(UUID);
    when(dataSetDef.getName()).thenReturn(NAME);
    when(dataSetDef.getProvider()).thenReturn(DataSetProviderType.BEAN);
    when(dataSet.getUUID()).thenReturn(UUID);
    when(dataSet.getRowCount()).thenReturn(0);
    when(dataSetDef.clone()).thenReturn(dataSetDef);
    doAnswer(new Answer<Void>() {
        @Override
        public Void answer(final InvocationOnMock invocationOnMock) throws Throwable {
            DataSetReadyCallback callback = (DataSetReadyCallback) invocationOnMock.getArguments()[2];
            callback.callback(dataSet);
            return null;
        }
    }).when(clientServices).lookupDataSet(any(dataSetDef.getClass()), any(DataSetLookup.class), any(DataSetReadyCallback.class));
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
@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);
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
public JsonObject toJsonObject( DisplayerSettings displayerSettings ) {
    JsonObject json = Json.createObject();

    // UUID
    json.put(SETTINGS_UUID, displayerSettings.getUUID());

    for (Map.Entry<String, String> entry : displayerSettings.getSettingsFlatMap().entrySet()) {
        setNodeValue(json, entry.getKey(), entry.getValue());
    }

    // Data set
    DataSetLookup dataSetLookup = displayerSettings.getDataSetLookup();
    DataSet dataSet = displayerSettings.getDataSet();
    if (dataSet != null) {
        json.put(DATASET_PREFIX, dataSetJsonMarshaller.toJson(dataSet));
    }
    else if (dataSetLookup != null) {
        json.put(DATASET_LOOKUP_PREFIX, dataSetLookupJsonMarshaller.toJson(dataSetLookup));
    }
    else {
        throw new RuntimeException("Displayer settings dataset lookup not specified");
    }

    // Column settings
    List<ColumnSettings> columnSettingsList = displayerSettings.getColumnSettingsList();
    if (!columnSettingsList.isEmpty()) {
        json.put(COLUMNS_PREFIX, formatColumnSettings(columnSettingsList));
    }

    return json;
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
void onDataSetLookupChanged(@Observes DataSetLookupChangedEvent event) {
    DataSetLookup dataSetLookup = event.getDataSetLookup();
    displayerSettings.setDataSet(null);
    displayerSettings.setDataSetLookup(dataSetLookup);
    removeStaleSettings();
    initDisplayer();
    initSettingsEditor();
    showDisplayer();
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
void displayerTypeChanged(DisplayerType type, DisplayerSubType displayerSubType) {

        // Create new settings for the selected type
        selectedTypeSettings = displayerPrototypes.getProto(type, displayerSubType);
        DataSet oldDataSet = displayerSettings.getDataSet();
        DataSetLookup oldDataLookup = displayerSettings.getDataSetLookup();

        // Check if the current data lookup is compatible with the new displayer type
        if (oldDataSet == null && oldDataLookup != null) {
            Displayer displayer = displayerLocator.lookupDisplayer(selectedTypeSettings);
            DisplayerConstraints displayerConstraints = displayer.getDisplayerConstraints();
            DataSetLookupConstraints dataConstraints = displayerConstraints.getDataSetLookupConstraints();
            DataSetMetadata metadata = clientServices.getMetadata(oldDataLookup.getDataSetUUID());

            // Keep the current data settings provided it satisfies the data constraints
            ValidationError validationError = dataConstraints.check(oldDataLookup, metadata);
            if (validationError == null) {
                selectedTypeSettings.setDataSet(null);
                selectedTypeSettings.setDataSetLookup(oldDataLookup);
                applySelectedType();
            }
            // If the data lookup is not compatible then ask the user what to do
            else {
                view.showTypeChangedWarning(this::applySelectedType, this::abortSelectedType);
            }
        }
        // If the displayer is static (no data lookup) then just display the selected displayer prototype
        else {
            applySelectedType();
        }
    }
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
@Test
public void testAddColumns() {

    DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
    presenter.init(DATA_2D_MULTIPLE, lookup);

    verify(view).setAddColumnOptionEnabled(true);
    presenter.onAddColumn();
    verify(event).fire(any(DataSetLookupChangedEvent.class));

    assertEquals(presenter.getFirstGroupFunctions().size(), 3);
    assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
    assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_2");
    assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);

    presenter.onAddColumn();
    assertEquals(presenter.getFirstGroupFunctions().size(), 4);
    assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
    assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_3");
    assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);

    reset(event);
    GroupFunction gf = new GroupFunction("population", "population_2", AggregateFunctionType.SUM);
    presenter.onColumnFunctionDeleted(new GroupFunctionDeletedEvent(gf));
    verify(event).fire(any(DataSetLookupChangedEvent.class));
    assertEquals(presenter.getFirstGroupFunctions().size(), 3);
    assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
    assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_3");
    assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);

    presenter.onAddColumn();
    assertEquals(presenter.getFirstGroupFunctions().size(), 4);
    assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
    assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_2");
    assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
@Test
public void testColumnChanged() {
    DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
    presenter.init(DATA_2D_MULTIPLE, lookup);

    GroupFunction gf = new GroupFunction("population", "population", AggregateFunctionType.SUM);
    presenter.onColumnFunctionChanged(new GroupFunctionChangedEvent(gf));
    assertEquals(gf.getColumnId(), "population_2");
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
/**
 * Listen to modifications on any of the data set being used in this perspective.
 */
private void onDataSetModifiedEvent(@Observes DataSetModifiedEvent event) {
    if (!editOn) {

        String targetUUID = event.getDataSetDef().getUUID();
        for (Displayer displayer : displayerCoordinator.getDisplayerList()) {
            DisplayerSettings settings = displayer.getDisplayerSettings();

            // Do nothing if the displayer:
            // - Is not drawn
            // - Is handling the refresh by itself
            // - Is not configured to be updated on stale data
            if (!displayer.isDrawn() || displayer.isRefreshOn() || !settings.isRefreshStaleData()) {
                continue;
            }

            String uuid = null;
            DataSet dataSet = settings.getDataSet();
            if (dataSet != null) {
                uuid = dataSet.getUUID();
            }
            DataSetLookup dataSetLookup = settings.getDataSetLookup();
            if (uuid == null && dataSetLookup != null) {
                uuid = dataSetLookup.getDataSetUUID();
            }
            if (uuid != null && targetUUID.equals(uuid)) {
                displayer.redraw();
            }
        }
    }
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
/**
 * Process the specified data set lookup request for a given definition.
 *
 * @param def     The data set definition
 * @param request The data set lookup request
 * @throws Exception It there is an unexpected error trying to execute the lookup request.
 */
public void lookupDataSet(final DataSetDef def,
                          final DataSetLookup request,
                          final DataSetReadyCallback listener) throws Exception {

    if (dataSetLookupServices != null) {
        try {
            dataSetLookupServices.call(
                    new RemoteCallback<DataSet>() {
                        public void callback(DataSet result) {
                            if (result == null) {
                                listener.notFound();
                            } else {
                                listener.callback(result);
                            }
                        }
                    },
                    new ErrorCallback<Message>() {
                        @Override
                        public boolean error(Message message,
                                             Throwable throwable) {
                            return listener.onError(new ClientRuntimeError(throwable));
                        }
                    })
                    .lookupDataSet(def,
                                   request);
        } catch (Exception e) {
            listener.onError(new ClientRuntimeError(e));
        }
    }
    // Data set not found on client.
    else {
        listener.notFound();
    }
}
 

import org.dashbuilder.dataset.DataSetLookup; //导入依赖的package包/类
@Override
public DataSet lookupDataSet(DataSetLookup lookup) {
    String uuid = lookup.getDataSetUUID();
    if (StringUtils.isEmpty(uuid)) {
        return null;
    }

    // Get the target data set
    DataSetIndex dataSetIndex = dataSetOpEngine.getIndexRegistry().get(uuid);
    if (dataSetIndex == null) {
        return null;
    }
    List<DataSetPreprocessor> dataSetDefPreProcessors = getDataSetPreprocessors(uuid);
    if (dataSetDefPreProcessors != null) {
        for(DataSetPreprocessor p : dataSetDefPreProcessors){
            p.preprocess(lookup);
        }
    }
    DataSet dataSet = dataSetIndex.getDataSet();

    // 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;
}