You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@drill.apache.org by GitBox <gi...@apache.org> on 2018/11/26 16:04:23 UTC
[GitHub] asfgit closed pull request #1552: DRILL-6865: Query returns wrong
result when filter pruning happens
asfgit closed pull request #1552: DRILL-6865: Query returns wrong result when filter pruning happens
URL: https://github.com/apache/drill/pull/1552
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/AbstractParquetGroupScan.java b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/AbstractParquetGroupScan.java
index 9bc969f035b..5699d4546f7 100644
--- a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/AbstractParquetGroupScan.java
+++ b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/AbstractParquetGroupScan.java
@@ -85,6 +85,8 @@
private List<EndpointAffinity> endpointAffinities;
private ParquetGroupScanStatistics parquetGroupScanStatistics;
+ // whether all row groups of this group scan fully match the filter
+ private boolean matchAllRowGroups = false;
protected AbstractParquetGroupScan(String userName,
List<SchemaPath> columns,
@@ -111,6 +113,7 @@ protected AbstractParquetGroupScan(AbstractParquetGroupScan that) {
this.fileSet = that.fileSet == null ? null : new HashSet<>(that.fileSet);
this.entries = that.entries == null ? null : new ArrayList<>(that.entries);
this.readerConfig = that.readerConfig;
+ this.matchAllRowGroups = that.matchAllRowGroups;
}
@JsonProperty
@@ -135,6 +138,11 @@ public ParquetReaderConfig getReaderConfig() {
return readerConfig;
}
+ @JsonIgnore
+ public boolean isMatchAllRowGroups() {
+ return matchAllRowGroups;
+ }
+
@JsonIgnore
@Override
public Collection<String> getFiles() {
@@ -229,15 +237,12 @@ public void setFilter(LogicalExpression filter) {
}
@Override
- public GroupScan applyFilter(LogicalExpression filterExpr, UdfUtilities udfUtilities,
- FunctionImplementationRegistry functionImplementationRegistry, OptionManager optionManager) {
-
- if (rowGroupInfos.size() == 1 ||
- ! (parquetTableMetadata.isRowGroupPrunable()) ||
- rowGroupInfos.size() > optionManager.getOption(PlannerSettings.PARQUET_ROWGROUP_FILTER_PUSHDOWN_PLANNING_THRESHOLD)
- ) {
- // Stop pruning for 3 cases:
- // - 1 single parquet file,
+ public AbstractParquetGroupScan applyFilter(LogicalExpression filterExpr, UdfUtilities udfUtilities,
+ FunctionImplementationRegistry functionImplementationRegistry, OptionManager optionManager) {
+
+ if (!parquetTableMetadata.isRowGroupPrunable() ||
+ rowGroupInfos.size() > optionManager.getOption(PlannerSettings.PARQUET_ROWGROUP_FILTER_PUSHDOWN_PLANNING_THRESHOLD)) {
+ // Stop pruning for 2 cases:
// - metadata does not have proper format to support row group level filter pruning,
// - # of row groups is beyond PARQUET_ROWGROUP_FILTER_PUSHDOWN_PLANNING_THRESHOLD.
return null;
@@ -248,7 +253,13 @@ public GroupScan applyFilter(LogicalExpression filterExpr, UdfUtilities udfUtili
final List<RowGroupInfo> qualifiedRGs = new ArrayList<>(rowGroupInfos.size());
Set<String> qualifiedFilePath = new HashSet<>(); // HashSet keeps a fileName unique.
- ParquetFilterPredicate filterPredicate = null;
+ ParquetFilterPredicate filterPredicate = getParquetFilterPredicate(filterExpr, udfUtilities, functionImplementationRegistry, optionManager, true);
+
+ if (filterPredicate == null) {
+ return null;
+ }
+
+ boolean matchAllRowGroupsLocal = true;
for (RowGroupInfo rowGroup : rowGroupInfos) {
final ColumnExplorer columnExplorer = new ColumnExplorer(optionManager, columns);
@@ -262,41 +273,33 @@ public GroupScan applyFilter(LogicalExpression filterExpr, UdfUtilities udfUtili
Map<SchemaPath, ColumnStatistics> columnStatisticsMap = statCollector.collectColStat(schemaPathsInExpr);
- if (filterPredicate == null) {
- ErrorCollector errorCollector = new ErrorCollectorImpl();
- LogicalExpression materializedFilter = ExpressionTreeMaterializer.materializeFilterExpr(
- filterExpr, columnStatisticsMap, errorCollector, functionImplementationRegistry);
-
- if (errorCollector.hasErrors()) {
- logger.error("{} error(s) encountered when materialize filter expression : {}",
- errorCollector.getErrorCount(), errorCollector.toErrorString());
- return null;
- }
- logger.debug("materializedFilter : {}", ExpressionStringBuilder.toString(materializedFilter));
-
- Set<LogicalExpression> constantBoundaries = ConstantExpressionIdentifier.getConstantExpressionSet(materializedFilter);
- filterPredicate = ParquetFilterBuilder.buildParquetFilterPredicate(materializedFilter, constantBoundaries, udfUtilities);
-
- if (filterPredicate == null) {
- return null;
- }
- }
-
- ParquetFilterPredicate.RowsMatch match = ParquetRGFilterEvaluator.matches(filterPredicate, columnStatisticsMap, rowGroup.getRowCount(), parquetTableMetadata, rowGroup.getColumns(), schemaPathsInExpr);
+ ParquetFilterPredicate.RowsMatch match = ParquetRGFilterEvaluator.matches(filterPredicate,
+ columnStatisticsMap, rowGroup.getRowCount(), parquetTableMetadata, rowGroup.getColumns(), schemaPathsInExpr);
if (match == ParquetFilterPredicate.RowsMatch.NONE) {
continue; // No row comply to the filter => drop the row group
}
- rowGroup.setRowsMatch(match);
+ // for the case when any of row groups partially matches the filter,
+ // matchAllRowGroupsLocal should be set to false
+ if (matchAllRowGroupsLocal) {
+ matchAllRowGroupsLocal = match == ParquetFilterPredicate.RowsMatch.ALL;
+ }
qualifiedRGs.add(rowGroup);
qualifiedFilePath.add(rowGroup.getPath());
}
- if (qualifiedRGs.size() == rowGroupInfos.size() ) {
+ if (qualifiedRGs.size() == rowGroupInfos.size()) {
// There is no reduction of rowGroups. Return the original groupScan.
logger.debug("applyFilter does not have any pruning!");
+ matchAllRowGroups = matchAllRowGroupsLocal;
return null;
} else if (qualifiedFilePath.size() == 0) {
+ if (rowGroupInfos.size() == 1) {
+ // For the case when group scan has single row group and it was filtered,
+ // no need to create new group scan with the same row group.
+ return null;
+ }
+ matchAllRowGroupsLocal = false;
logger.debug("All rowgroups have been filtered out. Add back one to get schema from scannner");
RowGroupInfo rg = rowGroupInfos.iterator().next();
qualifiedFilePath.add(rg.getPath());
@@ -310,6 +313,7 @@ public GroupScan applyFilter(LogicalExpression filterExpr, UdfUtilities udfUtili
AbstractParquetGroupScan cloneGroupScan = cloneWithFileSelection(qualifiedFilePath);
cloneGroupScan.rowGroupInfos = qualifiedRGs;
cloneGroupScan.parquetGroupScanStatistics.collect(cloneGroupScan.rowGroupInfos, cloneGroupScan.parquetTableMetadata);
+ cloneGroupScan.matchAllRowGroups = matchAllRowGroupsLocal;
return cloneGroupScan;
} catch (IOException e) {
@@ -317,6 +321,53 @@ public GroupScan applyFilter(LogicalExpression filterExpr, UdfUtilities udfUtili
return null;
}
}
+
+ /**
+ * Returns parquet filter predicate built from specified {@code filterExpr}.
+ *
+ * @param filterExpr filter expression to build
+ * @param udfUtilities udf utilities
+ * @param functionImplementationRegistry context to find drill function holder
+ * @param optionManager option manager
+ * @param omitUnsupportedExprs whether expressions which cannot be converted
+ * may be omitted from the resulting expression
+ * @return parquet filter predicate
+ */
+ public ParquetFilterPredicate getParquetFilterPredicate(LogicalExpression filterExpr,
+ UdfUtilities udfUtilities, FunctionImplementationRegistry functionImplementationRegistry,
+ OptionManager optionManager, boolean omitUnsupportedExprs) {
+ // used first row group to receive fields list
+ assert rowGroupInfos.size() > 0 : "row groups count cannot be 0";
+ RowGroupInfo rowGroup = rowGroupInfos.iterator().next();
+ ColumnExplorer columnExplorer = new ColumnExplorer(optionManager, columns);
+
+ Map<String, String> implicitColValues = columnExplorer.populateImplicitColumns(
+ rowGroup.getPath(),
+ getPartitionValues(rowGroup),
+ supportsFileImplicitColumns());
+
+ ParquetMetaStatCollector statCollector = new ParquetMetaStatCollector(
+ parquetTableMetadata,
+ rowGroup.getColumns(),
+ implicitColValues);
+
+ Set<SchemaPath> schemaPathsInExpr = filterExpr.accept(new ParquetRGFilterEvaluator.FieldReferenceFinder(), null);
+ Map<SchemaPath, ColumnStatistics> columnStatisticsMap = statCollector.collectColStat(schemaPathsInExpr);
+
+ ErrorCollector errorCollector = new ErrorCollectorImpl();
+ LogicalExpression materializedFilter = ExpressionTreeMaterializer.materializeFilterExpr(
+ filterExpr, columnStatisticsMap, errorCollector, functionImplementationRegistry);
+
+ if (errorCollector.hasErrors()) {
+ logger.error("{} error(s) encountered when materialize filter expression : {}",
+ errorCollector.getErrorCount(), errorCollector.toErrorString());
+ return null;
+ }
+ logger.debug("materializedFilter : {}", ExpressionStringBuilder.toString(materializedFilter));
+
+ Set<LogicalExpression> constantBoundaries = ConstantExpressionIdentifier.getConstantExpressionSet(materializedFilter);
+ return ParquetFilterBuilder.buildParquetFilterPredicate(materializedFilter, constantBoundaries, udfUtilities, omitUnsupportedExprs);
+ }
// filter push down methods block end
// limit push down methods start
diff --git a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetFilterBuilder.java b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetFilterBuilder.java
index f0f1029119e..86e207fa287 100644
--- a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetFilterBuilder.java
+++ b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetFilterBuilder.java
@@ -63,6 +63,12 @@
static final Logger logger = LoggerFactory.getLogger(ParquetFilterBuilder.class);
private final UdfUtilities udfUtilities;
+ // Flag to check whether predicate cannot be fully converted
+ // to parquet filter predicate without omitting its parts.
+ // It should be set to false for the case when we want to
+ // verify that predicate is fully convertible to parquet filter predicate,
+ // otherwise null is returned instead of the converted expression.
+ private final boolean omitUnsupportedExprs;
/**
* @param expr materialized filter expression
@@ -71,18 +77,24 @@
*
* @return parquet filter predicate
*/
- public static ParquetFilterPredicate buildParquetFilterPredicate(LogicalExpression expr, final Set<LogicalExpression> constantBoundaries, UdfUtilities udfUtilities) {
- LogicalExpression logicalExpression = expr.accept(new ParquetFilterBuilder(udfUtilities), constantBoundaries);
+ public static ParquetFilterPredicate buildParquetFilterPredicate(LogicalExpression expr,
+ Set<LogicalExpression> constantBoundaries, UdfUtilities udfUtilities, boolean omitUnsupportedExprs) {
+ LogicalExpression logicalExpression =
+ expr.accept(new ParquetFilterBuilder(udfUtilities, omitUnsupportedExprs), constantBoundaries);
if (logicalExpression instanceof ParquetFilterPredicate) {
return (ParquetFilterPredicate) logicalExpression;
+ } else if (logicalExpression instanceof TypedFieldExpr) {
+ // Calcite simplifies `= true` expression to field name, wrap it with is true predicate
+ return (ParquetFilterPredicate) ParquetIsPredicate.createIsPredicate(FunctionGenerationHelper.IS_TRUE, logicalExpression);
}
logger.debug("Logical expression {} was not qualified for filter push down", logicalExpression);
return null;
}
- private ParquetFilterBuilder(UdfUtilities udfUtilities) {
+ private ParquetFilterBuilder(UdfUtilities udfUtilities, boolean omitUnsupportedExprs) {
this.udfUtilities = udfUtilities;
+ this.omitUnsupportedExprs = omitUnsupportedExprs;
}
@Override
@@ -159,8 +171,9 @@ public LogicalExpression visitBooleanOperator(BooleanOperator op, Set<LogicalExp
for (LogicalExpression arg : op.args) {
LogicalExpression childPredicate = arg.accept(this, value);
if (childPredicate == null) {
- if (functionName.equals("booleanOr")) {
+ if (functionName.equals("booleanOr") || !omitUnsupportedExprs) {
// we can't include any leg of the OR if any of the predicates cannot be converted
+ // or prohibited omitting of unconverted operands
return null;
}
} else {
diff --git a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetPushDownFilter.java b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetPushDownFilter.java
index c59cdce8060..c12ea73129b 100644
--- a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetPushDownFilter.java
+++ b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetPushDownFilter.java
@@ -28,9 +28,7 @@
import org.apache.drill.common.expression.LogicalExpression;
import org.apache.drill.common.expression.ValueExpressions;
import org.apache.drill.exec.expr.stat.ParquetFilterPredicate;
-import org.apache.drill.exec.expr.stat.ParquetFilterPredicate.RowsMatch;
import org.apache.drill.exec.ops.OptimizerRulesContext;
-import org.apache.drill.exec.physical.base.GroupScan;
import org.apache.drill.exec.planner.common.DrillRelOptUtil;
import org.apache.drill.exec.planner.logical.DrillOptiq;
import org.apache.drill.exec.planner.logical.DrillParseContext;
@@ -134,13 +132,32 @@ protected void doOnMatch(RelOptRuleCall call, FilterPrel filter, ProjectPrel pro
// get a conjunctions of the filter condition. For each conjunction, if it refers to ITEM or FLATTEN expression
// then we could not pushed down. Otherwise, it's qualified to be pushed down.
- final List<RexNode> predList = RelOptUtil.conjunctions(condition);
+ final List<RexNode> predList = RelOptUtil.conjunctions(RexUtil.toCnf(filter.getCluster().getRexBuilder(), condition));
final List<RexNode> qualifiedPredList = new ArrayList<>();
- for (final RexNode pred : predList) {
+ // list of predicates which cannot be converted to parquet filter predicate
+ List<RexNode> nonConvertedPredList = new ArrayList<>();
+
+ for (RexNode pred : predList) {
if (DrillRelOptUtil.findOperators(pred, Collections.emptyList(), BANNED_OPERATORS) == null) {
+ LogicalExpression drillPredicate = DrillOptiq.toDrill(
+ new DrillParseContext(PrelUtil.getPlannerSettings(call.getPlanner())), scan, pred);
+
+ // checks whether predicate may be used for filter pushdown
+ ParquetFilterPredicate parquetFilterPredicate =
+ groupScan.getParquetFilterPredicate(drillPredicate,
+ optimizerContext,
+ optimizerContext.getFunctionRegistry(),
+ optimizerContext.getPlannerSettings().getOptions(), false);
+ // collects predicates that contain unsupported for filter pushdown expressions
+ // to build filter with them
+ if (parquetFilterPredicate == null) {
+ nonConvertedPredList.add(pred);
+ }
qualifiedPredList.add(pred);
+ } else {
+ nonConvertedPredList.add(pred);
}
}
@@ -155,39 +172,58 @@ protected void doOnMatch(RelOptRuleCall call, FilterPrel filter, ProjectPrel pro
Stopwatch timer = logger.isDebugEnabled() ? Stopwatch.createStarted() : null;
- final GroupScan newGroupScan = groupScan.applyFilter(conditionExp,optimizerContext,
+ AbstractParquetGroupScan newGroupScan = groupScan.applyFilter(conditionExp, optimizerContext,
optimizerContext.getFunctionRegistry(), optimizerContext.getPlannerSettings().getOptions());
if (timer != null) {
logger.debug("Took {} ms to apply filter on parquet row groups. ", timer.elapsed(TimeUnit.MILLISECONDS));
timer.stop();
}
- if (newGroupScan == null ) {
+ // For the case when newGroupScan wasn't created, the old one may
+ // fully match the filter for the case when row group pruning did not happen.
+ if (newGroupScan == null) {
+ if (groupScan.isMatchAllRowGroups()) {
+ RelNode child = project == null ? scan : project;
+ // If current row group fully matches filter,
+ // but row group pruning did not happen, remove the filter.
+ if (nonConvertedPredList.size() == 0) {
+ call.transformTo(child);
+ } else if (nonConvertedPredList.size() == predList.size()) {
+ // None of the predicates participated in filter pushdown.
+ return;
+ } else {
+ // If some of the predicates weren't used in the filter, creates new filter with them
+ // on top of current scan. Excludes the case when all predicates weren't used in the filter.
+ call.transformTo(filter.copy(filter.getTraitSet(), child,
+ RexUtil.composeConjunction(
+ filter.getCluster().getRexBuilder(),
+ nonConvertedPredList,
+ true)));
+ }
+ }
return;
}
- RelNode newScan = new ScanPrel(scan.getCluster(), scan.getTraitSet(), newGroupScan, scan.getRowType(), scan.getTable());
+ RelNode newNode = new ScanPrel(scan.getCluster(), scan.getTraitSet(), newGroupScan, scan.getRowType(), scan.getTable());
if (project != null) {
- newScan = project.copy(project.getTraitSet(), Collections.singletonList(newScan));
+ newNode = project.copy(project.getTraitSet(), Collections.singletonList(newNode));
}
- if (newGroupScan instanceof AbstractParquetGroupScan) {
- RowsMatch matchAll = RowsMatch.ALL;
- List<RowGroupInfo> rowGroupInfos = ((AbstractParquetGroupScan) newGroupScan).rowGroupInfos;
- for (RowGroupInfo rowGroup : rowGroupInfos) {
- if (rowGroup.getRowsMatch() != RowsMatch.ALL) {
- matchAll = RowsMatch.SOME;
- break;
- }
- }
- if (matchAll == ParquetFilterPredicate.RowsMatch.ALL) {
- call.transformTo(newScan);
- return;
+ if (newGroupScan.isMatchAllRowGroups()) {
+ // creates filter from the expressions which can't be pushed to the scan
+ if (nonConvertedPredList.size() > 0) {
+ newNode = filter.copy(filter.getTraitSet(), newNode,
+ RexUtil.composeConjunction(
+ filter.getCluster().getRexBuilder(),
+ nonConvertedPredList,
+ true));
}
+ call.transformTo(newNode);
+ return;
}
- final RelNode newFilter = filter.copy(filter.getTraitSet(), Collections.singletonList(newScan));
+ final RelNode newFilter = filter.copy(filter.getTraitSet(), Collections.singletonList(newNode));
call.transformTo(newFilter);
}
}
diff --git a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetRGFilterEvaluator.java b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetRGFilterEvaluator.java
index 281e86569a2..01251498a58 100644
--- a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetRGFilterEvaluator.java
+++ b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/ParquetRGFilterEvaluator.java
@@ -87,8 +87,8 @@ public static RowsMatch matches(LogicalExpression expr, Map<SchemaPath, ColumnSt
}
Set<LogicalExpression> constantBoundaries = ConstantExpressionIdentifier.getConstantExpressionSet(materializedFilter);
- ParquetFilterPredicate parquetPredicate = (ParquetFilterPredicate) ParquetFilterBuilder.buildParquetFilterPredicate(
- materializedFilter, constantBoundaries, udfUtilities);
+ ParquetFilterPredicate parquetPredicate = ParquetFilterBuilder.buildParquetFilterPredicate(
+ materializedFilter, constantBoundaries, udfUtilities, true);
return matches(parquetPredicate, columnStatisticsMap, rowCount);
}
diff --git a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/RowGroupInfo.java b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/RowGroupInfo.java
index 7d2143c1821..1c9ce107cdd 100644
--- a/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/RowGroupInfo.java
+++ b/exec/java-exec/src/main/java/org/apache/drill/exec/store/parquet/RowGroupInfo.java
@@ -19,7 +19,6 @@
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
-import org.apache.drill.exec.expr.stat.ParquetFilterPredicate.RowsMatch;
import org.apache.drill.exec.store.dfs.ReadEntryFromHDFS;
import org.apache.drill.exec.store.dfs.easy.FileWork;
import org.apache.drill.exec.store.schedule.CompleteWork;
@@ -36,7 +35,6 @@
private List<? extends ColumnMetadata> columns;
private long rowCount; // rowCount = -1 indicates to include all rows.
private long numRecordsToRead;
- private RowsMatch rowsMatch = RowsMatch.SOME;
@JsonCreator
public RowGroupInfo(@JsonProperty("path") String path,
@@ -96,8 +94,4 @@ public long getRowCount() {
public void setColumns(List<? extends ColumnMetadata> columns) {
this.columns = columns;
}
-
- public RowsMatch getRowsMatch() { return rowsMatch; }
-
- public void setRowsMatch(RowsMatch rowsMatch) { this.rowsMatch = rowsMatch; }
}
diff --git a/exec/java-exec/src/test/java/org/apache/drill/exec/store/parquet/TestParquetFilterPushDown.java b/exec/java-exec/src/test/java/org/apache/drill/exec/store/parquet/TestParquetFilterPushDown.java
index ea12f40998c..80b06d91679 100644
--- a/exec/java-exec/src/test/java/org/apache/drill/exec/store/parquet/TestParquetFilterPushDown.java
+++ b/exec/java-exec/src/test/java/org/apache/drill/exec/store/parquet/TestParquetFilterPushDown.java
@@ -70,6 +70,7 @@ public static void initFSAndCreateFragContext() throws Exception {
@AfterClass
public static void teardown() throws IOException {
+ fragContext.close();
fs.close();
}
@@ -294,6 +295,10 @@ public void testFilterPruning() throws Exception {
PlanTestBase.testPlanMatchingPatterns(sql + "a < 1 or a > 1", new String[]{"numRowGroups=3"}); // No filter pruning
PlanTestBase.testPlanMatchingPatterns(sql + "a < 1 or a > 2", new String[]{"numRowGroups=2"}, new String[]{"Filter\\("}); //Filter pruning
+
+ // Partial filter pruning
+ testParquetFilterPruning(sql + "a >=1 and cast(a as varchar) like '%3%'", 1, 2, new String[]{">\\($1, 1\\)"});
+ testParquetFilterPruning(sql + "a >=1 and a/3>=1", 2, 2, new String[]{">\\($1, 1\\)"});
}
@Test
@@ -644,6 +649,15 @@ public void testMinTrueMaxTrue() throws Exception {
assertEquals(RowsMatch.ALL, isNotFalse.matches(re));
}
+ @Test
+ public void testParquetSingleRowGroupFilterRemoving() throws Exception {
+ test("create table dfs.tmp.`singleRowGroupTable` as select * from cp.`tpch/nation.parquet`");
+
+ String query = "select * from dfs.tmp.`singleRowGroupTable` where n_nationkey > -1";
+
+ testParquetFilterPruning(query, 25, 1, new String[]{"Filter\\("});
+ }
+
//////////////////////////////////////////////////////////////////////////////////////////////////
// Some test helper functions.
//////////////////////////////////////////////////////////////////////////////////////////////////
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services