This is an automated email from the ASF dual-hosted git repository.
zstan pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
The following commit(s) were added to refs/heads/main by this push:
new 77186aac3d IGNITE-20226 Sql. Fix muted tests after disallowed char ->
varbinary casting (#2576)
77186aac3d is described below
commit 77186aac3da817407284de84133b0b611423d6c2
Author: Evgeniy Stanilovskiy <stanilov...@gmail.com>
AuthorDate: Mon Sep 18 09:18:11 2023 +0300
IGNITE-20226 Sql. Fix muted tests after disallowed char -> varbinary
casting (#2576)
---
.../datatypes/tests/BaseDmlDataTypeTest.java | 85 +---------------------
.../tests/BaseExpressionDataTypeTest.java | 40 ----------
.../datatypes/tests/BaseQueryDataTypeTest.java | 30 --------
.../sql/engine/datatypes/uuid/ItUuidDmlTest.java | 51 +++++++++++++
.../datatypes/uuid/ItUuidExpressionTest.java | 38 ++++++++--
.../sql/engine/datatypes/uuid/ItUuidQueryTest.java | 35 +++++++--
6 files changed, 114 insertions(+), 165 deletions(-)
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseDmlDataTypeTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseDmlDataTypeTest.java
index f5f2246304..dacbffcd23 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseDmlDataTypeTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseDmlDataTypeTest.java
@@ -17,14 +17,11 @@
package org.apache.ignite.internal.sql.engine.datatypes.tests;
-import static
org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs.VARBINARY_TYPE;
+import static
org.apache.ignite.internal.sql.engine.util.SqlTestUtils.assertThrowsSqlException;
import static org.apache.ignite.lang.IgniteStringFormatter.format;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsString;
-import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
-import org.apache.ignite.lang.IgniteException;
+import org.apache.ignite.lang.ErrorGroups.Sql;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
@@ -45,22 +42,6 @@ public abstract class BaseDmlDataTypeTest<T extends
Comparable<T>> extends BaseD
checkQuery("SELECT test_key FROM t WHERE
id=1").returns(arguments.value(0)).check();
}
- /** {@code INSERT} with dynamic parameters is not allowed for compatible
types. */
- @ParameterizedTest
- @MethodSource("convertedFrom")
- public void
testInsertFromDynamicParameterFromConvertible(TestTypeArguments<T> arguments) {
- // TODO: fix in scope of
https://issues.apache.org/jira/browse/IGNITE-20226
- if (testTypeSpec == VARBINARY_TYPE) {
- return;
- }
-
- var t = assertThrows(IgniteException.class, () -> {
- runSql("INSERT INTO t VALUES (1, ?)", arguments.argValue(0));
- });
-
- assertThat(t.getMessage(), containsString("Values passed to VALUES
operator must have compatible types"));
- }
-
/** {@code DELETE} by key. */
@Test
public void testDelete() {
@@ -106,64 +87,6 @@ public abstract class BaseDmlDataTypeTest<T extends
Comparable<T>> extends BaseD
.check();
}
- /** {@code UPDATE} is not allowed for dynamic parameter of compatible
type. */
- @ParameterizedTest
- @MethodSource("convertedFrom")
- public void
testUpdateFromDynamicParameterFromConvertible(TestTypeArguments<T> arguments) {
- // TODO: fix in scope of
https://issues.apache.org/jira/browse/IGNITE-20226
- if (testTypeSpec == VARBINARY_TYPE) {
- return;
- }
-
- String insert = format("INSERT INTO t VALUES (1, {})",
arguments.valueExpr(0));
- runSql(insert);
-
- var t = assertThrows(IgniteException.class, () -> {
- checkQuery("UPDATE t SET test_key = ? WHERE id=1")
- .withParams(arguments.argValue(0))
- .returns(1L)
- .check();
- });
-
- String error = format("Dynamic parameter requires adding explicit type
cast",
- testTypeSpec.typeName());
-
- assertThat(t.getMessage(), containsString(error));
- }
-
- /** Type mismatch in {@code INSERT}s {@code VALUES}.*/
- @ParameterizedTest
- @MethodSource("convertedFrom")
- public void testDisallowMismatchTypesOnInsert(TestTypeArguments<T>
arguments) {
- // TODO: fix in scope of
https://issues.apache.org/jira/browse/IGNITE-20226
- if (testTypeSpec == VARBINARY_TYPE) {
- return;
- }
-
- var query = format("INSERT INTO t (id, test_key) VALUES (10, null),
(20, {})", arguments.valueExpr(0));
- var t = assertThrows(IgniteException.class, () -> runSql(query));
-
- assertThat(t.getMessage(), containsString("Values passed to VALUES
operator must have compatible types"));
- }
-
- /**
- * Type mismatch in {@code INSERT}s {@code VALUES} with dynamic parameters.
- */
- @ParameterizedTest
- @MethodSource("convertedFrom")
- public void
testDisallowMismatchTypesOnInsertDynamicParam(TestTypeArguments<T> arguments) {
- // TODO: fix in scope of
https://issues.apache.org/jira/browse/IGNITE-20226
- if (testTypeSpec == VARBINARY_TYPE) {
- return;
- }
-
- Object value1 = arguments.argValue(0);
-
- var query = "INSERT INTO t (id, test_key) VALUES (1, null), (2, ?)";
- var t = assertThrows(IgniteException.class, () -> runSql(query,
value1));
- assertThat(t.getMessage(), containsString("Values passed to VALUES
operator must have compatible types"));
- }
-
/**
* Type mismatch in {@code INSERT}s {@code VALUES} with dynamic parameters.
*/
@@ -173,8 +96,8 @@ public abstract class BaseDmlDataTypeTest<T extends
Comparable<T>> extends BaseD
Object value1 = arguments.argValue(0);
var query = "INSERT INTO t (id, test_key) VALUES (1, 'str'), (2, ?)";
- var t = assertThrows(IgniteException.class, () -> runSql(query,
value1));
- assertThat(t.getMessage(), containsString("Values passed to VALUES
operator must have compatible types"));
+ assertThrowsSqlException(Sql.STMT_VALIDATION_ERR, "Values passed to
VALUES operator must have compatible types",
+ () -> runSql(query, value1));
}
private Stream<TestTypeArguments<T>> dml() {
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseExpressionDataTypeTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseExpressionDataTypeTest.java
index b7dc86924d..4fa05caf04 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseExpressionDataTypeTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseExpressionDataTypeTest.java
@@ -17,17 +17,12 @@
package org.apache.ignite.internal.sql.engine.datatypes.tests;
-import static
org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs.VARBINARY_TYPE;
import static org.apache.ignite.lang.IgniteStringFormatter.format;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsString;
-import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.Objects;
import java.util.stream.Stream;
import org.apache.ignite.internal.sql.engine.util.MetadataMatcher;
import org.apache.ignite.internal.sql.engine.util.QueryChecker;
-import org.apache.ignite.lang.IgniteException;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
@@ -122,24 +117,6 @@ public abstract class BaseExpressionDataTypeTest<T extends
Comparable<T>> extend
checkQuery("SELECT COALESCE($0, NULL)").returns(value1).check();
}
- /**
- * {@code COALESCE} operator does not allow different types in its
arguments.
- */
- @ParameterizedTest
- @MethodSource("convertedFrom")
- public void testCoalesceMissingTypesIsIllegal(TestTypeArguments arguments)
{
- // TODO: fix in scope of
https://issues.apache.org/jira/browse/IGNITE-20226
- if (testTypeSpec == VARBINARY_TYPE) {
- return;
- }
-
- IgniteException t = assertThrows(IgniteException.class, () -> {
- checkQuery(format("SELECT COALESCE($0, {})",
arguments.valueExpr(0))).check();
- });
-
- assertThat(t.getMessage(), containsString("Illegal mixing of types in
CASE or COALESCE statement"));
- }
-
/**
* {@code NULLIF} operator.
*/
@@ -222,23 +199,6 @@ public abstract class BaseExpressionDataTypeTest<T extends
Comparable<T>> extend
.check();
}
- /** Data type from string. **/
- @Test
- public void testCastFromString() {
- // TODO: fix in scope of
https://issues.apache.org/jira/browse/IGNITE-20226
- if (testTypeSpec == VARBINARY_TYPE) {
- return;
- }
-
- T value = dataSamples.values().get(0);
- String stringValue = testTypeSpec.toStringValue(value);
-
- checkQuery(format("SELECT CAST('{}' AS <type>)",
stringValue)).returns(value).check();
-
- // PG style cast
- checkQuery(format("SELECT '{}'::<type>",
stringValue)).returns(value).check();
- }
-
/**
* {@code BETWEEN} operator.
*/
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseQueryDataTypeTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseQueryDataTypeTest.java
index b5e543f1c0..41495d3158 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseQueryDataTypeTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseQueryDataTypeTest.java
@@ -17,14 +17,9 @@
package org.apache.ignite.internal.sql.engine.datatypes.tests;
-import static
org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs.VARBINARY_TYPE;
import static org.apache.ignite.lang.IgniteStringFormatter.format;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsString;
-import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
-import org.apache.ignite.lang.IgniteException;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
@@ -100,30 +95,6 @@ public abstract class BaseQueryDataTypeTest<T extends
Comparable<T>> extends Bas
.check();
}
- /** Test for equality predicate with dynamic parameter of compatible type
is illegal. */
- @ParameterizedTest
- @MethodSource("convertedFrom")
- public void testEqConditionWithDynamicParameters(TestTypeArguments<T>
arguments) {
- // TODO: fix in scope of
https://issues.apache.org/jira/browse/IGNITE-20226
- if (testTypeSpec == VARBINARY_TYPE) {
- return;
- }
-
- T value1 = values.get(0);
-
- runSql("INSERT INTO t VALUES(1, ?)", value1);
-
- var err = assertThrows(IgniteException.class, () -> {
- checkQuery("SELECT id FROM t where test_key = ? ORDER BY id")
- .withParams(arguments.argValue(0))
- .returns(1)
- .returns(3)
- .check();
- });
-
- assertThat(err.getMessage(), containsString("Values passed to =
operator must have compatible types"));
- }
-
private Stream<TestTypeArguments<T>> eq() {
return TestTypeArguments.unary(testTypeSpec, dataSamples,
values.get(0));
}
@@ -146,7 +117,6 @@ public abstract class BaseQueryDataTypeTest<T extends
Comparable<T>> extends Bas
public void testInWithDynamicParamsCondition() {
T value1 = values.get(0);
T value2 = values.get(1);
- T value3 = values.get(2);
runSql("INSERT INTO t VALUES(1, $0)");
runSql("INSERT INTO t VALUES(2, $1)");
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidDmlTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidDmlTest.java
index ead659442c..e3582be528 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidDmlTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidDmlTest.java
@@ -17,16 +17,67 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
+import static
org.apache.ignite.internal.sql.engine.util.SqlTestUtils.assertThrowsSqlException;
+import static org.apache.ignite.lang.IgniteStringFormatter.format;
+
import java.util.UUID;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseDmlDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
+import org.apache.ignite.internal.sql.engine.datatypes.tests.TestTypeArguments;
import org.apache.ignite.internal.sql.engine.type.UuidType;
+import org.apache.ignite.lang.ErrorGroups.Sql;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
/**
* Tests for DML statements for {@link UuidType UUID data type}.
*/
public class ItUuidDmlTest extends BaseDmlDataTypeTest<UUID> {
+ /** {@code INSERT} with dynamic parameters is not allowed for compatible
types. */
+ @ParameterizedTest
+ @MethodSource("convertedFrom")
+ public void
testInsertFromDynamicParameterFromConvertible(TestTypeArguments arguments) {
+ assertThrowsSqlException(Sql.STMT_VALIDATION_ERR, "Values passed to
VALUES operator must have compatible types",
+ () -> runSql("INSERT INTO t VALUES (1, ?)",
arguments.argValue(0)));
+ }
+
+ /** {@code UPDATE} is not allowed for dynamic parameter of compatible
type. */
+ @ParameterizedTest
+ @MethodSource("convertedFrom")
+ public void
testUpdateFromDynamicParameterFromConvertible(TestTypeArguments arguments) {
+ String insert = format("INSERT INTO t VALUES (1, {})",
arguments.valueExpr(0));
+ runSql(insert);
+
+ assertThrowsSqlException(Sql.STMT_VALIDATION_ERR, "Dynamic parameter
requires adding explicit type cast", () -> {
+ checkQuery("UPDATE t SET test_key = ? WHERE id=1")
+ .withParams(arguments.argValue(0))
+ .returns(1L)
+ .check();
+ });
+ }
+
+ /** Type mismatch in {@code INSERT}s {@code VALUES}.*/
+ @ParameterizedTest
+ @MethodSource("convertedFrom")
+ public void testDisallowMismatchTypesOnInsert(TestTypeArguments arguments)
{
+ var query = format("INSERT INTO t (id, test_key) VALUES (10, null),
(20, {})", arguments.valueExpr(0));
+ assertThrowsSqlException(Sql.STMT_VALIDATION_ERR, "Values passed to
VALUES operator must have compatible types",
+ () -> runSql(query));
+ }
+
+ /**
+ * Type mismatch in {@code INSERT}s {@code VALUES} with dynamic parameters.
+ */
+ @ParameterizedTest
+ @MethodSource("convertedFrom")
+ public void
testDisallowMismatchTypesOnInsertDynamicParam(TestTypeArguments arguments) {
+ Object value1 = arguments.argValue(0);
+
+ var query = "INSERT INTO t (id, test_key) VALUES (1, null), (2, ?)";
+ assertThrowsSqlException(Sql.STMT_VALIDATION_ERR, "Values passed to
VALUES operator must have compatible types",
+ () -> runSql(query, value1));
+ }
/** {@inheritDoc} **/
@Override
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidExpressionTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidExpressionTest.java
index c72b9aaf19..a4977da1fd 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidExpressionTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidExpressionTest.java
@@ -17,18 +17,20 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static
org.apache.ignite.internal.sql.engine.util.SqlTestUtils.assertThrowsSqlException;
+import static org.apache.ignite.lang.IgniteStringFormatter.format;
import java.util.UUID;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseExpressionDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
+import org.apache.ignite.internal.sql.engine.datatypes.tests.TestTypeArguments;
import org.apache.ignite.internal.sql.engine.type.UuidType;
-import org.apache.ignite.lang.IgniteException;
+import org.apache.ignite.lang.ErrorGroups.Sql;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
/**
* Tests for expressions for {@link UuidType UUID data type}.
@@ -54,15 +56,35 @@ public class ItUuidExpressionTest extends
BaseExpressionDataTypeTest<UUID> {
/** Invalid {@code UUID} string in literal parameter. */
@Test
public void testInvalidUuidString() {
- IgniteException t = assertThrows(IgniteException.class, () ->
runSql("SELECT '000000'::UUID"));
- assertThat(t.getMessage(), containsString("Invalid UUID string"));
+ assertThrowsSqlException(Sql.RUNTIME_ERR, "Invalid UUID string", () ->
runSql("SELECT '000000'::UUID"));
}
/** Invalid {@code UUID} string in dynamic parameter. */
@Test
public void testInvalidUuidStringInDynamicParams() {
- IgniteException t = assertThrows(IgniteException.class, () ->
runSql("SELECT ?::UUID", "00000"));
- assertThat(t.getMessage(), containsString("Invalid UUID string"));
+ assertThrowsSqlException(Sql.RUNTIME_ERR, "Invalid UUID string:
00000", () -> runSql("SELECT ?::UUID", "00000"));
+ }
+
+ /**
+ * {@code COALESCE} operator does not allow different types in its
arguments.
+ */
+ @ParameterizedTest
+ @MethodSource("convertedFrom")
+ public void testCoalesceMissingTypesIsIllegal(TestTypeArguments arguments)
{
+ assertThrowsSqlException(Sql.STMT_VALIDATION_ERR, "Illegal mixing of
types in CASE or COALESCE statement",
+ () -> checkQuery(format("SELECT COALESCE($0, {})",
arguments.valueExpr(0))).check());
+ }
+
+ /** Data type from string. **/
+ @Test
+ public void testCastFromString() {
+ UUID value = dataSamples.values().get(0);
+ String stringValue = testTypeSpec.toStringValue(value);
+
+ checkQuery(format("SELECT CAST('{}' AS <type>)",
stringValue)).returns(value).check();
+
+ // PG style cast
+ checkQuery(format("SELECT '{}'::<type>",
stringValue)).returns(value).check();
}
/** {@inheritDoc} **/
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidQueryTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidQueryTest.java
index 2345e36fa5..14602b294a 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidQueryTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidQueryTest.java
@@ -17,17 +17,17 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
+import static
org.apache.ignite.internal.sql.engine.util.SqlTestUtils.assertThrowsSqlException;
import static org.apache.ignite.lang.IgniteStringFormatter.format;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsString;
-import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.UUID;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseQueryDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
+import org.apache.ignite.internal.sql.engine.datatypes.tests.TestTypeArguments;
import org.apache.ignite.internal.sql.engine.type.UuidType;
-import org.apache.ignite.lang.IgniteException;
+import org.apache.ignite.lang.ErrorGroups.Sql;
+import org.junit.jupiter.api.function.Executable;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
@@ -35,6 +35,10 @@ import org.junit.jupiter.params.provider.MethodSource;
* Tests for {@code SELECT} operations for {@link UuidType UUID data type}.
*/
public class ItUuidQueryTest extends BaseQueryDataTypeTest<UUID> {
+ @Override
+ protected int nodes() {
+ return 1;
+ }
/**
* {@code UUID} vs type that can not be casted to {@code UUID}.
@@ -44,9 +48,28 @@ public class ItUuidQueryTest extends
BaseQueryDataTypeTest<UUID> {
public void testInvalidComparisonOperation(String opSql) {
String query = format("SELECT * FROM t WHERE test_key {} 1", opSql);
- IgniteException t = assertThrows(IgniteException.class, () ->
checkQuery(query).check());
String error = format("Values passed to {} operator must have
compatible types", opSql);
- assertThat(t.getMessage(), containsString(error));
+
+ assertThrowsSqlException(Sql.STMT_VALIDATION_ERR, error, () ->
checkQuery(query).check());
+ }
+
+ /** Test for equality predicate with dynamic parameter of compatible type
is illegal. */
+ @ParameterizedTest
+ @MethodSource("convertedFrom")
+ public void testEqConditionWithDynamicParameters(TestTypeArguments
arguments) {
+ UUID value1 = values.get(0);
+
+ runSql("INSERT INTO t VALUES(1, ?)", value1);
+
+ Executable qry = () -> {
+ checkQuery("SELECT id FROM t where test_key = ? ORDER BY id")
+ .withParams(arguments.argValue(0))
+ .returns(1)
+ .returns(3)
+ .check();
+ };
+
+ assertThrowsSqlException(Sql.STMT_VALIDATION_ERR, "Values passed to =
operator must have compatible types", qry);
}
/** {@inheritDoc} **/
