inputType)
+ {
+ CQL3Type elementsType = elementsType(inputType).asCQL3Type();
+ NativeAggregateFunction function = getAvgFunction((CQL3Type.Native) elementsType);
+ return new CollectionAggregationFunction(name, inputType, function);
+ }
+
+ private static NativeAggregateFunction getAvgFunction(CQL3Type.Native type)
+ {
+ switch (type)
+ {
+ case TINYINT:
+ return AggregateFcts.avgFunctionForByte;
+ case SMALLINT:
+ return AggregateFcts.avgFunctionForShort;
+ case INT:
+ return AggregateFcts.avgFunctionForInt32;
+ case BIGINT:
+ return AggregateFcts.avgFunctionForLong;
+ case FLOAT:
+ return AggregateFcts.avgFunctionForFloat;
+ case DOUBLE:
+ return AggregateFcts.avgFunctionForDouble;
+ case VARINT:
+ return AggregateFcts.avgFunctionForVarint;
+ case DECIMAL:
+ return AggregateFcts.avgFunctionForDecimal;
+ default:
+ throw new AssertionError("Expected numeric collection but found " + type);
+ }
+ }
+
+ /**
+ * @return the type of the elements of the specified collection type.
+ */
+ private static AbstractType elementsType(CollectionType type)
+ {
+ if (type.kind == CollectionType.Kind.LIST)
+ {
+ return ((ListType) type).getElementsType();
+ }
+
+ if (type.kind == CollectionType.Kind.SET)
+ {
+ return ((SetType) type).getElementsType();
+ }
+
+ throw new AssertionError("Cannot get the element type of: " + type);
+ }
+
+ /**
+ * A {@link NativeScalarFunction} for aggregating the elements of a collection according to the aggregator of
+ * a certain {@link NativeAggregateFunction}.
+ *
+ * {@link NativeAggregateFunction} is meant to be used for aggregating values accross rows, but here we use that
+ * function to aggregate the elements of a single collection value. That way, functions such as {@code avg} and
+ * {@code collection_avg} should have the same behaviour when applied to row columns or collection elements.
+ */
+ private static class CollectionAggregationFunction extends NativeScalarFunction
+ {
+ private final CollectionType inputType;
+ private final NativeAggregateFunction aggregateFunction;
+
+ public CollectionAggregationFunction(String name,
+ CollectionType inputType,
+ NativeAggregateFunction aggregateFunction)
+ {
+ super(name, aggregateFunction.returnType, inputType);
+ this.inputType = inputType;
+ this.aggregateFunction = aggregateFunction;
+ }
+
+ @Override
+ public ByteBuffer execute(ProtocolVersion version, List parameters)
+ {
+ ByteBuffer value = parameters.get(0);
+ if (value == null)
+ return null;
+
+ AggregateFunction.Aggregate aggregate = aggregateFunction.newAggregate();
+ inputType.forEach(value, version, element -> aggregate.addInput(version, Collections.singletonList(element)));
+ return aggregate.compute(version);
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/cql3/functions/FunctionParameter.java b/src/java/org/apache/cassandra/cql3/functions/FunctionParameter.java
index 0d5a0c4a12..78ad7a33e3 100644
--- a/src/java/org/apache/cassandra/cql3/functions/FunctionParameter.java
+++ b/src/java/org/apache/cassandra/cql3/functions/FunctionParameter.java
@@ -22,6 +22,11 @@ import javax.annotation.Nullable;
import org.apache.cassandra.cql3.AssignmentTestable;
import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.db.marshal.CollectionType;
+import org.apache.cassandra.db.marshal.ListType;
+import org.apache.cassandra.db.marshal.MapType;
+import org.apache.cassandra.db.marshal.NumberType;
+import org.apache.cassandra.db.marshal.SetType;
import org.apache.cassandra.exceptions.InvalidRequestException;
import static java.lang.String.format;
@@ -42,7 +47,10 @@ public interface FunctionParameter
* @return the inferred data type of the parameter, or {@link null} it isn't possible to infer it
*/
@Nullable
- AbstractType inferType(String keyspace, AssignmentTestable arg, @Nullable AbstractType receiverType);
+ default AbstractType inferType(String keyspace, AssignmentTestable arg, @Nullable AbstractType receiverType)
+ {
+ return arg.getCompatibleTypeIfKnown(keyspace);
+ }
void validateType(FunctionName name, AssignmentTestable arg, AbstractType argType);
@@ -106,4 +114,123 @@ public interface FunctionParameter
}
};
}
+
+ /**
+ * @return a function parameter definition that accepts values of type {@link CollectionType}, independently of the
+ * types of its elements.
+ */
+ public static FunctionParameter anyCollection()
+ {
+ return new FunctionParameter()
+ {
+ @Override
+ public void validateType(FunctionName name, AssignmentTestable arg, AbstractType argType)
+ {
+ if (!argType.isCollection())
+ throw new InvalidRequestException(format("Function %s requires a collection argument, " +
+ "but found argument %s of type %s",
+ name, arg, argType.asCQL3Type()));
+ }
+
+ @Override
+ public String toString()
+ {
+ return "collection";
+ }
+ };
+ }
+
+ /**
+ * @return a function parameter definition that accepts values of type {@link SetType} or {@link ListType}.
+ */
+ public static FunctionParameter setOrList()
+ {
+ return new FunctionParameter()
+ {
+ @Override
+ public void validateType(FunctionName name, AssignmentTestable arg, AbstractType argType)
+ {
+ if (argType.isCollection())
+ {
+ CollectionType.Kind kind = ((CollectionType) argType).kind;
+ if (kind == CollectionType.Kind.SET || kind == CollectionType.Kind.LIST)
+ return;
+ }
+
+ throw new InvalidRequestException(format("Function %s requires a set or list argument, " +
+ "but found argument %s of type %s",
+ name, arg, argType.asCQL3Type()));
+ }
+
+ @Override
+ public String toString()
+ {
+ return "numeric_set_or_list";
+ }
+ };
+ }
+
+ /**
+ * @return a function parameter definition that accepts values of type {@link SetType} or {@link ListType},
+ * provided that its elements are numeric.
+ */
+ public static FunctionParameter numericSetOrList()
+ {
+ return new FunctionParameter()
+ {
+ @Override
+ public void validateType(FunctionName name, AssignmentTestable arg, AbstractType argType)
+ {
+ AbstractType elementType = null;
+ if (argType.isCollection())
+ {
+ CollectionType collectionType = (CollectionType) argType;
+ if (collectionType.kind == CollectionType.Kind.SET)
+ {
+ elementType = ((SetType) argType).getElementsType();
+ }
+ else if (collectionType.kind == CollectionType.Kind.LIST)
+ {
+ elementType = ((ListType) argType).getElementsType();
+ }
+ }
+
+ if (!(elementType instanceof NumberType))
+ throw new InvalidRequestException(format("Function %s requires a numeric set/list argument, " +
+ "but found argument %s of type %s",
+ name, arg, argType.asCQL3Type()));
+ }
+
+ @Override
+ public String toString()
+ {
+ return "numeric_set_or_list";
+ }
+ };
+ }
+
+ /**
+ * @return a function parameter definition that accepts values of type {@link MapType}, independently of the types
+ * of the map keys and values.
+ */
+ public static FunctionParameter anyMap()
+ {
+ return new FunctionParameter()
+ {
+ @Override
+ public void validateType(FunctionName name, AssignmentTestable arg, AbstractType argType)
+ {
+ if (!argType.isUDT() && !(argType instanceof MapType))
+ throw new InvalidRequestException(format("Function %s requires a map argument, " +
+ "but found argument %s of type %s",
+ name, arg, argType.asCQL3Type()));
+ }
+
+ @Override
+ public String toString()
+ {
+ return "map";
+ }
+ };
+ }
}
diff --git a/src/java/org/apache/cassandra/cql3/functions/NativeFunctions.java b/src/java/org/apache/cassandra/cql3/functions/NativeFunctions.java
index 6ea5e81ed4..551662e3e5 100644
--- a/src/java/org/apache/cassandra/cql3/functions/NativeFunctions.java
+++ b/src/java/org/apache/cassandra/cql3/functions/NativeFunctions.java
@@ -40,6 +40,7 @@ public class NativeFunctions
FromJsonFct.addFunctionsTo(this);
OperationFcts.addFunctionsTo(this);
AggregateFcts.addFunctionsTo(this);
+ CollectionFcts.addFunctionsTo(this);
BytesConversionFcts.addFunctionsTo(this);
MathFcts.addFunctionsTo(this);
}
diff --git a/src/java/org/apache/cassandra/db/marshal/CollectionType.java b/src/java/org/apache/cassandra/db/marshal/CollectionType.java
index 5e9916e7e4..a8cc9d9231 100644
--- a/src/java/org/apache/cassandra/db/marshal/CollectionType.java
+++ b/src/java/org/apache/cassandra/db/marshal/CollectionType.java
@@ -22,6 +22,7 @@ import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
+import java.util.function.Consumer;
import org.apache.cassandra.cql3.CQL3Type;
import org.apache.cassandra.cql3.ColumnSpecification;
@@ -357,4 +358,11 @@ public abstract class CollectionType extends AbstractType
ByteBufferUtil.skipWithVIntLength(in);
}
}
+
+ public int size(ByteBuffer buffer)
+ {
+ return CollectionSerializer.readCollectionSize(buffer.duplicate(), ByteBufferAccessor.instance, ProtocolVersion.V3);
+ }
+
+ public abstract void forEach(ByteBuffer input, ProtocolVersion version, Consumer action);
}
diff --git a/src/java/org/apache/cassandra/db/marshal/ListType.java b/src/java/org/apache/cassandra/db/marshal/ListType.java
index f795def3a7..73290d5b6c 100644
--- a/src/java/org/apache/cassandra/db/marshal/ListType.java
+++ b/src/java/org/apache/cassandra/db/marshal/ListType.java
@@ -23,6 +23,7 @@ import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
import org.apache.cassandra.cql3.Json;
import org.apache.cassandra.cql3.Lists;
@@ -243,4 +244,10 @@ public class ListType extends CollectionType>
{
return setOrListToJsonString(buffer, elements, protocolVersion);
}
+
+ @Override
+ public void forEach(ByteBuffer input, ProtocolVersion version, Consumer action)
+ {
+ serializer.forEach(input, version, action);
+ }
}
diff --git a/src/java/org/apache/cassandra/db/marshal/MapType.java b/src/java/org/apache/cassandra/db/marshal/MapType.java
index be74ff1626..d9bfc8040c 100644
--- a/src/java/org/apache/cassandra/db/marshal/MapType.java
+++ b/src/java/org/apache/cassandra/db/marshal/MapType.java
@@ -20,6 +20,7 @@ package org.apache.cassandra.db.marshal;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
import org.apache.cassandra.cql3.Json;
import org.apache.cassandra.cql3.Maps;
@@ -377,4 +378,10 @@ public class MapType extends CollectionType>
}
return sb.append("}").toString();
}
+
+ @Override
+ public void forEach(ByteBuffer input, ProtocolVersion version, Consumer action)
+ {
+ throw new UnsupportedOperationException();
+ }
}
diff --git a/src/java/org/apache/cassandra/db/marshal/SetType.java b/src/java/org/apache/cassandra/db/marshal/SetType.java
index 67699ac3da..8e33ca6698 100644
--- a/src/java/org/apache/cassandra/db/marshal/SetType.java
+++ b/src/java/org/apache/cassandra/db/marshal/SetType.java
@@ -20,6 +20,7 @@ package org.apache.cassandra.db.marshal;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
import org.apache.cassandra.cql3.Json;
import org.apache.cassandra.cql3.Sets;
@@ -226,4 +227,10 @@ public class SetType extends CollectionType>
{
return setOrListToJsonString(buffer, elements, protocolVersion);
}
+
+ @Override
+ public void forEach(ByteBuffer input, ProtocolVersion version, Consumer action)
+ {
+ serializer.forEach(input, version, action);
+ }
}
diff --git a/src/java/org/apache/cassandra/serializers/CollectionSerializer.java b/src/java/org/apache/cassandra/serializers/CollectionSerializer.java
index 36e346c3e7..841a1b0aac 100644
--- a/src/java/org/apache/cassandra/serializers/CollectionSerializer.java
+++ b/src/java/org/apache/cassandra/serializers/CollectionSerializer.java
@@ -18,9 +18,11 @@
package org.apache.cassandra.serializers;
+import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.List;
+import java.util.function.Consumer;
import com.google.common.collect.Range;
@@ -224,4 +226,25 @@ public abstract class CollectionSerializer extends TypeSerializer
ByteBufferUtil.copyBytes(input, startPos, output, sizeLen, bodyLen);
return output;
}
+
+ public void forEach(ByteBuffer input, ProtocolVersion version, Consumer action)
+ {
+ try
+ {
+ int collectionSize = readCollectionSize(input, ByteBufferAccessor.instance, version);
+ int offset = sizeOfCollectionSize(collectionSize, version);
+
+ for (int i = 0; i < collectionSize; i++)
+ {
+ ByteBuffer value = readValue(input, ByteBufferAccessor.instance, offset, version);
+ offset += sizeOfValue(value, ByteBufferAccessor.instance, version);
+
+ action.accept(value);
+ }
+ }
+ catch (BufferUnderflowException | IndexOutOfBoundsException e)
+ {
+ throw new MarshalException("Not enough bytes to read a set");
+ }
+ }
}
diff --git a/src/java/org/apache/cassandra/serializers/MapSerializer.java b/src/java/org/apache/cassandra/serializers/MapSerializer.java
index b3e4cba994..0417d403e6 100644
--- a/src/java/org/apache/cassandra/serializers/MapSerializer.java
+++ b/src/java/org/apache/cassandra/serializers/MapSerializer.java
@@ -23,6 +23,7 @@ import java.nio.ByteBuffer;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import java.util.function.Consumer;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.db.marshal.ByteBufferAccessor;
@@ -197,4 +198,10 @@ public class MapSerializer extends AbstractMapSerializer>
{
return (Class) Map.class;
}
+
+ @Override
+ public void forEach(ByteBuffer input, ProtocolVersion version, Consumer action)
+ {
+ throw new UnsupportedOperationException();
+ }
}
diff --git a/test/unit/org/apache/cassandra/cql3/functions/CollectionFctsTest.java b/test/unit/org/apache/cassandra/cql3/functions/CollectionFctsTest.java
new file mode 100644
index 0000000000..0ad299edee
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/functions/CollectionFctsTest.java
@@ -0,0 +1,595 @@
+/*
+ * 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.cassandra.cql3.functions;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
+
+import org.junit.Test;
+
+import org.apache.cassandra.cql3.CQL3Type;
+import org.apache.cassandra.cql3.CQLTester;
+import org.apache.cassandra.db.marshal.NumberType;
+import org.apache.cassandra.exceptions.InvalidRequestException;
+
+/**
+ * Tests for the functions defined on {@link CollectionFcts}.
+ */
+public class CollectionFctsTest extends CQLTester
+{
+ private static final BigInteger bigint1 = new BigInteger("12345678901234567890");
+ private static final BigInteger bigint2 = new BigInteger("23456789012345678901");
+ private static final BigDecimal bigdecimal1 = new BigDecimal("1234567890.1234567890");
+ private static final BigDecimal bigdecimal2 = new BigDecimal("2345678901.2345678901");
+
+ @Test
+ public void testNotNumericCollection() throws Throwable
+ {
+ createTable("CREATE TABLE %s (k int PRIMARY KEY, v uuid, l list, s set, fl frozen>, fs frozen>)");
+
+ // sum
+ assertInvalidThrowMessage("Function system.collection_sum requires a numeric set/list argument, " +
+ "but found argument v of type uuid",
+ InvalidRequestException.class,
+ "SELECT collection_sum(v) FROM %s");
+ assertInvalidThrowMessage("Function system.collection_sum requires a numeric set/list argument, " +
+ "but found argument l of type list",
+ InvalidRequestException.class,
+ "SELECT collection_sum(l) FROM %s");
+ assertInvalidThrowMessage("Function system.collection_sum requires a numeric set/list argument, " +
+ "but found argument s of type set",
+ InvalidRequestException.class,
+ "SELECT collection_sum(s) FROM %s");
+ assertInvalidThrowMessage("Function system.collection_sum requires a numeric set/list argument, " +
+ "but found argument fl of type frozen>",
+ InvalidRequestException.class,
+ "SELECT collection_sum(fl) FROM %s");
+ assertInvalidThrowMessage("Function system.collection_sum requires a numeric set/list argument, " +
+ "but found argument fs of type frozen>",
+ InvalidRequestException.class,
+ "SELECT collection_sum(fs) FROM %s");
+
+ // avg
+ assertInvalidThrowMessage("Function system.collection_avg requires a numeric set/list argument, " +
+ "but found argument v of type uuid",
+ InvalidRequestException.class,
+ "SELECT collection_avg(v) FROM %s");
+ assertInvalidThrowMessage("Function system.collection_avg requires a numeric set/list argument, " +
+ "but found argument l of type list",
+ InvalidRequestException.class,
+ "SELECT collection_avg(l) FROM %s");
+ assertInvalidThrowMessage("Function system.collection_avg requires a numeric set/list argument, " +
+ "but found argument s of type set",
+ InvalidRequestException.class,
+ "SELECT collection_avg(s) FROM %s");
+ assertInvalidThrowMessage("Function system.collection_avg requires a numeric set/list argument, " +
+ "but found argument fl of type frozen>",
+ InvalidRequestException.class,
+ "SELECT collection_avg(fl) FROM %s");
+ assertInvalidThrowMessage("Function system.collection_avg requires a numeric set/list argument, " +
+ "but found argument fs of type frozen>",
+ InvalidRequestException.class,
+ "SELECT collection_avg(fs) FROM %s");
+ }
+
+ @Test
+ public void testTinyInt() throws Throwable
+ {
+ createTable(CQL3Type.Native.TINYINT);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(null, null, (byte) 0, (byte) 0));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(null, null, (byte) 0, (byte) 0));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list((byte) 1, (byte) 2), set((byte) 1, (byte) 2),
+ list((byte) 1, (byte) 2), set((byte) 1, (byte) 2),
+ map((byte) 1, (byte) 2, (byte) 3, (byte) 4),
+ map((byte) 1, (byte) 2, (byte) 3, (byte) 4));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set((byte) 1, (byte) 3), set((byte) 1, (byte) 3)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list((byte) 2, (byte) 4), list((byte) 2, (byte) 4)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row((byte) 1, (byte) 1, (byte) 1, (byte) 1));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row((byte) 2, (byte) 2, (byte) 2, (byte) 2));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row((byte) 3, (byte) 3, (byte) 3, (byte) 3));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row((byte) 1, (byte) 1, (byte) 1, (byte) 1));
+ }
+
+ @Test
+ public void testSmallInt() throws Throwable
+ {
+ createTable(CQL3Type.Native.SMALLINT);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(null, null, (short) 0, (short) 0));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(null, null, (short) 0, (short) 0));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list((short) 1, (short) 2), set((short) 1, (short) 2),
+ list((short) 1, (short) 2), set((short) 1, (short) 2),
+ map((short) 1, (short) 2, (short) 3, (short) 4),
+ map((short) 1, (short) 2, (short) 3, (short) 4));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set((short) 1, (short) 3), set((short) 1, (short) 3)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list((short) 2, (short) 4), list((short) 2, (short) 4)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row((short) 1, (short) 1, (short) 1, (short) 1));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row((short) 2, (short) 2, (short) 2, (short) 2));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row((short) 3, (short) 3, (short) 3, (short) 3));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row((short) 1, (short) 1, (short) 1, (short) 1));
+ }
+
+ @Test
+ public void testInt() throws Throwable
+ {
+ createTable(CQL3Type.Native.INT);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(null, null, 0, 0));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(null, null, 0, 0));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list(1, 2), set(1, 2), list(1, 2), set(1, 2), map(1, 2, 3, 4), map(1, 2, 3, 4));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set(1, 3), set(1, 3)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list(2, 4), list(2, 4)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(1, 1, 1, 1));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(2, 2, 2, 2));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(3, 3, 3, 3));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(1, 1, 1, 1));
+ }
+
+ @Test
+ public void testBigInt() throws Throwable
+ {
+ createTable(CQL3Type.Native.BIGINT);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(null, null, 0L, 0L));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(null, null, 0L, 0L));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list(1L, 2L), set(1L, 2L), list(1L, 2L), set(1L, 2L), map(1L, 2L, 3L, 4L), map(1L, 2L, 3L, 4L));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set(1L, 3L), set(1L, 3L)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list(2L, 4L), list(2L, 4L)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(1L, 1L, 1L, 1L));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(2L, 2L, 2L, 2L));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(3L, 3L, 3L, 3L));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(1L, 1L, 1L, 1L));
+ }
+
+ @Test
+ public void testFloat() throws Throwable
+ {
+ createTable(CQL3Type.Native.FLOAT);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(null, null, 0f, 0f));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(null, null, 0f, 0f));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list(1.23f, 2.34f), list(1.23f, 2.34f),
+ set(1.23f, 2.34f), set(1.23f, 2.34f),
+ map(1.23f, 2.34f, 3.45f, 4.56f), map(1.23f, 2.34f, 3.45f, 4.56f));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set(1.23f, 3.45f), set(1.23f, 3.45f)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list(2.34f, 4.56f), list(2.34f, 4.56f)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(1.23f, 1.23f, 1.23f, 1.23f));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(2.34f, 2.34f, 2.34f, 2.34f));
+
+ float sum = 1.23f + 2.34f;
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(sum, sum, sum, sum));
+
+ float avg = (1.23f + 2.34f) / 2;
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(avg, avg, avg, avg));
+ }
+
+ @Test
+ public void testDouble() throws Throwable
+ {
+ createTable(CQL3Type.Native.DOUBLE);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(null, null, 0d, 0d));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(null, null, 0d, 0d));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list(1.23d, 2.34d), list(1.23d, 2.34d),
+ set(1.23d, 2.34d), set(1.23d, 2.34d),
+ map(1.23d, 2.34d, 3.45d, 4.56d), map(1.23d, 2.34d, 3.45d, 4.56d));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set(1.23d, 3.45d), set(1.23d, 3.45d)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list(2.34d, 4.56d), list(2.34d, 4.56d)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(1.23d, 1.23d, 1.23d, 1.23d));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(2.34d, 2.34d, 2.34d, 2.34d));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(3.57d, 3.57d, 3.57d, 3.57d));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(1.785d, 1.785d, 1.785d, 1.785d));
+ }
+
+ @Test
+ public void testVarInt() throws Throwable
+ {
+ createTable(CQL3Type.Native.VARINT);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(null, null, BigInteger.ZERO, BigInteger.ZERO));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(null, null, BigInteger.ZERO, BigInteger.ZERO));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list(bigint1, bigint2), list(bigint1, bigint2),
+ set(bigint1, bigint2), set(bigint1, bigint2),
+ map(bigint1, bigint2, bigint2, bigint1), map(bigint1, bigint2, bigint2, bigint1));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set(bigint1, bigint2), set(bigint1, bigint2)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list(bigint2, bigint1), list(bigint2, bigint1)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(bigint1, bigint1, bigint1, bigint1));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(bigint2, bigint2, bigint2, bigint2));
+
+ BigInteger sum = bigint1.add(bigint2);
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(sum, sum, sum, sum));
+
+ BigInteger avg = bigint1.add(bigint2).divide(BigInteger.valueOf(2));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(avg, avg, avg, avg));
+ }
+
+ @Test
+ public void testDecimal() throws Throwable
+ {
+ createTable(CQL3Type.Native.DECIMAL);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(null, null, null, null));
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(null, null, BigDecimal.ZERO, BigDecimal.ZERO));
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(null, null, BigDecimal.ZERO, BigDecimal.ZERO));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list(bigdecimal1, bigdecimal2), list(bigdecimal1, bigdecimal2),
+ set(bigdecimal1, bigdecimal2), set(bigdecimal1, bigdecimal2),
+ map(bigdecimal1, bigdecimal2, bigdecimal2, bigdecimal1),
+ map(bigdecimal1, bigdecimal2, bigdecimal2, bigdecimal1));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set(bigdecimal1, bigdecimal2), set(bigdecimal1, bigdecimal2)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list(bigdecimal2, bigdecimal1), list(bigdecimal2, bigdecimal1)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(bigdecimal1, bigdecimal1, bigdecimal1, bigdecimal1));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(bigdecimal2, bigdecimal2, bigdecimal2, bigdecimal2));
+
+ BigDecimal sum = bigdecimal1.add(bigdecimal2);
+ assertRows(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"),
+ row(sum, sum, sum, sum));
+
+ BigDecimal avg = bigdecimal1.add(bigdecimal2).divide(BigDecimal.valueOf(2), RoundingMode.HALF_EVEN);
+ assertRows(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"),
+ row(avg, avg, avg, avg));
+ }
+
+ @Test
+ public void testAscii() throws Throwable
+ {
+ createTable(CQL3Type.Native.ASCII);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list("abc", "bcd"), set("abc", "bcd"),
+ list("abc", "bcd"), set("abc", "bcd"),
+ map("abc", "bcd", "cde", "def"), map("abc", "bcd", "cde", "def"));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set("abc", "cde"), set("abc", "cde")));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list("bcd", "def"), list("bcd", "def")));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row("abc", "abc", "abc", "abc"));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row("bcd", "bcd", "bcd", "bcd"));
+ }
+
+ @Test
+ public void testText() throws Throwable
+ {
+ createTable(CQL3Type.Native.TEXT);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list("ábc", "bcd"), set("ábc", "bcd"),
+ list("ábc", "bcd"), set("ábc", "bcd"),
+ map("ábc", "bcd", "cdé", "déf"), map("ábc", "bcd", "cdé", "déf"));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set("ábc", "cdé"), set("ábc", "cdé")));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list("déf", "bcd"), list("déf", "bcd")));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row("bcd", "bcd", "bcd", "bcd"));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row("ábc", "ábc", "ábc", "ábc"));
+ }
+
+ @Test
+ public void testBoolean() throws Throwable
+ {
+ createTable(CQL3Type.Native.BOOLEAN);
+
+ // empty collections
+ assertRows(execute("SELECT map_keys(m), map_values(m), map_keys(fm), map_values(fm) FROM %s"),
+ row(null, null, set(), list()));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m), " +
+ "collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(null, null, null, 0, 0, 0));
+
+ // not empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list(true, false), set(true, false),
+ list(true, false), set(true, false),
+ map(true, false, false, true), map(true, false, false, true));
+
+ assertRows(execute("SELECT map_keys(m), map_keys(fm) FROM %s"),
+ row(set(true, false), set(true, false)));
+ assertRows(execute("SELECT map_values(m), map_values(fm) FROM %s"),
+ row(list(true, false), list(true, false)));
+ assertRows(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"),
+ row(2, 2, 2));
+ assertRows(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"),
+ row(false, false, false, false));
+ assertRows(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"),
+ row(true, true, true, true));
+ }
+
+ private void createTable(CQL3Type.Native type) throws Throwable
+ {
+ createTable(String.format("CREATE TABLE %%s (" +
+ " k int PRIMARY KEY, " +
+ " l list<%s>, " +
+ " s set<%, " +
+ " m map<%, " +
+ " fl frozen>, " +
+ " fs frozen>, " +
+ " fm frozen>)", type));
+
+ // test functions with an empty table
+ assertEmpty(execute("SELECT map_keys(m), map_keys(fm), map_values(m), map_values(fm) FROM %s"));
+ assertEmpty(execute("SELECT collection_count(l), collection_count(s), collection_count(m) FROM %s"));
+ assertEmpty(execute("SELECT collection_count(fl), collection_count(fs), collection_count(fm) FROM %s"));
+ assertEmpty(execute("SELECT collection_min(l), collection_min(s), collection_min(fl), collection_min(fs) FROM %s"));
+ assertEmpty(execute("SELECT collection_max(l), collection_max(s), collection_max(fl), collection_max(fs) FROM %s"));
+
+ String errorMsg = "requires a numeric set/list argument";
+ if (type.getType() instanceof NumberType)
+ {
+ assertEmpty(execute("SELECT collection_sum(l), collection_sum(s), collection_sum(fl), collection_sum(fs) FROM %s"));
+ assertEmpty(execute("SELECT collection_avg(l), collection_avg(s), collection_avg(fl), collection_avg(fs) FROM %s"));
+ }
+ else
+ {
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_sum(l) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_avg(l) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_sum(s) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_avg(s) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_sum(fl) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_avg(fl) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_sum(fs) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_avg(fs) FROM %s");
+ }
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_sum(m) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_avg(m) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_sum(fm) FROM %s");
+ assertInvalidThrowMessage(errorMsg, InvalidRequestException.class, "SELECT collection_avg(fm) FROM %s");
+
+ // prepare empty collections
+ execute("INSERT INTO %s (k, l, fl, s, fs, m, fm) VALUES (1, ?, ?, ?, ?, ?, ?)",
+ list(), list(), set(), set(), map(), map());
+ }
+}