This is an automated email from the ASF dual-hosted git repository.
alexpl pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git
The following commit(s) were added to refs/heads/master by this push:
new 85066469eb2 IGNITE-23624 SQL Calcite: Add support for bitwise
aggregates (BIT_AND, BIT_OR, BIT_XOR) - Fixes #11649.
85066469eb2 is described below
commit 85066469eb204984ac108240b3eb399df4712c85
Author: Vladimir Steshin <[email protected]>
AuthorDate: Wed Nov 20 18:27:03 2024 +0300
IGNITE-23624 SQL Calcite: Add support for bitwise aggregates (BIT_AND,
BIT_OR, BIT_XOR) - Fixes #11649.
Signed-off-by: Aleksey Plekhanov <[email protected]>
---
docs/_docs/SQL/sql-calcite.adoc | 2 +-
docs/_docs/sql-reference/aggregate-functions.adoc | 15 ++
.../query/calcite/exec/exp/agg/Accumulators.java | 96 ++++++++++++
.../query/calcite/prepare/IgniteSqlValidator.java | 3 +
.../calcite/sql/fun/IgniteStdSqlOperatorTable.java | 5 +
.../integration/AggregatesIntegrationTest.java | 166 +++++++++++++++++++++
...{test_bit_and.test_ignore => test_bit_and.test} | 8 +-
.../{test_bit_or.test_ignore => test_bit_or.test} | 8 +-
...{test_bit_xor.test_ignore => test_bit_xor.test} | 8 +-
9 files changed, 292 insertions(+), 19 deletions(-)
diff --git a/docs/_docs/SQL/sql-calcite.adoc b/docs/_docs/SQL/sql-calcite.adoc
index afb7dc5a92e..298f4a5c28b 100644
--- a/docs/_docs/SQL/sql-calcite.adoc
+++ b/docs/_docs/SQL/sql-calcite.adoc
@@ -144,7 +144,7 @@ The Calcite-based SQL engine currently supports:
|Group | Functions list
|Aggregate functions
-|`COUNT`, `SUM`, `AVG`, `MIN`, `MAX`, `ANY_VALUE`, `LISTAGG`, `GROUP_CONCAT`,
`STRING_AGG`, `ARRAY_AGG`, `ARRAY_CONCAT_AGG`, `EVERY`, `SOME`
+|`COUNT`, `SUM`, `AVG`, `MIN`, `MAX`, `ANY_VALUE`, `LISTAGG`, `GROUP_CONCAT`,
`STRING_AGG`, `ARRAY_AGG`, `ARRAY_CONCAT_AGG`, `EVERY`, `SOME`, `BIT_AND`,
`BIT_OR`, `BIT_XOR`
|String functions
|`UPPER`, `LOWER`, `INITCAP`, `TO_BASE64`, `FROM_BASE64`, `MD5`, `SHA1`,
`SUBSTRING`, `LEFT`, `RIGHT`, `REPLACE`, `TRANSLATE`, `CHR`, `CHAR_LENGTH`,
`CHARACTER_LENGTH`, `LENGTH`, `CONCAT`, `OVERLAY`, `POSITION`, `ASCII`,
`REPEAT`, `SPACE`, `STRCMP`, `SOUNDEX`, `DIFFERENCE`, `REVERSE`, `TRIM`,
`LTRIM`, `RTRIM`, `REGEXP_REPLACE`
diff --git a/docs/_docs/sql-reference/aggregate-functions.adoc
b/docs/_docs/sql-reference/aggregate-functions.adoc
index da7ad3bbc13..040731e94f6 100644
--- a/docs/_docs/sql-reference/aggregate-functions.adoc
+++ b/docs/_docs/sql-reference/aggregate-functions.adoc
@@ -68,6 +68,21 @@ A logical OR operation is performed on each pair of
corresponding bits of two bi
In each pair, the result is 1 if the first bit is 1 OR the second bit is 1 OR
both bits are 1, and otherwise the result is 0.
+
+== BIT_XOR
+
+
+[source,sql]
+----
+BIT_XOR (expression)
+----
+
+The bitwise XOR of all non-null values. If no rows are selected, the result is
NULL. Aggregates are only allowed in select statements.
+
+A logical XOR operation is performed on each pair of corresponding bits of two
binary expressions of equal length.
+
+In each pair, the result is 1 if only one of the bits is 1. Otherwise the
result is 0.
+
////
== BOOL_AND
diff --git
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/agg/Accumulators.java
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/agg/Accumulators.java
index 73e3f305620..a8d453c1d86 100644
---
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/agg/Accumulators.java
+++
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/agg/Accumulators.java
@@ -33,6 +33,7 @@ import org.apache.calcite.rel.core.AggregateCall;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rex.RexLiteral;
import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.sql.SqlKind;
import
org.apache.ignite.internal.processors.query.calcite.exec.ExecutionContext;
import org.apache.ignite.internal.processors.query.calcite.exec.RowHandler;
import
org.apache.ignite.internal.processors.query.calcite.type.IgniteTypeFactory;
@@ -94,6 +95,10 @@ public class Accumulators {
case "ARRAY_AGG":
case "ARRAY_CONCAT_AGG":
return listAggregateSupplier(call, ctx);
+ case "BIT_AND":
+ case "BIT_OR":
+ case "BIT_XOR":
+ return bitWiseFactory(call, hnd);
default:
throw new AssertionError(call.getAggregation().getName());
}
@@ -143,6 +148,21 @@ public class Accumulators {
}
}
+ /** */
+ private static <Row> Supplier<Accumulator<Row>>
bitWiseFactory(AggregateCall call, RowHandler<Row> hnd) {
+ switch (call.type.getSqlTypeName()) {
+ case BIGINT:
+ case INTEGER:
+ case SMALLINT:
+ case TINYINT:
+ case NULL:
+ return () -> new BitWise<>(call, hnd);
+
+ default:
+ throw new UnsupportedOperationException(call.getName() + " is
not supported for type '" + call.type + "'.");
+ }
+ }
+
/** */
private static <Row> Supplier<Accumulator<Row>> sumFactory(AggregateCall
call, RowHandler<Row> hnd) {
switch (call.type.getSqlTypeName()) {
@@ -399,6 +419,82 @@ public class Accumulators {
}
}
+ /** */
+ private static class BitWise<Row> extends AbstractAccumulator<Row> {
+ /** */
+ private long res;
+
+ /** */
+ private boolean updated;
+
+ /** */
+ private final SqlKind kind;
+
+ /** */
+ private BitWise(AggregateCall aggCall, RowHandler<Row> hnd) {
+ super(aggCall, hnd);
+
+ kind = aggCall.getAggregation().kind;
+
+ assert kind == SqlKind.BIT_AND || kind == SqlKind.BIT_OR || kind
== SqlKind.BIT_XOR;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void add(Row row) {
+ Number in = get(0, row);
+
+ if (in == null)
+ return;
+
+ apply(in.longValue());
+ }
+
+ /** */
+ private void apply(long val) {
+ if (updated) {
+ switch (kind) {
+ case BIT_AND:
+ res &= val;
+ break;
+ case BIT_OR:
+ res |= val;
+ break;
+ case BIT_XOR:
+ res ^= val;
+ break;
+ }
+ }
+ else {
+ res = val;
+
+ updated = true;
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override public void apply(Accumulator<Row> other) {
+ BitWise<Row> other0 = (BitWise<Row>)other;
+
+ if (other0.updated)
+ apply(other0.res);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Object end() {
+ return updated ? res : null;
+ }
+
+ /** {@inheritDoc} */
+ @Override public List<RelDataType> argumentTypes(IgniteTypeFactory
typeFactory) {
+ return
F.asList(typeFactory.createTypeWithNullability(typeFactory.createSqlType(BIGINT),
true));
+ }
+
+ /** {@inheritDoc} */
+ @Override public RelDataType returnType(IgniteTypeFactory typeFactory)
{
+ return
typeFactory.createTypeWithNullability(typeFactory.createSqlType(BIGINT), true);
+ }
+ }
+
/** */
private static class DecimalAvg<Row> extends AbstractAccumulator<Row> {
/** */
diff --git
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteSqlValidator.java
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteSqlValidator.java
index 93cd94d1dec..36128236f24 100644
---
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteSqlValidator.java
+++
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteSqlValidator.java
@@ -429,6 +429,9 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
case GROUP_CONCAT:
case LISTAGG:
case STRING_AGG:
+ case BIT_AND:
+ case BIT_OR:
+ case BIT_XOR:
return;
default:
throw newValidationError(call,
diff --git
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/fun/IgniteStdSqlOperatorTable.java
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/fun/IgniteStdSqlOperatorTable.java
index 1b7492d958a..e69db3e3173 100644
---
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/fun/IgniteStdSqlOperatorTable.java
+++
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/fun/IgniteStdSqlOperatorTable.java
@@ -309,5 +309,10 @@ public class IgniteStdSqlOperatorTable extends
ReflectiveSqlOperatorTable {
register(SqlStdOperatorTable.CURRENT_DATE);
register(SqlStdOperatorTable.LOCALTIME);
register(SqlStdOperatorTable.LOCALTIMESTAMP);
+
+ // Bit wise operations.
+ register(SqlStdOperatorTable.BIT_AND);
+ register(SqlStdOperatorTable.BIT_OR);
+ register(SqlStdOperatorTable.BIT_XOR);
}
}
diff --git
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/AggregatesIntegrationTest.java
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/AggregatesIntegrationTest.java
index dfe89024b4c..ab2e18d79b0 100644
---
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/AggregatesIntegrationTest.java
+++
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/AggregatesIntegrationTest.java
@@ -174,6 +174,172 @@ public class AggregatesIntegrationTest extends
AbstractBasicIntegrationTransacti
.check();
}
+ /** */
+ @Test
+ public void testBitwiseTypesBounds() {
+ sql("CREATE TABLE tbl (t TINYINT, s SMALLINT, i INT, b BIGINT) WITH "
+ atomicity());
+
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", Byte.MAX_VALUE, 0, 1000, 0);
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", Byte.MIN_VALUE, 0, 1001, 0);
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", 0, Short.MAX_VALUE, 1002,
0);
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", 0, Short.MIN_VALUE, 1003,
0);
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", 0, 0, Integer.MIN_VALUE, 0);
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", 0, 0, Integer.MAX_VALUE, 0);
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", 0, 0, 1006, Long.MAX_VALUE);
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", 0, 0, 1007, Long.MIN_VALUE);
+
+ assertQuery("SELECT BIT_AND(t) FROM tbl WHERE i=? or
i=?").withParams(1000, 1001).returns((byte)0).check();
+ assertQuery("SELECT BIT_OR(t) FROM tbl WHERE i=? or
i=?").withParams(1000, 1001).returns((byte)-1).check();
+ assertQuery("SELECT BIT_XOR(t) FROM tbl WHERE i=? or
i=?").withParams(1000, 1001).returns((byte)-1).check();
+
+ assertQuery("SELECT BIT_AND(s) FROM tbl WHERE i=? or
i=?").withParams(1002, 1003).returns((short)0).check();
+ assertQuery("SELECT BIT_OR(s) FROM tbl WHERE i=? or
i=?").withParams(1002, 1003).returns((short)-1).check();
+ assertQuery("SELECT BIT_XOR(s) FROM tbl WHERE i=? or
i=?").withParams(1002, 1003).returns((short)-1).check();
+
+ assertQuery("SELECT BIT_AND(i) FROM tbl WHERE i=? or
i=?").withParams(Integer.MAX_VALUE, Integer.MIN_VALUE)
+ .returns(0).check();
+ assertQuery("SELECT BIT_OR(i) FROM tbl WHERE i=? or
i=?").withParams(Integer.MAX_VALUE, Integer.MIN_VALUE)
+ .returns(-1).check();
+ assertQuery("SELECT BIT_XOR(i) FROM tbl WHERE i=? or
i=?").withParams(Integer.MAX_VALUE, Integer.MIN_VALUE)
+ .returns(-1).check();
+
+ assertQuery("SELECT BIT_AND(b) FROM tbl WHERE i=? or
i=?").withParams(1006, 1007).returns(0L).check();
+ assertQuery("SELECT BIT_OR(b) FROM tbl WHERE i=? or
i=?").withParams(1006, 1007).returns(-1L).check();
+ assertQuery("SELECT BIT_XOR(b) FROM tbl WHERE i=? or
i=?").withParams(1006, 1007).returns(-1L).check();
+ }
+
+ /** */
+ @Test
+ public void testBitwiseBasics() {
+ sql("CREATE TABLE tbl (t TINYINT, s SMALLINT, i INT, b BIGINT) WITH "
+ atomicity());
+
+ for (int i = 0; i < 10; ++i)
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", i, i, i, i);
+
+ sql("INSERT INTO tbl values (null, null, null, null)");
+
+ for (String op : F.asList("AND", "OR", "XOR")) {
+ // Check dynamic parameter.
+ assertQuery("SELECT BIT_" + op +
"(?)").withParams((byte)1).returns((byte)1).check();
+ assertQuery("SELECT BIT_" + op +
"(?)").withParams((short)1).returns((short)1).check();
+ assertQuery("SELECT BIT_" + op +
"(?)").withParams(1).returns(1).check();
+ assertQuery("SELECT BIT_" + op +
"(?)").withParams(1L).returns(1L).check();
+
+ // Check 1 value.
+ assertQuery("SELECT BIT_" + op + "(t) FROM tbl WHERE
i=1").returns((byte)1).check();
+ assertQuery("SELECT BIT_" + op + "(s) FROM tbl WHERE
i=1").returns((short)1).check();
+ assertQuery("SELECT BIT_" + op + "(i) FROM tbl WHERE
i=1").returns(1).check();
+ assertQuery("SELECT BIT_" + op + "(b) FROM tbl WHERE
i=1").returns(1L).check();
+
+ // Check nulls.
+ assertQuery("SELECT BIT_" + op + "(t) FROM tbl WHERE t is
null").returns(NULL_RESULT).check();
+ assertQuery("SELECT BIT_" + op + "(s) FROM tbl WHERE s is
null").returns(NULL_RESULT).check();
+ assertQuery("SELECT BIT_" + op + "(i) FROM tbl WHERE i is
null").returns(NULL_RESULT).check();
+ assertQuery("SELECT BIT_" + op + "(b) FROM tbl WHERE b is
null").returns(NULL_RESULT).check();
+
+ // Check 1 value and null.
+ assertQuery("SELECT BIT_" + op + "(t) FROM tbl WHERE i=1 or i is
null").returns((byte)1).check();
+ assertQuery("SELECT BIT_" + op + "(s) FROM tbl WHERE i=1 or i is
null").returns((short)1).check();
+ assertQuery("SELECT BIT_" + op + "(i) FROM tbl WHERE i=1 or i is
null").returns(1).check();
+ assertQuery("SELECT BIT_" + op + "(b) FROM tbl WHERE i=1 or i is
null").returns(1L).check();
+
+ // Check not existing.
+ for (String col : F.asList("t", "s", "i", "b", "t + s", "s + i",
"i + b"))
+ assertQuery("SELECT BIT_" + op + "(" + col + ") FROM tbl WHERE
i=200").returns(NULL_RESULT).check();
+ }
+ }
+
+ /** */
+ @Test
+ public void testBitwiseLeastRestrictive() {
+ sql("CREATE TABLE tbl (t TINYINT, s SMALLINT, i INT, b BIGINT) WITH "
+ atomicity());
+
+ for (int i = 0; i < 10; ++i)
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", i, i, i, i);
+
+ // Check least restrictive.
+ assertQuery("SELECT BIT_AND(t + s) FROM tbl WHERE i=1 or i=7 or
i=200").returns((short)2).check();
+ assertQuery("SELECT BIT_AND(s + i) FROM tbl WHERE i=1 or i=7 or
i=200").returns(2).check();
+ assertQuery("SELECT BIT_AND(i + b) FROM tbl WHERE i=1 or i=7 or
i=200").returns(2L).check();
+
+ assertQuery("SELECT BIT_OR(t + s) FROM tbl WHERE i=2 or i=4 or
i=200").returns((short)12).check();
+ assertQuery("SELECT BIT_OR(s + i) FROM tbl WHERE i=2 or i=4 or
i=200").returns(12).check();
+ assertQuery("SELECT BIT_OR(i + b) FROM tbl WHERE i=2 or i=4 or
i=200").returns(12L).check();
+
+ assertQuery("SELECT BIT_XOR(t + s) FROM tbl WHERE i=6 or i=2 or
i=200").returns((short)8).check();
+ assertQuery("SELECT BIT_XOR(s + i) FROM tbl WHERE i=6 or i=2 or
i=200").returns(8).check();
+ assertQuery("SELECT BIT_XOR(i + b) FROM tbl WHERE i=6 or i=2 or
i=200").returns(8L).check();
+ }
+
+ /** */
+ @Test
+ public void testBitwiseGrouping() {
+ sql("CREATE TABLE tbl (g INT, i INT) WITH " + atomicity());
+
+ for (int i = 0; i < 3; ++i) {
+ sql("INSERT INTO tbl values (?, ?)", i, null);
+
+ for (int j = 0; j < 9; ++j)
+ sql("INSERT INTO tbl values (?, ?)", i, j);
+ }
+
+ assertQuery("SELECT g + 1, BIT_AND(i) from tbl where i in (3,7) group
by g")
+ .returns(1, 3)
+ .returns(2, 3)
+ .returns(3, 3)
+ .check();
+
+ assertQuery("SELECT g + 1, BIT_OR(i) from tbl group by g")
+ .returns(1, 15)
+ .returns(2, 15)
+ .returns(3, 15)
+ .check();
+
+ assertQuery("SELECT g + 1, BIT_XOR(i) from tbl where i in (1,2,4,8)
group by g")
+ .returns(1, 15)
+ .returns(2, 15)
+ .returns(3, 15)
+ .check();
+ }
+
+ /** */
+ @Test
+ public void testBitwiseResults() {
+ sql("CREATE TABLE tbl (t TINYINT, s SMALLINT, i INT, b BIGINT) WITH "
+ atomicity());
+
+ for (int i = 0; i < 10; ++i)
+ sql("INSERT INTO tbl values (?, ?, ?, ?)", i, i, i, i);
+
+ assertQuery("SELECT BIT_AND(t) FROM tbl WHERE i BETWEEN 2 and 3 or
i=200").returns((byte)2).check();
+ assertQuery("SELECT BIT_AND(s) FROM tbl WHERE i BETWEEN 2 and 3 or
i=200").returns((short)2).check();
+ assertQuery("SELECT BIT_AND(i) FROM tbl WHERE i BETWEEN 2 and 3 or
i=200").returns(2).check();
+ assertQuery("SELECT BIT_AND(b) FROM tbl WHERE i BETWEEN 2 and 3 or
i=200").returns(2L).check();
+
+ assertQuery("SELECT BIT_XOR(t) FROM tbl WHERE i=8 or i=9 or
i=200").returns((byte)1).check();
+ assertQuery("SELECT BIT_XOR(s) FROM tbl WHERE i=8 or i=9 or
i=200").returns((short)1).check();
+ assertQuery("SELECT BIT_XOR(i) FROM tbl WHERE i=8 or i=9 or
i=200").returns(1).check();
+ assertQuery("SELECT BIT_XOR(b) FROM tbl WHERE i=8 or i=9 or
i=200").returns(1L).check();
+
+ assertQuery("SELECT BIT_OR(t) FROM tbl WHERE i=8 or i=1 or
i=200").returns((byte)9).check();
+ assertQuery("SELECT BIT_OR(s) FROM tbl WHERE i=8 or i=1 or
i=200").returns((short)9).check();
+ assertQuery("SELECT BIT_OR(i) FROM tbl WHERE i=8 or i=1 or
i=200").returns(9).check();
+ assertQuery("SELECT BIT_OR(b) FROM tbl WHERE i=8 or i=1 or
i=200").returns(9L).check();
+
+ for (String op : F.asList("AND", "XOR")) {
+ String where = "AND".equals(op) ? "i<100" : "i=7 or i=4 or i=2 or
i=1";
+
+ assertQuery("SELECT BIT_" + op + "(t) FROM tbl WHERE " +
where).returns((byte)0).check();
+ assertQuery("SELECT BIT_" + op + "(s) FROM tbl WHERE " +
where).returns((short)0).check();
+ assertQuery("SELECT BIT_" + op + "(i) FROM tbl WHERE " +
where).returns(0).check();
+ assertQuery("SELECT BIT_" + op + "(b) FROM tbl WHERE " +
where).returns(0L).check();
+ }
+
+ sql("INSERT INTO tbl values (1, 1, 1, 1)");
+
+ assertQuery("SELECT BIT_XOR(i) from tbl where i=1").returns(0).check();
+ assertQuery("SELECT BIT_XOR(DISTINCT i) from tbl where
i=1").returns(1).check();
+ }
+
/** */
@Test
public void testCountOfNonNumericField() {
diff --git
a/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_and.test_ignore
b/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_and.test
similarity index 86%
rename from
modules/calcite/src/test/sql/aggregate/aggregates/test_bit_and.test_ignore
rename to modules/calcite/src/test/sql/aggregate/aggregates/test_bit_and.test
index 082fe2cd078..64a9f26409c 100644
--- a/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_and.test_ignore
+++ b/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_and.test
@@ -10,17 +10,13 @@ SELECT BIT_AND(3), BIT_AND(NULL)
3
NULL
-# test on a sequence
-statement ok
-CREATE SEQUENCE seq;
-
query I
-SELECT BIT_AND(nextval('seq'))
+SELECT BIT_AND(1)
----
1
query I
-SELECT BIT_AND(nextval('seq'))
+SELECT BIT_AND(2)
----
2
diff --git
a/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_or.test_ignore
b/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_or.test
similarity index 86%
rename from
modules/calcite/src/test/sql/aggregate/aggregates/test_bit_or.test_ignore
rename to modules/calcite/src/test/sql/aggregate/aggregates/test_bit_or.test
index 1fe325e77d4..e0ae5060ec7 100644
--- a/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_or.test_ignore
+++ b/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_or.test
@@ -10,17 +10,13 @@ SELECT BIT_OR(3), BIT_OR(NULL)
3
NULL
-# test on a sequence
-statement ok
-CREATE SEQUENCE seq;
-
query I
-SELECT BIT_OR(nextval('seq'))
+SELECT BIT_OR(1)
----
1
query I
-SELECT BIT_OR(nextval('seq'))
+SELECT BIT_OR(2)
----
2
diff --git
a/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_xor.test_ignore
b/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_xor.test
similarity index 86%
rename from
modules/calcite/src/test/sql/aggregate/aggregates/test_bit_xor.test_ignore
rename to modules/calcite/src/test/sql/aggregate/aggregates/test_bit_xor.test
index 4b9fb0b4fba..d16510dfcc6 100644
--- a/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_xor.test_ignore
+++ b/modules/calcite/src/test/sql/aggregate/aggregates/test_bit_xor.test
@@ -10,17 +10,13 @@ SELECT BIT_XOR(3), BIT_XOR(NULL)
3
NULL
-# test on a sequence
-statement ok
-CREATE SEQUENCE seq;
-
query I
-SELECT BIT_XOR(nextval('seq'))
+SELECT BIT_XOR(1)
----
1
query I
-SELECT BIT_XOR(nextval('seq'))
+SELECT BIT_XOR(2)
----
2
