Java FunctionInfo类代码示例

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
private void initProxies(Map<Function, EqProxy> existingProxies) {
    Symbol left = origin.arguments().get(0);
    DataType leftType = origin.info().ident().argumentTypes().get(0);
    DataType rightType = ((CollectionType)origin.info().ident().argumentTypes().get(1)).innerType();
    FunctionInfo eqInfo = new FunctionInfo(
            new FunctionIdent(
                    EqOperator.NAME,
                    ImmutableList.of(leftType, rightType)
            ),
            DataTypes.BOOLEAN
    );
    Literal arrayLiteral = (Literal)origin.arguments().get(1);
    proxies = new HashMap<>();
    for (Literal arrayElem : Literal.explodeCollection(arrayLiteral)) {
        Function f = new Function(eqInfo, Arrays.asList(left, arrayElem));
        EqProxy existingProxy = existingProxies.get(f);
        if (existingProxy == null) {
            existingProxy = new ChildEqProxy(f, this);
        } else if (existingProxy instanceof ChildEqProxy) {
            ((ChildEqProxy) existingProxy).addParent(this);
        }
        proxies.put(f, existingProxy);
    }
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
@Override
public Void visitFunction(Function symbol, SortContext context) {
    if (!context.inFunction  && !DataTypes.PRIMITIVE_TYPES.contains(symbol.valueType())) {
        throw new UnsupportedOperationException(
                String.format(Locale.ENGLISH,
                        "Cannot ORDER BY '%s': invalid return type '%s'.",
                        SymbolPrinter.INSTANCE.printSimple(symbol),
                        symbol.valueType())
        );
    }
    if (symbol.info().type() == FunctionInfo.Type.PREDICATE) {
        throw new UnsupportedOperationException(String.format(Locale.ENGLISH,
                "%s predicate cannot be used in an ORDER BY clause", symbol.info().ident().name()));
    }
    try {
        context.inFunction = true;
        for (Symbol arg : symbol.arguments()) {
            process(arg, context);
        }
    } finally {
        context.inFunction = false;
    }
    return null;
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
public static void register(ScalarFunctionModule module) {
    List<DataType> supportedTimestampTypes = ImmutableList.<DataType>of(
            DataTypes.TIMESTAMP, DataTypes.LONG, DataTypes.STRING);
    for (DataType dataType : supportedTimestampTypes) {
        // without format
        module.register(new DateFormatFunction(new FunctionInfo(
                new FunctionIdent(NAME, ImmutableList.of(dataType)),
                DataTypes.STRING)
        ));
        // with format
        module.register(new DateFormatFunction(new FunctionInfo(
                new FunctionIdent(NAME, ImmutableList.of(DataTypes.STRING, dataType)),
                DataTypes.STRING)
        ));
        // time zone aware variant
        module.register(new DateFormatFunction(new FunctionInfo(
                new FunctionIdent(NAME, ImmutableList.of(DataTypes.STRING, DataTypes.STRING, dataType)),
                DataTypes.STRING)
        ));
    }
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
public static void register(AggregationImplModule mod) {
    for (final DataType dataType : DataTypes.PRIMITIVE_TYPES) {
        mod.register(new CollectSetAggregation(new FunctionInfo(new FunctionIdent(NAME,
                ImmutableList.of(dataType)),
                new SetType(dataType), FunctionInfo.Type.AGGREGATE)));
    }
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
public static void register(AggregationImplModule mod) {
    for (final DataType t : DataTypes.PRIMITIVE_TYPES) {
        mod.register(new ArbitraryAggregation(
                new FunctionInfo(new FunctionIdent(NAME, ImmutableList.of(t)), t,
                                FunctionInfo.Type.AGGREGATE)));
    }
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
public static void register(AggregationImplModule mod) {
    for (DataType t : DataTypes.NUMERIC_PRIMITIVE_TYPES) {
        mod.register(new SumAggregation(new FunctionInfo(new FunctionIdent(NAME, ImmutableList.of(t)),
                        DataTypes.DOUBLE, FunctionInfo.Type.AGGREGATE)));
    }

}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
@Override
public Void visitFunction(Function symbol, OutputValidatorContext context) {
    context.insideAggregation = context.insideAggregation || symbol.info().type().equals(FunctionInfo.Type.AGGREGATE);
    for (Symbol argument : symbol.arguments()) {
        process(argument, context);
    }
    context.insideAggregation = false;
    return null;
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
@Override
protected Symbol visitComparisonExpression(ComparisonExpression node, ExpressionAnalysisContext context) {
    Symbol left = process(node.getLeft(), context);
    Symbol right = process(node.getRight(), context);

    if (left.valueType().equals(DataTypes.UNDEFINED) || right.valueType().equals(DataTypes.UNDEFINED)) {
        return Literal.NULL;
    }
    Comparison comparison = new Comparison(node.getType(), left, right);
    comparison.normalize(context);
    FunctionInfo info = getFunctionInfo(comparison.toFunctionIdent());
    return context.allocateFunction(info, comparison.arguments());
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
public static void register(AggregationImplModule mod) {
    for (DataType<?> t : DataTypes.NUMERIC_PRIMITIVE_TYPES) {
        mod.register(new StandardDeviationAggregation(new FunctionInfo(
                new FunctionIdent(NAME, ImmutableList.<DataType>of(t)), DataTypes.DOUBLE,
                FunctionInfo.Type.AGGREGATE)));
    }
    mod.register(new StandardDeviationAggregation(new FunctionInfo(
            new FunctionIdent(NAME, ImmutableList.<DataType>of(DataTypes.TIMESTAMP)), DataTypes.DOUBLE,
            FunctionInfo.Type.AGGREGATE)));
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
public static FunctionInfo functionInfo(Extract.Field field) {
    switch (field) {
        case CENTURY:
            return ExtractCentury.INFO;
        case YEAR:
            return ExtractYear.INFO;
        case QUARTER:
            return ExtractQuarter.INFO;
        case MONTH:
            return ExtractMonth.INFO;
        case WEEK:
            return ExtractWeek.INFO;
        case DAY:
        case DAY_OF_MONTH:
            return ExtractDayOfMonth.INFO;
        case DAY_OF_WEEK:
        case DOW:
            return ExtractDayOfWeek.INFO;
        case DAY_OF_YEAR:
        case DOY:
            return ExtractDayOfYear.INFO;
        case HOUR:
            return ExtractHour.INFO;
        case MINUTE:
            return ExtractMinute.INFO;
        case SECOND:
            return ExtractSecond.INFO;
        case TIMEZONE_HOUR:
            break;
        case TIMEZONE_MINUTE:
            break;
    }
    throw new UnsupportedOperationException(String.format(Locale.ENGLISH, "Extract( %s from <expression>) is not supported", field));
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
@Override
public Symbol visitArrayComparisonExpression(ArrayComparisonExpression node, ExpressionAnalysisContext context) {
    if (node.quantifier().equals(ArrayComparisonExpression.Quantifier.ALL)) {
        throw new UnsupportedFeatureException("ALL is not supported");
    }

    Symbol arraySymbol = normalize(process(node.getRight(), context));
    Symbol leftSymbol = normalize(process(node.getLeft(), context));
    DataType rightType = arraySymbol.valueType();

    if (!DataTypes.isCollectionType(rightType)) {
        throw new IllegalArgumentException(
                SymbolFormatter.format("invalid array expression: '%s'", arraySymbol));
    }
    DataType rightInnerType = ((CollectionType) rightType).innerType();
    if (rightInnerType.equals(DataTypes.OBJECT)) {
        throw new IllegalArgumentException("ANY on object arrays is not supported");
    }

    if (arraySymbol.symbolType().isValueSymbol()) {
        arraySymbol = castIfNeededOrFail(arraySymbol, new ArrayType(leftSymbol.valueType()));
    } else {
        leftSymbol = castIfNeededOrFail(leftSymbol, rightInnerType);
    }

    ComparisonExpression.Type operationType = node.getType();
    String operatorName;
    operatorName = AnyOperator.OPERATOR_PREFIX + operationType.getValue();
    FunctionIdent functionIdent = new FunctionIdent(operatorName, Arrays.asList(leftSymbol.valueType(), arraySymbol.valueType()));
    FunctionInfo functionInfo = getFunctionInfo(functionIdent);
    return context.allocateFunction(functionInfo, Arrays.asList(leftSymbol, arraySymbol));
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
/**
 * resolve the needed conversion function info based on the wanted return data type
 */
public static FunctionInfo functionInfo(DataType dataType, DataType returnType, boolean tryCast) {
    String functionName = FUNCTION_MAP.get(returnType);
    if (functionName == null) {
        throw new IllegalArgumentException(
                String.format(Locale.ENGLISH, "No cast function found for return type %s",
                        returnType.getName()));
    }
    functionName = tryCast ? TRY_CAST_PREFIX + functionName : functionName;
    return new FunctionInfo(new FunctionIdent(functionName, ImmutableList.of(dataType)), returnType);
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
public static void register(OperatorModule module) {
    for (DataType type : DataTypes.PRIMITIVE_TYPES) {
        FunctionInfo functionInfo = new FunctionInfo(
                new FunctionIdent(NAME, ImmutableList.<DataType>of(type, new SetType(type))), DataTypes.BOOLEAN);
        module.registerOperatorFunction(new InOperator(functionInfo));
    }
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
@Override
public FunctionImplementation<Function> getForTypes(List<DataType> dataTypes) throws IllegalArgumentException {
    checkArgument(dataTypes.size() == 2, "ANY operator requires exactly 2 arguments");
    checkArgument(DataTypes.isCollectionType(dataTypes.get(1)), "The second argument to ANY must be an array or set");
    checkArgument(((CollectionType) dataTypes.get(1)).innerType().equals(dataTypes.get(0)),
            "The inner type of the array/set passed to ANY must match its left expression");
    return newInstance(new FunctionInfo(new FunctionIdent(name(), dataTypes), BooleanType.INSTANCE));
}
 

import io.crate.metadata.FunctionInfo; //导入依赖的package包/类
@Override
protected Symbol visitIsNotNullPredicate(IsNotNullPredicate node, ExpressionAnalysisContext context) {
    Symbol argument = process(node.getValue(), context);

    FunctionIdent isNullIdent =
            new FunctionIdent(io.crate.operation.predicate.IsNullPredicate.NAME, ImmutableList.of(argument.valueType()));
    FunctionInfo isNullInfo = getFunctionInfo(isNullIdent);

    return context.allocateFunction(
            NotPredicate.INFO,
            Arrays.<Symbol>asList(context.allocateFunction(isNullInfo, Arrays.asList(argument))));
}