SQLExpressionVisitor.java

package com.temenos.interaction.jdbc.producer.sql;

/*
 * OData4j uses 'visitors' to convert expressions into Strings. This version converts an expression into a SQL command.
 */

/*
 * #%L
 * interaction-jdbc-producer
 * %%
 * Copyright (C) 2012 - 2013 Temenos Holdings N.V.
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * #L%
 */
import java.sql.Timestamp;

import javax.ws.rs.core.Response.Status;

import org.joda.time.LocalDateTime;
import org.odata4j.expression.AddExpression;
import org.odata4j.expression.AndExpression;
import org.odata4j.expression.BoolParenExpression;
import org.odata4j.expression.CeilingMethodCallExpression;
import org.odata4j.expression.ConcatMethodCallExpression;
import org.odata4j.expression.DateTimeLiteral;
import org.odata4j.expression.DateTimeOffsetLiteral;
import org.odata4j.expression.DayMethodCallExpression;
import org.odata4j.expression.DivExpression;
import org.odata4j.expression.EndsWithMethodCallExpression;
import org.odata4j.expression.EntitySimpleProperty;
import org.odata4j.expression.EqExpression;
import org.odata4j.expression.FloorMethodCallExpression;
import org.odata4j.expression.GeExpression;
import org.odata4j.expression.GtExpression;
import org.odata4j.expression.HourMethodCallExpression;
import org.odata4j.expression.IndexOfMethodCallExpression;
import org.odata4j.expression.IsofExpression;
import org.odata4j.expression.LeExpression;
import org.odata4j.expression.LengthMethodCallExpression;
import org.odata4j.expression.LtExpression;
import org.odata4j.expression.MinuteMethodCallExpression;
import org.odata4j.expression.ModExpression;
import org.odata4j.expression.MonthMethodCallExpression;
import org.odata4j.expression.MulExpression;
import org.odata4j.expression.NeExpression;
import org.odata4j.expression.NotExpression;
import org.odata4j.expression.OrExpression;
import org.odata4j.expression.OrderByExpression;
import org.odata4j.expression.ParenExpression;
import org.odata4j.expression.ReplaceMethodCallExpression;
import org.odata4j.expression.RoundMethodCallExpression;
import org.odata4j.expression.SecondMethodCallExpression;
import org.odata4j.expression.StartsWithMethodCallExpression;
import org.odata4j.expression.StringLiteral;
import org.odata4j.expression.SubExpression;
import org.odata4j.expression.SubstringMethodCallExpression;
import org.odata4j.expression.SubstringOfMethodCallExpression;
import org.odata4j.expression.TimeLiteral;
import org.odata4j.expression.ToLowerMethodCallExpression;
import org.odata4j.expression.ToUpperMethodCallExpression;
import org.odata4j.expression.TrimMethodCallExpression;
import org.odata4j.expression.YearMethodCallExpression;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.temenos.interaction.jdbc.SqlRelation;
import com.temenos.interaction.jdbc.exceptions.JdbcException;
import com.temenos.interaction.odataext.odataparser.odata4j.PrintExpressionVisitor;

public class SQLExpressionVisitor extends PrintExpressionVisitor {

    private final static Logger logger = LoggerFactory.getLogger(SQLExpressionVisitor.class);

    // Variables handling the SQLExpression tree,
    private SQLExpressionNode rootNode = new SQLExpressionNode();
    private SQLExpressionNode currentNode = rootNode;

    @Override
    public String toString() {
        // Print out the expression tree
        return rootNode.toSqlParameter();
    }

    /*
     * Support for formatted calls from the super class. These append the
     * argument as a simple string without formatting. Where local code requires
     * formatting use appendFormatted().
     */
    protected void append(String format, Object... args) {
        append(String.format("%s", args));
    }

    /*
     * Append with format string
     */
    protected void appendFormatted(String format, Object... args) {
        append(String.format(format, args));
    }

    protected void append(String str) {
        if (!currentNode.addArgument(str)) {
            throw new JdbcException(Status.INTERNAL_SERVER_ERROR, "Internal error adding:" + str);
        }
    }

    /*
     * Append an operator or function.
     */
    private void append(SqlRelation rel) {
        append(rel, false);
    }

    /*
     * Append an operator of function optionally surrounded by spaces.
     */
    private void append(SqlRelation rel, boolean spaced) {
        // If there is no SQL equivalent throw.
        if (null == rel.getSqlSymbol()) {
            String msg = "Unsupported SQL relation \"" + rel + "\".";
            logger.error(msg);
            throw new UnsupportedOperationException(msg);
        }

        // Remember if symbol should be surrounded by spaces.
        currentNode.setIsSpaced(spaced);

        currentNode.setRelation(rel);
    }

    @Override
    public void afterDescend() {
        toParent();
    }

    /*
     * Move a level up the expression tree.
     */
    private void toParent() {
        SQLExpressionNode parentNode = currentNode.getParent();
        if (null == parentNode) {
            throw new JdbcException(Status.INTERNAL_SERVER_ERROR, "Tried to go above expression tree root.");
        }

        // Child is complete. Print it as a parent argument.
        parentNode.addArgument(currentNode.toSqlParameter());

        currentNode = parentNode;
    }

    @Override
    public void beforeDescend() {
        // Create a new child node and move to it.
        currentNode = new SQLExpressionNode(currentNode);
    }

