Examples with JavaQueryCompiler org.datanucleus.query.compiler.JavaQueryCompiler used on opensource projects

Example 21 with JavaQueryCompiler

use of org.datanucleus.query.compiler.JavaQueryCompiler in project datanucleus-core by datanucleus.

the class AbstractJPQLQuery method compileGeneric.

/* (non-Javadoc)
     * @see org.datanucleus.store.query.AbstractJavaQuery#compileGeneric(java.util.Map)
     */
@Override
public void compileGeneric(Map parameterValues) {
    if (compilation != null) {
        return;
    }
    QueryManager queryMgr = getQueryManager();
    String queryCacheKey = getQueryCacheKey();
    if (useCaching() && queryCacheKey != null) {
        QueryCompilation cachedCompilation = queryMgr.getQueryCompilationForQuery(getLanguage(), queryCacheKey);
        if (cachedCompilation != null) {
            compilation = cachedCompilation;
            if (compilation.getExprResult() == null) {
                // If the result was "Object(e)" or "e" then this is meaningless so remove
                result = null;
            }
            checkParameterTypesAgainstCompilation(parameterValues);
            return;
        }
    }
    long startTime = 0;
    if (NucleusLogger.QUERY.isDebugEnabled()) {
        startTime = System.currentTimeMillis();
        NucleusLogger.QUERY.debug(Localiser.msg("021044", getLanguage(), getSingleStringQuery()));
    }
    String from = this.from;
    if (type == QueryType.BULK_INSERT) {
        // Append artificial alias so the compilation passes
        from += " this";
    }
    JavaQueryCompiler compiler = new JPQLCompiler(ec.getNucleusContext(), ec.getClassLoaderResolver(), from, candidateClass, candidateCollection, this.filter, getParsedImports(), this.ordering, this.result, this.grouping, this.having, explicitParameters, update);
    if (getBooleanExtensionProperty(EXTENSION_JPQL_STRICT, false)) {
        compiler.setOption(EXTENSION_JPQL_STRICT, "true");
    }
    compilation = compiler.compile(parameterValues, subqueries);
    if (QueryUtils.queryReturnsSingleRow(this)) {
        compilation.setReturnsSingleRow();
    }
    if (resultDistinct) {
        compilation.setResultDistinct();
    }
    if (compilation.getExprResult() == null) {
        // If the result was "Object(e)" or "e" then this is meaningless so remove
        result = null;
    }
    if (NucleusLogger.QUERY.isDebugEnabled()) {
        NucleusLogger.QUERY.debug(Localiser.msg("021045", getLanguage(), "" + (System.currentTimeMillis() - startTime)));
    }
    if (subqueries != null) {
        // Compile any subqueries
        compileSubqueries(subqueries, compilation, compiler, parameterValues);
    }
    if (NucleusLogger.QUERY.isDebugEnabled()) {
        // Log the query compilation
        NucleusLogger.QUERY.debug(compilation.toString());
    }
    if (implicitParameters != null) {
        // Make sure any implicit parameters have their values in the compilation
        Iterator paramKeyIter = implicitParameters.keySet().iterator();
        while (paramKeyIter.hasNext()) {
            Object paramKey = paramKeyIter.next();
            String paramName = "" + paramKey;
            applyImplicitParameterValueToCompilation(paramName, implicitParameters.get(paramName));
        }
    }
    checkParameterTypesAgainstCompilation(parameterValues);
    if (useCaching() && queryCacheKey != null) {
        // Cache for future reference
        queryMgr.addQueryCompilation(getLanguage(), queryCacheKey, compilation);
    }
}

Example 22 with JavaQueryCompiler

use of org.datanucleus.query.compiler.JavaQueryCompiler in project tests by datanucleus.

the class JPQLCompilerTest method testFilterWithExistsSubquery.

/**
 * Tests for "EXISTS (subquery)".
 */
