Java NaryFieldRelationalExpression类代码示例

import com.redhat.lightblue.query.NaryFieldRelationalExpression; //导入依赖的package包/类
@Override
public QueryExpression rewrite(QueryExpression q) {
    UnaryLogicalExpression le = dyncast(UnaryLogicalExpression.class, q);
    if (le != null && le.getOp() == UnaryLogicalOperator._not) {
        ValueComparisonExpression vce = dyncast(ValueComparisonExpression.class, le.getQuery());
        if (vce != null) {
            return new ValueComparisonExpression(vce.getField(), vce.getOp().negate(), vce.getRvalue());
        } else {
            FieldComparisonExpression fce = dyncast(FieldComparisonExpression.class, le.getQuery());
            if (fce != null) {
                return new FieldComparisonExpression(fce.getField(), fce.getOp().negate(), fce.getRfield());
            } else {
                NaryValueRelationalExpression nre = dyncast(NaryValueRelationalExpression.class, le.getQuery());
                if (nre != null) {
                    return new NaryValueRelationalExpression(nre.getField(), nre.getOp().negate(), nre.getValues());
                } else {
                    NaryFieldRelationalExpression nfe = dyncast(NaryFieldRelationalExpression.class, le.getQuery());
                    if (nfe != null) {
                        return new NaryFieldRelationalExpression(nfe.getField(), nfe.getOp().negate(), nfe.getRfield());
                    }
                }
            }
        }
    }
    return q;
}
 

import com.redhat.lightblue.query.NaryFieldRelationalExpression; //导入依赖的package包/类
public NaryFieldRelationalExpressionEvaluator(NaryFieldRelationalExpression expr, FieldTreeNode context) {
    field = expr.getField();
    fieldMd = context.resolve(field);
    if (fieldMd == null) {
        throw new EvaluationError(expr, CrudConstants.ERR_FIELD_NOT_THERE + field);
    }
    rfield = expr.getRfield();
    FieldTreeNode rf = context.resolve(rfield);
    if (rf == null) {
        throw new EvaluationError(expr, CrudConstants.ERR_FIELD_NOT_THERE + field);
    }
    if (rf instanceof ArrayField) {
        rfieldMd = (ArrayField) rf;
    } else {
        throw new EvaluationError(expr, CrudConstants.ERR_REQUIRED_ARRAY + rfield);
    }
    operator = expr.getOp();
    LOGGER.debug("ctor {} {} {}", field, operator, rfield);
}
 

import com.redhat.lightblue.query.NaryFieldRelationalExpression; //导入依赖的package包/类
public static QueryEvaluator getInstance(QueryExpression expr,
                                         FieldTreeNode context) {
    QueryEvaluator ret = null;
    if (expr instanceof ValueComparisonExpression) {
        return new ValueComparisonEvaluator((ValueComparisonExpression) expr, context);
    } else if (expr instanceof FieldComparisonExpression) {
        return new FieldComparisonEvaluator((FieldComparisonExpression) expr, context);
    } else if (expr instanceof RegexMatchExpression) {
        return new RegexEvaluator((RegexMatchExpression) expr, context);
    } else if (expr instanceof NaryValueRelationalExpression) {
        return new NaryValueRelationalExpressionEvaluator((NaryValueRelationalExpression) expr, context);
    } else if (expr instanceof NaryFieldRelationalExpression) {
        return new NaryFieldRelationalExpressionEvaluator((NaryFieldRelationalExpression) expr, context);
    } else if (expr instanceof UnaryLogicalExpression) {
        return new UnaryLogicalExpressionEvaluator((UnaryLogicalExpression) expr, context);
    } else if (expr instanceof NaryLogicalExpression) {
        return new NaryLogicalExpressionEvaluator((NaryLogicalExpression) expr, context);
    } else if (expr instanceof ArrayContainsExpression) {
        return new ArrayContainsEvaluator((ArrayContainsExpression) expr, context);
    } else if (expr instanceof ArrayMatchExpression) {
        return new ArrayMatchEvaluator((ArrayMatchExpression) expr, context);
    }
    return ret;
}
 

