lens-cube/src/test/java/org/apache/lens/cube/parse/TestHQLParser.java

/**
 * 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.lens.cube.parse;

import static org.apache.lens.cube.parse.HQLParser.getString;
import static org.apache.lens.cube.parse.HQLParser.parseExpr;
import static org.apache.lens.cube.parse.HQLParser.trimHavingAst;
import static org.apache.lens.cube.parse.HQLParser.trimOrderByAst;

import static org.apache.hadoop.hive.ql.parse.HiveParser.*;

import static com.google.common.collect.Lists.newArrayList;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

import org.apache.lens.cube.error.LensCubeErrorCode;
import org.apache.lens.server.api.error.LensException;

import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.ql.parse.ASTNode;
import org.apache.hadoop.hive.ql.parse.HiveParser;
import org.apache.hadoop.hive.ql.parse.ParseException;
import org.apache.hadoop.hive.ql.session.SessionState;

import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class TestHQLParser {

  HiveConf conf = new HiveConf();

  {
    conf.setBoolVar(HiveConf.ConfVars.HIVE_SUPPORT_SQL11_RESERVED_KEYWORDS, false);
    SessionState.start(conf);
  }

  @Test
  public void testGroupByOrderByGetString() throws Exception {
    String query = "SELECT a,b, sum(c) FROM tab GROUP BY a,f(b), d+e ORDER BY a, g(b), e/100";
    ASTNode node = HQLParser.parseHQL(query, conf);

    ASTNode groupby = HQLParser.findNodeByPath(node, TOK_INSERT, TOK_GROUPBY);

    String expected = "a, f(b), (d + e)";
    Assert.assertEquals(HQLParser.getString(groupby).trim(), expected);

    ASTNode orderby = HQLParser.findNodeByPath(node, TOK_INSERT, HiveParser.TOK_ORDERBY);

    String expectedOrderBy = "a asc, g(b) asc, e / 100 asc";
    System.out.println("###Actual order by:" + HQLParser.getString(orderby).trim());
    Assert.assertEquals(expectedOrderBy, HQLParser.getString(orderby).trim());
  }

  @Test
  public void testLiteralCaseIsPreserved() throws Exception {
    String literalQuery = "SELECT 'abc' AS col1, 'DEF' AS col2 FROM foo where col3='GHI' " + "AND col4 = 'JKLmno'";

    ASTNode tree = HQLParser.parseHQL(literalQuery, conf);

    ASTNode select = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    String selectStr = HQLParser.getString(select).trim();
    String expectedSelect = "'abc' as `col1`, 'DEF' as `col2`";
    Assert.assertEquals(selectStr, expectedSelect);

    ASTNode where = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_WHERE);
    String whereStr = HQLParser.getString(where).trim();
    String expectedWhere = "((col3 = 'GHI') and (col4 = 'JKLmno'))";
    Assert.assertEquals(whereStr, expectedWhere);
  }

  @Test
  public void testCaseStatementGetString() throws Exception {
    String query = "SELECT  " + "CASE (col1 * 100)/200 + 5 WHEN 'ABC' THEN 'def'WHEN 'EFG' THEN 'hij' "
      + "ELSE 'XyZ' END AS ComplexCaseStatement FROM FOO";

    ASTNode tree = HQLParser.parseHQL(query, conf);
    ASTNode select = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    String selectStr = HQLParser.getString(select);
    System.out.println("reconstructed clause ");
    System.out.println(selectStr);
    Assert.assertEquals(selectStr.trim(), "case (((col1 * 100) / 200) + 5) when 'ABC' then 'def' when 'EFG' "
      + "then 'hij' else 'XyZ' end as `ComplexCaseStatement`");

    String q2 = "SELECT " + "CASE WHEN col1 = 'abc' then 'def' when col1 = 'ghi' then 'jkl' "
      + "else 'none' END AS Complex_Case_Statement_2" + " from FOO";

    tree = HQLParser.parseHQL(q2, conf);
    select = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    selectStr = HQLParser.getString(select);
    System.out.println("reconstructed clause 2");
    System.out.println(selectStr);

    Assert.assertEquals(selectStr.trim(), "case  when (col1 = 'abc') then 'def' when (col1 = 'ghi') then 'jkl' "
      + "else 'none' end as `Complex_Case_Statement_2`");

    String q3 = "SELECT  " + "CASE (col1 * 100)/200 + 5 " + "WHEN 'ABC' THEN 'def' " + "WHEN 'EFG' THEN 'hij' "
      + "END AS ComplexCaseStatement FROM FOO";

    tree = HQLParser.parseHQL(q3, conf);
    select = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    selectStr = HQLParser.getString(select);
    System.out.println("reconstructed clause ");
    System.out.println(selectStr);
    Assert.assertEquals(selectStr.trim(), "case (((col1 * 100) / 200) + 5) when 'ABC' then 'def' when 'EFG' "
      + "then 'hij' end as `ComplexCaseStatement`");

    String q4 = "SELECT " + "CASE WHEN col1 = 'abc' then 'def' when col1 = 'ghi' then 'jkl' "
      + "END AS Complex_Case_Statement_2" + " from FOO";

    tree = HQLParser.parseHQL(q4, conf);
    select = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    selectStr = HQLParser.getString(select);
    System.out.println("reconstructed clause 2");
    System.out.println(selectStr);
    Assert.assertEquals(selectStr.trim(), "case  when (col1 = 'abc') then 'def' when (col1 = 'ghi') then 'jkl' end "
      + "as `Complex_Case_Statement_2`");

  }

  @Test
  public void testIsNullCondition() throws Exception {
    String q1 = "SELECT * FROM FOO WHERE col1 IS NULL";
    ASTNode where = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_WHERE);
    String whereStr = HQLParser.getString(where);
    Assert.assertEquals(whereStr.trim(), "col1 is null");

    String q2 = "SELECT * FROM FOO WHERE col1 IS NULL and col2 is not null";
    where = HQLParser.findNodeByPath(HQLParser.parseHQL(q2, conf), TOK_INSERT, TOK_WHERE);
    whereStr = HQLParser.getString(where);
    Assert.assertEquals(whereStr.trim(), "(col1 is null and col2 is not null)");
  }

  @Test
  public void testIsNotNullCondition() throws Exception {
    String q1 = "SELECT * FROM FOO WHERE col1 IS NOT NULL";
    ASTNode where = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_WHERE);
    String whereStr = HQLParser.getString(where);
    System.out.println(whereStr);
    Assert.assertEquals(whereStr.trim(), "col1 is not null");
  }

  @Test
  public void testBetweenCondition() throws Exception {
    String q1 = "SELECT * FROM FOO WHERE col1 BETWEEN 10 AND 100";
    ASTNode where = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_WHERE);
    String whereStr = HQLParser.getString(where);
    System.out.println(whereStr);
    Assert.assertEquals(whereStr.trim(), "col1 between 10 and 100");
  }

  @Test
  public void testNotBetweenCondition() throws Exception {
    String q1 = "SELECT * FROM FOO WHERE col1 NOT BETWEEN 10 AND 100";
    ASTNode where = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_WHERE);
    String whereStr = HQLParser.getString(where);
    System.out.println(whereStr);
    Assert.assertEquals(whereStr.trim(), "col1 not between 10 and 100");
  }

  @Test
  public void testBinaryOperators() throws Exception {
    String q1 = "SELECT * FROM FOO WHERE " + "(A <=> 10) AND (B & C = 10) AND (D | E = 10) "
      + "AND (F ^ G = 10) AND (H % 2 = 1) AND  (~I = 10)" + "AND (!J) AND (NOT K) AND TRUE AND FALSE";

    ASTNode where = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_WHERE);
    String whereStr = HQLParser.getString(where);

    String expected = "((a <=> 10) and ((b & c) = 10) and ((d | e) = 10) and ((f ^ g) = 10) and "
      + "((h % 2) = 1) and ( ~i = 10) and  not j and  not k and  true  and  false )";
    Assert.assertEquals(whereStr.trim(), expected);
  }

  @Test
  public void testCompelxTypeOperators() throws Exception {
    String q1 = "SELECT A[2], B['key'], C.D FROM FOO";

    ASTNode select = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_SELECT);
    String selectStr = HQLParser.getString(select);
    System.out.println(selectStr);
    Assert.assertEquals(selectStr.trim(), "a[2], b['key'], (c.d)");
  }

  @Test
  public void testInAndNotInOperator() throws Exception {
    String q1 = "SELECT * FROM FOO WHERE A IN ('B', 'C', 'D', 'E', 'F')";
    ASTNode where = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_WHERE);
    String whereStr = HQLParser.getString(where);
    System.out.println(whereStr);
    Assert.assertEquals(whereStr.trim(), "a in ('B' , 'C' , 'D' , 'E' , 'F')");

    q1 = "SELECT * FROM FOO WHERE A NOT IN ('B', 'C', 'D', 'E', 'F')";
    where = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_WHERE);
    whereStr = HQLParser.getString(where);
    System.out.println(whereStr);
    Assert.assertEquals(whereStr.trim(), "a not  in ('B' , 'C' , 'D' , 'E' , 'F')");
  }

  @Test
  public void testLiteralWithSpaces() throws Exception {
    String q1 = "SELECT * FROM FOO WHERE A IN ('B  X', 'C  Y', 'D Z', 'E', 'F')";
    ASTNode where = HQLParser.findNodeByPath(HQLParser.parseHQL(q1, conf), TOK_INSERT, TOK_WHERE);
    String whereStr = HQLParser.getString(where);
    System.out.println(whereStr);
    System.out.println("HQLParser.parseHQL(q1, conf)" + HQLParser.parseHQL(q1, conf).dump());
    System.out.println("where dump:" + where.dump());
    Assert.assertEquals(whereStr.trim(), "a in ('B  X' , 'C  Y' , 'D Z' , 'E' , 'F')");
  }

  @Test
  public void testOrderbyBrackets() throws Exception {
    String query = "SELECT id from citytable order by (citytable.id) asc";
    // String hql = rewrite(driver, query);
    ASTNode tree = HQLParser.parseHQL(query, conf);
    ASTNode orderByTree = HQLParser.findNodeByPath(tree, TOK_INSERT, HiveParser.TOK_ORDERBY);
    String reconstructed = HQLParser.getString(orderByTree);
    System.out.println("RECONSTRUCTED0:" + reconstructed);
    Assert.assertEquals(reconstructed, "citytable.id asc");
    String query3 = "SELECT id, name from citytable order by citytable.id asc, citytable.name desc";
    tree = HQLParser.parseHQL(query3, conf);
    orderByTree = HQLParser.findNodeByPath(tree, TOK_INSERT, HiveParser.TOK_ORDERBY);
    reconstructed = HQLParser.getString(orderByTree);
    System.out.println("RECONSTRUCTED2:" + reconstructed);
    Assert.assertEquals(reconstructed, "citytable.id asc, citytable.name desc");
  }

  @Test
  public void testInnerJoin() throws Exception {
    String query
      = "select tab1.a, tab2.b from table1 tab1 inner join table tab2 on tab1.id = tab2.id where tab1.a > 123";
    ASTNode node = HQLParser.parseHQL(query, conf);
    ASTNode temp = HQLParser.findNodeByPath(node, TOK_FROM, TOK_JOIN);
    String expected = "table1tab1tabletab2((tab1.id) = (tab2.id))";
    Assert.assertEquals(HQLParser.getString(temp), expected);
  }

  @Test
  public void testAliasWithSpaces() throws Exception {
    String query = "select id as `an id` from sample_dim";
    try {
      ASTNode tree = HQLParser.parseHQL(query, conf);
      Assert.assertNotNull(tree);
    } catch (NullPointerException exc) {
      log.error("should not have thrown npe", exc);
      Assert.fail("should not have thrown npe");
    }
  }

  @Test
  public void testAliasShouldBeQuoted() throws Exception {
    Assert.assertEquals(getSelectStrForQuery("select id as identity from sample_dim"), "id as `identity`");
    Assert.assertEquals(getSelectStrForQuery("select id as `column identity` from sample_dim"),
      "id as `column identity`");
    Assert.assertEquals(getSelectStrForQuery("select id identity from sample_dim"), "id as `identity`");
    Assert.assertEquals(getSelectStrForQuery("select id `column identity` from sample_dim"),
      "id as `column identity`");
  }

  private String getSelectStrForQuery(String query) throws Exception {
    ASTNode tree = HQLParser.parseHQL(query, conf);
    ASTNode select = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    return HQLParser.getString(select).trim();
  }

  @Test
  public void testAllColumns() throws Exception {
    String query = "select * from tab";
    ASTNode select = HQLParser.findNodeByPath(HQLParser.parseHQL(query, conf), TOK_INSERT, TOK_SELECT);
    String selectStr = HQLParser.getString(select);
    System.out.println(selectStr);
    Assert.assertEquals(selectStr, "*");

    query = "select tab.*, tab2.a, tab2.b from tab";
    ASTNode ast = HQLParser.parseHQL(query, conf);
    select = HQLParser.findNodeByPath(ast, TOK_INSERT, TOK_SELECT);
    selectStr = HQLParser.getString(select);
    System.out.println(selectStr);
    Assert.assertEquals(selectStr, "tab.*, (tab2.a), (tab2.b)");

    query = "select count(*) from tab";
    ast = HQLParser.parseHQL(query, conf);
    select = HQLParser.findNodeByPath(ast, TOK_INSERT, TOK_SELECT);
    selectStr = HQLParser.getString(select);
    System.out.println(selectStr);
    Assert.assertEquals("count(*)", selectStr);

    query = "select count(tab.*) from tab";
    ast = HQLParser.parseHQL(query, conf);
    select = HQLParser.findNodeByPath(ast, TOK_INSERT, TOK_SELECT);
    selectStr = HQLParser.getString(select);
    System.out.println(selectStr);
    Assert.assertEquals("count(tab.*)", selectStr);
  }

  @Test
  public void testNegativeLiteral() throws Exception {
    String query1 = "select 2-1 as col1,col2 from table1";
    ASTNode tree = HQLParser.parseHQL(query1, conf);
    ASTNode selectAST = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    HQLParser.printAST(selectAST);
    String genQuery = HQLParser.getString(selectAST);
    System.out.println("genQuery1: " + genQuery);

    String query2 = "select -1 as col1,col2 from table1";
    tree = HQLParser.parseHQL(query2, conf);
    selectAST = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    HQLParser.printAST(selectAST);
    String genQuery2 = HQLParser.getString(selectAST);
    System.out.println("genQuery2: " + genQuery2);

    Assert.assertFalse(genQuery2.contains("1 -"));
    Assert.assertTrue(genQuery2.contains("-1"));

    // Validate returned string is parseable
    HQLParser.printAST(HQLParser.findNodeByPath(HQLParser.parseHQL("SELECT " + genQuery2 + " FROM table1", conf),
      TOK_INSERT,
      TOK_SELECT));
  }

  @Test
  public void testEqualsAST() throws Exception {
    ASTNode expr1 = parseExpr("T1.a + T2.b - T2.c");
    ASTNode expr2 = parseExpr("t1.A + t2.B - t2.C");

    Assert.assertTrue(HQLParser.equalsAST(expr1, expr2));

    ASTNode literalExpr1 = parseExpr("A = 'FooBar'");
    ASTNode literalExpr2 = parseExpr("a = 'FooBar'");
    Assert.assertTrue(HQLParser.equalsAST(literalExpr1, literalExpr2));

    ASTNode literalExpr3 = parseExpr("A = 'fOObAR'");
    Assert.assertFalse(HQLParser.equalsAST(literalExpr1, literalExpr3));

    ASTNode literalExpr4 = parseExpr("A <> 'FooBar'");
    Assert.assertFalse(HQLParser.equalsAST(literalExpr1, literalExpr4));
  }

  @Test
  public void testCastStatement() throws ParseException, LensException {
    String castSelect = "cast(( a  +  b ) as tinyint), cast(( a  +  b ) as smallint), cast(( a  +  b ) as int),"
      + " cast(( a  +  b ) as bigint), cast(( a  +  b ) as float), cast(( a  +  b ) as double),"
      + " cast(( a  +  b ) as boolean), cast( a  as date), cast( b  as datetime), cast( a  as timestamp),"
      + " cast(( a  +  b ) as string), cast(( a  +  b ) as binary), cast(( a  +  b ) as decimal(3,6)),"
      + " cast(( a  +  b ) as decimal(5)), cast(( a  +  b ) as varchar(10)), cast(( a  +  b ) as char(20)),"
      + " cast( '17.29'  as decimal(4,2))";
    castSelect = "3.1415926BD";
    String query = "select " + castSelect + " from table limit 1";
    ASTNode tree = HQLParser.parseHQL(query, conf);
    System.out.println(tree.dump());
    ASTNode selectAST = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    String genQuery = HQLParser.getString(selectAST);
    Assert.assertEquals(genQuery, castSelect);
  }

  @Test
  public void testOtherStatements() throws ParseException, LensException {
    String select = "3.1415926BD";
    String query = "select " + select + " from table limit 1";
    ASTNode tree = HQLParser.parseHQL(query, conf);
    ASTNode selectAST = HQLParser.findNodeByPath(tree, TOK_INSERT, TOK_SELECT);
    String genQuery = HQLParser.getString(selectAST);
    Assert.assertEquals(genQuery, select);
  }

  @DataProvider
  public Object[][] nAryFlatteningDataProvider() {
    return new Object[][]{
      {"a", "a"},
      {"a or b", "a or b"},
      {"a or b or c or d", "a or b or c or d"},
      {"a and b and c and d", "a and b and c and d"},
      {"a and (b or c)", "a and (b or c)"},
      {"a and (b or c or d) and (e or f) and (g and h)", "a and (b or c or d) and (e or f) and g and h"},
      // ambiguous, but uniquely understood, and > or.
      {"a and b or c or d and e or f and g and h", "(a and b) or c or (d and e) or (f and g and h)"},
    };
  }

  @Test(dataProvider = "nAryFlatteningDataProvider")
  public void testNAryOperatorFlattening(String input, String expected) throws LensException {
    ASTNode tree = parseExpr(input);
    String infixString = HQLParser.getString(tree);
    Assert.assertEquals(infixString, expected);
  }

  @DataProvider
  public Object[][] colsInExpr() {
    return new Object[][]{
      {" t1.c1", new String[]{}}, // simple selection
      {" cie.c5", new String[]{"c5"}}, // simple selection
      {" fun1(cie.c4)", new String[]{"c4"}}, // simple selection
      {" t1.c1 + cie.c5+ t2.c3", new String[]{"c5"}}, // simple selection
      {" t1.c1=x and cie.c2=y", new String[]{"c2"}}, //filter expression
      {"case when t1.c1 then 1 when cie.c3 then 2 when cie.c4 then 3 when t2.c2 then 4 else cie.c6 end",
        new String[]{"c3", "c4", "c6", }, },  // case when statement
      {"complexfunc(round(t1.c1), myfunc(t2.c2), myfunc2(cie.c4, cie.c5, t2.c6))", new String[]{"c4", "c5"}},
    };
  }

  @Test(dataProvider = "colsInExpr")
  public void testColsInExpr(String input, String[] expected) throws Exception {
    String tableAlias = "cie";
    ASTNode inputAST = parseExpr(input);
    Set<String> actual = HQLParser.getColsInExpr(tableAlias, inputAST);
    Set<String> expectedSet = new HashSet<>(Arrays.asList(expected));
    Assert.assertEquals(actual, expectedSet, "Received " + actual + " for input:" + input);
  }

  @Test
  public void testGetDotAST() {
    Assert.assertEquals(HQLParser.getString(HQLParser.getDotAST("tbl1", "col1")), "(tbl1.col1)");
  }

  @DataProvider
  public Object[][] primitiveBool() {
    return new Object[][]{
      {" t1.c1", false},
      {" t1.c1 = 24", true},
      {" t1.c1 >= 24", true},
      {" t1.c1 <= 24", true},
      {" t1.c1 <=> 24", true},
      {" t1.c1 != 24", true},
      {" t1.c1 < 24", true},
      {" t1.c1 > 24", true},
      {" fun1(cie.c4)", false},
      {" arraycontains(arr1, v1)", false},
      {" t1.c1=x and cie.c2=y", false},
      {" t1.col1 in ('x', 'y', 'z')", false},
    };
  }

  @Test(dataProvider = "primitiveBool")
  public void testIsPrimitiveBooleanExpr(String input, boolean expected) throws Exception {
    ASTNode inputAST = parseExpr(input);
    boolean actual = HQLParser.isPrimitiveBooleanExpression(inputAST);
    Assert.assertEquals(actual, expected, "Received " + actual + " for input:" + input + ":" + inputAST.dump());
  }

  @DataProvider
  public Object[][] primitiveBoolFunc() {
    return new Object[][]{
      {" t1.c1", false},
      {" t1.c1 = 24", false},
      {" t1.c1 >= 24", false},
      {" t1.c1 <= 24", false},
      {" t1.c1 <=> 24", false},
      {" t1.c1 != 24", false},
      {" t1.c1 < 24", false},
      {" t1.c1 > 24", false},
      {" fun1(cie.c4)", false},
      {" arraycontains(arr1, v1)", false},
      {" t1.c1=x and cie.c2=y", false},
      {" t1.col1 in ('x', 'y', 'z')", true},
    };
  }

  @Test(dataProvider = "primitiveBoolFunc")
  public void testIsPrimitiveBooleanFunction(String input, boolean expected) throws Exception {
    ASTNode inputAST = parseExpr(input);
    boolean actual = HQLParser.isPrimitiveBooleanFunction(inputAST);
    Assert.assertEquals(actual, expected, "Received " + actual + " for input:" + input);
  }

  @DataProvider
  public Object[][] dirDataProvider() {
    return new Object[][]{
      {"directory 'a'"},
      {"local directory 'a'"},
    };
  }

  @Test(dataProvider = "dirDataProvider")
  public void testLocalDirectory(String dirString) throws LensException {
    String expr = "insert overwrite " + dirString + " select * from table";
    ASTNode tree = HQLParser.parseHQL(expr, conf);
    Assert.assertEquals(HQLParser.getString((ASTNode) tree.getChild(1).getChild(0)), dirString);
  }

  @DataProvider
  public Object[][] exprDataProvider() {
    return new Object[][] {
      {"a.b", null, true},
      {"a.date", null, false},
      {"a.date", conf, true},
    };
  }

  @Test(dataProvider = "exprDataProvider")
  public void testParseExpr(String expr, HiveConf conf, boolean success) {
    try {
      parseExpr(expr, conf);
      Assert.assertTrue(success);
    } catch (LensException e) {
      Assert.assertFalse(success);
      Assert.assertTrue(e.getMessage().contains(expr));
      Assert.assertTrue(e.getMessage().contains(LensCubeErrorCode.COULD_NOT_PARSE_EXPRESSION.name()));
    }
  }
  @DataProvider
  public Object[][] havingTrimDataProvider() {
    return new Object[][] {
      {"((sum((testcube.segmsr1)) > 1) and (sum((testcube.msr2)) > 2))", newArrayList("segmsr1"),
        "(sum((testcube.segmsr1)) > 1)", },
      {"(sum((testcube.msr2)) > 2)", newArrayList("segmsr1"), null, },
      {"(sum((testcube.segmsr1)) > 1)", newArrayList("segmsr1"), "(sum((testcube.segmsr1)) > 1)", },
    };
  }

  @Test(dataProvider = "havingTrimDataProvider")
  public void testHavingTrim(String expr, Collection<String> columns, String expected) throws LensException {
    ASTNode actualAst = trimHavingAst(parseExpr(expr), columns);
    ASTNode expectedAst = expected == null ? null : parseExpr(expected);
    if (!HQLParser.equalsAST(actualAst, expectedAst)) {
      Assert.assertEquals(getString(actualAst), expected);
    }
  }
  @DataProvider
  public Object[][] orderByTrimDataProvider() {
    return new Object[][] {
      {"testcube.segmsr1 asc", newArrayList("segmsr1"), "testcube.segmsr1 asc", },
      {"testcube.segmsr1 desc, testcube.msr2", newArrayList("segmsr1"), "testcube.segmsr1 desc", },
      {"testcube.segmsr1, testcube.msr2 desc", newArrayList("segmsr1"), "testcube.segmsr1 asc", },
      {"testcube.msr2 desc", newArrayList("segmsr1"), "", },
    };
  }

  @Test(dataProvider = "orderByTrimDataProvider")
  public void testOrderByTrim(String expr, Collection<String> columns, String expected) throws LensException {
    String query = "select * from testcube order by " + expr;
    ASTNode queryAst = HQLParser.parseHQL(query, conf);
    ASTNode orderByAST = HQLParser.findNodeByPath(queryAst, TOK_INSERT, TOK_ORDERBY);
    ASTNode actualAst = trimOrderByAst(orderByAST, columns);
    Assert.assertEquals(getString(actualAst), expected);
  }
}