This is an automated email from the ASF dual-hosted git repository.
kgyrtkirk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/druid.git
The following commit(s) were added to refs/heads/master by this push:
new 6710451564b Fix applyPolicies in DruidRel (#17757)
6710451564b is described below
commit 6710451564be9d5f39dfffe9f5e167bb51ab8c55
Author: Cece Mei <[email protected]>
AuthorDate: Wed Feb 26 00:28:56 2025 -0800
Fix applyPolicies in DruidRel (#17757)
---
.../planner/querygen/DruidQueryGenerator.java | 2 +-
.../sql/calcite/rel/DruidCorrelateUnnestRel.java | 7 +-
.../druid/sql/calcite/rel/DruidJoinQueryRel.java | 6 +-
.../druid/sql/calcite/rel/DruidOuterQueryRel.java | 6 +-
.../apache/druid/sql/calcite/rel/DruidQuery.java | 6 +-
.../druid/sql/calcite/rel/DruidQueryRel.java | 11 +-
.../sql/calcite/rel/DruidUnionDataSourceRel.java | 9 +-
.../druid/sql/calcite/rel/PartialDruidQuery.java | 12 +-
.../apache/druid/sql/calcite/rel/DruidRelTest.java | 286 +++++++++++++++++++++
9 files changed, 319 insertions(+), 26 deletions(-)
diff --git
a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java
b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java
index ddf84f21590..7948e08a77c 100644
---
a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java
+++
b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java
@@ -313,7 +313,7 @@ public class DruidQueryGenerator
plannerContext,
rexBuilder,
!(topLevel) && tweaks.finalizeSubQuery(),
- false
+ true
);
}
diff --git
a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidCorrelateUnnestRel.java
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidCorrelateUnnestRel.java
index 37872ee302f..0f3370cf622 100644
---
a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidCorrelateUnnestRel.java
+++
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidCorrelateUnnestRel.java
@@ -78,7 +78,7 @@ import java.util.stream.Collectors;
*/
public class DruidCorrelateUnnestRel extends DruidRel<DruidCorrelateUnnestRel>
{
- private static final TableDataSource DUMMY_DATA_SOURCE = new
TableDataSource("__correlate_unnest__")
+ static final TableDataSource DUMMY_DATA_SOURCE = new
TableDataSource("__correlate_unnest__")
{
@Override
public boolean isConcrete()
@@ -317,8 +317,7 @@ public class DruidCorrelateUnnestRel extends
DruidRel<DruidCorrelateUnnestRel>
getPlannerContext(),
getCluster().getRexBuilder(),
finalizeAggregations,
- null,
- false
+ true
);
}
@@ -340,7 +339,7 @@ public class DruidCorrelateUnnestRel extends
DruidRel<DruidCorrelateUnnestRel>
getPlannerContext(),
getCluster().getRexBuilder(),
false,
- true
+ false
);
}
diff --git
a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidJoinQueryRel.java
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidJoinQueryRel.java
index 4a1e3bf81da..b74065094d0 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidJoinQueryRel.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidJoinQueryRel.java
@@ -249,8 +249,8 @@ public class DruidJoinQueryRel extends
DruidRel<DruidJoinQueryRel>
getPlannerContext(),
getCluster().getRexBuilder(),
finalizeAggregations,
- sourceDesc.virtualColumnRegistry,
- false
+ true,
+ sourceDesc.virtualColumnRegistry
);
}
@@ -266,7 +266,7 @@ public class DruidJoinQueryRel extends
DruidRel<DruidJoinQueryRel>
getPlannerContext(),
getCluster().getRexBuilder(),
false,
- true
+ false
);
}
diff --git
a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidOuterQueryRel.java
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidOuterQueryRel.java
index 3e1a28b7b15..8e4be94960e 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidOuterQueryRel.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidOuterQueryRel.java
@@ -47,7 +47,7 @@ import java.util.Set;
*/
public class DruidOuterQueryRel extends DruidRel<DruidOuterQueryRel>
{
- private static final TableDataSource DUMMY_DATA_SOURCE = new
TableDataSource("__subquery__")
+ static final TableDataSource DUMMY_DATA_SOURCE = new
TableDataSource("__subquery__")
{
@Override
public boolean isConcrete()
@@ -120,7 +120,7 @@ public class DruidOuterQueryRel extends
DruidRel<DruidOuterQueryRel>
getPlannerContext(),
getCluster().getRexBuilder(),
finalizeAggregations,
- false
+ true
);
}
@@ -136,7 +136,7 @@ public class DruidOuterQueryRel extends
DruidRel<DruidOuterQueryRel>
getPlannerContext(),
getCluster().getRexBuilder(),
false,
- true
+ false
);
}
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java
index 0a3a928b1b4..5d068d3fe0a 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQuery.java
@@ -206,8 +206,8 @@ public class DruidQuery
final PlannerContext plannerContext,
final RexBuilder rexBuilder,
final boolean finalizeAggregations,
- @Nullable VirtualColumnRegistry virtualColumnRegistry,
- final boolean applyPolicies
+ final boolean applyPolicies,
+ @Nullable VirtualColumnRegistry virtualColumnRegistry
)
{
final RelDataType outputRowType = partialQuery.leafRel().getRowType();
@@ -303,7 +303,7 @@ public class DruidQuery
}
return new DruidQuery(
- applyPolicies ? dataSource :
dataSource.withPolicies(plannerContext.getAuthorizationResult().getPolicyMap()),
+ applyPolicies ?
dataSource.withPolicies(plannerContext.getAuthorizationResult().getPolicyMap())
: dataSource,
plannerContext,
filter,
selectProjection,
diff --git
a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQueryRel.java
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQueryRel.java
index 498c8402321..4ccf944e254 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQueryRel.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQueryRel.java
@@ -132,14 +132,21 @@ public class DruidQueryRel extends DruidRel<DruidQueryRel>
getPlannerContext(),
getCluster().getRexBuilder(),
finalizeAggregations,
- false
+ true
);
}
@Override
public DruidQuery toDruidQueryForExplaining()
{
- return toDruidQuery(false);
+ return partialQuery.build(
+ druidTable.getDataSource(),
+ druidTable.getRowSignature(),
+ getPlannerContext(),
+ getCluster().getRexBuilder(),
+ false,
+ false
+ );
}
@Override
diff --git
a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidUnionDataSourceRel.java
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidUnionDataSourceRel.java
index f815779db16..904149f1b1b 100644
---
a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidUnionDataSourceRel.java
+++
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidUnionDataSourceRel.java
@@ -32,6 +32,7 @@ import org.apache.calcite.rel.metadata.RelMetadataQuery;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.druid.java.util.common.StringUtils;
import org.apache.druid.query.DataSource;
+import org.apache.druid.query.RestrictedDataSource;
import org.apache.druid.query.TableDataSource;
import org.apache.druid.query.UnionDataSource;
import org.apache.druid.segment.column.RowSignature;
@@ -54,7 +55,7 @@ import java.util.stream.Collectors;
*/
public class DruidUnionDataSourceRel extends DruidRel<DruidUnionDataSourceRel>
{
- private static final TableDataSource DUMMY_DATA_SOURCE = new
TableDataSource("__union__");
+ static final TableDataSource DUMMY_DATA_SOURCE = new
TableDataSource("__union__");
private final Union unionRel;
private final List<String> unionColumnNames;
private final PartialDruidQuery partialQuery;
@@ -130,7 +131,7 @@ public class DruidUnionDataSourceRel extends
DruidRel<DruidUnionDataSourceRel>
final DruidQuery query = druidRel.toDruidQuery(false);
final DataSource dataSource = query.getDataSource();
- if (!(dataSource instanceof TableDataSource)) {
+ if (!(dataSource instanceof TableDataSource) && !(dataSource instanceof
RestrictedDataSource)) {
getPlannerContext().setPlanningError("SQL requires union with input of
'%s' type that is not supported."
+ " Union operation is only supported between regular tables.
",
dataSource.getClass().getSimpleName());
@@ -166,7 +167,7 @@ public class DruidUnionDataSourceRel extends
DruidRel<DruidUnionDataSourceRel>
getPlannerContext(),
getCluster().getRexBuilder(),
finalizeAggregations,
- false
+ true
);
}
@@ -182,7 +183,7 @@ public class DruidUnionDataSourceRel extends
DruidRel<DruidUnionDataSourceRel>
getPlannerContext(),
getCluster().getRexBuilder(),
false,
- true
+ false
);
}
diff --git
a/sql/src/main/java/org/apache/druid/sql/calcite/rel/PartialDruidQuery.java
b/sql/src/main/java/org/apache/druid/sql/calcite/rel/PartialDruidQuery.java
index 6ab804552e2..cabef87a912 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/PartialDruidQuery.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/PartialDruidQuery.java
@@ -530,8 +530,8 @@ public class PartialDruidQuery
plannerContext,
rexBuilder,
finalizeAggregations,
- null,
- applyPolicies
+ applyPolicies,
+ null
);
}
@@ -541,8 +541,8 @@ public class PartialDruidQuery
final PlannerContext plannerContext,
final RexBuilder rexBuilder,
final boolean finalizeAggregations,
- @Nullable VirtualColumnRegistry virtualColumnRegistry,
- final boolean applyPolicies
+ final boolean applyPolicies,
+ @Nullable VirtualColumnRegistry virtualColumnRegistry
)
{
return DruidQuery.fromPartialQuery(
@@ -552,8 +552,8 @@ public class PartialDruidQuery
plannerContext,
rexBuilder,
finalizeAggregations,
- virtualColumnRegistry,
- applyPolicies
+ applyPolicies,
+ virtualColumnRegistry
);
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
new file mode 100644
index 00000000000..549484b5f9a
--- /dev/null
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
@@ -0,0 +1,286 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.sql.calcite.rel;
+
+import com.fasterxml.jackson.databind.json.JsonMapper;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.core.Correlate;
+import org.apache.calcite.rel.core.CorrelationId;
+import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.rel.logical.LogicalCorrelate;
+import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalTableScan;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeFieldImpl;
+import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.rel.type.RelRecordType;
+import org.apache.calcite.rel.type.StructKind;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.sql.type.BasicSqlType;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.util.ImmutableBitSet;
+import org.apache.druid.math.expr.Expr;
+import org.apache.druid.math.expr.ExprEval;
+import org.apache.druid.query.JoinAlgorithm;
+import org.apache.druid.query.JoinDataSource;
+import org.apache.druid.query.QueryDataSource;
+import org.apache.druid.query.RestrictedDataSource;
+import org.apache.druid.query.TableDataSource;
+import org.apache.druid.query.UnionDataSource;
+import org.apache.druid.query.UnnestDataSource;
+import org.apache.druid.query.policy.Policy;
+import org.apache.druid.segment.column.ColumnType;
+import org.apache.druid.segment.column.RowSignature;
+import org.apache.druid.server.security.AuthorizationResult;
+import org.apache.druid.sql.calcite.planner.ExpressionParser;
+import org.apache.druid.sql.calcite.planner.PlannerConfig;
+import org.apache.druid.sql.calcite.planner.PlannerContext;
+import org.apache.druid.sql.calcite.rel.logical.DruidUnion;
+import org.apache.druid.sql.calcite.table.DatasourceTable;
+import
org.apache.druid.sql.calcite.table.DatasourceTable.PhysicalDatasourceMetadata;
+import org.apache.druid.sql.calcite.table.DruidTable;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.Optional;
+
+import static
org.apache.druid.sql.calcite.util.CalciteTests.POLICY_RESTRICTION;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+public class DruidRelTest
+{
+ private static final RowSignature ROW_SIGNATURE =
RowSignature.builder().add("col1", ColumnType.LONG).build();
+ private static final RelDataType LONG_TYPE = new
BasicSqlType(RelDataTypeSystem.DEFAULT, SqlTypeName.BIGINT);
+ private static final RelDataTypeFieldImpl COL1_FIELD = new
RelDataTypeFieldImpl("col1", 0, LONG_TYPE);
+ private static final RelRecordType REC_TYPE = new
RelRecordType(StructKind.NONE, ImmutableList.of(COL1_FIELD), true);
+ private static final RelDataTypeFactory DEFAULT_TYPE_FACTORY = new
JavaTypeFactoryImpl();
+ private static final RexLiteral ALWAYS_TRUE = new
RexBuilder(DEFAULT_TYPE_FACTORY).makeLiteral(true);
+ private static final Expr EXPR_6L = ExprEval.ofLong(6).toExpr();
+ private static final TableDataSource TABLE =
TableDataSource.create("restricted_foo");
+ private static final RestrictedDataSource RESTRICTED =
RestrictedDataSource.create(TABLE, POLICY_RESTRICTION);
+ private static final PhysicalDatasourceMetadata RESTRICTED_METADATA = new
PhysicalDatasourceMetadata(
+ TABLE,
+ ROW_SIGNATURE,
+ true,
+ false
+ );
+ private static final DruidTable DRUID_TABLE = new
DatasourceTable(RESTRICTED_METADATA);
+ private static final ImmutableMap<String, Optional<Policy>> RESTRICTIONS =
ImmutableMap.of(
+ "restricted_foo",
+ Optional.of(POLICY_RESTRICTION)
+ );
+ private static final AuthorizationResult AUTHORIZATION_RESULT =
AuthorizationResult.allowWithRestriction(RESTRICTIONS);
+
+
+ @Mock
+ private RelOptTable mockRelOptTable;
+ @Mock
+ private RelOptCluster mockRelOptCluster;
+ @Mock
+ private RelTraitSet mockRelTraitSet;
+
+ @Mock
+ private PlannerContext mockPlannerContext;
+ private DruidQueryRel druidQueryRelNode;
+
+ @Before
+ public void setup() throws Exception
+ {
+ MockitoAnnotations.openMocks(this);
+ when(mockRelOptCluster.getTypeFactory()).thenReturn(DEFAULT_TYPE_FACTORY);
+ when(mockRelOptTable.getRowType()).thenReturn(REC_TYPE);
+
+
when(mockPlannerContext.getPlannerConfig()).thenReturn(PlannerConfig.builder().build());
+
when(mockPlannerContext.getJsonMapper()).thenReturn(JsonMapper.builder().build());
+
when(mockPlannerContext.getAuthorizationResult()).thenReturn(AUTHORIZATION_RESULT);
+
+ LogicalTableScan logicalTableScan = new LogicalTableScan(
+ mockRelOptCluster,
+ mockRelTraitSet,
+ ImmutableList.of(),
+ mockRelOptTable
+ );
+ druidQueryRelNode = DruidQueryRel.scanTable(
+ logicalTableScan,
+ mockRelOptTable,
+ DRUID_TABLE,
+ mockPlannerContext
+ );
+ }
+
+ @Test
+ public void testDruidQueryRel()
+ {
+ DruidQuery queryForExplaining =
druidQueryRelNode.toDruidQueryForExplaining();
+ DruidQuery query = druidQueryRelNode.toDruidQuery(true);
+
+ // explain query should return a TableDataSource.
+ Assert.assertEquals(TABLE, queryForExplaining.getDataSource());
+ // query should return a RestrictedDataSource.
+ Assert.assertEquals(RESTRICTED, query.getDataSource());
+ }
+
+ @Test
+ public void testDruidJoinQueryRel()
+ {
+ // Arrange
+
when(mockPlannerContext.getJoinAlgorithm()).thenReturn(JoinAlgorithm.SORT_MERGE);
+ mockExpressionParser();
+ LogicalJoin logicalJoin = LogicalJoin.create(
+ druidQueryRelNode,
+ druidQueryRelNode,
+ ImmutableList.of(),
+ ALWAYS_TRUE,
+ ImmutableSet.of(),
+ JoinRelType.INNER
+ );
+ DruidJoinQueryRel joinRel = DruidJoinQueryRel.create(logicalJoin, null,
mockPlannerContext);
+
+ // Act
+ DruidQuery queryForExplaining = joinRel.toDruidQueryForExplaining();
+ DruidQuery query = joinRel.toDruidQuery(false);
+
+ // Assert
+ Assert.assertEquals(DruidJoinQueryRel.DUMMY_DATA_SOURCE,
queryForExplaining.getDataSource());
+ JoinDataSource dataSource = (JoinDataSource) query.getDataSource();
+ Assert.assertEquals(RESTRICTED, ((QueryDataSource)
dataSource.getLeft()).getQuery().getDataSource());
+ Assert.assertEquals(RESTRICTED, ((QueryDataSource)
dataSource.getRight()).getQuery().getDataSource());
+ }
+
+ @Test
+ public void testDruidUnionQueryRel()
+ {
+ // Arrange
+ DruidUnion union = new DruidUnion(
+ mockRelOptCluster,
+ mockRelTraitSet,
+ ImmutableList.of(),
+ ImmutableList.of(druidQueryRelNode, druidQueryRelNode),
+ true
+ );
+ DruidUnionDataSourceRel rel = DruidUnionDataSourceRel.create(union,
ImmutableList.of("col1"), mockPlannerContext);
+
+ // Act
+ DruidQuery queryForExplaining = rel.toDruidQueryForExplaining();
+ DruidQuery query = rel.toDruidQuery(false);
+
+ // Assert
+ Assert.assertEquals(DruidUnionDataSourceRel.DUMMY_DATA_SOURCE,
queryForExplaining.getDataSource());
+ Assert.assertEquals(new UnionDataSource(ImmutableList.of(RESTRICTED,
RESTRICTED)), query.getDataSource());
+ }
+
+ @Test
+ public void testDruidOuterQueryRel()
+ {
+ // Arrange
+ PartialDruidQuery partialDruidQuerySpy =
spy(druidQueryRelNode.getPartialDruidQuery());
+ when(partialDruidQuerySpy.getTraitSet(any(),
any())).thenReturn(mockRelTraitSet);
+ when(mockRelTraitSet.containsIfApplicable(any())).thenReturn(true);
+ PartialDruidQuery inputQuery = PartialDruidQuery.createOuterQuery(
+ partialDruidQuerySpy,
+ druidQueryRelNode.getPlannerContext()
+ );
+ DruidOuterQueryRel rel = DruidOuterQueryRel.create(druidQueryRelNode,
inputQuery);
+
+ // Act
+ DruidQuery queryForExplaining = rel.toDruidQueryForExplaining();
+ DruidQuery query = rel.toDruidQuery(false);
+
+ // Assert
+ Assert.assertEquals(DruidOuterQueryRel.DUMMY_DATA_SOURCE,
queryForExplaining.getDataSource());
+ Assert.assertEquals(RESTRICTED, ((QueryDataSource)
query.getDataSource()).getQuery().getDataSource());
+ }
+
+ @Test
+ public void testDruidCorrelateUnnestRel()
+ {
+ // Arrange
+ mockExpressionParser();
+ DruidUnnestRel right = mock(DruidUnnestRel.class);
+ when(right.getRowType()).thenReturn(REC_TYPE);
+ when(right.getInputRexNode()).thenReturn(ALWAYS_TRUE);
+
+ Correlate correlateRel = LogicalCorrelate.create(
+ druidQueryRelNode,
+ right,
+ ImmutableList.of(),
+ mock(CorrelationId.class),
+ ImmutableBitSet.of(0),
+ JoinRelType.LEFT
+ );
+ DruidCorrelateUnnestRel rel = DruidCorrelateUnnestRel.create(correlateRel,
mockPlannerContext);
+
+ // Act
+ DruidQuery queryForExplaining = rel.toDruidQueryForExplaining();
+ DruidQuery query = rel.toDruidQuery(false);
+
+ // Assert
+ Assert.assertEquals(DruidCorrelateUnnestRel.DUMMY_DATA_SOURCE,
queryForExplaining.getDataSource());
+ Assert.assertEquals(RESTRICTED, ((UnnestDataSource)
query.getDataSource()).getBase());
+ }
+
+ @Test
+ public void testDruidUnnestRel()
+ {
+ DruidUnnestRel rel = DruidUnnestRel.create(mockRelOptCluster,
mockRelTraitSet, ALWAYS_TRUE, mockPlannerContext);
+
+ CannotBuildQueryException e1 =
Assert.assertThrows(CannotBuildQueryException.class,
rel::toDruidQueryForExplaining);
+ CannotBuildQueryException e2 =
Assert.assertThrows(CannotBuildQueryException.class, () ->
rel.toDruidQuery(false));
+ Assert.assertEquals("Cannot execute UNNEST directly", e1.getMessage());
+ Assert.assertEquals("Cannot execute UNNEST directly", e2.getMessage());
+ }
+
+ @Test
+ public void testDruidUnionRel()
+ {
+ DruidUnionRel rel = DruidUnionRel.create(mockPlannerContext, REC_TYPE,
ImmutableList.of(druidQueryRelNode), 1000);
+
+ UnsupportedOperationException e1 = Assert.assertThrows(
+ UnsupportedOperationException.class,
+ rel::toDruidQueryForExplaining
+ );
+ UnsupportedOperationException e2 = Assert.assertThrows(
+ UnsupportedOperationException.class,
+ () -> rel.toDruidQuery(false)
+ );
+ }
+
+ private void mockExpressionParser()
+ {
+ ExpressionParser parser = mock(ExpressionParser.class);
+ when(parser.parse(any())).thenReturn(EXPR_6L);
+ when(mockPlannerContext.getExpressionParser()).thenReturn(parser);
+ when(mockPlannerContext.parseExpression(any())).thenReturn(EXPR_6L);
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
