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 2018/09/17 16:51:26 UTC
[2/4] calcite git commit: [CALCITE-2535] Enable SqlTester.checkFails
(previously it was a no-op) (Hongze Zhang)
[CALCITE-2535] Enable SqlTester.checkFails (previously it was a no-op) (Hongze Zhang)
Close apache/calcite#823
Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/c69e1bcb
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/c69e1bcb
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/c69e1bcb
Branch: refs/heads/master
Commit: c69e1bcb13000adf9ae4bd433e2f8c75baba1501
Parents: 337f247
Author: hongzezhang <ho...@tencent.com>
Authored: Wed Sep 12 20:34:34 2018 +0800
Committer: Julian Hyde <jh...@apache.org>
Committed: Mon Sep 17 09:39:31 2018 -0700
----------------------------------------------------------------------
.../main/java/org/apache/calcite/util/Bug.java | 5 +
.../calcite/sql/test/AbstractSqlTester.java | 680 +++++++++++++++++++
.../apache/calcite/sql/test/SqlAdvisorTest.java | 2 +-
.../calcite/sql/test/SqlOperatorBaseTest.java | 372 +++++-----
.../calcite/sql/test/SqlRuntimeTester.java | 88 +++
.../apache/calcite/sql/test/SqlTesterImpl.java | 668 ------------------
.../org/apache/calcite/sql/test/SqlTests.java | 224 +++++-
.../calcite/sql/test/SqlValidatorTester.java | 35 +
.../sql/validate/SqlValidatorUtilTest.java | 7 +-
.../org/apache/calcite/test/SqlTestGen.java | 4 +-
.../calcite/test/SqlValidatorDynamicTest.java | 4 +-
.../calcite/test/SqlValidatorFeatureTest.java | 4 +-
.../calcite/test/SqlValidatorTestCase.java | 210 +-----
core/src/test/resources/sql/misc.iq | 3 +
core/src/test/resources/sql/spatial.iq | 2 +
15 files changed, 1268 insertions(+), 1040 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/main/java/org/apache/calcite/util/Bug.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/Bug.java b/core/src/main/java/org/apache/calcite/util/Bug.java
index 26f1bbc..7eeb208 100644
--- a/core/src/main/java/org/apache/calcite/util/Bug.java
+++ b/core/src/main/java/org/apache/calcite/util/Bug.java
@@ -180,6 +180,11 @@ public abstract class Bug {
*/
public static final boolean CALCITE_2401_FIXED = false;
+ /** Whether
+ * <a href="https://issues.apache.org/jira/browse/CALCITE-2539">[CALCITE-2539]
+ * Several test case not passed in CalciteSqlOperatorTest.java</a> is fixed. */
+ public static final boolean CALCITE_2539_FIXED = false;
+
/**
* Use this to flag temporary code.
*/
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/sql/test/AbstractSqlTester.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/AbstractSqlTester.java b/core/src/test/java/org/apache/calcite/sql/test/AbstractSqlTester.java
new file mode 100644
index 0000000..f9f252e
--- /dev/null
+++ b/core/src/test/java/org/apache/calcite/sql/test/AbstractSqlTester.java
@@ -0,0 +1,680 @@
+/*
+ * 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.calcite.sql.test;
+
+import org.apache.calcite.avatica.util.Casing;
+import org.apache.calcite.avatica.util.Quoting;
+import org.apache.calcite.config.CalciteConnectionProperty;
+import org.apache.calcite.config.Lex;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.runtime.Utilities;
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlCollation;
+import org.apache.calcite.sql.SqlIntervalLiteral;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlOperatorTable;
+import org.apache.calcite.sql.SqlSelect;
+import org.apache.calcite.sql.dialect.AnsiSqlDialect;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.SqlParseException;
+import org.apache.calcite.sql.parser.SqlParser;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.parser.SqlParserUtil;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.util.SqlShuttle;
+import org.apache.calcite.sql.validate.SqlConformance;
+import org.apache.calcite.sql.validate.SqlConformanceEnum;
+import org.apache.calcite.sql.validate.SqlMonotonicity;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorNamespace;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+import org.apache.calcite.test.CalciteAssert;
+import org.apache.calcite.test.SqlValidatorTestCase;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.TestUtil;
+import org.apache.calcite.util.Util;
+
+import com.google.common.collect.ImmutableList;
+
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import static org.apache.calcite.sql.SqlUtil.stripAs;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Abstract implementation of
+ * {@link org.apache.calcite.test.SqlValidatorTestCase.Tester}
+ * that talks to a mock catalog.
+ *
+ * <p>This is to implement the default behavior: testing is only against the
+ * {@link SqlValidator}.
+ */
+public abstract class AbstractSqlTester implements SqlTester, AutoCloseable {
+ protected final SqlTestFactory factory;
+
+ public AbstractSqlTester(SqlTestFactory factory) {
+ this.factory = factory;
+ }
+
+ public final SqlTestFactory getFactory() {
+ return factory;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>This default implementation does nothing.
+ */
+ public void close() {
+ // no resources to release
+ }
+
+ public final SqlConformance getConformance() {
+ return (SqlConformance) factory.get("conformance");
+ }
+
+ public final SqlValidator getValidator() {
+ return factory.getValidator();
+ }
+
+ public void assertExceptionIsThrown(String sql, String expectedMsgPattern) {
+ final SqlValidator validator;
+ final SqlNode sqlNode;
+ final SqlParserUtil.StringAndPos sap = SqlParserUtil.findPos(sql);
+ try {
+ sqlNode = parseQuery(sap.sql);
+ validator = getValidator();
+ } catch (Throwable e) {
+ checkParseEx(e, expectedMsgPattern, sap.sql);
+ return;
+ }
+
+ Throwable thrown = null;
+ try {
+ validator.validate(sqlNode);
+ } catch (Throwable ex) {
+ thrown = ex;
+ }
+
+ SqlValidatorTestCase.checkEx(thrown, expectedMsgPattern, sap);
+ }
+
+ protected void checkParseEx(Throwable e, String expectedMsgPattern, String sql) {
+ try {
+ throw e;
+ } catch (SqlParseException spe) {
+ String errMessage = spe.getMessage();
+ if (expectedMsgPattern == null) {
+ throw new RuntimeException("Error while parsing query:" + sql, spe);
+ } else if (errMessage == null
+ || !errMessage.matches(expectedMsgPattern)) {
+ throw new RuntimeException("Error did not match expected ["
+ + expectedMsgPattern + "] while parsing query ["
+ + sql + "]", spe);
+ }
+ } catch (Throwable t) {
+ throw new RuntimeException("Error while parsing query: " + sql, t);
+ }
+ }
+
+ public RelDataType getColumnType(String sql) {
+ RelDataType rowType = getResultType(sql);
+ final List<RelDataTypeField> fields = rowType.getFieldList();
+ assertEquals("expected query to return 1 field", 1, fields.size());
+ return fields.get(0).getType();
+ }
+
+ public RelDataType getResultType(String sql) {
+ SqlValidator validator = getValidator();
+ SqlNode n = parseAndValidate(validator, sql);
+
+ return validator.getValidatedNodeType(n);
+ }
+
+ public SqlNode parseAndValidate(SqlValidator validator, String sql) {
+ if (validator == null) {
+ validator = getValidator();
+ }
+ SqlNode sqlNode;
+ try {
+ sqlNode = parseQuery(sql);
+ } catch (Throwable e) {
+ throw new RuntimeException("Error while parsing query: " + sql, e);
+ }
+ return validator.validate(sqlNode);
+ }
+
+ public SqlNode parseQuery(String sql) throws SqlParseException {
+ SqlParser parser = factory.createParser(sql);
+ return parser.parseQuery();
+ }
+
+ public void checkColumnType(String sql, String expected) {
+ RelDataType actualType = getColumnType(sql);
+ String actual = SqlTests.getTypeString(actualType);
+ assertEquals(expected, actual);
+ }
+
+ public void checkFieldOrigin(String sql, String fieldOriginList) {
+ SqlValidator validator = getValidator();
+ SqlNode n = parseAndValidate(validator, sql);
+ final List<List<String>> list = validator.getFieldOrigins(n);
+ final StringBuilder buf = new StringBuilder("{");
+ int i = 0;
+ for (List<String> strings : list) {
+ if (i++ > 0) {
+ buf.append(", ");
+ }
+ if (strings == null) {
+ buf.append("null");
+ } else {
+ int j = 0;
+ for (String s : strings) {
+ if (j++ > 0) {
+ buf.append('.');
+ }
+ buf.append(s);
+ }
+ }
+ }
+ buf.append("}");
+ assertEquals(fieldOriginList, buf.toString());
+ }
+
+ public void checkResultType(String sql, String expected) {
+ RelDataType actualType = getResultType(sql);
+ String actual = SqlTests.getTypeString(actualType);
+ assertEquals(expected, actual);
+ }
+
+ public void checkIntervalConv(String sql, String expected) {
+ SqlValidator validator = getValidator();
+ final SqlCall n = (SqlCall) parseAndValidate(validator, sql);
+
+ SqlNode node = null;
+ for (int i = 0; i < n.operandCount(); i++) {
+ node = stripAs(n.operand(i));
+ if (node instanceof SqlCall) {
+ node = ((SqlCall) node).operand(0);
+ break;
+ }
+ }
+
+ assertNotNull(node);
+ SqlIntervalLiteral intervalLiteral = (SqlIntervalLiteral) node;
+ SqlIntervalLiteral.IntervalValue interval =
+ (SqlIntervalLiteral.IntervalValue) intervalLiteral.getValue();
+ long l =
+ interval.getIntervalQualifier().isYearMonth()
+ ? SqlParserUtil.intervalToMonths(interval)
+ : SqlParserUtil.intervalToMillis(interval);
+ String actual = l + "";
+ assertEquals(expected, actual);
+ }
+
+ public void checkType(String expression, String type) {
+ for (String sql : buildQueries(expression)) {
+ checkColumnType(sql, type);
+ }
+ }
+
+ public void checkCollation(
+ String expression,
+ String expectedCollationName,
+ SqlCollation.Coercibility expectedCoercibility) {
+ for (String sql : buildQueries(expression)) {
+ RelDataType actualType = getColumnType(sql);
+ SqlCollation collation = actualType.getCollation();
+
+ assertEquals(
+ expectedCollationName, collation.getCollationName());
+ assertEquals(expectedCoercibility, collation.getCoercibility());
+ }
+ }
+
+ public void checkCharset(
+ String expression,
+ Charset expectedCharset) {
+ for (String sql : buildQueries(expression)) {
+ RelDataType actualType = getColumnType(sql);
+ Charset actualCharset = actualType.getCharset();
+
+ if (!expectedCharset.equals(actualCharset)) {
+ fail("\n"
+ + "Expected=" + expectedCharset.name() + "\n"
+ + " actual=" + actualCharset.name());
+ }
+ }
+ }
+
+ public SqlTester withQuoting(Quoting quoting) {
+ return with("quoting", quoting);
+ }
+
+ public SqlTester withQuotedCasing(Casing casing) {
+ return with("quotedCasing", casing);
+ }
+
+ public SqlTester withUnquotedCasing(Casing casing) {
+ return with("unquotedCasing", casing);
+ }
+
+ public SqlTester withCaseSensitive(boolean sensitive) {
+ return with("caseSensitive", sensitive);
+ }
+
+ public SqlTester withLex(Lex lex) {
+ return withQuoting(lex.quoting)
+ .withCaseSensitive(lex.caseSensitive)
+ .withQuotedCasing(lex.quotedCasing)
+ .withUnquotedCasing(lex.unquotedCasing);
+ }
+
+ public SqlTester withConformance(SqlConformance conformance) {
+ if (conformance == null) {
+ conformance = SqlConformanceEnum.DEFAULT;
+ }
+ final SqlTester tester = with("conformance", conformance);
+ if (conformance instanceof SqlConformanceEnum) {
+ return tester
+ .withConnectionFactory(
+ CalciteAssert.EMPTY_CONNECTION_FACTORY
+ .with(CalciteConnectionProperty.CONFORMANCE, conformance));
+ } else {
+ return tester;
+ }
+ }
+
+ public SqlTester withOperatorTable(SqlOperatorTable operatorTable) {
+ return with("operatorTable", operatorTable);
+ }
+
+ public SqlTester withConnectionFactory(
+ CalciteAssert.ConnectionFactory connectionFactory) {
+ return with("connectionFactory", connectionFactory);
+ }
+
+ protected final SqlTester with(final String name, final Object value) {
+ return with(factory.with(name, value));
+ }
+
+ protected abstract SqlTester with(SqlTestFactory factory);
+
+ // SqlTester methods
+
+ public void setFor(
+ SqlOperator operator,
+ VmName... unimplementedVmNames) {
+ // do nothing
+ }
+
+ public void checkAgg(
+ String expr,
+ String[] inputValues,
+ Object result,
+ double delta) {
+ String query =
+ SqlTests.generateAggQuery(expr, inputValues);
+ check(query, SqlTests.ANY_TYPE_CHECKER, result, delta);
+ }
+
+ public void checkWinAgg(
+ String expr,
+ String[] inputValues,
+ String windowSpec,
+ String type,
+ Object result,
+ double delta) {
+ String query =
+ SqlTests.generateWinAggQuery(
+ expr, windowSpec, inputValues);
+ check(query, SqlTests.ANY_TYPE_CHECKER, result, delta);
+ }
+
+ public void checkScalar(
+ String expression,
+ Object result,
+ String resultType) {
+ checkType(expression, resultType);
+ for (String sql : buildQueries(expression)) {
+ check(sql, SqlTests.ANY_TYPE_CHECKER, result, 0);
+ }
+ }
+
+ public void checkScalarExact(
+ String expression,
+ String result) {
+ for (String sql : buildQueries(expression)) {
+ check(sql, SqlTests.INTEGER_TYPE_CHECKER, result, 0);
+ }
+ }
+
+ public void checkScalarExact(
+ String expression,
+ String expectedType,
+ String result) {
+ for (String sql : buildQueries(expression)) {
+ TypeChecker typeChecker =
+ new SqlTests.StringTypeChecker(expectedType);
+ check(sql, typeChecker, result, 0);
+ }
+ }
+
+ public void checkScalarApprox(
+ String expression,
+ String expectedType,
+ double expectedResult,
+ double delta) {
+ for (String sql : buildQueries(expression)) {
+ TypeChecker typeChecker =
+ new SqlTests.StringTypeChecker(expectedType);
+ check(sql, typeChecker, expectedResult, delta);
+ }
+ }
+
+ public void checkBoolean(
+ String expression,
+ Boolean result) {
+ for (String sql : buildQueries(expression)) {
+ if (null == result) {
+ checkNull(expression);
+ } else {
+ check(
+ sql,
+ SqlTests.BOOLEAN_TYPE_CHECKER,
+ result.toString(),
+ 0);
+ }
+ }
+ }
+
+ public void checkString(
+ String expression,
+ String result,
+ String expectedType) {
+ for (String sql : buildQueries(expression)) {
+ TypeChecker typeChecker =
+ new SqlTests.StringTypeChecker(expectedType);
+ check(sql, typeChecker, result, 0);
+ }
+ }
+
+ public void checkNull(String expression) {
+ for (String sql : buildQueries(expression)) {
+ check(sql, SqlTests.ANY_TYPE_CHECKER, null, 0);
+ }
+ }
+
+ public final void check(
+ String query,
+ TypeChecker typeChecker,
+ Object result,
+ double delta) {
+ check(query, typeChecker, SqlTests.ANY_PARAMETER_CHECKER,
+ SqlTests.createChecker(result, delta));
+ }
+
+ public void check(String query, TypeChecker typeChecker,
+ ParameterChecker parameterChecker, ResultChecker resultChecker) {
+ // This implementation does NOT check the result!
+ // All it does is check the return type.
+
+ if (typeChecker == null) {
+ // Parse and validate. There should be no errors.
+ Util.discard(getResultType(query));
+ } else {
+ // Parse and validate. There should be no errors.
+ // There must be 1 column. Get its type.
+ RelDataType actualType = getColumnType(query);
+
+ // Check result type.
+ typeChecker.checkType(actualType);
+ }
+
+ SqlValidator validator = getValidator();
+ SqlNode n = parseAndValidate(validator, query);
+ final RelDataType parameterRowType = validator.getParameterRowType(n);
+ parameterChecker.checkParameters(parameterRowType);
+ }
+
+ public void checkMonotonic(String query,
+ SqlMonotonicity expectedMonotonicity) {
+ SqlValidator validator = getValidator();
+ SqlNode n = parseAndValidate(validator, query);
+ final RelDataType rowType = validator.getValidatedNodeType(n);
+ final SqlValidatorNamespace selectNamespace = validator.getNamespace(n);
+ final String field0 = rowType.getFieldList().get(0).getName();
+ final SqlMonotonicity monotonicity =
+ selectNamespace.getMonotonicity(field0);
+ assertThat(monotonicity, equalTo(expectedMonotonicity));
+ }
+
+ public void checkRewrite(
+ SqlValidator validator,
+ String query,
+ String expectedRewrite) {
+ SqlNode rewrittenNode = parseAndValidate(validator, query);
+ String actualRewrite =
+ rewrittenNode.toSqlString(AnsiSqlDialect.DEFAULT, false).getSql();
+ TestUtil.assertEqualsVerbose(expectedRewrite, Util.toLinux(actualRewrite));
+ }
+
+ public void checkFails(
+ String expression,
+ String expectedError,
+ boolean runtime) {
+ if (runtime) {
+ // We need to test that the expression fails at runtime.
+ // Ironically, that means that it must succeed at prepare time.
+ SqlValidator validator = getValidator();
+ final String sql = buildQuery(expression);
+ SqlNode n = parseAndValidate(validator, sql);
+ assertNotNull(n);
+ } else {
+ checkQueryFails(buildQuery(expression), expectedError);
+ }
+ }
+
+ public void checkQueryFails(String sql, String expectedError) {
+ assertExceptionIsThrown(sql, expectedError);
+ }
+
+ public void checkQuery(String sql) {
+ assertExceptionIsThrown(sql, null);
+ }
+
+ public SqlMonotonicity getMonotonicity(String sql) {
+ final SqlValidator validator = getValidator();
+ final SqlNode node = parseAndValidate(validator, sql);
+ final SqlSelect select = (SqlSelect) node;
+ final SqlNode selectItem0 = select.getSelectList().get(0);
+ final SqlValidatorScope scope = validator.getSelectScope(select);
+ return selectItem0.getMonotonicity(scope);
+ }
+
+ public static String buildQuery(String expression) {
+ return "values (" + expression + ")";
+ }
+
+ public static String buildQueryAgg(String expression) {
+ return "select " + expression + " from (values (1)) as t(x) group by x";
+ }
+
+ /**
+ * Builds a query that extracts all literals as columns in an underlying
+ * select.
+ *
+ * <p>For example,</p>
+ *
+ * <blockquote>{@code 1 < 5}</blockquote>
+ *
+ * <p>becomes</p>
+ *
+ * <blockquote>{@code SELECT p0 < p1
+ * FROM (VALUES (1, 5)) AS t(p0, p1)}</blockquote>
+ *
+ * <p>Null literals don't have enough type information to be extracted.
+ * We push down {@code CAST(NULL AS type)} but raw nulls such as
+ * {@code CASE 1 WHEN 2 THEN 'a' ELSE NULL END} are left as is.</p>
+ *
+ * @param expression Scalar expression
+ * @return Query that evaluates a scalar expression
+ */
+ protected String buildQuery2(String expression) {
+ // "values (1 < 5)"
+ // becomes
+ // "select p0 < p1 from (values (1, 5)) as t(p0, p1)"
+ SqlNode x;
+ final String sql = "values (" + expression + ")";
+ try {
+ x = parseQuery(sql);
+ } catch (SqlParseException e) {
+ throw new RuntimeException(e);
+ }
+ final Collection<SqlNode> literalSet = new LinkedHashSet<>();
+ x.accept(
+ new SqlShuttle() {
+ private final List<SqlOperator> ops =
+ ImmutableList.of(
+ SqlStdOperatorTable.LITERAL_CHAIN,
+ SqlStdOperatorTable.LOCALTIME,
+ SqlStdOperatorTable.LOCALTIMESTAMP,
+ SqlStdOperatorTable.CURRENT_TIME,
+ SqlStdOperatorTable.CURRENT_TIMESTAMP);
+
+ @Override public SqlNode visit(SqlLiteral literal) {
+ if (!isNull(literal)
+ && literal.getTypeName() != SqlTypeName.SYMBOL) {
+ literalSet.add(literal);
+ }
+ return literal;
+ }
+
+ @Override public SqlNode visit(SqlCall call) {
+ final SqlOperator operator = call.getOperator();
+ if (operator == SqlStdOperatorTable.CAST
+ && isNull(call.operand(0))) {
+ literalSet.add(call);
+ return call;
+ } else if (ops.contains(operator)) {
+ // "Argument to function 'LOCALTIME' must be a
+ // literal"
+ return call;
+ } else {
+ return super.visit(call);
+ }
+ }
+
+ private boolean isNull(SqlNode sqlNode) {
+ return sqlNode instanceof SqlLiteral
+ && ((SqlLiteral) sqlNode).getTypeName()
+ == SqlTypeName.NULL;
+ }
+ });
+ final List<SqlNode> nodes = new ArrayList<>(literalSet);
+ nodes.sort((o1, o2) -> {
+ final SqlParserPos pos0 = o1.getParserPosition();
+ final SqlParserPos pos1 = o2.getParserPosition();
+ int c = -Utilities.compare(pos0.getLineNum(), pos1.getLineNum());
+ if (c != 0) {
+ return c;
+ }
+ return -Utilities.compare(pos0.getColumnNum(), pos1.getColumnNum());
+ });
+ String sql2 = sql;
+ final List<Pair<String, String>> values = new ArrayList<>();
+ int p = 0;
+ for (SqlNode literal : nodes) {
+ final SqlParserPos pos = literal.getParserPosition();
+ final int start =
+ SqlParserUtil.lineColToIndex(
+ sql, pos.getLineNum(), pos.getColumnNum());
+ final int end =
+ SqlParserUtil.lineColToIndex(
+ sql,
+ pos.getEndLineNum(),
+ pos.getEndColumnNum()) + 1;
+ String param = "p" + (p++);
+ values.add(Pair.of(sql2.substring(start, end), param));
+ sql2 = sql2.substring(0, start)
+ + param
+ + sql2.substring(end);
+ }
+ if (values.isEmpty()) {
+ values.add(Pair.of("1", "p0"));
+ }
+ return "select "
+ + sql2.substring("values (".length(), sql2.length() - 1)
+ + " from (values ("
+ + Util.commaList(Pair.left(values))
+ + ")) as t("
+ + Util.commaList(Pair.right(values))
+ + ")";
+ }
+
+ /**
+ * Converts a scalar expression into a list of SQL queries that
+ * evaluate it.
+ *
+ * @param expression Scalar expression
+ * @return List of queries that evaluate an expression
+ */
+ private Iterable<String> buildQueries(final String expression) {
+ // Why an explicit iterable rather than a list? If there is
+ // a syntax error in the expression, the calling code discovers it
+ // before we try to parse it to do substitutions on the parse tree.
+ return () -> new Iterator<String>() {
+ int i = 0;
+
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+
+ public String next() {
+ switch (i++) {
+ case 0:
+ return buildQuery(expression);
+ case 1:
+ return buildQuery2(expression);
+ default:
+ throw new NoSuchElementException();
+ }
+ }
+
+ public boolean hasNext() {
+ return i < 2;
+ }
+ };
+ }
+
+}
+
+// End AbstractSqlTester.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
index ebee877..5b57d82 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
@@ -576,7 +576,7 @@ public class SqlAdvisorTest extends SqlValidatorTestCase {
}
@Override public SqlTester getTester() {
- return new SqlTesterImpl(ADVISOR_TEST_FACTORY);
+ return new SqlValidatorTester(ADVISOR_TEST_FACTORY);
}
/**
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
index 903504c..aac111c 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
@@ -531,9 +531,11 @@ public abstract class SqlOperatorBaseTest {
"cast(.48 as varchar(10))",
".48",
"VARCHAR(10) NOT NULL");
- tester.checkFails(
- "cast(2.523 as char(2))", STRING_TRUNC_MESSAGE,
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails(
+ "cast(2.523 as char(2))", STRING_TRUNC_MESSAGE,
+ true);
+ }
tester.checkString(
"cast(-0.29 as varchar(10))",
@@ -563,13 +565,14 @@ public abstract class SqlOperatorBaseTest {
if (TODO) {
checkCastToString("cast(-0.1 as real)", "CHAR(5)", "-1E-1");
}
-
- tester.checkFails(
- "cast(1.3243232e0 as varchar(4))", STRING_TRUNC_MESSAGE,
- true);
- tester.checkFails(
- "cast(1.9e5 as char(4))", STRING_TRUNC_MESSAGE,
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails(
+ "cast(1.3243232e0 as varchar(4))", STRING_TRUNC_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast(1.9e5 as char(4))", STRING_TRUNC_MESSAGE,
+ true);
+ }
// string
checkCastToString("'abc'", "CHAR(1)", "a");
@@ -634,18 +637,21 @@ public abstract class SqlOperatorBaseTest {
checkCastToString("True", "CHAR(6)", "TRUE ");
checkCastToString("True", "VARCHAR(6)", "TRUE");
checkCastToString("False", "CHAR(5)", "FALSE");
- tester.checkFails(
- "cast(true as char(3))", INVALID_CHAR_MESSAGE,
- true);
- tester.checkFails(
- "cast(false as char(4))", INVALID_CHAR_MESSAGE,
- true);
- tester.checkFails(
- "cast(true as varchar(3))", INVALID_CHAR_MESSAGE,
- true);
- tester.checkFails(
- "cast(false as varchar(4))", INVALID_CHAR_MESSAGE,
- true);
+
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails(
+ "cast(true as char(3))", INVALID_CHAR_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast(false as char(4))", INVALID_CHAR_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast(true as varchar(3))", INVALID_CHAR_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast(false as varchar(4))", INVALID_CHAR_MESSAGE,
+ true);
+ }
}
@Test public void testCastExactNumericLimits() {
@@ -678,14 +684,16 @@ public abstract class SqlOperatorBaseTest {
type, LITERAL_OUT_OF_RANGE_MESSAGE,
false);
} else {
- checkCastFails(
- MAX_OVERFLOW_NUMERIC_STRINGS[i],
- type, OUT_OF_RANGE_MESSAGE,
- true);
- checkCastFails(
- MIN_OVERFLOW_NUMERIC_STRINGS[i],
- type, OUT_OF_RANGE_MESSAGE,
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ checkCastFails(
+ MAX_OVERFLOW_NUMERIC_STRINGS[i],
+ type, OUT_OF_RANGE_MESSAGE,
+ true);
+ checkCastFails(
+ MIN_OVERFLOW_NUMERIC_STRINGS[i],
+ type, OUT_OF_RANGE_MESSAGE,
+ true);
+ }
}
// Convert from string to type
@@ -698,15 +706,17 @@ public abstract class SqlOperatorBaseTest {
type,
MIN_NUMERIC_STRINGS[i]);
- checkCastFails(
- "'" + MAX_OVERFLOW_NUMERIC_STRINGS[i] + "'",
- type, OUT_OF_RANGE_MESSAGE,
- true);
- checkCastFails(
- "'" + MIN_OVERFLOW_NUMERIC_STRINGS[i] + "'",
- type,
- OUT_OF_RANGE_MESSAGE,
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ checkCastFails(
+ "'" + MAX_OVERFLOW_NUMERIC_STRINGS[i] + "'",
+ type, OUT_OF_RANGE_MESSAGE,
+ true);
+ checkCastFails(
+ "'" + MIN_OVERFLOW_NUMERIC_STRINGS[i] + "'",
+ type,
+ OUT_OF_RANGE_MESSAGE,
+ true);
+ }
// Convert from type to string
checkCastToString(MAX_NUMERIC_STRINGS[i], null, null);
@@ -715,7 +725,9 @@ public abstract class SqlOperatorBaseTest {
checkCastToString(MIN_NUMERIC_STRINGS[i], null, null);
checkCastToString(MIN_NUMERIC_STRINGS[i], type, null);
- checkCastFails("'notnumeric'", type, INVALID_CHAR_MESSAGE, true);
+ if (Bug.CALCITE_2539_FIXED) {
+ checkCastFails("'notnumeric'", type, INVALID_CHAR_MESSAGE, true);
+ }
}
}
@@ -1215,14 +1227,16 @@ public abstract class SqlOperatorBaseTest {
// generate Java constants that throw when the class is loaded, thus
// ExceptionInInitializerError.
tester.checkScalarExact("cast('15' as integer)", "INTEGER NOT NULL", "15");
- tester.checkFails("cast('15.4' as integer)", "xxx", true);
- tester.checkFails("cast('15.6' as integer)", "xxx", true);
- tester.checkFails("cast('ue' as boolean)", "xxx", true);
- tester.checkFails("cast('' as boolean)", "xxx", true);
- tester.checkFails("cast('' as integer)", "xxx", true);
- tester.checkFails("cast('' as real)", "xxx", true);
- tester.checkFails("cast('' as double)", "xxx", true);
- tester.checkFails("cast('' as smallint)", "xxx", true);
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails("cast('15.4' as integer)", "xxx", true);
+ tester.checkFails("cast('15.6' as integer)", "xxx", true);
+ tester.checkFails("cast('ue' as boolean)", "xxx", true);
+ tester.checkFails("cast('' as boolean)", "xxx", true);
+ tester.checkFails("cast('' as integer)", "xxx", true);
+ tester.checkFails("cast('' as real)", "xxx", true);
+ tester.checkFails("cast('' as double)", "xxx", true);
+ tester.checkFails("cast('' as smallint)", "xxx", true);
+ }
}
@Test public void testCastDateTime() {
@@ -1342,21 +1356,23 @@ public abstract class SqlOperatorBaseTest {
tester.checkFails(
"cast('nottime' as TIME)", BAD_DATETIME_MESSAGE,
true);
- tester.checkFails(
- "cast('1241241' as TIME)", BAD_DATETIME_MESSAGE,
- true);
- tester.checkFails(
- "cast('12:54:78' as TIME)", BAD_DATETIME_MESSAGE,
- true);
- tester.checkFails(
- "cast('12:34:5' as TIME)", BAD_DATETIME_MESSAGE,
- true);
- tester.checkFails(
- "cast('12:3:45' as TIME)", BAD_DATETIME_MESSAGE,
- true);
- tester.checkFails(
- "cast('1:23:45' as TIME)", BAD_DATETIME_MESSAGE,
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails(
+ "cast('1241241' as TIME)", BAD_DATETIME_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast('12:54:78' as TIME)", BAD_DATETIME_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast('12:34:5' as TIME)", BAD_DATETIME_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast('12:3:45' as TIME)", BAD_DATETIME_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast('1:23:45' as TIME)", BAD_DATETIME_MESSAGE,
+ true);
+ }
// timestamp <-> string
checkCastToString(
@@ -1406,18 +1422,21 @@ public abstract class SqlOperatorBaseTest {
tester.checkFails(
"cast('nottime' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
true);
- tester.checkFails(
- "cast('1241241' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
- true);
- tester.checkFails(
- "cast('1945-20-24 12:42:25.34' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
- true);
- tester.checkFails(
- "cast('1945-01-24 25:42:25.34' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
- true);
- tester.checkFails(
- "cast('1945-1-24 12:23:34.454' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
- true);
+
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails(
+ "cast('1241241' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast('1945-20-24 12:42:25.34' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast('1945-01-24 25:42:25.34' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast('1945-1-24 12:23:34.454' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
+ true);
+ }
// date <-> string
checkCastToString("DATE '1945-02-24'", null, "1945-02-24");
@@ -1438,12 +1457,15 @@ public abstract class SqlOperatorBaseTest {
tester.checkFails(
"cast('notdate' as DATE)", BAD_DATETIME_MESSAGE,
true);
- tester.checkFails(
- "cast('52534253' as DATE)", BAD_DATETIME_MESSAGE,
- true);
- tester.checkFails(
- "cast('1945-30-24' as DATE)", BAD_DATETIME_MESSAGE,
- true);
+
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails(
+ "cast('52534253' as DATE)", BAD_DATETIME_MESSAGE,
+ true);
+ tester.checkFails(
+ "cast('1945-30-24' as DATE)", BAD_DATETIME_MESSAGE,
+ true);
+ }
// cast null
tester.checkNull("cast(null as date)");
@@ -1896,12 +1918,14 @@ public abstract class SqlOperatorBaseTest {
}
tester.checkScalar("{fn DAYOFMONTH(DATE '2014-12-10')}", 10,
"BIGINT NOT NULL");
- tester.checkFails("{fn DAYOFWEEK(DATE '2014-12-10')}",
- "cannot translate call EXTRACT.*",
- true);
- tester.checkFails("{fn DAYOFYEAR(DATE '2014-12-10')}",
- "cannot translate call EXTRACT.*",
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails("{fn DAYOFWEEK(DATE '2014-12-10')}",
+ "cannot translate call EXTRACT.*",
+ true);
+ tester.checkFails("{fn DAYOFYEAR(DATE '2014-12-10')}",
+ "cannot translate call EXTRACT.*",
+ true);
+ }
tester.checkScalar("{fn HOUR(TIMESTAMP '2014-12-10 12:34:56')}", 12,
"BIGINT NOT NULL");
tester.checkScalar("{fn MINUTE(TIMESTAMP '2014-12-10 12:34:56')}", 34,
@@ -1921,9 +1945,12 @@ public abstract class SqlOperatorBaseTest {
tester.checkScalar("{fn TIMESTAMPDIFF(HOUR,"
+ " TIMESTAMP '2014-03-29 12:34:56',"
+ " TIMESTAMP '2014-03-29 12:34:56')}", "0", "INTEGER NOT NULL");
- tester.checkFails("{fn WEEK(DATE '2014-12-10')}",
- "cannot translate call EXTRACT.*",
- true);
+
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails("{fn WEEK(DATE '2014-12-10')}",
+ "cannot translate call EXTRACT.*",
+ true);
+ }
tester.checkScalar("{fn YEAR(DATE '2014-12-10')}", 2014, "BIGINT NOT NULL");
// System Functions
@@ -2192,9 +2219,11 @@ public abstract class SqlOperatorBaseTest {
}
tester.checkNull("1e1 / cast(null as float)");
- tester.checkFails(
- "100.1 / 0.00000000000000001", OUT_OF_RANGE_MESSAGE,
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails(
+ "100.1 / 0.00000000000000001", OUT_OF_RANGE_MESSAGE,
+ true);
+ }
}
@Test public void testDivideOperatorIntervals() {
@@ -3963,15 +3992,17 @@ public abstract class SqlOperatorBaseTest {
+ " \\^",
true);
- tester.checkFails(
- "'cd' similar to '[(a-e)]d' ",
- "Invalid regular expression: \\[\\(a-e\\)\\]d at 1",
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails(
+ "'cd' similar to '[(a-e)]d' ",
+ "Invalid regular expression: \\[\\(a-e\\)\\]d at 1",
+ true);
- tester.checkFails(
- "'yd' similar to '[(a-e)]d' ",
- "Invalid regular expression: \\[\\(a-e\\)\\]d at 1",
- true);
+ tester.checkFails(
+ "'yd' similar to '[(a-e)]d' ",
+ "Invalid regular expression: \\[\\(a-e\\)\\]d at 1",
+ true);
+ }
// all the following tests wrong results due to missing functionality
// or defect (FRG-375, 377).
@@ -5643,15 +5674,17 @@ public abstract class SqlOperatorBaseTest {
SqlStdOperatorTable.WEEK,
VM_FENNEL,
VM_JAVA);
- // TODO: Not implemented in operator test execution code
- tester.checkFails(
- "week(date '2008-1-23')",
- "cannot translate call EXTRACT.*",
- true);
- tester.checkFails(
- "week(cast(null as date))",
- "cannot translate call EXTRACT.*",
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ // TODO: Not implemented in operator test execution code
+ tester.checkFails(
+ "week(date '2008-1-23')",
+ "cannot translate call EXTRACT.*",
+ true);
+ tester.checkFails(
+ "week(cast(null as date))",
+ "cannot translate call EXTRACT.*",
+ true);
+ }
}
@Test public void testDayOfYear() {
@@ -5659,15 +5692,17 @@ public abstract class SqlOperatorBaseTest {
SqlStdOperatorTable.DAYOFYEAR,
VM_FENNEL,
VM_JAVA);
- // TODO: Not implemented in operator test execution code
- tester.checkFails(
- "dayofyear(date '2008-1-23')",
- "cannot translate call EXTRACT.*",
- true);
- tester.checkFails(
- "dayofyear(cast(null as date))",
- "cannot translate call EXTRACT.*",
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ // TODO: Not implemented in operator test execution code
+ tester.checkFails(
+ "dayofyear(date '2008-1-23')",
+ "cannot translate call EXTRACT.*",
+ true);
+ tester.checkFails(
+ "dayofyear(cast(null as date))",
+ "cannot translate call EXTRACT.*",
+ true);
+ }
}
@Test public void testDayOfMonth() {
@@ -5687,14 +5722,16 @@ public abstract class SqlOperatorBaseTest {
SqlStdOperatorTable.DAYOFWEEK,
VM_FENNEL,
VM_JAVA);
- // TODO: Not implemented in operator test execution code
- tester.checkFails(
- "dayofweek(date '2008-1-23')",
- "cannot translate call EXTRACT.*",
- true);
- tester.checkFails("dayofweek(cast(null as date))",
- "cannot translate call EXTRACT.*",
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ // TODO: Not implemented in operator test execution code
+ tester.checkFails(
+ "dayofweek(date '2008-1-23')",
+ "cannot translate call EXTRACT.*",
+ true);
+ tester.checkFails("dayofweek(cast(null as date))",
+ "cannot translate call EXTRACT.*",
+ true);
+ }
}
@Test public void testHour() {
@@ -5874,14 +5911,16 @@ public abstract class SqlOperatorBaseTest {
// Postgres doesn't support DOW, ISODOW, DOY and WEEK on INTERVAL DAY TIME type.
// SQL standard doesn't have extract units for DOW, ISODOW, DOY and WEEK.
- tester.checkFails("extract(doy from interval '2 3:4:5.678' day to second)",
- INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
- tester.checkFails("extract(dow from interval '2 3:4:5.678' day to second)",
- INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
- tester.checkFails("extract(week from interval '2 3:4:5.678' day to second)",
- INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
- tester.checkFails("extract(isodow from interval '2 3:4:5.678' day to second)",
- INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
+ if (Bug.CALCITE_2539_FIXED) {
+ tester.checkFails("extract(doy from interval '2 3:4:5.678' day to second)",
+ INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
+ tester.checkFails("extract(dow from interval '2 3:4:5.678' day to second)",
+ INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
+ tester.checkFails("extract(week from interval '2 3:4:5.678' day to second)",
+ INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
+ tester.checkFails("extract(isodow from interval '2 3:4:5.678' day to second)",
+ INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
+ }
tester.checkFails(
"^extract(month from interval '2 3:4:5.678' day to second)^",
@@ -6109,23 +6148,25 @@ public abstract class SqlOperatorBaseTest {
"2008",
"BIGINT NOT NULL");
- // TODO: Not implemented in operator test execution code
- tester.checkFails(
- "extract(doy from timestamp '2008-2-23 12:34:56')",
- "cannot translate call EXTRACT.*",
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ // TODO: Not implemented in operator test execution code
+ tester.checkFails(
+ "extract(doy from timestamp '2008-2-23 12:34:56')",
+ "cannot translate call EXTRACT.*",
+ true);
- // TODO: Not implemented in operator test execution code
- tester.checkFails(
- "extract(dow from timestamp '2008-2-23 12:34:56')",
- "cannot translate call EXTRACT.*",
- true);
+ // TODO: Not implemented in operator test execution code
+ tester.checkFails(
+ "extract(dow from timestamp '2008-2-23 12:34:56')",
+ "cannot translate call EXTRACT.*",
+ true);
- // TODO: Not implemented in operator test execution code
- tester.checkFails(
- "extract(week from timestamp '2008-2-23 12:34:56')",
- "cannot translate call EXTRACT.*",
- true);
+ // TODO: Not implemented in operator test execution code
+ tester.checkFails(
+ "extract(week from timestamp '2008-2-23 12:34:56')",
+ "cannot translate call EXTRACT.*",
+ true);
+ }
tester.checkScalar(
"extract(decade from timestamp '2008-2-23 12:34:56')",
@@ -6817,7 +6858,7 @@ public abstract class SqlOperatorBaseTest {
* {@code SELECT sum(1) FROM emp GROUP BY deptno} has type "INTEGER NOT NULL",
*/
protected void checkAggType(SqlTester tester, String expr, String type) {
- tester.checkColumnType(SqlTesterImpl.buildQueryAgg(expr), type);
+ tester.checkColumnType(AbstractSqlTester.buildQueryAgg(expr), type);
}
@Test public void testAvgFunc() {
@@ -7322,6 +7363,7 @@ public abstract class SqlOperatorBaseTest {
"0",
0d);
}
+
/**
* Tests that CAST fails when given a value just outside the valid range for
* that type. For example,
@@ -7414,15 +7456,17 @@ public abstract class SqlOperatorBaseTest {
// Casting overlarge string/binary values do not fail -
// they are truncated. See testCastTruncates().
} else {
- // Value outside legal bound should fail at runtime (not
- // validate time).
- //
- // NOTE: Because Java and Fennel calcs give
- // different errors, the pattern hedges its bets.
- tester.checkFails(
- "CAST(" + literalString + " AS " + type + ")",
- "(?s).*(Overflow during calculation or cast\\.|Code=22003).*",
- true);
+ if (Bug.CALCITE_2539_FIXED) {
+ // Value outside legal bound should fail at runtime (not
+ // validate time).
+ //
+ // NOTE: Because Java and Fennel calcs give
+ // different errors, the pattern hedges its bets.
+ tester.checkFails(
+ "CAST(" + literalString + " AS " + type + ")",
+ "(?s).*(Overflow during calculation or cast\\.|Code=22003).*",
+ true);
+ }
}
}
}
@@ -7533,7 +7577,7 @@ public abstract class SqlOperatorBaseTest {
query = "SELECT " + s + " FROM (VALUES (1))";
}
} else {
- query = SqlTesterImpl.buildQuery(s);
+ query = AbstractSqlTester.buildQuery(s);
}
tester.check(query, SqlTests.ANY_TYPE_CHECKER,
SqlTests.ANY_PARAMETER_CHECKER, result -> { });
@@ -7648,7 +7692,7 @@ public abstract class SqlOperatorBaseTest {
* Implementation of {@link org.apache.calcite.sql.test.SqlTester} based on a
* JDBC connection.
*/
- protected static class TesterImpl extends SqlTesterImpl {
+ protected static class TesterImpl extends SqlRuntimeTester {
public TesterImpl(SqlTestFactory testFactory) {
super(testFactory);
}
@@ -7672,8 +7716,8 @@ public abstract class SqlOperatorBaseTest {
}
}
- @Override protected TesterImpl with(final String name, final Object value) {
- return new TesterImpl(factory.with(name, value));
+ @Override protected SqlTester with(SqlTestFactory factory) {
+ return new TesterImpl(factory);
}
}
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/sql/test/SqlRuntimeTester.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlRuntimeTester.java b/core/src/test/java/org/apache/calcite/sql/test/SqlRuntimeTester.java
new file mode 100644
index 0000000..25f5285
--- /dev/null
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlRuntimeTester.java
@@ -0,0 +1,88 @@
+/*
+ * 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.calcite.sql.test;
+
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.parser.SqlParserUtil;
+import org.apache.calcite.sql.validate.SqlValidator;
+
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * Tester of {@link SqlValidator} and runtime execution of the input SQL.
+ */
+public class SqlRuntimeTester extends AbstractSqlTester {
+ public SqlRuntimeTester(SqlTestFactory factory) {
+ super(factory);
+ }
+
+ @Override protected SqlTester with(SqlTestFactory factory) {
+ return new SqlRuntimeTester(factory);
+ }
+
+ @Override public void checkFails(String expression, String expectedError,
+ boolean runtime) {
+ final String sql =
+ runtime ? buildQuery2(expression) : buildQuery(expression);
+ assertExceptionIsThrown(sql, expectedError, runtime);
+ }
+
+ public void assertExceptionIsThrown(
+ String sql,
+ String expectedMsgPattern) {
+ assertExceptionIsThrown(sql, expectedMsgPattern, false);
+ }
+
+ public void assertExceptionIsThrown(String sql, String expectedMsgPattern,
+ boolean runtime) {
+ final SqlNode sqlNode;
+ final SqlParserUtil.StringAndPos sap = SqlParserUtil.findPos(sql);
+ try {
+ sqlNode = parseQuery(sap.sql);
+ } catch (Throwable e) {
+ checkParseEx(e, expectedMsgPattern, sap.sql);
+ return;
+ }
+
+ Throwable thrown = null;
+ final SqlTests.Stage stage;
+ final SqlValidator validator = getValidator();
+ if (runtime) {
+ stage = SqlTests.Stage.RUNTIME;
+ SqlNode validated = validator.validate(sqlNode);
+ assertNotNull(validated);
+ try {
+ check(sap.sql, SqlTests.ANY_TYPE_CHECKER,
+ SqlTests.ANY_PARAMETER_CHECKER, SqlTests.ANY_RESULT_CHECKER);
+ } catch (Throwable ex) {
+ // get the real exception in runtime check
+ thrown = ex;
+ }
+ } else {
+ stage = SqlTests.Stage.VALIDATE;
+ try {
+ validator.validate(sqlNode);
+ } catch (Throwable ex) {
+ thrown = ex;
+ }
+ }
+
+ SqlTests.checkEx(thrown, expectedMsgPattern, sap, stage);
+ }
+}
+
+// End SqlRuntimeTester.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/sql/test/SqlTesterImpl.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlTesterImpl.java b/core/src/test/java/org/apache/calcite/sql/test/SqlTesterImpl.java
deleted file mode 100644
index 533cb99..0000000
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlTesterImpl.java
+++ /dev/null
@@ -1,668 +0,0 @@
-/*
- * 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.calcite.sql.test;
-
-import org.apache.calcite.avatica.util.Casing;
-import org.apache.calcite.avatica.util.Quoting;
-import org.apache.calcite.config.CalciteConnectionProperty;
-import org.apache.calcite.config.Lex;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeField;
-import org.apache.calcite.runtime.Utilities;
-import org.apache.calcite.sql.SqlCall;
-import org.apache.calcite.sql.SqlCollation;
-import org.apache.calcite.sql.SqlIntervalLiteral;
-import org.apache.calcite.sql.SqlLiteral;
-import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlOperatorTable;
-import org.apache.calcite.sql.SqlSelect;
-import org.apache.calcite.sql.dialect.AnsiSqlDialect;
-import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.sql.parser.SqlParseException;
-import org.apache.calcite.sql.parser.SqlParser;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.parser.SqlParserUtil;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.util.SqlShuttle;
-import org.apache.calcite.sql.validate.SqlConformance;
-import org.apache.calcite.sql.validate.SqlConformanceEnum;
-import org.apache.calcite.sql.validate.SqlMonotonicity;
-import org.apache.calcite.sql.validate.SqlValidator;
-import org.apache.calcite.sql.validate.SqlValidatorNamespace;
-import org.apache.calcite.sql.validate.SqlValidatorScope;
-import org.apache.calcite.test.CalciteAssert;
-import org.apache.calcite.test.SqlValidatorTestCase;
-import org.apache.calcite.util.Pair;
-import org.apache.calcite.util.TestUtil;
-import org.apache.calcite.util.Util;
-
-import com.google.common.collect.ImmutableList;
-
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.NoSuchElementException;
-
-import static org.apache.calcite.sql.SqlUtil.stripAs;
-
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Implementation of {@link org.apache.calcite.test.SqlValidatorTestCase.Tester}
- * that talks to a mock catalog.
- */
-public class SqlTesterImpl implements SqlTester, AutoCloseable {
- protected final SqlTestFactory factory;
-
- public SqlTesterImpl(SqlTestFactory factory) {
- this.factory = factory;
- }
-
- public final SqlTestFactory getFactory() {
- return factory;
- }
-
- /**
- * {@inheritDoc}
- *
- * <p>This default implementation does nothing.
- */
- public void close() {
- // no resources to release
- }
-
- public final SqlConformance getConformance() {
- return (SqlConformance) factory.get("conformance");
- }
-
- public final SqlValidator getValidator() {
- return factory.getValidator();
- }
-
- public void assertExceptionIsThrown(
- String sql,
- String expectedMsgPattern) {
- SqlValidator validator;
- SqlNode sqlNode;
- SqlParserUtil.StringAndPos sap = SqlParserUtil.findPos(sql);
- try {
- sqlNode = parseQuery(sap.sql);
- validator = getValidator();
- } catch (SqlParseException e) {
- String errMessage = e.getMessage();
- if (expectedMsgPattern == null) {
- throw new RuntimeException("Error while parsing query:" + sap.sql, e);
- } else if (errMessage == null
- || !errMessage.matches(expectedMsgPattern)) {
- throw new RuntimeException("Error did not match expected ["
- + expectedMsgPattern + "] while parsing query ["
- + sap.sql + "]", e);
- }
- return;
- } catch (Throwable e) {
- throw new RuntimeException("Error while parsing query: " + sap.sql, e);
- }
-
- Throwable thrown = null;
- try {
- validator.validate(sqlNode);
- } catch (Throwable ex) {
- thrown = ex;
- }
-
- SqlValidatorTestCase.checkEx(thrown, expectedMsgPattern, sap);
- }
-
- public RelDataType getColumnType(String sql) {
- RelDataType rowType = getResultType(sql);
- final List<RelDataTypeField> fields = rowType.getFieldList();
- assertEquals("expected query to return 1 field", 1, fields.size());
- return fields.get(0).getType();
- }
-
- public RelDataType getResultType(String sql) {
- SqlValidator validator = getValidator();
- SqlNode n = parseAndValidate(validator, sql);
-
- return validator.getValidatedNodeType(n);
- }
-
- public SqlNode parseAndValidate(SqlValidator validator, String sql) {
- if (validator == null) {
- validator = getValidator();
- }
- SqlNode sqlNode;
- try {
- sqlNode = parseQuery(sql);
- } catch (Throwable e) {
- throw new RuntimeException("Error while parsing query: " + sql, e);
- }
- return validator.validate(sqlNode);
- }
-
- public SqlNode parseQuery(String sql) throws SqlParseException {
- SqlParser parser = factory.createParser(sql);
- return parser.parseQuery();
- }
-
- public void checkColumnType(String sql, String expected) {
- RelDataType actualType = getColumnType(sql);
- String actual = SqlTests.getTypeString(actualType);
- assertEquals(expected, actual);
- }
-
- public void checkFieldOrigin(String sql, String fieldOriginList) {
- SqlValidator validator = getValidator();
- SqlNode n = parseAndValidate(validator, sql);
- final List<List<String>> list = validator.getFieldOrigins(n);
- final StringBuilder buf = new StringBuilder("{");
- int i = 0;
- for (List<String> strings : list) {
- if (i++ > 0) {
- buf.append(", ");
- }
- if (strings == null) {
- buf.append("null");
- } else {
- int j = 0;
- for (String s : strings) {
- if (j++ > 0) {
- buf.append('.');
- }
- buf.append(s);
- }
- }
- }
- buf.append("}");
- assertEquals(fieldOriginList, buf.toString());
- }
-
- public void checkResultType(String sql, String expected) {
- RelDataType actualType = getResultType(sql);
- String actual = SqlTests.getTypeString(actualType);
- assertEquals(expected, actual);
- }
-
- public void checkIntervalConv(String sql, String expected) {
- SqlValidator validator = getValidator();
- final SqlCall n = (SqlCall) parseAndValidate(validator, sql);
-
- SqlNode node = null;
- for (int i = 0; i < n.operandCount(); i++) {
- node = stripAs(n.operand(i));
- if (node instanceof SqlCall) {
- node = ((SqlCall) node).operand(0);
- break;
- }
- }
-
- assertNotNull(node);
- SqlIntervalLiteral intervalLiteral = (SqlIntervalLiteral) node;
- SqlIntervalLiteral.IntervalValue interval =
- (SqlIntervalLiteral.IntervalValue) intervalLiteral.getValue();
- long l =
- interval.getIntervalQualifier().isYearMonth()
- ? SqlParserUtil.intervalToMonths(interval)
- : SqlParserUtil.intervalToMillis(interval);
- String actual = l + "";
- assertEquals(expected, actual);
- }
-
- public void checkType(String expression, String type) {
- for (String sql : buildQueries(expression)) {
- checkColumnType(sql, type);
- }
- }
-
- public void checkCollation(
- String expression,
- String expectedCollationName,
- SqlCollation.Coercibility expectedCoercibility) {
- for (String sql : buildQueries(expression)) {
- RelDataType actualType = getColumnType(sql);
- SqlCollation collation = actualType.getCollation();
-
- assertEquals(
- expectedCollationName, collation.getCollationName());
- assertEquals(expectedCoercibility, collation.getCoercibility());
- }
- }
-
- public void checkCharset(
- String expression,
- Charset expectedCharset) {
- for (String sql : buildQueries(expression)) {
- RelDataType actualType = getColumnType(sql);
- Charset actualCharset = actualType.getCharset();
-
- if (!expectedCharset.equals(actualCharset)) {
- fail("\n"
- + "Expected=" + expectedCharset.name() + "\n"
- + " actual=" + actualCharset.name());
- }
- }
- }
-
- public SqlTesterImpl withQuoting(Quoting quoting) {
- return with("quoting", quoting);
- }
-
- public SqlTester withQuotedCasing(Casing casing) {
- return with("quotedCasing", casing);
- }
-
- public SqlTester withUnquotedCasing(Casing casing) {
- return with("unquotedCasing", casing);
- }
-
- public SqlTester withCaseSensitive(boolean sensitive) {
- return with("caseSensitive", sensitive);
- }
-
- public SqlTester withLex(Lex lex) {
- return withQuoting(lex.quoting)
- .withCaseSensitive(lex.caseSensitive)
- .withQuotedCasing(lex.quotedCasing)
- .withUnquotedCasing(lex.unquotedCasing);
- }
-
- public SqlTesterImpl withConformance(SqlConformance conformance) {
- if (conformance == null) {
- conformance = SqlConformanceEnum.DEFAULT;
- }
- final SqlTesterImpl tester = with("conformance", conformance);
- if (conformance instanceof SqlConformanceEnum) {
- return tester
- .withConnectionFactory(
- CalciteAssert.EMPTY_CONNECTION_FACTORY
- .with(CalciteConnectionProperty.CONFORMANCE, conformance));
- } else {
- return tester;
- }
- }
-
- public SqlTester withOperatorTable(SqlOperatorTable operatorTable) {
- return with("operatorTable", operatorTable);
- }
-
- public SqlTesterImpl withConnectionFactory(
- CalciteAssert.ConnectionFactory connectionFactory) {
- return with("connectionFactory", connectionFactory);
- }
-
- protected SqlTesterImpl with(final String name, final Object value) {
- return new SqlTesterImpl(factory.with(name, value));
- }
-
- // SqlTester methods
-
- public void setFor(
- SqlOperator operator,
- VmName... unimplementedVmNames) {
- // do nothing
- }
-
- public void checkAgg(
- String expr,
- String[] inputValues,
- Object result,
- double delta) {
- String query =
- SqlTests.generateAggQuery(expr, inputValues);
- check(query, SqlTests.ANY_TYPE_CHECKER, result, delta);
- }
-
- public void checkWinAgg(
- String expr,
- String[] inputValues,
- String windowSpec,
- String type,
- Object result,
- double delta) {
- String query =
- SqlTests.generateWinAggQuery(
- expr, windowSpec, inputValues);
- check(query, SqlTests.ANY_TYPE_CHECKER, result, delta);
- }
-
- public void checkScalar(
- String expression,
- Object result,
- String resultType) {
- checkType(expression, resultType);
- for (String sql : buildQueries(expression)) {
- check(sql, SqlTests.ANY_TYPE_CHECKER, result, 0);
- }
- }
-
- public void checkScalarExact(
- String expression,
- String result) {
- for (String sql : buildQueries(expression)) {
- check(sql, SqlTests.INTEGER_TYPE_CHECKER, result, 0);
- }
- }
-
- public void checkScalarExact(
- String expression,
- String expectedType,
- String result) {
- for (String sql : buildQueries(expression)) {
- TypeChecker typeChecker =
- new SqlTests.StringTypeChecker(expectedType);
- check(sql, typeChecker, result, 0);
- }
- }
-
- public void checkScalarApprox(
- String expression,
- String expectedType,
- double expectedResult,
- double delta) {
- for (String sql : buildQueries(expression)) {
- TypeChecker typeChecker =
- new SqlTests.StringTypeChecker(expectedType);
- check(sql, typeChecker, expectedResult, delta);
- }
- }
-
- public void checkBoolean(
- String expression,
- Boolean result) {
- for (String sql : buildQueries(expression)) {
- if (null == result) {
- checkNull(expression);
- } else {
- check(
- sql,
- SqlTests.BOOLEAN_TYPE_CHECKER,
- result.toString(),
- 0);
- }
- }
- }
-
- public void checkString(
- String expression,
- String result,
- String expectedType) {
- for (String sql : buildQueries(expression)) {
- TypeChecker typeChecker =
- new SqlTests.StringTypeChecker(expectedType);
- check(sql, typeChecker, result, 0);
- }
- }
-
- public void checkNull(String expression) {
- for (String sql : buildQueries(expression)) {
- check(sql, SqlTests.ANY_TYPE_CHECKER, null, 0);
- }
- }
-
- public final void check(
- String query,
- TypeChecker typeChecker,
- Object result,
- double delta) {
- check(query, typeChecker, SqlTests.ANY_PARAMETER_CHECKER,
- SqlTests.createChecker(result, delta));
- }
-
- public void check(String query, TypeChecker typeChecker,
- ParameterChecker parameterChecker, ResultChecker resultChecker) {
- // This implementation does NOT check the result!
- // All it does is check the return type.
-
- if (typeChecker == null) {
- // Parse and validate. There should be no errors.
- Util.discard(getResultType(query));
- } else {
- // Parse and validate. There should be no errors.
- // There must be 1 column. Get its type.
- RelDataType actualType = getColumnType(query);
-
- // Check result type.
- typeChecker.checkType(actualType);
- }
-
- SqlValidator validator = getValidator();
- SqlNode n = parseAndValidate(validator, query);
- final RelDataType parameterRowType = validator.getParameterRowType(n);
- parameterChecker.checkParameters(parameterRowType);
- }
-
- public void checkMonotonic(String query,
- SqlMonotonicity expectedMonotonicity) {
- SqlValidator validator = getValidator();
- SqlNode n = parseAndValidate(validator, query);
- final RelDataType rowType = validator.getValidatedNodeType(n);
- final SqlValidatorNamespace selectNamespace = validator.getNamespace(n);
- final String field0 = rowType.getFieldList().get(0).getName();
- final SqlMonotonicity monotonicity =
- selectNamespace.getMonotonicity(field0);
- assertThat(monotonicity, equalTo(expectedMonotonicity));
- }
-
- public void checkRewrite(
- SqlValidator validator,
- String query,
- String expectedRewrite) {
- SqlNode rewrittenNode = parseAndValidate(validator, query);
- String actualRewrite =
- rewrittenNode.toSqlString(AnsiSqlDialect.DEFAULT, false).getSql();
- TestUtil.assertEqualsVerbose(expectedRewrite, Util.toLinux(actualRewrite));
- }
-
- public void checkFails(
- String expression,
- String expectedError,
- boolean runtime) {
- if (runtime) {
- // We need to test that the expression fails at runtime.
- // Ironically, that means that it must succeed at prepare time.
- SqlValidator validator = getValidator();
- final String sql = buildQuery(expression);
- SqlNode n = parseAndValidate(validator, sql);
- assertNotNull(n);
- } else {
- checkQueryFails(buildQuery(expression), expectedError);
- }
- }
-
- public void checkQueryFails(String sql, String expectedError) {
- assertExceptionIsThrown(sql, expectedError);
- }
-
- public void checkQuery(String sql) {
- assertExceptionIsThrown(sql, null);
- }
-
- public SqlMonotonicity getMonotonicity(String sql) {
- final SqlValidator validator = getValidator();
- final SqlNode node = parseAndValidate(validator, sql);
- final SqlSelect select = (SqlSelect) node;
- final SqlNode selectItem0 = select.getSelectList().get(0);
- final SqlValidatorScope scope = validator.getSelectScope(select);
- return selectItem0.getMonotonicity(scope);
- }
-
- public static String buildQuery(String expression) {
- return "values (" + expression + ")";
- }
-
- public static String buildQueryAgg(String expression) {
- return "select " + expression + " from (values (1)) as t(x) group by x";
- }
-
- /**
- * Builds a query that extracts all literals as columns in an underlying
- * select.
- *
- * <p>For example,</p>
- *
- * <blockquote>{@code 1 < 5}</blockquote>
- *
- * <p>becomes</p>
- *
- * <blockquote>{@code SELECT p0 < p1
- * FROM (VALUES (1, 5)) AS t(p0, p1)}</blockquote>
- *
- * <p>Null literals don't have enough type information to be extracted.
- * We push down {@code CAST(NULL AS type)} but raw nulls such as
- * {@code CASE 1 WHEN 2 THEN 'a' ELSE NULL END} are left as is.</p>
- *
- * @param expression Scalar expression
- * @return Query that evaluates a scalar expression
- */
- private String buildQuery2(String expression) {
- // "values (1 < 5)"
- // becomes
- // "select p0 < p1 from (values (1, 5)) as t(p0, p1)"
- SqlNode x;
- final String sql = "values (" + expression + ")";
- try {
- x = parseQuery(sql);
- } catch (SqlParseException e) {
- throw new RuntimeException(e);
- }
- final Collection<SqlNode> literalSet = new LinkedHashSet<>();
- x.accept(
- new SqlShuttle() {
- private final List<SqlOperator> ops =
- ImmutableList.of(
- SqlStdOperatorTable.LITERAL_CHAIN,
- SqlStdOperatorTable.LOCALTIME,
- SqlStdOperatorTable.LOCALTIMESTAMP,
- SqlStdOperatorTable.CURRENT_TIME,
- SqlStdOperatorTable.CURRENT_TIMESTAMP);
-
- @Override public SqlNode visit(SqlLiteral literal) {
- if (!isNull(literal)
- && literal.getTypeName() != SqlTypeName.SYMBOL) {
- literalSet.add(literal);
- }
- return literal;
- }
-
- @Override public SqlNode visit(SqlCall call) {
- final SqlOperator operator = call.getOperator();
- if (operator == SqlStdOperatorTable.CAST
- && isNull(call.operand(0))) {
- literalSet.add(call);
- return call;
- } else if (ops.contains(operator)) {
- // "Argument to function 'LOCALTIME' must be a
- // literal"
- return call;
- } else {
- return super.visit(call);
- }
- }
-
- private boolean isNull(SqlNode sqlNode) {
- return sqlNode instanceof SqlLiteral
- && ((SqlLiteral) sqlNode).getTypeName()
- == SqlTypeName.NULL;
- }
- });
- final List<SqlNode> nodes = new ArrayList<>(literalSet);
- nodes.sort((o1, o2) -> {
- final SqlParserPos pos0 = o1.getParserPosition();
- final SqlParserPos pos1 = o2.getParserPosition();
- int c = -Utilities.compare(pos0.getLineNum(), pos1.getLineNum());
- if (c != 0) {
- return c;
- }
- return -Utilities.compare(pos0.getColumnNum(), pos1.getColumnNum());
- });
- String sql2 = sql;
- final List<Pair<String, String>> values = new ArrayList<>();
- int p = 0;
- for (SqlNode literal : nodes) {
- final SqlParserPos pos = literal.getParserPosition();
- final int start =
- SqlParserUtil.lineColToIndex(
- sql, pos.getLineNum(), pos.getColumnNum());
- final int end =
- SqlParserUtil.lineColToIndex(
- sql,
- pos.getEndLineNum(),
- pos.getEndColumnNum()) + 1;
- String param = "p" + (p++);
- values.add(Pair.of(sql2.substring(start, end), param));
- sql2 = sql2.substring(0, start)
- + param
- + sql2.substring(end);
- }
- if (values.isEmpty()) {
- values.add(Pair.of("1", "p0"));
- }
- return "select "
- + sql2.substring("values (".length(), sql2.length() - 1)
- + " from (values ("
- + Util.commaList(Pair.left(values))
- + ")) as t("
- + Util.commaList(Pair.right(values))
- + ")";
- }
-
- /**
- * Converts a scalar expression into a list of SQL queries that
- * evaluate it.
- *
- * @param expression Scalar expression
- * @return List of queries that evaluate an expression
- */
- private Iterable<String> buildQueries(final String expression) {
- // Why an explicit iterable rather than a list? If there is
- // a syntax error in the expression, the calling code discovers it
- // before we try to parse it to do substitutions on the parse tree.
- return () -> new Iterator<String>() {
- int i = 0;
-
- public void remove() {
- throw new UnsupportedOperationException();
- }
-
- public String next() {
- switch (i++) {
- case 0:
- return buildQuery(expression);
- case 1:
- return buildQuery2(expression);
- default:
- throw new NoSuchElementException();
- }
- }
-
- public boolean hasNext() {
- return i < 2;
- }
- };
- }
-
-}
-
-// End SqlTesterImpl.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/sql/test/SqlTests.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlTests.java b/core/src/test/java/org/apache/calcite/sql/test/SqlTests.java
index e0c4bb1..22e3d95 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlTests.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlTests.java
@@ -18,13 +18,19 @@ package org.apache.calcite.sql.test;
import org.apache.calcite.avatica.ColumnMetaData;
import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.runtime.CalciteContextException;
+import org.apache.calcite.sql.parser.SqlParseException;
+import org.apache.calcite.sql.parser.SqlParserUtil;
import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.util.TestUtil;
+import org.apache.calcite.util.Util;
import java.sql.ResultSet;
import java.sql.Types;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
+import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static org.apache.calcite.sql.test.SqlTester.ParameterChecker;
@@ -32,6 +38,7 @@ import static org.apache.calcite.sql.test.SqlTester.ResultChecker;
import static org.apache.calcite.sql.test.SqlTester.TypeChecker;
import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
@@ -62,6 +69,24 @@ public abstract class SqlTests {
};
/**
+ * Checker that allows any result.
+ */
+ public static final ResultChecker ANY_RESULT_CHECKER = result -> {
+ while (true) {
+ if (!result.next()) {
+ break;
+ }
+ }
+ };
+
+ private static final Pattern LINE_COL_PATTERN =
+ Pattern.compile("At line ([0-9]+), column ([0-9]+)");
+
+ private static final Pattern LINE_COL_TWICE_PATTERN =
+ Pattern.compile(
+ "(?s)From line ([0-9]+), column ([0-9]+) to line ([0-9]+), column ([0-9]+): (.*)");
+
+ /**
* Helper function to get the string representation of a RelDataType
* (include precision/scale but no charset or collation)
*
@@ -265,6 +290,199 @@ public abstract class SqlTests {
}
}
+ /**
+ * Checks whether an exception matches the expected pattern. If
+ * <code>sap</code> contains an error location, checks this too.
+ *
+ * @param ex Exception thrown
+ * @param expectedMsgPattern Expected pattern
+ * @param sap Query and (optional) position in query
+ * @param stage Query processing stage
+ */
+ public static void checkEx(Throwable ex,
+ String expectedMsgPattern,
+ SqlParserUtil.StringAndPos sap,
+ Stage stage) {
+ if (null == ex) {
+ if (expectedMsgPattern == null) {
+ // No error expected, and no error happened.
+ return;
+ } else {
+ throw new AssertionError("Expected query to throw exception, "
+ + "but it did not; query [" + sap.sql
+ + "]; expected [" + expectedMsgPattern + "]");
+ }
+ }
+ Throwable actualException = ex;
+ String actualMessage = actualException.getMessage();
+ int actualLine = -1;
+ int actualColumn = -1;
+ int actualEndLine = 100;
+ int actualEndColumn = 99;
+
+ // Search for an CalciteContextException somewhere in the stack.
+ CalciteContextException ece = null;
+ for (Throwable x = ex; x != null; x = x.getCause()) {
+ if (x instanceof CalciteContextException) {
+ ece = (CalciteContextException) x;
+ break;
+ }
+ if (x.getCause() == x) {
+ break;
+ }
+ }
+
+ // Search for a SqlParseException -- with its position set -- somewhere
+ // in the stack.
+ SqlParseException spe = null;
+ for (Throwable x = ex; x != null; x = x.getCause()) {
+ if ((x instanceof SqlParseException)
+ && (((SqlParseException) x).getPos() != null)) {
+ spe = (SqlParseException) x;
+ break;
+ }
+ if (x.getCause() == x) {
+ break;
+ }
+ }
+
+ if (ece != null) {
+ actualLine = ece.getPosLine();
+ actualColumn = ece.getPosColumn();
+ actualEndLine = ece.getEndPosLine();
+ actualEndColumn = ece.getEndPosColumn();
+ if (ece.getCause() != null) {
+ actualException = ece.getCause();
+ actualMessage = actualException.getMessage();
+ }
+ } else if (spe != null) {
+ actualLine = spe.getPos().getLineNum();
+ actualColumn = spe.getPos().getColumnNum();
+ actualEndLine = spe.getPos().getEndLineNum();
+ actualEndColumn = spe.getPos().getEndColumnNum();
+ if (spe.getCause() != null) {
+ actualException = spe.getCause();
+ actualMessage = actualException.getMessage();
+ }
+ } else {
+ final String message = ex.getMessage();
+ if (message != null) {
+ Matcher matcher = LINE_COL_TWICE_PATTERN.matcher(message);
+ if (matcher.matches()) {
+ actualLine = Integer.parseInt(matcher.group(1));
+ actualColumn = Integer.parseInt(matcher.group(2));
+ actualEndLine = Integer.parseInt(matcher.group(3));
+ actualEndColumn = Integer.parseInt(matcher.group(4));
+ actualMessage = matcher.group(5);
+ } else {
+ matcher = LINE_COL_PATTERN.matcher(message);
+ if (matcher.matches()) {
+ actualLine = Integer.parseInt(matcher.group(1));
+ actualColumn = Integer.parseInt(matcher.group(2));
+ } else {
+ if (expectedMsgPattern != null
+ && actualMessage.matches(expectedMsgPattern)) {
+ return;
+ }
+ }
+ }
+ }
+ }
+
+ if (null == expectedMsgPattern) {
+ actualException.printStackTrace();
+ fail(stage.componentName + " threw unexpected exception"
+ + "; query [" + sap.sql
+ + "]; exception [" + actualMessage
+ + "]; class [" + actualException.getClass()
+ + "]; pos [line " + actualLine
+ + " col " + actualColumn
+ + " thru line " + actualLine
+ + " col " + actualColumn + "]");
+ }
+
+ String sqlWithCarets;
+ if (actualColumn <= 0
+ || actualLine <= 0
+ || actualEndColumn <= 0
+ || actualEndLine <= 0) {
+ if (sap.pos != null) {
+ throw new AssertionError("Expected error to have position,"
+ + " but actual error did not: "
+ + " actual pos [line " + actualLine
+ + " col " + actualColumn
+ + " thru line " + actualEndLine + " col "
+ + actualEndColumn + "]", actualException);
+ }
+ sqlWithCarets = sap.sql;
+ } else {
+ sqlWithCarets =
+ SqlParserUtil.addCarets(
+ sap.sql,
+ actualLine,
+ actualColumn,
+ actualEndLine,
+ actualEndColumn + 1);
+ if (sap.pos == null) {
+ throw new AssertionError("Actual error had a position, but expected "
+ + "error did not. Add error position carets to sql:\n"
+ + sqlWithCarets);
+ }
+ }
+
+ if (actualMessage != null) {
+ actualMessage = Util.toLinux(actualMessage);
+ }
+
+ if (actualMessage == null
+ || !actualMessage.matches(expectedMsgPattern)) {
+ actualException.printStackTrace();
+ final String actualJavaRegexp =
+ (actualMessage == null)
+ ? "null"
+ : TestUtil.quoteForJava(
+ TestUtil.quotePattern(actualMessage));
+ fail(stage.componentName + " threw different "
+ + "exception than expected; query [" + sap.sql
+ + "];\n"
+ + " expected pattern [" + expectedMsgPattern
+ + "];\n"
+ + " actual [" + actualMessage
+ + "];\n"
+ + " actual as java regexp [" + actualJavaRegexp
+ + "]; pos [" + actualLine
+ + " col " + actualColumn
+ + " thru line " + actualEndLine
+ + " col " + actualEndColumn
+ + "]; sql [" + sqlWithCarets + "]");
+ } else if (sap.pos != null
+ && (actualLine != sap.pos.getLineNum()
+ || actualColumn != sap.pos.getColumnNum()
+ || actualEndLine != sap.pos.getEndLineNum()
+ || actualEndColumn != sap.pos.getEndColumnNum())) {
+ fail(stage.componentName + " threw expected "
+ + "exception [" + actualMessage
+ + "];\nbut at pos [line " + actualLine
+ + " col " + actualColumn
+ + " thru line " + actualEndLine
+ + " col " + actualEndColumn
+ + "];\nsql [" + sqlWithCarets + "]");
+ }
+ }
+
+ /** Stage of query processing */
+ public enum Stage {
+ PARSE("Parser"),
+ VALIDATE("Validator"),
+ RUNTIME("Executor");
+
+ public final String componentName;
+
+ Stage(String componentName) {
+ this.componentName = componentName;
+ }
+ }
+
//~ Inner Classes ----------------------------------------------------------
/**
@@ -279,9 +497,7 @@ public abstract class SqlTests {
}
public void checkType(RelDataType type) {
- assertEquals(
- typeName.toString(),
- type.toString());
+ assertThat(type.toString(), is(typeName.toString()));
}
}
@@ -308,7 +524,7 @@ public abstract class SqlTests {
public void checkType(RelDataType type) {
String actual = getTypeString(type);
- assertEquals(expected, actual);
+ assertThat(actual, is(expected));
}
}
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/sql/test/SqlValidatorTester.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlValidatorTester.java b/core/src/test/java/org/apache/calcite/sql/test/SqlValidatorTester.java
new file mode 100644
index 0000000..e38d0ed
--- /dev/null
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlValidatorTester.java
@@ -0,0 +1,35 @@
+/*
+ * 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.calcite.sql.test;
+
+import org.apache.calcite.sql.validate.SqlValidator;
+
+/**
+ * Tester of {@link SqlValidator}.
+ */
+public class SqlValidatorTester extends AbstractSqlTester {
+
+ public SqlValidatorTester(SqlTestFactory factory) {
+ super(factory);
+ }
+
+ @Override protected SqlTester with(SqlTestFactory factory) {
+ return new SqlValidatorTester(factory);
+ }
+}
+
+// End SqlValidatorTester.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java b/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
index 0405308..71f6786 100644
--- a/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
@@ -21,7 +21,8 @@ import org.apache.calcite.sql.SqlIdentifier;
import org.apache.calcite.sql.SqlNode;
import org.apache.calcite.sql.parser.SqlParserPos;
import org.apache.calcite.sql.test.SqlTestFactory;
-import org.apache.calcite.sql.test.SqlTesterImpl;
+import org.apache.calcite.sql.test.SqlTester;
+import org.apache.calcite.sql.test.SqlValidatorTester;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
@@ -124,8 +125,8 @@ public class SqlValidatorUtilTest {
final List<SqlNode> newList = new ArrayList<>(2);
newList.add(new SqlIdentifier(Arrays.asList("f0", "c0"), SqlParserPos.ZERO));
newList.add(new SqlIdentifier(Arrays.asList("f0", "c0"), SqlParserPos.ZERO));
- final SqlTesterImpl tester =
- new SqlTesterImpl(SqlTestFactory.INSTANCE);
+ final SqlTester tester =
+ new SqlValidatorTester(SqlTestFactory.INSTANCE);
final SqlValidatorImpl validator =
(SqlValidatorImpl) tester.getValidator();
try {
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlTestGen.java b/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
index ceac204..9a4e263 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
@@ -19,7 +19,7 @@ package org.apache.calcite.test;
import org.apache.calcite.sql.SqlCollation;
import org.apache.calcite.sql.test.SqlTestFactory;
import org.apache.calcite.sql.test.SqlTester;
-import org.apache.calcite.sql.test.SqlTesterImpl;
+import org.apache.calcite.sql.test.SqlValidatorTester;
import org.apache.calcite.sql.validate.SqlValidator;
import org.apache.calcite.util.BarfingInvocationHandler;
import org.apache.calcite.util.Util;
@@ -102,7 +102,7 @@ public class SqlTestGen {
}
public SqlTester getTester() {
- return new SqlTesterImpl(SPOOLER_VALIDATOR) {
+ return new SqlValidatorTester(SPOOLER_VALIDATOR) {
public void assertExceptionIsThrown(
String sql,
String expectedMsgPattern) {
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/test/SqlValidatorDynamicTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorDynamicTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorDynamicTest.java
index 1863157..1bca24b 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorDynamicTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorDynamicTest.java
@@ -18,7 +18,7 @@ package org.apache.calcite.test;
import org.apache.calcite.sql.test.SqlTestFactory;
import org.apache.calcite.sql.test.SqlTester;
-import org.apache.calcite.sql.test.SqlTesterImpl;
+import org.apache.calcite.sql.test.SqlValidatorTester;
import org.apache.calcite.test.catalog.MockCatalogReaderDynamic;
import org.junit.BeforeClass;
@@ -96,7 +96,7 @@ public class SqlValidatorDynamicTest extends SqlValidatorTestCase {
@Override public SqlTester getTester() {
// Dymamic schema should not be reused since it is mutable, so
// we create new SqlTestFactory for each test
- return new SqlTesterImpl(SqlTestFactory.INSTANCE
+ return new SqlValidatorTester(SqlTestFactory.INSTANCE
.withCatalogReader(MockCatalogReaderDynamic::new));
}
//~ Methods ----------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/calcite/blob/c69e1bcb/core/src/test/java/org/apache/calcite/test/SqlValidatorFeatureTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorFeatureTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorFeatureTest.java
index 48cbf0f..b44318f 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorFeatureTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorFeatureTest.java
@@ -24,7 +24,7 @@ import org.apache.calcite.sql.SqlOperatorTable;
import org.apache.calcite.sql.parser.SqlParserPos;
import org.apache.calcite.sql.test.SqlTestFactory;
import org.apache.calcite.sql.test.SqlTester;
-import org.apache.calcite.sql.test.SqlTesterImpl;
+import org.apache.calcite.sql.test.SqlValidatorTester;
import org.apache.calcite.sql.validate.SqlConformance;
import org.apache.calcite.sql.validate.SqlValidatorCatalogReader;
import org.apache.calcite.sql.validate.SqlValidatorImpl;
@@ -55,7 +55,7 @@ public class SqlValidatorFeatureTest extends SqlValidatorTestCase {
//~ Methods ----------------------------------------------------------------
@Override public SqlTester getTester() {
- return new SqlTesterImpl(SqlTestFactory.INSTANCE.withValidator(FeatureValidator::new));
+ return new SqlValidatorTester(SqlTestFactory.INSTANCE.withValidator(FeatureValidator::new));
}
@Test public void testDistinct() {