Java CommonExpression類代碼示例

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * elasticsearchの検索文字列を返卻する.
 * @param expr CommonExpression
 * @return elasticsearchの検索文字列
 */
private Object getSearchValue(CommonExpression expr) {
    if (expr instanceof IntegralLiteral) {
        return ((IntegralLiteral) expr).getValue();
    } else if (expr instanceof Int64Literal) {
        return ((Int64Literal) expr).getValue();
    } else if (expr instanceof DoubleLiteral) {
        return ((DoubleLiteral) expr).getValue();
    } else if (expr instanceof BooleanLiteral) {
        return ((BooleanLiteral) expr).getValue();
    } else if (expr instanceof DateTimeLiteral) {
        return ((DateTimeLiteral) expr).getValue().toDateTime(DateTimeZone.UTC).getMillis();
    } else if (expr instanceof DateTimeOffsetLiteral) {
        return ((DateTimeOffsetLiteral) expr).getValue().getMillis();
    } else {
        String value;
        try {
            value = StringEscapeUtils.unescapeJavaScript(((StringLiteral) expr).getValue());
        } catch (Exception e) {
            log.info("Failed to unescape searchValue.", e);
            throw PersoniumCoreException.OData.OPERATOR_AND_OPERAND_UNABLE_TO_UNESCAPE.params(((StringLiteral) expr)
                    .getValue());
        }
        return value;
    }
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * elasticsearchの検索キーを返卻する.
 * @param expr CommonExpression
 * @param isUntouched isUntouched
 * @return elasticsearchの検索キー
 */
protected String getSearchKey(CommonExpression expr, Boolean isUntouched) {
    // 検索キーとして設定を行う
    String keyName = ((EntitySimpleProperty) expr).getPropertyName();

    // published, updated
    if (Common.P_PUBLISHED.getName().equals(keyName)) {
        return OEntityDocHandler.KEY_PUBLISHED;
    } else if (Common.P_UPDATED.getName().equals(keyName)) {
        return OEntityDocHandler.KEY_UPDATED;
    }

    // スキーマ定義項目であればs.フィールド、定義外項目であればd.フィールドを検索する
    String fieldPrefix = OEntityDocHandler.KEY_STATIC_FIELDS + ".";

    // untouchedフィールドの指定であれば、untouchedを返卻する
    if (isUntouched) {
        return fieldPrefix + keyName + ".untouched";
    } else {
        return fieldPrefix + keyName;
    }
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
@Override
public void visit(GeExpression expr) {
    log.debug("visit(GeExpression expr)");

    // $filterに指定された検索條件のプロパティが単純型ではない場合は、パースエラーとする。
    if (!(expr.getLHS() instanceof EntitySimpleProperty)) {
        throw PersoniumCoreException.OData.FILTER_PARSE_ERROR;
    }
    EdmProperty edmProperty = getEdmProprety((EntitySimpleProperty) expr.getLHS());

    // $filterに指定されたプロパティの型と検索條件の値として指定されたデータ型の検証
    CommonExpression searchValue = expr.getRHS();
    FilterConditionValidator.validateFilterOpCondition(edmProperty, searchValue);

    // ESの Range filterを設定する
    Map<String, Object> ge = new HashMap<String, Object>();
    Map<String, Object> property = new HashMap<String, Object>();
    ge.put("gte", getSearchValue(expr.getRHS()));
    property.put(getSearchKey(expr.getLHS(), true), ge);
    this.current.put("range", property);
    this.current = stack.pop();
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * $filterクエリの検索條件に指定するプロパティのデータ型と検索條件の値として指定されたデータ型の整合性を検証する.
 * <ul>
 * <li>StringLiteral</li>
 * <li>IntegralLiteral、Int64Literal</li>
 * <li>DoubleLiteral</li>
 * </ul>
 * なお、"1.0f" や "1.0m" などの表記（それぞれSingleLiteral、DecimalLiteral）はパースエラーとする。
 * @param edmProperty $filterの検索條件に指定されたプロパティ
 * @param searchValue $filterの検索條件の値
 */
static void validateFilterOpCondition(EdmProperty edmProperty, CommonExpression searchValue) {
    // 比較演算子（lt/le/ge/gt）共通で許容するデータ： 文字列／整數値／実數値
    // 真偽値やNULLは大小比較ができないため、許容しない。
    if (searchValue instanceof BooleanLiteral
            || searchValue instanceof NullLiteral) {
        throw PersoniumCoreException.OData.FILTER_PARSE_ERROR;
    }

    // スキーマ定義されているプロパティのデータ型として検索條件の値が評価できることを検証する。
    // ただし、スキーマ定義されていない場合は、検証できないので除外する。
    if (edmProperty != null) {
        AbstractValidator validator = validatorMap.get(edmProperty.getType());
        if (null == validator) {
            throw PersoniumCoreException.OData.FILTER_PARSE_ERROR;
        }
        validator.validate(searchValue, edmProperty.getName());
    }
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
@Override
public void validate(CommonExpression searchValue, String propertyName) {
    long value = 0L; // odata4jのInt64Literal#gerValueがlong型の値を返すためvalueはlong型とした。
    if (searchValue instanceof IntegralLiteral) {
        value = ((IntegralLiteral) searchValue).getValue();
    } else if (searchValue instanceof Int64Literal) {
        value = ((Int64Literal) searchValue).getValue();
    } else if (searchValue instanceof NullLiteral) {
        value = 0;
    } else {
        throw PersoniumCoreException.OData.OPERATOR_AND_OPERAND_TYPE_MISMATCHED.params(propertyName);
    }

    // 値の範囲チェック
    if (value > Integer.MAX_VALUE || value < Integer.MIN_VALUE) {
        throw PersoniumCoreException.OData.UNSUPPORTED_OPERAND_FORMAT.params(propertyName);
    }
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * orderbyのパース.
 * @param value orderbyの値
 * @return パース結果
 */
public static List<OrderByExpression> parseOrderBy(String value) {
    List<Token> tokens = tokenize(value);
    // dump(value,tokens,null);

    List<CommonExpression> expressions = readExpressions(tokens);
    if (ExpressionParser.DUMP_EXPRESSION_INFO) {
        dump(value, tokens, Enumerable.create(expressions).toArray(CommonExpression.class));
    }

    return Enumerable.create(expressions).select(new Func1<CommonExpression, OrderByExpression>() {
        public OrderByExpression apply(CommonExpression input) {
            if (input instanceof OrderByExpression) {
                return (OrderByExpression) input;
            }
            return Expression.orderBy(input, Direction.ASCENDING); // default to asc
        }
    }).toList();
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * selectのパース.
 * @param value selectの値
 * @return パース結果
 */
public static List<EntitySimpleProperty> parseExpand(String value) {
    List<Token> tokens = tokenize(value);
    // dump(value,tokens,null);

    List<CommonExpression> expressions = readExpressions(tokens);

    // since we support currently simple properties only we have to
    // confine ourselves to EntitySimpleProperties.
    return Enumerable.create(expressions).select(new Func1<CommonExpression, EntitySimpleProperty>() {
        public EntitySimpleProperty apply(CommonExpression input) {
            if (input instanceof EntitySimpleProperty) {
                return (EntitySimpleProperty) input;
            }
            return null;
        }
    }).toList();
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * expandのパース.
 * @param value expandの値
 * @return パース結果
 */
public static List<EntitySimpleProperty> parseExpandQuery(String value) {
    List<Token> tokens = tokenize(value);
    for (Token token : tokens) {
        if (!token.value.equals(",") && !token.value.startsWith("_")) {
            throw new RuntimeException("Invalid navigationProperty name.(" + token.toString() + ")");
        }
    }

    List<CommonExpression> expressions = readExpressions(tokens);

    // since we support currently simple properties only we have to
    // confine ourselves to EntitySimpleProperties.
    return Enumerable.create(expressions).select(new Func1<CommonExpression, EntitySimpleProperty>() {
        public EntitySimpleProperty apply(CommonExpression input) {
            if (input instanceof EntitySimpleProperty) {
                return (EntitySimpleProperty) input;
            }
            return null;
        }
    }).toList();
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
private static CommonExpression processBinaryExpression(List<Token> tokens,
        String op,
        Func2<CommonExpression, CommonExpression, CommonExpression> fn) {

    int ts = tokens.size();
    for (int i = 0; i < ts; i++) {
        Token t = tokens.get(i);
        if (i < ts - 2
                && t.type == TokenType.WHITESPACE && tokens.get(i + 2).type == TokenType.WHITESPACE
                && tokens.get(i + 1).type == TokenType.WORD && tokens.get(i + 1).value.equals(op)) {
            CommonExpression lhs = readExpression(tokens.subList(0, i));
            CommonExpression rhs = readExpression(tokens.subList(i + BINARY_EXPRESSION_CONSTANT, ts));
            return fn.apply(lhs, rhs);
        }
    }
    return null;
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
private static CommonExpression processUnaryExpression(List<Token> tokens,
        String op,
        boolean whitespaceRequired,
        Func1<CommonExpression, CommonExpression> fn) {

    int ts = tokens.size();
    for (int i = 0; i < ts; i++) {
        Token t = tokens.get(i);
        if (i < ts - 1
                && (t.type == TokenType.WORD || t.type == TokenType.SYMBOL)
                && (!whitespaceRequired || tokens.get(i + 1).type == TokenType.WHITESPACE)
                && t.value.equals(op)) {
            int idx = 0;
            if (whitespaceRequired) {
                idx = 2;
            } else {
                idx = 1;
            }
            CommonExpression expression = readExpression(tokens.subList(i + idx, ts));
            return fn.apply(expression);
        }
    }
    return null;
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
private static List<CommonExpression> readExpressions(List<Token> tokens) {
    List<CommonExpression> rt = new ArrayList<CommonExpression>();

    int stack = 0;
    int start = 0;
    for (int i = 0; i < tokens.size(); i++) {
        Token token = tokens.get(i);
        if (token.type == TokenType.OPENPAREN) {
            stack++;
        } else if (token.type == TokenType.CLOSEPAREN) {
            stack--;
        } else if (stack == 0 && token.type == TokenType.SYMBOL && token.value.equals(",")) {
            List<Token> tokensInsideComma = tokens.subList(start, i);
            CommonExpression expressionInsideComma = readExpression(tokensInsideComma);
            rt.add(expressionInsideComma);
            start = i + 1;
        } else if (i == tokens.size() - 1) {
            List<Token> tokensInside = tokens.subList(start, i + 1);
            CommonExpression expressionInside = readExpression(tokensInside);
            rt.add(expressionInside);
        }

    }
    return rt;
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * filterクエリに未知の関數を指定した場合にvisitメソッドの呼び出しでエラーが発生すること.
 */
@Test
public void filterクエリに未知の関數を指定した場合にvisitメソッドの呼び出しでエラーが発生すること() {
    Map<String, CommonExpression> operatorMap = new HashMap<String, CommonExpression>();
    operatorMap.put("endswith", ExpressionParser.parse("endswith(itemKey, 'searchValue')"));

    // ESQueryHandlerでVisitする
    EsQueryHandler esQueryHandler = new EsQueryHandler();
    for (Entry<String, CommonExpression> entry : operatorMap.entrySet()) {
        String function = entry.getKey();
        CommonExpression filterExp = entry.getValue();
        try {
            filterExp.visit(esQueryHandler);
            fail("Not Throw Exception, function = " + function);
        } catch (Exception e) {
            String code = PersoniumCoreException.OData.UNSUPPORTED_QUERY_FUNCTION.getCode();
            String message = PersoniumCoreException.OData.UNSUPPORTED_QUERY_FUNCTION.getMessage();
            assertEquals(code, ((PersoniumCoreException) e).getCode());
            assertEquals(message, ((PersoniumCoreException) e).getMessage());
        }
    }
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * $filterクエリの関數に指定するプロパティのデータ型と値として指定されたデータ型の整合性を検証する.
 * <ul>
 * <li>StringLiteral</li>
 * </ul>
 * @param edmProperty $filterの関數に指定されたプロパティ
 * @param searchValue $filterの関數に指定された値
 */
static void validateFilterFuncCondition(EdmProperty edmProperty, CommonExpression searchValue) {
    // 関數（substringof/startswith）共通で許容するデータ： 文字列
    if (!(searchValue instanceof StringLiteral)) {
        throw PersoniumCoreException.OData.OPERATOR_AND_OPERAND_TYPE_MISMATCHED.params(edmProperty.getName());
    }

    // スキーマ定義されているプロパティのデータ型として検索條件の値が評価できることを検証する。
    // ただし、スキーマ定義されていない場合は、検証できないので除外する。
    if (edmProperty != null
            && !EdmSimpleType.STRING.getFullyQualifiedTypeName().equals(
                    edmProperty.getType().getFullyQualifiedTypeName())) {
            throw PersoniumCoreException.OData.OPERATOR_AND_OPERAND_TYPE_MISMATCHED.params(edmProperty.getName());
    }
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
@Override
protected String getSearchKey(CommonExpression expr, Boolean isUntouched) {
    // 検索キーとして設定を行う
    String name = ((EntitySimpleProperty) expr).getPropertyName();
    EdmProperty edmProperty = this.entityType.findProperty(name);

    // published, updated
    if (Common.P_PUBLISHED.getName().equals(name)) {
        return OEntityDocHandler.KEY_PUBLISHED;
    } else if (Common.P_UPDATED.getName().equals(name)) {
        return OEntityDocHandler.KEY_UPDATED;
    }

    // s.フィールドフィールドを検索する
    String fieldPrefix = OEntityDocHandler.KEY_STATIC_FIELDS;

    // キー名をAliasに変換する
    String key = "Name='" + name + "',_EntityType.Name='" + this.entityType.getName() + "'";
    String keyName = getAlias(key, this.entityType.getName());
    if (keyName == null) {
        keyName = name;
    }

    // 型によってサフィックス（検索対象フィールド）変更する
    String suffix = getSuffix(edmProperty);

    if (isUntouched) {
        return fieldPrefix + "." + keyName + "." + suffix;
    } else {
        return fieldPrefix + "." + keyName;
    }
}
 

import org.odata4j.expression.CommonExpression; //導入依賴的package包/類
/**
 * filterのパース.
 * @param value filterの値
 * @return パース結果
 */
public static CommonExpression parse(String value) {
    List<Token> tokens = tokenize(value);
    // dump(value,tokens,null);

    CommonExpression rt = readExpression(tokens);
    if (ExpressionParser.DUMP_EXPRESSION_INFO) {
        dump(value, tokens, rt);
    }

    return rt;
}