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>
