You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by ab...@apache.org on 2025/01/26 21:26:10 UTC
(cassandra-java-driver) branch 4.x updated (b6aba1505 -> 2e0c44c02)
This is an automated email from the ASF dual-hosted git repository.
absurdfarce pushed a change to branch 4.x
in repository https://gitbox.apache.org/repos/asf/cassandra-java-driver.git
discard b6aba1505 JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0) patch by Jane He; reviewed by Bret McGuire and João Reis for JAVA-3143
new 2e0c44c02 JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)
This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version. This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:
* -- * -- B -- O -- O -- O (b6aba1505)
\
N -- N -- N refs/heads/4.x (2e0c44c02)
You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.
Any revisions marked "omit" are not gone; other references still
refer to them. Any revisions marked "discard" are gone forever.
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org
(cassandra-java-driver) 01/01: JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)
Posted by ab...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
absurdfarce pushed a commit to branch 4.x
in repository https://gitbox.apache.org/repos/asf/cassandra-java-driver.git
commit 2e0c44c020819c928730e1aac812bf2f475d8256
Author: SiyaoIsHiding <11...@users.noreply.github.com>
AuthorDate: Sun Jan 26 22:38:52 2025 +0800
JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)
patch by Jane He; reviewed by Bret McGuire and João Reis
reference: https://github.com/apache/cassandra-java-driver/pull/1952
---
core/revapi.json | 297 +++++++++++++++++++++
.../oss/driver/api/core/data/CqlVector.java | 72 +++--
.../oss/driver/api/core/data/GettableById.java | 2 +-
.../oss/driver/api/core/data/GettableByIndex.java | 3 +-
.../oss/driver/api/core/data/GettableByName.java | 2 +-
.../oss/driver/api/core/data/SettableById.java | 2 +-
.../oss/driver/api/core/data/SettableByIndex.java | 2 +-
.../oss/driver/api/core/data/SettableByName.java | 2 +-
.../oss/driver/api/core/type/DataTypes.java | 19 +-
.../oss/driver/api/core/type/codec/TypeCodec.java | 6 +
.../oss/driver/api/core/type/codec/TypeCodecs.java | 4 +-
.../driver/api/core/type/reflect/GenericType.java | 6 +-
.../schema/parsing/DataTypeClassNameParser.java | 8 +
.../internal/core/type/DefaultVectorType.java | 2 +-
.../internal/core/type/codec/BigIntCodec.java | 7 +
.../internal/core/type/codec/BooleanCodec.java | 7 +
.../internal/core/type/codec/DoubleCodec.java | 7 +
.../internal/core/type/codec/FloatCodec.java | 7 +
.../driver/internal/core/type/codec/IntCodec.java | 7 +
.../internal/core/type/codec/TimestampCodec.java | 7 +
.../driver/internal/core/type/codec/UuidCodec.java | 7 +
.../internal/core/type/codec/VectorCodec.java | 86 ++++--
.../codec/extras/time/TimestampMillisCodec.java | 7 +
.../type/codec/registry/CachingCodecRegistry.java | 12 +-
.../driver/internal/core/type/util/VIntCoding.java | 77 +++++-
.../oss/driver/api/core/data/CqlVectorTest.java | 167 ++++++------
.../internal/core/type/codec/VectorCodecTest.java | 265 +++++++++++++-----
.../CachingCodecRegistryTestDataProviders.java | 20 ++
.../internal/core/type/util/VIntCodingTest.java | 86 ++++++
.../datastax/oss/driver/core/data/DataTypeIT.java | 38 ++-
30 files changed, 1002 insertions(+), 232 deletions(-)
diff --git a/core/revapi.json b/core/revapi.json
index 1c875895d..5aa46a3cc 100644
--- a/core/revapi.json
+++ b/core/revapi.json
@@ -7089,6 +7089,303 @@
"new": "method com.datastax.oss.driver.api.core.cql.SimpleStatement com.datastax.oss.driver.api.core.cql.SimpleStatement::setNamedValues(java.util.Map<java.lang.String, java.lang.Object>)",
"annotation": "@edu.umd.cs.findbugs.annotations.CheckReturnValue",
"justification": "Annotate mutating methods with @CheckReturnValue"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>===)",
+ "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
+ "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
+ "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::from(java.lang.String, com.datastax.oss.driver.api.core.type.codec.TypeCodec<V>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeChanged",
+ "old": "method T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::get(int)",
+ "new": "method T com.datastax.oss.driver.api.core.data.CqlVector<T>::get(int)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method java.util.Iterator<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::iterator()",
+ "new": "method java.util.Iterator<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::iterator()",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeChanged",
+ "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(===V[]===)",
+ "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(===V[]===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(V[])",
+ "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(V[])",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(V[])",
+ "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(V[])",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(===java.util.List<V>===)",
+ "new": "parameter <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(===java.util.List<V>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(java.util.List<V>)",
+ "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(java.util.List<V>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <V extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::newInstance(java.util.List<V>)",
+ "new": "method <V> com.datastax.oss.driver.api.core.data.CqlVector<V> com.datastax.oss.driver.api.core.data.CqlVector<T>::newInstance(java.util.List<V>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeChanged",
+ "old": "parameter T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::set(int, ===T===)",
+ "new": "parameter T com.datastax.oss.driver.api.core.data.CqlVector<T>::set(int, ===T===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeChanged",
+ "old": "method T com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::set(int, T)",
+ "new": "method T com.datastax.oss.driver.api.core.data.CqlVector<T>::set(int, T)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method java.util.Spliterator<T> java.lang.Iterable<T>::spliterator() @ com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
+ "new": "method java.util.Spliterator<T> java.lang.Iterable<T>::spliterator() @ com.datastax.oss.driver.api.core.data.CqlVector<T>",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method java.util.stream.Stream<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::stream()",
+ "new": "method java.util.stream.Stream<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::stream()",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method com.datastax.oss.driver.api.core.data.CqlVector<T> com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>::subVector(int, int)",
+ "new": "method com.datastax.oss.driver.api.core.data.CqlVector<T> com.datastax.oss.driver.api.core.data.CqlVector<T>::subVector(int, int)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.class.noLongerImplementsInterface",
+ "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
+ "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
+ "interface": "java.lang.Iterable<T extends java.lang.Number>",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
+ "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.class.superTypeTypeParametersChanged",
+ "old": "class com.datastax.oss.driver.api.core.data.CqlVector<T extends java.lang.Number>",
+ "new": "class com.datastax.oss.driver.api.core.data.CqlVector<T>",
+ "oldSuperType": "java.lang.Iterable<T extends java.lang.Number>",
+ "newSuperType": "java.lang.Iterable<T>",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===java.lang.Class<ElementT>===)",
+ "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===java.lang.Class<ElementT>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableById::getVector(com.datastax.oss.driver.api.core.CqlIdentifier, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, ===java.lang.Class<ElementT>===)",
+ "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, ===java.lang.Class<ElementT>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByIndex::getVector(int, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, ===java.lang.Class<ElementT>===)",
+ "new": "parameter <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, ===java.lang.Class<ElementT>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <ElementT extends java.lang.Number> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> com.datastax.oss.driver.api.core.data.CqlVector<ElementT> com.datastax.oss.driver.api.core.data.GettableByName::getVector(java.lang.String, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+ "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+ "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableById<SelfT extends com.datastax.oss.driver.api.core.data.SettableById<SelfT>>::setVector(com.datastax.oss.driver.api.core.CqlIdentifier, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+ "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+ "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT extends com.datastax.oss.driver.api.core.data.SettableByIndex<SelfT>>::setVector(int, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+ "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, ===com.datastax.oss.driver.api.core.data.CqlVector<ElementT>===, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+ "new": "parameter <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, ===java.lang.Class<ElementT>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <ElementT extends java.lang.Number> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+ "new": "method <ElementT> SelfT com.datastax.oss.driver.api.core.data.SettableByName<SelfT extends com.datastax.oss.driver.api.core.data.SettableByName<SelfT>>::setVector(java.lang.String, com.datastax.oss.driver.api.core.data.CqlVector<ElementT>, java.lang.Class<ElementT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
+ "new": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+ "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+ "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(com.datastax.oss.driver.api.core.type.VectorType, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
+ "new": "parameter <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, ===com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+ "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <SubtypeT extends java.lang.Number> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+ "new": "method <SubtypeT> com.datastax.oss.driver.api.core.type.codec.TypeCodec<com.datastax.oss.driver.api.core.data.CqlVector<SubtypeT>> com.datastax.oss.driver.api.core.type.codec.TypeCodecs::vectorOf(int, com.datastax.oss.driver.api.core.type.codec.TypeCodec<SubtypeT>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===com.datastax.oss.driver.api.core.type.reflect.GenericType<T>===)",
+ "new": "parameter <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===com.datastax.oss.driver.api.core.type.reflect.GenericType<T>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
+ "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
+ "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(com.datastax.oss.driver.api.core.type.reflect.GenericType<T>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.parameterTypeParameterChanged",
+ "old": "parameter <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===java.lang.Class<T>===)",
+ "new": "parameter <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(===java.lang.Class<T>===)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.method.returnTypeTypeParametersChanged",
+ "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
+ "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
+ },
+ {
+ "code": "java.generics.formalTypeParameterChanged",
+ "old": "method <T extends java.lang.Number> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
+ "new": "method <T> com.datastax.oss.driver.api.core.type.reflect.GenericType<com.datastax.oss.driver.api.core.data.CqlVector<T>> com.datastax.oss.driver.api.core.type.reflect.GenericType<T>::vectorOf(java.lang.Class<T>)",
+ "justification": "JAVA-3143: Extend driver vector support to arbitrary subtypes and fix handling of variable length types (OSS C* 5.0)"
}
]
}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
index 911b6187f..8089d5517 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
@@ -18,11 +18,10 @@
package com.datastax.oss.driver.api.core.data;
import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
+import com.datastax.oss.driver.internal.core.type.codec.ParseUtils;
import com.datastax.oss.driver.shaded.guava.common.base.Preconditions;
import com.datastax.oss.driver.shaded.guava.common.base.Predicates;
-import com.datastax.oss.driver.shaded.guava.common.base.Splitter;
import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
-import com.datastax.oss.driver.shaded.guava.common.collect.Streams;
import edu.umd.cs.findbugs.annotations.NonNull;
import java.io.IOException;
import java.io.InvalidObjectException;
@@ -35,7 +34,6 @@ import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
-import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
@@ -52,7 +50,7 @@ import java.util.stream.Stream;
* where possible we've tried to make the API of this class similar to the equivalent methods on
* {@link List}.
*/
-public class CqlVector<T extends Number> implements Iterable<T>, Serializable {
+public class CqlVector<T> implements Iterable<T>, Serializable {
/**
* Create a new CqlVector containing the specified values.
@@ -60,7 +58,7 @@ public class CqlVector<T extends Number> implements Iterable<T>, Serializable {
* @param vals the collection of values to wrap.
* @return a CqlVector wrapping those values
*/
- public static <V extends Number> CqlVector<V> newInstance(V... vals) {
+ public static <V> CqlVector<V> newInstance(V... vals) {
// Note that Array.asList() guarantees the return of an array which implements RandomAccess
return new CqlVector(Arrays.asList(vals));
@@ -73,29 +71,64 @@ public class CqlVector<T extends Number> implements Iterable<T>, Serializable {
* @param list the collection of values to wrap.
* @return a CqlVector wrapping those values
*/
- public static <V extends Number> CqlVector<V> newInstance(List<V> list) {
+ public static <V> CqlVector<V> newInstance(List<V> list) {
Preconditions.checkArgument(list != null, "Input list should not be null");
return new CqlVector(list);
}
/**
- * Create a new CqlVector instance from the specified string representation. Note that this method
- * is intended to mirror {@link #toString()}; passing this method the output from a <code>toString
- * </code> call on some CqlVector should return a CqlVector that is equal to the origin instance.
+ * Create a new CqlVector instance from the specified string representation.
*
* @param str a String representation of a CqlVector
* @param subtypeCodec
* @return a new CqlVector built from the String representation
*/
- public static <V extends Number> CqlVector<V> from(
- @NonNull String str, @NonNull TypeCodec<V> subtypeCodec) {
+ public static <V> CqlVector<V> from(@NonNull String str, @NonNull TypeCodec<V> subtypeCodec) {
Preconditions.checkArgument(str != null, "Cannot create CqlVector from null string");
Preconditions.checkArgument(!str.isEmpty(), "Cannot create CqlVector from empty string");
- ArrayList<V> vals =
- Streams.stream(Splitter.on(", ").split(str.substring(1, str.length() - 1)))
- .map(subtypeCodec::parse)
- .collect(Collectors.toCollection(ArrayList::new));
- return new CqlVector(vals);
+ if (str.equalsIgnoreCase("NULL")) return null;
+
+ int idx = ParseUtils.skipSpaces(str, 0);
+ if (str.charAt(idx++) != '[')
+ throw new IllegalArgumentException(
+ String.format(
+ "Cannot parse vector value from \"%s\", at character %d expecting '[' but got '%c'",
+ str, idx, str.charAt(idx)));
+
+ idx = ParseUtils.skipSpaces(str, idx);
+
+ if (str.charAt(idx) == ']') {
+ return new CqlVector<>(new ArrayList<>());
+ }
+
+ List<V> list = new ArrayList<>();
+ while (idx < str.length()) {
+ int n;
+ try {
+ n = ParseUtils.skipCQLValue(str, idx);
+ } catch (IllegalArgumentException e) {
+ throw new IllegalArgumentException(
+ String.format(
+ "Cannot parse vector value from \"%s\", invalid CQL value at character %d",
+ str, idx),
+ e);
+ }
+
+ list.add(subtypeCodec.parse(str.substring(idx, n)));
+ idx = n;
+
+ idx = ParseUtils.skipSpaces(str, idx);
+ if (str.charAt(idx) == ']') return new CqlVector<>(list);
+ if (str.charAt(idx++) != ',')
+ throw new IllegalArgumentException(
+ String.format(
+ "Cannot parse vector value from \"%s\", at character %d expecting ',' but got '%c'",
+ str, idx, str.charAt(idx)));
+
+ idx = ParseUtils.skipSpaces(str, idx);
+ }
+ throw new IllegalArgumentException(
+ String.format("Malformed vector value \"%s\", missing closing ']'", str));
}
private final List<T> list;
@@ -194,6 +227,11 @@ public class CqlVector<T extends Number> implements Iterable<T>, Serializable {
return Objects.hash(list);
}
+ /**
+ * The string representation of the vector. Elements, like strings, may not be properly quoted.
+ *
+ * @return the string representation
+ */
@Override
public String toString() {
return Iterables.toString(this.list);
@@ -205,7 +243,7 @@ public class CqlVector<T extends Number> implements Iterable<T>, Serializable {
*
* @param <T> inner type of CqlVector, assume Number is always Serializable.
*/
- private static class SerializationProxy<T extends Number> implements Serializable {
+ private static class SerializationProxy<T> implements Serializable {
private static final long serialVersionUID = 1;
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java
index 0a24214b2..8393bc9f7 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java
@@ -531,7 +531,7 @@ public interface GettableById extends GettableByIndex, AccessibleById {
* @throws IllegalArgumentException if the id is invalid.
*/
@Nullable
- default <ElementT extends Number> CqlVector<ElementT> getVector(
+ default <ElementT> CqlVector<ElementT> getVector(
@NonNull CqlIdentifier id, @NonNull Class<ElementT> elementsClass) {
return getVector(firstIndexOf(id), elementsClass);
}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java
index 53541b0ac..bb75bd9a2 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java
@@ -446,8 +446,7 @@ public interface GettableByIndex extends AccessibleByIndex {
* @throws IndexOutOfBoundsException if the index is invalid.
*/
@Nullable
- default <ElementT extends Number> CqlVector<ElementT> getVector(
- int i, @NonNull Class<ElementT> elementsClass) {
+ default <ElementT> CqlVector<ElementT> getVector(int i, @NonNull Class<ElementT> elementsClass) {
return get(i, GenericType.vectorOf(elementsClass));
}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java
index ec3ee362c..b0a466003 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java
@@ -527,7 +527,7 @@ public interface GettableByName extends GettableByIndex, AccessibleByName {
* @throws IllegalArgumentException if the name is invalid.
*/
@Nullable
- default <ElementT extends Number> CqlVector<ElementT> getVector(
+ default <ElementT> CqlVector<ElementT> getVector(
@NonNull String name, @NonNull Class<ElementT> elementsClass) {
return getVector(firstIndexOf(name), elementsClass);
}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java
index 845244620..0f5e3cd9d 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java
@@ -573,7 +573,7 @@ public interface SettableById<SelfT extends SettableById<SelfT>>
*/
@NonNull
@CheckReturnValue
- default <ElementT extends Number> SelfT setVector(
+ default <ElementT> SelfT setVector(
@NonNull CqlIdentifier id,
@Nullable CqlVector<ElementT> v,
@NonNull Class<ElementT> elementsClass) {
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java
index bb55db3ad..4ecdf6475 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java
@@ -425,7 +425,7 @@ public interface SettableByIndex<SelfT extends SettableByIndex<SelfT>> extends A
*/
@NonNull
@CheckReturnValue
- default <ElementT extends Number> SelfT setVector(
+ default <ElementT> SelfT setVector(
int i, @Nullable CqlVector<ElementT> v, @NonNull Class<ElementT> elementsClass) {
return set(i, v, GenericType.vectorOf(elementsClass));
}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java
index c25a70743..afe9ba59f 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java
@@ -572,7 +572,7 @@ public interface SettableByName<SelfT extends SettableByName<SelfT>>
*/
@NonNull
@CheckReturnValue
- default <ElementT extends Number> SelfT setVector(
+ default <ElementT> SelfT setVector(
@NonNull String name,
@Nullable CqlVector<ElementT> v,
@NonNull Class<ElementT> elementsClass) {
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/DataTypes.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/DataTypes.java
index 3a341eaa5..492fc121c 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/type/DataTypes.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/type/DataTypes.java
@@ -27,12 +27,10 @@ import com.datastax.oss.driver.internal.core.type.DefaultSetType;
import com.datastax.oss.driver.internal.core.type.DefaultTupleType;
import com.datastax.oss.driver.internal.core.type.DefaultVectorType;
import com.datastax.oss.driver.internal.core.type.PrimitiveType;
-import com.datastax.oss.driver.shaded.guava.common.base.Splitter;
import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
import com.datastax.oss.protocol.internal.ProtocolConstants;
import edu.umd.cs.findbugs.annotations.NonNull;
import java.util.Arrays;
-import java.util.List;
/** Constants and factory methods to obtain data type instances. */
public class DataTypes {
@@ -59,7 +57,6 @@ public class DataTypes {
public static final DataType DURATION = new PrimitiveType(ProtocolConstants.DataType.DURATION);
private static final DataTypeClassNameParser classNameParser = new DataTypeClassNameParser();
- private static final Splitter paramSplitter = Splitter.on(',').trimResults();
@NonNull
public static DataType custom(@NonNull String className) {
@@ -68,20 +65,8 @@ public class DataTypes {
if (className.equals("org.apache.cassandra.db.marshal.DurationType")) return DURATION;
/* Vector support is currently implemented as a custom type but is also parameterized */
- if (className.startsWith(DefaultVectorType.VECTOR_CLASS_NAME)) {
- List<String> params =
- paramSplitter.splitToList(
- className.substring(
- DefaultVectorType.VECTOR_CLASS_NAME.length() + 1, className.length() - 1));
- DataType subType = classNameParser.parse(params.get(0), AttachmentPoint.NONE);
- int dimensions = Integer.parseInt(params.get(1));
- if (dimensions <= 0) {
- throw new IllegalArgumentException(
- String.format(
- "Request to create vector of size %d, size must be positive", dimensions));
- }
- return new DefaultVectorType(subType, dimensions);
- }
+ if (className.startsWith(DefaultVectorType.VECTOR_CLASS_NAME))
+ return classNameParser.parse(className, AttachmentPoint.NONE);
return new DefaultCustomType(className);
}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodec.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodec.java
index 05ae39808..d6afbe038 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodec.java
@@ -28,6 +28,7 @@ import com.datastax.oss.driver.shaded.guava.common.base.Preconditions;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.nio.ByteBuffer;
+import java.util.Optional;
/**
* Manages the two-way conversion between a CQL type and a Java type.
@@ -234,4 +235,9 @@ public interface TypeCodec<JavaTypeT> {
*/
@Nullable
JavaTypeT parse(@Nullable String value);
+
+ @NonNull
+ default Optional<Integer> serializedSize() {
+ return Optional.empty();
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java
index 9f2fd5cc6..68f1b07b1 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java
@@ -210,13 +210,13 @@ public class TypeCodecs {
return new TupleCodec(cqlType);
}
- public static <SubtypeT extends Number> TypeCodec<CqlVector<SubtypeT>> vectorOf(
+ public static <SubtypeT> TypeCodec<CqlVector<SubtypeT>> vectorOf(
@NonNull VectorType type, @NonNull TypeCodec<SubtypeT> subtypeCodec) {
return new VectorCodec(
DataTypes.vectorOf(subtypeCodec.getCqlType(), type.getDimensions()), subtypeCodec);
}
- public static <SubtypeT extends Number> TypeCodec<CqlVector<SubtypeT>> vectorOf(
+ public static <SubtypeT> TypeCodec<CqlVector<SubtypeT>> vectorOf(
int dimensions, @NonNull TypeCodec<SubtypeT> subtypeCodec) {
return new VectorCodec(DataTypes.vectorOf(subtypeCodec.getCqlType(), dimensions), subtypeCodec);
}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java
index c6482d4f4..d22b6f1bf 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java
@@ -151,8 +151,7 @@ public class GenericType<T> {
}
@NonNull
- public static <T extends Number> GenericType<CqlVector<T>> vectorOf(
- @NonNull Class<T> elementType) {
+ public static <T> GenericType<CqlVector<T>> vectorOf(@NonNull Class<T> elementType) {
TypeToken<CqlVector<T>> token =
new TypeToken<CqlVector<T>>() {}.where(
new TypeParameter<T>() {}, TypeToken.of(elementType));
@@ -160,8 +159,7 @@ public class GenericType<T> {
}
@NonNull
- public static <T extends Number> GenericType<CqlVector<T>> vectorOf(
- @NonNull GenericType<T> elementType) {
+ public static <T> GenericType<CqlVector<T>> vectorOf(@NonNull GenericType<T> elementType) {
TypeToken<CqlVector<T>> token =
new TypeToken<CqlVector<T>>() {}.where(new TypeParameter<T>() {}, elementType.token);
return new GenericType<>(token);
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java
index fd6f1a4bd..bf252d0bc 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java
@@ -34,6 +34,7 @@ import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
import com.datastax.oss.protocol.internal.util.Bytes;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@@ -164,6 +165,13 @@ public class DataTypeClassNameParser implements DataTypeParser {
return new DefaultTupleType(componentTypesBuilder.build(), attachmentPoint);
}
+ if (next.startsWith("org.apache.cassandra.db.marshal.VectorType")) {
+ Iterator<String> rawTypes = parser.getTypeParameters().iterator();
+ DataType subtype = parse(rawTypes.next(), userTypes, attachmentPoint, logPrefix);
+ int dimensions = Integer.parseInt(rawTypes.next());
+ return DataTypes.vectorOf(subtype, dimensions);
+ }
+
DataType type = NATIVE_TYPES_BY_CLASS_NAME.get(next);
return type == null ? DataTypes.custom(toParse) : type;
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
index c9180d44e..0b1ced947 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/DefaultVectorType.java
@@ -78,7 +78,7 @@ public class DefaultVectorType implements VectorType {
@Override
public int hashCode() {
- return Objects.hash(super.hashCode(), subtype, dimensions);
+ return Objects.hash(DefaultVectorType.class, subtype, dimensions);
}
@Override
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BigIntCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BigIntCodec.java
index 2b3b8255c..8496da17f 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BigIntCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BigIntCodec.java
@@ -25,6 +25,7 @@ import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.nio.ByteBuffer;
+import java.util.Optional;
import net.jcip.annotations.ThreadSafe;
@ThreadSafe
@@ -90,4 +91,10 @@ public class BigIntCodec implements PrimitiveLongCodec {
String.format("Cannot parse 64-bits long value from \"%s\"", value));
}
}
+
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return Optional.of(8);
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BooleanCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BooleanCodec.java
index 7a982a9e6..af388982b 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BooleanCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/BooleanCodec.java
@@ -25,6 +25,7 @@ import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.nio.ByteBuffer;
+import java.util.Optional;
import net.jcip.annotations.ThreadSafe;
@ThreadSafe
@@ -98,4 +99,10 @@ public class BooleanCodec implements PrimitiveBooleanCodec {
String.format("Cannot parse boolean value from \"%s\"", value));
}
}
+
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return Optional.of(1);
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/DoubleCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/DoubleCodec.java
index 28eff6f94..b01847517 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/DoubleCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/DoubleCodec.java
@@ -25,6 +25,7 @@ import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.nio.ByteBuffer;
+import java.util.Optional;
import net.jcip.annotations.ThreadSafe;
@ThreadSafe
@@ -90,4 +91,10 @@ public class DoubleCodec implements PrimitiveDoubleCodec {
String.format("Cannot parse 64-bits double value from \"%s\"", value));
}
}
+
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return Optional.of(8);
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/FloatCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/FloatCodec.java
index 11786dbc7..fd851edfa 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/FloatCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/FloatCodec.java
@@ -25,6 +25,7 @@ import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.nio.ByteBuffer;
+import java.util.Optional;
import net.jcip.annotations.ThreadSafe;
@ThreadSafe
@@ -90,4 +91,10 @@ public class FloatCodec implements PrimitiveFloatCodec {
String.format("Cannot parse 32-bits float value from \"%s\"", value));
}
}
+
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return Optional.of(4);
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/IntCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/IntCodec.java
index e5bb530ba..b11b164a4 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/IntCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/IntCodec.java
@@ -25,6 +25,7 @@ import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.nio.ByteBuffer;
+import java.util.Optional;
import net.jcip.annotations.ThreadSafe;
@ThreadSafe
@@ -90,4 +91,10 @@ public class IntCodec implements PrimitiveIntCodec {
String.format("Cannot parse 32-bits int value from \"%s\"", value));
}
}
+
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return Optional.of(4);
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/TimestampCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/TimestampCodec.java
index eeba3c7c6..964f774c8 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/TimestampCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/TimestampCodec.java
@@ -33,6 +33,7 @@ import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.ZoneId;
import java.util.Date;
+import java.util.Optional;
import java.util.TimeZone;
import net.jcip.annotations.ThreadSafe;
@@ -293,4 +294,10 @@ public class TimestampCodec implements TypeCodec<Instant> {
String.format("Cannot parse timestamp value from \"%s\"", value));
}
}
+
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return Optional.of(8);
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UuidCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UuidCodec.java
index 57feac4ae..cc5f48dbe 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UuidCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/UuidCodec.java
@@ -25,6 +25,7 @@ import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.nio.ByteBuffer;
+import java.util.Optional;
import java.util.UUID;
import net.jcip.annotations.ThreadSafe;
@@ -95,4 +96,10 @@ public class UuidCodec implements TypeCodec<UUID> {
String.format("Cannot parse UUID value from \"%s\"", value), e);
}
}
+
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return Optional.of(16);
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
index 2c4d2200b..1f8ce1a71 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
@@ -24,7 +24,7 @@ import com.datastax.oss.driver.api.core.type.VectorType;
import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
import com.datastax.oss.driver.api.core.type.reflect.GenericType;
import com.datastax.oss.driver.internal.core.type.DefaultVectorType;
-import com.datastax.oss.driver.shaded.guava.common.collect.Iterables;
+import com.datastax.oss.driver.internal.core.type.util.VIntCoding;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.nio.ByteBuffer;
@@ -32,8 +32,10 @@ import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.stream.Collectors;
-public class VectorCodec<SubtypeT extends Number> implements TypeCodec<CqlVector<SubtypeT>> {
+public class VectorCodec<SubtypeT> implements TypeCodec<CqlVector<SubtypeT>> {
private final VectorType cqlType;
private final GenericType<CqlVector<SubtypeT>> javaType;
@@ -55,6 +57,14 @@ public class VectorCodec<SubtypeT extends Number> implements TypeCodec<CqlVector
return this.javaType;
}
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return subtypeCodec.serializedSize().isPresent()
+ ? Optional.of(subtypeCodec.serializedSize().get() * cqlType.getDimensions())
+ : Optional.empty();
+ }
+
@NonNull
@Override
public DataType getCqlType() {
@@ -65,6 +75,7 @@ public class VectorCodec<SubtypeT extends Number> implements TypeCodec<CqlVector
@Override
public ByteBuffer encode(
@Nullable CqlVector<SubtypeT> value, @NonNull ProtocolVersion protocolVersion) {
+ boolean isVarSized = !subtypeCodec.serializedSize().isPresent();
if (value == null || cqlType.getDimensions() <= 0) {
return null;
}
@@ -92,14 +103,28 @@ public class VectorCodec<SubtypeT extends Number> implements TypeCodec<CqlVector
if (valueBuff == null) {
throw new NullPointerException("Vector elements cannot encode to CQL NULL");
}
- allValueBuffsSize += valueBuff.limit();
+ int elementSize = valueBuff.limit();
+ if (isVarSized) {
+ allValueBuffsSize += VIntCoding.computeVIntSize(elementSize);
+ }
+ allValueBuffsSize += elementSize;
valueBuff.rewind();
valueBuffs[i] = valueBuff;
}
+ // if too many elements, throw
+ if (values.hasNext()) {
+ throw new IllegalArgumentException(
+ String.format(
+ "Too many elements; must provide elements for %d dimensions",
+ cqlType.getDimensions()));
+ }
/* Since we already did an early return for <= 0 dimensions above */
assert valueBuffs.length > 0;
ByteBuffer rv = ByteBuffer.allocate(allValueBuffsSize);
for (int i = 0; i < cqlType.getDimensions(); ++i) {
+ if (isVarSized) {
+ VIntCoding.writeUnsignedVInt32(valueBuffs[i].remaining(), rv);
+ }
rv.put(valueBuffs[i]);
}
rv.flip();
@@ -114,39 +139,58 @@ public class VectorCodec<SubtypeT extends Number> implements TypeCodec<CqlVector
return null;
}
- /* Determine element size by dividing count of remaining bytes by number of elements. This should have a remainder
- of zero if we assume all elements are of uniform size (which is really a terrible assumption).
-
- TODO: We should probably tweak serialization format for vectors if we're going to allow them for arbitrary subtypes.
- Elements should at least precede themselves with their size (along the lines of what lists do). */
- int elementSize = Math.floorDiv(bytes.remaining(), cqlType.getDimensions());
- if (!(bytes.remaining() % cqlType.getDimensions() == 0)) {
- throw new IllegalArgumentException(
- String.format(
- "Expected elements of uniform size, observed %d elements with total bytes %d",
- cqlType.getDimensions(), bytes.remaining()));
- }
-
+ // Upfront check for fixed-size types only
+ subtypeCodec
+ .serializedSize()
+ .ifPresent(
+ (fixed_size) -> {
+ if (bytes.remaining() != cqlType.getDimensions() * fixed_size) {
+ throw new IllegalArgumentException(
+ String.format(
+ "Expected elements of uniform size, observed %d elements with total bytes %d",
+ cqlType.getDimensions(), bytes.remaining()));
+ }
+ });
+ ;
ByteBuffer slice = bytes.slice();
List<SubtypeT> rv = new ArrayList<SubtypeT>(cqlType.getDimensions());
for (int i = 0; i < cqlType.getDimensions(); ++i) {
- // Set the limit for the current element
+
+ int size =
+ subtypeCodec
+ .serializedSize()
+ .orElseGet(() -> VIntCoding.getUnsignedVInt32(slice, slice.position()));
+ // If we aren't dealing with a fixed-size type we need to move the current slice position
+ // beyond the vint-encoded size of the current element. Ideally this would be
+ // serializedSize().ifNotPresent(Consumer) but the Optional API isn't doing us any favors
+ // there.
+ if (!subtypeCodec.serializedSize().isPresent())
+ slice.position(slice.position() + VIntCoding.computeUnsignedVIntSize(size));
int originalPosition = slice.position();
- slice.limit(originalPosition + elementSize);
+ slice.limit(originalPosition + size);
rv.add(this.subtypeCodec.decode(slice, protocolVersion));
// Move to the start of the next element
- slice.position(originalPosition + elementSize);
+ slice.position(originalPosition + size);
// Reset the limit to the end of the buffer
slice.limit(slice.capacity());
}
+ // if too many elements, throw
+ if (slice.hasRemaining()) {
+ throw new IllegalArgumentException(
+ String.format(
+ "Too many elements; must provide elements for %d dimensions",
+ cqlType.getDimensions()));
+ }
+
return CqlVector.newInstance(rv);
}
@NonNull
@Override
- public String format(@Nullable CqlVector<SubtypeT> value) {
- return value == null ? "NULL" : Iterables.toString(value);
+ public String format(CqlVector<SubtypeT> value) {
+ if (value == null) return "NULL";
+ return value.stream().map(subtypeCodec::format).collect(Collectors.joining(", ", "[", "]"));
}
@Nullable
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/extras/time/TimestampMillisCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/extras/time/TimestampMillisCodec.java
index a15495a43..12e3e839d 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/extras/time/TimestampMillisCodec.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/extras/time/TimestampMillisCodec.java
@@ -31,6 +31,7 @@ import java.nio.ByteBuffer;
import java.time.Instant;
import java.time.ZoneId;
import java.util.Objects;
+import java.util.Optional;
import net.jcip.annotations.Immutable;
/**
@@ -114,4 +115,10 @@ public class TimestampMillisCodec implements PrimitiveLongCodec {
Instant instant = value == null ? null : Instant.ofEpochMilli(value);
return timestampCodec.format(instant);
}
+
+ @NonNull
+ @Override
+ public Optional<Integer> serializedSize() {
+ return Optional.of(8);
+ }
}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java
index 495d6227d..3af5a30ba 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java
@@ -394,10 +394,9 @@ public abstract class CachingCodecRegistry implements MutableCodecRegistry {
"Can't infer vector codec because the first element is null "
+ "(note that CQL does not allow null values in collections)");
}
- GenericType<? extends Number> elementType =
- (GenericType<? extends Number>)
- inspectType(
- firstElement, cqlType == null ? null : ((VectorType) cqlType).getElementType());
+ GenericType<?> elementType =
+ inspectType(
+ firstElement, cqlType == null ? null : ((VectorType) cqlType).getElementType());
return GenericType.vectorOf(elementType);
}
} else {
@@ -421,8 +420,7 @@ public abstract class CachingCodecRegistry implements MutableCodecRegistry {
inferJavaTypeFromCqlType(keyType), inferJavaTypeFromCqlType(valueType));
} else if (cqlType instanceof VectorType) {
DataType elementType = ((VectorType) cqlType).getElementType();
- GenericType<? extends Number> numberType =
- (GenericType<? extends Number>) inferJavaTypeFromCqlType(elementType);
+ GenericType<?> numberType = inferJavaTypeFromCqlType(elementType);
return GenericType.vectorOf(numberType);
}
switch (cqlType.getProtocolCode()) {
@@ -657,7 +655,7 @@ public abstract class CachingCodecRegistry implements MutableCodecRegistry {
/* For a vector type we'll always get back an instance of TypeCodec<? extends Number> due to the
* type of CqlVector... but getElementCodecForCqlAndJavaType() is a generalized function that can't
* return this more precise type. Thus the cast here. */
- TypeCodec<? extends Number> elementCodec =
+ TypeCodec<?> elementCodec =
uncheckedCast(getElementCodecForCqlAndJavaType(vectorType, token, isJavaCovariant));
return TypeCodecs.vectorOf(vectorType, elementCodec);
} else if (cqlType instanceof CustomType
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/util/VIntCoding.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/util/VIntCoding.java
index 5ee375a81..552f84f2a 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/type/util/VIntCoding.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/type/util/VIntCoding.java
@@ -49,6 +49,7 @@ package com.datastax.oss.driver.internal.core.type.util;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
+import java.nio.ByteBuffer;
/**
* Variable length encoding inspired from Google <a
@@ -174,10 +175,84 @@ public class VIntCoding {
}
/** Compute the number of bytes that would be needed to encode an unsigned varint. */
- private static int computeUnsignedVIntSize(final long value) {
+ public static int computeUnsignedVIntSize(final long value) {
int magnitude =
Long.numberOfLeadingZeros(
value | 1); // | with 1 to ensure magnitude <= 63, so (63 - 1) / 7 <= 8
return (639 - magnitude * 9) >> 6;
}
+
+ public static void writeUnsignedVInt32(int value, ByteBuffer output) {
+ writeUnsignedVInt((long) value, output);
+ }
+
+ public static void writeUnsignedVInt(long value, ByteBuffer output) {
+ int size = VIntCoding.computeUnsignedVIntSize(value);
+ if (size == 1) {
+ output.put((byte) value);
+ return;
+ }
+
+ output.put(VIntCoding.encodeVInt(value, size), 0, size);
+ }
+
+ /**
+ * Read up to a 32-bit integer back, using the unsigned (no zigzag) encoding.
+ *
+ * <p>Note this method is the same as {@link #readUnsignedVInt(DataInput)}, except that we do
+ * *not* block if there are not enough bytes in the buffer to reconstruct the value.
+ *
+ * @throws VIntOutOfRangeException If the vint doesn't fit into a 32-bit integer
+ */
+ public static int getUnsignedVInt32(ByteBuffer input, int readerIndex) {
+ return checkedCast(getUnsignedVInt(input, readerIndex));
+ }
+
+ public static long getUnsignedVInt(ByteBuffer input, int readerIndex) {
+ return getUnsignedVInt(input, readerIndex, input.limit());
+ }
+
+ public static long getUnsignedVInt(ByteBuffer input, int readerIndex, int readerLimit) {
+ if (readerIndex < 0)
+ throw new IllegalArgumentException(
+ "Reader index should be non-negative, but was " + readerIndex);
+
+ if (readerIndex >= readerLimit) return -1;
+
+ int firstByte = input.get(readerIndex++);
+
+ // Bail out early if this is one byte, necessary or it fails later
+ if (firstByte >= 0) return firstByte;
+
+ int size = numberOfExtraBytesToRead(firstByte);
+ if (readerIndex + size > readerLimit) return -1;
+
+ long retval = firstByte & firstByteValueMask(size);
+ for (int ii = 0; ii < size; ii++) {
+ byte b = input.get(readerIndex++);
+ retval <<= 8;
+ retval |= b & 0xff;
+ }
+
+ return retval;
+ }
+
+ public static int checkedCast(long value) {
+ int result = (int) value;
+ if ((long) result != value) throw new VIntOutOfRangeException(value);
+ return result;
+ }
+
+ /**
+ * Throw when attempting to decode a vint and the output type doesn't have enough space to fit the
+ * value that was decoded
+ */
+ public static class VIntOutOfRangeException extends RuntimeException {
+ public final long value;
+
+ private VIntOutOfRangeException(long value) {
+ super(value + " is out of range for a 32-bit integer");
+ this.value = value;
+ }
+ }
}
diff --git a/core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java b/core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java
index 90f4cc6e7..3e0872cb9 100644
--- a/core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java
@@ -23,56 +23,60 @@ import static org.assertj.core.api.Assertions.fail;
import com.datastax.oss.driver.api.core.type.codec.TypeCodecs;
import com.datastax.oss.driver.internal.SerializationHelper;
-import com.datastax.oss.driver.shaded.guava.common.collect.Iterators;
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import com.tngtech.java.junit.dataprovider.UseDataProvider;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.io.ObjectStreamException;
+import java.time.LocalTime;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
+import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.assertj.core.util.Lists;
import org.junit.Test;
+import org.junit.runner.RunWith;
+@RunWith(DataProviderRunner.class)
public class CqlVectorTest {
- private static final Float[] VECTOR_ARGS = {1.0f, 2.5f};
-
- private void validate_built_vector(CqlVector<Float> vec) {
+ @DataProvider
+ public static Object[][] dataProvider() {
+ return new Object[][] {
+ {new Float[] {1.0f, 2.5f}},
+ {new LocalTime[] {LocalTime.of(1, 2), LocalTime.of(3, 4)}},
+ {new List[] {Arrays.asList(1, 2), Arrays.asList(3, 4)}},
+ {new CqlVector[] {CqlVector.newInstance("a", "bc"), CqlVector.newInstance("d", "ef")}}
+ };
+ }
+ private void validate_built_vector(CqlVector<?> vec, Object[] expectedVals) {
assertThat(vec.size()).isEqualTo(2);
assertThat(vec.isEmpty()).isFalse();
- assertThat(vec.get(0)).isEqualTo(VECTOR_ARGS[0]);
- assertThat(vec.get(1)).isEqualTo(VECTOR_ARGS[1]);
+ assertThat(vec.get(0)).isEqualTo(expectedVals[0]);
+ assertThat(vec.get(1)).isEqualTo(expectedVals[1]);
}
+ @UseDataProvider("dataProvider")
@Test
- public void should_build_vector_from_elements() {
-
- validate_built_vector(CqlVector.newInstance(VECTOR_ARGS));
+ public void should_build_vector_from_elements(Object[] vals) {
+ validate_built_vector(CqlVector.newInstance(vals), vals);
}
@Test
- public void should_build_vector_from_list() {
-
- validate_built_vector(CqlVector.newInstance(Lists.newArrayList(VECTOR_ARGS)));
- }
-
- @Test
- public void should_build_vector_from_tostring_output() {
-
- CqlVector<Float> vector1 = CqlVector.newInstance(VECTOR_ARGS);
- CqlVector<Float> vector2 = CqlVector.from(vector1.toString(), TypeCodecs.FLOAT);
- assertThat(vector2).isEqualTo(vector1);
+ @UseDataProvider("dataProvider")
+ public void should_build_vector_from_list(Object[] vals) {
+ validate_built_vector(CqlVector.newInstance(Lists.newArrayList(vals)), vals);
}
@Test
public void should_throw_from_null_string() {
-
assertThatThrownBy(
() -> {
CqlVector.from(null, TypeCodecs.FLOAT);
@@ -116,101 +120,97 @@ public class CqlVectorTest {
@Test
public void should_build_empty_vector() {
-
CqlVector<Float> vector = CqlVector.newInstance();
assertThat(vector.isEmpty()).isTrue();
assertThat(vector.size()).isEqualTo(0);
}
@Test
- public void should_behave_mostly_like_a_list() {
-
- CqlVector<Float> vector = CqlVector.newInstance(VECTOR_ARGS);
- assertThat(vector.get(0)).isEqualTo(VECTOR_ARGS[0]);
- Float newVal = VECTOR_ARGS[0] * 2;
- vector.set(0, newVal);
- assertThat(vector.get(0)).isEqualTo(newVal);
+ @UseDataProvider("dataProvider")
+ public <T> void should_behave_mostly_like_a_list(T[] vals) {
+ T[] theArray = Arrays.copyOf(vals, vals.length);
+ CqlVector<T> vector = CqlVector.newInstance(theArray);
+ assertThat(vector.get(0)).isEqualTo(theArray[0]);
+ vector.set(0, theArray[1]);
+ assertThat(vector.get(0)).isEqualTo(theArray[1]);
assertThat(vector.isEmpty()).isFalse();
assertThat(vector.size()).isEqualTo(2);
- assertThat(Iterators.toArray(vector.iterator(), Float.class)).isEqualTo(VECTOR_ARGS);
+ Iterator<?> iterator = vector.iterator();
+ assertThat(iterator.next()).isEqualTo(theArray[1]);
+ assertThat(iterator.next()).isEqualTo(theArray[1]);
}
@Test
- public void should_play_nicely_with_streams() {
-
- CqlVector<Float> vector = CqlVector.newInstance(VECTOR_ARGS);
- List<Float> results =
+ @UseDataProvider("dataProvider")
+ public <T> void should_play_nicely_with_streams(T[] vals) {
+ CqlVector<T> vector = CqlVector.newInstance(vals);
+ List<String> results =
vector.stream()
- .map((f) -> f * 2)
- .collect(Collectors.toCollection(() -> new ArrayList<Float>()));
+ .map(Object::toString)
+ .collect(Collectors.toCollection(() -> new ArrayList<String>()));
for (int i = 0; i < vector.size(); ++i) {
- assertThat(results.get(i)).isEqualTo(vector.get(i) * 2);
+ assertThat(results.get(i)).isEqualTo(vector.get(i).toString());
}
}
@Test
- public void should_reflect_changes_to_mutable_list() {
-
- List<Float> theList = Lists.newArrayList(1.1f, 2.2f, 3.3f);
- CqlVector<Float> vector = CqlVector.newInstance(theList);
- assertThat(vector.size()).isEqualTo(3);
- assertThat(vector.get(2)).isEqualTo(3.3f);
-
- float newVal1 = 4.4f;
- theList.set(2, newVal1);
- assertThat(vector.size()).isEqualTo(3);
- assertThat(vector.get(2)).isEqualTo(newVal1);
+ @UseDataProvider("dataProvider")
+ public <T> void should_reflect_changes_to_mutable_list(T[] vals) {
+ List<T> theList = Lists.newArrayList(vals);
+ CqlVector<T> vector = CqlVector.newInstance(theList);
+ assertThat(vector.size()).isEqualTo(2);
+ assertThat(vector.get(1)).isEqualTo(vals[1]);
- float newVal2 = 5.5f;
- theList.add(newVal2);
- assertThat(vector.size()).isEqualTo(4);
- assertThat(vector.get(3)).isEqualTo(newVal2);
+ T newVal = vals[0];
+ theList.set(1, newVal);
+ assertThat(vector.size()).isEqualTo(2);
+ assertThat(vector.get(1)).isEqualTo(newVal);
}
@Test
- public void should_reflect_changes_to_array() {
-
- Float[] theArray = new Float[] {1.1f, 2.2f, 3.3f};
- CqlVector<Float> vector = CqlVector.newInstance(theArray);
- assertThat(vector.size()).isEqualTo(3);
- assertThat(vector.get(2)).isEqualTo(3.3f);
+ @UseDataProvider("dataProvider")
+ public <T> void should_reflect_changes_to_array(T[] vals) {
+ T[] theArray = Arrays.copyOf(vals, vals.length);
+ CqlVector<T> vector = CqlVector.newInstance(theArray);
+ assertThat(vector.size()).isEqualTo(2);
+ assertThat(vector.get(1)).isEqualTo(theArray[1]);
- float newVal1 = 4.4f;
- theArray[2] = newVal1;
- assertThat(vector.size()).isEqualTo(3);
- assertThat(vector.get(2)).isEqualTo(newVal1);
+ T newVal = theArray[0];
+ theArray[1] = newVal;
+ assertThat(vector.size()).isEqualTo(2);
+ assertThat(vector.get(1)).isEqualTo(newVal);
}
@Test
- public void should_correctly_compare_vectors() {
-
- Float[] args = VECTOR_ARGS.clone();
- CqlVector<Float> vector1 = CqlVector.newInstance(args);
- CqlVector<Float> vector2 = CqlVector.newInstance(args);
- CqlVector<Float> vector3 = CqlVector.newInstance(Lists.newArrayList(args));
+ @UseDataProvider("dataProvider")
+ public <T> void should_correctly_compare_vectors(T[] vals) {
+ CqlVector<T> vector1 = CqlVector.newInstance(vals);
+ CqlVector<T> vector2 = CqlVector.newInstance(vals);
+ CqlVector<T> vector3 = CqlVector.newInstance(Lists.newArrayList(vals));
assertThat(vector1).isNotSameAs(vector2);
assertThat(vector1).isEqualTo(vector2);
assertThat(vector1).isNotSameAs(vector3);
assertThat(vector1).isEqualTo(vector3);
- Float[] differentArgs = args.clone();
- float newVal = differentArgs[0] * 2;
+ T[] differentArgs = Arrays.copyOf(vals, vals.length);
+ T newVal = differentArgs[1];
differentArgs[0] = newVal;
- CqlVector<Float> vector4 = CqlVector.newInstance(differentArgs);
+ CqlVector<T> vector4 = CqlVector.newInstance(differentArgs);
assertThat(vector1).isNotSameAs(vector4);
assertThat(vector1).isNotEqualTo(vector4);
- Float[] biggerArgs = Arrays.copyOf(args, args.length + 1);
+ T[] biggerArgs = Arrays.copyOf(vals, vals.length + 1);
biggerArgs[biggerArgs.length - 1] = newVal;
- CqlVector<Float> vector5 = CqlVector.newInstance(biggerArgs);
+ CqlVector<T> vector5 = CqlVector.newInstance(biggerArgs);
assertThat(vector1).isNotSameAs(vector5);
assertThat(vector1).isNotEqualTo(vector5);
}
@Test
- public void should_serialize_and_deserialize() throws Exception {
- CqlVector<Float> initial = CqlVector.newInstance(VECTOR_ARGS);
- CqlVector<Float> deserialized = SerializationHelper.serializeAndDeserialize(initial);
+ @UseDataProvider("dataProvider")
+ public <T> void should_serialize_and_deserialize(T[] vals) throws Exception {
+ CqlVector<T> initial = CqlVector.newInstance(vals);
+ CqlVector<T> deserialized = SerializationHelper.serializeAndDeserialize(initial);
assertThat(deserialized).isEqualTo(initial);
}
@@ -222,21 +222,22 @@ public class CqlVectorTest {
}
@Test
- public void should_serialize_and_deserialize_unserializable_list() throws Exception {
- CqlVector<Float> initial =
+ @UseDataProvider("dataProvider")
+ public <T> void should_serialize_and_deserialize_unserializable_list(T[] vals) throws Exception {
+ CqlVector<T> initial =
CqlVector.newInstance(
- new AbstractList<Float>() {
+ new AbstractList<T>() {
@Override
- public Float get(int index) {
- return VECTOR_ARGS[index];
+ public T get(int index) {
+ return vals[index];
}
@Override
public int size() {
- return VECTOR_ARGS.length;
+ return vals.length;
}
});
- CqlVector<Float> deserialized = SerializationHelper.serializeAndDeserialize(initial);
+ CqlVector<T> deserialized = SerializationHelper.serializeAndDeserialize(initial);
assertThat(deserialized).isEqualTo(initial);
}
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java
index 969d35cbb..17c785141 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java
@@ -20,122 +20,255 @@ package com.datastax.oss.driver.internal.core.type.codec;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import com.datastax.oss.driver.api.core.ProtocolVersion;
import com.datastax.oss.driver.api.core.data.CqlVector;
+import com.datastax.oss.driver.api.core.type.DataType;
import com.datastax.oss.driver.api.core.type.DataTypes;
-import com.datastax.oss.driver.api.core.type.VectorType;
+import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
import com.datastax.oss.driver.api.core.type.codec.TypeCodecs;
-import com.datastax.oss.driver.api.core.type.reflect.GenericType;
+import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
import com.datastax.oss.driver.internal.core.type.DefaultVectorType;
-import java.util.Arrays;
+import com.datastax.oss.protocol.internal.util.Bytes;
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import com.tngtech.java.junit.dataprovider.UseDataProvider;
+import java.nio.ByteBuffer;
+import java.time.LocalTime;
+import java.util.HashMap;
+import org.apache.commons.lang3.ArrayUtils;
import org.junit.Test;
+import org.junit.runner.RunWith;
-public class VectorCodecTest extends CodecTestBase<CqlVector<Float>> {
+@RunWith(DataProviderRunner.class)
+public class VectorCodecTest {
- private static final Float[] VECTOR_ARGS = {1.0f, 2.5f};
-
- private static final CqlVector<Float> VECTOR = CqlVector.newInstance(VECTOR_ARGS);
-
- private static final String VECTOR_HEX_STRING = "0x" + "3f800000" + "40200000";
-
- private static final String FORMATTED_VECTOR = "[1.0, 2.5]";
-
- public VectorCodecTest() {
- VectorType vectorType = DataTypes.vectorOf(DataTypes.FLOAT, 2);
- this.codec = TypeCodecs.vectorOf(vectorType, TypeCodecs.FLOAT);
+ @DataProvider
+ public static Object[] dataProvider() {
+ HashMap<Integer, String> map1 = new HashMap<>();
+ map1.put(1, "a");
+ HashMap<Integer, String> map2 = new HashMap<>();
+ map2.put(2, "b");
+ return new TestDataContainer[] {
+ new TestDataContainer(
+ DataTypes.FLOAT,
+ new Float[] {1.0f, 2.5f},
+ "[1.0, 2.5]",
+ Bytes.fromHexString("0x3f80000040200000")),
+ new TestDataContainer(
+ DataTypes.ASCII,
+ new String[] {"ab", "cde"},
+ "['ab', 'cde']",
+ Bytes.fromHexString("0x02616203636465")),
+ new TestDataContainer(
+ DataTypes.BIGINT,
+ new Long[] {1L, 2L},
+ "[1, 2]",
+ Bytes.fromHexString("0x00000000000000010000000000000002")),
+ new TestDataContainer(
+ DataTypes.BLOB,
+ new ByteBuffer[] {Bytes.fromHexString("0xCAFE"), Bytes.fromHexString("0xABCD")},
+ "[0xcafe, 0xabcd]",
+ Bytes.fromHexString("0x02cafe02abcd")),
+ new TestDataContainer(
+ DataTypes.BOOLEAN,
+ new Boolean[] {true, false},
+ "[true, false]",
+ Bytes.fromHexString("0x0100")),
+ new TestDataContainer(
+ DataTypes.TIME,
+ new LocalTime[] {LocalTime.ofNanoOfDay(1), LocalTime.ofNanoOfDay(2)},
+ "['00:00:00.000000001', '00:00:00.000000002']",
+ Bytes.fromHexString("0x080000000000000001080000000000000002")),
+ new TestDataContainer(
+ DataTypes.mapOf(DataTypes.INT, DataTypes.ASCII),
+ new HashMap[] {map1, map2},
+ "[{1:'a'}, {2:'b'}]",
+ Bytes.fromHexString(
+ "0x110000000100000004000000010000000161110000000100000004000000020000000162")),
+ new TestDataContainer(
+ DataTypes.vectorOf(DataTypes.INT, 1),
+ new CqlVector[] {CqlVector.newInstance(1), CqlVector.newInstance(2)},
+ "[[1], [2]]",
+ Bytes.fromHexString("0x0000000100000002")),
+ new TestDataContainer(
+ DataTypes.vectorOf(DataTypes.TEXT, 1),
+ new CqlVector[] {CqlVector.newInstance("ab"), CqlVector.newInstance("cdef")},
+ "[['ab'], ['cdef']]",
+ Bytes.fromHexString("0x03026162050463646566")),
+ new TestDataContainer(
+ DataTypes.vectorOf(DataTypes.vectorOf(DataTypes.FLOAT, 2), 1),
+ new CqlVector[] {
+ CqlVector.newInstance(CqlVector.newInstance(1.0f, 2.5f)),
+ CqlVector.newInstance(CqlVector.newInstance(3.0f, 4.5f))
+ },
+ "[[[1.0, 2.5]], [[3.0, 4.5]]]",
+ Bytes.fromHexString("0x3f800000402000004040000040900000"))
+ };
}
+ @UseDataProvider("dataProvider")
@Test
- public void should_encode() {
- assertThat(encode(VECTOR)).isEqualTo(VECTOR_HEX_STRING);
- assertThat(encode(null)).isNull();
+ public void should_encode(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ CqlVector<Object> vector = CqlVector.newInstance(testData.getValues());
+ assertThat(codec.encode(vector, ProtocolVersion.DEFAULT)).isEqualTo(testData.getBytes());
}
- /** Too few eleements will cause an exception, extra elements will be silently ignored */
@Test
- public void should_throw_on_encode_with_too_few_elements() {
- assertThatThrownBy(() -> encode(VECTOR.subVector(0, 1)))
+ @UseDataProvider("dataProvider")
+ public void should_throw_on_encode_with_too_few_elements(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ assertThatThrownBy(
+ () ->
+ codec.encode(
+ CqlVector.newInstance(testData.getValues()[0]), ProtocolVersion.DEFAULT))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void should_throw_on_encode_with_empty_list() {
- assertThatThrownBy(() -> encode(CqlVector.newInstance()))
+ @UseDataProvider("dataProvider")
+ public void should_throw_on_encode_with_too_many_elements(TestDataContainer testData) {
+ Object[] doubled = ArrayUtils.addAll(testData.getValues(), testData.getValues());
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ assertThatThrownBy(() -> codec.encode(CqlVector.newInstance(doubled), ProtocolVersion.DEFAULT))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void should_encode_with_too_many_elements() {
- Float[] doubledVectorContents = Arrays.copyOf(VECTOR_ARGS, VECTOR_ARGS.length * 2);
- System.arraycopy(VECTOR_ARGS, 0, doubledVectorContents, VECTOR_ARGS.length, VECTOR_ARGS.length);
- assertThat(encode(CqlVector.newInstance(doubledVectorContents))).isEqualTo(VECTOR_HEX_STRING);
+ @UseDataProvider("dataProvider")
+ public void should_decode(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ assertThat(codec.decode(testData.getBytes(), ProtocolVersion.DEFAULT))
+ .isEqualTo(CqlVector.newInstance(testData.getValues()));
}
@Test
- public void should_decode() {
- assertThat(decode(VECTOR_HEX_STRING)).isEqualTo(VECTOR);
- assertThat(decode("0x")).isNull();
- assertThat(decode(null)).isNull();
+ @UseDataProvider("dataProvider")
+ public void should_throw_on_decode_if_too_few_bytes(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ int lastIndex = testData.getBytes().remaining() - 1;
+ assertThatThrownBy(
+ () ->
+ codec.decode(
+ (ByteBuffer) testData.getBytes().duplicate().limit(lastIndex),
+ ProtocolVersion.DEFAULT))
+ .isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void should_throw_on_decode_if_too_few_bytes() {
- // Dropping 4 bytes would knock off exactly 1 float, anything less than that would be something
- // we couldn't parse a float out of
- for (int i = 1; i <= 3; ++i) {
- // 2 chars of hex encoded string = 1 byte
- int lastIndex = VECTOR_HEX_STRING.length() - (2 * i);
- assertThatThrownBy(() -> decode(VECTOR_HEX_STRING.substring(0, lastIndex)))
- .isInstanceOf(IllegalArgumentException.class);
- }
+ @UseDataProvider("dataProvider")
+ public void should_throw_on_decode_if_too_many_bytes(TestDataContainer testData) {
+ ByteBuffer doubled = ByteBuffer.allocate(testData.getBytes().remaining() * 2);
+ doubled.put(testData.getBytes().duplicate()).put(testData.getBytes().duplicate()).flip();
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ assertThatThrownBy(() -> codec.decode(doubled, ProtocolVersion.DEFAULT))
+ .isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void should_format() {
- assertThat(format(VECTOR)).isEqualTo(FORMATTED_VECTOR);
- assertThat(format(null)).isEqualTo("NULL");
+ @UseDataProvider("dataProvider")
+ public void should_format(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ CqlVector<Object> vector = CqlVector.newInstance(testData.getValues());
+ assertThat(codec.format(vector)).isEqualTo(testData.getFormatted());
}
@Test
- public void should_parse() {
- assertThat(parse(FORMATTED_VECTOR)).isEqualTo(VECTOR);
- assertThat(parse("NULL")).isNull();
- assertThat(parse("null")).isNull();
- assertThat(parse("")).isNull();
- assertThat(parse(null)).isNull();
+ @UseDataProvider("dataProvider")
+ public void should_parse(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ assertThat(codec.parse(testData.getFormatted()))
+ .isEqualTo(CqlVector.newInstance(testData.getValues()));
}
@Test
- public void should_accept_data_type() {
- assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, 2))).isTrue();
- assertThat(codec.accepts(DataTypes.INT)).isFalse();
+ @UseDataProvider("dataProvider")
+ public void should_accept_data_type(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ assertThat(codec.accepts(new DefaultVectorType(testData.getDataType(), 2))).isTrue();
+ assertThat(codec.accepts(new DefaultVectorType(DataTypes.custom("non-existent"), 2))).isFalse();
}
@Test
- public void should_accept_vector_type_correct_dimension_only() {
- assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, 0))).isFalse();
- assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, 1))).isFalse();
- assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, 2))).isTrue();
- for (int i = 3; i < 1000; ++i) {
- assertThat(codec.accepts(new DefaultVectorType(DataTypes.FLOAT, i))).isFalse();
- }
+ @UseDataProvider("dataProvider")
+ public void should_accept_vector_type_correct_dimension_only(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ assertThat(codec.accepts(new DefaultVectorType(testData.getDataType(), 0))).isFalse();
+ assertThat(codec.accepts(new DefaultVectorType(testData.getDataType(), 1))).isFalse();
+ assertThat(codec.accepts(new DefaultVectorType(testData.getDataType(), 3))).isFalse();
}
@Test
- public void should_accept_generic_type() {
- assertThat(codec.accepts(GenericType.vectorOf(GenericType.FLOAT))).isTrue();
- assertThat(codec.accepts(GenericType.vectorOf(GenericType.INTEGER))).isFalse();
- assertThat(codec.accepts(GenericType.of(Integer.class))).isFalse();
+ @UseDataProvider("dataProvider")
+ public void should_accept_generic_type(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ assertThat(codec.accepts(codec.getJavaType())).isTrue();
}
@Test
- public void should_accept_raw_type() {
+ @UseDataProvider("dataProvider")
+ public void should_accept_raw_type(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
assertThat(codec.accepts(CqlVector.class)).isTrue();
assertThat(codec.accepts(Integer.class)).isFalse();
}
@Test
- public void should_accept_object() {
- assertThat(codec.accepts(VECTOR)).isTrue();
+ @UseDataProvider("dataProvider")
+ public void should_accept_object(TestDataContainer testData) {
+ TypeCodec<CqlVector<Object>> codec = getCodec(testData.getDataType());
+ CqlVector<?> vector = CqlVector.newInstance(testData.getValues());
+ assertThat(codec.accepts(vector)).isTrue();
assertThat(codec.accepts(Integer.MIN_VALUE)).isFalse();
}
+
+ @Test
+ public void should_handle_null_and_empty() {
+ TypeCodec<CqlVector<Object>> codec = getCodec(DataTypes.FLOAT);
+ assertThat(codec.encode(null, ProtocolVersion.DEFAULT)).isNull();
+ assertThat(codec.decode(Bytes.fromHexString("0x"), ProtocolVersion.DEFAULT)).isNull();
+ assertThat(codec.format(null)).isEqualTo("NULL");
+ assertThat(codec.parse("NULL")).isNull();
+ assertThat(codec.parse("null")).isNull();
+ assertThat(codec.parse("")).isNull();
+ assertThat(codec.parse(null)).isNull();
+ assertThatThrownBy(() -> codec.encode(CqlVector.newInstance(), ProtocolVersion.DEFAULT))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ private static TypeCodec<CqlVector<Object>> getCodec(DataType dataType) {
+ return TypeCodecs.vectorOf(
+ DataTypes.vectorOf(dataType, 2), CodecRegistry.DEFAULT.codecFor(dataType));
+ }
+
+ private static class TestDataContainer {
+ private final DataType dataType;
+ private final Object[] values;
+ private final String formatted;
+ private final ByteBuffer bytes;
+
+ public TestDataContainer(
+ DataType dataType, Object[] values, String formatted, ByteBuffer bytes) {
+ this.dataType = dataType;
+ this.values = values;
+ this.formatted = formatted;
+ this.bytes = bytes;
+ }
+
+ public DataType getDataType() {
+ return dataType;
+ }
+
+ public Object[] getValues() {
+ return values;
+ }
+
+ public String getFormatted() {
+ return formatted;
+ }
+
+ public ByteBuffer getBytes() {
+ return bytes;
+ }
+ }
}
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTestDataProviders.java b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTestDataProviders.java
index 1f3f6bbff..4c0298baf 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTestDataProviders.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTestDataProviders.java
@@ -337,6 +337,26 @@ public class CachingCodecRegistryTestDataProviders {
GenericType.vectorOf(BigInteger.class),
CqlVector.newInstance(BigInteger.ONE)
},
+ // vector with arbitrary types
+ {
+ DataTypes.vectorOf(DataTypes.TEXT, 2),
+ GenericType.vectorOf(String.class),
+ GenericType.vectorOf(String.class),
+ CqlVector.newInstance("abc", "de")
+ },
+ {
+ DataTypes.vectorOf(DataTypes.TIME, 2),
+ GenericType.vectorOf(LocalTime.class),
+ GenericType.vectorOf(LocalTime.class),
+ CqlVector.newInstance(LocalTime.MIDNIGHT, LocalTime.NOON)
+ },
+ {
+ DataTypes.vectorOf(DataTypes.vectorOf(DataTypes.TINYINT, 2), 2),
+ GenericType.vectorOf(GenericType.vectorOf(Byte.class)),
+ GenericType.vectorOf(GenericType.vectorOf(Byte.class)),
+ CqlVector.newInstance(
+ CqlVector.newInstance((byte) 1, (byte) 2), CqlVector.newInstance((byte) 3, (byte) 4))
+ },
};
}
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/type/util/VIntCodingTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/type/util/VIntCodingTest.java
new file mode 100644
index 000000000..b85d6d668
--- /dev/null
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/type/util/VIntCodingTest.java
@@ -0,0 +1,86 @@
+/*
+ * 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 com.datastax.oss.driver.internal.core.type.util;
+
+import static org.junit.Assert.assertEquals;
+
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import com.tngtech.java.junit.dataprovider.UseDataProvider;
+import java.nio.ByteBuffer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(DataProviderRunner.class)
+public class VIntCodingTest {
+ @DataProvider
+ public static Object[] roundTripTestValues() {
+ return new Integer[] {
+ Integer.MAX_VALUE + 1,
+ Integer.MAX_VALUE,
+ Integer.MAX_VALUE - 1,
+ Integer.MIN_VALUE,
+ Integer.MIN_VALUE + 1,
+ Integer.MIN_VALUE - 1,
+ 0,
+ -1,
+ 1
+ };
+ };
+
+ private static final long[] LONGS =
+ new long[] {
+ 53L,
+ 10201L,
+ 1097151L,
+ 168435455L,
+ 33251130335L,
+ 3281283447775L,
+ 417672546086779L,
+ 52057592037927932L,
+ 72057594037927937L
+ };
+
+ @Test
+ public void should_compute_unsigned_vint_size() {
+ for (int i = 0; i < LONGS.length; i++) {
+ long val = LONGS[i];
+ assertEquals(i + 1, VIntCoding.computeUnsignedVIntSize(val));
+ }
+ }
+
+ @Test
+ @UseDataProvider("roundTripTestValues")
+ public void should_write_and_read_unsigned_vint_32(int value) {
+ ByteBuffer bb = ByteBuffer.allocate(9);
+
+ VIntCoding.writeUnsignedVInt32(value, bb);
+ bb.flip();
+ assertEquals(value, VIntCoding.getUnsignedVInt32(bb, 0));
+ }
+
+ @Test
+ @UseDataProvider("roundTripTestValues")
+ public void should_write_and_read_unsigned_vint(int value) {
+ ByteBuffer bb = ByteBuffer.allocate(9);
+
+ VIntCoding.writeUnsignedVInt(value, bb);
+ bb.flip();
+ assertEquals(value, VIntCoding.getUnsignedVInt(bb, 0));
+ }
+}
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java
index a33c87048..e3d891454 100644
--- a/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java
+++ b/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java
@@ -32,6 +32,7 @@ import com.datastax.oss.driver.api.core.cql.Row;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.cql.Statement;
import com.datastax.oss.driver.api.core.data.CqlDuration;
+import com.datastax.oss.driver.api.core.data.CqlVector;
import com.datastax.oss.driver.api.core.data.SettableByIndex;
import com.datastax.oss.driver.api.core.data.SettableByName;
import com.datastax.oss.driver.api.core.data.TupleValue;
@@ -183,6 +184,7 @@ public class DataTypeIT {
// 5) include map<type, int>
// 6) include tuple<int, type>
// 7) include udt<int, type>
+ // 8) include vector<type>
return Arrays.stream(primitiveSamples)
.flatMap(
o -> {
@@ -263,6 +265,30 @@ public class DataTypeIT {
UdtValue udtValue2 = udt.newValue(1, o[1]);
samples.add(new Object[] {udt, udtValue2});
+ if (CCM_RULE.getCassandraVersion().compareTo(Version.parse("5.0")) >= 0) {
+ // vector of type
+ CqlVector<?> vector = CqlVector.newInstance(o[1]);
+ samples.add(new Object[] {DataTypes.vectorOf(dataType, 1), vector});
+ }
+
+ return samples.stream();
+ })
+ .toArray(Object[][]::new);
+ }
+
+ @DataProvider
+ public static Object[][] addVectors() {
+ Object[][] previousSamples = typeSamples();
+ if (CCM_RULE.getCassandraVersion().compareTo(Version.parse("5.0")) < 0) return previousSamples;
+ return Arrays.stream(previousSamples)
+ .flatMap(
+ o -> {
+ List<Object[]> samples = new ArrayList<>();
+ samples.add(o);
+ if (o[1] == null) return samples.stream();
+ DataType dataType = (DataType) o[0];
+ CqlVector<?> vector = CqlVector.newInstance(o[1]);
+ samples.add(new Object[] {DataTypes.vectorOf(dataType, 1), vector});
return samples.stream();
})
.toArray(Object[][]::new);
@@ -278,7 +304,7 @@ public class DataTypeIT {
List<String> columnData = new ArrayList<>();
- for (Object[] sample : typeSamples()) {
+ for (Object[] sample : addVectors()) {
DataType dataType = (DataType) sample[0];
if (!typeToColumnName.containsKey(dataType)) {
@@ -308,7 +334,7 @@ public class DataTypeIT {
return keyCounter.incrementAndGet();
}
- @UseDataProvider("typeSamples")
+ @UseDataProvider("addVectors")
@Test
public <K> void should_insert_non_primary_key_column_simple_statement_using_format(
DataType dataType, K value, K expectedPrimitiveValue) {
@@ -335,7 +361,7 @@ public class DataTypeIT {
readValue(select, dataType, value, expectedPrimitiveValue);
}
- @UseDataProvider("typeSamples")
+ @UseDataProvider("addVectors")
@Test
public <K> void should_insert_non_primary_key_column_simple_statement_positional_value(
DataType dataType, K value, K expectedPrimitiveValue) {
@@ -358,7 +384,7 @@ public class DataTypeIT {
readValue(select, dataType, value, expectedPrimitiveValue);
}
- @UseDataProvider("typeSamples")
+ @UseDataProvider("addVectors")
@Test
public <K> void should_insert_non_primary_key_column_simple_statement_named_value(
DataType dataType, K value, K expectedPrimitiveValue) {
@@ -382,7 +408,7 @@ public class DataTypeIT {
readValue(select, dataType, value, expectedPrimitiveValue);
}
- @UseDataProvider("typeSamples")
+ @UseDataProvider("addVectors")
@Test
public <K> void should_insert_non_primary_key_column_bound_statement_positional_value(
DataType dataType, K value, K expectedPrimitiveValue) {
@@ -411,7 +437,7 @@ public class DataTypeIT {
readValue(boundSelect, dataType, value, expectedPrimitiveValue);
}
- @UseDataProvider("typeSamples")
+ @UseDataProvider("addVectors")
@Test
public <K> void should_insert_non_primary_key_column_bound_statement_named_value(
DataType dataType, K value, K expectedPrimitiveValue) {
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org