You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@calcite.apache.org by jh...@apache.org on 2023/06/10 19:18:31 UTC
[calcite] branch main updated (2e3e4ae220 -> 0f0288f4e9)
This is an automated email from the ASF dual-hosted git repository.
jhyde pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/calcite.git
from 2e3e4ae220 [CALCITE-5401] Rule fired by HepPlanner can return Volcano's RelSubset
new cf1454ddda Code style: Lint
new 0f0288f4e9 [CALCITE-5767] JDBC adapter for MSSQL adds GROUPING to ORDER BY clause twice when emulating NULLS LAST
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../test/CassandraAdapterWithoutKeyspaceTest.java | 3 +-
.../apache/calcite/test/CassandraExtension.java | 8 +--
.../calcite/adapter/enumerable/EnumUtils.java | 3 +-
.../adapter/enumerable/EnumerableMergeJoin.java | 59 +++++++++++++++-------
.../calcite/config/CalciteSystemProperty.java | 18 ++++---
.../plan/visualizer/RuleMatchVisualizer.java | 7 +--
.../apache/calcite/plan/volcano/package-info.java | 37 +++++++-------
.../java/org/apache/calcite/rel/PhysicalNode.java | 52 +++++++++----------
.../org/apache/calcite/rel/RelCollationImpl.java | 5 +-
.../main/java/org/apache/calcite/rel/RelNode.java | 4 +-
.../metadata/ProxyingMetadataHandlerProvider.java | 2 +-
.../calcite/rel/metadata/RelMetadataProvider.java | 19 ++++---
.../rel/metadata/janino/CacheGeneratorUtil.java | 38 ++++++++------
.../calcite/rel/rel2sql/RelToSqlConverter.java | 4 +-
.../apache/calcite/rel/rel2sql/SqlImplementor.java | 2 +-
.../rel/rules/JoinDeriveIsNotNullFilterRule.java | 10 ++--
.../apache/calcite/rel/rules/PruneEmptyRules.java | 13 +++--
.../java/org/apache/calcite/rex/RexChecker.java | 2 +-
.../java/org/apache/calcite/rex/package-info.java | 4 +-
.../calcite/sql/dialect/MssqlSqlDialect.java | 5 --
.../java/org/apache/calcite/sql/package-info.java | 25 ++++-----
.../calcite/sql/type/SqlTypeCoercionRule.java | 4 +-
.../org/apache/calcite/sql/validate/ListScope.java | 10 ++--
.../calcite/sql/validate/SqlValidatorImpl.java | 6 +--
.../sql/validate/implicit/TypeCoercionImpl.java | 8 +--
.../calcite/sql2rel/CorrelateProjectExtractor.java | 19 ++++---
.../apache/calcite/sql2rel/SqlToRelConverter.java | 20 ++++----
.../java/org/apache/calcite/tools/RelBuilder.java | 2 +-
.../main/java/org/apache/calcite/util/Util.java | 16 +++---
.../calcite/rel/rel2sql/RelToSqlConverterTest.java | 24 +++++++++
.../java/org/apache/calcite/test/LintTest.java | 28 +++++++++-
.../org/apache/calcite/test/RelOptRulesTest.java | 24 ++++-----
.../calcite/test/concurrent/package-info.java | 9 ++--
.../elasticsearch/EmbeddedElasticsearchPolicy.java | 5 +-
.../apache/calcite/linq4j/EnumerableDefaults.java | 10 ++--
.../calcite/linq4j/function/NonDeterministic.java | 4 +-
.../calcite/adapter/redis/RedisCaseBase.java | 6 +--
.../calcite/benchmarks/MetadataBenchmark.java | 3 +-
38 files changed, 308 insertions(+), 210 deletions(-)
[calcite] 01/02: Code style: Lint
Posted by jh...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jhyde pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/calcite.git
commit cf1454dddae7264d381018f10eaef01328e73703
Author: Julian Hyde <jh...@apache.org>
AuthorDate: Sat Jun 10 11:04:38 2023 -0700
Code style: Lint
If a block of text in javadoc is preceded by a blank line, and is not
inside '<blockquote>' or '<ul>', the block must start with '<p>'.
---
.../test/CassandraAdapterWithoutKeyspaceTest.java | 3 +-
.../apache/calcite/test/CassandraExtension.java | 8 +--
.../calcite/adapter/enumerable/EnumUtils.java | 3 +-
.../adapter/enumerable/EnumerableMergeJoin.java | 59 +++++++++++++++-------
.../calcite/config/CalciteSystemProperty.java | 18 ++++---
.../plan/visualizer/RuleMatchVisualizer.java | 7 +--
.../apache/calcite/plan/volcano/package-info.java | 37 +++++++-------
.../java/org/apache/calcite/rel/PhysicalNode.java | 52 +++++++++----------
.../org/apache/calcite/rel/RelCollationImpl.java | 5 +-
.../main/java/org/apache/calcite/rel/RelNode.java | 4 +-
.../metadata/ProxyingMetadataHandlerProvider.java | 2 +-
.../calcite/rel/metadata/RelMetadataProvider.java | 19 ++++---
.../rel/metadata/janino/CacheGeneratorUtil.java | 38 ++++++++------
.../calcite/rel/rel2sql/RelToSqlConverter.java | 4 +-
.../apache/calcite/rel/rel2sql/SqlImplementor.java | 2 +-
.../rel/rules/JoinDeriveIsNotNullFilterRule.java | 10 ++--
.../apache/calcite/rel/rules/PruneEmptyRules.java | 13 +++--
.../java/org/apache/calcite/rex/RexChecker.java | 2 +-
.../java/org/apache/calcite/rex/package-info.java | 4 +-
.../java/org/apache/calcite/sql/package-info.java | 25 ++++-----
.../calcite/sql/type/SqlTypeCoercionRule.java | 4 +-
.../org/apache/calcite/sql/validate/ListScope.java | 10 ++--
.../calcite/sql/validate/SqlValidatorImpl.java | 6 +--
.../sql/validate/implicit/TypeCoercionImpl.java | 8 +--
.../calcite/sql2rel/CorrelateProjectExtractor.java | 19 ++++---
.../apache/calcite/sql2rel/SqlToRelConverter.java | 20 ++++----
.../java/org/apache/calcite/tools/RelBuilder.java | 2 +-
.../main/java/org/apache/calcite/util/Util.java | 16 +++---
.../java/org/apache/calcite/test/LintTest.java | 28 +++++++++-
.../org/apache/calcite/test/RelOptRulesTest.java | 24 ++++-----
.../calcite/test/concurrent/package-info.java | 9 ++--
.../elasticsearch/EmbeddedElasticsearchPolicy.java | 5 +-
.../apache/calcite/linq4j/EnumerableDefaults.java | 10 ++--
.../calcite/linq4j/function/NonDeterministic.java | 4 +-
.../calcite/adapter/redis/RedisCaseBase.java | 6 +--
.../calcite/benchmarks/MetadataBenchmark.java | 3 +-
36 files changed, 284 insertions(+), 205 deletions(-)
diff --git a/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterWithoutKeyspaceTest.java b/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterWithoutKeyspaceTest.java
index 8822e9dbe6..79f1400b6d 100644
--- a/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterWithoutKeyspaceTest.java
+++ b/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterWithoutKeyspaceTest.java
@@ -30,8 +30,7 @@ import org.junit.jupiter.api.parallel.ExecutionMode;
/**
* Tests for the {@code org.apache.calcite.adapter.cassandra} package.
*
- *
- * Instantiates a CQL session without keyspace, but passes it to
+ * <p>Instantiates a CQL session without keyspace, but passes it to
* {@code org.apache.calcite.adapter.cassandra.CassandraTable}.
* All generated CQL queries should still succeed and explicitly
* reference the keyspace.
diff --git a/cassandra/src/test/java/org/apache/calcite/test/CassandraExtension.java b/cassandra/src/test/java/org/apache/calcite/test/CassandraExtension.java
index 73f19b49cc..7a55e472da 100644
--- a/cassandra/src/test/java/org/apache/calcite/test/CassandraExtension.java
+++ b/cassandra/src/test/java/org/apache/calcite/test/CassandraExtension.java
@@ -146,10 +146,12 @@ class CassandraExtension implements ParameterResolver, ExecutionCondition {
}
/**
- * Best effort to gracefully shutdown <strong>embedded</strong> cassandra cluster.
+ * Best effort to gracefully shutdown <strong>embedded</strong> cassandra
+ * cluster.
*
- * Since it uses many static variables as well as {@link System#exit(int)} during close,
- * clean shutdown (as part of unit test) is not straightforward.
+ * <p>Since it uses many static variables as well as {@link System#exit(int)}
+ * during close, clean shutdown (as part of unit test) is not
+ * straightforward.
*/
@Override public void close() throws IOException {
session.close();
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java
index 70e99deeb8..c4f97ae9d3 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java
@@ -794,7 +794,8 @@ public class EnumUtils {
* Generates a window selector which appends attribute of the window based on
* the parameters.
*
- * Note that it only works for batch scenario. E.g. all data is known and there is no late data.
+ * <p>Note that it only works for batch scenario. E.g. all data is known and
+ * there is no late data.
*/
static Expression tumblingWindowSelector(
PhysType inputPhysType,
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoin.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoin.java
index caa6509921..d3f45d8d31 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoin.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoin.java
@@ -149,42 +149,66 @@ public class EnumerableMergeJoin extends Join implements EnumerableRel {
/**
* Pass collations through can have three cases:
- * 1. If sort keys are equal to either left join keys, or right join keys,
+ *
+ * <p>1. If sort keys are equal to either left join keys, or right join keys,
* collations can be pushed to both join sides with correct mappings.
* For example, for the query
- * select * from foo join bar on foo.a=bar.b order by foo.a desc
- * after traits pass through it will be equivalent to
+ *
+ * <blockquote><pre>{@code
+ * select * from foo join bar
+ * on foo.a=bar.b
+ * order by foo.a desc
+ * }</pre></blockquote>
+ *
+ * <p>after traits pass through it will be equivalent to
+ *
+ * <blockquote><pre>{@code
* select * from
* (select * from foo order by foo.a desc)
* join
* (select * from bar order by bar.b desc)
+ * }</pre></blockquote>
*
- * 2. If sort keys are sub-set of either left join keys, or right join keys,
- * collations have to be extended to cover all joins keys before passing through,
- * because merge join requires all join keys are sorted.
+ * <p>2. If sort keys are sub-set of either left join keys, or right join
+ * keys, collations have to be extended to cover all joins keys before
+ * passing through, because merge join requires all join keys are sorted.
* For example, for the query
+ *
+ * <blockquote><pre>{@code
* select * from foo join bar
* on foo.a=bar.b and foo.c=bar.d
- * order by foo.a desc
- * after traits pass through it will be equivalent to
+ * order by foo.a desc
+ * }</pre></blockquote>
+ *
+ * <p>after traits pass through it will be equivalent to
+ *
+ * <blockquote><pre>{@code
* select * from
* (select * from foo order by foo.a desc, foo.c)
* join
* (select * from bar order by bar.b desc, bar.d)
+ * }</pre></blockquote>
*
- * 3. If sort keys are super-set of either left join keys, or right join keys,
- * but not both, collations can be completely passed to the join key whose join
- * keys match the prefix of collations. Meanwhile, partial mapped collations can
- * be passed to another join side to make sure join keys are sorted.
- * For example, for the query
+ * <p>3. If sort keys are super-set of either left join keys, or right join
+ * keys, but not both, collations can be completely passed to the join key
+ * whose join keys match the prefix of collations. Meanwhile, partial mapped
+ * collations can be passed to another join side to make sure join keys are
+ * sorted. For example, for the query
+
+ * <blockquote><pre>{@code
* select * from foo join bar
* on foo.a=bar.b and foo.c=bar.d
* order by foo.a desc, foo.c desc, foo.e
- * after traits pass through it will be equivalent to
+ * }</pre></blockquote>
+ *
+ * <p>after traits pass through it will be equivalent to
+ *
+ * <blockquote><pre>{@code
* select * from
* (select * from foo order by foo.a desc, foo.c desc, foo.e)
* join
* (select * from bar order by bar.b desc, bar.d desc)
+ * }</pre></blockquote>
*/
@Override public @Nullable Pair<RelTraitSet, List<RelTraitSet>> passThroughTraits(
final RelTraitSet required) {
@@ -354,9 +378,10 @@ public class EnumerableMergeJoin extends Join implements EnumerableRel {
* on foo.a = bar.a and foo.c=bar.c
* order by bar.a, bar.c, bar.b;
*
- * The collation [bar.a, bar.c, bar.b] can be pushed down to bar. However, only
- * [a, c] can be pushed down to foo. This function will help create [a, c] for foo by removing
- * b from the required collation, because b is not defined on join keys.
+ * <p>The collation [bar.a, bar.c, bar.b] can be pushed down to bar. However,
+ * only [a, c] can be pushed down to foo. This function will help create [a,
+ * c] for foo by removing b from the required collation, because b is not
+ * defined on join keys.
*
* @param collation collation defined on the JOIN
* @param joinKeys the join keys
diff --git a/core/src/main/java/org/apache/calcite/config/CalciteSystemProperty.java b/core/src/main/java/org/apache/calcite/config/CalciteSystemProperty.java
index 964d0cc081..4570cccf93 100644
--- a/core/src/main/java/org/apache/calcite/config/CalciteSystemProperty.java
+++ b/core/src/main/java/org/apache/calcite/config/CalciteSystemProperty.java
@@ -251,16 +251,18 @@ public final class CalciteSystemProperty<T> {
/**
* Whether to use Docker containers (https://www.testcontainers.org/) in tests.
*
- * If the property is set to <code>true</code>, affected tests will attempt to start Docker
- * containers; when Docker is not available tests fallback to other execution modes and if it's
- * not possible they are skipped entirely.
+ * <p>If the property is set to <code>true</code>, affected tests will attempt
+ * to start Docker containers; when Docker is not available tests fallback to
+ * other execution modes and if it's not possible they are skipped entirely.
*
- * If the property is set to <code>false</code>, Docker containers are not used at all and
- * affected tests either fallback to other execution modes or skipped entirely.
+ * <p>If the property is set to <code>false</code>, Docker containers are not
+ * used at all and affected tests either fallback to other execution modes or
+ * skipped entirely.
*
- * Users can override the default behavior to force non-Dockerized execution even when Docker
- * is installed on the machine; this can be useful for replicating an issue that appears only in
- * non-docker test mode or for running tests both with and without containers in CI.
+ * <p>Users can override the default behavior to force non-Dockerized
+ * execution even when Docker is installed on the machine; this can be useful
+ * for replicating an issue that appears only in non-docker test mode or for
+ * running tests both with and without containers in CI.
*/
public static final CalciteSystemProperty<Boolean> TEST_WITH_DOCKER_CONTAINER =
booleanProperty("calcite.test.docker", true);
diff --git a/core/src/main/java/org/apache/calcite/plan/visualizer/RuleMatchVisualizer.java b/core/src/main/java/org/apache/calcite/plan/visualizer/RuleMatchVisualizer.java
index d9e795996d..b1bb04f320 100644
--- a/core/src/main/java/org/apache/calcite/plan/visualizer/RuleMatchVisualizer.java
+++ b/core/src/main/java/org/apache/calcite/plan/visualizer/RuleMatchVisualizer.java
@@ -60,9 +60,10 @@ import static org.apache.calcite.util.Util.transform;
/**
* This is a tool to visualize the rule match process of a RelOptPlanner.
*
- * <pre>{@code
+ * <blockquote><pre>{@code
* // create the visualizer
- * RuleMatchVisualizer viz = new RuleMatchVisualizer("/path/to/output/dir", "file-name-suffix");
+ * RuleMatchVisualizer viz =
+ * new RuleMatchVisualizer("/path/to/output/dir", "file-name-suffix");
* viz.attachTo(planner)
*
* planner.findBestExpr();
@@ -70,7 +71,7 @@ import static org.apache.calcite.util.Util.transform;
* // extra step for HepPlanner: write the output to files
* // a VolcanoPlanner will call it automatically
* viz.writeToFile();
- * }</pre>
+ * }</pre></blockquote>
*/
public class RuleMatchVisualizer implements RelOptListener {
diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/package-info.java b/core/src/main/java/org/apache/calcite/plan/volcano/package-info.java
index 24232dc9c9..8605f1def8 100644
--- a/core/src/main/java/org/apache/calcite/plan/volcano/package-info.java
+++ b/core/src/main/java/org/apache/calcite/plan/volcano/package-info.java
@@ -210,29 +210,29 @@
*
* <ul>
*
- * <li>Registering exp 5 triggers <code>CombineProjectsRule</code>(exp 1,
- * exp 5), which creates
+ * <li>Registering exp 5 triggers <code>CombineProjectsRule</code>(exp 1,
+ * exp 5), which creates
*
- * <blockquote>
+ * <blockquote>
* <pre>Project (deptno) [exp 7, subset A]
* Filter (gender='F') [exp 6, subset E]
* Project (deptno, gender, empno, salary) [exp 4, subset D]
* TableScan (emp) [exp 0, subset X]</pre>
- * </blockquote>
- * </li>
+ * </blockquote>
+ * </li>
*
- * <li>Registering exp 6 triggers
- * <code>PushFilterThroughProjectRule</code>(exp 6, exp 4), which
- * creates
+ * <li>Registering exp 6 triggers
+ * <code>PushFilterThroughProjectRule</code>(exp 6, exp 4), which
+ * creates
*
- * <blockquote>
+ * <blockquote>
* <pre>Project (deptno) [exp 1, subset A]
* Project (deptno, gender, empno) [exp 5, subset B]
* Project (deptno, gender, empno, salary) [exp 8, subset E]
* Filter (gender='F') [exp 9, subset F]
* TableScan (emp) [exp 0, subset X]</pre>
- * </blockquote>
- * </li>
+ * </blockquote>
+ * </li>
* </ul>
*
* <p>Each rule application adds additional members to existing subsets. The
@@ -250,16 +250,17 @@
* <p>Todo: show how rules can cause subsets to merge.
*
* <p>Conclusion:
+ *
* <ol>
- * <li>A rule can be triggered by any of its operands.</li>
- * <li>If a subset is a child of more than one parent, it can trigger rule
- * matches for any of its parents.
- * </li>
+ * <li>A rule can be triggered by any of its operands.</li>
+ * <li>If a subset is a child of more than one parent, it can trigger rule
+ * matches for any of its parents.
+ * </li>
*
- * <li>Registering one relexp can trigger several rules (and even the same
- * rule several times).</li>
+ * <li>Registering one relexp can trigger several rules (and even the same
+ * rule several times).</li>
*
- * <li>Firing rules can cause subsets to merge.</li>
+ * <li>Firing rules can cause subsets to merge.</li>
* </ol>
* <h2>References</h2>
*
diff --git a/core/src/main/java/org/apache/calcite/rel/PhysicalNode.java b/core/src/main/java/org/apache/calcite/rel/PhysicalNode.java
index e90cffb04f..50da278f27 100644
--- a/core/src/main/java/org/apache/calcite/rel/PhysicalNode.java
+++ b/core/src/main/java/org/apache/calcite/rel/PhysicalNode.java
@@ -35,38 +35,38 @@ import java.util.List;
* <p>How to use?
*
* <ol>
- * <li>Enable top-down optimization by setting
- * {@link org.apache.calcite.plan.volcano.VolcanoPlanner#setTopDownOpt(boolean)}.
- * </li>
+ * <li>Enable top-down optimization by setting
+ * {@link org.apache.calcite.plan.volcano.VolcanoPlanner#setTopDownOpt(boolean)}.
+ * </li>
*
- * <li>Let your convention's rel interface extends {@link PhysicalNode},
- * see {@link org.apache.calcite.adapter.enumerable.EnumerableRel} as
- * an example.</li>
+ * <li>Let your convention's rel interface extends {@link PhysicalNode},
+ * see {@link org.apache.calcite.adapter.enumerable.EnumerableRel} as
+ * an example.</li>
*
- * <li>Each physical operator overrides any one of the two methods:
- * {@link PhysicalNode#passThrough(RelTraitSet)} or
- * {@link PhysicalNode#passThroughTraits(RelTraitSet)} depending on
- * your needs.</li>
+ * <li>Each physical operator overrides any one of the two methods:
+ * {@link PhysicalNode#passThrough(RelTraitSet)} or
+ * {@link PhysicalNode#passThroughTraits(RelTraitSet)} depending on
+ * your needs.</li>
*
- * <li>Choose derive mode for each physical operator by overriding
- * {@link PhysicalNode#getDeriveMode()}.</li>
+ * <li>Choose derive mode for each physical operator by overriding
+ * {@link PhysicalNode#getDeriveMode()}.</li>
*
- * <li>If the derive mode is {@link DeriveMode#OMAKASE}, override
- * method {@link PhysicalNode#derive(List)} in the physical operator,
- * otherwise, override {@link PhysicalNode#derive(RelTraitSet, int)}
- * or {@link PhysicalNode#deriveTraits(RelTraitSet, int)}.</li>
+ * <li>If the derive mode is {@link DeriveMode#OMAKASE}, override
+ * method {@link PhysicalNode#derive(List)} in the physical operator,
+ * otherwise, override {@link PhysicalNode#derive(RelTraitSet, int)}
+ * or {@link PhysicalNode#deriveTraits(RelTraitSet, int)}.</li>
*
- * <li>Mark your enforcer operator by overriding {@link RelNode#isEnforcer()},
- * see {@link Sort#isEnforcer()} as an example. This is important,
- * because it can help {@code VolcanoPlanner} avoid unnecessary
- * trait propagation and derivation, therefore improve optimization
- * efficiency.</li>
+ * <li>Mark your enforcer operator by overriding {@link RelNode#isEnforcer()},
+ * see {@link Sort#isEnforcer()} as an example. This is important,
+ * because it can help {@code VolcanoPlanner} avoid unnecessary
+ * trait propagation and derivation, therefore improve optimization
+ * efficiency.</li>
*
- * <li>Implement {@link Convention#enforce(RelNode, RelTraitSet)}
- * in your convention, which generates appropriate physical enforcer.
- * See {@link org.apache.calcite.adapter.enumerable.EnumerableConvention}
- * as example. Simply return {@code null} if you don't want physical
- * trait enforcement.</li>
+ * <li>Implement {@link Convention#enforce(RelNode, RelTraitSet)}
+ * in your convention, which generates appropriate physical enforcer.
+ * See {@link org.apache.calcite.adapter.enumerable.EnumerableConvention}
+ * as example. Simply return {@code null} if you don't want physical
+ * trait enforcement.</li>
* </ol>
*/
public interface PhysicalNode extends RelNode {
diff --git a/core/src/main/java/org/apache/calcite/rel/RelCollationImpl.java b/core/src/main/java/org/apache/calcite/rel/RelCollationImpl.java
index 44a78ca646..06433cd57c 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelCollationImpl.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelCollationImpl.java
@@ -121,8 +121,9 @@ public class RelCollationImpl implements RelCollation {
/**
* Applies mapping to a given collation.
*
- * If mapping destroys the collation prefix, this method returns an empty collation.
- * Examples of applying mappings to collation [0, 1]:
+ * <p>If mapping destroys the collation prefix, this method returns an empty
+ * collation. Examples of applying mappings to collation [0, 1]:
+ *
* <ul>
* <li>mapping(0, 1) => [0, 1]</li>
* <li>mapping(1, 0) => [1, 0]</li>
diff --git a/core/src/main/java/org/apache/calcite/rel/RelNode.java b/core/src/main/java/org/apache/calcite/rel/RelNode.java
index bee62a8a31..5eeece9822 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelNode.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelNode.java
@@ -232,8 +232,8 @@ public interface RelNode extends RelOptNode, Cloneable {
* The string returned is the same as
* {@link RelOptUtil#toString(org.apache.calcite.rel.RelNode)}.
*
- * This method is intended mainly for use while debugging in an IDE,
- * as a convenient short-hand for RelOptUtil.toString.
+ * <p>This method is intended mainly for use while debugging in an IDE,
+ * as a convenient shorthand for {@link RelOptUtil#toString}.
* We recommend that classes implementing this interface
* do not override this method.
*
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/ProxyingMetadataHandlerProvider.java b/core/src/main/java/org/apache/calcite/rel/metadata/ProxyingMetadataHandlerProvider.java
index ecba433ac4..92490cdd6d 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/ProxyingMetadataHandlerProvider.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/ProxyingMetadataHandlerProvider.java
@@ -36,7 +36,7 @@ import static java.util.Objects.requireNonNull;
/**
* A MetadataHandlerProvider built on a RelMetadataProvider.
*
- * Uses proxies to call the underlying metadata provider.
+ * <p>Uses proxies to call the underlying metadata provider.
*/
public class ProxyingMetadataHandlerProvider implements MetadataHandlerProvider {
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java
index f9a4e5d1f8..2fd2cbee29 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java
@@ -77,18 +77,21 @@ public interface RelMetadataProvider {
/**
* Retrieves a list of {@link MetadataHandler} for implements a particular
- * {@link MetadataHandler}.class. The resolution order is specificity of the relNode class,
- * with preference given to handlers that occur earlier in the list.
+ * {@link MetadataHandler}.class. The resolution order is specificity of the
+ * relNode class, with preference given to handlers that occur earlier in the
+ * list.
*
- * For instance, given a return list of {A, B, C} where A implements RelNode and Scan,
- * B implements Scan, and C implements LogicalScan and Filter.
+ * <p>For instance, given a return list of {A, B, C} where A implements
+ * RelNode and Scan, B implements Scan, and C implements LogicalScan and
+ * Filter.
*
- * Scan dispatches to a.method(Scan)
- * LogicalFilter dispatches to c.method(Filter).
- * LogicalScan dispatches to c.method(LogicalScan).
+ * <p>Scan dispatches to a.method(Scan);
+ * LogicalFilter dispatches to c.method(Filter);
+ * LogicalScan dispatches to c.method(LogicalScan);
* Aggregate dispatches to a.method(RelNode).
*
- * The behavior is undefined if the class hierarchy for dispatching is not a tree.
+ * <p>The behavior is undefined if the class hierarchy for dispatching is not
+ * a tree.
*/
List<MetadataHandler<?>> handlers(Class<? extends MetadataHandler<?>> handlerClass);
}
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/janino/CacheGeneratorUtil.java b/core/src/main/java/org/apache/calcite/rel/metadata/janino/CacheGeneratorUtil.java
index 262a7c7e23..939ad2ce15 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/janino/CacheGeneratorUtil.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/janino/CacheGeneratorUtil.java
@@ -222,13 +222,15 @@ class CacheGeneratorUtil {
return buff;
}
},
+
/**
* Generates an immutable key that is reused across all calls.
*
- * Example:
- * <code>
+ * <p>Example:
+ *
+ * <blockquote><pre><code>
* private final Object method_key_0 =
- * new org.apache.calcite.rel.metadata.janino.DescriptiveCacheKey("...");
+ * new org.apache.calcite.rel.metadata.janino.DescriptiveCacheKey("...");
*
* ...
*
@@ -238,7 +240,7 @@ class CacheGeneratorUtil {
* final Object key;
* key = method_key_0;
* final Object v = mq.map.get(r, key);
- * </code>
+ * </code></pre></blockquote>
*/
NO_ARG {
@Override void cacheProperties(StringBuilder buff, Method method, int methodIndex) {
@@ -257,14 +259,16 @@ class CacheGeneratorUtil {
/**
* Generates immutable cache keys for metadata calls with single enum argument.
*
- * Example:
- * <code>
+ * <p>Example:
+ *
+ * <blockquote><pre><code>
* private final Object method_key_0Null =
* new org.apache.calcite.rel.metadata.janino.DescriptiveCacheKey(
- * "Boolean isVisibleInExplain(null)");
+ * "Boolean isVisibleInExplain(null)");
* private final Object[] method_key_0 =
* org.apache.calcite.rel.metadata.janino.CacheUtil.generateEnum(
- * "Boolean isVisibleInExplain", org.apache.calcite.sql.SqlExplainLevel.values());
+ * "Boolean isVisibleInExplain",
+ * org.apache.calcite.sql.SqlExplainLevel.values());
*
* ...
*
@@ -278,7 +282,7 @@ class CacheGeneratorUtil {
* } else {
* key = method_key_0[a2.ordinal()];
* }
- * </code>
+ * </code></pre></blockquote>
*/
ENUM_ARG {
@Override void cacheKeyBlock(StringBuilder buff, Method method, int methodIndex) {
@@ -315,13 +319,14 @@ class CacheGeneratorUtil {
.append(".values());\n");
}
},
+
/**
* Generates 2 immutable keys for functions that only take a single boolean
* arg.
*
* <p>Example:
*
- * <blockquote><pre>{@code
+ * <blockquote><pre><code>
* private final Object method_key_0True =
* new org.apache.calcite.rel.metadata.janino.DescriptiveCacheKey("...");
* private final Object method_key_0False =
@@ -336,7 +341,7 @@ class CacheGeneratorUtil {
* final Object v = mq.map.get(r, key);
* ...
* }
- * }</pre></blockquote>
+ * </code></pre></blockquote>
*/
BOOLEAN_ARG {
@Override void cacheKeyBlock(StringBuilder buff, Method method, int methodIndex) {
@@ -360,11 +365,14 @@ class CacheGeneratorUtil {
newDescriptiveCacheKey(buff, method, "false");
}
},
+
/**
- * Uses a flyweight for fixed range, otherwise instantiates a new list with the arguement in it.
+ * Uses a flyweight for fixed range, otherwise instantiates a new list with
+ * the argument in it.
+ *
+ * <p>Example:
*
- * Example:
- * <code>
+ * <blockquote><pre><code>
* private final Object method_key_0 =
* new org.apache.calcite.rel.metadata.janino.DescriptiveCacheKey("...");
* private final Object[] method_key_0FlyWeight =
@@ -383,7 +391,7 @@ class CacheGeneratorUtil {
* } else {
* key = org.apache.calcite.runtime.FlatLists.of(method_key_0, a2);
* }
- * </code>
+ * </code></pre></blockquote>
*/
INT_ARG {
private final int min = -256;
diff --git a/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
index d702ff9b7a..3dd420ea27 100644
--- a/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
+++ b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
@@ -311,7 +311,7 @@ public class RelToSqlConverter extends SqlImplementor
*
* <p>For example, the following queries are equivalent:
*
- * <pre>{@code
+ * <blockquote><pre>{@code
* // Comma join
* SELECT *
* FROM Emp, Dept
@@ -323,7 +323,7 @@ public class RelToSqlConverter extends SqlImplementor
* // Inner join
* SELECT *
* FROM Emp INNER JOIN Dept ON TRUE
- * }</pre>
+ * }</pre></blockquote>
*
* <p>Examples:
* <ul>
diff --git a/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
index e90e5dacbc..6517440c5b 100644
--- a/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
+++ b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
@@ -505,7 +505,7 @@ public abstract class SqlImplementor {
*
* <pre>{@code INSERT INTO t1 SELECT x, y + 1 FROM t2}</pre>
*
- * rather than with it:
+ * <p>rather than with it:
*
* <pre>{@code INSERT INTO t1 SELECT x, y + 1 AS EXPR$0 FROM t2}</pre>
*
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/JoinDeriveIsNotNullFilterRule.java b/core/src/main/java/org/apache/calcite/rel/rules/JoinDeriveIsNotNullFilterRule.java
index 24074afddb..aec3cb34fb 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/JoinDeriveIsNotNullFilterRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/JoinDeriveIsNotNullFilterRule.java
@@ -41,11 +41,13 @@ import java.util.stream.Collectors;
* {@link org.apache.calcite.rel.core.Join} and creates
* {@link org.apache.calcite.rel.core.Filter}s with those predicates as new inputs of the join.
*
- * Since the Null value can never match in the inner join and it can lead to skewness due to
- * too many Null values, a not-null filter can be created and pushed down into the input of join.
+ * <p>Since the Null value can never match in the inner join, and it can lead to
+ * skewness due to too many Null values, a not-null filter can be created and
+ * pushed down into the input of join.
*
- * Similar to {@link CoreRules#FILTER_INTO_JOIN}, it would try to create filters and push them into
- * the inputs of the join to filter data as much as possible before join.
+ * <p>Similar to {@link CoreRules#FILTER_INTO_JOIN}, it would try to create
+ * filters and push them into the inputs of the join to filter data as much as
+ * possible before join.
*
*/
@Value.Enclosing
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java b/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
index ff208a9ccd..48b37ca74f 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
@@ -152,8 +152,9 @@ public abstract class PruneEmptyRules {
* Rule that converts a {@link org.apache.calcite.rel.core.TableScan}
* to empty if the table has no rows in it.
*
- * The rule exploits the {@link org.apache.calcite.rel.metadata.RelMdMaxRowCount} to derive if
- * the table is empty or not.
+ * <p>The rule exploits the
+ * {@link org.apache.calcite.rel.metadata.RelMdMaxRowCount} to derive if the
+ * table is empty or not.
*/
public static final RelOptRule EMPTY_TABLE_INSTANCE =
ImmutableZeroMaxRowsRuleConfig.DEFAULT.toRule();
@@ -628,10 +629,12 @@ public abstract class PruneEmptyRules {
}
}
- /** Configuration for rule that transforms an empty relational expression into an empty values.
+ /** Configuration for rule that transforms an empty relational expression into
+ * an empty values.
*
- * It relies on {@link org.apache.calcite.rel.metadata.RelMdMaxRowCount} to derive if the relation
- * is empty or not. If the stats are not available then the rule is a noop. */
+ * <p>It relies on {@link org.apache.calcite.rel.metadata.RelMdMaxRowCount} to
+ * derive if the relation is empty or not. If the stats are not available then
+ * the rule is a noop. */
@Value.Immutable
public interface ZeroMaxRowsRuleConfig extends PruneEmptyRule.Config {
ZeroMaxRowsRuleConfig DEFAULT = ImmutableZeroMaxRowsRuleConfig.of()
diff --git a/core/src/main/java/org/apache/calcite/rex/RexChecker.java b/core/src/main/java/org/apache/calcite/rex/RexChecker.java
index 66a70588f9..edf9b2bc63 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexChecker.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexChecker.java
@@ -41,7 +41,7 @@ import static java.util.Objects.requireNonNull;
* RelDataType rowType;<br>
* assert new RexChecker(rowType, true).isValid(node);</code></blockquote>
*
- * This mode requires that assertions are enabled.</li>
+ * <p>This mode requires that assertions are enabled.</li>
*
* <li>Use <code>fail=false</code> to test for validity without throwing an
* error.
diff --git a/core/src/main/java/org/apache/calcite/rex/package-info.java b/core/src/main/java/org/apache/calcite/rex/package-info.java
index 57bd7f4c39..351f21ce47 100644
--- a/core/src/main/java/org/apache/calcite/rex/package-info.java
+++ b/core/src/main/java/org/apache/calcite/rex/package-info.java
@@ -71,9 +71,9 @@
*
* <h2>Related packages</h2>
* <ul>
- * <li>{@link org.apache.calcite.sql} SQL object model</li>
+ * <li>{@link org.apache.calcite.sql} SQL object model</li>
*
- * <li>{@link org.apache.calcite.plan} Core classes, including
+ * <li>{@link org.apache.calcite.plan} Core classes, including
* {@link org.apache.calcite.rel.type.RelDataType} and
* {@link org.apache.calcite.rel.type.RelDataTypeFactory}.</li>
*
diff --git a/core/src/main/java/org/apache/calcite/sql/package-info.java b/core/src/main/java/org/apache/calcite/sql/package-info.java
index eb1e52b367..27a8d137dd 100644
--- a/core/src/main/java/org/apache/calcite/sql/package-info.java
+++ b/core/src/main/java/org/apache/calcite/sql/package-info.java
@@ -31,23 +31,24 @@
*
* <p>Every node in the parse tree is a {@link org.apache.calcite.sql.SqlNode}.
* Sub-types are:
+ *
* <ul>
*
- * <li>{@link org.apache.calcite.sql.SqlLiteral} represents a boolean,
- * numeric, string, or date constant, or the value <code>NULL</code>.
- * </li>
+ * <li>{@link org.apache.calcite.sql.SqlLiteral} represents a boolean,
+ * numeric, string, or date constant, or the value <code>NULL</code>.
+ * </li>
*
- * <li>{@link org.apache.calcite.sql.SqlIdentifier} represents an
- * identifier, such as <code> EMPNO</code> or <code>emp.deptno</code>.
- * </li>
+ * <li>{@link org.apache.calcite.sql.SqlIdentifier} represents an
+ * identifier, such as <code> EMPNO</code> or <code>emp.deptno</code>.
+ * </li>
*
- * <li>{@link org.apache.calcite.sql.SqlCall} is a call to an operator or
- * function. By means of special operators, we can use this construct
- * to represent virtually every non-leaf node in the tree. For example,
- * a <code>select</code> statement is a call to the 'select'
- * operator.</li>
+ * <li>{@link org.apache.calcite.sql.SqlCall} is a call to an operator or
+ * function. By means of special operators, we can use this construct
+ * to represent virtually every non-leaf node in the tree. For example,
+ * a <code>select</code> statement is a call to the 'select'
+ * operator.</li>
*
- * <li>{@link org.apache.calcite.sql.SqlNodeList} is a list of nodes.</li>
+ * <li>{@link org.apache.calcite.sql.SqlNodeList} is a list of nodes.</li>
*
* </ul>
*
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
index c54a7949bd..7370c1db9e 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
@@ -50,7 +50,7 @@ import java.util.Set;
*
* <p>The code snippet below illustrates how to implement a customized instance.
*
- * <pre>
+ * <blockquote><pre>{@code
* // Initialize a Builder instance with the default mappings.
* Builder builder = SqlTypeMappingRules.builder();
* builder.addAll(SqlTypeCoercionRules.instance().getTypeMapping());
@@ -68,7 +68,7 @@ import java.util.Set;
* SqlValidator.Config validatorConf ...;
* validatorConf.withTypeCoercionRules(typeCoercionRules);
* // Use this conf to initialize the SqlValidator.
- * </pre>
+ * }</pre></blockquote>
*/
public class SqlTypeCoercionRule implements SqlTypeMappingRule {
//~ Static fields/initializers ---------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/ListScope.java b/core/src/main/java/org/apache/calcite/sql/validate/ListScope.java
index b86472d5b4..8c49a4a427 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/ListScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/ListScope.java
@@ -83,13 +83,15 @@ public abstract class ListScope extends DelegatingScope {
/**
* Whether the ith child namespace produces nullable result.
*
- * For example, in below query,
- * <pre>
+ * <p>For example, in below query,
+ *
+ * <blockquote><pre>{@code
* SELECT *
* FROM EMPS
* LEFT OUTER JOIN DEPT
- * </pre>
- * the namespace which corresponding to 'DEPT' is nullable.
+ * }</pre></blockquote>
+ *
+ * <p>the namespace which corresponding to 'DEPT' is nullable.
*
* @param i The child index.
* @return Whether it's nullable.
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index 387a36d33b..c65123c81f 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -7068,10 +7068,10 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
* <p>Examples:
*
* <ul>
- * <li>{@code PREV(A.price + A.amount)} →
- * {@code PREV(A.price) + PREV(A.amount)}
+ * <li>{@code PREV(A.price + A.amount)} →
+ * {@code PREV(A.price) + PREV(A.amount)}
*
- * <li>{@code FIRST(A.price * 2)} → {@code FIRST(A.PRICE) * 2}
+ * <li>{@code FIRST(A.price * 2)} → {@code FIRST(A.PRICE) * 2}
* </ul>
*/
private static class NavigationExpander extends NavigationModifier {
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/implicit/TypeCoercionImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/implicit/TypeCoercionImpl.java
index 23ae94f7ff..73de170e5c 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/implicit/TypeCoercionImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/implicit/TypeCoercionImpl.java
@@ -72,15 +72,15 @@ public class TypeCoercionImpl extends AbstractTypeCoercion {
* mainly used for set operations like UNION, INTERSECT and EXCEPT.
*
* <p>Rules:
- * <pre>
- *
+ * <blockquote><pre>
* type1, type2 type3 select a, b, c from t1
* \ \ \
* type4 type5 type6 UNION
* / / /
* type7 type8 type9 select d, e, f from t2
- * </pre>
- * For struct type (type1, type2, type3) union type (type4, type5, type6),
+ * </pre></blockquote>
+ *
+ * <p>For struct type (type1, type2, type3) union type (type4, type5, type6),
* infer the first result column type type7 as the wider type of type1 and type4,
* the second column type as the wider type of type2 and type5 and so on.
*
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/CorrelateProjectExtractor.java b/core/src/main/java/org/apache/calcite/sql2rel/CorrelateProjectExtractor.java
index 2e8029ba3c..50d255c331 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/CorrelateProjectExtractor.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/CorrelateProjectExtractor.java
@@ -204,9 +204,10 @@ public final class CorrelateProjectExtractor extends RelHomogeneousShuttle {
/**
* A collector of simply correlated row expressions.
*
- * The shuttle traverses the tree and collects all calls and field accesses that are classified
- * as simply correlated expressions. Multiple nodes in a call hierarchy may satisfy the criteria
- * of a simple correlation so we peek the expressions closest to the root.
+ * <p>The shuttle traverses the tree and collects all calls and field accesses
+ * that are classified as simply correlated expressions. Multiple nodes in a
+ * call hierarchy may satisfy the criteria of a simple correlation so we peek
+ * the expressions closest to the root.
*
* @see SimpleCorrelationDetector
*/
@@ -248,24 +249,26 @@ public final class CorrelateProjectExtractor extends RelHomogeneousShuttle {
}
/**
- * A visitor classifying row expressions as simply correlated if they satisfy the conditions
- * below.
+ * A visitor classifying row expressions as simply correlated if they satisfy
+ * the conditions below.
+ *
* <ul>
* <li>all correlated variables have the specified correlation id</li>
* <li>all leafs are either correlated variables, dynamic parameters, or literals</li>
* <li>intermediate nodes are either calls or field access expressions</li>
* </ul>
*
- * Examples:
+ * <p>Examples:
+ *
* <pre>{@code
* +(10, $cor0.DEPTNO) -> TRUE
* /(100,+(10, $cor0.DEPTNO)) -> TRUE
* CAST(+(10, $cor0.DEPTNO)):INTEGER NOT NULL -> TRUE
* +($0, $cor0.DEPTNO) -> FALSE
* }</pre>
- *
*/
- private static class SimpleCorrelationDetector extends RexVisitorImpl<@Nullable Boolean> {
+ private static class SimpleCorrelationDetector
+ extends RexVisitorImpl<@Nullable Boolean> {
private final CorrelationId corrId;
private SimpleCorrelationDetector(CorrelationId corrId) {
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java b/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
index f1360507ee..d45c987a92 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
@@ -2292,16 +2292,16 @@ public class SqlToRelConverter {
* @param bb Scope within which to resolve identifiers
* @param from FROM clause of a query. Examples include:
*
- * <ul>
- * <li>a single table ("SALES.EMP"),
- * <li>an aliased table ("EMP AS E"),
- * <li>a list of tables ("EMP, DEPT"),
- * <li>an ANSI Join expression ("EMP JOIN DEPT ON EMP.DEPTNO =
- * DEPT.DEPTNO"),
- * <li>a VALUES clause ("VALUES ('Fred', 20)"),
- * <li>a query ("(SELECT * FROM EMP WHERE GENDER = 'F')"),
- * <li>or any combination of the above.
- * </ul>
+ * <ul>
+ * <li>a single table ("SALES.EMP"),
+ * <li>an aliased table ("EMP AS E"),
+ * <li>a list of tables ("EMP, DEPT"),
+ * <li>an ANSI Join expression ("EMP JOIN DEPT ON EMP.DEPTNO = DEPT.DEPTNO"),
+ * <li>a VALUES clause ("VALUES ('Fred', 20)"),
+ * <li>a query ("(SELECT * FROM EMP WHERE GENDER = 'F')"),
+ * <li>or any combination of the above.
+ * </ul>
+ *
* @param fieldNames Field aliases, usually come from AS clause, or null
*/
protected void convertFrom(
diff --git a/core/src/main/java/org/apache/calcite/tools/RelBuilder.java b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
index d745488cb3..7c014d490c 100644
--- a/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
+++ b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
@@ -4765,7 +4765,7 @@ public class RelBuilder {
* (a+b+c)-(d+e+f)-(g+h+i) AS t) # complexity 34
* </pre>
*
- * The complexity of an expression is the number of nodes (leaves and
+ * <p>The complexity of an expression is the number of nodes (leaves and
* operators). For example, {@code a+b+c} has complexity 5 (3 field
* references and 2 calls):
*
diff --git a/core/src/main/java/org/apache/calcite/util/Util.java b/core/src/main/java/org/apache/calcite/util/Util.java
index 864a394476..4134e903cb 100644
--- a/core/src/main/java/org/apache/calcite/util/Util.java
+++ b/core/src/main/java/org/apache/calcite/util/Util.java
@@ -1469,15 +1469,13 @@ public class Util {
* time
* <li>The second offset is how many hours changed during DST. Default=1
* <li>'start' and 'end' are the dates when DST goes into (and out of)
- * effect.<br>
- * <br>
- * They can each be one of three forms:
- *
- * <ol>
- * <li>Mm.w.d {month=1-12, week=1-5 (5 is always last), day=0-6}
- * <li>Jn {n=1-365 Feb29 is never counted}
- * <li>n {n=0-365 Feb29 is counted in leap years}
- * </ol>
+ * effect. They can each be one of three forms:
+ *
+ * <ol>
+ * <li>Mm.w.d {month=1-12, week=1-5 (5 is always last), day=0-6}
+ * <li>Jn {n=1-365 Feb29 is never counted}
+ * <li>n {n=0-365 Feb29 is counted in leap years}
+ * </ol>
* </li>
*
* <li>'time' has the same format as 'offset', and defaults to 02:00:00.</li>
diff --git a/core/src/test/java/org/apache/calcite/test/LintTest.java b/core/src/test/java/org/apache/calcite/test/LintTest.java
index d84ea99dc0..8e65856dac 100644
--- a/core/src/test/java/org/apache/calcite/test/LintTest.java
+++ b/core/src/test/java/org/apache/calcite/test/LintTest.java
@@ -76,10 +76,24 @@ class LintTest {
line.state().message("<p> must be preceded by blank line",
line))
+ // A non-blank line following a blank line must have a '<p>'
+ .add(line -> line.state().inJavadoc()
+ && line.state().ulCount == 0
+ && line.state().blockquoteCount == 0
+ && line.contains("* ")
+ && line.fnr() - 1 == line.state().starLine
+ && line.matches("^ *\\* [^<@].*"),
+ line -> line.state().message("missing '<p>'", line))
+
// The first "@param" of a javadoc block must be preceded by a blank
// line.
.add(line -> line.matches("^ */\\*\\*.*"),
- line -> line.state().javadocStartLine = line.fnr())
+ line -> {
+ final FileState f = line.state();
+ f.javadocStartLine = line.fnr();
+ f.blockquoteCount = 0;
+ f.ulCount = 0;
+ })
.add(line -> line.matches(".*\\*/"),
line -> line.state().javadocEndLine = line.fnr())
.add(line -> line.matches("^ *\\* @.*"),
@@ -93,6 +107,14 @@ class LintTest {
}
line.state().atLine = line.fnr();
})
+ .add(line -> line.contains("<blockquote>"),
+ line -> line.state().blockquoteCount++)
+ .add(line -> line.contains("</blockquote>"),
+ line -> line.state().blockquoteCount--)
+ .add(line -> line.contains("<ul>"),
+ line -> line.state().ulCount++)
+ .add(line -> line.contains("</ul>"),
+ line -> line.state().ulCount--)
.build();
}
@@ -111,6 +133,8 @@ class LintTest {
+ " String x = \"ok because it's not in javadoc:</p>\";\n"
+ "}\n";
final String expectedMessages = "["
+ + "GuavaCharSource{memory}:4:"
+ + "missing '<p>'\n"
+ "GuavaCharSource{memory}:6:"
+ "<p> must not be on its own line\n"
+ "GuavaCharSource{memory}:7:"
@@ -267,6 +291,8 @@ class LintTest {
int atLine;
int javadocStartLine;
int javadocEndLine;
+ int blockquoteCount;
+ int ulCount;
FileState(GlobalState global) {
this.global = global;
diff --git a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
index 150fa85f25..1fc25ab75f 100644
--- a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
@@ -7660,13 +7660,13 @@ class RelOptRulesTest extends RelOptTestBase {
.checkUnchanged();
}
- /**
- * Test case for <a href="https://issues.apache.org/jira/browse/CALCITE-5247">[CALCITE-5247]
- * * FilterJoinRule cannot simplify left join to inner join for `WHERE RHS.C1 IS NOT NULL OR
- * RHS.C2 IS NOT NULL`</a>.
+ /** Test case for
+ * <a href="https://issues.apache.org/jira/browse/CALCITE-5247">[CALCITE-5247]
+ * FilterJoinRule cannot simplify left join to inner join for `WHERE
+ * RHS.C1 IS NOT NULL OR RHS.C2 IS NOT NULL`</a>.
*
- * This tests the case where the condition contains an OR between the IS NOT NULL filters
- */
+ * <p>This tests the case where the condition contains an OR between
+ * the IS NOT NULL filters. */
@Test void testFilterJoinRuleOrIsNotNull() {
final String sql = "select * from\n"
+ "emp LHS\n"
@@ -7680,13 +7680,13 @@ class RelOptRulesTest extends RelOptTestBase {
.check();
}
- /**
- * Test case for <a href="https://issues.apache.org/jira/browse/CALCITE-5247">[CALCITE-5247]
- * * FilterJoinRule cannot simplify left join to inner join for `WHERE RHS.C1 IS NOT NULL OR
- * RHS.C2 IS NOT NULL`</a>.
+ /** Test case for
+ * <a href="https://issues.apache.org/jira/browse/CALCITE-5247">[CALCITE-5247]
+ * FilterJoinRule cannot simplify left join to inner join for `WHERE
+ * RHS.C1 IS NOT NULL OR RHS.C2 IS NOT NULL`</a>.
*
- * This tests the case where the condition contains an AND between the IS NOT NULL filters
- */
+ * <p>This tests the case where the condition contains an AND
+ * between the IS NOT NULL filters. */
@Test void testFilterJoinRuleAndIsNotNull() {
final String sql = "select * from\n"
+ "emp LHS\n"
diff --git a/core/src/test/java/org/apache/calcite/test/concurrent/package-info.java b/core/src/test/java/org/apache/calcite/test/concurrent/package-info.java
index c00e80a859..524e6d6d93 100644
--- a/core/src/test/java/org/apache/calcite/test/concurrent/package-info.java
+++ b/core/src/test/java/org/apache/calcite/test/concurrent/package-info.java
@@ -306,11 +306,10 @@
*
* <p>(Yes the results of the select statements are obviously wrong.)
*
- * <h3>Open Issues</h3>
- *
- * <ul>
- * <li>Repeating tests for a period of time isn't supported.</li>
- * </ul>
+ * <h3>Open Issues</h3>
*
+ * <ul>
+ * <li>Repeating tests for a period of time isn't supported.</li>
+ * </ul>
*/
package org.apache.calcite.test.concurrent;
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/EmbeddedElasticsearchPolicy.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/EmbeddedElasticsearchPolicy.java
index 38029c32fc..fb84809443 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/EmbeddedElasticsearchPolicy.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/EmbeddedElasticsearchPolicy.java
@@ -43,7 +43,8 @@ import java.util.Objects;
* does not allow multiple instances per JVM).
*
* <p>This rule should be used as follows:
- * <pre>
+ *
+ * <blockquote><pre><code>
* public class MyTest {
* public static final EmbeddedElasticsearchPolicy RULE =
* EmbeddedElasticsearchPolicy.create();
@@ -61,7 +62,7 @@ import java.util.Objects;
* // ....
* }
* }
- * </pre>
+ * </code></pre></blockquote>
*/
class EmbeddedElasticsearchPolicy {
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java b/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
index ae92498dc2..8494dd531d 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
@@ -2206,9 +2206,10 @@ public abstract class EnumerableDefaults {
}
/**
- * Joins two inputs that are sorted on the key, with an extra predicate for non equi-join
- * conditions.
- * Inputs must sorted in ascending order, nulls last.
+ * Joins two inputs that are sorted on the key, with an extra predicate for
+ * non equi-join conditions.
+ *
+ * <p>Inputs be must sorted in ascending order, nulls last.
*
* @param extraPredicate predicate for non equi-join conditions. In case of equi-join,
* it will be null. In case of non-equi join, the non-equi conditions
@@ -2219,7 +2220,8 @@ public abstract class EnumerableDefaults {
* @param comparator key comparator, possibly null (in which case {@link Comparable#compareTo}
* will be used).
*
- * NOTE: The current API is experimental and subject to change without notice.
+ * <p>NOTE: The current API is experimental and subject to change without
+ * notice.
*/
@API(since = "1.23", status = API.Status.EXPERIMENTAL)
public static <TSource, TInner, TKey extends Comparable<TKey>, TResult> Enumerable<TResult>
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/function/NonDeterministic.java b/linq4j/src/main/java/org/apache/calcite/linq4j/function/NonDeterministic.java
index 0de4c53847..6c9569847e 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/function/NonDeterministic.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/function/NonDeterministic.java
@@ -25,8 +25,8 @@ import java.lang.annotation.Target;
* Specifies that function is NOT deterministic (i.e. it can return
* different output given the same inputs).
*
- * The function is treated as non-deterministic even if {@code @Deterministic}
- * annotation is present at class level.
+ * <p>The function is treated as non-deterministic even if
+ * {@code @Deterministic} annotation is present at class level.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE })
diff --git a/redis/src/test/java/org/apache/calcite/adapter/redis/RedisCaseBase.java b/redis/src/test/java/org/apache/calcite/adapter/redis/RedisCaseBase.java
index 1459a00cbc..bf54157249 100644
--- a/redis/src/test/java/org/apache/calcite/adapter/redis/RedisCaseBase.java
+++ b/redis/src/test/java/org/apache/calcite/adapter/redis/RedisCaseBase.java
@@ -46,7 +46,7 @@ public abstract class RedisCaseBase {
/**
* The Redis Docker container.
*
- * Uses the Redis 2.8.19 version to be aligned with the embedded server.
+ * <p>Uses the Redis 2.8.19 version to be aligned with the embedded server.
*/
private static final GenericContainer<?> REDIS_CONTAINER =
new GenericContainer<>("redis:2.8.19").withExposedPorts(6379);
@@ -54,8 +54,8 @@ public abstract class RedisCaseBase {
/**
* The embedded Redis server.
*
- * With the existing dependencies (com.github.kstyrc:embedded-redis:0.6) it uses by default
- * Redis 2.8.19 version.
+ * <p>With the existing dependencies (com.github.kstyrc:embedded-redis:0.6) it
+ * uses by default Redis 2.8.19 version.
*/
private static RedisServer redisServer;
diff --git a/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/MetadataBenchmark.java b/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/MetadataBenchmark.java
index a78c79eb15..dece4c9aff 100644
--- a/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/MetadataBenchmark.java
+++ b/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/MetadataBenchmark.java
@@ -46,8 +46,7 @@ import java.util.function.Supplier;
/**
* A benchmark to compare metadata retrieval time for a complex query.
*
- * Compares metadata retrieval performance on a large query
- *
+ * <p>Compares metadata retrieval performance on a large query.
*/
@Fork(value = 1, jvmArgsPrepend = "-Xmx2048m")
@State(Scope.Benchmark)
[calcite] 02/02: [CALCITE-5767] JDBC adapter for MSSQL adds GROUPING to ORDER BY clause twice when emulating NULLS LAST
Posted by jh...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jhyde pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/calcite.git
commit 0f0288f4e93476823329a5ec59b471fd186bd16d
Author: Will Noble <wn...@google.com>
AuthorDate: Wed Jun 7 15:01:07 2023 -0700
[CALCITE-5767] JDBC adapter for MSSQL adds GROUPING to ORDER BY clause twice when emulating NULLS LAST
This is a problem because MSSQL disallows duplicate sort keys. The MSSQL
dialect should not give GROUPING special treatment when emulating NULL
direction, and this change solves the problem by removing that special
treatment.
Close apache/calcite#3251
---
.../calcite/sql/dialect/MssqlSqlDialect.java | 5 -----
.../calcite/rel/rel2sql/RelToSqlConverterTest.java | 24 ++++++++++++++++++++++
2 files changed, 24 insertions(+), 5 deletions(-)
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/MssqlSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/MssqlSqlDialect.java
index 0a168a1050..6f76207b0c 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/MssqlSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/MssqlSqlDialect.java
@@ -91,11 +91,6 @@ public class MssqlSqlDialect extends SqlDialect {
return null;
}
- // Grouping node should preserve grouping, no emulation needed
- if (node.getKind() == SqlKind.GROUPING) {
- return node;
- }
-
// Emulate nulls first/last with case ordering
final SqlParserPos pos = SqlParserPos.ZERO;
final SqlNodeList whenList =
diff --git a/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java b/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
index 9de19094a8..3eafff29d6 100644
--- a/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
@@ -7058,6 +7058,30 @@ class RelToSqlConverterTest {
.withBigQuery().ok(expected);
}
+ /** Test case for
+ * <a href="https://issues.apache.org/jira/browse/CALCITE-5767">[CALCITE-5767]
+ * JDBC adapter for MSSQL adds GROUPING to ORDER BY clause twice when
+ * emulating NULLS LAST</a>.
+ *
+ * <p>Calcite's MSSQL dialect should not give GROUPING special treatment when
+ * emulating NULL direction.
+ */
+ @Test void testSortByGroupingInMssql() {
+ final String query = "select \"product_class_id\", \"brand_name\", GROUPING(\"brand_name\")\n"
+ + "from \"product\"\n"
+ + "group by GROUPING SETS ((\"product_class_id\", \"brand_name\"),"
+ + " (\"product_class_id\"))\n"
+ + "order by 3, 2, 1";
+ final String expectedMssql = "SELECT [product_class_id], [brand_name], GROUPING([brand_name])\n"
+ + "FROM [foodmart].[product]\n"
+ + "GROUP BY GROUPING SETS(([product_class_id], [brand_name]), [product_class_id])\n"
+ + "ORDER BY CASE WHEN GROUPING([brand_name]) IS NULL THEN 1 ELSE 0 END, 3,"
+ + " CASE WHEN [brand_name] IS NULL THEN 1 ELSE 0 END, [brand_name],"
+ + " CASE WHEN [product_class_id] IS NULL THEN 1 ELSE 0 END, [product_class_id]";
+
+ sql(query).withMssql().ok(expectedMssql);
+ }
+
/** Fluid interface to run tests. */
static class Sql {
private final CalciteAssert.SchemaSpec schemaSpec;