Examples with Multiplication net.sf.jsqlparser.expression.operators.arithmetic.Multiplication used on opensource projects

Example 1 with Multiplication

use of net.sf.jsqlparser.expression.operators.arithmetic.Multiplication in project herddb by diennea.

the class SQLExpressionCompiler method compileExpression.

// this method never returns NULL
public static CompiledSQLExpression compileExpression(String validatedTableAlias, Expression exp) {
    if (exp instanceof BinaryExpression) {
        CompiledSQLExpression compiled = compileSpecialBinaryExpression(validatedTableAlias, exp);
        if (compiled != null) {
            return compiled;
        }
    }
    if (exp instanceof net.sf.jsqlparser.schema.Column) {
        return compileColumnExpression(validatedTableAlias, exp);
    } else if (exp instanceof StringValue) {
        return new ConstantExpression(RawString.of(((StringValue) exp).getValue()));
    } else if (exp instanceof LongValue) {
        try {
            return new ConstantExpression(((LongValue) exp).getValue());
        } catch (NumberFormatException largeNumber) {
            return new ConstantExpression(Double.valueOf(((LongValue) exp).getStringValue()));
        }
    } else if (exp instanceof DoubleValue) {
        return new ConstantExpression(((DoubleValue) exp).getValue());
    } else if (exp instanceof TimestampValue) {
        return new ConstantExpression(((TimestampValue) exp).getValue());
    } else if (exp instanceof NullValue) {
        return new ConstantExpression(null);
    } else if (exp instanceof TimeKeyExpression) {
        TimeKeyExpression ext = (TimeKeyExpression) exp;
        if (CURRENT_TIMESTAMP.equalsIgnoreCase(ext.getStringValue())) {
            return new ConstantExpression(new java.sql.Timestamp(System.currentTimeMillis()));
        } else {
            throw new StatementExecutionException("unhandled expression " + exp);
        }
    } else if (exp instanceof JdbcParameter) {
        int index = ((JdbcParameter) exp).getIndex() - 1;
        return new JdbcParameterExpression(index);
    } else if (exp instanceof AndExpression) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledAndExpression(a, b, c));
    } else if (exp instanceof OrExpression) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledOrExpression(a, b, c));
    } else if (exp instanceof Function) {
        return CompiledFunction.create((Function) exp, validatedTableAlias);
    } else if (exp instanceof Addition) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledAddExpression(a, b, c));
    } else if (exp instanceof Subtraction) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledSubtractExpression(a, b, c));
    } else if (exp instanceof Multiplication) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledMultiplyExpression(a, b, c));
    } else if (exp instanceof Division) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledDivideExpression(a, b, c));
    } else if (exp instanceof Parenthesis) {
        Parenthesis p = (Parenthesis) exp;
        CompiledSQLExpression inner = compileExpression(validatedTableAlias, p.getExpression());
        return new CompiledParenthesisExpression(p.isNot(), inner);
    } else if (exp instanceof EqualsTo) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledEqualsExpression(a, b, c));
    } else if (exp instanceof NotEqualsTo) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledNotEqualsExpression(a, b, c));
    } else if (exp instanceof MinorThan) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledMinorThenExpression(a, b, c));
    } else if (exp instanceof MinorThanEquals) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledMinorThenEqualsExpression(a, b, c));
    } else if (exp instanceof GreaterThan) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledGreaterThenExpression(a, b, c));
    } else if (exp instanceof GreaterThanEquals) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledGreaterThenEqualsExpression(a, b, c));
    } else if (exp instanceof LikeExpression) {
        return tryCompileBinaryExpression(validatedTableAlias, (BinaryExpression) exp, (a, b, c) -> new CompiledLikeExpression(a, b, c));
    } else if (exp instanceof Between) {
        return CompiledBetweenExpression.create(validatedTableAlias, (Between) exp);
    } else if (exp instanceof SignedExpression) {
        SignedExpression s = (SignedExpression) exp;
        CompiledSQLExpression inner = compileExpression(validatedTableAlias, s.getExpression());
        return new CompiledSignedExpression(s.getSign(), inner);
    } else if (exp instanceof InExpression) {
        InExpression in = (InExpression) exp;
        return CompiledInExpression.create(in, validatedTableAlias);
    } else if (exp instanceof IsNullExpression) {
        IsNullExpression i = (IsNullExpression) exp;
        CompiledSQLExpression left = compileExpression(validatedTableAlias, i.getLeftExpression());
        return new CompiledIsNullExpression(i.isNot(), left);
    } else if (exp instanceof CaseExpression) {
        return CompiledCaseExpression.create(validatedTableAlias, (CaseExpression) exp);
    }
    throw new StatementExecutionException("unsupported operand " + exp.getClass() + ", expression is " + exp);
}

