tajo-core-tests/src/test/java/org/apache/tajo/engine/planner/TestEvalNodeToExprConverter.java - tajo - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.tajo.engine.planner;

 import org.apache.tajo.BuiltinStorages;
 import org.apache.tajo.LocalTajoTestingUtility;
 import org.apache.tajo.QueryVars;
 import org.apache.tajo.TajoTestingCluster;
 import org.apache.tajo.algebra.*;
 import org.apache.tajo.benchmark.TPCH;
 import org.apache.tajo.catalog.*;
 import org.apache.tajo.engine.function.FunctionLoader;
 import org.apache.tajo.engine.query.QueryContext;
 import org.apache.tajo.exception.TajoException;
 import org.apache.tajo.parser.sql.SQLAnalyzer;
 import org.apache.tajo.plan.LogicalOptimizer;
 import org.apache.tajo.plan.LogicalPlan;
 import org.apache.tajo.plan.LogicalPlanner;
 import org.apache.tajo.plan.expr.AlgebraicUtil;
 import org.apache.tajo.plan.logical.LogicalNode;
 import org.apache.tajo.plan.logical.NodeType;
 import org.apache.tajo.plan.logical.ScanNode;
 import org.apache.tajo.plan.util.EvalNodeToExprConverter;
 import org.apache.tajo.plan.util.PlannerUtil;
 import org.apache.tajo.schema.IdentifierUtil;
 import org.apache.tajo.session.Session;
 import org.apache.tajo.storage.TablespaceManager;
 import org.apache.tajo.util.CommonTestingUtil;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;

 import java.util.Stack;

 import static org.apache.tajo.TajoConstants.DEFAULT_DATABASE_NAME;
 import static org.apache.tajo.TajoConstants.DEFAULT_TABLESPACE_NAME;
 import static org.junit.Assert.*;

 public class TestEvalNodeToExprConverter {
   private static TajoTestingCluster util;
   private static CatalogService catalog;
   private static SQLAnalyzer sqlAnalyzer;
   private static LogicalPlanner planner;
   private static TPCH tpch;
   private static Session session = LocalTajoTestingUtility.createDummySession();

   @BeforeClass
   public static void setUp() throws Exception {
     util = new TajoTestingCluster();
     util.startCatalogCluster();
     catalog = util.getCatalogService();
     catalog.createTablespace(DEFAULT_TABLESPACE_NAME, "hdfs://localhost:1234");
     catalog.createDatabase(DEFAULT_DATABASE_NAME, DEFAULT_TABLESPACE_NAME);

     for (FunctionDesc funcDesc : FunctionLoader.findLegacyFunctions()) {
       catalog.createFunction(funcDesc);
     }

     // TPC-H Schema for Complex Queries
     String [] tpchTables = {
       "part", "supplier", "partsupp", "nation", "region", "lineitem"
     };
     tpch = new TPCH();
     tpch.loadSchemas();
     tpch.loadOutSchema();
     for (String table : tpchTables) {
       TableMeta m = CatalogUtil.newTableMeta(BuiltinStorages.TEXT, util.getConfiguration());
       TableDesc d = CatalogUtil.newTableDesc(
         IdentifierUtil.buildFQName(DEFAULT_DATABASE_NAME, table), tpch.getSchema(table), m,
         CommonTestingUtil.getTestDir());
       catalog.createTable(d);
     }

     sqlAnalyzer = new SQLAnalyzer();
     planner = new LogicalPlanner(catalog, TablespaceManager.getInstance());
   }

   @AfterClass
   public static void tearDown() throws Exception {
     util.shutdownCatalogCluster();
   }

   static String[] QUERIES = {
     "select * from lineitem where L_ORDERKEY > 500", //0
     "select * from region where r_name = 'EUROPE'", //1
     "select * from lineitem where L_DISCOUNT >= 0.05 and L_DISCOUNT <= 0.07 OR L_QUANTITY < 24.0 ", //2
     "select * from lineitem where L_DISCOUNT between 0.06 - 0.01 and 0.08 + 0.02 and L_ORDERKEY < 24 ", //3
     "select * from lineitem where (case when L_DISCOUNT > 0.0 then L_DISCOUNT / L_TAX else null end) > 1.2 ", //4
     "select * from part where p_brand = 'Brand#23' and p_container in ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') " +
       "and p_size between 1 and 10", //5
   };

   private static QueryContext createQueryContext() {
     QueryContext qc = new QueryContext(util.getConfiguration(), session);
     qc.put(QueryVars.DEFAULT_SPACE_URI, "file:/");
     qc.put(QueryVars.DEFAULT_SPACE_ROOT_URI, "file:/");
     return qc;
   }

   @Test
   public final void testBinaryOperator1() throws CloneNotSupportedException, TajoException {
     QueryContext qc = createQueryContext();

     Expr expr = sqlAnalyzer.parse(QUERIES[0]);

     LogicalPlan plan = planner.createPlan(qc, expr);
     LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
     optimizer.optimize(plan);

     LogicalNode node = plan.getRootBlock().getRoot();
     ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

     EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
     convertor.visit(null, scanNode.getQual(), new Stack<>());

     Expr resultExpr = convertor.getResult();

     BinaryOperator binaryOperator = AlgebraicUtil.findTopExpr(resultExpr, OpType.GreaterThan);
     assertNotNull(binaryOperator);

     ColumnReferenceExpr column = binaryOperator.getLeft();
     assertEquals("default.lineitem", column.getQualifier());
     assertEquals("l_orderkey", column.getName());

     LiteralValue literalValue = binaryOperator.getRight();
     assertEquals("500", literalValue.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Integer, literalValue.getValueType());
   }

   @Test
   public final void testBinaryOperator2() throws CloneNotSupportedException, TajoException {
     QueryContext qc = createQueryContext();

     Expr expr = sqlAnalyzer.parse(QUERIES[1]);

     LogicalPlan plan = planner.createPlan(qc, expr);
     LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
     optimizer.optimize(plan);

     LogicalNode node = plan.getRootBlock().getRoot();
     ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

     EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
     convertor.visit(null, scanNode.getQual(), new Stack<>());

     Expr resultExpr = convertor.getResult();
     BinaryOperator equals = AlgebraicUtil.findTopExpr(resultExpr, OpType.Equals);
     assertNotNull(equals);

     ColumnReferenceExpr column = equals.getLeft();
     assertEquals("default.region", column.getQualifier());
     assertEquals("r_name", column.getName());

     LiteralValue literalValue = equals.getRight();
     assertEquals("EUROPE", literalValue.getValue());
     assertEquals(LiteralValue.LiteralType.String, literalValue.getValueType());
   }

   @Test
   public final void testBinaryOperator3() throws CloneNotSupportedException, TajoException {
     QueryContext qc = createQueryContext();

     Expr expr = sqlAnalyzer.parse(QUERIES[2]);

     LogicalPlan plan = planner.createPlan(qc, expr);
     LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
     optimizer.optimize(plan);

     LogicalNode node = plan.getRootBlock().getRoot();
     ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

     EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
     convertor.visit(null, scanNode.getQual(), new Stack<>());

     Expr resultExpr = convertor.getResult();

     BinaryOperator greaterThanOrEquals = AlgebraicUtil.findTopExpr(resultExpr, OpType.GreaterThanOrEquals);
     assertNotNull(greaterThanOrEquals);

     ColumnReferenceExpr greaterThanOrEqualsLeft = greaterThanOrEquals.getLeft();
     assertEquals("default.lineitem", greaterThanOrEqualsLeft.getQualifier());
     assertEquals("l_discount", greaterThanOrEqualsLeft.getName());

     LiteralValue greaterThanOrEqualsRight = greaterThanOrEquals.getRight();
     assertEquals("0.05", greaterThanOrEqualsRight.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, greaterThanOrEqualsRight.getValueType());

     BinaryOperator lessThanOrEquals = AlgebraicUtil.findTopExpr(resultExpr, OpType.LessThanOrEquals);
     assertNotNull(lessThanOrEquals);

     ColumnReferenceExpr lessThanOrEqualsLeft = lessThanOrEquals.getLeft();
     assertEquals("default.lineitem", lessThanOrEqualsLeft.getQualifier());
     assertEquals("l_discount", lessThanOrEqualsLeft.getName());

     LiteralValue lessThanOrEqualsRight = lessThanOrEquals.getRight();
     assertEquals("0.07", lessThanOrEqualsRight.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, lessThanOrEqualsRight.getValueType());

     BinaryOperator lessThan = AlgebraicUtil.findTopExpr(resultExpr, OpType.LessThan);
     assertNotNull(lessThan);

     ColumnReferenceExpr lessThanLeft = lessThan.getLeft();
     assertEquals("default.lineitem", lessThanLeft.getQualifier());
     assertEquals("l_quantity", lessThanLeft.getName());

     LiteralValue lessThanRight = lessThan.getRight();
     assertEquals("24.0", lessThanRight.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, lessThanRight.getValueType());

     BinaryOperator leftExpr = new BinaryOperator(OpType.And, greaterThanOrEquals, lessThanOrEquals);

     BinaryOperator topExpr = AlgebraicUtil.findTopExpr(resultExpr, OpType.Or);
     assertEquals(leftExpr, topExpr.getLeft());
     assertEquals(lessThan, topExpr.getRight());
   }

   @Test
   public final void testBetweenPredicate() throws CloneNotSupportedException, TajoException {
     QueryContext qc = createQueryContext();

     Expr expr = sqlAnalyzer.parse(QUERIES[3]);

     LogicalPlan plan = planner.createPlan(qc, expr);
     LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
     optimizer.optimize(plan);

     LogicalNode node = plan.getRootBlock().getRoot();
     ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

     EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
     convertor.visit(null, scanNode.getQual(), new Stack<>());

     Expr resultExpr = convertor.getResult();

     BinaryOperator binaryOperator = AlgebraicUtil.findTopExpr(resultExpr, OpType.LessThan);
     assertNotNull(binaryOperator);
     ColumnReferenceExpr column = binaryOperator.getLeft();
     assertEquals("default.lineitem", column.getQualifier());
     assertEquals("l_orderkey", column.getName());

     LiteralValue literalValue = binaryOperator.getRight();
     assertEquals("24", literalValue.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Integer, literalValue.getValueType());

     BetweenPredicate between = AlgebraicUtil.findTopExpr(resultExpr, OpType.Between);
     assertFalse(between.isNot());
     assertFalse(between.isSymmetric());

     ColumnReferenceExpr predicand = (ColumnReferenceExpr)between.predicand();
     assertEquals("default.lineitem", predicand.getQualifier());
     assertEquals("l_discount", predicand.getName());

     BinaryOperator begin = (BinaryOperator)between.begin();
     assertEquals(OpType.Minus, begin.getType());
     LiteralValue left = begin.getLeft();
     assertEquals("0.06", left.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, left.getValueType());
     LiteralValue right = begin.getRight();
     assertEquals("0.01", right.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, right.getValueType());

     BinaryOperator end = (BinaryOperator)between.end();
     assertEquals(OpType.Plus, end.getType());
     left = end.getLeft();
     assertEquals("0.08", left.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, left.getValueType());
     right = end.getRight();
     assertEquals("0.02", right.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, right.getValueType());
   }

   @Test
   public final void testCaseWhenPredicate() throws CloneNotSupportedException, TajoException {
     QueryContext qc = createQueryContext();

     Expr expr = sqlAnalyzer.parse(QUERIES[4]);

     LogicalPlan plan = planner.createPlan(qc, expr);
     LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
     optimizer.optimize(plan);

     LogicalNode node = plan.getRootBlock().getRoot();
     ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

     EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
     convertor.visit(null, scanNode.getQual(), new Stack<>());

     Expr resultExpr = convertor.getResult();

     CaseWhenPredicate caseWhen = AlgebraicUtil.findTopExpr(resultExpr, OpType.CaseWhen);
     assertNotNull(caseWhen);

     CaseWhenPredicate.WhenExpr[] whenExprs = new CaseWhenPredicate.WhenExpr[1];
     caseWhen.getWhens().toArray(whenExprs);

     BinaryOperator condition = (BinaryOperator) whenExprs[0].getCondition();
     assertEquals(OpType.GreaterThan, condition.getType());

     ColumnReferenceExpr conditionLeft = condition.getLeft();
     assertEquals("default.lineitem", conditionLeft.getQualifier());
     assertEquals("l_discount", conditionLeft.getName());

     LiteralValue conditionRight = condition.getRight();
     assertEquals("0.0", conditionRight.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, conditionRight.getValueType());

     BinaryOperator result = (BinaryOperator) whenExprs[0].getResult();
     assertEquals(OpType.Divide, result.getType());
     ColumnReferenceExpr resultLeft = result.getLeft();
     assertEquals("default.lineitem", resultLeft.getQualifier());
     assertEquals("l_discount", resultLeft.getName());

     ColumnReferenceExpr resultRight = result.getRight();
     assertEquals("default.lineitem", resultRight.getQualifier());
     assertEquals("l_tax", resultRight.getName());

     BinaryOperator greaterThan = AlgebraicUtil.findMostBottomExpr(resultExpr, OpType.GreaterThan);
     assertNotNull(greaterThan);

     assertEquals(greaterThan.getLeft(), caseWhen);

     LiteralValue binaryOperatorRight = greaterThan.getRight();
     assertEquals("1.2", binaryOperatorRight.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Float, conditionRight.getValueType());
   }

   @Test
   public final void testThreeFilters() throws CloneNotSupportedException, TajoException {
     QueryContext qc = createQueryContext();

     Expr expr = sqlAnalyzer.parse(QUERIES[5]);

     LogicalPlan plan = planner.createPlan(qc, expr);
     LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
     optimizer.optimize(plan);

     LogicalNode node = plan.getRootBlock().getRoot();
     ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

     EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
     convertor.visit(null, scanNode.getQual(), new Stack<>());

     Expr resultExpr = convertor.getResult();

     BetweenPredicate between = AlgebraicUtil.findTopExpr(resultExpr, OpType.Between);
     assertFalse(between.isNot());
     assertFalse(between.isSymmetric());

     ColumnReferenceExpr predicand = (ColumnReferenceExpr)between.predicand();
     assertEquals("default.part", predicand.getQualifier());
     assertEquals("p_size", predicand.getName());

     LiteralValue begin = (LiteralValue)between.begin();
     assertEquals("1", begin.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Integer, begin.getValueType());

     LiteralValue end = (LiteralValue)between.end();
     assertEquals("10", end.getValue());
     assertEquals(LiteralValue.LiteralType.Unsigned_Integer, end.getValueType());

     BinaryOperator equals = AlgebraicUtil.findTopExpr(resultExpr, OpType.Equals);
     assertNotNull(equals);

     ColumnReferenceExpr equalsLeft = equals.getLeft();
     assertEquals("default.part", equalsLeft.getQualifier());
     assertEquals("p_brand", equalsLeft.getName());

     LiteralValue equalsRight = equals.getRight();
     assertEquals("Brand#23", equalsRight.getValue());
     assertEquals(LiteralValue.LiteralType.String, equalsRight.getValueType());

     InPredicate inPredicate = AlgebraicUtil.findTopExpr(resultExpr, OpType.InPredicate);
     assertNotNull(inPredicate);

     ValueListExpr valueList = (ValueListExpr)inPredicate.getInValue();
     assertEquals(4, valueList.getValues().length);
     for(int i = 0; i < valueList.getValues().length; i++) {
       LiteralValue literalValue = (LiteralValue) valueList.getValues()[i];

       if (i == 0) {
         assertEquals("MED BAG", literalValue.getValue());
       } else if (i == 1) {
         assertEquals("MED BOX", literalValue.getValue());
       } else if (i == 2) {
         assertEquals("MED PKG", literalValue.getValue());
       } else {
         assertEquals("MED PACK", literalValue.getValue());
       }
     }
   }
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.tajo.engine.planner;

	import org.apache.tajo.BuiltinStorages;
	import org.apache.tajo.LocalTajoTestingUtility;
	import org.apache.tajo.QueryVars;
	import org.apache.tajo.TajoTestingCluster;
	import org.apache.tajo.algebra.*;
	import org.apache.tajo.benchmark.TPCH;
	import org.apache.tajo.catalog.*;
	import org.apache.tajo.engine.function.FunctionLoader;
	import org.apache.tajo.engine.query.QueryContext;
	import org.apache.tajo.exception.TajoException;
	import org.apache.tajo.parser.sql.SQLAnalyzer;
	import org.apache.tajo.plan.LogicalOptimizer;
	import org.apache.tajo.plan.LogicalPlan;
	import org.apache.tajo.plan.LogicalPlanner;
	import org.apache.tajo.plan.expr.AlgebraicUtil;
	import org.apache.tajo.plan.logical.LogicalNode;
	import org.apache.tajo.plan.logical.NodeType;
	import org.apache.tajo.plan.logical.ScanNode;
	import org.apache.tajo.plan.util.EvalNodeToExprConverter;
	import org.apache.tajo.plan.util.PlannerUtil;
	import org.apache.tajo.schema.IdentifierUtil;
	import org.apache.tajo.session.Session;
	import org.apache.tajo.storage.TablespaceManager;
	import org.apache.tajo.util.CommonTestingUtil;
	import org.junit.AfterClass;
	import org.junit.BeforeClass;
	import org.junit.Test;

	import java.util.Stack;

	import static org.apache.tajo.TajoConstants.DEFAULT_DATABASE_NAME;
	import static org.apache.tajo.TajoConstants.DEFAULT_TABLESPACE_NAME;
	import static org.junit.Assert.*;

	public class TestEvalNodeToExprConverter {
	private static TajoTestingCluster util;
	private static CatalogService catalog;
	private static SQLAnalyzer sqlAnalyzer;
	private static LogicalPlanner planner;
	private static TPCH tpch;
	private static Session session = LocalTajoTestingUtility.createDummySession();

	@BeforeClass
	public static void setUp() throws Exception {
	util = new TajoTestingCluster();
	util.startCatalogCluster();
	catalog = util.getCatalogService();
	catalog.createTablespace(DEFAULT_TABLESPACE_NAME, "hdfs://localhost:1234");
	catalog.createDatabase(DEFAULT_DATABASE_NAME, DEFAULT_TABLESPACE_NAME);

	for (FunctionDesc funcDesc : FunctionLoader.findLegacyFunctions()) {
	catalog.createFunction(funcDesc);
	}

	// TPC-H Schema for Complex Queries
	String [] tpchTables = {
	"part", "supplier", "partsupp", "nation", "region", "lineitem"
	};
	tpch = new TPCH();
	tpch.loadSchemas();
	tpch.loadOutSchema();
	for (String table : tpchTables) {
	TableMeta m = CatalogUtil.newTableMeta(BuiltinStorages.TEXT, util.getConfiguration());
	TableDesc d = CatalogUtil.newTableDesc(
	IdentifierUtil.buildFQName(DEFAULT_DATABASE_NAME, table), tpch.getSchema(table), m,
	CommonTestingUtil.getTestDir());
	catalog.createTable(d);
	}

	sqlAnalyzer = new SQLAnalyzer();
	planner = new LogicalPlanner(catalog, TablespaceManager.getInstance());
	}

	@AfterClass
	public static void tearDown() throws Exception {
	util.shutdownCatalogCluster();
	}

	static String[] QUERIES = {
	"select * from lineitem where L_ORDERKEY > 500", //0
	"select * from region where r_name = 'EUROPE'", //1
	"select * from lineitem where L_DISCOUNT >= 0.05 and L_DISCOUNT <= 0.07 OR L_QUANTITY < 24.0 ", //2
	"select * from lineitem where L_DISCOUNT between 0.06 - 0.01 and 0.08 + 0.02 and L_ORDERKEY < 24 ", //3
	"select * from lineitem where (case when L_DISCOUNT > 0.0 then L_DISCOUNT / L_TAX else null end) > 1.2 ", //4
	"select * from part where p_brand = 'Brand#23' and p_container in ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') " +
	"and p_size between 1 and 10", //5
	};

	private static QueryContext createQueryContext() {
	QueryContext qc = new QueryContext(util.getConfiguration(), session);
	qc.put(QueryVars.DEFAULT_SPACE_URI, "file:/");
	qc.put(QueryVars.DEFAULT_SPACE_ROOT_URI, "file:/");
	return qc;
	}

	@Test
	public final void testBinaryOperator1() throws CloneNotSupportedException, TajoException {
	QueryContext qc = createQueryContext();

	Expr expr = sqlAnalyzer.parse(QUERIES[0]);

	LogicalPlan plan = planner.createPlan(qc, expr);
	LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
	optimizer.optimize(plan);

	LogicalNode node = plan.getRootBlock().getRoot();
	ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

	EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
	convertor.visit(null, scanNode.getQual(), new Stack<>());

	Expr resultExpr = convertor.getResult();

	BinaryOperator binaryOperator = AlgebraicUtil.findTopExpr(resultExpr, OpType.GreaterThan);
	assertNotNull(binaryOperator);

	ColumnReferenceExpr column = binaryOperator.getLeft();
	assertEquals("default.lineitem", column.getQualifier());
	assertEquals("l_orderkey", column.getName());

	LiteralValue literalValue = binaryOperator.getRight();
	assertEquals("500", literalValue.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Integer, literalValue.getValueType());
	}

	@Test
	public final void testBinaryOperator2() throws CloneNotSupportedException, TajoException {
	QueryContext qc = createQueryContext();

	Expr expr = sqlAnalyzer.parse(QUERIES[1]);

	LogicalPlan plan = planner.createPlan(qc, expr);
	LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
	optimizer.optimize(plan);

	LogicalNode node = plan.getRootBlock().getRoot();
	ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

	EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
	convertor.visit(null, scanNode.getQual(), new Stack<>());

	Expr resultExpr = convertor.getResult();
	BinaryOperator equals = AlgebraicUtil.findTopExpr(resultExpr, OpType.Equals);
	assertNotNull(equals);

	ColumnReferenceExpr column = equals.getLeft();
	assertEquals("default.region", column.getQualifier());
	assertEquals("r_name", column.getName());

	LiteralValue literalValue = equals.getRight();
	assertEquals("EUROPE", literalValue.getValue());
	assertEquals(LiteralValue.LiteralType.String, literalValue.getValueType());
	}

	@Test
	public final void testBinaryOperator3() throws CloneNotSupportedException, TajoException {
	QueryContext qc = createQueryContext();

	Expr expr = sqlAnalyzer.parse(QUERIES[2]);

	LogicalPlan plan = planner.createPlan(qc, expr);
	LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
	optimizer.optimize(plan);

	LogicalNode node = plan.getRootBlock().getRoot();
	ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

	EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
	convertor.visit(null, scanNode.getQual(), new Stack<>());

	Expr resultExpr = convertor.getResult();

	BinaryOperator greaterThanOrEquals = AlgebraicUtil.findTopExpr(resultExpr, OpType.GreaterThanOrEquals);
	assertNotNull(greaterThanOrEquals);

	ColumnReferenceExpr greaterThanOrEqualsLeft = greaterThanOrEquals.getLeft();
	assertEquals("default.lineitem", greaterThanOrEqualsLeft.getQualifier());
	assertEquals("l_discount", greaterThanOrEqualsLeft.getName());

	LiteralValue greaterThanOrEqualsRight = greaterThanOrEquals.getRight();
	assertEquals("0.05", greaterThanOrEqualsRight.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, greaterThanOrEqualsRight.getValueType());

	BinaryOperator lessThanOrEquals = AlgebraicUtil.findTopExpr(resultExpr, OpType.LessThanOrEquals);
	assertNotNull(lessThanOrEquals);

	ColumnReferenceExpr lessThanOrEqualsLeft = lessThanOrEquals.getLeft();
	assertEquals("default.lineitem", lessThanOrEqualsLeft.getQualifier());
	assertEquals("l_discount", lessThanOrEqualsLeft.getName());

	LiteralValue lessThanOrEqualsRight = lessThanOrEquals.getRight();
	assertEquals("0.07", lessThanOrEqualsRight.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, lessThanOrEqualsRight.getValueType());

	BinaryOperator lessThan = AlgebraicUtil.findTopExpr(resultExpr, OpType.LessThan);
	assertNotNull(lessThan);

	ColumnReferenceExpr lessThanLeft = lessThan.getLeft();
	assertEquals("default.lineitem", lessThanLeft.getQualifier());
	assertEquals("l_quantity", lessThanLeft.getName());

	LiteralValue lessThanRight = lessThan.getRight();
	assertEquals("24.0", lessThanRight.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, lessThanRight.getValueType());

	BinaryOperator leftExpr = new BinaryOperator(OpType.And, greaterThanOrEquals, lessThanOrEquals);

	BinaryOperator topExpr = AlgebraicUtil.findTopExpr(resultExpr, OpType.Or);
	assertEquals(leftExpr, topExpr.getLeft());
	assertEquals(lessThan, topExpr.getRight());
	}

	@Test
	public final void testBetweenPredicate() throws CloneNotSupportedException, TajoException {
	QueryContext qc = createQueryContext();

	Expr expr = sqlAnalyzer.parse(QUERIES[3]);

	LogicalPlan plan = planner.createPlan(qc, expr);
	LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
	optimizer.optimize(plan);

	LogicalNode node = plan.getRootBlock().getRoot();
	ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

	EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
	convertor.visit(null, scanNode.getQual(), new Stack<>());

	Expr resultExpr = convertor.getResult();

	BinaryOperator binaryOperator = AlgebraicUtil.findTopExpr(resultExpr, OpType.LessThan);
	assertNotNull(binaryOperator);
	ColumnReferenceExpr column = binaryOperator.getLeft();
	assertEquals("default.lineitem", column.getQualifier());
	assertEquals("l_orderkey", column.getName());

	LiteralValue literalValue = binaryOperator.getRight();
	assertEquals("24", literalValue.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Integer, literalValue.getValueType());

	BetweenPredicate between = AlgebraicUtil.findTopExpr(resultExpr, OpType.Between);
	assertFalse(between.isNot());
	assertFalse(between.isSymmetric());

	ColumnReferenceExpr predicand = (ColumnReferenceExpr)between.predicand();
	assertEquals("default.lineitem", predicand.getQualifier());
	assertEquals("l_discount", predicand.getName());

	BinaryOperator begin = (BinaryOperator)between.begin();
	assertEquals(OpType.Minus, begin.getType());
	LiteralValue left = begin.getLeft();
	assertEquals("0.06", left.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, left.getValueType());
	LiteralValue right = begin.getRight();
	assertEquals("0.01", right.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, right.getValueType());

	BinaryOperator end = (BinaryOperator)between.end();
	assertEquals(OpType.Plus, end.getType());
	left = end.getLeft();
	assertEquals("0.08", left.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, left.getValueType());
	right = end.getRight();
	assertEquals("0.02", right.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, right.getValueType());
	}

	@Test
	public final void testCaseWhenPredicate() throws CloneNotSupportedException, TajoException {
	QueryContext qc = createQueryContext();

	Expr expr = sqlAnalyzer.parse(QUERIES[4]);

	LogicalPlan plan = planner.createPlan(qc, expr);
	LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
	optimizer.optimize(plan);

	LogicalNode node = plan.getRootBlock().getRoot();
	ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

	EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
	convertor.visit(null, scanNode.getQual(), new Stack<>());

	Expr resultExpr = convertor.getResult();

	CaseWhenPredicate caseWhen = AlgebraicUtil.findTopExpr(resultExpr, OpType.CaseWhen);
	assertNotNull(caseWhen);

	CaseWhenPredicate.WhenExpr[] whenExprs = new CaseWhenPredicate.WhenExpr[1];
	caseWhen.getWhens().toArray(whenExprs);

	BinaryOperator condition = (BinaryOperator) whenExprs[0].getCondition();
	assertEquals(OpType.GreaterThan, condition.getType());

	ColumnReferenceExpr conditionLeft = condition.getLeft();
	assertEquals("default.lineitem", conditionLeft.getQualifier());
	assertEquals("l_discount", conditionLeft.getName());

	LiteralValue conditionRight = condition.getRight();
	assertEquals("0.0", conditionRight.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, conditionRight.getValueType());

	BinaryOperator result = (BinaryOperator) whenExprs[0].getResult();
	assertEquals(OpType.Divide, result.getType());
	ColumnReferenceExpr resultLeft = result.getLeft();
	assertEquals("default.lineitem", resultLeft.getQualifier());
	assertEquals("l_discount", resultLeft.getName());

	ColumnReferenceExpr resultRight = result.getRight();
	assertEquals("default.lineitem", resultRight.getQualifier());
	assertEquals("l_tax", resultRight.getName());

	BinaryOperator greaterThan = AlgebraicUtil.findMostBottomExpr(resultExpr, OpType.GreaterThan);
	assertNotNull(greaterThan);

	assertEquals(greaterThan.getLeft(), caseWhen);

	LiteralValue binaryOperatorRight = greaterThan.getRight();
	assertEquals("1.2", binaryOperatorRight.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Float, conditionRight.getValueType());
	}

	@Test
	public final void testThreeFilters() throws CloneNotSupportedException, TajoException {
	QueryContext qc = createQueryContext();

	Expr expr = sqlAnalyzer.parse(QUERIES[5]);

	LogicalPlan plan = planner.createPlan(qc, expr);
	LogicalOptimizer optimizer = new LogicalOptimizer(util.getConfiguration(), catalog, TablespaceManager.getInstance());
	optimizer.optimize(plan);

	LogicalNode node = plan.getRootBlock().getRoot();
	ScanNode scanNode = PlannerUtil.findTopNode(node, NodeType.SCAN);

	EvalNodeToExprConverter convertor = new EvalNodeToExprConverter(scanNode.getTableName());
	convertor.visit(null, scanNode.getQual(), new Stack<>());

	Expr resultExpr = convertor.getResult();

	BetweenPredicate between = AlgebraicUtil.findTopExpr(resultExpr, OpType.Between);
	assertFalse(between.isNot());
	assertFalse(between.isSymmetric());

	ColumnReferenceExpr predicand = (ColumnReferenceExpr)between.predicand();
	assertEquals("default.part", predicand.getQualifier());
	assertEquals("p_size", predicand.getName());

	LiteralValue begin = (LiteralValue)between.begin();
	assertEquals("1", begin.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Integer, begin.getValueType());

	LiteralValue end = (LiteralValue)between.end();
	assertEquals("10", end.getValue());
	assertEquals(LiteralValue.LiteralType.Unsigned_Integer, end.getValueType());

	BinaryOperator equals = AlgebraicUtil.findTopExpr(resultExpr, OpType.Equals);
	assertNotNull(equals);

	ColumnReferenceExpr equalsLeft = equals.getLeft();
	assertEquals("default.part", equalsLeft.getQualifier());
	assertEquals("p_brand", equalsLeft.getName());

	LiteralValue equalsRight = equals.getRight();
	assertEquals("Brand#23", equalsRight.getValue());
	assertEquals(LiteralValue.LiteralType.String, equalsRight.getValueType());

	InPredicate inPredicate = AlgebraicUtil.findTopExpr(resultExpr, OpType.InPredicate);
	assertNotNull(inPredicate);

	ValueListExpr valueList = (ValueListExpr)inPredicate.getInValue();
	assertEquals(4, valueList.getValues().length);
	for(int i = 0; i < valueList.getValues().length; i++) {
	LiteralValue literalValue = (LiteralValue) valueList.getValues()[i];

	if (i == 0) {
	assertEquals("MED BAG", literalValue.getValue());
	} else if (i == 1) {
	assertEquals("MED BOX", literalValue.getValue());
	} else if (i == 2) {
	assertEquals("MED PKG", literalValue.getValue());
	} else {
	assertEquals("MED PACK", literalValue.getValue());
	}
	}
	}
	}