public void testFilterWithExistsSubquery() {
    JavaQueryCompiler compiler = null;
    QueryCompilation compilation = null;
    try {
        compiler = new JPQLCompiler(nucCtx, nucCtx.getClassLoaderResolver(null), null, Project.class, null, "EXISTS (SUBQ_1)", null, null, null, null, null, null, null);
        compilation = compiler.compile(new HashMap(), null);
    } catch (NucleusException ne) {
        NucleusLogger.QUERY.error("Exception during compile", ne);
        fail("compilation of filter with valid field threw exception : " + ne.getMessage());
    }
    Expression expr = compilation.getExprFilter();
    assertTrue("Expression is not a SubqueryExpression", expr instanceof SubqueryExpression);
    SubqueryExpression subExpr = (SubqueryExpression) expr;
    assertEquals("Subquery keyword is incorrect", "EXISTS", subExpr.getKeyword());
    assertTrue("Subquery right expression is not VariableExpression", subExpr.getRight() instanceof VariableExpression);
    VariableExpression varExpr = (VariableExpression) subExpr.getRight();
    assertEquals("VariableExpression name is incorrect", "SUBQ_1", varExpr.getId());
}

Example 23 with JavaQueryCompiler

use of org.datanucleus.query.compiler.JavaQueryCompiler in project tests by datanucleus.

the class JPQLCompilerTest method testFilterWithNegateExpression.

/**
 * Tests for "!(expression)".
 */
public void testFilterWithNegateExpression() {
    JavaQueryCompiler compiler = null;
    QueryCompilation compilation = null;
    try {
        compiler = new JPQLCompiler(nucCtx, nucCtx.getClassLoaderResolver(null), null, Project.class, null, "NOT (budget > 32)", null, null, null, null, null, null, null);
        compilation = compiler.compile(new HashMap(), null);
    } catch (NucleusException ne) {
        NucleusLogger.QUERY.error("Exception during compile", ne);
        fail("compilation of filter with valid field threw exception : " + ne.getMessage());
    }
    Expression expr = compilation.getExprFilter();
    assertTrue("Compiled expression should have been DyadicExpression but wasnt", expr instanceof DyadicExpression);
    DyadicExpression dyExpr = (DyadicExpression) expr;
    assertTrue("Compiled left expression should have been DyadicExpression but wasnt", dyExpr.getLeft() instanceof DyadicExpression);
    assertNull("Compiled right expression should have been null but wasnt", dyExpr.getRight());
    assertEquals("Expression operator is wrong", Expression.OP_NOT, dyExpr.getOperator());
    DyadicExpression leftExpr = (DyadicExpression) dyExpr.getLeft();
    assertTrue("Left (left) should be PrimaryExpression but isnt", leftExpr.getLeft() instanceof PrimaryExpression);
    assertTrue("Left (right) should be Literal but isnt", leftExpr.getRight() instanceof Literal);
    assertEquals("Left expression operator is wrong", Expression.OP_GT, leftExpr.getOperator());
    PrimaryExpression primExpr = (PrimaryExpression) leftExpr.getLeft();
    assertEquals("Left (left) expression has incorrect number of tuples", 1, primExpr.getTuples().size());
    assertEquals("Left (left) expression 'id' is incorrect", "budget", primExpr.getId());
    Literal lit = (Literal) leftExpr.getRight();
    assertTrue("Left (right) expression literal is of incorrect type", lit.getLiteral() instanceof Long);
    assertEquals("Left (right) expression literal has incorrect value", 32, ((Long) lit.getLiteral()).longValue());
}

Example 24 with JavaQueryCompiler

use of org.datanucleus.query.compiler.JavaQueryCompiler in project tests by datanucleus.

the class JPQLCompilerTest method testFromMemberOfExpression.

/**
 * Tests for from clause with a "MEMBER OF {primary}" expression.
 */
public void testFromMemberOfExpression() {
    JavaQueryCompiler compiler = null;
    QueryCompilation compilation = null;
    try {
        compiler = new JPQLCompiler(nucCtx, nucCtx.getClassLoaderResolver(null), null, Department.class, null, ":param MEMBER OF projects", null, null, null, null, null, null, null);
        compilation = compiler.compile(new HashMap(), null);
    } catch (NucleusException ne) {
        NucleusLogger.QUERY.error("Exception during compile", ne);
        fail("compilation of filter with valid field threw exception : " + ne.getMessage());
    }
    // InvokeExpression{[PrimaryExpression{elements}].contains(ParameterExpression{param})}
    Expression expr = compilation.getExprFilter();
    assertTrue("Invalid type of filter expression", expr instanceof InvokeExpression);
    InvokeExpression invokeExpr = (InvokeExpression) expr;
    assertEquals("Invoke method is incorrect", "contains", invokeExpr.getOperation());
    assertTrue("Invoke left expression is of incorrect type", invokeExpr.getLeft() instanceof PrimaryExpression);
    PrimaryExpression leftExpr = (PrimaryExpression) invokeExpr.getLeft();
    assertEquals("Invoke left expression id is wrong", "projects", leftExpr.getId());
    List args = invokeExpr.getArguments();
    assertNotNull("Number of args is null!", args);
    assertEquals("Incorrect number of args to invoke", 1, args.size());
    assertTrue("Argument is of incorrect type", args.get(0) instanceof ParameterExpression);
    ParameterExpression argExpr = (ParameterExpression) args.get(0);
    assertEquals("Argument param name is incorrect", "param", argExpr.getId());
}

