@Override public RendererPrecedence getPrecedence(final AnalyzerComponentBuilder<UpdateTableAnalyzer> ajb) { if (ajb.getDescriptor().getComponentClass() == UpdateTableAnalyzer.class) { return RendererPrecedence.HIGH; } return RendererPrecedence.NOT_CAPABLE; }
@Override public String toString() { return "AnalyzerComponentBuilder[analyzer=" + getDescriptor().getDisplayName() + ",inputColumns=" + getInputColumns() + "]"; }
@Override protected Map<ConfiguredPropertyDescriptor, Object> getConfiguredPropertiesForQuestioning() { final Map<ConfiguredPropertyDescriptor, Object> properties = super.getConfiguredPropertiesForQuestioning(); if (!isMultipleJobsSupported()) { return properties; } // create a mutable copy and replace the property values that are final Map<ConfiguredPropertyDescriptor, Object> map = new HashMap<>(properties); for (final Entry<ConfiguredPropertyDescriptor, Object> entry : map.entrySet()) { if (isMultipleJobsDeterminedBy(entry.getKey())) { final Object value = entry.getValue(); if (Array.getLength(value) > 1) { // pick the first element final Object element = Array.get(value, 0); entry.setValue(element); } } } return Collections.unmodifiableMap(map); }
public <A extends Analyzer<?>> AnalyzerComponentBuilder<A> addAnalyzer( final AnalyzerComponentBuilder<A> analyzerJobBuilder) { _analyzerComponentBuilders.add(analyzerJobBuilder); if (analyzerJobBuilder.getComponentRequirement() == null) { analyzerJobBuilder.setComponentRequirement(_defaultRequirement); } // Before triggering component's listeners, so listeners are ready. onComponentAdded(); // make a copy since some of the listeners may add additional listeners // which will otherwise cause ConcurrentModificationExceptions final List<AnalyzerChangeListener> listeners = new ArrayList<>(_analyzerChangeListeners); for (final AnalyzerChangeListener listener : listeners) { listener.onAdd(analyzerJobBuilder); } return analyzerJobBuilder; }
public AnalyzerJob[] toAnalyzerJobs(final boolean validate, final AnalysisJobImmutabilizer immutabilizer) throws IllegalStateException { final Map<ConfiguredPropertyDescriptor, Object> configuredProperties = getConfiguredProperties(); final ComponentRequirement componentRequirement = immutabilizer.load(getComponentRequirement()); inputColumns = _escalatingInputColumns; } else { inputColumns = getInputColumns(); final Map<Table, List<InputColumn<?>>> originatingTables = new LinkedHashMap<>(); for (final InputColumn<?> inputColumn : inputColumns) { final Table table = getAnalysisJobBuilder().getOriginatingTable(inputColumn); if (table == null) { final List<Table> sourceTables = getAnalysisJobBuilder().getSourceTables(); if (sourceTables.size() == 1) { logger.info("Only a single source table is available, so the source of analyzer '{}' is inferred", if (!isMultipleJobsSupported() && originatingTables.size() == 1) { final OutputDataStreamJob[] outputDataStreamJobs = immutabilizer.load(getOutputDataStreamJobs(), validate); final ImmutableAnalyzerJob job = new ImmutableAnalyzerJob(getName(), getDescriptor(), new ImmutableComponentConfiguration(configuredProperties), componentRequirement, getMetadataProperties(), outputDataStreamJobs); return new AnalyzerJob[] { job }; jobs.add(createPartitionedJob(null, columnsOfTable, configuredProperties, partitionIndex++)); } else { for (final InputColumn<?> escalatingColumn : columnsOfTable) {
partitionValue(propertyDescriptor, unpartitionedValue, availableColumns); jobProperty.setValue(partitionedValue); final Map<String, String> metadataProperties = new LinkedHashMap<>(getMetadataProperties()); metadataProperties.put(METADATA_PROPERTY_BUILDER_ID, "" + System.identityHashCode(this)); metadataProperties.put(METADATA_PROPERTY_BUILDER_PARTITION_INDEX, "" + partitionIndex); new AnalysisJobImmutabilizer().load(getComponentRequirement()); return new ImmutableAnalyzerJob(getName(), getDescriptor(), new ImmutableComponentConfiguration(jobProperties), componentRequirement, metadataProperties, outputDataStreamJobs);
private ActionListener createWriteDataActionListener(final Class<? extends Analyzer<?>> analyzerClass, final String filenameExtension) { return e -> { final AnalysisJob copyAnalysisJob = _analysisJobBuilder.toAnalysisJob(false); final AnalysisJobBuilder copyAnalysisJobBuilder = new AnalysisJobBuilder(_analysisJobBuilder.getConfiguration(), copyAnalysisJob); final AnalyzerComponentBuilder<? extends Analyzer<?>> analyzer = copyAnalysisJobBuilder.addAnalyzer(analyzerClass); analyzer.addInputColumns(copyAnalysisJobBuilder.getAvailableInputColumns(Object.class)); final String formattedDate = new SimpleDateFormat("yyyy-MM-dd").format(new Date()); final FileResource resource = createResource("datacleaner-" + formattedDate + "-output", filenameExtension); if (analyzerClass == CreateExcelSpreadsheetAnalyzer.class) { final File file = resource.getFile(); analyzer.setConfiguredProperty("File", file); } else { analyzer.setConfiguredProperty("File", resource); } final ConfiguredPropertyDescriptor sheetNameProperty = analyzer.getDescriptor().getConfiguredProperty("Sheet name"); if (sheetNameProperty != null) { analyzer.setConfiguredProperty(sheetNameProperty, "data"); } final RunAnalysisActionListener runAnalysis = new RunAnalysisActionListener(_dcModule, copyAnalysisJobBuilder); ExecuteJobWithoutAnalyzersDialog.this.close(); runAnalysis.run(); }; }
ajb.setDatastore(ds); ajb.addSourceColumns(table.getLiteralColumns()); ajb.addAnalyzer(PatternFinderAnalyzer.class).addInputColumns(ajb.getSourceColumns()) .setName("Ungrouped pattern finders"); groupedPatternFinder.setName("Grouped PF"); groupedPatternFinder.addInputColumn(ajb.getSourceColumnByName("PUBLIC.OFFICES.CITY")); groupedPatternFinder.addInputColumn(ajb.getSourceColumnByName("PUBLIC.OFFICES.TERRITORY"), groupedPatternFinder.getDescriptor().getConfiguredProperty("Group column"));
@Override public boolean isConfigured(final ConfiguredPropertyDescriptor configuredProperty, final boolean throwException) { if (isMultipleJobsSupported() && configuredProperty == _escalatingInputProperty) { if (_escalatingInputColumns.isEmpty()) { final Object propertyValue = super.getConfiguredProperty(configuredProperty); if (propertyValue != null) { if (propertyValue.getClass().isArray() && Array.getLength(propertyValue) > 0) { setConfiguredProperty(configuredProperty, propertyValue); return isConfigured(configuredProperty, throwException); } } if (throwException) { throw new ComponentConfigurationException( "No input columns configured for " + LabelUtils.getLabel(this)); } else { return false; } } return true; } return super.isConfigured(configuredProperty, throwException); }
.addInputColumns(tjb.getInputColumns()).addInputColumns(tjb.getOutputColumns()); rowCollector.setComponentRequirement(tjb.getComponentRequirement());
@Override public AnalyzerComponentBuilder<A> addInputColumn(final InputColumn<?> inputColumn, final ConfiguredPropertyDescriptor propertyDescriptor) { assert propertyDescriptor.isInputColumn(); if (inputColumn == null) { throw new IllegalArgumentException("InputColumn cannot be null"); } if (isMultipleJobsDeterminedBy(propertyDescriptor)) { _escalatingInputColumns.add(inputColumn); registerListenerIfLinkedToTransformer(propertyDescriptor, _escalatingInputColumns.toArray(new InputColumn<?>[_escalatingInputColumns.size()])); return this; } else { return super.addInputColumn(inputColumn, propertyDescriptor); } }
excelOutputAnalyzerBuilder.addInputColumns(ajb.getSourceColumns()); final File directory = _userPreferences.getConfiguredFileDirectory(); excelOutputAnalyzerBuilder.getComponentInstance().setFile(new File(directory, _datastore.getName() + ".xlsx")); excelOutputAnalyzerBuilder.getComponentInstance().setSheetName(_table.getName());
singleValueDist.addInputColumn(ajb.getSourceColumnByName("PUBLIC.CUSTOMERS.ADDRESSLINE2")); groupedValueDist.addInputColumn(ajb.getSourceColumnByName("PUBLIC.CUSTOMERS.CITY")); groupedValueDist.setConfiguredProperty("Group column", ajb.getSourceColumnByName("PUBLIC.CUSTOMERS.COUNTRY"));
@Override public Object getConfiguredProperty(final ConfiguredPropertyDescriptor propertyDescriptor) { if (isMultipleJobsDeterminedBy(propertyDescriptor)) { return _escalatingInputColumns.toArray(new InputColumn[_escalatingInputColumns.size()]); } else { return super.getConfiguredProperty(propertyDescriptor); } }
ajb.addAnalyzer(BooleanAnalyzer.class).addInputColumns(booleanColumns);
@Override public List<OutputDataStream> getOutputDataStreams() { if (isMultipleJobsSupported()) { return Collections.emptyList(); } return super.getOutputDataStreams(); }
final String[] columnNames = new String[rowCollector.getInputColumns().size()]; for (int i = 0; i < columnNames.length; i++) { columnNames[i] = rowCollector.getInputColumns().get(i).getName();
@Override public void addNotify() { super.addNotify(); _analyzerComponentBuilder.addChangeListener(this); }
public <A extends Analyzer<?>> AnalyzerComponentBuilder<A> addAnalyzer(final AnalyzerDescriptor<A> descriptor, final Map<ConfiguredPropertyDescriptor, Object> configuredProperties, final ComponentRequirement requirement, final Map<String, String> metadataProperties) { final AnalyzerComponentBuilder<A> analyzerJobBuilder = new AnalyzerComponentBuilder<>(this, descriptor); initializeComponentBuilder(analyzerJobBuilder, configuredProperties, requirement, metadataProperties); return addAnalyzer(analyzerJobBuilder); }
columnCount = 0; analyzerJobBuilder.addInputColumn(inputColumn); ajb.addAnalyzer(ValueDistributionAnalyzer.class).addInputColumn(inputColumn); ajb.addAnalyzer(PatternFinderAnalyzer.class).addInputColumn(inputColumn);