adelapena commented on code in PR #2310: URL: https://github.com/apache/cassandra/pull/2310#discussion_r1227916858
########## src/java/org/apache/cassandra/cql3/Vectors.java: ########## @@ -0,0 +1,231 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.cql3; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import org.apache.cassandra.cql3.functions.Function; +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.VectorType; +import org.apache.cassandra.exceptions.InvalidRequestException; +import org.apache.cassandra.transport.ProtocolVersion; +import org.apache.cassandra.utils.ByteBufferUtil; + +public class Vectors +{ + private Vectors() {} + + private static AbstractType<?> elementsType(AbstractType<?> type) + { + return ((VectorType<?>) type.unwrap()).getElementsType(); + } + + private static ColumnSpecification valueSpecOf(ColumnSpecification column) + { + return new ColumnSpecification(column.ksName, column.cfName, new ColumnIdentifier("value(" + column.name + ")", true), elementsType(column.type)); + } + + /** + * Tests that the list with the specified elements can be assigned to the specified column. + * + * @param receiver the receiving column + * @param elements the list elements + */ + public static AssignmentTestable.TestResult testVectorAssignment(ColumnSpecification receiver, + List<? extends AssignmentTestable> elements) + { + if (!(receiver.type instanceof VectorType)) + return AssignmentTestable.TestResult.NOT_ASSIGNABLE; + + // If there is no elements, we can't say it's an exact match (an empty list if fundamentally polymorphic). + if (elements.isEmpty()) + return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE; + + ColumnSpecification valueSpec = valueSpecOf(receiver); + return AssignmentTestable.TestResult.testAll(receiver.ksName, valueSpec, elements); + } + + /** + * Returns the exact ListType from the items if it can be known. + * + * @param items the items mapped to the list elements + * @param mapper the mapper used to retrieve the element types from the items + * @return the exact ListType from the items if it can be known or <code>null</code> + */ + public static <T> VectorType<?> getExactListTypeIfKnown(List<T> items, Review Comment: JavaDoc and the function name are still about lists instead of vectors. ########## src/java/org/apache/cassandra/cql3/ArrayLiteral.java: ########## @@ -0,0 +1,75 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.cql3; + +import java.util.List; + +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.ListType; +import org.apache.cassandra.db.marshal.VectorType; +import org.apache.cassandra.exceptions.InvalidRequestException; + +/** + * Represents {@code [a, b, c, d]} in CQL. Mutliple {@link org.apache.cassandra.db.marshal.AbstractType} use array literals, + * so this class is meant to act as a proxy once the real type is known. + */ +public class ArrayLiteral extends Term.Raw +{ + private final List<Term.Raw> elements; + + public ArrayLiteral(List<Term.Raw> elements) + { + this.elements = elements; + } + + private Term.Raw forReceiver(ColumnSpecification receiver) + { + AbstractType<?> type = receiver.type.unwrap(); + if (type instanceof VectorType) Review Comment: We can use `type.isVector()` ########## src/java/org/apache/cassandra/cql3/Vectors.java: ########## @@ -0,0 +1,231 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.cql3; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import org.apache.cassandra.cql3.functions.Function; +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.VectorType; +import org.apache.cassandra.exceptions.InvalidRequestException; +import org.apache.cassandra.transport.ProtocolVersion; +import org.apache.cassandra.utils.ByteBufferUtil; + +public class Vectors +{ + private Vectors() {} + + private static AbstractType<?> elementsType(AbstractType<?> type) + { + return ((VectorType<?>) type.unwrap()).getElementsType(); + } + + private static ColumnSpecification valueSpecOf(ColumnSpecification column) + { + return new ColumnSpecification(column.ksName, column.cfName, new ColumnIdentifier("value(" + column.name + ")", true), elementsType(column.type)); + } + + /** + * Tests that the list with the specified elements can be assigned to the specified column. + * + * @param receiver the receiving column + * @param elements the list elements + */ + public static AssignmentTestable.TestResult testVectorAssignment(ColumnSpecification receiver, + List<? extends AssignmentTestable> elements) + { + if (!(receiver.type instanceof VectorType)) Review Comment: I think we can use `receiver.type.isVector()` ########## src/java/org/apache/cassandra/cql3/selection/VectorSelector.java: ########## @@ -0,0 +1,178 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.cql3.selection; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +import com.google.common.base.Preconditions; + +import org.apache.cassandra.cql3.Lists; +import org.apache.cassandra.cql3.QueryOptions; +import org.apache.cassandra.db.filter.ColumnFilter; +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.VectorType; +import org.apache.cassandra.exceptions.InvalidRequestException; +import org.apache.cassandra.io.util.DataInputPlus; +import org.apache.cassandra.io.util.DataOutputPlus; +import org.apache.cassandra.schema.TableMetadata; +import org.apache.cassandra.transport.ProtocolVersion; + +public class VectorSelector extends Selector +{ + protected static final SelectorDeserializer deserializer = new SelectorDeserializer() + { + protected Selector deserialize(DataInputPlus in, int version, TableMetadata metadata) throws IOException + { + VectorType<?> type = (VectorType<?>) readType(metadata, in); + List<Selector> elements = new ArrayList<>(type.dimension); + for (int i = 0; i < type.dimension; i++) + elements.add(serializer.deserialize(in, version, metadata)); + + return new VectorSelector(type, elements); + } + }; + + /** + * The vector type. + */ + private final VectorType<?> type; + + /** + * The list elements + */ + private final List<Selector> elements; + + private VectorSelector(VectorType<?> type, List<Selector> elements) + { + super(Kind.VECTOR_SELECTOR); + Preconditions.checkArgument(elements.size() == type.dimension, "Unable to create a vector select of type %s from %s elements", type.asCQL3Type(), elements.size()); + this.type = type; + this.elements = elements; + } + + public static Factory newFactory(final AbstractType<?> type, final SelectorFactories factories) + { + assert type.isVector() : String.format("Unable to create vector selector from typs %s", type.asCQL3Type()); + VectorType<?> vt = (VectorType<?>) type; + // TODO : should CollectionFactory be renamed? Its used by Collections, Tuples, and Vectors Review Comment: Maybe `MultiElementFactory`? To further complicate things, that factory isn't used for maps, even though they are collections. I guess we should also update its JavaDoc, now it says `A base <code>Selector.Factory</code> for collections or tuples.` and it should probably mention vectors. ########## src/java/org/apache/cassandra/cql3/selection/VectorSelector.java: ########## @@ -0,0 +1,178 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.cql3.selection; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +import com.google.common.base.Preconditions; + +import org.apache.cassandra.cql3.Lists; +import org.apache.cassandra.cql3.QueryOptions; +import org.apache.cassandra.db.filter.ColumnFilter; +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.VectorType; +import org.apache.cassandra.exceptions.InvalidRequestException; +import org.apache.cassandra.io.util.DataInputPlus; +import org.apache.cassandra.io.util.DataOutputPlus; +import org.apache.cassandra.schema.TableMetadata; +import org.apache.cassandra.transport.ProtocolVersion; + +public class VectorSelector extends Selector +{ + protected static final SelectorDeserializer deserializer = new SelectorDeserializer() + { + protected Selector deserialize(DataInputPlus in, int version, TableMetadata metadata) throws IOException Review Comment: Nit: add `@Override` ########## src/java/org/apache/cassandra/cql3/Vectors.java: ########## @@ -0,0 +1,231 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.cql3; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import org.apache.cassandra.cql3.functions.Function; +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.VectorType; +import org.apache.cassandra.exceptions.InvalidRequestException; +import org.apache.cassandra.transport.ProtocolVersion; +import org.apache.cassandra.utils.ByteBufferUtil; + +public class Vectors +{ + private Vectors() {} + + private static AbstractType<?> elementsType(AbstractType<?> type) + { + return ((VectorType<?>) type.unwrap()).getElementsType(); + } + + private static ColumnSpecification valueSpecOf(ColumnSpecification column) + { + return new ColumnSpecification(column.ksName, column.cfName, new ColumnIdentifier("value(" + column.name + ")", true), elementsType(column.type)); + } + + /** + * Tests that the list with the specified elements can be assigned to the specified column. + * + * @param receiver the receiving column + * @param elements the list elements + */ + public static AssignmentTestable.TestResult testVectorAssignment(ColumnSpecification receiver, + List<? extends AssignmentTestable> elements) + { + if (!(receiver.type instanceof VectorType)) + return AssignmentTestable.TestResult.NOT_ASSIGNABLE; + + // If there is no elements, we can't say it's an exact match (an empty list if fundamentally polymorphic). + if (elements.isEmpty()) + return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE; + + ColumnSpecification valueSpec = valueSpecOf(receiver); + return AssignmentTestable.TestResult.testAll(receiver.ksName, valueSpec, elements); + } + + /** + * Returns the exact ListType from the items if it can be known. + * + * @param items the items mapped to the list elements + * @param mapper the mapper used to retrieve the element types from the items + * @return the exact ListType from the items if it can be known or <code>null</code> + */ + public static <T> VectorType<?> getExactListTypeIfKnown(List<T> items, + java.util.function.Function<T, AbstractType<?>> mapper) + { + // TODO - this doesn't feel right... if you are dealing with a literal then the value is `null`, so we will ignore + // if there are multiple times, we randomly select the first? This logic matches Lists.getExactListTypeIfKnown but feels flawed + Optional<AbstractType<?>> type = items.stream().map(mapper).filter(Objects::nonNull).findFirst(); + return type.isPresent() ? VectorType.getInstance(type.get(), items.size()) : null; + } + + public static <T> VectorType<?> getPreferredCompatibleType(List<T> items, + java.util.function.Function<T, AbstractType<?>> mapper) + { + // TODO - this doesn't feel right... if you are dealing with a literal then the value is `null`, so we will ignore + // if there are multiple times, we randomly select the first? This logic matches Lists.getExactListTypeIfKnown but feels flawed Review Comment: I guess it would be: ```suggestion // if there are multiple items, we randomly select the first? This logic matches Lists.getPreferredCompatibleType but feels flawed ``` But I think that `AssignmentTestable#getCompatibleTypeIfKnown` selects an element compatible type that is also compatible with all the compatible types of all the other elements. So it doesn't randomly select the first type. ########## src/java/org/apache/cassandra/cql3/CQL3Type.java: ########## @@ -499,6 +514,55 @@ public String toString(boolean withFrozen) } } + public static class Vector implements CQL3Type + { + private final VectorType<?> type; + + public Vector(VectorType<?> type) + { + this.type = type; + } + + public Vector(AbstractType<?> type, int dimensions) Review Comment: Nit: I'd name the first parameter `elementType`, so we can immediately understand what type is it taking and easily distinguish it from the other constructor. ########## src/java/org/apache/cassandra/cql3/Vectors.java: ########## @@ -0,0 +1,231 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.cql3; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import org.apache.cassandra.cql3.functions.Function; +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.VectorType; +import org.apache.cassandra.exceptions.InvalidRequestException; +import org.apache.cassandra.transport.ProtocolVersion; +import org.apache.cassandra.utils.ByteBufferUtil; + +public class Vectors +{ + private Vectors() {} + + private static AbstractType<?> elementsType(AbstractType<?> type) + { + return ((VectorType<?>) type.unwrap()).getElementsType(); + } + + private static ColumnSpecification valueSpecOf(ColumnSpecification column) + { + return new ColumnSpecification(column.ksName, column.cfName, new ColumnIdentifier("value(" + column.name + ")", true), elementsType(column.type)); + } + + /** + * Tests that the list with the specified elements can be assigned to the specified column. + * + * @param receiver the receiving column + * @param elements the list elements + */ + public static AssignmentTestable.TestResult testVectorAssignment(ColumnSpecification receiver, + List<? extends AssignmentTestable> elements) + { + if (!(receiver.type instanceof VectorType)) + return AssignmentTestable.TestResult.NOT_ASSIGNABLE; + + // If there is no elements, we can't say it's an exact match (an empty list if fundamentally polymorphic). + if (elements.isEmpty()) + return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE; + + ColumnSpecification valueSpec = valueSpecOf(receiver); + return AssignmentTestable.TestResult.testAll(receiver.ksName, valueSpec, elements); + } + + /** + * Returns the exact ListType from the items if it can be known. + * + * @param items the items mapped to the list elements + * @param mapper the mapper used to retrieve the element types from the items + * @return the exact ListType from the items if it can be known or <code>null</code> + */ + public static <T> VectorType<?> getExactListTypeIfKnown(List<T> items, + java.util.function.Function<T, AbstractType<?>> mapper) + { + // TODO - this doesn't feel right... if you are dealing with a literal then the value is `null`, so we will ignore + // if there are multiple times, we randomly select the first? This logic matches Lists.getExactListTypeIfKnown but feels flawed + Optional<AbstractType<?>> type = items.stream().map(mapper).filter(Objects::nonNull).findFirst(); + return type.isPresent() ? VectorType.getInstance(type.get(), items.size()) : null; + } + + public static <T> VectorType<?> getPreferredCompatibleType(List<T> items, + java.util.function.Function<T, AbstractType<?>> mapper) + { + // TODO - this doesn't feel right... if you are dealing with a literal then the value is `null`, so we will ignore + // if there are multiple times, we randomly select the first? This logic matches Lists.getExactListTypeIfKnown but feels flawed + Set<AbstractType<?>> types = items.stream().map(mapper).filter(Objects::nonNull).collect(Collectors.toSet()); + AbstractType<?> type = AssignmentTestable.getCompatibleTypeIfKnown(types); + return type == null ? null : VectorType.getInstance(type, items.size()); + } + + public static class Literal extends Term.Raw + { + private final List<Term.Raw> elements; + + public Literal(List<Term.Raw> elements) + { + this.elements = elements; + } + + @Override + public TestResult testAssignment(String keyspace, ColumnSpecification receiver) + { + if (!(receiver.type instanceof VectorType)) Review Comment: I think we can use `receiver.type.isVector()` ########## src/java/org/apache/cassandra/cql3/selection/VectorSelector.java: ########## @@ -0,0 +1,178 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.cql3.selection; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +import com.google.common.base.Preconditions; + +import org.apache.cassandra.cql3.Lists; +import org.apache.cassandra.cql3.QueryOptions; +import org.apache.cassandra.db.filter.ColumnFilter; +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.VectorType; +import org.apache.cassandra.exceptions.InvalidRequestException; +import org.apache.cassandra.io.util.DataInputPlus; +import org.apache.cassandra.io.util.DataOutputPlus; +import org.apache.cassandra.schema.TableMetadata; +import org.apache.cassandra.transport.ProtocolVersion; + +public class VectorSelector extends Selector +{ + protected static final SelectorDeserializer deserializer = new SelectorDeserializer() + { + protected Selector deserialize(DataInputPlus in, int version, TableMetadata metadata) throws IOException + { + VectorType<?> type = (VectorType<?>) readType(metadata, in); + List<Selector> elements = new ArrayList<>(type.dimension); + for (int i = 0; i < type.dimension; i++) + elements.add(serializer.deserialize(in, version, metadata)); + + return new VectorSelector(type, elements); + } + }; + + /** + * The vector type. + */ + private final VectorType<?> type; + + /** + * The list elements + */ + private final List<Selector> elements; + + private VectorSelector(VectorType<?> type, List<Selector> elements) + { + super(Kind.VECTOR_SELECTOR); + Preconditions.checkArgument(elements.size() == type.dimension, "Unable to create a vector select of type %s from %s elements", type.asCQL3Type(), elements.size()); Review Comment: Nit: break the long line, for example: ```suggestion Preconditions.checkArgument(elements.size() == type.dimension, "Unable to create a vector select of type %s from %s elements", type.asCQL3Type(), elements.size()); ``` ########## src/java/org/apache/cassandra/cql3/selection/Selectable.java: ########## @@ -721,6 +721,91 @@ public Selectable prepare(TableMetadata cfm) /** * <code>Selectable</code> for literal Lists. */ + public static class WithArrayLiteral implements Selectable + { + /** + * The list elements + */ + private final List<Selectable> selectables; + + public WithArrayLiteral(List<Selectable> selectables) + { + this.selectables = selectables; + } + + private Selectable target(AbstractType<?> target) + { + // when the target isn't known, fallback to list; cases like "SELECT [1, 2]" can't be known, but used to be list type! + // If a vector is actually desired, then can use type cast/hints: "SELECT (vector<int, 2>) [k, v1]" + if (target == null) + return new WithList(selectables); + if (target instanceof ListType) + return new WithList(selectables); + else if (target instanceof VectorType) Review Comment: I think we can use `receiver.type.isVector()` -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
