@UiHandler(value = "newFilterListBox")
  public void onNewFilterSelected(ChangeEvent changeEvent) {
    int selectedIdx = newFilterListBox.getSelectedIndex();
    if (selectedIdx > 0) {
      String columnId = metadata.getColumnId(selectedIdx - 1);
      ColumnType columnType = metadata.getColumnType(selectedIdx - 1);
      CoreFunctionFilter columnFilter =
          FilterFactory.createCoreFunctionFilter(
              columnId,
              columnType,
              ColumnType.DATE.equals(columnType)
                  ? CoreFunctionType.TIME_FRAME
                  : CoreFunctionType.NOT_EQUALS_TO);

      if (filter == null) filter = new DataSetFilter();
      filter.addFilterColumn(columnFilter);

      ColumnFilterEditor columnFilterEditor = new ColumnFilterEditor();
      columnFilterEditor.init(metadata, columnFilter, this);
      columnFilterEditor.expand();
      filterListPanel.add(columnFilterEditor);

      newFilterListBox.setSelectedIndex(0);
      addFilterPanel.setVisible(false);
      addFilterButton.setVisible(true);

      columnFilterChanged(columnFilterEditor);
    }
  }
  protected void initNewFilterListBox() {
    newFilterListBox.clear();
    newFilterListBox.addItem(FiltersConstants.INSTANCE.filter_editor_selectcolumn());

    if (metadata != null) {
      for (int i = 0; i < metadata.getNumberOfColumns(); i++) {
        newFilterListBox.addItem(metadata.getColumnId(i));
      }
    }
  }
  private List<Query> buildGroupIntervalQuery(DataSetGroup group) {
    if (group == null || !group.isSelect()) return null;

    List<Query> result = new LinkedList<Query>();
    String sourceId = group.getColumnGroup().getSourceId();
    ColumnType columnType = metadata.getColumnType(sourceId);
    ElasticSearchDataSetDef def = (ElasticSearchDataSetDef) metadata.getDefinition();

    List<Interval> intervals = group.getSelectedIntervalList();
    for (Interval interval : intervals) {
      Query _result = null;
      boolean isLabelCol = ColumnType.LABEL.equals(columnType);
      boolean isNumericCol = ColumnType.NUMBER.equals(columnType);
      boolean isDateCol = ColumnType.DATE.equals(columnType);
      boolean isTextCol = ColumnType.TEXT.equals(columnType);

      if (isTextCol) {
        throw new IllegalArgumentException(
            "Not supported type ["
                + columnType.name()
                + "] for column with id ["
                + sourceId
                + "] using grouping.");
      }

      if (isLabelCol) {
        String filterValue = valueTypeMapper.formatLabel(def, sourceId, interval.getName());
        _result = new Query(sourceId, Query.Type.TERM);
        _result.setParam(Query.Parameter.VALUE.name(), filterValue);
      } else if (isNumericCol || isDateCol) {
        Object maxValue = interval.getMaxValue();
        Object minValue = interval.getMinValue();
        Object value0 =
            isNumericCol
                ? valueTypeMapper.formatNumeric(def, sourceId, (Double) minValue)
                : valueTypeMapper.formatDate(def, sourceId, (Date) minValue);
        Object value1 =
            isNumericCol
                ? valueTypeMapper.formatNumeric(def, sourceId, (Double) maxValue)
                : valueTypeMapper.formatDate(def, sourceId, (Date) maxValue);
        _result = new Query(sourceId, Query.Type.RANGE);
        _result.setParam(Query.Parameter.GT.name(), value0);
        _result.setParam(Query.Parameter.LT.name(), value1);
      }

      result.add(_result);
    }

    return result;
  }
  private String formatValue(ElasticSearchDataSetDef definition, String columnId, Object value) {
    ColumnType columnType = metadata.getColumnType(columnId);
    boolean isLabelCol = ColumnType.LABEL.equals(columnType);
    boolean isNumericCol = ColumnType.NUMBER.equals(columnType);
    boolean isDateCol = ColumnType.DATE.equals(columnType);
    boolean isTextCol = ColumnType.TEXT.equals(columnType);
    if (isTextCol) {
      return valueTypeMapper.formatText(definition, columnId, (String) value);
    } else if (isLabelCol) {
      return valueTypeMapper.formatLabel(definition, columnId, (String) value);
    } else if (isDateCol) {
      return valueTypeMapper.formatDate(definition, columnId, (Date) value);
    } else if (isNumericCol) {
      return valueTypeMapper.formatNumeric(definition, columnId, (Double) value);
    }

    throw new IllegalArgumentException(
        "Not supported type [" + columnType.name() + "] for column id [" + columnId + "].");
  }
  protected Query buildColumnCoreFunctionFilter(
      CoreFunctionFilter filter, DataSetMetadata metadata) {
    String columnId = filter.getColumnId();
    ColumnType columnType = metadata.getColumnType(columnId);
    ElasticSearchDataSetDef def = (ElasticSearchDataSetDef) metadata.getDefinition();

    Query result = null;

    CoreFunctionType type = filter.getType();
    List params = filter.getParameters();

    if (CoreFunctionType.IS_NULL.equals(type)) {

      result = new Query(Query.Type.NOT);
      Query existResult = new Query(columnId, Query.Type.EXISTS);
      result.setParam(Query.Parameter.FILTER.name(), existResult);

    } else if (CoreFunctionType.NOT_NULL.equals(type)) {

      result = new Query(columnId, Query.Type.EXISTS);

    } else if (CoreFunctionType.EQUALS_TO.equals(type)) {

      Object value = formatValue(def, columnId, params.get(0));

      if (ColumnType.LABEL.equals(columnType)) {
        result = new Query(columnId, Query.Type.TERM);
      } else {
        result = new Query(columnId, Query.Type.MATCH);
      }
      result.setParam(Query.Parameter.VALUE.name(), value);

    } else if (CoreFunctionType.LIKE_TO.equals(type)) {

      Object value = formatValue(def, columnId, params.get(0));

      if (value != null) {

        if (ColumnType.NUMBER.equals(columnType) || ColumnType.DATE.equals(columnType)) {
          throw new RuntimeException(
              "The operator LIKE can be applied only for LABEL or TEXT column types. The column ["
                  + columnId
                  + "] is type ["
                  + columnType.name()
                  + "}.");
        }

        // TEXT or LABEL columns.
        String indexType = def.getPattern(columnId);
        if (indexType == null || indexType.trim().length() == 0) {
          // Default ELS index type for String fields is ANALYZED.
          indexType = FieldMappingResponse.IndexType.ANALYZED.name();
        }

        // Replace Dashbuilder wildcard characters by the ones used in ELS wildcard query.
        boolean caseSensitive = params.size() < 2 || Boolean.parseBoolean(params.get(1).toString());
        boolean isFieldAnalyzed =
            FieldMappingResponse.IndexType.ANALYZED.name().equalsIgnoreCase(indexType);

        // Case un-sensitive is not supported for not_analyzed string fields.
        if (!isFieldAnalyzed && !caseSensitive) {
          throw new RuntimeException(
              "Case unsensitive is not supported for not_analyzed string fields. Field: ["
                  + columnId
                  + "].");
        }

        String pattern = utils.transformPattern(value.toString());
        boolean isLowerCaseExpandedTerms = isFieldAnalyzed && (!caseSensitive);
        result = new Query(columnId, Query.Type.QUERY_STRING);
        result.setParam(Query.Parameter.DEFAULT_FIELD.name(), columnId);
        result.setParam(Query.Parameter.DEFAULT_OPERATOR.name(), "AND");
        result.setParam(Query.Parameter.QUERY.name(), pattern);
        result.setParam(Query.Parameter.LOWERCASE_EXPANDED_TERMS.name(), isLowerCaseExpandedTerms);
      }

    } else if (CoreFunctionType.NOT_EQUALS_TO.equals(type)) {

      Object value = formatValue(def, columnId, params.get(0));

      if (ColumnType.LABEL.equals(columnType)) {
        Query resultMatch = new Query(columnId, Query.Type.TERM);
        resultMatch.setParam(Query.Parameter.VALUE.name(), value);
        result = new Query(columnId, Query.Type.NOT);
        result.setParam(Query.Parameter.FILTER.name(), resultMatch);
      } else {
        Query resultMatch = new Query(columnId, Query.Type.MATCH);
        resultMatch.setParam(Query.Parameter.VALUE.name(), value);
        result = new Query(columnId, Query.Type.BOOL);
        result.setParam(Query.Parameter.MUST_NOT.name(), asList(resultMatch));
      }

    } else if (CoreFunctionType.LOWER_THAN.equals(type)) {

      Object value = formatValue(def, columnId, params.get(0));
      result = new Query(columnId, Query.Type.RANGE);
      result.setParam(Query.Parameter.LT.name(), value);

    } else if (CoreFunctionType.LOWER_OR_EQUALS_TO.equals(type)) {

      Object value = formatValue(def, columnId, params.get(0));
      result = new Query(columnId, Query.Type.RANGE);
      result.setParam(Query.Parameter.LTE.name(), value);

    } else if (CoreFunctionType.GREATER_THAN.equals(type)) {

      Object value = formatValue(def, columnId, params.get(0));
      result = new Query(columnId, Query.Type.RANGE);
      result.setParam(Query.Parameter.GT.name(), value);

    } else if (CoreFunctionType.GREATER_OR_EQUALS_TO.equals(type)) {

      Object value = formatValue(def, columnId, params.get(0));
      result = new Query(columnId, Query.Type.RANGE);
      result.setParam(Query.Parameter.GTE.name(), value);

    } else if (CoreFunctionType.BETWEEN.equals(type)) {

      Object value0 = formatValue(def, columnId, params.get(0));
      Object value1 = formatValue(def, columnId, params.get(1));
      result = new Query(columnId, Query.Type.RANGE);
      result.setParam(Query.Parameter.GT.name(), value0);
      result.setParam(Query.Parameter.LT.name(), value1);

    } else if (CoreFunctionType.TIME_FRAME.equals(type)) {

      TimeFrame timeFrame = TimeFrame.parse(params.get(0).toString());
      if (timeFrame != null) {
        java.sql.Date past = new java.sql.Date(timeFrame.getFrom().getTimeInstant().getTime());
        java.sql.Date future = new java.sql.Date(timeFrame.getTo().getTimeInstant().getTime());
        result = new Query(columnId, Query.Type.RANGE);
        result.setParam(Query.Parameter.GTE.name(), past);
        result.setParam(Query.Parameter.LTE.name(), future);
      }

    } else {
      throw new IllegalArgumentException("Core function type not supported: " + type);
    }

    return result;
  }