src/java/org/apache/cassandra/cql3/functions/Functions.java

/*
 * 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.List;

import com.google.common.collect.ArrayListMultimap;

import org.apache.cassandra.cql3.ColumnIdentifier;
import org.apache.cassandra.cql3.ColumnSpecification;
import org.apache.cassandra.cql3.CQL3Type;
import org.apache.cassandra.cql3.AssignementTestable;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.exceptions.InvalidRequestException;

public abstract class Functions
{
    private Functions() {}

    // If we ever allow this to be populated at runtime, this will need to be thread safe.
    private static final ArrayListMultimap<String, Function.Factory> declared = ArrayListMultimap.create();
    static
    {
        // All method sharing the same name must have the same returnType. We could find a way to make that clear.
        declared.put("token", TokenFct.factory);

        declared.put("now", AbstractFunction.factory(TimeuuidFcts.nowFct));
        declared.put("mintimeuuid", AbstractFunction.factory(TimeuuidFcts.minTimeuuidFct));
        declared.put("maxtimeuuid", AbstractFunction.factory(TimeuuidFcts.maxTimeuuidFct));
        declared.put("dateof", AbstractFunction.factory(TimeuuidFcts.dateOfFct));
        declared.put("unixtimestampof", AbstractFunction.factory(TimeuuidFcts.unixTimestampOfFct));
        declared.put("uuid", AbstractFunction.factory(UuidFcts.uuidFct));

        for (CQL3Type type : CQL3Type.Native.values())
        {
            // Note: because text and varchar ends up being synonimous, our automatic makeToBlobFunction doesn't work
            // for varchar, so we special case it below. We also skip blob for obvious reasons.
            if (type == CQL3Type.Native.VARCHAR || type == CQL3Type.Native.BLOB)
                continue;

            Function toBlob = BytesConversionFcts.makeToBlobFunction(type.getType());
            Function fromBlob = BytesConversionFcts.makeFromBlobFunction(type.getType());
            declared.put(toBlob.name(), AbstractFunction.factory(toBlob));
            declared.put(fromBlob.name(), AbstractFunction.factory(fromBlob));
        }
        declared.put("varcharasblob", AbstractFunction.factory(BytesConversionFcts.VarcharAsBlobFct));
        declared.put("blobasvarchar", AbstractFunction.factory(BytesConversionFcts.BlobAsVarcharFact));
    }

    public static AbstractType<?> getReturnType(String functionName, String ksName, String cfName)
    {
        List<Function.Factory> factories = declared.get(functionName.toLowerCase());
        return factories.isEmpty()
             ? null // That's ok, we'll complain later
             : factories.get(0).create(ksName, cfName).returnType();
    }

    public static ColumnSpecification makeArgSpec(ColumnSpecification receiver, Function fun, int i)
    {
        return new ColumnSpecification(receiver.ksName,
                receiver.cfName,
                new ColumnIdentifier("arg" + i +  "(" + fun.name() + ")", true),
                fun.argsType().get(i));
    }

    public static Function get(String keyspace, String name, List<? extends AssignementTestable> providedArgs, ColumnSpecification receiver) throws InvalidRequestException
    {
        List<Function.Factory> factories = declared.get(name.toLowerCase());
        if (factories.isEmpty())
            throw new InvalidRequestException(String.format("Unknown CQL3 function %s called", name));

        // Fast path if there is not choice
        if (factories.size() == 1)
        {
            Function fun = factories.get(0).create(receiver.ksName, receiver.cfName);
            validateTypes(keyspace, fun, providedArgs, receiver);
            return fun;
        }

        Function candidate = null;
        for (Function.Factory factory : factories)
        {
            Function toTest = factory.create(receiver.ksName, receiver.cfName);
            if (!isValidType(keyspace, toTest, providedArgs, receiver))
                continue;

            if (candidate == null)
                candidate = toTest;
            else
                throw new InvalidRequestException(String.format("Ambiguous call to function %s (can match both type signature %s and %s): use type casts to disambiguate", name, signature(candidate), signature(toTest)));
        }
        if (candidate == null)
            throw new InvalidRequestException(String.format("Invalid call to function %s, none of its type signature matches (known type signatures: %s)", name, signatures(factories, receiver)));
        return candidate;
    }

    private static void validateTypes(String keyspace, Function fun, List<? extends AssignementTestable> providedArgs, ColumnSpecification receiver) throws InvalidRequestException
    {
        if (!receiver.type.isValueCompatibleWith(fun.returnType()))
            throw new InvalidRequestException(String.format("Type error: cannot assign result of function %s (type %s) to %s (type %s)", fun.name(), fun.returnType().asCQL3Type(), receiver, receiver.type.asCQL3Type()));

        if (providedArgs.size() != fun.argsType().size())
            throw new InvalidRequestException(String.format("Invalid number of arguments in call to function %s: %d required but %d provided", fun.name(), fun.argsType().size(), providedArgs.size()));

        for (int i = 0; i < providedArgs.size(); i++)
        {
            AssignementTestable 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(receiver, fun, i);
            if (!provided.isAssignableTo(keyspace, expected))
                throw new InvalidRequestException(String.format("Type error: %s cannot be passed as argument %d of function %s of type %s", provided, i, fun.name(), expected.type.asCQL3Type()));
        }
    }

    private static boolean isValidType(String keyspace, Function fun, List<? extends AssignementTestable> providedArgs, ColumnSpecification receiver) throws InvalidRequestException
    {
        if (!receiver.type.isValueCompatibleWith(fun.returnType()))
            return false;

        if (providedArgs.size() != fun.argsType().size())
            return false;

        for (int i = 0; i < providedArgs.size(); i++)
        {
            AssignementTestable 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(receiver, fun, i);
            if (!provided.isAssignableTo(keyspace, expected))
                return false;
        }
        return true;
    }

    private static String signature(Function fun)
    {
        List<AbstractType<?>> args = fun.argsType();
        StringBuilder sb = new StringBuilder();
        sb.append("(");
        for (int i = 0; i < args.size(); i++)
        {
            if (i > 0) sb.append(", ");
            sb.append(args.get(i).asCQL3Type());
        }
        sb.append(") -> ");
        sb.append(fun.returnType().asCQL3Type());
        return sb.toString();
    }

    private static String signatures(List<Function.Factory> factories, ColumnSpecification receiver)
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < factories.size(); i++)
        {
            if (i > 0) sb.append(", ");
            sb.append(signature(factories.get(i).create(receiver.ksName, receiver.cfName)));
        }
        return sb.toString();
    }
}