Example 2 with Multiplication

use of net.sf.jsqlparser.expression.operators.arithmetic.Multiplication in project herddb by diennea.

the class SQLParserExpressionCompiler method compileBinaryExpression.

private static CompiledSQLExpression compileBinaryExpression(BinaryExpression expression, OpSchema tableSchema) {
    CompiledSQLExpression left = compileExpression(expression.getLeftExpression(), tableSchema);
    CompiledSQLExpression right = compileExpression(expression.getRightExpression(), tableSchema);
    if (expression instanceof EqualsTo) {
        EqualsTo eq = (EqualsTo) expression;
        checkSupported(eq.getOldOracleJoinSyntax() == EqualsTo.NO_ORACLE_JOIN);
        checkSupported(eq.getOraclePriorPosition() == EqualsTo.NO_ORACLE_PRIOR);
        return new CompiledEqualsExpression(left, right);
    } else if (expression instanceof AndExpression) {
        return new CompiledAndExpression(left, right);
    } else if (expression instanceof OrExpression) {
        return new CompiledOrExpression(left, right);
    } else if (expression instanceof GreaterThan) {
        return new CompiledGreaterThanExpression(left, right);
    } else if (expression instanceof GreaterThanEquals) {
        return new CompiledGreaterThanEqualsExpression(left, right);
    } else if (expression instanceof MinorThan) {
        return new CompiledMinorThanExpression(left, right);
    } else if (expression instanceof MinorThanEquals) {
        return new CompiledMinorThanEqualsExpression(left, right);
    } else if (expression instanceof Addition) {
        return new CompiledAddExpression(left, right);
    } else if (expression instanceof Division) {
        return new CompiledDivideExpression(left, right);
    } else if (expression instanceof Multiplication) {
        return new CompiledMultiplyExpression(left, right);
    } else if (expression instanceof LikeExpression) {
        LikeExpression eq = (LikeExpression) expression;
        if (eq.isCaseInsensitive()) {
            // this is not supported by Calcite, do not support it with jSQLParser
            throw new StatementExecutionException("ILIKE is not supported");
        }
        CompiledSQLExpression res;
        if (eq.getEscape() != null) {
            CompiledSQLExpression escape = new ConstantExpression(eq.getEscape(), ColumnTypes.NOTNULL_STRING);
            res = new CompiledLikeExpression(left, right, escape);
        } else {
            res = new CompiledLikeExpression(left, right);
        }
        if (eq.isNot()) {
            res = new CompiledNotExpression(res);
        }
        return res;
    } else if (expression instanceof Modulo) {
        return new CompiledModuloExpression(left, right);
    } else if (expression instanceof Subtraction) {
        return new CompiledSubtractExpression(left, right);
    } else if (expression instanceof NotEqualsTo) {
        NotEqualsTo eq = (NotEqualsTo) expression;
        checkSupported(eq.getOldOracleJoinSyntax() == EqualsTo.NO_ORACLE_JOIN);
        checkSupported(eq.getOraclePriorPosition() == EqualsTo.NO_ORACLE_PRIOR);
        return new CompiledNotEqualsExpression(left, right);
    } else {
        throw new StatementExecutionException("not implemented expression type " + expression.getClass() + ": " + expression);
    }
}

Example 3 with Multiplication

use of net.sf.jsqlparser.expression.operators.arithmetic.Multiplication in project JSqlParser by JSQLParser.

the class CCJSqlParserUtilTest method testParseExpression2.

@Test
public void testParseExpression2() throws Exception {
    Expression result = CCJSqlParserUtil.parseExpression("2*(a+6.0)");
    assertEquals("2 * (a + 6.0)", result.toString());
    assertTrue(result instanceof Multiplication);
    Multiplication mult = (Multiplication) result;
    assertTrue(mult.getLeftExpression() instanceof LongValue);
    assertTrue(mult.getRightExpression() instanceof Parenthesis);
}