You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lens.apache.org by pr...@apache.org on 2017/04/12 13:03:53 UTC
[10/20] lens git commit: LENS-1381: Support Fact to Fact Union
http://git-wip-us.apache.org/repos/asf/lens/blob/ae83caae/lens-cube/src/test/java/org/apache/lens/cube/parse/TestBaseCubeQueries.java
----------------------------------------------------------------------
diff --git a/lens-cube/src/test/java/org/apache/lens/cube/parse/TestBaseCubeQueries.java b/lens-cube/src/test/java/org/apache/lens/cube/parse/TestBaseCubeQueries.java
index dbb8fa3..93dbfc3 100644
--- a/lens-cube/src/test/java/org/apache/lens/cube/parse/TestBaseCubeQueries.java
+++ b/lens-cube/src/test/java/org/apache/lens/cube/parse/TestBaseCubeQueries.java
@@ -31,15 +31,12 @@ import static org.apache.hadoop.hive.ql.parse.HiveParser.KW_AND;
import static org.testng.Assert.*;
import java.util.*;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
import org.apache.lens.api.error.ErrorCollectionFactory;
import org.apache.lens.cube.error.LensCubeErrorCode;
import org.apache.lens.cube.error.NoCandidateFactAvailableException;
import org.apache.lens.cube.metadata.TimeRange;
import org.apache.lens.cube.metadata.UpdatePeriod;
-import org.apache.lens.cube.parse.CandidateTablePruneCause.CandidateTablePruneCode;
import org.apache.lens.server.api.error.LensException;
import org.apache.commons.lang.time.DateUtils;
@@ -52,7 +49,6 @@ import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import com.google.common.base.Splitter;
-import com.google.common.collect.Sets;
import lombok.Getter;
public class TestBaseCubeQueries extends TestQueryRewrite {
@@ -71,21 +67,17 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
}
@Test
- public void testNoCandidateFactAvailableExceptionCompareTo() throws Exception {
- //maxCause : COLUMN_NOT_FOUND, Ordinal : 9
- NoCandidateFactAvailableException ne1 =(NoCandidateFactAvailableException)
- getLensExceptionInRewrite("select dim1, test_time_dim, msr3, msr13 from basecube where "
- + TWO_DAYS_RANGE, conf);
- //maxCause : FACT_NOT_AVAILABLE_IN_RANGE, Ordinal : 1
- NoCandidateFactAvailableException ne2 = (NoCandidateFactAvailableException)
- getLensExceptionInRewrite("select dim1 from " + cubeName + " where " + LAST_YEAR_RANGE, getConf());
- assertEquals(ne1.compareTo(ne2), 8);
+ public void testNoUnionCandidateAndNoJoinCandidateErrorWeight() throws Exception {
+ LensException e1 = getLensExceptionInRewrite(
+ "select dim1, test_time_dim, msr3, msr13 from basecube where " + TWO_DAYS_RANGE, conf);
+ LensException e2 = getLensExceptionInRewrite("select dim1 from " + cubeName
+ + " where " + LAST_YEAR_RANGE, getConf());
+ assertEquals(e1.getErrorWeight() - e2.getErrorWeight(), 1);
}
@Test
public void testColumnErrors() throws Exception {
LensException e;
-
e = getLensExceptionInRewrite("select msr11 + msr2 from basecube" + " where " + TWO_DAYS_RANGE, conf);
e.buildLensErrorResponse(new ErrorCollectionFactory().createErrorCollection(), null, "testid");
assertEquals(e.getErrorCode(),
@@ -96,43 +88,9 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
e = getLensExceptionInRewrite("select dim1, test_time_dim, msr3, msr13 from basecube where "
+ TWO_DAYS_RANGE, conf);
assertEquals(e.getErrorCode(),
- LensCubeErrorCode.NO_CANDIDATE_FACT_AVAILABLE.getLensErrorInfo().getErrorCode());
- NoCandidateFactAvailableException ne = (NoCandidateFactAvailableException) e;
- PruneCauses.BriefAndDetailedError pruneCauses = ne.getJsonMessage();
- String regexp = String.format(CandidateTablePruneCause.CandidateTablePruneCode.COLUMN_NOT_FOUND.errorFormat,
- "Column Sets: (.*?)", "queriable together");
- Matcher matcher = Pattern.compile(regexp).matcher(pruneCauses.getBrief());
- assertTrue(matcher.matches(), pruneCauses.getBrief());
- assertEquals(matcher.groupCount(), 1);
- String columnSetsStr = matcher.group(1);
- assertNotEquals(columnSetsStr.indexOf("test_time_dim"), -1, columnSetsStr);
- assertNotEquals(columnSetsStr.indexOf("msr3, msr13"), -1);
-
- /**
- * Verifying the BriefAndDetailedError:
- * 1. Check for missing columns(COLUMN_NOT_FOUND)
- * and check the respective tables for each COLUMN_NOT_FOUND
- * 2. check for ELEMENT_IN_SET_PRUNED
- *
- */
- boolean columnNotFound = false;
- List<String> testTimeDimFactTables = Arrays.asList("testfact3_base", "testfact1_raw_base", "testfact3_raw_base",
- "testfact5_base", "testfact6_base", "testfact4_raw_base");
- List<String> factTablesForMeasures = Arrays.asList("testfact_deprecated", "testfact2_raw_base", "testfact2_base",
- "testfact5_raw_base");
- for (Map.Entry<String, List<CandidateTablePruneCause>> entry : pruneCauses.getDetails().entrySet()) {
- if (entry.getValue().contains(CandidateTablePruneCause.columnNotFound("test_time_dim"))) {
- columnNotFound = true;
- compareStrings(testTimeDimFactTables, entry);
- }
- if (entry.getValue().contains(CandidateTablePruneCause.columnNotFound("msr3", "msr13"))) {
- columnNotFound = true;
- compareStrings(factTablesForMeasures, entry);
- }
- }
- Assert.assertTrue(columnNotFound);
- assertEquals(pruneCauses.getDetails().get("testfact1_base"),
- Arrays.asList(new CandidateTablePruneCause(CandidateTablePruneCode.ELEMENT_IN_SET_PRUNED)));
+ LensCubeErrorCode.NO_JOIN_CANDIDATE_AVAILABLE.getLensErrorInfo().getErrorCode());
+ assertTrue(e.getMessage().contains("[msr3, msr13]"));
+
}
private void compareStrings(List<String> factTablesList, Map.Entry<String, List<CandidateTablePruneCause>> entry) {
@@ -147,117 +105,116 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
public void testCommonDimensions() throws Exception {
String hqlQuery = rewrite("select dim1, SUM(msr1) from basecube" + " where " + TWO_DAYS_RANGE, conf);
String expected =
- getExpectedQuery(cubeName, "select basecube.dim1, SUM(basecube.msr1) FROM ", null, " group by basecube.dim1",
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `dim1`, sum((basecube.msr1)) as `sum(msr1)` FROM ",
+ null, " group by basecube.dim1",
getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareQueries(hqlQuery, expected);
hqlQuery = rewrite("select dim1, SUM(msr1), msr2 from basecube" + " where " + TWO_DAYS_RANGE, conf);
expected =
- getExpectedQuery(cubeName, "select basecube.dim1, SUM(basecube.msr1), basecube.msr2 FROM ", null,
- " group by basecube.dim1", getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `dim1`, sum((basecube.msr1)) as `sum(msr1)`, "
+ + "(basecube.msr2) as `msr2` FROM ", null, " group by basecube.dim1",
+ getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareQueries(hqlQuery, expected);
hqlQuery = rewrite("select dim1, roundedmsr2 from basecube" + " where " + TWO_DAYS_RANGE, conf);
expected =
- getExpectedQuery(cubeName, "select basecube.dim1, round(sum(basecube.msr2)/1000) FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `dim1`, round((sum((basecube.msr2)) / 1000)) "
+ + "as `roundedmsr2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareQueries(hqlQuery, expected);
hqlQuery =
rewrite("select booleancut, msr2 from basecube" + " where " + TWO_DAYS_RANGE + " and substrexpr != 'XYZ'", conf);
expected =
- getExpectedQuery(cubeName, "select basecube.dim1 != 'x' AND basecube.dim2 != 10 ,"
- + " sum(basecube.msr2) FROM ", null, " and substr(basecube.dim1, 3) != 'XYZ' "
+ getExpectedQuery(cubeName, "SELECT (((basecube.dim1) != 'x') and ((basecube.dim2) != 10)) as `booleancut`, "
+ + "sum((basecube.msr2)) as `msr2` FROM",
+ null, " and substr(basecube.dim1, 3) != 'XYZ' "
+ "group by basecube.dim1 != 'x' AND basecube.dim2 != 10",
getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareQueries(hqlQuery, expected);
hqlQuery = rewrite("select dim1, msr12 from basecube" + " where " + TWO_DAYS_RANGE, conf);
expected =
- getExpectedQuery(cubeName, "select basecube.dim1, sum(basecube.msr12) FROM ", null, " group by basecube.dim1",
- getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `dim1`, sum((basecube.msr12)) as `msr12` FROM ", null,
+ " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
compareQueries(hqlQuery, expected);
}
@Test
public void testMultiFactQueryWithNoDimensionsSelected() throws Exception {
CubeQueryContext ctx = rewriteCtx("select roundedmsr2, msr12 from basecube" + " where " + TWO_DAYS_RANGE, conf);
- Set<String> candidateFacts = new HashSet<String>();
- for (CandidateFact cfact : ctx.getCandidateFacts()) {
- candidateFacts.add(cfact.getName().toLowerCase());
+ Set<String> storageCandidates = new HashSet<String>();
+ Set<StorageCandidate> scSet = CandidateUtil.getStorageCandidates(ctx.getCandidates());
+ for (StorageCandidate sc : scSet) {
+ storageCandidates.add(sc.getStorageTable());
}
- Assert.assertTrue(candidateFacts.contains("testfact1_base"));
- Assert.assertTrue(candidateFacts.contains("testfact2_base"));
+ Assert.assertTrue(storageCandidates.contains("c1_testfact1_base"));
+ Assert.assertTrue(storageCandidates.contains("c1_testfact2_base"));
String hqlQuery = ctx.toHQL();
String expected1 =
- getExpectedQuery(cubeName, "select sum(basecube.msr12) as `msr12` FROM ", null,
+ getExpectedQuery(cubeName, "SELECT 0.0 as `alias0`, sum((basecube.msr12)) as `alias1` FROM ", null,
null, getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 =
- getExpectedQuery(cubeName, "select round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null,
+ getExpectedQuery(cubeName, "SELECT sum((basecube.msr2)) as `alias0`, 0.0 as `alias1` FROM ", null,
null, getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
String lower = hqlQuery.toLowerCase();
- assertTrue(lower.startsWith("select mq2.roundedmsr2 roundedmsr2, mq1.msr12 msr12 from ")
- || lower.startsWith("select mq1.roundedmsr2 roundedmsr2, mq2.msr12 msr12 from "), hqlQuery);
- assertTrue(lower.contains("mq1 full outer join") && lower.endsWith("mq2"), hqlQuery);
- assertFalse(lower.contains("mq2 on"), hqlQuery);
- assertFalse(lower.contains("<=>"), hqlQuery);
+ assertTrue(lower.startsWith("select round((sum((basecube.alias0)) / 1000)) as `roundedmsr2`, "
+ + "sum((basecube.alias1)) as `msr12` from "), hqlQuery);
+ assertFalse(lower.contains("UNION ALL"), hqlQuery);
}
@Test
public void testMoreThanTwoFactQueryWithNoDimensionsSelected() throws Exception {
CubeQueryContext ctx = rewriteCtx("select roundedmsr2, msr14, msr12 from basecube" + " where " + TWO_DAYS_RANGE,
conf);
- Set<String> candidateFacts = new HashSet<String>();
- for (CandidateFact cfact : ctx.getCandidateFacts()) {
- candidateFacts.add(cfact.getName().toLowerCase());
+ Set<String> storageCandidates = new HashSet<String>();
+ Set<StorageCandidate> scSet = CandidateUtil.getStorageCandidates(ctx.getCandidates());
+ for (StorageCandidate sc : scSet) {
+ storageCandidates.add(sc.getStorageTable());
}
- Assert.assertEquals(candidateFacts.size(), 3);
- Assert.assertTrue(candidateFacts.contains("testfact1_base"));
- Assert.assertTrue(candidateFacts.contains("testfact2_base"));
- Assert.assertTrue(candidateFacts.contains("testfact3_base"));
+ Assert.assertEquals(storageCandidates.size(), 3);
+ Assert.assertTrue(storageCandidates.contains("c1_testfact1_base"));
+ Assert.assertTrue(storageCandidates.contains("c1_testfact2_base"));
+ Assert.assertTrue(storageCandidates.contains("c1_testfact3_base"));
String hqlQuery = ctx.toHQL();
- String expected1 = getExpectedQuery(cubeName, "select sum(basecube.msr12) as `msr12` FROM ", null, null,
+ String expected1 = getExpectedQuery(cubeName, "SELECT 0.0 as `alias0`, 0.0 as `alias1`, "
+ + "sum((basecube.msr12)) as `alias2` FROM ", null, null,
getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
- String expected2 = getExpectedQuery(cubeName, "select round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null,
+ String expected2 = getExpectedQuery(cubeName, "SELECT sum((basecube.msr2)) as `alias0`, 0.0 as `alias1`, "
+ + "0.0 as `alias2` FROM ", null,
null, getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
- String expected3 = getExpectedQuery(cubeName, "select count((basecube.msr14)) as `msr14` FROM ", null, null,
+ String expected3 = getExpectedQuery(cubeName, "SELECT 0.0 as `alias0`, count((basecube.msr14)) as `alias1`, "
+ + "0.0 as `alias2` FROM ", null, null,
getWhereForDailyAndHourly2days(cubeName, "C1_testFact3_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
compareContains(expected3, hqlQuery);
String lower = hqlQuery.toLowerCase();
- assertTrue(lower.startsWith("select mq1.roundedmsr2 roundedmsr2, mq3.msr14 msr14, mq2.msr12 msr12 from ") || lower
- .startsWith("select mq3.roundedmsr2 roundedmsr2, mq1.msr14 msr14, mq2.msr12 msr12 from ") || lower
- .startsWith("select mq2.roundedmsr2 roundedmsr2, mq3.msr14 msr14, mq1.msr12 msr12 from ") || lower
- .startsWith("select mq3.roundedmsr2 roundedmsr2, mq2.msr14 msr14, mq1.msr12 msr12 from ") || lower
- .startsWith("select mq1.roundedmsr2 roundedmsr2, mq2.msr14 msr14, mq3.msr12 msr12 from ") || lower
- .startsWith("select mq2.roundedmsr2 roundedmsr2, mq1.msr14 msr14, mq3.msr12 msr12 from "), hqlQuery);
- assertTrue(lower.contains("mq1 full outer join") && lower.endsWith("mq3"));
- assertFalse(lower.contains("mq3 on"), hqlQuery);
- assertFalse(lower.contains("mq2 on"), hqlQuery);
- assertFalse(lower.contains("<=>"), hqlQuery);
+ assertTrue(lower.startsWith("select round((sum((basecube.alias0)) / 1000)) as `roundedmsr2`, "
+ + "count((basecube.alias1)) as `msr14`, sum((basecube.alias2)) as `msr12` from"), hqlQuery);
+ assertTrue(lower.contains("union all"));
}
@Test
public void testMultiFactQueryWithSingleCommonDimension() throws Exception {
String hqlQuery = rewrite("select dim1, roundedmsr2, msr12 from basecube" + " where " + TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, sum(basecube.msr12) as `msr12` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
- String expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as `dim1`, round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum((basecube.msr2)) as `alias1`, "
+ + "0.0 as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ String expected2 = getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, "
+ + "sum((basecube.msr12)) as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
String lower = hqlQuery.toLowerCase();
assertTrue(
- lower.startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, mq2.roundedmsr2 roundedmsr2, mq1.msr12 msr12 from ")
- || lower.startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, mq1.roundedmsr2 roundedmsr2, mq2.msr12 msr12"
- + " from "), hqlQuery);
-
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1"),
+ lower.startsWith("select (basecube.alias0) as `dim1`, round((sum((basecube.alias1)) / 1000)) as `roundedmsr2`, "
+ + "sum((basecube.alias2)) as `msr12` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -266,21 +223,18 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
Configuration tConf = new Configuration(conf);
tConf.setBoolean(CubeQueryConfUtil.LIGHTEST_FACT_FIRST, true);
String hqlQuery = rewrite("select dim1, roundedmsr2, msr12 from basecube" + " where " + TWO_DAYS_RANGE, tConf);
- String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, sum(basecube.msr12) as `msr12` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
- String expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as `dim1`, round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ String expected1 = getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, "
+ + "sum((basecube.msr12)) as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ String expected2 = getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum((basecube.msr2)) "
+ + "as `alias1`, 0.0 as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
String lower = hqlQuery.toLowerCase();
- assertTrue(
- lower.startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, mq2.roundedmsr2 roundedmsr2, mq1.msr12 msr12 from ")
- || lower.startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, mq1.roundedmsr2 roundedmsr2, mq2.msr12 msr12"
- + " from "), hqlQuery);
-
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1"),
+ assertTrue(lower.startsWith("select (basecube.alias0) as `dim1`, round((sum((basecube.alias1)) / 1000)) "
+ + "as `roundedmsr2`, sum((basecube.alias2)) as `msr12` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -290,25 +244,19 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
tConf.setBoolean(CubeQueryConfUtil.LIGHTEST_FACT_FIRST, true);
String hqlQuery = rewrite("select dim1, roundedmsr2, flooredmsr12 from basecube" + " where "
+ TWO_DAYS_RANGE, tConf);
- String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, "
- + "floor(sum(( basecube . msr12 ))) as `flooredmsr12` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
- String expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as `dim1`, round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ String expected1 = getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, "
+ + "sum((basecube.msr12)) as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ String expected2 = getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum((basecube.msr2)) "
+ + "as `alias1`, 0.0 as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
String lower = hqlQuery.toLowerCase();
- assertTrue(
- lower.startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, mq2.roundedmsr2 roundedmsr2, "
- + "mq1.flooredmsr12 flooredmsr12 from ")
- || lower.startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, mq1.roundedmsr2 roundedmsr2, "
- + "mq2.flooredmsr12 flooredmsr12"
- + " from "), hqlQuery);
-
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1"),
- hqlQuery);
+ assertTrue(lower.startsWith("select (basecube.alias0) as `dim1`, round((sum((basecube.alias1)) / 1000)) "
+ + "as `roundedmsr2`, floor(sum((basecube.alias2))) as `flooredmsr12` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
+ hqlQuery);
}
@Test
@@ -316,21 +264,20 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
// columns in select interchanged
String hqlQuery = rewrite("select dim1, msr12, roundedmsr2 from basecube" + " where " + TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, sum(basecube.msr12) as `msr12` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum((basecube.msr12)) as `alias1`, "
+ + "0.0 as `alias2` FROM", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as `dim1`, round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null,
+ "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, sum((basecube.msr2)) as `alias2` FROM ", null,
" group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
String lower = hqlQuery.toLowerCase();
assertTrue(
- lower.startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2 from ")
- || lower.startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2"
- + " from "), hqlQuery);
+ lower.startsWith("select (basecube.alias0) as `dim1`, sum((basecube.alias1)) as `msr12`, "
+ + "round((sum((basecube.alias2)) / 1000)) as `roundedmsr2` from"), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1"),
- hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"), hqlQuery);
}
@Test
@@ -339,67 +286,49 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
String hqlQuery = rewrite("select dim1, d_time, msr12, roundedmsr2, msr13, msr3 from basecube where "
+ TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, basecube.d_time as `d_time`, "
- + "sum(basecube.msr12) as `msr12` FROM ", null, " group by basecube.dim1",
+ getExpectedQuery(cubeName, " SELECT (basecube.dim1) as `alias0`, (basecube.d_time) as `alias1`, "
+ + "sum((basecube.msr12)) as `alias2`, 0.0 as `alias3`, 0.0 as `alias4`, 0.0 as `alias5` FROM ",
+ null, " group by basecube.dim1, (basecube.d_time)",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 = getExpectedQuery(
cubeName,
- "select basecube.dim1 as `dim1`, basecube.d_time as `d_time`, round(sum(basecube.msr2)/1000) "
- + "as `roundedmsr2`, max(basecube.msr3) as `msr3` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ "SELECT (basecube.dim1) as `alias0`, (basecube.d_time) as `alias1`, 0.0 as `alias2`, "
+ + "sum((basecube.msr2)) as `alias3`, 0.0 as `alias4`, max((basecube.msr3)) as `alias5` FROM ", null,
+ " group by basecube.dim1, (basecube.d_time)", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
String expected3 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, basecube.d_time as `d_time`, "
- + "max(basecube.msr13) as `msr13` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "c1_testfact3_base"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, (basecube.d_time) as `alias1`, 0.0 "
+ + "as `alias2`, 0.0 as `alias3`, max((basecube.msr13)) as `alias4`, 0.0 as `alias5` FROM ", null,
+ " group by basecube.dim1, (basecube.d_time)", getWhereForDailyAndHourly2days(cubeName, "c1_testfact3_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
compareContains(expected3, hqlQuery);
assertTrue(
hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1, mq3.dim1) dim1, coalesce(mq1.d_time, mq2.d_time, mq3.d_time) d_time, "
- + "mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2, mq3.msr13 msr13, mq2.msr3 msr3 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1, mq3.dim1) dim1, coalesce(mq1.d_time, mq2.d_time, mq3.d_time) d_time,"
- + " mq1.msr12 msr12, mq3.roundedmsr2 roundedmsr2, mq2.msr13 msr13, mq3.msr3 msr3 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1, mq3.dim1) dim1, coalesce(mq1.d_time, mq2.d_time, mq3.d_time) d_time,"
- + " mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2, mq3.msr13 msr13, mq1.msr3 msr3 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1, mq3.dim1) dim1, coalesce(mq1.d_time, mq2.d_time, mq3.d_time) d_time, "
- + "mq2.msr12 msr12, mq3.roundedmsr2 roundedmsr2, mq1.msr13 msr13, mq3.msr3 msr3 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1, mq3.dim1) dim1, coalesce(mq1.d_time, mq2.d_time, mq3.d_time) d_time,"
- + " mq3.msr12 msr12, mq1.roundedmsr2 roundedmsr2, mq2.msr13 msr13, mq1.msr3 msr3 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1, mq3.dim1) dim1, coalesce(mq1.d_time, mq2.d_time, mq3.d_time) d_time, "
- + "mq3.msr12 msr12, mq2.roundedmsr2 roundedmsr2, mq1.msr13 msr13, mq2.msr3 msr3 from "), hqlQuery);
- assertTrue(hqlQuery.toLowerCase().contains("mq1 full outer join ")
- && hqlQuery.toLowerCase().contains("mq2 on mq1.dim1 <=> mq2.dim1 and mq1.d_time <=> mq2.d_time")
- && hqlQuery.toLowerCase().endsWith("mq3 on mq2.dim1 <=> mq3.dim1 and mq2.d_time <=> mq3.d_time"), hqlQuery);
+ "select (basecube.alias0) as `dim1`, (basecube.alias1) as `d_time`, sum((basecube.alias2)) as `msr12`, "
+ + "round((sum((basecube.alias3)) / 1000)) as `roundedmsr2`, max((basecube.alias4)) as `msr13`, "
+ + "max((basecube.alias5)) as `msr3` from "), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0), (basecube.alias1)"),
+ hqlQuery);
}
@Test
public void testMultiFactQueryWithTwoCommonDimensions() throws Exception {
// query two dim attributes
String hqlQuery = rewrite("select dim1, dim11, msr12, roundedmsr2 from basecube where " + TWO_DAYS_RANGE, conf);
- String expected1 = getExpectedQuery(cubeName,
- "select basecube.dim1 as `dim1`, basecube.dim11 as `dim11`, sum(basecube.msr12) as `msr12` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
- String expected2 = getExpectedQuery(
- cubeName,
- "select basecube.dim1 as `dim1`, basecube.dim11 as `dim11`, round(sum(basecube.msr2)/1000) as `roundedmsr2` "
- + "FROM ", null, " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ String expected1 = getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, "
+ + "sum((basecube.msr12)) as `alias2`, 0.0 as `alias3` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ String expected2 = getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, "
+ + "0.0 as `alias2`, sum((basecube.msr2)) as `alias3` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, coalesce(mq1.dim11, mq2.dim11) dim11,"
- + " mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, coalesce(mq1.dim11, mq2.dim11) dim11,"
- + " mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2 from "), hqlQuery);
-
- assertTrue(hqlQuery.contains("mq1 full outer join ")
- && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1 AND mq1.dim11 <=> mq2.dim11"), hqlQuery);
+ "select (basecube.alias0) as `dim1`, (basecube.alias1) as `dim11`, sum((basecube.alias2)) as `msr12`, "
+ + "round((sum((basecube.alias3)) / 1000)) as `roundedmsr2` from"), hqlQuery);
+
+ assertTrue(hqlQuery.contains("UNION ALL")
+ && hqlQuery.endsWith("GROUP BY (basecube.alias0), (basecube.alias1)"), hqlQuery);
}
@Test
@@ -407,19 +336,18 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
// no aggregates in the query
String hqlQuery = rewrite("select dim1, msr11, roundedmsr2 from basecube where " + TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, basecube.msr11 as `msr11` FROM ", null, null,
- getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, (basecube.msr11) as `alias1`, "
+ + "0.0 as `alias2` FROM ", null, null, getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
String expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as `dim1`, round(basecube.msr2/1000) as `roundedmsr2` FROM ", null, null,
+ "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, round(((basecube.msr2) / 1000)) "
+ + "as `alias2` FROM ", null, null,
getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, mq1.msr11 msr11, mq2.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, mq2.msr11 msr11, mq1.roundedmsr2 roundedmsr2 from "), hqlQuery);
-
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1"),
+ "select (basecube.alias0) as `dim1`, (basecube.alias1) as `msr11`, "
+ + "(basecube.alias2) as `roundedmsr2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("as basecube"),
hqlQuery);
}
@@ -429,18 +357,19 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
String hqlQuery =
rewrite("select dim1 d1, msr12 `my msr12`, roundedmsr2 m2 from basecube where " + TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `expr1`, sum(basecube.msr12) as `expr2` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum((basecube.msr12)) as `alias1`, "
+ + "0.0 as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `expr1`, round(sum(basecube.msr2)/1000) as `expr3` FROM ",
- null, " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, sum((basecube.msr2)) "
+ + "as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `d1`, mq2.expr2 `my msr12`, mq1.expr3 `m2` from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `d1`, mq1.expr2 `my msr12`, mq2.expr3 `m2` from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.expr1 <=> mq2.expr1"),
+ "select (basecube.alias0) as `d1`, sum((basecube.alias1)) as `my msr12`, "
+ + "round((sum((basecube.alias2)) / 1000)) as `m2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -450,19 +379,19 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
rewrite("select dim1 d1, msr12 `sum(msr12)`, roundedmsr2 as `round(sum(msr2)/1000)` from basecube where "
+ TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `expr1`, sum(basecube.msr12) as `expr2` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum((basecube.msr12)) as `alias1`, "
+ + "0.0 as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `expr1`, round(sum(basecube.msr2)/1000) as `expr3` FROM ",
- null, " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, sum((basecube.msr2)) "
+ + "as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `d1`, mq2.expr2 `sum(msr12)`, mq1.expr3 `round(sum(msr2)/1000)` from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `d1`, mq1.expr2 `sum(msr12)`, mq2.expr3 `round(sum(msr2)/1000)` from "),
- hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.expr1 <=> mq2.expr1"),
+ "select (basecube.alias0) as `d1`, sum((basecube.alias1)) as `sum(msr12)`, "
+ + "round((sum((basecube.alias2)) / 1000)) as `round(sum(msr2)/1000)` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -472,19 +401,19 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
rewrite("select dim1 d1, msr12 `my msr12`, roundedmsr2 as `msr2` from basecube where " + TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `expr1`, sum(basecube.msr12) as `expr2` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum((basecube.msr12)) as `alias1`, "
+ + "0.0 as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `expr1`, round(sum(basecube.msr2)/1000) as `expr3` FROM ",
- null, " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, sum((basecube.msr2)) "
+ + "as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `d1`, mq2.expr2 `my msr12`, mq1.expr3 `msr2` from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `d1`, mq1.expr2 `my msr12`, mq2.expr3 `msr2` from "),
- hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.expr1 <=> mq2.expr1"),
+ "select (basecube.alias0) as `d1`, sum((basecube.alias1)) as `my msr12`,"
+ + " round((sum((basecube.alias2)) / 1000)) as `msr2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("(basecube.alias0)"),
hqlQuery);
}
@@ -495,19 +424,19 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `expr1`, sum(basecube.msr12) as `expr2` FROM ", null,
- " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum((basecube.msr12)) as `alias1`, "
+ + "0.0 as `alias2` FROM", null, " group by basecube.dim1",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `expr1`, round(sum(basecube.msr2)/1000) as `expr3` FROM ",
- null, " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, sum((basecube.msr2)) "
+ + "as `alias2` FROM", null,
+ " group by basecube.dim1", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `d1`, mq2.expr2 `my msr12`, mq1.expr3 `roundedmsr2` from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `d1`, mq1.expr2 `my msr12`, mq2.expr3 `roundedmsr2` from "),
- hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.expr1 <=> mq2.expr1"),
+ "select (basecube.alias0) as `d1`, sum((basecube.alias1)) as `my msr12`, "
+ + "round((sum((basecube.alias2)) / 1000)) as `roundedmsr2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -516,24 +445,23 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
String hqlQuery =
rewrite("select reverse(dim1), ltrim(dim1), msr12, roundedmsr2 from basecube where " + TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select reverse(basecube.dim1) as `expr1`, ltrim(basecube.dim1) as `expr2`,"
- + " sum(basecube.msr12) as `msr12` FROM ", null,
- " group by reverse(basecube.dim1), ltrim(basecube.dim1)",
+ getExpectedQuery(cubeName, "SELECT reverse((basecube.dim1)) as `alias0`, ltrim((basecube.dim1)) as `alias1`, "
+ + "sum((basecube.msr12)) as `alias2`, 0.0 as `alias3` FROM ", null,
+ " group by reverse(basecube.dim1), ltrim(basecube.dim1)",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 =
- getExpectedQuery(cubeName, "select reverse(basecube.dim1) as `expr1`, ltrim(basecube.dim1) as `expr2`,"
- + " round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null,
+ getExpectedQuery(cubeName, "SELECT reverse((basecube.dim1)) as `alias0`, ltrim((basecube.dim1)) as `alias1`, "
+ + "0.0 as `alias2`, sum((basecube.msr2)) as `alias3` FROM ", null,
" group by reverse(basecube.dim1), ltrim(basecube.dim1)",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.expr1, mq2.expr1) `reverse(dim1)`,"
- + " coalesce(mq1.expr2, mq2.expr2) `ltrim(dim1)`, mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.expr1, mq2.expr1) `reverse(dim1)`,"
- + " coalesce(mq1.expr2, mq2.expr2) `ltrim(dim1)`, mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2 from "),
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `reverse(dim1)`, (basecube.alias1) "
+ + "as `ltrim(dim1)`, sum((basecube.alias2)) as `msr12`, round((sum((basecube.alias3)) / 1000)) "
+ + "as `roundedmsr2` from"),
hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ")
- && hqlQuery.endsWith("mq2 on mq1.expr1 <=> mq2.expr1 AND mq1.expr2 <=> mq2.expr2"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL")
+ && hqlQuery.endsWith("GROUP BY (basecube.alias0), (basecube.alias1)"), hqlQuery);
}
@Test
@@ -542,23 +470,20 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
rewrite("select reverse(dim1), directMsrExpr as directMsr, roundedmsr2 from basecube where " + TWO_DAYS_RANGE,
conf);
String expected1 =
- getExpectedQuery(cubeName, "select reverse(basecube.dim1) as `expr1`, "
- + "max(basecube.msr13) + count(basecube . msr14) as `expr2` FROM ", null,
+ getExpectedQuery(cubeName, "SELECT reverse((basecube.dim1)) as `alias0`, max((basecube.msr13)) as `alias1`, "
+ + "count((basecube.msr14)) as `alias2`, 0.0 as `alias3` FROM", null,
" group by reverse(basecube.dim1)", getWhereForDailyAndHourly2days(cubeName, "C1_testFact3_BASE"));
String expected2 =
- getExpectedQuery(cubeName, "select reverse(basecube.dim1) as expr1, "
- + "round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null, " group by reverse(basecube.dim1)",
- getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
+ getExpectedQuery(cubeName, "SELECT reverse((basecube.dim1)) as `alias0`, 0.0 as `alias1`, "
+ + "0.0 as `alias2`, sum((basecube.msr2)) as `alias3` FROM", null,
+ " group by reverse(basecube.dim1)", getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `reverse(dim1)`, mq2.expr2 `directmsr`, mq1.roundedmsr2 roundedmsr2 "
- + "from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.expr1, mq2.expr1) `reverse(dim1)`, mq1.expr2 `directmsr`, mq2.roundedmsr2 roundedmsr2 "
- + "from "),
+ "select (basecube.alias0) as `reverse(dim1)`, (max((basecube.alias1)) + count((basecube.alias2))) "
+ + "as `directmsr`, round((sum((basecube.alias3)) / 1000)) as `roundedmsr2` from"),
hqlQuery.toLowerCase());
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.expr1 <=> mq2.expr1"),
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -567,20 +492,19 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
// query with non default aggregate
String hqlQuery = rewrite("select dim1, avg(msr12), avg(msr2) from basecube where " + TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, avg(basecube.msr12) as `expr2` FROM ", null,
- " group by basecube.dim1", getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, avg((basecube.msr12)) as `alias1`,"
+ + " 0.0 as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, avg(basecube.msr2)) as `expr3` FROM ", null,
- " group by basecube.dim1", getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, avg((basecube.msr2)) "
+ + "as `alias2` FROM ", null, " group by basecube.dim1",
+ getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, mq2.expr2 `avg(msr12)`, mq1.expr3 `avg(msr2)` from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, mq1.expr2 `avg(msr12)`, mq2.expr3 `avg(msr2)` from "), hqlQuery);
-
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1"),
- hqlQuery);
+ "select (basecube.alias0) as `dim1`, avg((basecube.alias1)) as `avg(msr12)`, avg((basecube.alias2)) "
+ + "as `avg(msr2)` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"), hqlQuery);
}
@Test
@@ -588,20 +512,23 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
// query with join
String hqlQuery = rewrite("select dim2chain.name, msr12, roundedmsr2 from basecube where " + TWO_DAYS_RANGE, conf);
String expected1 = getExpectedQuery(cubeName,
- "select dim2chain.name as `name`, sum(basecube.msr12) as `msr12` FROM ", " JOIN " + getDbName()
- + "c1_testdim2tbl dim2chain ON basecube.dim2 = " + " dim2chain.id and (dim2chain.dt = 'latest') ", null,
+ "SELECT (dim2chain.name) as `alias0`, sum((basecube.msr12)) as `alias1`, 0.0 as `alias2` FROM ",
+ " JOIN " + getDbName()
+ + "c1_testdim2tbl dim2chain ON basecube.dim2 = "
+ + " dim2chain.id and (dim2chain.dt = 'latest') ", null,
" group by dim2chain.name", null, getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
String expected2 = getExpectedQuery(cubeName,
- "select dim2chain.name as `name`, round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", " JOIN " + getDbName()
- + "c1_testdim2tbl dim2chain ON basecube.dim2 = " + " dim2chain.id and (dim2chain.dt = 'latest') ", null,
+ "SELECT (dim2chain.name) as `alias0`, 0.0 as `alias1`, sum((basecube.msr2)) as `alias2` FROM ", " JOIN "
+ + getDbName()
+ + "c1_testdim2tbl dim2chain ON basecube.dim2 = "
+ + " dim2chain.id and (dim2chain.dt = 'latest') ", null,
" group by dim2chain.name", null, getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.name, mq2.name) name, mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.name, mq2.name) name, mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2 from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.name <=> mq2.name"),
+ "select (basecube.alias0) as `name`, sum((basecube.alias1)) as `msr12`, "
+ + "round((sum((basecube.alias2)) / 1000)) as `roundedmsr2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -609,20 +536,20 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
public void testMultiFactQueryWithDenormColumn() throws Exception {
// query with denorm variable
String hqlQuery = rewrite("select dim2, msr13, roundedmsr2 from basecube where " + TWO_DAYS_RANGE, conf);
- String expected1 = getExpectedQuery(cubeName, "select dim2chain.id as `dim2`, max(basecube.msr13) as `msr13` FROM ",
- " JOIN " + getDbName() + "c1_testdim2tbl dim2chain ON basecube.dim12 = "
- + " dim2chain.id and (dim2chain.dt = 'latest') ", null, " group by dim2chain.id", null,
+ String expected1 = getExpectedQuery(cubeName, "SELECT (dim2chain.id) as `alias0`, max((basecube.msr13)) "
+ + "as `alias1`, 0.0 as `alias2` FROM ", " JOIN " + getDbName()
+ + "c1_testdim2tbl dim2chain ON basecube.dim12 = "
+ + " dim2chain.id and (dim2chain.dt = 'latest') ", null, " group by dim2chain.id", null,
getWhereForHourly2days(cubeName, "C1_testFact3_RAW_BASE"));
String expected2 = getExpectedQuery(cubeName,
- "select basecube.dim2 as `dim2`, round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", null,
+ "SELECT (basecube.dim2) as `alias0`, 0.0 as `alias1`, sum((basecube.msr2)) as `alias2` FROM ", null,
" group by basecube.dim2", getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim2, mq2.dim2) dim2, mq2.msr13 msr13, mq1.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim2, mq2.dim2) dim2, mq1.msr13 msr13, mq2.roundedmsr2 roundedmsr2 from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim2 <=> mq2.dim2"),
+ "select (basecube.alias0) as `dim2`, max((basecube.alias1)) as `msr13`, "
+ + "round((sum((basecube.alias2)) / 1000)) as `roundedmsr2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -631,22 +558,24 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
// query with denorm variable
String hqlQuery = rewrite("select dim2, msr13, roundedmsr2 from basecube where dim2 == 10 and " + TWO_DAYS_RANGE,
conf);
- String expected1 = getExpectedQuery(cubeName, "select dim2chain.id as `dim2`, max(basecube.msr13) as `msr13` FROM ",
- " JOIN " + getDbName() + "c1_testdim2tbl dim2chain ON basecube.dim12 = "
+ String expected1 = getExpectedQuery(cubeName, "SELECT (dim2chain.id) as `alias0`, max((basecube.msr13)) "
+ + "as `alias1`, 0.0 as `alias2` FROM ", " JOIN " + getDbName()
+ + "c1_testdim2tbl dim2chain ON basecube.dim12 = "
+ " dim2chain.id and (dim2chain.dt = 'latest') ", "dim2chain.id == 10", " group by dim2chain.id", null,
getWhereForHourly2days(cubeName, "C1_testFact3_RAW_BASE"));
String expected2 = getExpectedQuery(cubeName,
- "select basecube.dim2 as `dim2`, round(sum(basecube.msr2)/1000) as `roundedmsr2` FROM ", "basecube.dim2 == 10",
- " group by basecube.dim2", getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
+ "SELECT (basecube.dim2) as `alias0`, 0.0 as `alias1`, sum((basecube.msr2)) as `alias2` FROM ",
+ "basecube.dim2 == 10", " group by basecube.dim2",
+ getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim2, mq2.dim2) dim2, mq2.msr13 msr13, mq1.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim2, mq2.dim2) dim2, mq1.msr13 msr13, mq2.roundedmsr2 roundedmsr2 from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim2 <=> mq2.dim2"),
+ "select (basecube.alias0) as `dim2`, max((basecube.alias1)) as `msr13`, "
+ + "round((sum((basecube.alias2)) / 1000)) as `roundedmsr2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
+
@Test
public void testMultiFactQueryWithExpressionInvolvingDenormVariable() throws Exception {
// query with expression
@@ -656,24 +585,24 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
"select booleancut, round(sum(msr2)/1000), avg(msr13 + msr14) from basecube where " + TWO_DAYS_RANGE,
conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 != 'x' AND dim2chain.id != 10 as `booleancut`,"
- + " avg(basecube.msr13 + basecube.msr14) as `expr3` FROM ", " JOIN " + getDbName()
- + "c1_testdim2tbl dim2chain ON basecube.dim12 = " + " dim2chain.id and (dim2chain.dt = 'latest') ", null,
+ getExpectedQuery(cubeName, "SELECT (((basecube.dim1) != 'x') and ((dim2chain.id) != 10)) as `alias0`, "
+ + "0.0 as `alias1`, avg(((basecube.msr13) + (basecube.msr14))) as `alias2` FROM ", " JOIN "
+ + getDbName() + "c1_testdim2tbl dim2chain ON basecube.dim12 = "
+ + " dim2chain.id and (dim2chain.dt = 'latest') ", null,
" group by basecube.dim1 != 'x' AND dim2chain.id != 10", null,
getWhereForHourly2days(cubeName, "C1_testfact3_raw_base"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 != 'x' AND basecube.dim2 != 10 as `booleancut`,"
- + " round(sum(basecube.msr2)/1000) as `expr2` FROM ", null,
- " group by basecube.dim1 != 'x' AND basecube.dim2 != 10",
+ getExpectedQuery(cubeName, "SELECT (((basecube.dim1) != 'x') and ((basecube.dim2) != 10)) as `alias0`, "
+ + "sum((basecube.msr2)) as `alias1`, 0.0 as `alias2` FROM", null,
+ " group by basecube.dim1 != 'x' AND basecube.dim2 != 10",
getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.booleancut, mq2.booleancut) booleancut, "
- + "mq2.expr2 `round((sum(msr2) / 1000))`, mq1.expr3 `avg((msr13 + msr14))` from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.booleancut, mq2.booleancut) booleancut, "
- + "mq1.expr2 `round((sum(msr2) / 1000))`, mq2.expr3 `avg((msr13 + msr14))` from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ")
- && hqlQuery.endsWith("mq2 on mq1.booleancut <=> mq2.booleancut"),
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `booleancut`, "
+ + "round((sum((basecube.alias1)) / 1000)) as `round((sum(msr2) / 1000))`, "
+ + "avg((basecube.alias2)) as `avg((msr13 + msr14))` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL")
+ && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -686,26 +615,25 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
"select booleancut, round(sum(msr2)/1000), avg(msr13 + msr14) from basecube where booleancut == 'true' and "
+ TWO_DAYS_RANGE, conf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 != 'x' AND dim2chain.id != 10 as `booleancut`,"
- + " avg(basecube.msr13 + basecube.msr14) as `expr3` FROM ", " JOIN " + getDbName()
+ getExpectedQuery(cubeName, "SELECT (((basecube.dim1) != 'x') and ((dim2chain.id) != 10)) as `alias0`, "
+ + "0.0 as `alias1`, avg(((basecube.msr13) + (basecube.msr14))) as `alias2` FROM ", " JOIN " + getDbName()
+ "c1_testdim2tbl dim2chain ON basecube.dim12 = " + " dim2chain.id and (dim2chain.dt = 'latest') ",
"(basecube.dim1 != 'x' AND dim2chain.id != 10) == true",
" group by basecube.dim1 != 'x' AND dim2chain.id != 10", null,
getWhereForHourly2days(cubeName, "C1_testfact3_raw_base"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 != 'x' AND basecube.dim2 != 10 as `booleancut`,"
- + " round(sum(basecube.msr2)/1000) as `expr2` FROM ",
- "(basecube.dim1 != 'x' AND basecube.dim2 != 10) == true",
- " group by basecube.dim1 != 'x' AND basecube.dim2 != 10",
+ getExpectedQuery(cubeName, "SELECT (((basecube.dim1) != 'x') and ((basecube.dim2) != 10)) as `alias0`, "
+ + "sum((basecube.msr2)) as `alias1`, 0.0 as `alias2` FROM ",
+ "(basecube.dim1 != 'x' AND basecube.dim2 != 10) == true",
+ " group by basecube.dim1 != 'x' AND basecube.dim2 != 10",
getWhereForHourly2days(cubeName, "C1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.booleancut, mq2.booleancut) booleancut, "
- + "mq2.expr2 `round((sum(msr2) / 1000))`, mq1.expr3 `avg((msr13 + msr14))` from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.booleancut, mq2.booleancut) booleancut, "
- + "mq1.expr2 `round((sum(msr2) / 1000))`, mq2.expr3 `avg((msr13 + msr14))` from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ")
- && hqlQuery.endsWith("mq2 on mq1.booleancut <=> mq2.booleancut"),
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `booleancut`, "
+ + "round((sum((basecube.alias1)) / 1000)) as `round((sum(msr2) / 1000))`, "
+ + "avg((basecube.alias2)) as `avg((msr13 + msr14))` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL")
+ && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -714,23 +642,22 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
Configuration tconf = new Configuration(conf);
tconf.set(CubeQueryConfUtil.getValidFactTablesKey("basecube"), "testfact5_base,testfact6_base");
String hqlQuery =
- rewrite(
- "select booleancut, round(sum(msr2)/1000), msr13 from basecube where " + TWO_DAYS_RANGE, tconf);
+ rewrite("select booleancut, round(sum(msr2)/1000), msr13 from basecube where " + TWO_DAYS_RANGE, tconf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.booleancut as `booleancut`,max(basecube.msr13) as `msr13` FROM ",
- null, " group by basecube.booleancut", getWhereForDailyAndHourly2days(cubeName, "C1_testfact6_base"));
+ getExpectedQuery(cubeName, "SELECT (basecube.booleancut) as `alias0`, 0.0 as `alias1`, "
+ + "max((basecube.msr13)) as `alias2` FROM", null, " "
+ + "group by basecube.booleancut", getWhereForDailyAndHourly2days(cubeName, "C1_testfact6_base"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.booleancut as `booleancut`,"
- + " round(sum(basecube.msr2)/1000) as `expr2` FROM ", null, " group by basecube.booleancut",
+ getExpectedQuery(cubeName, "SELECT (basecube.booleancut) as `alias0`, sum((basecube.msr2)) as `alias1`, "
+ + "0.0 as `alias2` FROM ", null, " group by basecube.booleancut",
getWhereForDailyAndHourly2days(cubeName, "C1_testfact5_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.booleancut, mq2.booleancut) booleancut, "
- + "mq2.expr2 `round((sum(msr2) / 1000))`, mq1.msr13 msr13 from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.booleancut, mq2.booleancut) booleancut, "
- + "mq1.expr2 `round((sum(msr2) / 1000))`, mq2.msr13 msr13 from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ")
- && hqlQuery.endsWith("mq2 on mq1.booleancut <=> mq2.booleancut"),
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `booleancut`, "
+ + "round((sum((basecube.alias1)) / 1000)) as `round((sum(msr2) / 1000))`, "
+ + "max((basecube.alias2)) as `msr13` from "), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL")
+ && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -741,16 +668,17 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
rewrite("select sum(case when dim22 = 'x' then msr12 else 0 end) as case_expr, sum(msr1) from basecube where "
+ TWO_DAYS_RANGE, tconf);
String expected1 =
- getExpectedQuery(cubeName, "select sum(case when basecube.dim22 = 'x' then basecube.msr12 else 0 end) as "
- + "`expr1` FROM ", null, null, getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
+ getExpectedQuery(cubeName, "SELECT sum(case when ((basecube.dim22) = 'x') then (basecube.msr12) else 0 end) "
+ + "as `alias0`, 0.0 as `alias1` FROM ", null, null,
+ getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
String expected2 =
- getExpectedQuery(cubeName, "select sum(basecube.msr1) as `expr2` FROM ", null, null,
+ getExpectedQuery(cubeName, "SELECT 0.0 as `alias0`, sum((basecube.msr1)) as `alias1` FROM ", null, null,
getWhereForHourly2days(cubeName, "c1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select mq2.expr1 `case_expr`, mq1.expr2 `sum(msr1)` from ")
- || hqlQuery.toLowerCase().startsWith("select mq1.expr1 `case_expr`, mq2.expr2 `sum(msr1)` from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2"), hqlQuery);
+ assertTrue(hqlQuery.toLowerCase().startsWith("select sum((basecube.alias0)) as `case_expr`, "
+ + "sum((basecube.alias1)) as `sum(msr1)` from "), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("basecube"), hqlQuery);
}
@Test
@@ -760,16 +688,17 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
rewrite("select sum(case when dim13 = 'x' then msr12 else 0 end) as case_expr, sum(msr1) from basecube where "
+ TWO_DAYS_RANGE, tconf);
String expected1 =
- getExpectedQuery(cubeName, "select sum(case when basecube.dim13 = 'x' then basecube.msr12 else 0 end) as "
- + "`expr1` FROM ", null, null, getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
+ getExpectedQuery(cubeName, "SELECT sum(case when ((basecube.dim13) = 'x') then (basecube.msr12) else 0 end) "
+ + "as `alias0`, 0.0 as `alias1` FROM ", null, null,
+ getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
String expected2 =
- getExpectedQuery(cubeName, "select sum(basecube.msr1) as `expr2` FROM ", null, null,
+ getExpectedQuery(cubeName, "SELECT 0.0 as `alias0`, sum((basecube.msr1)) as `alias1` FROM ", null, null,
getWhereForHourly2days(cubeName, "c1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select mq2.expr1 `case_expr`, mq1.expr2 `sum(msr1)` from ")
- || hqlQuery.toLowerCase().startsWith("select mq1.expr1 `case_expr`, mq2.expr2 `sum(msr1)` from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2"), hqlQuery);
+ assertTrue(hqlQuery.toLowerCase().startsWith("select sum((basecube.alias0)) as `case_expr`, "
+ + "sum((basecube.alias1)) as `sum(msr1)` from "), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("basecube"), hqlQuery);
}
@Test
@@ -779,19 +708,20 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
rewrite("select dim1, sum(case when dim13 = 'x' then msr12 else 0 end) as case_expr, sum(msr1) from basecube "
+ "where " + TWO_DAYS_RANGE, tconf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, sum(case when basecube.dim13 = 'x' then basecube"
- + ".msr12 else 0 end) as `expr2` FROM ", null, " group by basecube.dim1 ",
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum(case when ((basecube.dim13) = 'x') "
+ + "then (basecube.msr12) else 0 end) as `alias1`, 0.0 as `alias2` FROM ", null,
+ " group by basecube.dim1 ",
getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, sum(basecube.msr1) as `expr3` FROM ", null,
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, sum((basecube.msr1)) "
+ + "as `alias2` FROM", null,
" group by basecube.dim1 ", getWhereForHourly2days(cubeName, "c1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, mq2.expr2 `case_expr`, mq1.expr3 `sum(msr1)` from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, mq1.expr2 `case_expr`, mq2.expr3 `sum(msr1)` from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1"),
+ "select (basecube.alias0) as `dim1`, sum((basecube.alias1)) as `case_expr`, "
+ + "sum((basecube.alias2)) as `sum(msr1)` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("GROUP BY (basecube.alias0)"),
hqlQuery);
}
@@ -801,19 +731,21 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
String hqlQuery =
rewrite("select sum(case when dim13 = 'x' then msr12 else 0 end) as case_expr, sum(msr1) from basecube "
+ "where "
- + TWO_DAYS_RANGE + " having sum(case when dim13 = 'x' then msr12 else 0 end) > 100 and sum(msr1) > 500", tconf);
+ + TWO_DAYS_RANGE + " having sum(case when dim13 = 'x' then msr12 else 0 end) > 100 "
+ + "and sum(msr1) > 500", tconf);
String expected1 =
- getExpectedQuery(cubeName, "select sum(case when basecube.dim13 = 'x' then basecube.msr12 else 0 end) as "
- + "`expr1` FROM ", null, " having sum(case when basecube.dim13 = 'x' then basecube.msr12 else 0 end) > 100",
- getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
+ getExpectedQuery(cubeName, "SELECT sum(case when ((basecube.dim13) = 'x') then (basecube.msr12) else 0 end) "
+ + "as `alias0`, 0.0 as `alias1` FROM ", null, "",
+ getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
String expected2 =
- getExpectedQuery(cubeName, "select sum(basecube.msr1) as `expr2` FROM ", null, " having sum(basecube.msr1) > 500",
+ getExpectedQuery(cubeName, "SELECT 0.0 as `alias0`, sum((basecube.msr1)) as `alias1` FROM ", null, "",
getWhereForHourly2days(cubeName, "c1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select mq2.expr1 `case_expr`, mq1.expr2 `sum(msr1)` from ")
- || hqlQuery.toLowerCase().startsWith("select mq1.expr1 `case_expr`, mq2.expr2 `sum(msr1)` from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2"), hqlQuery);
+ assertTrue(hqlQuery.toLowerCase().startsWith("select sum((basecube.alias0)) as `case_expr`, sum((basecube.alias1)) "
+ + "as `sum(msr1)` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL") && hqlQuery.endsWith("HAVING ((sum((basecube.alias0)) > 100) "
+ + "and (sum((basecube.alias1)) > 500))"), hqlQuery);
}
@Test
@@ -821,25 +753,23 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
Configuration tconf = new Configuration(conf);
String hqlQuery =
rewrite("select dim1, sum(case when dim13 = 'x' then msr12 else 0 end) as case_expr, sum(msr1) from basecube "
- + "where "
- + TWO_DAYS_RANGE + " having sum(case when dim13 = 'x' then msr12 else 0 end) > 100 and sum(msr1) > 500", tconf);
+ + "where " + TWO_DAYS_RANGE + " having sum(case when dim13 = 'x' then msr12 else 0 end) > 100 "
+ + "and sum(msr1) > 500", tconf);
String expected1 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, sum(case when basecube.dim13 = 'x' then basecube"
- + ".msr12 else 0 end) as `expr2` FROM ", null,
- " group by basecube.dim1 having sum(case when basecube.dim13 = 'x' then basecube.msr12 else 0 end) > 100",
- getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, sum(case when ((basecube.dim13) = 'x') then "
+ + "(basecube.msr12) else 0 end) as `alias1`, 0.0 as `alias2` FROM", null, " group by basecube.dim1",
+ getWhereForHourly2days(cubeName, "C1_testfact2_raw_base"));
String expected2 =
- getExpectedQuery(cubeName, "select basecube.dim1 as `dim1`, sum(basecube.msr1) as `expr3` FROM ", null,
- " group by basecube.dim1 having sum(basecube.msr1) > 500",
- getWhereForHourly2days(cubeName, "c1_testfact1_raw_base"));
+ getExpectedQuery(cubeName, "SELECT (basecube.dim1) as `alias0`, 0.0 as `alias1`, sum((basecube.msr1)) "
+ + "as `alias2` FROM", null, " group by basecube.dim1",
+ getWhereForHourly2days(cubeName, "c1_testfact1_raw_base"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
assertTrue(hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, mq2.expr2 `case_expr`, mq1.expr3 `sum(msr1)` from ")
- || hqlQuery.toLowerCase().startsWith(
- "select coalesce(mq1.dim1, mq2.dim1) dim1, mq1.expr2 `case_expr`, mq2.expr3 `sum(msr1)` from "), hqlQuery);
- assertTrue(hqlQuery.contains("mq1 full outer join ") && hqlQuery.endsWith("mq2 on mq1.dim1 <=> mq2.dim1"),
- hqlQuery);
+ "select (basecube.alias0) as `dim1`, sum((basecube.alias1)) as `case_expr`, "
+ + "sum((basecube.alias2)) as `sum(msr1)` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL")
+ && hqlQuery.endsWith("HAVING ((sum((basecube.alias1)) > 100) and (sum((basecube.alias2)) > 500))"), hqlQuery);
}
@Test
@@ -849,10 +779,9 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
String hql, expected;
// Prefer fact that has a storage with part col on queried time dim
hql = rewrite("select msr12 from basecube where " + TWO_DAYS_RANGE, conf);
- expected = getExpectedQuery(BASE_CUBE_NAME, "select sum(basecube.msr12) FROM ", null, null,
+ expected = getExpectedQuery(BASE_CUBE_NAME, "select sum(basecube.msr12) as `msr12` FROM ", null, null,
getWhereForDailyAndHourly2days(BASE_CUBE_NAME, "c1_testfact2_base"));
compareQueries(hql, expected);
-
// If going to fallback timedim, and partitions are missing, then error should be missing partition on that
conf.set(CubeQueryConfUtil.DRIVER_SUPPORTED_STORAGES, "C4");
conf.setBoolean(CubeQueryConfUtil.FAIL_QUERY_ON_PARTIAL_DATA, true);
@@ -860,11 +789,11 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
getLensExceptionInRewrite("select msr12 from basecube where " + TWO_DAYS_RANGE, conf);
NoCandidateFactAvailableException ne = (NoCandidateFactAvailableException) exc;
PruneCauses.BriefAndDetailedError pruneCause = ne.getJsonMessage();
- assertTrue(pruneCause.getBrief().contains("Missing partitions"));
- assertEquals(pruneCause.getDetails().get("testfact2_base").iterator().next().getCause(), MISSING_PARTITIONS);
- assertEquals(pruneCause.getDetails().get("testfact2_base").iterator().next().getMissingPartitions().size(), 1);
+ assertTrue(pruneCause.getBrief().contains("Missing partitions"), pruneCause.getBrief());
+ assertEquals(pruneCause.getDetails().get("c4_testfact2_base").iterator().next().getCause(), MISSING_PARTITIONS);
+ assertEquals(pruneCause.getDetails().get("c4_testfact2_base").iterator().next().getMissingPartitions().size(), 1);
assertEquals(
- pruneCause.getDetails().get("testfact2_base").iterator().next().getMissingPartitions().iterator().next(),
+ pruneCause.getDetails().get("c4_testfact2_base").iterator().next().getMissingPartitions().iterator().next(),
"ttd:["
+ UpdatePeriod.SECONDLY.format(DateUtils.addDays(DateUtils.truncate(TWODAYS_BACK, Calendar.HOUR), -10))
+ ", " + UpdatePeriod.SECONDLY.format(DateUtils.addDays(DateUtils.truncate(NOW, Calendar.HOUR), 10))
@@ -884,7 +813,7 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
DateUtils.addDays(TWODAYS_BACK, -5))))) + "' and "
+ "basecube.processing_time < '" + HIVE_QUERY_DATE_PARSER.get().format(ABSDATE_PARSER.get().parse(
getAbsDateFormatString(getDateUptoHours(DateUtils.addDays(NOW, 5)))));
- expected = getExpectedQuery(BASE_CUBE_NAME, "select sum(basecube.msr12) FROM ", null,
+ expected = getExpectedQuery(BASE_CUBE_NAME, "select sum(basecube.msr12) as `msr12` FROM ", null,
" and " + dTimeWhereClause + " and " + pTimeWhereClause,
getWhereForDailyAndHourly2daysWithTimeDim(BASE_CUBE_NAME, "ttd",
DateUtils.addDays(TWODAYS_BACK, -10), DateUtils.addDays(NOW, 10), "c4_testfact2_base"));
@@ -893,32 +822,27 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
// Multiple timedims in single query. test that
CubeQueryContext ctx =
rewriteCtx("select msr12 from basecube where " + TWO_DAYS_RANGE + " and " + TWO_DAYS_RANGE_TTD, conf);
- assertEquals(ctx.getCandidateFactSets().size(), 1);
- assertEquals(ctx.getCandidateFactSets().iterator().next().size(), 1);
- CandidateFact cfact = ctx.getCandidateFactSets().iterator().next().iterator().next();
-
- assertEquals(cfact.getRangeToStoragePartMap().size(), 2);
- Set<String> storages = Sets.newHashSet();
- for(Map<String, String> entry: cfact.getRangeToStorageWhereMap().values()) {
- storages.addAll(entry.keySet());
- }
- assertEquals(storages.size(), 1);
- String storage = storages.iterator().next();
- for(Map.Entry<TimeRange, Map<String, String>> entry: cfact.getRangeToStorageWhereMap().entrySet()) {
- if (entry.getKey().getPartitionColumn().equals("dt")) {
- ASTNode parsed = HQLParser.parseExpr(entry.getValue().get(storage));
+ assertEquals(ctx.getCandidates().size(), 1);
+ assertEquals(CandidateUtil.getStorageCandidates(ctx.getCandidates().iterator().next()).size(), 1);
+ StorageCandidate sc = CandidateUtil.getStorageCandidates(ctx.getCandidates().iterator().next()).iterator().next();
+ assertEquals(sc.getRangeToPartitions().size(), 2);
+ for(TimeRange range: sc.getRangeToPartitions().keySet()) {
+ String rangeWhere = CandidateUtil.getTimeRangeWhereClasue(ctx.getRangeWriter(), sc, range);
+ if (range.getPartitionColumn().equals("dt")) {
+ ASTNode parsed = HQLParser.parseExpr(rangeWhere);
assertEquals(parsed.getToken().getType(), KW_AND);
- assertTrue(entry.getValue().get(storage).substring(((CommonToken) parsed.getToken()).getStopIndex() + 1)
+ assertTrue(rangeWhere.substring(((CommonToken) parsed.getToken()).getStopIndex() + 1)
.toLowerCase().contains(dTimeWhereClause));
- assertFalse(entry.getValue().get(storage).substring(0, ((CommonToken) parsed.getToken()).getStartIndex())
+ assertFalse(rangeWhere.substring(0, ((CommonToken) parsed.getToken()).getStartIndex())
.toLowerCase().contains("and"));
- } else if (entry.getKey().getPartitionColumn().equals("ttd")) {
- assertFalse(entry.getValue().get(storage).toLowerCase().contains("and"));
+ } else if (range.getPartitionColumn().equals("ttd")) {
+ assertFalse(rangeWhere.toLowerCase().contains("and"));
} else {
throw new LensException("Unexpected");
}
}
}
+
@Test
public void testMultiFactQueryWithHaving() throws Exception {
@@ -930,198 +854,205 @@ public class TestBaseCubeQueries extends TestQueryRewrite {
hqlQuery = rewrite("select dim1, dim11, msr12 from basecube where " + TWO_DAYS_RANGE
+ "having roundedmsr2 > 0", conf);
expected1 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11, sum(basecube.msr12) as msr12 FROM ",
- null, " group by basecube.dim1, basecube.dim11",
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, sum((basecube.msr12)) "
+ + "as `alias2`, 0.0 as `alias3` FROM ", null, " group by basecube.dim1, basecube.dim11",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11 FROM ",
- null, " group by basecube.dim1, basecube.dim11 having round(sum(basecube.msr2)/1000) > 0",
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, 0.0 as `alias2`, "
+ + "sum((basecube.msr2)) as `alias3` FROM ", null, " group by basecube.dim1, basecube.dim11",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
- assertTrue(hqlQuery.toLowerCase().contains("having"));
+ assertTrue(hqlQuery.toLowerCase().contains("group by (basecube.alias0), (basecube.alias1)"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, "
- + "coalesce(mq1.dim11, mq2.dim11) dim11, mq2.msr12 msr12 from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, coalesce(mq1.dim11, mq2.dim11) "
- + "dim11, mq1.msr12 msr12 from "), hqlQuery);
- assertTrue(hqlQuery.contains(joinSubString)
- && hqlQuery.endsWith(endSubString), hqlQuery);
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `dim1`, (basecube.alias1) as `dim11`, "
+ + "sum((basecube.alias2)) as `msr12` from"), hqlQuery);
+ assertTrue(hqlQuery.endsWith("HAVING (round((sum((basecube.alias3)) / 1000)) > 0)"));
// Two having clause, one from each fact.
hqlQuery = rewrite("select dim1, dim11, msr12, roundedmsr2 from basecube where " + TWO_DAYS_RANGE
+ "having msr12 > 2 and roundedmsr2 > 0", conf);
expected1 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11, sum(basecube.msr12) as msr12 FROM ",
- null, " group by basecube.dim1, basecube.dim11 HAVING sum(basecube.msr12) > 2",
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, sum((basecube.msr12)) as `alias2`, "
+ + "0.0 as `alias3` FROM ", null, " group by basecube.dim1, basecube.dim11",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11, round(sum(basecube.msr2)/1000) as roundedmsr2 FROM ",
- null, " group by basecube.dim1, basecube.dim11 HAVING round(sum(basecube.msr2)/1000) > 0",
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, 0.0 as `alias2`, "
+ + "sum((basecube.msr2)) as `alias3` FROM ", null, " group by basecube.dim1, basecube.dim11",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, "
- + "coalesce(mq1.dim11, mq2.dim11) dim11, mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, "
- + "coalesce(mq1.dim11, mq2.dim11) dim11, mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2 from "), hqlQuery);
- assertTrue(hqlQuery.contains(joinSubString)
- && hqlQuery.endsWith(endSubString), hqlQuery);
-
- // Two having clauses and one complex expression in having which needs to be split over the two facts
- // And added as where clause outside
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `dim1`, (basecube.alias1) as `dim11`, "
+ + "sum((basecube.alias2)) as `msr12`, round((sum((basecube.alias3)) / 1000)) as `roundedmsr2` from"),
+ hqlQuery);
+ assertTrue(hqlQuery.endsWith("HAVING ((sum((basecube.alias2)) > 2) "
+ + "and (round((sum((basecube.alias3)) / 1000)) > 0))"));
+
hqlQuery = rewrite("select dim1, dim11, msr12, roundedmsr2 from basecube where " + TWO_DAYS_RANGE
- + "having flooredmsr12+roundedmsr2 <= 1000 and msr12 > 2 and roundedmsr2 > 0", conf);
+ + "having msr12+roundedmsr2 <= 1000 and msr12 > 2 and roundedmsr2 > 0", conf);
expected1 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11, sum(basecube.msr12) as msr12 , "
- + "floor(sum(basecube.msr12)) as alias0 FROM ",
- null, " group by basecube.dim1, basecube.dim11 HAVING sum(basecube.msr12) > 2",
- getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, sum((basecube.msr12)) as `alias2`, "
+ + "0.0 as `alias3` FROM ", null, " group by basecube.dim1, basecube.dim11",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
+
+ expected2 = getExpectedQuery(cubeName,
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, 0.0 as `alias2`, "
+ + "sum((basecube.msr2)) as `alias3` FROM ", null, " group by basecube.dim1, basecube.dim11",
+ getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, "
- + "coalesce(mq1.dim11, mq2.dim11) dim11, mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, "
- + "coalesce(mq1.dim11, mq2.dim11) dim11, mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2 from "), hqlQuery);
- assertTrue(hqlQuery.contains(joinSubString)
- && hqlQuery.endsWith(endSubString + " WHERE ((alias0 + roundedmsr2) <= 1000)"), hqlQuery);
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `dim1`, (basecube.alias1) as `dim11`, "
+ + "sum((basecube.alias2)) as `msr12`, round((sum((basecube.alias3)) / 1000)) as `roundedmsr2` from"), hqlQuery);
+ assertTrue(hqlQuery.endsWith("(((sum((basecube.alias2)) + round((sum((basecube.alias3)) / 1000))) <= 1000) "
+ + "and (sum((basecube.alias2)) > 2) and (round((sum((basecube.alias3)) / 1000)) > 0))"), hqlQuery);
// No push-down-able having clauses.
hqlQuery = rewrite("select dim1, dim11, msr12, roundedmsr2 from basecube where " + TWO_DAYS_RANGE
- + "having flooredmsr12+roundedmsr2 <= 1000", conf);
+ + "having msr12+roundedmsr2 <= 1000", conf);
expected1 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11, sum(basecube.msr12) as msr12, "
- + "floor(sum(( basecube . msr12 ))) as `alias0` FROM ",
- null, " group by basecube.dim1, basecube.dim11",
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, sum((basecube.msr12)) as `alias2`, "
+ + "0.0 as `alias3` FROM", null, " group by basecube.dim1, basecube.dim11",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11, round(sum(basecube.msr2)/1000) as roundedmsr2 FROM ",
- null, " group by basecube.dim1, basecube.dim11",
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, 0.0 as `alias2`, sum((basecube.msr2)) "
+ + "as `alias3` FROM", null, " group by basecube.dim1, basecube.dim11",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
- assertFalse(hqlQuery.toLowerCase().contains("having"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, "
- + "coalesce(mq1.dim11, mq2.dim11) dim11, mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, coalesce(mq1.dim11, mq2.dim11) "
- + "dim11, mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2 from "), hqlQuery);
- assertTrue(hqlQuery.contains(joinSubString)
- && hqlQuery.endsWith(endSubString + " WHERE ((alias0 + roundedmsr2) <= 1000)"), hqlQuery);
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `dim1`, (basecube.alias1) as `dim11`, "
+ + "sum((basecube.alias2)) as `msr12`, round((sum((basecube.alias3)) / 1000)) as `roundedmsr2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL")
+ && hqlQuery.endsWith("HAVING ((sum((basecube.alias2)) + "
+ + "round((sum((basecube.alias3)) / 1000))) <= 1000)"), hqlQuery);
// function over expression of two functions over measures
hqlQuery = rewrite("select dim1, dim11, msr12, roundedmsr2 from basecube where " + TWO_DAYS_RANGE
- + "having round(flooredmsr12+roundedmsr2) <= 1000", conf);
+ + "having round(msr12+roundedmsr2) <= 1000", conf);
expected1 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11, sum(basecube.msr12) as msr12, "
- + "floor(sum(( basecube . msr12 ))) as `alias0` FROM ",
- null, " group by basecube.dim1, basecube.dim11",
+ "SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, sum((basecube.msr12)) as `alias2`, "
+ + "0.0 as `alias3` FROM ", null, " group by basecube.dim1, basecube.dim11",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact2_BASE"));
expected2 = getExpectedQuery(cubeName,
- "select basecube.dim1 as dim1, basecube.dim11 as dim11, round(sum(basecube.msr2)/1000) as roundedmsr2 FROM ",
- null, " group by basecube.dim1, basecube.dim11",
+ " SELECT (basecube.dim1) as `alias0`, (basecube.dim11) as `alias1`, 0.0 as `alias2`, "
+ + "sum((basecube.msr2)) as `alias3` FROM ", null, " group by basecube.dim1, basecube.dim11",
getWhereForDailyAndHourly2days(cubeName, "C1_testFact1_BASE"));
- assertFalse(hqlQuery.toLowerCase().contains("having"));
compareContains(expected1, hqlQuery);
compareContains(expected2, hqlQuery);
- assertTrue(hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, "
- + "coalesce(mq1.dim11, mq2.dim11) dim11, mq2.msr12 msr12, mq1.roundedmsr2 roundedmsr2 from ")
- || hqlQuery.toLowerCase().startsWith("select coalesce(mq1.dim1, mq2.dim1) dim1, coalesce(mq1.dim11, mq2.dim11) "
- + "dim11, mq1.msr12 msr12, mq2.roundedmsr2 roundedmsr2 from "), hqlQuery);
- assertTrue(hqlQuery.contains(joinSubString)
- && hqlQuery.endsWith(endSubString + " WHERE (round((alias0 + roundedmsr2)) <= 1000)"), hqlQuery);
+ assertTrue(hqlQuery.toLowerCase().startsWith("select (basecube.alias0) as `dim1`, (basecube.alias1) as `dim11`, "
+ + "sum((basecube.alias2)) as `msr12`, round((sum((basecube.alias3)) / 1000)) "
+ + "as `roundedmsr2` from"), hqlQuery);
+ assertTrue(hqlQuery.contains("UNION ALL")
+ && hqlQuery.endsWith(" HAVING (round((sum((basecube.alias2)) + "
+ + "round((sum((basecube.alias3)) / 1000)))) <= 1000)"), hqlQuery);
// Following test cases only select dimensions, and all the measures are in having.
// Mostly tests follow the same pattern as the above tests,
// The extra thing to test is the inclusion of sub-expressions in select clauses.
-
hqlQuery = rewrite("select dim1, dim11 from basecube where " + TWO_
<TRUNCATED>