    @Override
    public void betweenDescend() {
        toParent();

        // Create next child node and move to it.
        currentNode = new SQLExpressionNode(currentNode);
    }

    @Override
    public void visit(OrderByExpression expr) {
        // Don't append the 'orderBy' tag.
    }

    // Double quote column names.
    @Override
    public void visit(EntitySimpleProperty expr) {
        appendFormatted("\"%s\"", expr.getPropertyName());
    }

    @Override
    public void visit(EqExpression expr) {
        append(SqlRelation.EQ);
    }

    @Override
    public void visit(NeExpression expr) {
        append(SqlRelation.NE);
    }

    @Override
    public void visit(GtExpression expr) {
        append(SqlRelation.GT);
    }

    @Override
    public void visit(LtExpression expr) {
        append(SqlRelation.LT);
    }

    @Override
    public void visit(GeExpression expr) {
        append(SqlRelation.GE);
    }

    @Override
    public void visit(LeExpression expr) {
        append(SqlRelation.LE);
    }

    @Override
    public void visit(AndExpression expr) {
        append(SqlRelation.AND, true);
    }

    @Override
    public void visit(OrExpression expr) {
        append(SqlRelation.OR, true);
    }

    @Override
    public void visit(AddExpression expr) {
        append(SqlRelation.ADD);
    }

    @Override
    public void visit(SubExpression expr) {
        append(SqlRelation.SUB);
    }

    @Override
    public void visit(MulExpression expr) {
        append(SqlRelation.MUL);
    }

    @Override
    public void visit(DivExpression expr) {
        append(SqlRelation.DIV);
    }

    @Override
    public void visit(ModExpression expr) {
        append(SqlRelation.MOD);
    }

    @Override
    public void visit(NotExpression expr) {
        append(SqlRelation.NOT, true);
    }

    @Override
    public void visit(BoolParenExpression expr) {
        // Make a note that The current term is bracketed.
        currentNode.setIsBracketed();
    }

    @Override
    public void visit(ParenExpression expr) {
        // Make a note that The current term is bracketed.
        currentNode.setIsBracketed();
    }

    // Literal strings may contain spaces or dots. So single quote.
    @Override
    public void visit(StringLiteral expr) {
        appendFormatted("'%s'", expr.getValue());
    }

    @Override
    public void visit(SubstringMethodCallExpression expr) {
        append(SqlRelation.SUBSTR);
    }

    @Override
    public void visit(SubstringOfMethodCallExpression expr) {
        append(SqlRelation.SUBSTROF);
    }

    @Override
    public void visit(ToUpperMethodCallExpression expr) {
        append(SqlRelation.TOUPPER);
    }

    @Override
    public void visit(ToLowerMethodCallExpression expr) {
        append(SqlRelation.TOLOWER);
    }

    @Override
    public void visit(ReplaceMethodCallExpression expr) {
        append(SqlRelation.REPLACE);
    }

    @Override
    public void visit(LengthMethodCallExpression expr) {
        append(SqlRelation.LENGTH);
    }

    @Override
    public void visit(TrimMethodCallExpression expr) {
        append(SqlRelation.TRIM);
    }

    @Override
    public void visit(YearMethodCallExpression expr) {
        append(SqlRelation.YEAR);
    }

    @Override
    public void visit(MonthMethodCallExpression expr) {
        append(SqlRelation.MONTH);
    }

    @Override
    public void visit(DayMethodCallExpression expr) {
        append(SqlRelation.DAY);
    }

    @Override
    public void visit(HourMethodCallExpression expr) {
        append(SqlRelation.HOUR);
    }

    @Override
    public void visit(MinuteMethodCallExpression expr) {
        append(SqlRelation.MINUTE);
    }

    @Override
    public void visit(SecondMethodCallExpression expr) {
        append(SqlRelation.SECOND);
    }

    @Override
    public void visit(RoundMethodCallExpression expr) {
        append(SqlRelation.ROUND);
    }

    @Override
    public void visit(FloorMethodCallExpression expr) {
        append(SqlRelation.FLOOR);
    }

    @Override
    public void visit(CeilingMethodCallExpression expr) {
        append(SqlRelation.CEILING);
    }

    @Override
    public void visit(IsofExpression expr) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void visit(EndsWithMethodCallExpression expr) {
        append(SqlRelation.ENDSWITH);
    }

    @Override
    public void visit(StartsWithMethodCallExpression expr) {
        append(SqlRelation.STARTSWITH);
    }

    @Override
    public void visit(IndexOfMethodCallExpression expr) {
        append(SqlRelation.INDEXOF);
    }

    @Override
    public void visit(ConcatMethodCallExpression expr) {
        append(SqlRelation.CONCAT);
    }

    @Override
    public void visit(DateTimeLiteral expr) {
        // Get the joda representation
        LocalDateTime jodaTime = expr.getValue();

        // Convert it to SQL representation
        Timestamp timeStamp = new Timestamp(jodaTime.toDateTime().getMillis());

        // Print it out.
        String timeStampStr = timeStamp.toString();
        appendFormatted("'%s'", timeStampStr);
    }

    @Override
    public void visit(DateTimeOffsetLiteral expr) {
        throw new UnsupportedOperationException("DateTimeOffsetLiteral not supported.");
    }

    @Override
    public void visit(TimeLiteral expr) {
        throw new UnsupportedOperationException("TimeLiteral not supported.");
    }
}