Skip to content

Commit 6201e62

Browse files
zstanzstan
committed
remove checker class
1 parent d066d4a commit 6201e62

5 files changed

Lines changed: 170 additions & 276 deletions

File tree

‎modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/SortNode.java‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
import java.util.PriorityQueue;
2323
import org.apache.calcite.rel.type.RelDataType;
2424
import org.apache.ignite.internal.processors.query.calcite.exec.ExecutionContext;
25+
import org.apache.ignite.internal.processors.query.calcite.util.IgniteMath;
2526
import org.apache.ignite.internal.util.GridBoundedPriorityQueue;
2627
import org.apache.ignite.internal.util.typedef.F;
2728

@@ -69,8 +70,8 @@ public SortNode(
6970
if (limit < 1 || limit > Integer.MAX_VALUE)
7071
rows = new PriorityQueue<>(comp);
7172
else {
72-
rows = new GridBoundedPriorityQueue<>((int)limit, comp == null ? (Comparator<Row>)Comparator.reverseOrder()
73-
: comp.reversed());
73+
rows = new GridBoundedPriorityQueue<>(IgniteMath.convertToIntExact(limit), comp == null ?
74+
(Comparator<Row>)Comparator.reverseOrder() : comp.reversed());
7475
}
7576
}
7677

‎modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/AbstractPlannerTest.java‎

Lines changed: 131 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,6 @@
2525
import java.util.Comparator;
2626
import java.util.List;
2727
import java.util.UUID;
28-
import java.util.function.Consumer;
2928
import java.util.function.Predicate;
3029
import java.util.stream.Collectors;
3130
import com.google.common.collect.ImmutableSet;
@@ -76,8 +75,8 @@
7675
import org.apache.ignite.internal.processors.query.calcite.schema.IgniteSchema;
7776
import org.apache.ignite.internal.processors.query.calcite.trait.IgniteDistribution;
7877
import org.apache.ignite.internal.processors.query.calcite.type.IgniteTypeFactory;
78+
import org.apache.ignite.internal.util.lang.RunnableX;
7979
import org.apache.ignite.internal.util.typedef.F;
80-
import org.apache.ignite.internal.util.typedef.T2;
8180
import org.apache.ignite.plugin.extensions.communication.Message;
8281
import org.apache.ignite.testframework.GridTestUtils;
8382
import org.apache.ignite.testframework.ListeningTestLogger;
@@ -225,6 +224,32 @@ protected PlanningContext plannerCtx(
225224
return plannerCtx(sql, Collections.singleton(publicSchema), planLsnr, null, disabledRules);
226225
}
227226

