package jnpf.elnFormula;
|
|
import java.util.List;
|
import java.util.Map;
|
|
public final class FormulaTypeChecker {
|
|
private final FormulaFunctionRegistry functions;
|
|
public FormulaTypeChecker(FormulaFunctionRegistry functions) {
|
if (functions == null) {
|
throw new IllegalArgumentException("functions must not be null");
|
}
|
this.functions = functions;
|
}
|
|
public FormulaType check(FormulaAst.Node node, Map<String, FormulaType> parameters) {
|
if (node == null || parameters == null) {
|
throw new IllegalArgumentException("node and parameters must not be null");
|
}
|
return typeOf(node, parameters);
|
}
|
|
private FormulaType typeOf(FormulaAst.Node node, Map<String, FormulaType> parameters) {
|
if (node instanceof FormulaAst.Literal) {
|
return literalType((FormulaAst.Literal) node);
|
}
|
if (node instanceof FormulaAst.Parameter) {
|
FormulaAst.Parameter parameter = (FormulaAst.Parameter) node;
|
FormulaType type = parameters.get(parameter.getCode());
|
if (type == null) {
|
throw error("UNKNOWN_PARAMETER", "未知参数: " + parameter.getCode(), node);
|
}
|
return type;
|
}
|
if (node instanceof FormulaAst.Unary) {
|
FormulaAst.Unary unary = (FormulaAst.Unary) node;
|
FormulaType operand = typeOf(unary.getOperand(), parameters);
|
if ("!".equals(unary.getOperator())) {
|
require(operand, FormulaType.BOOLEAN, node);
|
return FormulaType.BOOLEAN;
|
}
|
require(operand, FormulaType.DECIMAL, node);
|
return FormulaType.DECIMAL;
|
}
|
if (node instanceof FormulaAst.Binary) {
|
return binaryType((FormulaAst.Binary) node, parameters);
|
}
|
if (node instanceof FormulaAst.FunctionCall) {
|
return functionType((FormulaAst.FunctionCall) node, parameters);
|
}
|
throw error("TYPE_MISMATCH", "不支持的公式节点", node);
|
}
|
|
private FormulaType binaryType(FormulaAst.Binary binary,
|
Map<String, FormulaType> parameters) {
|
FormulaType left = typeOf(binary.getLeft(), parameters);
|
FormulaType right = typeOf(binary.getRight(), parameters);
|
String operator = binary.getOperator();
|
if ("+".equals(operator) || "-".equals(operator) || "*".equals(operator)
|
|| "/".equals(operator) || "%".equals(operator) || "^".equals(operator)) {
|
require(left, FormulaType.DECIMAL, binary);
|
require(right, FormulaType.DECIMAL, binary);
|
return FormulaType.DECIMAL;
|
}
|
if (">".equals(operator) || ">=".equals(operator)
|
|| "<".equals(operator) || "<=".equals(operator)) {
|
require(left, FormulaType.DECIMAL, binary);
|
require(right, FormulaType.DECIMAL, binary);
|
return FormulaType.BOOLEAN;
|
}
|
if ("&&".equals(operator) || "||".equals(operator)) {
|
require(left, FormulaType.BOOLEAN, binary);
|
require(right, FormulaType.BOOLEAN, binary);
|
return FormulaType.BOOLEAN;
|
}
|
if ("==".equals(operator) || "!=".equals(operator)) {
|
if (left != right || (left != FormulaType.DECIMAL && left != FormulaType.TEXT
|
&& left != FormulaType.BOOLEAN)) {
|
throw error("TYPE_MISMATCH", "相等比较仅支持相同的标量类型", binary);
|
}
|
return FormulaType.BOOLEAN;
|
}
|
throw error("TYPE_MISMATCH", "不支持的运算符: " + operator, binary);
|
}
|
|
private FormulaType functionType(FormulaAst.FunctionCall call,
|
Map<String, FormulaType> parameters) {
|
String name = call.getName();
|
if (!functions.contains(name)) {
|
throw error("UNKNOWN_FUNCTION", "未知函数: " + name, call);
|
}
|
List<FormulaAst.Node> arguments = call.getArguments();
|
if ("ABS".equals(name) || "SQRT".equals(name)
|
|| "LN".equals(name) || "LOG10".equals(name) || "EXP".equals(name)) {
|
count(arguments, 1, 1, call);
|
require(typeOf(arguments.get(0), parameters), FormulaType.DECIMAL, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("POW".equals(name) || "LOG".equals(name) || "NTH_ROOT".equals(name)) {
|
count(arguments, 2, 2, call);
|
requireAll(arguments, parameters, FormulaType.DECIMAL, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("MIN".equals(name) || "MAX".equals(name)) {
|
count(arguments, 1, FormulaLimits.DEFAULTS.getMaxFunctionArguments(), call);
|
requireAll(arguments, parameters, FormulaType.DECIMAL, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("IF".equals(name)) {
|
count(arguments, 3, 3, call);
|
require(typeOf(arguments.get(0), parameters), FormulaType.BOOLEAN, call);
|
return merge(typeOf(arguments.get(1), parameters),
|
typeOf(arguments.get(2), parameters), call);
|
}
|
if ("COALESCE".equals(name)) {
|
count(arguments, 1, FormulaLimits.DEFAULTS.getMaxFunctionArguments(), call);
|
FormulaType result = FormulaType.NULL;
|
for (FormulaAst.Node argument : arguments) {
|
result = merge(result, typeOf(argument, parameters), call);
|
}
|
return result;
|
}
|
if ("IS_BLANK".equals(name)) {
|
count(arguments, 1, 1, call);
|
typeOf(arguments.get(0), parameters);
|
return FormulaType.BOOLEAN;
|
}
|
if ("SUM".equals(name) || "MEAN".equals(name) || "STDDEV_S".equals(name)
|
|| "STDDEV_P".equals(name) || "VAR_S".equals(name)
|
|| "VAR_P".equals(name) || "RSD".equals(name)
|
|| "COUNT".equals(name) || "MEDIAN".equals(name)
|
|| "GEOMEAN".equals(name)) {
|
count(arguments, 1, 1, call);
|
require(typeOf(arguments.get(0), parameters), FormulaType.DECIMAL_LIST, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("WEIGHTED_MEAN".equals(name) || "SLOPE".equals(name)
|
|| "INTERCEPT".equals(name) || "CORREL".equals(name)) {
|
count(arguments, 2, 2, call);
|
requireAll(arguments, parameters, FormulaType.DECIMAL_LIST, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("LINEAR_PREDICT".equals(name)) {
|
count(arguments, 3, 3, call);
|
require(typeOf(arguments.get(0), parameters), FormulaType.DECIMAL, call);
|
require(typeOf(arguments.get(1), parameters), FormulaType.DECIMAL_LIST, call);
|
require(typeOf(arguments.get(2), parameters), FormulaType.DECIMAL_LIST, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("ROUND".equals(name) || "ROUND_UP".equals(name)
|
|| "ROUND_DOWN".equals(name) || "ROUND_HALF_EVEN".equals(name)
|
|| "ROUND_SIG".equals(name) || "ROUND_SIG_HALF_EVEN".equals(name)) {
|
count(arguments, 2, 2, call);
|
requireAll(arguments, parameters, FormulaType.DECIMAL, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("CONVERT".equals(name)) {
|
count(arguments, 3, 3, call);
|
require(typeOf(arguments.get(0), parameters), FormulaType.DECIMAL, call);
|
require(typeOf(arguments.get(1), parameters), FormulaType.TEXT, call);
|
require(typeOf(arguments.get(2), parameters), FormulaType.TEXT, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("LOOKUP_EXACT".equals(name)) {
|
lookupShape(arguments, 3, call);
|
requireAll(arguments, parameters, FormulaType.DECIMAL, call);
|
return FormulaType.DECIMAL;
|
}
|
if ("LOOKUP_LINEAR".equals(name)) {
|
lookupShape(arguments, 5, call);
|
requireAll(arguments, parameters, FormulaType.DECIMAL, call);
|
return FormulaType.DECIMAL;
|
}
|
throw error("UNKNOWN_FUNCTION", "未知函数: " + name, call);
|
}
|
|
private static FormulaType literalType(FormulaAst.Literal literal) {
|
switch (literal.getKind()) {
|
case DECIMAL:
|
return FormulaType.DECIMAL;
|
case TEXT:
|
return FormulaType.TEXT;
|
case BOOLEAN:
|
return FormulaType.BOOLEAN;
|
case NULL:
|
return FormulaType.NULL;
|
default:
|
throw new IllegalStateException("unknown literal kind");
|
}
|
}
|
|
private static void lookupShape(List<FormulaAst.Node> arguments, int minimum,
|
FormulaAst.Node node) {
|
if (arguments.size() < minimum || arguments.size() % 2 == 0) {
|
throw error("FUNCTION_ARGUMENT_COUNT_MISMATCH", "查值函数参数必须为 key 和数值点对", node);
|
}
|
}
|
|
private void requireAll(List<FormulaAst.Node> arguments,
|
Map<String, FormulaType> parameters,
|
FormulaType expected, FormulaAst.Node node) {
|
for (FormulaAst.Node argument : arguments) {
|
require(typeOf(argument, parameters), expected, node);
|
}
|
}
|
|
private static FormulaType merge(FormulaType left, FormulaType right, FormulaAst.Node node) {
|
if (left == FormulaType.NULL) {
|
return right;
|
}
|
if (right == FormulaType.NULL) {
|
return left;
|
}
|
if (left != right) {
|
throw error("TYPE_MISMATCH", "分支或参数类型不一致", node);
|
}
|
return left;
|
}
|
|
private static void count(List<FormulaAst.Node> arguments, int minimum, int maximum,
|
FormulaAst.Node node) {
|
if (arguments.size() < minimum || arguments.size() > maximum) {
|
throw error("FUNCTION_ARGUMENT_COUNT_MISMATCH", "函数参数数量不正确", node);
|
}
|
}
|
|
private static void require(FormulaType actual, FormulaType expected, FormulaAst.Node node) {
|
requireStatic(actual, expected, node);
|
}
|
|
private static void requireStatic(FormulaType actual, FormulaType expected,
|
FormulaAst.Node node) {
|
if (actual != expected) {
|
throw error("TYPE_MISMATCH", "需要 " + expected + "，实际为 " + actual, node);
|
}
|
}
|
|
private static FormulaException error(String code, String message, FormulaAst.Node node) {
|
return new FormulaException(code, message, node.getStartOffset(), node.getEndOffset());
|
}
|
}
|