import com.redhat.lightblue.query.NaryFieldRelationalExpression; //导入依赖的package包/类
/**
 * @param context The field tree node for the latest enclosing context (array of elemMatch, or top level node)
 * @param query The query to translate
 * @param emd The metadata
 * @param fullPath Current full path
 */
private DBObject translate(FieldTreeNode context, QueryExpression query, EntityMetadata emd, MutablePath fullPath) {
    DBObject ret;
    try {
        if (query instanceof ArrayContainsExpression) {
            ret = translateArrayContains(context, emd, (ArrayContainsExpression) query,fullPath);
        } else if (query instanceof ArrayMatchExpression) {
            ret = translateArrayElemMatch(context, emd, (ArrayMatchExpression) query, emd, fullPath);
        } else if (query instanceof FieldComparisonExpression) {
            ret = translateFieldComparison(context, emd, (FieldComparisonExpression) query, fullPath);
        } else if (query instanceof NaryLogicalExpression) {
            ret = translateNaryLogicalExpression(context, emd, (NaryLogicalExpression) query, emd, fullPath);
        } else if (query instanceof NaryValueRelationalExpression) {
            ret = translateNaryValueRelationalExpression(context, emd, (NaryValueRelationalExpression) query,fullPath);
        } else if (query instanceof NaryFieldRelationalExpression) {
            ret = translateNaryFieldRelationalExpression(context, emd, (NaryFieldRelationalExpression) query,fullPath);
        } else if (query instanceof RegexMatchExpression) {
            ret = translateRegexMatchExpression(context, emd, (RegexMatchExpression) query, emd, fullPath);
        } else if (query instanceof UnaryLogicalExpression) {
            ret = translateUnaryLogicalExpression(context, emd, (UnaryLogicalExpression) query, emd, fullPath);
        } else {
            ret = translateValueComparisonExpression(context, emd, (ValueComparisonExpression) query,fullPath);
        }
    } catch (NeedsJS x) {
        // We can't translate the query, we have to write a $where query
        // But we can't do that if we're in an arrayElemMatch
        if(fullPath.isEmpty()) {
            JSQueryTranslator tx=new JSQueryTranslator(emd);
            ret=new BasicDBObject("$where",tx.translateQuery(query).toString());
        } else
            throw x; // Continue unroll stack
    }
    return ret;
}
 

import com.redhat.lightblue.query.NaryFieldRelationalExpression; //导入依赖的package包/类
private DBObject translateNaryFieldRelationalExpression(FieldTreeNode context, EntityMetadata md,  NaryFieldRelationalExpression expr,MutablePath fullPath) {        
    FieldInfo finfo=resolveFieldForQuery(context,fullPath.immutableCopy(),expr.getField());
    Type t = finfo.fieldMd.getType();
    if (t.supportsEq()) {
        if(!fullPath.isEmpty()) {
            // We are in array elemMatch query, and can't use a $where
            throw new NeedsJS();
        }
        JSQueryTranslator jstx=new JSQueryTranslator(md);
        return new BasicDBObject("$where",jstx.translateQuery(expr).toString());
    } else {
        throw Error.get(ERR_INVALID_FIELD, expr.toString());
    }
}
 

import com.redhat.lightblue.query.NaryFieldRelationalExpression; //导入依赖的package包/类
@Override
protected Filter itrNaryFieldRelationalExpression(NaryFieldRelationalExpression q, Path context) {
    //TODO: Support
    throw new UnsupportedOperationException("Operation not yet supported");
}
 

import com.redhat.lightblue.query.NaryFieldRelationalExpression; //导入依赖的package包/类
@Test(expected = UnsupportedOperationException.class)
public void testbuild_NaryFieldRelationalExpression(){
    QueryExpression query = new NaryFieldRelationalExpression(null, null, null);

    new FilterBuilder(new TrivialLdapFieldNameTranslator()).build(query);
}