227+
/** */
228+
private PlanningContext plannerCtx(
229+
String sql,
230+
Collection<IgniteSchema> schemas,
231+
@Nullable RelOptListener planLsnr,
232+
Collection<Object> params,
233+
Collection<String> disabledRules
234+
) {
235+
PlanningContext.Builder ctxBuilder = PlanningContext.builder()
236+
.parentContext(Contexts.of(baseQueryContext(schemas), planLsnr))
237+
.query(sql);
238+
239+
if (params != null)
240+
ctxBuilder.parameters(params.toArray(Object[]::new));
241+
242+
PlanningContext ctx = ctxBuilder.build();
243+
244+
IgnitePlanner planner = ctx.planner();
245+
246+
assertNotNull(planner);
247+
248+
planner.addDisabledRules(disabledRules);
249+
250+
return ctx;
251+
}
252+
228253
/** */
229254
protected PlanningContext plannerCtx(
230255
String sql,
@@ -445,14 +470,31 @@ protected static TestTable createTable(IgniteSchema schema, String name, RelData
445470
return table;
446471
}
447472

473+
/** */
474+
protected <T extends RelNode> void assertPlan(
475+
TestPlanningContextBuilder ctxBuilder
476+
) throws Exception {
477+
assertPlan(ctxBuilder, rel -> true);
478+
}
479+
480+
/** */
481+
protected <T extends RelNode> void assertPlan(
482+
TestPlanningContextBuilder ctxBuilder,
483+
Predicate<T> predicate
484+
) throws Exception {
485+
invalidatePlan(ctxBuilder, predicate);
486+
}
487+
448488
/** */
449489
protected <T extends RelNode> void assertPlan(
450490
String sql,
451491
IgniteSchema schema,
452492
Predicate<T> predicate,
453493
String... disabledRules
454494
) throws Exception {
455-
assertPlan(sql, schema, null, predicate, disabledRules);
495+
TestPlanningContextBuilder builder = contextBuilder().query(sql).schema(schema).disabledRules(disabledRules);
496+
497+
assertPlan(builder, predicate);
456498
}
457499

458500
/** */
@@ -462,20 +504,34 @@ protected <T extends RelNode> void assertPlan(
462504
Predicate<T> predicate,
463505
String... disabledRules
464506
) throws Exception {
465-
assertPlan(sql, schemas, null, predicate, disabledRules);
507+
TestPlanningContextBuilder builder = contextBuilder().query(sql).schemas(schemas).disabledRules(disabledRules);
508+
509+
assertPlan(builder, predicate);
466510
}
467511

468512
/** */
469513
protected <T extends RelNode> void assertPlan(
470514
String sql,
471-
Collection<IgniteSchema> schemas,
472-
@Nullable RelOptListener planLsnr,
515+
IgniteSchema schema,
516+
RelOptListener planLsnr,
473517
Predicate<T> predicate,
474518
String... disabledRules
475519
) throws Exception {
476-
IgniteRel plan = physicalPlan(plannerCtx(sql, schemas, planLsnr, null, disabledRules));
520+
TestPlanningContextBuilder builder = contextBuilder().query(sql).schema(schema).disabledRules(disabledRules)
521+
.planListener(planLsnr);
522+
523+
assertPlan(builder, predicate);
524+
}
525+
526+
/** */
527+
private <T extends RelNode> void invalidatePlan(
528+
TestPlanningContextBuilder ctxBuilder,
529+
Predicate<T> predicate
530+
) throws Exception {
531+
IgniteRel plan = physicalPlan(plannerCtx(ctxBuilder.query, ctxBuilder.schemas, ctxBuilder.planListener,
532+
ctxBuilder.params, ctxBuilder.disabledRules));
477533

478-
checkSplitAndSerialization(plan, schemas);
534+
checkSplitAndSerialization(plan, ctxBuilder.schemas);
479535

480536
if (!predicate.test((T)plan)) {
481537
String invalidPlanMsg = "Invalid plan (" + lastErrorMsg + "):\n" +
@@ -485,17 +541,6 @@ protected <T extends RelNode> void assertPlan(
485541
}
486542
}
487543

488-
/** */
489-
protected <T extends RelNode> void assertPlan(
490-
String sql,
491-
IgniteSchema schema,
492-
@Nullable RelOptListener planLsnr,
493-
Predicate<T> predicate,
494-
String... disabledRules
495-
) throws Exception {
496-
assertPlan(sql, Collections.singletonList(schema), planLsnr, predicate, disabledRules);
497-
}
498-
499544
/**
500545
* Predicate builder for "Instance of class" condition.
501546
*/
@@ -813,48 +858,78 @@ class TestFailureProcessor extends FailureProcessor {
813858
}
814859
}
815860

816-
/**
817-
* Creates an instance of {@link StatementChecker statement checker} to test plans.
818-
* <pre>
819-
* checkStatement().sql("SELECT 1").ok()
820-
* </pre>
821-
*/
822-
public StatementChecker checkStatement() {
823-
return new PlanChecker();
824-
}
861+
/** Test planning context builder. */
862+
public static class TestPlanningContextBuilder {
863+
/** */
864+
private String query;
825865

826-
/**
827-
* Creates an instance of {@link PlanChecker statement checker} with the given setup.
828-
* A shorthand for {@code checkStatement().setup(func)}.
829-
*/
830-
public StatementChecker checkStatement(Consumer<StatementChecker> setup) {
831-
return new PlanChecker().setup(setup);
832-
}
866+
/** */
867+
private Collection<IgniteSchema> schemas;
833868

834-
/**
835-
* An implementation of {@link PlanChecker} with initialized {@link SqlPrepare} to test plans.
836-
*/
837-
public class PlanChecker extends StatementChecker {
838869
/** */
839-
PlanChecker() {
840-
super((schema, sql, params, rulesToDisable) -> {
841-
PlanningContext planningCtx = plannerCtx(sql, List.of(schema), null, params, rulesToDisable);
842-
843-
IgnitePlanner planner = planningCtx.planner();
844-
try {
845-
IgniteRel igniteRel = physicalPlan(planner, sql);
846-
return new T2<>(igniteRel, planner);
847-
}
848-
catch (Throwable t) {
849-
planner.close();
850-
throw t;
851-
}
852-
});
870+
private Collection<Object> params = List.of();
871+
872+
/** */
873+
private Collection<String> disabledRules = List.of();
874+
875+
/** */
876+
@Nullable private RelOptListener planListener;
877+
878+
/** */
879+
public TestPlanningContextBuilder query(String qry) {
880+
query = qry;
881+
return this;
853882
}
854883

855-
/** {@inheritDoc} */
856-
@Override protected void checkRel(IgniteRel igniteRel, IgnitePlanner planner, IgniteSchema schema) {
857-
checkSplitAndSerialization(igniteRel, schema);
884+
/** */
885+
public TestPlanningContextBuilder schema(IgniteSchema schemas) {
886+
this.schemas = List.of(schemas);
887+
return this;
888+
}
889+
890+
/** */
891+
public TestPlanningContextBuilder schemas(Collection<IgniteSchema> schemas) {
892+
this.schemas = List.copyOf(schemas);
893+
return this;
894+
}
895+
896+
/** */
897+
public TestPlanningContextBuilder params(Collection<Object> params) {
898+
this.params = List.copyOf(params);
899+
return this;
900+
}
901+
902+
/** */
903+
public TestPlanningContextBuilder params(Object... params) {
904+
this.params = Arrays.asList(params);
905+
return this;
858906
}
907+
908+
/** */
909+
public TestPlanningContextBuilder disabledRules(String... rules) {
910+
disabledRules = List.of(rules);
911+
return this;
912+
}
913+
914+
/** */
915+
public TestPlanningContextBuilder planListener(@Nullable RelOptListener planListener) {
916+
this.planListener = planListener;
917+
return this;
918+
}
919+
}
920+
921+
/** */
922+
public static TestPlanningContextBuilder contextBuilder() {
923+
return new TestPlanningContextBuilder();
924+
}
925+
926+
/** */
927+
@SuppressWarnings("ThrowableNotThrown")
928+
static void assertThrows(
929+
RunnableX run,
930+
Class<? extends Throwable> cls,
931+
@Nullable String msg
932+
) {
933+
GridTestUtils.assertThrows(null, run, cls, msg);
859934
}
860935
}

‎modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/DynamicParametersPlannerTest.java‎

Lines changed: 35 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -18,55 +18,68 @@
1818
package org.apache.ignite.internal.processors.query.calcite.planner;
1919

2020
import java.math.BigInteger;
21-
import java.util.function.Consumer;
21+
import org.apache.ignite.IgniteException;
22+
import org.apache.ignite.internal.processors.query.calcite.schema.IgniteSchema;
2223
import org.junit.Test;
2324

25+
import static org.apache.ignite.internal.processors.query.calcite.trait.IgniteDistributions.single;
26+
2427
/** */
2528
public class DynamicParametersPlannerTest extends AbstractPlannerTest {
2629
/** Dynamic parameters in LIMIT / OFFSET. */
2730
@Test
2831
public void testLimitOffset() throws Exception {
29-
Consumer<StatementChecker> setup = (checker) -> {
30-
checker.table("T1", "c1", Integer.class);
31-
};
32+
IgniteSchema schema = createSchema(createTable("T1", single(), "c1", Integer.class));
3233

33-
checkStatement(setup).sql("SELECT * FROM t1 LIMIT ?", Long.MAX_VALUE).ok();
34+
TestPlanningContextBuilder builder = contextBuilder().query("SELECT * FROM t1 LIMIT ?").schema(schema);
3435

35-
// Strange case, count of dynamic parameters need to be invalidated. After fix this check need to be removed.
36-
checkStatement(setup).sql("SELECT * FROM t1 LIMIT ?", Long.MAX_VALUE, -1).ok();
36+
assertPlan(builder.params(Long.MAX_VALUE));
3737

38-
checkStatement(setup).sql("SELECT * FROM t1 LIMIT ?", "a").fails(
39-
"Incorrect type of a dynamic parameter. Expected <BIGINT> but got <VARCHAR>");
38+
// Count of dynamic parameters need to be invalidated, remove it after: IGNITE-28906
39+
assertPlan(builder.params(Long.MAX_VALUE, -1));
4040

41-
checkStatement(setup).sql("SELECT * FROM t1 OFFSET ?", "a").fails(
41+
assertThrows(() -> assertPlan(builder.params("a")), IgniteException.class,
4242
"Incorrect type of a dynamic parameter. Expected <BIGINT> but got <VARCHAR>");
4343

4444
BigInteger moreThanMaxLong = BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE);
4545

46-
checkStatement(setup).sql("SELECT * FROM t1 LIMIT ?", moreThanMaxLong).fails(
46+
assertThrows(() -> assertPlan(builder.params(moreThanMaxLong)), IgniteException.class,
47+
"Illegal value of fetch / limit");
48+
49+
assertThrows(() -> assertPlan(builder.params(-1)), IgniteException.class,
4750
"Illegal value of fetch / limit");
4851

49-
checkStatement(setup).sql("SELECT * FROM t1 OFFSET ?", moreThanMaxLong).fails(
52+
assertThrows(() -> assertPlan(builder.params((Object)null)), IgniteException.class,
53+
"Incorrect type of a dynamic parameter. Expected <BIGINT> but got <null>");
54+
55+
// OFFSET.
56+
builder.query("SELECT * FROM t1 OFFSET ?");
57+
58+
assertThrows(() -> assertPlan(builder.params(moreThanMaxLong)), IgniteException.class,
5059
"Illegal value of offset");
5160

52-
checkStatement(setup).sql("SELECT * FROM t1 OFFSET ? ROWS", moreThanMaxLong).fails(
61+
assertThrows(() -> assertPlan(builder.params(-1)), IgniteException.class,
5362
"Illegal value of offset");
5463

55-
checkStatement(setup).sql("SELECT * FROM t1 LIMIT ?", -1).fails(
56-
"Illegal value of fetch / limit");
64+
assertThrows(() -> assertPlan(builder.params((Object)null)), IgniteException.class,
65+
"Incorrect type of a dynamic parameter. Expected <BIGINT> but got <null>");
66+
67+
// OFFSET Alternate syntax.
68+
builder.query("SELECT * FROM t1 OFFSET ? ROWS");
5769

58-
checkStatement(setup).sql("SELECT * FROM t1 OFFSET ?", -1).fails(
70+
assertThrows(() -> assertPlan(builder.params(moreThanMaxLong)), IgniteException.class,
5971
"Illegal value of offset");
6072

61-
checkStatement(setup).sql("SELECT * FROM t1 LIMIT ?", (Object)null).fails(
62-
"Incorrect type of a dynamic parameter. Expected <BIGINT> but got <null>");
73+
assertThrows(() -> assertPlan(builder.params(-1)), IgniteException.class,
74+
"Illegal value of offset");
6375

64-
checkStatement(setup).sql("SELECT * FROM t1 OFFSET ?", (Object)null).fails(
76+
assertThrows(() -> assertPlan(builder.params((Object)null)), IgniteException.class,
6577
"Incorrect type of a dynamic parameter. Expected <BIGINT> but got <null>");
6678

67-
checkStatement(setup).sql("SELECT * FROM t1 OFFSET ? ROWS", (Object)null).fails(
68-
"Incorrect type of a dynamic parameter. Expected <BIGINT> but got <null>");
79+
// Expression.
80+
builder.query("SELECT * FROM TEST_REPL OFFSET 2+? ROWS");
6981

70-
checkStatement(setup).sql("SELECT * FROM TEST_REPL OFFSET 2+? ROWS", 1).fails("Encountered \"+\"");
82+
assertThrows(() -> assertPlan(builder), IgniteException.class,
83+
"Encountered \" \"+\"");
7184
}
7285
}

‎modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/HashJoinPlannerTest.java‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,6 @@
3131
import org.junit.Test;
3232

3333
import static org.apache.calcite.rel.RelFieldCollation.Direction.ASCENDING;
34-
import static org.apache.ignite.testframework.GridTestUtils.assertThrows;
3534

3635
/** */
3736
public class HashJoinPlannerTest extends AbstractPlannerTest {
@@ -148,7 +147,7 @@ public void testHashJoinApplied() throws Exception {
148147
if (canBePlanned)
149148
assertPlan(sql0, schema, nodeOrAnyChild(isInstanceOf(IgniteHashJoin.class)), DISABLED_RULES);
150149
else {
151-
assertThrows(null, () -> physicalPlan(sql0, schema, DISABLED_RULES), CannotPlanException.class,
150+
assertThrows(() -> physicalPlan(sql0, schema, DISABLED_RULES), CannotPlanException.class,
152151
"There are not enough rules");
153152
}
154153
}

0 commit comments

Comments
 (0)