org.apache.cassandra.cql3.functions.FunctionResolver Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cassandra-all Show documentation
Show all versions of cassandra-all Show documentation
The Apache Cassandra Project develops a highly scalable second-generation distributed database, bringing together Dynamo's fully distributed design and Bigtable's ColumnFamily-based data model.
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.cassandra.cql3.functions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.apache.cassandra.cql3.AbstractMarker;
import org.apache.cassandra.cql3.AssignmentTestable;
import org.apache.cassandra.cql3.ColumnIdentifier;
import org.apache.cassandra.cql3.ColumnSpecification;
import org.apache.cassandra.schema.Schema;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.exceptions.InvalidRequestException;
import org.apache.cassandra.schema.UserFunctions;
import static java.util.stream.Collectors.joining;
import static org.apache.cassandra.cql3.statements.RequestValidations.invalidRequest;
public final class FunctionResolver
{
private FunctionResolver()
{
}
public static ColumnSpecification makeArgSpec(String receiverKeyspace, String receiverTable, Function fun, int i)
{
return new ColumnSpecification(receiverKeyspace,
receiverTable,
new ColumnIdentifier("arg" + i + '(' + fun.name().toString().toLowerCase() + ')', true),
fun.argTypes().get(i));
}
/**
* @param keyspace the current keyspace
* @param name the name of the function
* @param providedArgs the arguments provided for the function call
* @param receiverKeyspace the receiver's keyspace
* @param receiverTable the receiver's table
* @param receiverType if the receiver type is known (during inserts, for example), this should be the type of
* the receiver
*/
@Nullable
public static Function get(String keyspace,
FunctionName name,
List providedArgs,
String receiverKeyspace,
String receiverTable,
AbstractType receiverType)
throws InvalidRequestException
{
return get(keyspace, name, providedArgs, receiverKeyspace, receiverTable, receiverType, UserFunctions.none());
}
/**
* @param keyspace the current keyspace
* @param name the name of the function
* @param providedArgs the arguments provided for the function call
* @param receiverKeyspace the receiver's keyspace
* @param receiverTable the receiver's table
* @param receiverType if the receiver type is known (during inserts, for example), this should be the type of
* the receiver
* @param functions a set of user functions that is not yet available in the schema, used during startup when those
* functions might not be yet available
*/
@Nullable
public static Function get(String keyspace,
FunctionName name,
List providedArgs,
String receiverKeyspace,
String receiverTable,
AbstractType receiverType,
UserFunctions functions)
throws InvalidRequestException
{
Collection candidates = collectCandidates(keyspace, name, receiverKeyspace, receiverTable, providedArgs, receiverType, functions);
if (candidates.isEmpty())
return null;
// Fast path if there is only one choice
if (candidates.size() == 1)
{
Function fun = candidates.iterator().next();
validateTypes(keyspace, fun, providedArgs, receiverKeyspace, receiverTable);
return fun;
}
return pickBestMatch(keyspace, name, providedArgs, receiverKeyspace, receiverTable, receiverType, candidates);
}
private static Collection collectCandidates(String keyspace,
FunctionName name,
String receiverKeyspace,
String receiverTable,
List providedArgs,
AbstractType receiverType,
UserFunctions functions)
{
Collection candidates = new ArrayList<>();
if (name.hasKeyspace())
{
// function name is fully qualified (keyspace + name)
candidates.addAll(functions.get(name));
candidates.addAll(Schema.instance.getUserFunctions(name));
candidates.addAll(NativeFunctions.instance.getFunctions(name));
candidates.addAll(NativeFunctions.instance.getFactories(name).stream()
.map(f -> f.getOrCreateFunction(providedArgs, receiverType, receiverKeyspace, receiverTable))
.filter(Objects::nonNull)
.collect(Collectors.toList()));
}
else
{
// function name is not fully qualified
// add 'current keyspace' candidates
FunctionName userName = new FunctionName(keyspace, name.name);
candidates.addAll(functions.get(userName));
candidates.addAll(Schema.instance.getUserFunctions(userName));
// add 'SYSTEM' (native) candidates
FunctionName nativeName = name.asNativeFunction();
candidates.addAll(NativeFunctions.instance.getFunctions(nativeName));
candidates.addAll(NativeFunctions.instance.getFactories(nativeName).stream()
.map(f -> f.getOrCreateFunction(providedArgs, receiverType, receiverKeyspace, receiverTable))
.filter(Objects::nonNull)
.collect(Collectors.toList()));
}
return candidates;
}
private static Function pickBestMatch(String keyspace,
FunctionName name,
List providedArgs,
String receiverKeyspace,
String receiverTable,
AbstractType receiverType,
Collection candidates)
{
List compatibles = null;
for (Function toTest : candidates)
{
if (matchReturnType(toTest, receiverType))
{
AssignmentTestable.TestResult r = matchAguments(keyspace, toTest, providedArgs, receiverKeyspace, receiverTable);
switch (r)
{
case EXACT_MATCH:
// We always favor exact matches
return toTest;
case WEAKLY_ASSIGNABLE:
if (compatibles == null)
compatibles = new ArrayList<>();
compatibles.add(toTest);
break;
}
}
}
if (compatibles == null)
{
if (OperationFcts.isOperation(name))
throw invalidRequest("the '%s' operation is not supported between %s and %s",
OperationFcts.getOperator(name), providedArgs.get(0), providedArgs.get(1));
throw invalidRequest("Invalid call to function %s, none of its type signatures match (known type signatures: %s)",
name, format(candidates));
}
if (compatibles.size() > 1)
{
if (OperationFcts.isOperation(name))
{
if (receiverType != null && !containsMarkers(providedArgs))
{
for (Function toTest : compatibles)
{
List> argTypes = toTest.argTypes();
if (receiverType.equals(argTypes.get(0)) && receiverType.equals(argTypes.get(1)))
return toTest;
}
}
throw invalidRequest("Ambiguous '%s' operation with args %s and %s: use type hint to disambiguate, example '(int) ?'",
OperationFcts.getOperator(name), providedArgs.get(0), providedArgs.get(1));
}
if (OperationFcts.isNegation(name))
throw invalidRequest("Ambiguous negation: use type casts to disambiguate");
throw invalidRequest("Ambiguous call to function %s (can be matched by following signatures: %s): use type casts to disambiguate",
name, format(compatibles));
}
return compatibles.get(0);
}
/**
* Checks if at least one of the specified arguments is a marker.
*
* @param args the arguments to check
* @return {@code true} if if at least one of the specified arguments is a marker, {@code false} otherwise
*/
private static boolean containsMarkers(List args)
{
return args.stream().anyMatch(AbstractMarker.Raw.class::isInstance);
}
/**
* Checks that the return type of the specified function can be assigned to the specified receiver.
*
* @param fun the function to check
* @param receiverType the receiver type
* @return {@code true} if the return type of the specified function can be assigned to the specified receiver,
* {@code false} otherwise.
*/
private static boolean matchReturnType(Function fun, AbstractType receiverType)
{
return receiverType == null || fun.returnType().testAssignment(receiverType.udfType()).isAssignable();
}
// This method and matchArguments are somewhat duplicate, but this method allows us to provide more precise errors in the common
// case where there is no override for a given function. This is thus probably worth the minor code duplication.
private static void validateTypes(String keyspace,
Function fun,
List providedArgs,
String receiverKeyspace,
String receiverTable)
{
if (providedArgs.size() != fun.argTypes().size())
throw invalidRequest("Invalid number of arguments in call to function %s: %d required but %d provided",
fun.name(), fun.argTypes().size(), providedArgs.size());
for (int i = 0; i < providedArgs.size(); i++)
{
AssignmentTestable provided = providedArgs.get(i);
// If the concrete argument is a bind variables, it can have any type.
// We'll validate the actually provided value at execution time.
if (provided == null)
continue;
ColumnSpecification expected = makeArgSpec(receiverKeyspace, receiverTable, fun, i);
if (!provided.testAssignment(keyspace, expected).isAssignable())
throw invalidRequest("Type error: %s cannot be passed as argument %d of function %s of type %s",
provided, i, fun.name(), expected.type.asCQL3Type());
}
}
private static AssignmentTestable.TestResult matchAguments(String keyspace,
Function fun,
List providedArgs,
String receiverKeyspace,
String receiverTable)
{
if (providedArgs.size() != fun.argTypes().size())
return AssignmentTestable.TestResult.NOT_ASSIGNABLE;
// It's an exact match if all are exact match, but is not assignable as soon as any is not assignable.
AssignmentTestable.TestResult res = AssignmentTestable.TestResult.EXACT_MATCH;
for (int i = 0; i < providedArgs.size(); i++)
{
AssignmentTestable provided = providedArgs.get(i);
if (provided == null)
{
res = AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE;
continue;
}
ColumnSpecification expected = makeArgSpec(receiverKeyspace, receiverTable, fun, i);
AssignmentTestable.TestResult argRes = provided.testAssignment(keyspace, expected);
if (argRes == AssignmentTestable.TestResult.NOT_ASSIGNABLE)
return AssignmentTestable.TestResult.NOT_ASSIGNABLE;
if (argRes == AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE)
res = AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE;
}
return res;
}
private static String format(Collection funs)
{
return funs.stream().map(Function::toString).collect(joining(", "));
}
}