TestExpressionUtil.java

package edu.brown.expressions;

import java.util.Collection;

import org.json.JSONObject;
import org.junit.Test;
import org.voltdb.catalog.Procedure;
import org.voltdb.catalog.Statement;
import org.voltdb.expressions.AbstractExpression;
import org.voltdb.expressions.AggregateExpression;
import org.voltdb.expressions.NullValueExpression;
import org.voltdb.plannodes.AbstractPlanNode;
import org.voltdb.plannodes.AbstractScanPlanNode;
import org.voltdb.plannodes.IndexScanPlanNode;
import org.voltdb.types.ExpressionType;

import edu.brown.BaseTestCase;
import edu.brown.benchmark.tm1.procedures.DeleteCallForwarding;
import edu.brown.plannodes.PlanNodeUtil;
import edu.brown.utils.CollectionUtil;
import edu.brown.utils.ProjectType;

public class TestExpressionUtil extends BaseTestCase {

    public static final String TARGET_PROC = DeleteCallForwarding.class.getSimpleName();
    public static final String TARGET_STMT = "query";

    private Procedure catalog_proc;
    private Statement catalog_stmt;
    
    @Override
    protected void setUp() throws Exception {
        super.setUp(ProjectType.TM1);
        
        this.catalog_proc = this.getProcedure(TARGET_PROC);
        this.catalog_stmt = this.getStatement(this.catalog_proc, TARGET_STMT);
    }
    
    /**
     * testClone
     */
    @Test
    public void testClone() throws Exception {
        AggregateExpression exp = new AggregateExpression(ExpressionType.COMPARE_EQUAL);
        exp.m_distinct = true;
        AggregateExpression clone = (AggregateExpression)exp.clone();
        assertNotNull(clone);
        
        assertEquals(exp.getId(), clone.getId());
        assertEquals(exp.isJoiningClause(), clone.isJoiningClause());
        assertEquals(exp.getExpressionType(), clone.getExpressionType());
        assertEquals(exp.getValueType(), clone.getValueType());
        assertEquals(exp.getValueSize(), clone.getValueSize());
        assertEquals(exp.isDistinct(), clone.isDistinct());
    }
    
    /**
     * testEquals
     */
    @Test
    public void testEquals() throws Exception {
        AbstractPlanNode root = PlanNodeUtil.getRootPlanNodeForStatement(catalog_stmt, true);
        assertNotNull(root);
        
        Collection<AbstractScanPlanNode> scan_nodes = PlanNodeUtil.getPlanNodes(root, AbstractScanPlanNode.class);
        assertNotNull(scan_nodes);
        assertEquals(1, scan_nodes.size());
        AbstractScanPlanNode scan_node = CollectionUtil.first(scan_nodes);
        assertNotNull(scan_node);
        
        Collection<AbstractExpression> exps = PlanNodeUtil.getExpressionsForPlanNode(scan_node);
        assertNotNull(exps);
        assertFalse(exps.isEmpty());
        AbstractExpression exp = CollectionUtil.first(exps);
        assertNotNull(exp);
        
        // Clone the mofo and make sure equals() returns true!
        String json = exp.toJSONString();
        assertFalse(json.isEmpty());
        AbstractExpression clone = AbstractExpression.fromJSONObject(new JSONObject(json), catalog_db);
        assertNotNull(clone);
        assert(ExpressionUtil.equals(exp, clone));

        // Change one of the branches. This should now return false!
        clone.setRight(new NullValueExpression());
        assertFalse(ExpressionUtil.equals(exp, clone));
        
        // Remove both the branch on both sids. This should return true!
        exp.setRight(null);
        clone.setRight(null);
        assert(ExpressionUtil.equals(exp, clone));
    }
    
    /**
     * testDebug
     */
    public void testDebug() throws Exception {
        // Just make sure this doesn't throw an Exception
        AbstractPlanNode root = PlanNodeUtil.getRootPlanNodeForStatement(catalog_stmt, true);
        assertNotNull(root);
        //System.err.println(PlanNodeUtil.debug(root));
        IndexScanPlanNode scan_node = CollectionUtil.first(PlanNodeUtil.getPlanNodes(root, IndexScanPlanNode.class));
        assertNotNull(scan_node);
        
        AbstractExpression exp = scan_node.getEndExpression();
        assertNotNull(exp);
        String debug = ExpressionUtil.debug(exp);
        assertNotNull(debug);
        assertFalse(debug.isEmpty());
    }
    
}