@Override public String getSuggestedLabel() { if (column == null) { return null; } return "Value matcher: " + column.getName(); }
@Override public OutputDataStreamBuilder withColumnLike(final InputColumn<?> column) { if (column.isPhysicalColumn()) { return withColumnLike(column.getPhysicalColumn()); } else { final ColumnType columnType = ColumnTypeImpl.convertColumnType(column.getDataType()); return withColumn(column.getName(), columnType); } }
private String[] getInputColumnNames(final InputColumn<?>[] inputColumns) { final String[] result = new String[inputColumns.length]; for (int i = 0; i < inputColumns.length; i++) { final InputColumn<?> inputColumn = inputColumns[i]; if (inputColumn.isPhysicalColumn()) { result[i] = inputColumn.getPhysicalColumn().getQualifiedLabel(); } else { result[i] = inputColumn.getName(); } } return result; }
private static String getKey(final Object object) { if (object instanceof InputColumn<?>) { final InputColumn<?> inputColumn = (InputColumn<?>) object; if (inputColumn.isVirtualColumn()) { return inputColumn.getName(); } } return String.valueOf(object.hashCode()); }
@Override public OutputColumns getOutputColumns() { init(); final int size = _outputColumns.size(); final String[] names = new String[size]; final Class<?>[] types = new Class[size]; for (int i = 0; i < size; i++) { final InputColumn<?> outputColumn = _outputColumns.get(i); names[i] = outputColumn.getName(); types[i] = outputColumn.getDataType(); } return new OutputColumns(names, types); }
public static Icon getColumnIcon(final InputColumn<?> column, final int iconSize) { if (column.isPhysicalColumn()) { return getColumnIcon(column.getPhysicalColumn(), iconSize); } return _imageManager.getImageIcon(MODEL_COLUMN, IconUtils.ICON_SIZE_SMALL); }
@Override public boolean isTimeCategory() { return ReflectionUtils.isDate(_categoryColumn.getDataType()); }
@Override public void onAdd(final InputColumn<?> column) { final Column physicalColumn = column.getPhysicalColumn(); if (physicalColumn != null) { if (physicalColumn.getTable() == _table) { _columnListTable.addColumn(column); } } }
public void addValue(final InputColumn<?> inputColumn, final Object value) { if (inputColumn.isPhysicalColumn()) { throw new IllegalArgumentException("Cannot add physical column values to transformed InputRow."); } _values.put(inputColumn, value); }
/** * Gets the key to use in the capture state file. If there is not a * captureStateIdentifier available, we want to avoid using a hardcoded key, * since the same file may be used for multiple purposes, even multiple * filters of the same type. Of course this is not desired configuration, * but may be more convenient for lazy users! * * @return */ private String getPropertyKey() { if (StringUtils.isNullOrEmpty(captureStateIdentifier)) { if (lastModifiedColumn.isPhysicalColumn()) { final Table table = lastModifiedColumn.getPhysicalColumn().getTable(); if (table != null && !StringUtils.isNullOrEmpty(table.getName())) { return table.getName() + "." + lastModifiedColumn.getName() + ".GreatestLastModifiedValue"; } } return lastModifiedColumn.getName() + ".GreatestLastModifiedValue"; } return captureStateIdentifier.trim() + ".GreatestLastModifiedValue"; }
@Override public String evaluate(final InputRow row) { final SimpleContext context = new SimpleContext(); final List<InputColumn<?>> inputColumns = row.getInputColumns(); for (final InputColumn<?> inputColumn : inputColumns) { if (!(inputColumn instanceof ExpressionBasedInputColumn)) { final Object value = row.getValue(inputColumn); final Class<?> javaType = inputColumn.getDataType(); final ValueExpression valueExpression = _factory.createValueExpression(value, javaType); String variableName = inputColumn.getName(); variableName = StringUtils.replaceWhitespaces(variableName, "_"); context.setVariable(variableName, valueExpression); } } try { final ValueExpression valueExpression = _factory.createValueExpression(context, _expression, String.class); return (String) valueExpression.getValue(context); } catch (final ELException e) { logger.error("Could not evaluate EL expression", e); return null; } }
@SuppressWarnings("unchecked") @Override public <E> E getValueInternal(final InputColumn<E> column) { if (!column.isPhysicalColumn()) { return null; } final Column physicalColumn = column.getPhysicalColumn(); Object value = _row.getValue(physicalColumn); value = convertValue(value); return (E) value; }
@Override public boolean isNumberCategory() { return ReflectionUtils.isNumber(_categoryColumn.getDataType()); }
@Override public Query optimizeQuery(final Query q, final Category category) { if (category == Category.TRUE) { final Column inputPhysicalColumn = inputColumn.getPhysicalColumn(); final Object operand; if (compareColumn != null) { final Column physicalCompareColumn = compareColumn.getPhysicalColumn(); operand = new SelectItem(physicalCompareColumn); } else { operand = toOperand(compareValue); } q.where(inputPhysicalColumn, operator.getOperatorType(), operand); return q; } throw new UnsupportedOperationException(); } }
@SuppressWarnings("unchecked") @Override public <E> E getValueInternal(final InputColumn<E> column) { if (column.isPhysicalColumn()) { logger.debug("Column is physical, delegating."); return _delegate.getValue(column); } if (_values.containsKey(column)) { return (E) _values.get(column); } return _delegate.getValue(column); }
@Override public String getName() { // not applicable return _column.getName(); }
private Set<Column> findOriginatingColumnsOfInputColumn(final InputColumn<?> inputColumn) { final Set<Column> cachedOriginatingColumns = originatingColumnsOfInputColumnCache.get(inputColumn); if (cachedOriginatingColumns != null) { return cachedOriginatingColumns; } final Set<Column> originatingColumns = new HashSet<>(); if (inputColumn != null) { if (inputColumn.isPhysicalColumn()) { originatingColumns.add(inputColumn.getPhysicalColumn()); } else { final InputColumnSourceJob source = findInputColumnSource(inputColumn); originatingColumns.addAll(findOriginatingColumnsOfSource(source)); } } originatingColumnsOfInputColumnCache.put(inputColumn, originatingColumns); return originatingColumns; }
private boolean isColumnApplicable(final InputColumn<?> column) { return _dataType == Object.class || ReflectionUtils.is(column.getDataType(), _dataType); }
@Override public Query optimizeQuery(final Query q, final RangeFilterCategory category) { final Column col = getColumn().getPhysicalColumn(); final SelectItem selectItem = new SelectItem(col); switch (category) { case LOWER: return lowerQuery(q, selectItem); case HIGHER: return higherQuery(q, selectItem); case VALID: return validQuery(q, col, selectItem); default: throw new UnsupportedOperationException(); } }
private String getColumnHeader(final int index) { if (fields == null) { return columns[index].getName(); } return fields[index]; }