Example 25 with JavaQueryCompiler

use of org.datanucleus.query.compiler.JavaQueryCompiler in project tests by datanucleus.

the class JPQLCompilerTest method testFilterComparison.

/**
 * Tests for simple field-literal comparison in filter.
 */
public void testFilterComparison() {
    JavaQueryCompiler compiler = null;
    QueryCompilation compilation = null;
    try {
        compiler = new JPQLCompiler(nucCtx, nucCtx.getClassLoaderResolver(null), null, Project.class, null, "budget = 2", null, null, null, null, null, null, null);
        compilation = compiler.compile(new HashMap(), null);
    } catch (NucleusException ne) {
        NucleusLogger.QUERY.error("Exception during compile", ne);
        fail("compilation of filter with valid field threw exception : " + ne.getMessage());
    }
    Expression expr = compilation.getExprFilter();
    assertTrue("Compiled expression should have been DyadicExpression but wasnt", expr instanceof DyadicExpression);
    DyadicExpression dyExpr = (DyadicExpression) expr;
    assertTrue("Compiled left expression should be PrimaryExpression but isnt", dyExpr.getLeft() instanceof PrimaryExpression);
    assertTrue("Compiled right expression should be Literal but isnt", dyExpr.getRight() instanceof Literal);
    assertEquals("Operator between left and right is incorrect", Expression.OP_EQ, dyExpr.getOperator());
    PrimaryExpression leftExpr1 = (PrimaryExpression) dyExpr.getLeft();
    assertEquals("Compiled left expression has incorrect number of tuples", 1, leftExpr1.getTuples().size());
    assertEquals("Compiled left expression 'id' is incorrect", "budget", leftExpr1.getId());
    Literal rightExpr1 = (Literal) dyExpr.getRight();
    assertTrue("Compiled right expression literal is of incorrect type", rightExpr1.getLiteral() instanceof Long);
    assertEquals("Compiled right expression literal has incorrect value", 2, ((Long) rightExpr1.getLiteral()).longValue());
    try {
        compiler = new JPQLCompiler(nucCtx, nucCtx.getClassLoaderResolver(null), null, Project.class, null, "100.0 > budget", null, null, null, null, null, null, null);
    } catch (NucleusException ne) {
        NucleusLogger.QUERY.error("Exception during compile", ne);
        fail("compilation of filter with valid field threw exception : " + ne.getMessage());
    }
    compilation = compiler.compile(new HashMap(), null);
    expr = compilation.getExprFilter();
    assertTrue("Compiled expression should have been DyadicExpression but wasnt", expr instanceof DyadicExpression);
    dyExpr = (DyadicExpression) expr;
    assertTrue("Compiled right expression should be PrimaryExpression but isnt", dyExpr.getRight() instanceof PrimaryExpression);
    assertTrue("Compiled left expression should be Literal but isnt", dyExpr.getLeft() instanceof Literal);
    assertEquals("Operator between left and right is incorrect", Expression.OP_GT, dyExpr.getOperator());
    PrimaryExpression rightExpr2 = (PrimaryExpression) dyExpr.getRight();
    assertEquals("Compiled left expression has incorrect number of tuples", 1, rightExpr2.getTuples().size());
    assertEquals("Compiled left expression 'id' is incorrect", "budget", rightExpr2.getId());
    Literal leftExpr2 = (Literal) dyExpr.getLeft();
    // TODO Why BigDecimal and not Double??
    assertTrue("Compiled right expression literal is of incorrect type", leftExpr2.getLiteral() instanceof BigDecimal);
    assertEquals("Compiled right expression literal has incorrect value", 100.0, ((BigDecimal) leftExpr2.getLiteral()).longValue(), 0.1);
}