Java FilterList.getFilters方法代碼示例

import org.apache.hadoop.hbase.filter.FilterList; //導入方法依賴的package包/類
private Filter handleFilterWithinAND(Filter filter) {
  if (filter instanceof FilterList) {
    FilterList fList = (FilterList) filter;
    if (fList.getOperator() == Operator.MUST_PASS_ONE) {
      return new FilterGroupingWorker().group(fList);
    } else {
      List<Filter> filters = fList.getFilters();
      for (Filter subFilter : filters) {
        handleFilterWithinAND(subFilter);
      }
    }
  } else if (filter instanceof SingleColumnValueFilter) {
    handleScvf((SingleColumnValueFilter) filter);
  } // TODO when we expose SingleColumnRangeFilter to handle that also here.
  return null;
}
 

import org.apache.hadoop.hbase.filter.FilterList; //導入方法依賴的package包/類
FilterNode evalFilterForIndexSelection(Filter filter, List<IndexSpecification> indices) {
  if (filter instanceof FilterList) {
    FilterList fList = (FilterList) filter;
    GroupingCondition condition =
        (fList.getOperator() == Operator.MUST_PASS_ALL) ? GroupingCondition.AND
            : GroupingCondition.OR;
    NonLeafFilterNode nonLeafFilterNode = new NonLeafFilterNode(condition);
    List<Filter> filters = fList.getFilters();
    for (Filter fltr : filters) {
      FilterNode node = evalFilterForIndexSelection(fltr, indices);
      nonLeafFilterNode.addFilterNode(node);
    }
    return handleNonLeafFilterNode(nonLeafFilterNode);
  } else if (filter instanceof SingleColumnValueFilter) {
    // Check for the availability of index
    return selectBestFitAndPossibleIndicesForSCVF(indices, (SingleColumnValueFilter) filter);
  } else if (filter instanceof SingleColumnRangeFilter) {
    return selectBestFitAndPossibleIndicesForSCRF(indices, (SingleColumnRangeFilter) filter);
  }
  return new NoIndexFilterNode();
}
 

import org.apache.hadoop.hbase.filter.FilterList; //導入方法依賴的package包/類
private RowFilter filterMustPassOne(FilterAdapterContext context, FilterList filter)
    throws IOException {
  Interleave.Builder interLeaveBuilder = Interleave.newBuilder();
  for (Filter subFilter : filter.getFilters()) {
    interLeaveBuilder.addFilters(subFilterAdapter.adaptFilter(context, subFilter));
  }
  return RowFilter.newBuilder()
      .setInterleave(interLeaveBuilder)
      .build();
}
 

import org.apache.hadoop.hbase.filter.FilterList; //導入方法依賴的package包/類
private RowFilter filterMustPassAll(FilterAdapterContext context, FilterList filter)
    throws IOException {
  Chain.Builder chainBuilder = Chain.newBuilder();
  for (Filter subFilter : filter.getFilters()) {
    chainBuilder.addFilters(subFilterAdapter.adaptFilter(context, subFilter));
  }
  return RowFilter.newBuilder()
      .setChain(chainBuilder)
      .build();
}
 

import org.apache.hadoop.hbase.filter.FilterList; //導入方法依賴的package包/類
@Override
public void collectUnsupportedStatuses(
    FilterAdapterContext context,
    FilterList filter,
    List<FilterSupportStatus> unsupportedStatuses) {
  for (Filter subFilter : filter.getFilters()) {
    subFilterAdapter.collectUnsupportedStatuses(context, subFilter, unsupportedStatuses);
  }
}
 

import org.apache.hadoop.hbase.filter.FilterList; //導入方法依賴的package包/類
/**
 * Since you can use Filter Lists as children of Filter Lists, you can create a hierarchy of
 * filters to be evaluated. In the hierarchy if OR branch having any filter type other than SCVF
 * as child then we should not consider the branch for scanning because we cannot fetch seek
 * points from other type of filters without column and value details. Ex: AND AND
 * __________|_______ | | | --> SCVF OR SCVF _______|______ | | ROWFILTER SVCF If the OR is root
 * then we should skip index table scanning for this filter. OR _______|______ --> null | |
 * ROWFILTER SVCF If the OR is child of another OR branch then parent OR branch will be excluded
 * for scanning. Ex: AND AND __________|_______ | | | --> SCVF OR SCVF _______|______ | | OR SVCF
 * _______|______ | | ROWFILTER SVCF
 * @param filter
 * @return if filter is filter list with AND condition then we will return AND branch after
 *         grouping. if filter is filter list with OR condition return null if no children is of
 *         type other than SCVF or filter list else return different filter. if filter is SCVF
 *         then return null. returning null means we are combining the filter(s) with children of
 *         parent OR filter to perform optimizations.
 */
private Filter handleFilterWithinOR(Filter filter) {
  if (filter instanceof FilterList) {
    FilterList fList = (FilterList) filter;
    if (fList.getOperator() == Operator.MUST_PASS_ONE) {
      List<Filter> filters = fList.getFilters();
      Filter resultFilter = null;
      for (Filter subFilter : filters) {
        // If this OR branch in the filter list have filter type other than SCVF we should report
        // it to parent by returning the other type of filter in such a way that the branch will
        // be skipped from index scan.
        resultFilter = handleFilterWithinOR(subFilter);
        if (resultFilter == null || (resultFilter instanceof FilterList)) {
          continue;
        } else {
          return resultFilter;
        }
      }
      return null;
    } else {
      return new FilterGroupingWorker().group(fList);
    }
  } else if (filter instanceof SingleColumnValueFilter) {
    handleScvfOfOR((SingleColumnValueFilter) filter);
    return null;
  }// TODO when we expose SingleColumnRangeFilter to handle that also here.
   // filter other than SingleColumnValueFilter.
  return filter;
}
 

import org.apache.hadoop.hbase.filter.FilterList; //導入方法依賴的package包/類
/**
 * Wraps an existing {@link FilterList} filter into a {@link ModelAwareFilterList}.
 */
public static ModelAwareFilterList wrap(FilterList filter) {
    return new ModelAwareFilterList(filter.getOperator(), filter.getFilters());
}