columnPositions = result.getAxes()[0].getPositions();
Member measure = columnPositions.get(ordinal).get(0);
assertEquals(expectedName, measure.getName());
assertEquals(
expectedVisibility,
measure.getPropertyValue(Property.VISIBLE.name));
}
/**
* Test an expression for the format_string of a calculated member that
* evaluates calculated members based on a virtual cube. One cube has cache
* turned on, the other cache turned off.
*
* Since evaluation of the format_string used to happen after the
* aggregate cache was cleared, this used to fail, this should be solved
* with the caching of the format string.
*
*
Without caching of format string, the query returns green for all
* styles.
*/
public void testFormatStringExpressionCubeNoCache() {
TestContext testContext = TestContext.instance().create(
null,
null,
"\n"
+ " \n"
+ "\n"
+ " \n"
+ " \n"
+ " \n"
+ "\n"
+ "\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " [Measures].[Store Sales] - [Measures].[Store Cost]\n"
+ " \n"
+ " \n"
+ " [Measures].[Profit] / [Measures].[Units Shipped]\n"
+ " 2.0), '|0.#|style=green', '|0.#|style=red')\"/>\n"
+ " \n"
+ "",
null,
null,
null);
testContext.assertQueryReturns(
"select {[Measures].[Profit Per Unit Shipped]} ON COLUMNS, "
+ "{[Store].[All Stores].[USA].[CA], [Store].[All Stores].[USA].[OR], [Store].[All Stores].[USA].[WA]} ON ROWS "
+ "from [Warehouse and Sales Format Expression Cube No Cache] "
+ "where [Time].[1997]",
"Axis #0:\n"
+ "{[Time].[1997]}\n"
+ "Axis #1:\n"
+ "{[Measures].[Profit Per Unit Shipped]}\n"
+ "Axis #2:\n"
+ "{[Store].[USA].[CA]}\n"
+ "{[Store].[USA].[OR]}\n"
+ "{[Store].[USA].[WA]}\n"
+ "Row #0: |1.6|style=red\n"
+ "Row #1: |2.1|style=green\n"
+ "Row #2: |1.5|style=red\n");
}
public void testCalculatedMeasure() {
// calculated measures reference measures defined in the base cube
assertQueryReturns(
"select\n"
+ "{[Measures].[Profit Growth], "
+ "[Measures].[Profit], "
+ "[Measures].[Average Warehouse Sale] }\n"
+ "ON COLUMNS\n"
+ "from [Warehouse and Sales]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Profit Growth]}\n"
+ "{[Measures].[Profit]}\n"
+ "{[Measures].[Average Warehouse Sale]}\n"
+ "Row #0: 0.0%\n"
+ "Row #0: $339,610.90\n"
+ "Row #0: $2.21\n");
}
public void testLostData() {
assertQueryReturns(
"select {[Time].[Time].Members} on columns,\n"
+ " {[Product].Children} on rows\n"
+ "from [Sales]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Time].[1997]}\n"
+ "{[Time].[1997].[Q1]}\n"
+ "{[Time].[1997].[Q1].[1]}\n"
+ "{[Time].[1997].[Q1].[2]}\n"
+ "{[Time].[1997].[Q1].[3]}\n"
+ "{[Time].[1997].[Q2]}\n"
+ "{[Time].[1997].[Q2].[4]}\n"
+ "{[Time].[1997].[Q2].[5]}\n"
+ "{[Time].[1997].[Q2].[6]}\n"
+ "{[Time].[1997].[Q3]}\n"
+ "{[Time].[1997].[Q3].[7]}\n"
+ "{[Time].[1997].[Q3].[8]}\n"
+ "{[Time].[1997].[Q3].[9]}\n"
+ "{[Time].[1997].[Q4]}\n"
+ "{[Time].[1997].[Q4].[10]}\n"
+ "{[Time].[1997].[Q4].[11]}\n"
+ "{[Time].[1997].[Q4].[12]}\n"
+ "{[Time].[1998]}\n"
+ "{[Time].[1998].[Q1]}\n"
+ "{[Time].[1998].[Q1].[1]}\n"
+ "{[Time].[1998].[Q1].[2]}\n"
+ "{[Time].[1998].[Q1].[3]}\n"
+ "{[Time].[1998].[Q2]}\n"
+ "{[Time].[1998].[Q2].[4]}\n"
+ "{[Time].[1998].[Q2].[5]}\n"
+ "{[Time].[1998].[Q2].[6]}\n"
+ "{[Time].[1998].[Q3]}\n"
+ "{[Time].[1998].[Q3].[7]}\n"
+ "{[Time].[1998].[Q3].[8]}\n"
+ "{[Time].[1998].[Q3].[9]}\n"
+ "{[Time].[1998].[Q4]}\n"
+ "{[Time].[1998].[Q4].[10]}\n"
+ "{[Time].[1998].[Q4].[11]}\n"
+ "{[Time].[1998].[Q4].[12]}\n"
+ "Axis #2:\n"
+ "{[Product].[Drink]}\n"
+ "{[Product].[Food]}\n"
+ "{[Product].[Non-Consumable]}\n"
+ "Row #0: 24,597\n"
+ "Row #0: 5,976\n"
+ "Row #0: 1,910\n"
+ "Row #0: 1,951\n"
+ "Row #0: 2,115\n"
+ "Row #0: 5,895\n"
+ "Row #0: 1,948\n"
+ "Row #0: 2,039\n"
+ "Row #0: 1,908\n"
+ "Row #0: 6,065\n"
+ "Row #0: 2,205\n"
+ "Row #0: 1,921\n"
+ "Row #0: 1,939\n"
+ "Row #0: 6,661\n"
+ "Row #0: 1,898\n"
+ "Row #0: 2,344\n"
+ "Row #0: 2,419\n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #1: 191,940\n"
+ "Row #1: 47,809\n"
+ "Row #1: 15,604\n"
+ "Row #1: 15,142\n"
+ "Row #1: 17,063\n"
+ "Row #1: 44,825\n"
+ "Row #1: 14,393\n"
+ "Row #1: 15,055\n"
+ "Row #1: 15,377\n"
+ "Row #1: 47,440\n"
+ "Row #1: 17,036\n"
+ "Row #1: 15,741\n"
+ "Row #1: 14,663\n"
+ "Row #1: 51,866\n"
+ "Row #1: 14,232\n"
+ "Row #1: 18,278\n"
+ "Row #1: 19,356\n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #2: 50,236\n"
+ "Row #2: 12,506\n"
+ "Row #2: 4,114\n"
+ "Row #2: 3,864\n"
+ "Row #2: 4,528\n"
+ "Row #2: 11,890\n"
+ "Row #2: 3,838\n"
+ "Row #2: 3,987\n"
+ "Row #2: 4,065\n"
+ "Row #2: 12,343\n"
+ "Row #2: 4,522\n"
+ "Row #2: 4,035\n"
+ "Row #2: 3,786\n"
+ "Row #2: 13,497\n"
+ "Row #2: 3,828\n"
+ "Row #2: 4,648\n"
+ "Row #2: 5,021\n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n");
assertQueryReturns(
"select\n"
+ " {[Measures].[Unit Sales]} on 0,\n"
+ " {[Product].Children} on 1\n"
+ "from [Warehouse and Sales]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n"
+ "{[Product].[Drink]}\n"
+ "{[Product].[Food]}\n"
+ "{[Product].[Non-Consumable]}\n"
+ "Row #0: 24,597\n"
+ "Row #1: 191,940\n"
+ "Row #2: 50,236\n");
}
/**
* Tests a calc measure which combines a measures from the Sales cube with a
* measures from the Warehouse cube.
*/
public void testCalculatedMeasureAcrossCubes() {
assertQueryReturns(
"with member [Measures].[Shipped per Ordered] as ' [Measures].[Units Shipped] / [Measures].[Unit Sales] ', format_string='#.00%'\n"
+ " member [Measures].[Profit per Unit Shipped] as ' [Measures].[Profit] / [Measures].[Units Shipped] '\n"
+ "select\n"
+ " {[Measures].[Unit Sales], \n"
+ " [Measures].[Units Shipped],\n"
+ " [Measures].[Shipped per Ordered],\n"
+ " [Measures].[Profit per Unit Shipped]} on 0,\n"
+ " NON EMPTY Crossjoin([Product].Children, [Time].[1997].Children) on 1\n"
+ "from [Warehouse and Sales]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "{[Measures].[Units Shipped]}\n"
+ "{[Measures].[Shipped per Ordered]}\n"
+ "{[Measures].[Profit per Unit Shipped]}\n"
+ "Axis #2:\n"
+ "{[Product].[Drink], [Time].[1997].[Q1]}\n"
+ "{[Product].[Drink], [Time].[1997].[Q2]}\n"
+ "{[Product].[Drink], [Time].[1997].[Q3]}\n"
+ "{[Product].[Drink], [Time].[1997].[Q4]}\n"
+ "{[Product].[Food], [Time].[1997].[Q1]}\n"
+ "{[Product].[Food], [Time].[1997].[Q2]}\n"
+ "{[Product].[Food], [Time].[1997].[Q3]}\n"
+ "{[Product].[Food], [Time].[1997].[Q4]}\n"
+ "{[Product].[Non-Consumable], [Time].[1997].[Q1]}\n"
+ "{[Product].[Non-Consumable], [Time].[1997].[Q2]}\n"
+ "{[Product].[Non-Consumable], [Time].[1997].[Q3]}\n"
+ "{[Product].[Non-Consumable], [Time].[1997].[Q4]}\n"
+ "Row #0: 5,976\n"
+ "Row #0: 4637.0\n"
+ "Row #0: 77.59%\n"
+ "Row #0: $1.50\n"
+ "Row #1: 5,895\n"
+ "Row #1: 4501.0\n"
+ "Row #1: 76.35%\n"
+ "Row #1: $1.60\n"
+ "Row #2: 6,065\n"
+ "Row #2: 6258.0\n"
+ "Row #2: 103.18%\n"
+ "Row #2: $1.15\n"
+ "Row #3: 6,661\n"
+ "Row #3: 5802.0\n"
+ "Row #3: 87.10%\n"
+ "Row #3: $1.38\n"
+ "Row #4: 47,809\n"
+ "Row #4: 37153.0\n"
+ "Row #4: 77.71%\n"
+ "Row #4: $1.64\n"
+ "Row #5: 44,825\n"
+ "Row #5: 35459.0\n"
+ "Row #5: 79.11%\n"
+ "Row #5: $1.62\n"
+ "Row #6: 47,440\n"
+ "Row #6: 41545.0\n"
+ "Row #6: 87.57%\n"
+ "Row #6: $1.47\n"
+ "Row #7: 51,866\n"
+ "Row #7: 34706.0\n"
+ "Row #7: 66.91%\n"
+ "Row #7: $1.91\n"
+ "Row #8: 12,506\n"
+ "Row #8: 9161.0\n"
+ "Row #8: 73.25%\n"
+ "Row #8: $1.76\n"
+ "Row #9: 11,890\n"
+ "Row #9: 9227.0\n"
+ "Row #9: 77.60%\n"
+ "Row #9: $1.65\n"
+ "Row #10: 12,343\n"
+ "Row #10: 9986.0\n"
+ "Row #10: 80.90%\n"
+ "Row #10: $1.59\n"
+ "Row #11: 13,497\n"
+ "Row #11: 9291.0\n"
+ "Row #11: 68.84%\n"
+ "Row #11: $1.86\n");
}
/**
* Tests a calc member defined in the cube.
*/
public void testCalculatedMemberInSchema() {
TestContext testContext = TestContext.instance().createSubstitutingCube(
"Warehouse and Sales",
null,
" \n"
+ " [Measures].[Units Shipped] / [Measures].[Unit Sales]\n"
+ " \n"
+ " \n");
testContext.assertQueryReturns(
"select\n"
+ " {[Measures].[Unit Sales], \n"
+ " [Measures].[Shipped per Ordered]} on 0,\n"
+ " NON EMPTY Crossjoin([Product].Children, [Time].[1997].Children) on 1\n"
+ "from [Warehouse and Sales]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "{[Measures].[Shipped per Ordered]}\n"
+ "Axis #2:\n"
+ "{[Product].[Drink], [Time].[1997].[Q1]}\n"
+ "{[Product].[Drink], [Time].[1997].[Q2]}\n"
+ "{[Product].[Drink], [Time].[1997].[Q3]}\n"
+ "{[Product].[Drink], [Time].[1997].[Q4]}\n"
+ "{[Product].[Food], [Time].[1997].[Q1]}\n"
+ "{[Product].[Food], [Time].[1997].[Q2]}\n"
+ "{[Product].[Food], [Time].[1997].[Q3]}\n"
+ "{[Product].[Food], [Time].[1997].[Q4]}\n"
+ "{[Product].[Non-Consumable], [Time].[1997].[Q1]}\n"
+ "{[Product].[Non-Consumable], [Time].[1997].[Q2]}\n"
+ "{[Product].[Non-Consumable], [Time].[1997].[Q3]}\n"
+ "{[Product].[Non-Consumable], [Time].[1997].[Q4]}\n"
+ "Row #0: 5,976\n"
+ "Row #0: 77.6%\n"
+ "Row #1: 5,895\n"
+ "Row #1: 76.4%\n"
+ "Row #2: 6,065\n"
+ "Row #2: 103.2%\n"
+ "Row #3: 6,661\n"
+ "Row #3: 87.1%\n"
+ "Row #4: 47,809\n"
+ "Row #4: 77.7%\n"
+ "Row #5: 44,825\n"
+ "Row #5: 79.1%\n"
+ "Row #6: 47,440\n"
+ "Row #6: 87.6%\n"
+ "Row #7: 51,866\n"
+ "Row #7: 66.9%\n"
+ "Row #8: 12,506\n"
+ "Row #8: 73.3%\n"
+ "Row #9: 11,890\n"
+ "Row #9: 77.6%\n"
+ "Row #10: 12,343\n"
+ "Row #10: 80.9%\n"
+ "Row #11: 13,497\n"
+ "Row #11: 68.8%\n");
}
public void testAllMeasureMembers() {
// result should exclude measures that are not explicitly defined
// in the virtual cube (e.g., [Profit last Period])
assertQueryReturns(
"select\n"
+ "{[Measures].allMembers} on columns\n"
+ "from [Warehouse and Sales]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Sales Count]}\n"
+ "{[Measures].[Store Cost]}\n"
+ "{[Measures].[Store Sales]}\n"
+ "{[Measures].[Unit Sales]}\n"
+ "{[Measures].[Store Invoice]}\n"
+ "{[Measures].[Supply Time]}\n"
+ "{[Measures].[Units Ordered]}\n"
+ "{[Measures].[Units Shipped]}\n"
+ "{[Measures].[Warehouse Cost]}\n"
+ "{[Measures].[Warehouse Profit]}\n"
+ "{[Measures].[Warehouse Sales]}\n"
+ "{[Measures].[Profit]}\n"
+ "{[Measures].[Profit Growth]}\n"
+ "{[Measures].[Average Warehouse Sale]}\n"
+ "{[Measures].[Profit Per Unit Shipped]}\n"
+ "Row #0: 86,837\n"
+ "Row #0: 225,627.23\n"
+ "Row #0: 565,238.13\n"
+ "Row #0: 266,773\n"
+ "Row #0: 102,278.409\n"
+ "Row #0: 10,425\n"
+ "Row #0: 227238.0\n"
+ "Row #0: 207726.0\n"
+ "Row #0: 89,043.253\n"
+ "Row #0: 107,727.635\n"
+ "Row #0: 196,770.888\n"
+ "Row #0: $339,610.90\n"
+ "Row #0: 0.0%\n"
+ "Row #0: $2.21\n"
+ "Row #0: $1.63\n");
}
/**
* Test a virtual cube where one of the dimensions contains an
* ordinalColumn property
*/
public void testOrdinalColumn() {
TestContext testContext = TestContext.instance().create(
null,
null,
"\n"
+ "\n"
+ "\n"
+ "\n"
+ "",
null,
null,
null);
testContext.assertQueryReturns(
"select {[Measures].[Org Salary]} on columns, "
+ "non empty "
+ "crossjoin([Store].[Store Country].members, [Position].[Store Management].children) "
+ "on rows from [Sales vs HR]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Org Salary]}\n"
+ "Axis #2:\n"
+ "{[Store].[Canada], [Position].[Store Management].[Store Manager]}\n"
+ "{[Store].[Canada], [Position].[Store Management].[Store Assistant Manager]}\n"
+ "{[Store].[Canada], [Position].[Store Management].[Store Shift Supervisor]}\n"
+ "{[Store].[Mexico], [Position].[Store Management].[Store Manager]}\n"
+ "{[Store].[Mexico], [Position].[Store Management].[Store Assistant Manager]}\n"
+ "{[Store].[Mexico], [Position].[Store Management].[Store Shift Supervisor]}\n"
+ "{[Store].[USA], [Position].[Store Management].[Store Manager]}\n"
+ "{[Store].[USA], [Position].[Store Management].[Store Assistant Manager]}\n"
+ "{[Store].[USA], [Position].[Store Management].[Store Shift Supervisor]}\n"
+ "Row #0: $462.86\n"
+ "Row #1: $394.29\n"
+ "Row #2: $565.71\n"
+ "Row #3: $13,254.55\n"
+ "Row #4: $11,443.64\n"
+ "Row #5: $17,705.46\n"
+ "Row #6: $4,069.80\n"
+ "Row #7: $3,417.72\n"
+ "Row #8: $5,145.96\n");
}
public void testDefaultMeasureProperty() {
TestContext testContext = TestContext.instance().create(
null,
null,
"\n"
+ "\n"
+ "\n"
+ "\n"
+ "\n"
+ "",
null,
null,
null);
String queryWithoutFilter =
"select"
+ " from [Sales vs Warehouse]";
String queryWithDeflaultMeasureFilter =
"select "
+ "from [Sales vs Warehouse] where measures.[Unit Sales]";
assertQueriesReturnSimilarResults(
queryWithoutFilter, queryWithDeflaultMeasureFilter, testContext);
}
/**
* Checks that native set caching considers base cubes in the cache key.
* Native sets referencing different base cubes do not share the cached
* result.
*/
public void testNativeSetCaching() {
// Only need to run this against one db to verify caching
// behavior is correct.
final Dialect dialect = getTestContext().getDialect();
if (dialect.getDatabaseProduct() != Dialect.DatabaseProduct.DERBY) {
return;
}
if (!MondrianProperties.instance().EnableNativeCrossJoin.get()
&& !MondrianProperties.instance().EnableNativeNonEmpty.get())
{
// Only run the tests if either native CrossJoin or native NonEmpty
// is enabled.
return;
}
String query1 =
"With "
+ "Set [*NATIVE_CJ_SET] as 'NonEmptyCrossJoin([Product].[Product Family].Members, [Store].[Store Country].Members)' "
+ "Select "
+ "{[Store Sales]} on columns, "
+ "Non Empty Generate([*NATIVE_CJ_SET], {([Product].CurrentMember,[Store].CurrentMember)}) on rows "
+ "From [Warehouse and Sales]";
String query2 =
"With "
+ "Set [*NATIVE_CJ_SET] as 'NonEmptyCrossJoin([Product].[Product Family].Members, [Store].[Store Country].Members)' "
+ "Select "
+ "{[Warehouse Sales]} on columns, "
+ "Non Empty Generate([*NATIVE_CJ_SET], {([Product].CurrentMember,[Store].CurrentMember)}) on rows "
+ "From [Warehouse and Sales]";
String derbyNecjSql1, derbyNecjSql2;
if (MondrianProperties.instance().EnableNativeCrossJoin.get()) {
derbyNecjSql1 =
"select "
+ "\"product_class\".\"product_family\", "
+ "\"store\".\"store_country\" "
+ "from "
+ "\"product\" as \"product\", "
+ "\"product_class\" as \"product_class\", "
+ "\"sales_fact_1997\" as \"sales_fact_1997\", "
+ "\"store\" as \"store\" "
+ "where "
+ "\"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" "
+ "and \"sales_fact_1997\".\"product_id\" = \"product\".\"product_id\" "
+ "and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "group by \"product_class\".\"product_family\", \"store\".\"store_country\" "
+ "order by 1 ASC, 2 ASC";
derbyNecjSql2 =
"select "
+ "\"product_class\".\"product_family\", "
+ "\"store\".\"store_country\" "
+ "from "
+ "\"product\" as \"product\", "
+ "\"product_class\" as \"product_class\", "
+ "\"inventory_fact_1997\" as \"inventory_fact_1997\", "
+ "\"store\" as \"store\" "
+ "where "
+ "\"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" "
+ "and \"inventory_fact_1997\".\"product_id\" = \"product\".\"product_id\" "
+ "and \"inventory_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "group by \"product_class\".\"product_family\", \"store\".\"store_country\" "
+ "order by 1 ASC, 2 ASC";
} else {
// NECJ is truend off so native NECJ SQL will not be generated;
// however, because the NECJ set should not find match in the cache,
// each NECJ input will still be joined with the correct
// fact table if NonEmpty condition is natively evaluated.
derbyNecjSql1 =
"select "
+ "\"store\".\"store_country\" "
+ "from "
+ "\"store\" as \"store\", "
+ "\"sales_fact_1997\" as \"sales_fact_1997\" "
+ "where "
+ "\"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "group by \"store\".\"store_country\" "
+ "order by 1 ASC";
derbyNecjSql2 =
"select "
+ "\"store\".\"store_country\" "
+ "from "
+ "\"store\" as \"store\", "
+ "\"inventory_fact_1997\" as \"inventory_fact_1997\" "
+ "where "
+ "\"inventory_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "group by \"store\".\"store_country\" "
+ "order by 1 ASC";
}
SqlPattern[] patterns1 = {
new SqlPattern(
Dialect.DatabaseProduct.DERBY, derbyNecjSql1, derbyNecjSql1)
};
SqlPattern[] patterns2 = {
new SqlPattern(
Dialect.DatabaseProduct.DERBY, derbyNecjSql2, derbyNecjSql2)
};
// Run query 1 with cleared cache;
// Make sure NECJ 1 is evaluated natively.
assertQuerySql(query1, patterns1, true);
// Now run query 2 with warm cache;
// Make sure NECJ 2 does not reuse the cache result from NECJ 1, and
// NECJ 2 is evaluated natively.
assertQuerySql(query2, patterns2, false);
}
/**
* Test case for bug
* MONDRIAN-322, "cube.getStar() throws NullPointerException".
* Happens when you aggregate distinct-count measures in a virtual cube.
*/
public void testBugMondrian322() {
final TestContext testContext = TestContext.instance().create(
null,
null,
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "",
null,
null,
null);
/*
* This test case does not actually reject the dimension constraint from
* an unrelated base cube. The reason is that the constraint contains an
* AllLevel member. Even though semantically constraining Cells using an
* non-existent dimension perhaps does not make sense; however, in the
* case where the constraint contains AllLevel member, the constraint
* can be considered "always true".
*
* See the next test case for a constraint that does not contain
* AllLevel member and hence cannot be satisfied. The cell should be
* empty.
*/
testContext.assertQueryReturns(
"with member [Warehouse].[x] as 'Aggregate([Warehouse].members)'\n"
+ "member [Measures].[foo] AS '([Warehouse].[x],[Measures].[Customer Count])'\n"
+ "select {[Measures].[foo]} on 0 from [Warehouse And Sales2]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[foo]}\n"
+ "Row #0: 5,581\n");
}
public void testBugMondrian322a() {
final TestContext testContext = TestContext.instance().create(
null,
null,
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "",
null,
null,
null);
testContext.assertQueryReturns(
"with member [Warehouse].[x] as 'Aggregate({[Warehouse].[Canada], [Warehouse].[USA]})'\n"
+ "member [Measures].[foo] AS '([Warehouse].[x],[Measures].[Customer Count])'\n"
+ "select {[Measures].[foo]} on 0 from [Warehouse And Sales2]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[foo]}\n"
+ "Row #0: \n");
}
/**
* Test case for bug
* MONDRIAN-352, "Caption is not set on RolapVirtualCubeMesure".
*/
public void testVirtualCubeMeasureCaption() {
TestContext testContext = TestContext.instance().create(
null,
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n",
"\n"
+ " \n"
+ " \n"
+ "",
null,
null,
null);
Result result = testContext.executeQuery(
"select {[Measures].[Store Sqft]} ON COLUMNS,"
+ "{[HCB]} ON ROWS "
+ "from [VirtualTestStore]");
Axis[] axes = result.getAxes();
List positions = axes[0].getPositions();
Member m0 = positions.get(0).get(0);
String caption = m0.getCaption();
assertEquals("Store Sqft Caption", caption);
}
/**
* Test that RolapCubeLevel is used correctly in the context of virtual
* cube.
*/
public void testRolapCubeLevelInVirtualCube() {
String query1 =
"With "
+ "Set [*NATIVE_CJ_SET] as 'NonEmptyCrossJoin([*BASE_MEMBERS_Warehouse],[*BASE_MEMBERS_Time])' "
+ "Set [*NATIVE_MEMBERS_Warehouse] as 'Generate([*NATIVE_CJ_SET], {[Warehouse].CurrentMember})' "
+ "Set [*BASE_MEMBERS_Warehouse] as '[Warehouse].[Country].Members' "
+ "Set [*NATIVE_MEMBERS_Time] as 'Generate([*NATIVE_CJ_SET], {[Time].[Time].CurrentMember})' "
+ "Set [*BASE_MEMBERS_Time] as '[Time].[Month].Members' "
+ "Set [*BASE_MEMBERS_Measures] as '{[Measures].[*FORMATTED_MEASURE_0]}' Member [Measures].[*FORMATTED_MEASURE_0] as '[Measures].[Warehouse Sales]', FORMAT_STRING = '#,##0', SOLVE_ORDER=400 "
+ "Select [*BASE_MEMBERS_Measures] on columns, Non Empty Generate([*NATIVE_CJ_SET], {([Warehouse].currentMember,[Time].[Time].currentMember)}) on rows From [Warehouse and Sales] ";
String query2 =
"With "
+ "Set [*NATIVE_CJ_SET] as 'NonEmptyCrossJoin([*BASE_MEMBERS_Warehouse],[*BASE_MEMBERS_Time])' "
+ "Set [*NATIVE_MEMBERS_Warehouse] as 'Generate([*NATIVE_CJ_SET], {[Warehouse].CurrentMember})' "
+ "Set [*BASE_MEMBERS_Warehouse] as '[Warehouse].[Country].Members' "
+ "Set [*NATIVE_MEMBERS_Time] as 'Generate([*NATIVE_CJ_SET], {[Time].[Time].CurrentMember})' "
+ "Set [*BASE_MEMBERS_Time] as 'Filter([Time].[Month].Members,[Time].[Time].CurrentMember Not In {[Time].[1997].[Q1].[2]})' "
+ "Set [*BASE_MEMBERS_Measures] as '{[Measures].[*FORMATTED_MEASURE_0]}' Member [Measures].[*FORMATTED_MEASURE_0] as '[Measures].[Warehouse Sales]', FORMAT_STRING = '#,##0', SOLVE_ORDER=400 "
+ "Select [*BASE_MEMBERS_Measures] on columns, Non Empty Generate([*NATIVE_CJ_SET], {([Warehouse].currentMember,[Time].[Time].currentMember)}) on rows From [Warehouse and Sales]";
executeQuery(query1);
/* The query with the filter should now succeed without NPE */
String result =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[*FORMATTED_MEASURE_0]}\n"
+ "Axis #2:\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q1].[1]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q1].[3]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q2].[4]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q2].[5]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q2].[6]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q3].[7]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q3].[8]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q3].[9]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q4].[10]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q4].[11]}\n"
+ "{[Warehouse].[USA], [Time].[1997].[Q4].[12]}\n"
+ "Row #0: 21,762\n"
+ "Row #1: 13,775\n"
+ "Row #2: 15,938\n"
+ "Row #3: 15,649\n"
+ "Row #4: 14,629\n"
+ "Row #5: 18,626\n"
+ "Row #6: 15,833\n"
+ "Row #7: 21,393\n"
+ "Row #8: 17,100\n"
+ "Row #9: 15,356\n"
+ "Row #10: 13,948\n";
assertQueryReturns(query2, result);
}
/**
* Tests that the logic to apply non empty context constraint in virtual
* cube is correct. The joins shouldn't be cartesian product.
*/
public void testNonEmptyCJConstraintOnVirtualCube() {
if (!MondrianProperties.instance().EnableNativeCrossJoin.get()) {
// Generated SQL is different if NonEmptyCrossJoin is evaluated in
// memory.
return;
}
String query =
"with "
+ "set [foo] as [Time].[Month].members "
+ "set [bar] as {[Store].[USA]} "
+ "Select {[Measures].[Warehouse Sales],[Measures].[Store Sales]} on columns, "
+ "nonemptycrossjoin([foo],[bar]) on rows "
+ "From [Warehouse and Sales] "
+ "Where ([Product].[All Products].[Food])";
// Note that for MySQL (because MySQL sorts NULLs first), because there
// is a UNION (which prevents us from sorting on column names or
// expressions) the ORDER BY clause should be something like
// ORDER BY ISNULL(1), 1 ASC, ISNULL(2), 2 ASC, ISNULL(3), 3 ASC,
// ISNULL(4), 4 ASC
// but ISNULL(1) isn't valid SQL, so we forego correct ordering of NULL
// values.
String mysqlSQL =
"select "
+ "`time_by_day`.`the_year` as `c0`, `time_by_day`.`quarter` as `c1`, `time_by_day`.`month_of_year` as `c2`, `store`.`store_country` as `c3` "
+ "from "
+ "`time_by_day` as `time_by_day`, `sales_fact_1997` as `sales_fact_1997`, "
+ "`store` as `store`, `product_class` as `product_class`, `product` as `product` "
+ "where "
+ "`sales_fact_1997`.`time_id` = `time_by_day`.`time_id` and `sales_fact_1997`.`store_id` = `store`.`store_id` and "
+ "`sales_fact_1997`.`product_id` = `product`.`product_id` and `product`.`product_class_id` = `product_class`.`product_class_id` and "
+ "`product_class`.`product_family` = 'Food' and (`store`.`store_country` = 'USA') "
+ "group by "
+ "`time_by_day`.`the_year`, `time_by_day`.`quarter`, `time_by_day`.`month_of_year`, `store`.`store_country` "
+ "union "
+ "select "
+ "`time_by_day`.`the_year` as `c0`, `time_by_day`.`quarter` as `c1`, `time_by_day`.`month_of_year` as `c2`, `store`.`store_country` as `c3` "
+ "from "
+ "`time_by_day` as `time_by_day`, `inventory_fact_1997` as `inventory_fact_1997`, `store` as `store`, "
+ "`product_class` as `product_class`, `product` as `product` "
+ "where "
+ "`inventory_fact_1997`.`time_id` = `time_by_day`.`time_id` and `inventory_fact_1997`.`store_id` = `store`.`store_id` and "
+ "`inventory_fact_1997`.`product_id` = `product`.`product_id` and `product`.`product_class_id` = `product_class`.`product_class_id` and "
+ "`product_class`.`product_family` = 'Food' and (`store`.`store_country` = 'USA') "
+ "group by "
+ "`time_by_day`.`the_year`, `time_by_day`.`quarter`, `time_by_day`.`month_of_year`, `store`.`store_country` "
+ "order by "
+ "1 ASC, 2 ASC, 3 ASC, 4 ASC";
String derbySQL =
"select "
+ "\"time_by_day\".\"the_year\", \"time_by_day\".\"quarter\", \"time_by_day\".\"month_of_year\", \"store\".\"store_country\" "
+ "from \"time_by_day\" as \"time_by_day\", \"sales_fact_1997\" as \"sales_fact_1997\", \"store\" as \"store\", "
+ "\"product_class\" as \"product_class\", \"product\" as \"product\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" and "
+ "\"sales_fact_1997\".\"product_id\" = \"product\".\"product_id\" and \"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" and "
+ "\"product_class\".\"product_family\" = 'Food' and (\"store\".\"store_country\" = 'USA') "
+ "group by \"time_by_day\".\"the_year\", \"time_by_day\".\"quarter\", \"time_by_day\".\"month_of_year\", \"store\".\"store_country\" "
+ "union "
+ "select "
+ "\"time_by_day\".\"the_year\", \"time_by_day\".\"quarter\", \"time_by_day\".\"month_of_year\", \"store\".\"store_country\" "
+ "from \"time_by_day\" as \"time_by_day\", \"inventory_fact_1997\" as \"inventory_fact_1997\", \"store\" as \"store\", "
+ "\"product_class\" as \"product_class\", \"product\" as \"product\" "
+ "where \"inventory_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and \"inventory_fact_1997\".\"store_id\" = \"store\".\"store_id\" and "
+ "\"inventory_fact_1997\".\"product_id\" = \"product\".\"product_id\" and \"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" and "
+ "\"product_class\".\"product_family\" = 'Food' and (\"store\".\"store_country\" = 'USA') "
+ "group by \"time_by_day\".\"the_year\", \"time_by_day\".\"quarter\", \"time_by_day\".\"month_of_year\", \"store\".\"store_country\" "
+ "order by 1 ASC, 2 ASC, 3 ASC, 4 ASC";
SqlPattern[] mysqlPattern = {
new SqlPattern(Dialect.DatabaseProduct.MYSQL, mysqlSQL, mysqlSQL),
new SqlPattern(Dialect.DatabaseProduct.DERBY, derbySQL, derbySQL)
};
String result =
"Axis #0:\n"
+ "{[Product].[Food]}\n"
+ "Axis #1:\n"
+ "{[Measures].[Warehouse Sales]}\n"
+ "{[Measures].[Store Sales]}\n"
+ "Axis #2:\n"
+ "{[Time].[1997].[Q1].[1], [Store].[USA]}\n"
+ "{[Time].[1997].[Q1].[2], [Store].[USA]}\n"
+ "{[Time].[1997].[Q1].[3], [Store].[USA]}\n"
+ "{[Time].[1997].[Q2].[4], [Store].[USA]}\n"
+ "{[Time].[1997].[Q2].[5], [Store].[USA]}\n"
+ "{[Time].[1997].[Q2].[6], [Store].[USA]}\n"
+ "{[Time].[1997].[Q3].[7], [Store].[USA]}\n"
+ "{[Time].[1997].[Q3].[8], [Store].[USA]}\n"
+ "{[Time].[1997].[Q3].[9], [Store].[USA]}\n"
+ "{[Time].[1997].[Q4].[10], [Store].[USA]}\n"
+ "{[Time].[1997].[Q4].[11], [Store].[USA]}\n"
+ "{[Time].[1997].[Q4].[12], [Store].[USA]}\n"
+ "Row #0: 16,083.015\n"
+ "Row #0: 32,993.12\n"
+ "Row #1: 9,298.379\n"
+ "Row #1: 32,139.91\n"
+ "Row #2: 10,129.659\n"
+ "Row #2: 36,128.29\n"
+ "Row #3: 11,415.462\n"
+ "Row #3: 30,747.21\n"
+ "Row #4: 11,358.086\n"
+ "Row #4: 31,896.24\n"
+ "Row #5: 10,425.768\n"
+ "Row #5: 32,792.55\n"
+ "Row #6: 13,684.193\n"
+ "Row #6: 36,324.76\n"
+ "Row #7: 11,332.797\n"
+ "Row #7: 33,842.75\n"
+ "Row #8: 15,667.978\n"
+ "Row #8: 31,640.09\n"
+ "Row #9: 11,902.18\n"
+ "Row #9: 30,337.12\n"
+ "Row #10: 10,144.841\n"
+ "Row #10: 38,709.15\n"
+ "Row #11: 9,705.561\n"
+ "Row #11: 41,484.40\n";
assertQuerySql(query, mysqlPattern, true);
assertQueryReturns(query, result);
}
/**
* Tests that the logic to apply non empty context constraint in virtual
* cube is correct. The joins shouldn't be cartesian product.
*/
public void testNonEmptyConstraintOnVirtualCubeWithCalcMeasure() {
if (!MondrianProperties.instance().EnableNativeNonEmpty.get()) {
// Generated SQL is different if NON EMPTY is evaluated in memory.
return;
}
String query =
"with "
+ "set [bar] as {[Store].[USA]} "
+ "member [Measures].[CalcMeasure] as '[Measures].[Warehouse Sales] / [Measures].[Store Sales]' "
+ "Select "
+ "{[Measures].[CalcMeasure]} on columns, "
+ "non empty([Product].[Product Family].Members) on rows "
+ "From [Warehouse and Sales] "
+ "where [bar]";
// Comments as for testNonEmptyCJConstraintOnVirtualCube. The ORDER BY
// clause should be "order by ISNULL(1), 1 ASC" but we will settle for
// "order by 1 ASC" and forego correct sorting of NULL values.
String mysqlSQL =
"select `product_class`.`product_family` as `c0` "
+ "from `product` as `product`, `product_class` as `product_class`, `sales_fact_1997` as `sales_fact_1997`, `store` as `store` "
+ "where `product`.`product_class_id` = `product_class`.`product_class_id` and `sales_fact_1997`.`product_id` = `product`.`product_id` and "
+ "`sales_fact_1997`.`store_id` = `store`.`store_id` and `store`.`store_country` = 'USA' "
+ "group by `product_class`.`product_family` "
+ "union "
+ "select `product_class`.`product_family` as `c0` "
+ "from `product` as `product`, `product_class` as `product_class`, `inventory_fact_1997` as `inventory_fact_1997`, `store` as `store` "
+ "where `product`.`product_class_id` = `product_class`.`product_class_id` and `inventory_fact_1997`.`product_id` = `product`.`product_id` and "
+ "`inventory_fact_1997`.`store_id` = `store`.`store_id` and `store`.`store_country` = 'USA' "
+ "group by `product_class`.`product_family` "
+ "order by 1 ASC";
String derbySQL =
"select \"product_class\".\"product_family\" "
+ "from \"product\" as \"product\", \"product_class\" as \"product_class\", \"sales_fact_1997\" as \"sales_fact_1997\", \"store\" as \"store\" "
+ "where \"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" and \"sales_fact_1997\".\"product_id\" = \"product\".\"product_id\""
+ " and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" and \"store\".\"store_country\" = 'USA' "
+ "group by \"product_class\".\"product_family\" "
+ "union "
+ "select \"product_class\".\"product_family\" "
+ "from \"product\" as \"product\", \"product_class\" as \"product_class\", \"inventory_fact_1997\" as \"inventory_fact_1997\", \"store\" as \"store\" "
+ "where \"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" and \"inventory_fact_1997\".\"product_id\" = \"product\".\"product_id\""
+ " and \"inventory_fact_1997\".\"store_id\" = \"store\".\"store_id\" and \"store\".\"store_country\" = 'USA' "
+ "group by \"product_class\".\"product_family\" "
+ "order by 1 ASC";
String result =
"Axis #0:\n"
+ "{[Store].[USA]}\n"
+ "Axis #1:\n"
+ "{[Measures].[CalcMeasure]}\n"
+ "Axis #2:\n"
+ "{[Product].[Drink]}\n"
+ "{[Product].[Food]}\n"
+ "{[Product].[Non-Consumable]}\n"
+ "Row #0: 0.369\n"
+ "Row #1: 0.345\n"
+ "Row #2: 0.35\n";
SqlPattern[] mysqlPattern = {
new SqlPattern(
Dialect.DatabaseProduct.MYSQL, mysqlSQL, mysqlSQL),
new SqlPattern(
Dialect.DatabaseProduct.DERBY, derbySQL, derbySQL)
};
assertQuerySql(query, mysqlPattern, true);
assertQueryReturns(query, result);
}
/**
* Test case for bug
* MONDRIAN-902, "mondrian populating the same members on both axes".
*/
public void testBugMondrian902() {
Result result = executeQuery(
"SELECT\n"
+ "NON EMPTY CrossJoin(\n"
+ " [Education Level].[Education Level].Members,\n"
+ " CrossJoin(\n"
+ " [Product].[Product Family].Members,\n"
+ " [Store].[Store State].Members)) ON COLUMNS,\n"
+ "NON EMPTY CrossJoin(\n"
+ " [Promotions].[Promotion Name].Members,\n"
+ " [Marital Status].[Marital Status].Members) ON ROWS\n"
+ "FROM [Warehouse and Sales]");
assertEquals(
"[[Education Level].[Bachelors Degree], [Product].[Drink], [Store].[USA].[CA]]",
result.getAxes()[0].getPositions().get(0).toString());
assertEquals(45, result.getAxes()[0].getPositions().size());
// With bug MONDRIAN-902, this gave the same result as for axis #0:
assertEquals(
"[[Promotions].[Bag Stuffers], [Marital Status].[M]]",
result.getAxes()[1].getPositions().get(0).toString());
assertEquals(96, result.getAxes()[1].getPositions().size());
}
}
// End VirtualCubeTest.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/RolapConnectionTest.java 0000644 0001750 0001750 00000043327 11735330606 025376 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2004-2005 Julian Hyde
// Copyright (C) 2005-2011 Pentaho and others
// All Rights Reserved.
//
// jng, 16 April, 2004
*/
package mondrian.rolap;
import mondrian.olap.*;
import mondrian.spi.Dialect;
import mondrian.test.TestContext;
import mondrian.util.Pair;
import junit.framework.TestCase;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.*;
import javax.naming.*;
import javax.naming.spi.*;
import javax.sql.DataSource;
/**
* Unit test for {@link RolapConnection}.
*
* @author jng
* @since 16 April, 2004
*/
public class RolapConnectionTest extends TestCase {
private static final ThreadLocal THREAD_INITIAL_CONTEXT =
new ThreadLocal();
public RolapConnectionTest(String name) {
super(name);
}
protected void setUp() throws Exception {
super.setUp();
if (!NamingManager.hasInitialContextFactoryBuilder()) {
NamingManager.setInitialContextFactoryBuilder(
new InitialContextFactoryBuilder() {
public InitialContextFactory createInitialContextFactory(
Hashtable environment)
throws NamingException
{
return new InitialContextFactory() {
public Context getInitialContext(
Hashtable environment)
throws NamingException
{
return THREAD_INITIAL_CONTEXT.get();
}
};
}
}
);
}
}
public void testPooledConnectionWithProperties() throws SQLException {
Util.PropertyList properties =
TestContext.instance().getConnectionProperties().clone();
// Only the JDBC-ODBC bridge gives the error necessary for this
// test to succeed. So trivially succeed for all other JDBC
// drivers.
final String jdbc = properties.get("Jdbc");
if (jdbc != null
&& !jdbc.startsWith("jdbc:odbc:"))
{
return;
}
// JDBC-ODBC driver does not support UTF-16, so this test succeeds
// because creating the connection from the DataSource will fail.
properties.put("jdbc.charSet", "UTF-16");
final StringBuilder buf = new StringBuilder();
DataSource dataSource =
RolapConnection.createDataSource(null, properties, buf);
final String desc = buf.toString();
assertTrue(desc.startsWith("Jdbc="));
Connection connection;
try {
connection = dataSource.getConnection();
connection.close();
fail("Expected exception");
} catch (SQLException e) {
if (e.getClass().getName().equals(
"org.apache.commons.dbcp.DbcpException"))
{
// This is expected. (We use string-comparison so that the
// compiler doesn't warn about using a deprecated class.)
} else if (e.getClass() == SQLException.class
&& e.getCause() == null
&& e.getMessage() != null
&& e.getMessage().equals(""))
{
// This is expected, from a later version of Dbcp.
} else {
fail("Expected exception, but got a different one: " + e);
}
} catch (IllegalArgumentException e) {
handleIllegalArgumentException(properties, e);
} finally {
RolapConnectionPool.instance().clearPool();
}
}
public void testNonPooledConnectionWithProperties() {
Util.PropertyList properties =
TestContext.instance().getConnectionProperties().clone();
// Only the JDBC-ODBC bridge gives the error necessary for this
// test to succeed. So trivially succeed for all other JDBC
// drivers.
final String jdbc = properties.get("Jdbc");
if (jdbc != null
&& !jdbc.startsWith("jdbc:odbc:"))
{
return;
}
// This test is just like the test testPooledConnectionWithProperties
// except with non-pooled connections.
properties.put("jdbc.charSet", "UTF-16");
properties.put(RolapConnectionProperties.PoolNeeded.name(), "false");
final StringBuilder buf = new StringBuilder();
DataSource dataSource =
RolapConnection.createDataSource(null, properties, buf);
final String desc = buf.toString();
assertTrue(desc.startsWith("Jdbc="));
Connection connection = null;
try {
connection = dataSource.getConnection();
fail("Expected exception");
} catch (SQLException se) {
// this is expected
} catch (IllegalArgumentException e) {
handleIllegalArgumentException(properties, e);
} finally {
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
// ignore
}
}
}
}
/**
* Handle an {@link IllegalArgumentException} which occurs when have
* tried to create a connection with an illegal charset.
*/
private void handleIllegalArgumentException(
Util.PropertyList properties,
IllegalArgumentException e)
{
// Workaround Java bug #6504538 (see http://bugs.sun.com) with synopsis
// "DriverManager.getConnection throws IllegalArgumentException".
if (System.getProperties().getProperty("java.version")
.startsWith("1.6."))
{
properties.remove("jdbc.charSet");
final StringBuilder buf = new StringBuilder();
DataSource dataSource =
RolapConnection.createDataSource(null, properties, buf);
final String desc = buf.toString();
assertTrue(desc.startsWith("Jdbc="));
try {
Connection connection1 = dataSource.getConnection();
connection1.close();
} catch (SQLException e1) {
// ignore
}
} else {
fail("Expect IllegalArgumentException only in JDK 1.6, got " + e);
}
}
/**
* Tests that the FORMAT function uses the connection's locale.
*/
public void testFormatLocale() {
String expr = "FORMAT(1234.56, \"#,##.#\")";
checkLocale("es_ES", expr, "1.234,6", false);
checkLocale("es_MX", expr, "1,234.6", false);
checkLocale("en_US", expr, "1,234.6", false);
}
/**
* Tests that measures are formatted using the connection's locale.
*/
public void testFormatStringLocale() {
checkLocale("es_ES", "1234.56", "1.234,6", true);
checkLocale("es_MX", "1234.56", "1,234.6", true);
checkLocale("en_US", "1234.56", "1,234.6", true);
}
private static void checkLocale(
final String localeName, String expr, String expected, boolean isQuery)
{
TestContext testContextSpain = new TestContext() {
public mondrian.olap.Connection getConnection() {
Util.PropertyList properties =
Util.parseConnectString(getConnectString());
properties.put(
RolapConnectionProperties.Locale.name(),
localeName);
return DriverManager.getConnection(properties, null);
}
};
if (isQuery) {
String query = "WITH MEMBER [Measures].[Foo] AS '" + expr + "',\n"
+ " FORMAT_STRING = '#,##.#' \n"
+ "SELECT {[MEasures].[Foo]} ON COLUMNS FROM [Sales]";
String expected2 =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Foo]}\n"
+ "Row #0: " + expected + "\n";
testContextSpain.assertQueryReturns(query, expected2);
} else {
testContextSpain.assertExprReturns(expr, expected);
}
}
public void testConnectSansCatalogFails() {
Util.PropertyList properties =
TestContext.instance().getConnectionProperties().clone();
properties.remove(RolapConnectionProperties.Catalog.name());
properties.remove(RolapConnectionProperties.CatalogContent.name());
if (RolapUtil.SQL_LOGGER.isDebugEnabled()) {
RolapUtil.SQL_LOGGER.debug(
this.getName() + "\n [Connection Properties | " + properties
+ "]\n");
} else {
System.out.println(properties);
}
try {
DriverManager.getConnection(
properties,
null);
fail("expected exception");
} catch (MondrianException e) {
assertTrue(
e.getMessage().indexOf(
"Connect string must contain property 'Catalog' or "
+ "property 'CatalogContent'")
>= 0);
}
}
public void testJndiConnection() throws NamingException {
// Cannot guarantee that this test will work if they have chosen to
// resolve data sources other than by JNDI.
if (MondrianProperties.instance().DataSourceResolverClass.isSet()) {
return;
}
// get a regular connection
Util.PropertyList properties =
TestContext.instance().getConnectionProperties().clone();
final StringBuilder buf = new StringBuilder();
final DataSource dataSource =
RolapConnection.createDataSource(null, properties, buf);
// Don't know what the connect string is - it differs with database
// and with the user's set up - but we know that it contains a JDBC
// connect string. Best we can do is check that createDataSource is
// setting it to something.
final String desc = buf.toString();
assertTrue(desc, desc.startsWith("Jdbc="));
final List lookupCalls = new ArrayList();
// mock the JNDI naming manager to provide that datasource
THREAD_INITIAL_CONTEXT.set(
// Use lazy initialization. Otherwise during initialization of this
// initial context JNDI tries to create a default initial context
// and bumps into itself coming the other way.
new InitialContext(true) {
public Object lookup(String str) {
lookupCalls.add("Called");
return dataSource;
}
}
);
// Use the datasource property to connect to the database.
// Remove user and password, because some data sources (those using
// pools) don't allow you to override user.
Util.PropertyList properties2 =
TestContext.instance().getConnectionProperties().clone();
properties2.remove(RolapConnectionProperties.Jdbc.name());
properties2.remove(RolapConnectionProperties.JdbcUser.name());
properties2.remove(RolapConnectionProperties.JdbcPassword.name());
properties2.put(
RolapConnectionProperties.DataSource.name(), "jnditest");
DriverManager.getConnection(properties2, null);
// if we've made it here with lookupCalls,
// we've successfully used JNDI
assertTrue(lookupCalls.size() > 0);
}
public void testDataSourceOverrideUserPass()
throws SQLException, NamingException
{
// use the datasource property to connect to the database
Util.PropertyList properties =
TestContext.instance().getConnectionProperties().clone();
final Dialect dialect = TestContext.instance().getDialect();
if (dialect.getDatabaseProduct() == Dialect.DatabaseProduct.ACCESS) {
// Access doesn't accept user/password, so this test is pointless.
return;
}
final String jdbcUser =
properties.get(RolapConnectionProperties.JdbcUser.name());
final String jdbcPassword =
properties.get(RolapConnectionProperties.JdbcPassword.name());
if (jdbcUser == null || jdbcPassword == null) {
// Can only run this test if username and password are explicit.
return;
}
// Define a data source with bogus user and password.
properties.put(
RolapConnectionProperties.JdbcUser.name(),
"bogususer");
properties.put(
RolapConnectionProperties.JdbcPassword.name(),
"boguspassword");
properties.put(
RolapConnectionProperties.PoolNeeded.name(),
"false");
final StringBuilder buf = new StringBuilder();
final DataSource dataSource =
RolapConnection.createDataSource(null, properties, buf);
final String desc = buf.toString();
assertTrue(desc, desc.startsWith("Jdbc="));
assertTrue(
desc,
desc.indexOf("JdbcUser=bogususer; JdbcPassword=boguspassword")
>= 0);
final String jndiName = "jndiDataSource";
THREAD_INITIAL_CONTEXT.set(
new InitialContext() {
public Object lookup(String str) {
return str.equals(jndiName)
? dataSource
: null;
}
}
);
// Create a property list that we will use for the actual mondrian
// connection. Replace the original JDBC info with the data source we
// just created.
final Util.PropertyList properties2 = new Util.PropertyList();
for (Pair entry : properties) {
properties2.put(entry.getKey(), entry.getValue());
}
properties2.remove(RolapConnectionProperties.Jdbc.name());
properties2.put(
RolapConnectionProperties.DataSource.name(),
jndiName);
// With JdbcUser and JdbcPassword credentials in the mondrian connect
// string, the data source's "user" and "password" properties are
// overridden and the connection succeeds.
properties2.put(
RolapConnectionProperties.JdbcUser.name(),
jdbcUser);
properties2.put(
RolapConnectionProperties.JdbcPassword.name(),
jdbcPassword);
mondrian.olap.Connection connection = null;
try {
connection =
DriverManager.getConnection(properties2, null);
Query query = connection.parseQuery("select from [Sales]");
final Result result = connection.execute(query);
assertNotNull(result);
} finally {
if (connection != null) {
connection.close();
connection = null;
}
}
// If we don't specify JdbcUser and JdbcPassword in the mondrian
// connection properties, mondrian uses the data source's
// bogus credentials, and the connection fails.
properties2.remove(RolapConnectionProperties.JdbcUser.name());
properties2.remove(RolapConnectionProperties.JdbcPassword.name());
for (String poolNeeded : Arrays.asList("false", "true")) {
// Important to test with & without pooling. Connection pools
// typically do not let you change user, so it's important that
// mondrian handles these right.
properties2.put(
RolapConnectionProperties.PoolNeeded.name(), poolNeeded);
try {
connection = DriverManager.getConnection(properties2, null);
fail("Expected exception");
} catch (MondrianException e) {
final String s = TestContext.getStackTrace(e);
assertTrue(
s,
s.indexOf(
"Error while creating SQL connection: "
+ "DataSource=jndiDataSource") >= 0);
switch (dialect.getDatabaseProduct()) {
case DERBY:
assertTrue(
s,
s.indexOf(
"Caused by: java.sql.SQLException: "
+ "Schema 'BOGUSUSER' does not exist") >= 0);
break;
case ORACLE:
assertTrue(
s,
s.indexOf(
"Caused by: java.sql.SQLException: ORA-01017: "
+ "invalid username/password; logon denied") >= 0);
break;
case MYSQL:
assertTrue(
s,
s.indexOf(
"Caused by: java.sql.SQLException: Access denied "
+ "for user 'bogususer'@'localhost' (using "
+ "password: YES)") >= 0);
break;
case POSTGRESQL:
assertTrue(
s,
s.indexOf(
"Caused by: org.postgresql.util.PSQLException: "
+ "FATAL: password authentication failed for "
+ "user \"bogususer\"") >= 0);
break;
}
} finally {
if (connection != null) {
connection.close();
connection = null;
}
}
}
}
}
// End RolapConnectionTest.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/SharedDimensionTest.java 0000644 0001750 0001750 00000041466 11735330606 025357 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2005-2011 Pentaho and others
// All Rights Reserved.
*/
package mondrian.rolap;
import mondrian.test.FoodMartTestCase;
import mondrian.test.TestContext;
/**
* SharedDimensionTest tests shared dimensions.
*
* @author Rushan Chen
*/
public class SharedDimensionTest extends FoodMartTestCase {
public static final String sharedDimension =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "";
// Base Cube A: use product_id as foreign key for Employee diemnsion
// because there exist rows satidfying the join condition
// "employee.employee_id = inventory_fact_1997.product_id"
public static final String cubeA =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "";
// Base Cube B: use time_id as foreign key for Employee diemnsion
// because there exist rows satidfying the join condition
// "employee.employee_id = inventory_fact_1997.time_id"
public static final String cubeB =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "";
public static final String virtualCube =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "";
public static final String queryCubeA =
"with\n"
+ " set [*NATIVE_CJ_SET] as 'NonEmptyCrossJoin([*BASE_MEMBERS_Employee], [*BASE_MEMBERS_Store Type])'\n"
+ " set [*BASE_MEMBERS_Measures] as '{[Measures].[Employee Store Sales], [Measures].[Employee Store Cost]}'\n"
+ " set [*BASE_MEMBERS_Employee] as '[Employee].[Role].Members'\n"
+ " set [*NATIVE_MEMBERS_Employee] as 'Generate([*NATIVE_CJ_SET], {[Employee].CurrentMember})'\n"
+ " set [*BASE_MEMBERS_Store Type] as '[Store Type].[Store Type].Members'\n"
+ " set [*NATIVE_MEMBERS_Store Type] as 'Generate([*NATIVE_CJ_SET], {[Store Type].CurrentMember})'\n"
+ "select\n"
+ " [*BASE_MEMBERS_Measures] ON COLUMNS,\n"
+ " NON EMPTY Generate([*NATIVE_CJ_SET], {([Employee].CurrentMember, [Store Type].CurrentMember)}) ON ROWS\n"
+ "from\n"
+ " [Employee Store Analysis A]";
public static final String queryCubeB =
"with\n"
+ " set [*NATIVE_CJ_SET] as 'NonEmptyCrossJoin([*BASE_MEMBERS_Employee], [*BASE_MEMBERS_Store Type])'\n"
+ " set [*BASE_MEMBERS_Measures] as '{[Measures].[Employee Store Sales], [Measures].[Employee Store Cost]}'\n"
+ " set [*BASE_MEMBERS_Employee] as '[Employee].[Role].Members'\n"
+ " set [*NATIVE_MEMBERS_Employee] as 'Generate([*NATIVE_CJ_SET], {[Employee].CurrentMember})'\n"
+ " set [*BASE_MEMBERS_Store Type] as '[Store Type].[Store Type].Members'\n"
+ " set [*NATIVE_MEMBERS_Store Type] as 'Generate([*NATIVE_CJ_SET], {[Store Type].CurrentMember})'\n"
+ "select\n"
+ " [*BASE_MEMBERS_Measures] ON COLUMNS,\n"
+ " NON EMPTY Generate([*NATIVE_CJ_SET], {([Employee].CurrentMember, [Store Type].CurrentMember)}) ON ROWS\n"
+ "from\n"
+ " [Employee Store Analysis B]";
public static final String queryVirtualCube =
"with\n"
+ " set [*NATIVE_CJ_SET] as 'NonEmptyCrossJoin([*BASE_MEMBERS_Employee], [*BASE_MEMBERS_Store Type])'\n"
+ " set [*BASE_MEMBERS_Measures] as '{[Measures].[Employee Store Sales], [Measures].[Employee Store Cost]}'\n"
+ " set [*BASE_MEMBERS_Employee] as '[Employee].[Role].Members'\n"
+ " set [*NATIVE_MEMBERS_Employee] as 'Generate([*NATIVE_CJ_SET], {[Employee].CurrentMember})'\n"
+ " set [*BASE_MEMBERS_Store Type] as '[Store Type].[Store Type].Members'\n"
+ " set [*NATIVE_MEMBERS_Store Type] as 'Generate([*NATIVE_CJ_SET], {[Store Type].CurrentMember})'\n"
+ "select\n"
+ " [*BASE_MEMBERS_Measures] ON COLUMNS,\n"
+ " NON EMPTY Generate([*NATIVE_CJ_SET], {([Employee].CurrentMember, [Store Type].CurrentMember)}) ON ROWS\n"
+ "from\n"
+ " [Employee Store Analysis]";
public static final String queryStoreCube =
"with set [*NATIVE_CJ_SET] as 'NonEmptyCrossJoin([*BASE_MEMBERS_Store Type], [*BASE_MEMBERS_Store])'\n"
+ "set [*BASE_MEMBERS_Measures] as '{[Measures].[Store Sqft]}'\n"
+ "set [*BASE_MEMBERS_Store Type] as '[Store Type].[Store Type].Members'\n"
+ "set [*BASE_MEMBERS_Store] as '[Store].[Store State].Members'\n"
+ "select [*BASE_MEMBERS_Measures] ON COLUMNS,\n"
+ "Non Empty Generate([*NATIVE_CJ_SET], {[Store Type].CurrentMember}) on rows from [Store]";
public static final String queryNECJMemberList =
"select {[Measures].[Employee Store Sales]} on columns,\n"
+ "NonEmptyCrossJoin([Store Type].[Store Type].Members,\n"
+ "{[Employee].[All Employees].[Middle Management],\n"
+ " [Employee].[All Employees].[Store Management]})\n"
+ "on rows from [Employee Store Analysis B]";
public static final String queryNECJMultiLevelMemberList =
"select {[Employee Store Sales]} on columns, "
+ "NonEmptyCrossJoin([Store Type].[Store Type].Members, "
+ "{[Employee].[Store Management].[Store Manager], "
+ " [Employee].[Senior Management].[President]}) "
+ "on rows from [Employee Store Analysis B]";
public static final String querySF1711865 =
"select NON EMPTY {[Product].[Product Family].Members} ON COLUMNS from [Sales 2]";
public static final String resultCubeA =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Employee Store Sales]}\n"
+ "{[Measures].[Employee Store Cost]}\n"
+ "Axis #2:\n"
+ "{[Employee].[Middle Management], [Store Type].[Deluxe Supermarket]}\n"
+ "{[Employee].[Middle Management], [Store Type].[Supermarket]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Deluxe Supermarket]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Gourmet Supermarket]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Mid-Size Grocery]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Small Grocery]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Supermarket]}\n"
+ "{[Employee].[Store Management], [Store Type].[Deluxe Supermarket]}\n"
+ "{[Employee].[Store Management], [Store Type].[Gourmet Supermarket]}\n"
+ "{[Employee].[Store Management], [Store Type].[Mid-Size Grocery]}\n"
+ "{[Employee].[Store Management], [Store Type].[Small Grocery]}\n"
+ "{[Employee].[Store Management], [Store Type].[Supermarket]}\n"
+ "Row #0: $200\n"
+ "Row #0: $87\n"
+ "Row #1: $161\n"
+ "Row #1: $68\n"
+ "Row #2: $1,721\n"
+ "Row #2: $739\n"
+ "Row #3: $261\n"
+ "Row #3: $114\n"
+ "Row #4: $257\n"
+ "Row #4: $111\n"
+ "Row #5: $196\n"
+ "Row #5: $101\n"
+ "Row #6: $3,993\n"
+ "Row #6: $1,858\n"
+ "Row #7: $45,014\n"
+ "Row #7: $20,604\n"
+ "Row #8: $7,231\n"
+ "Row #8: $3,211\n"
+ "Row #9: $8,171\n"
+ "Row #9: $3,635\n"
+ "Row #10: $4,471\n"
+ "Row #10: $2,045\n"
+ "Row #11: $77,236\n"
+ "Row #11: $34,842\n";
public static final String resultCubeB =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Employee Store Sales]}\n"
+ "{[Measures].[Employee Store Cost]}\n"
+ "Axis #2:\n"
+ "{[Employee].[Store Management], [Store Type].[Deluxe Supermarket]}\n"
+ "{[Employee].[Store Management], [Store Type].[Gourmet Supermarket]}\n"
+ "{[Employee].[Store Management], [Store Type].[Mid-Size Grocery]}\n"
+ "{[Employee].[Store Management], [Store Type].[Small Grocery]}\n"
+ "{[Employee].[Store Management], [Store Type].[Supermarket]}\n"
+ "Row #0: $61,860\n"
+ "Row #0: $28,093\n"
+ "Row #1: $10,156\n"
+ "Row #1: $4,482\n"
+ "Row #2: $10,212\n"
+ "Row #2: $4,576\n"
+ "Row #3: $5,932\n"
+ "Row #3: $2,714\n"
+ "Row #4: $108,610\n"
+ "Row #4: $49,178\n";
public static final String resultVirtualCube =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Employee Store Sales]}\n"
+ "{[Measures].[Employee Store Cost]}\n"
+ "Axis #2:\n"
+ "{[Employee].[Middle Management], [Store Type].[Deluxe Supermarket]}\n"
+ "{[Employee].[Middle Management], [Store Type].[Supermarket]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Deluxe Supermarket]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Gourmet Supermarket]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Mid-Size Grocery]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Small Grocery]}\n"
+ "{[Employee].[Senior Management], [Store Type].[Supermarket]}\n"
+ "{[Employee].[Store Management], [Store Type].[Deluxe Supermarket]}\n"
+ "{[Employee].[Store Management], [Store Type].[Gourmet Supermarket]}\n"
+ "{[Employee].[Store Management], [Store Type].[Mid-Size Grocery]}\n"
+ "{[Employee].[Store Management], [Store Type].[Small Grocery]}\n"
+ "{[Employee].[Store Management], [Store Type].[Supermarket]}\n"
+ "Row #0: $200\n"
+ "Row #0: \n"
+ "Row #1: $161\n"
+ "Row #1: \n"
+ "Row #2: $1,721\n"
+ "Row #2: \n"
+ "Row #3: $261\n"
+ "Row #3: \n"
+ "Row #4: $257\n"
+ "Row #4: \n"
+ "Row #5: $196\n"
+ "Row #5: \n"
+ "Row #6: $3,993\n"
+ "Row #6: \n"
+ "Row #7: $45,014\n"
+ "Row #7: $28,093\n"
+ "Row #8: $7,231\n"
+ "Row #8: $4,482\n"
+ "Row #9: $8,171\n"
+ "Row #9: $4,576\n"
+ "Row #10: $4,471\n"
+ "Row #10: $2,714\n"
+ "Row #11: $77,236\n"
+ "Row #11: $49,178\n";
// This result is actually incorrect for native evaluation.
// Keep the test case here to test the SQL generation.
public static final String resultStoreCube =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Store Sqft]}\n"
+ "Axis #2:\n"
+ "{[Store Type].[Deluxe Supermarket]}\n"
+ "{[Store Type].[Gourmet Supermarket]}\n"
+ "{[Store Type].[Mid-Size Grocery]}\n"
+ "{[Store Type].[Small Grocery]}\n"
+ "{[Store Type].[Supermarket]}\n"
+ "Row #0: 146,045\n"
+ "Row #1: 47,447\n"
+ "Row #2: 109,343\n"
+ "Row #3: 75,281\n"
+ "Row #4: 193,480\n";
public static final String resultNECJMemberList =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Employee Store Sales]}\n"
+ "Axis #2:\n"
+ "{[Store Type].[Deluxe Supermarket], [Employee].[Store Management]}\n"
+ "{[Store Type].[Gourmet Supermarket], [Employee].[Store Management]}\n"
+ "{[Store Type].[Mid-Size Grocery], [Employee].[Store Management]}\n"
+ "{[Store Type].[Small Grocery], [Employee].[Store Management]}\n"
+ "{[Store Type].[Supermarket], [Employee].[Store Management]}\n"
+ "Row #0: $61,860\n"
+ "Row #1: $10,156\n"
+ "Row #2: $10,212\n"
+ "Row #3: $5,932\n"
+ "Row #4: $108,610\n";
public static final String resultNECJMultiLevelMemberList =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Employee Store Sales]}\n"
+ "Axis #2:\n"
+ "{[Store Type].[Deluxe Supermarket], [Employee].[Store Management].[Store Manager]}\n"
+ "{[Store Type].[Gourmet Supermarket], [Employee].[Store Management].[Store Manager]}\n"
+ "{[Store Type].[Supermarket], [Employee].[Store Management].[Store Manager]}\n"
+ "Row #0: $1,783\n"
+ "Row #1: $286\n"
+ "Row #2: $1,020\n";
public static final String resultSF1711865 =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Product].[Drink]}\n"
+ "{[Product].[Food]}\n"
+ "{[Product].[Non-Consumable]}\n"
+ "Row #0: 7,978\n"
+ "Row #0: 62,445\n"
+ "Row #0: 16,414\n";
public SharedDimensionTest() {
}
public SharedDimensionTest(String name) {
super(name);
}
public void testA() {
// Schema has two cubes sharing a dimension.
// Query from the first cube.
TestContext testContext = getTestContextForSharedDimCubeACubeB();
testContext.assertQueryReturns(queryCubeA, resultCubeA);
}
public void testB() {
// Schema has two cubes sharing a dimension.
// Query from the second cube.
TestContext testContext = getTestContextForSharedDimCubeACubeB();
testContext.assertQueryReturns(queryCubeB, resultCubeB);
}
public void testVirtualCube() {
// Schema has two cubes sharing a dimension, and a virtual cube built
// over these two cubes.
// Query from the virtual cube.
TestContext testContext =
TestContext.instance().create(
sharedDimension,
cubeA + "\n" + cubeB,
virtualCube,
null,
null,
null);
testContext.assertQueryReturns(queryVirtualCube, resultVirtualCube);
}
public void testNECJMemberList() {
// Schema has two cubes sharing a dimension.
// Query from the second cube.
TestContext testContext = getTestContextForSharedDimCubeACubeB();
testContext.assertQueryReturns(
queryNECJMemberList,
resultNECJMemberList);
}
public void testNECJMultiLevelMemberList() {
// Schema has two cubes sharing a dimension.
// Query from the first cube.
// This is a case where not using alias not only affects performance,
// but also produces incorrect result.
TestContext testContext = getTestContextForSharedDimCubeACubeB();
testContext.assertQueryReturns(
queryNECJMultiLevelMemberList,
resultNECJMultiLevelMemberList);
}
public void testSF1711865() {
// Test for sourceforge.net bug 1711865
// Use the default FoodMart schema
getTestContext().assertQueryReturns(querySF1711865, resultSF1711865);
}
public void testStoreCube() {
// Use the default FoodMart schema
getTestContext().assertQueryReturns(queryStoreCube, resultStoreCube);
}
private TestContext getTestContextForSharedDimCubeACubeB() {
return TestContext.instance().create(
sharedDimension,
cubeA + "\n" + cubeB,
null,
null,
null,
null);
}
}
// End SharedDimensionTest.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/agg/ 0000755 0001750 0001750 00000000000 11735330606 021323 5 ustar drazzib drazzib mondrian-3.4.1/testsrc/main/mondrian/rolap/agg/SegmentLoaderTest.java 0000644 0001750 0001750 00000113104 11735330606 025557 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2004-2005 Julian Hyde
// Copyright (C) 2005-2012 Pentaho and others
// All Rights Reserved.
*/
package mondrian.rolap.agg;
import mondrian.olap.*;
import mondrian.rolap.*;
import mondrian.server.*;
import mondrian.server.Statement;
import mondrian.spi.Dialect;
import mondrian.test.SqlPattern;
import mondrian.util.DelegatingInvocationHandler;
import java.lang.reflect.Proxy;
import java.sql.*;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
/**
* Test for SegmentLoader
*
* @author Thiyagu
* @since 06-Jun-2007
*/
public class SegmentLoaderTest extends BatchTestCase {
private Execution execution;
private Locus locus;
private SegmentCacheManager cacheMgr;
protected void setUp() throws Exception {
super.setUp();
final Statement statement =
((RolapConnection) getConnection()).getInternalStatement();
execution = new Execution(statement, 1000);
locus = new Locus(execution, null, null);
cacheMgr = execution.getMondrianStatement().getMondrianConnection()
.getServer().getAggregationManager().cacheMgr;
Locus.push(locus);
}
@Override
protected void tearDown() throws Exception {
Locus.pop(locus);
super.tearDown();
}
public void testRollup() throws Exception {
propSaver.set(
MondrianProperties.instance().DisableCaching,
true);
propSaver.set(
MondrianProperties.instance().SegmentCache,
MockSegmentCache.class.getName());
final String queryOracle =
"select \"store\".\"store_country\" as \"c0\", \"time_by_day\".\"the_year\" as \"c1\", sum(\"sales_fact_1997\".\"unit_sales\") as \"m0\" from \"store\" \"store\", \"sales_fact_1997\" \"sales_fact_1997\", \"time_by_day\" \"time_by_day\" where \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" and \"store\".\"store_country\" = 'USA' and \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and \"time_by_day\".\"the_year\" = 1997 group by \"store\".\"store_country\", \"time_by_day\".\"the_year\"";
executeQuery(
"select {[Store].[Store Country].Members} on rows, {[Measures].[Unit Sales]} on columns from [Sales]");
getTestContext().flushSchemaCache();
assertQuerySqlOrNot(
getTestContext(),
"select {[Store].[Store Country].[USA]} on rows, {[Measures].[Unit Sales]} on columns from [Sales]",
new SqlPattern[] {
new SqlPattern(
Dialect.DatabaseProduct.ORACLE,
queryOracle,
queryOracle.length())
},
true,
true,
true);
}
public void testLoadWithMockResultsForLoadingSummaryAndDetailedSegments()
throws ExecutionException, InterruptedException
{
GroupingSet groupableSetsInfo = getGroupingSetRollupOnGender();
GroupingSet groupingSetsInfo = getDefaultGroupingSet();
ArrayList groupingSets =
new ArrayList();
groupingSets.add(groupingSetsInfo);
groupingSets.add(groupableSetsInfo);
SegmentLoader loader = new SegmentLoader(cacheMgr) {
SqlStatement createExecuteSql(
int cellRequestCount,
final GroupingSetsList groupingSetsList,
List compoundPredicateList)
{
return new MockSqlStatement(
cellRequestCount,
groupingSetsList,
getData(true));
}
};
final List>> segmentFutures =
new ArrayList>>();
loader.load(0, groupingSets, null, segmentFutures);
SegmentAxis[] axes = groupingSetsInfo.getAxes();
verifyYearAxis(axes[0]);
verifyProductFamilyAxis(axes[1]);
verifyProductDepartmentAxis(axes[2]);
verifyGenderAxis(axes[3]);
verifyUnitSalesDetailed(
getFor(
segmentFutures,
groupingSets.get(0).getSegments().get(0)));
axes = groupingSets.get(0).getAxes();
verifyYearAxis(axes[0]);
verifyProductFamilyAxis(axes[1]);
verifyProductDepartmentAxis(axes[2]);
verifyUnitSalesAggregate(
getFor(
segmentFutures,
groupingSets.get(1).getSegments().get(0)));
}
private ResultSet toResultSet(final List list) {
final MyDelegatingInvocationHandler handler =
new MyDelegatingInvocationHandler(list);
Object o =
Proxy.newProxyInstance(
null,
new Class[] {ResultSet.class, ResultSetMetaData.class},
handler);
handler.resultSetMetaData = (ResultSetMetaData) o;
return (ResultSet) o;
}
private SegmentLoader.RowList toRowList2(List list) {
final SegmentLoader.RowList rowList =
new SegmentLoader.RowList(
Collections.nCopies(
list.get(0).length,
SqlStatement.Type.OBJECT));
for (Object[] objects : list) {
rowList.createRow();
for (int i = 0; i < objects.length; i++) {
Object object = objects[i];
rowList.setObject(i, object);
}
}
return rowList;
}
/**
* Tests load with mock results for loading summary and detailed
* segments with null in rollup column.
*/
public void testLoadWithWithNullInRollupColumn()
throws ExecutionException, InterruptedException
{
GroupingSet groupableSetsInfo = getGroupingSetRollupOnGender();
GroupingSet groupingSetsInfo = getDefaultGroupingSet();
ArrayList groupingSets =
new ArrayList();
groupingSets.add(groupingSetsInfo);
groupingSets.add(groupableSetsInfo);
SegmentLoader loader = new SegmentLoader(cacheMgr) {
SqlStatement createExecuteSql(
int cellRequestCount,
GroupingSetsList groupingSetsList,
List compoundPredicateList)
{
return new MockSqlStatement(
cellRequestCount,
groupingSetsList,
getDataWithNullInRollupColumn(true));
}
};
final List>> segmentFutures =
new ArrayList>>();
loader.load(0, groupingSets, null, segmentFutures);
SegmentWithData detailedSegment =
getFor(
segmentFutures,
groupingSets.get(0).getSegments().get(0));
assertEquals(3, detailedSegment.getCellCount());
}
public void
testLoadWithMockResultsForLoadingSummaryAndDetailedSegmentsUsingSparse()
throws ExecutionException, InterruptedException
{
GroupingSet groupableSetsInfo = getGroupingSetRollupOnGender();
GroupingSet groupingSetsInfo = getDefaultGroupingSet();
ArrayList groupingSets =
new ArrayList();
groupingSets.add(groupingSetsInfo);
groupingSets.add(groupableSetsInfo);
SegmentLoader loader = new SegmentLoader(cacheMgr) {
SqlStatement createExecuteSql(
int cellRequestCount,
GroupingSetsList groupingSetsList,
List compoundPredicateList)
{
return new MockSqlStatement(
cellRequestCount,
groupingSetsList,
getData(true));
}
boolean useSparse(boolean sparse, int n, RowList rows) {
return true;
}
};
final List>> segmentFutures =
new ArrayList>>();
loader.load(0, groupingSets, null, segmentFutures);
SegmentAxis[] axes = groupingSetsInfo.getAxes();
verifyYearAxis(axes[0]);
verifyProductFamilyAxis(axes[1]);
verifyProductDepartmentAxis(axes[2]);
verifyGenderAxis(axes[3]);
verifyUnitSalesDetailedForSparse(
getFor(
segmentFutures,
groupingSets.get(0).getSegments().get(0)));
axes = groupingSets.get(0).getAxes();
verifyYearAxis(axes[0]);
verifyProductFamilyAxis(axes[1]);
verifyProductDepartmentAxis(axes[2]);
verifyUnitSalesAggregateForSparse(
getFor(
segmentFutures,
groupingSets.get(1).getSegments().get(0)));
}
private SegmentWithData getFor(
List>> mapFutures,
Segment segment)
throws ExecutionException, InterruptedException
{
for (Future> mapFuture : mapFutures) {
final Map map = mapFuture.get();
if (map.containsKey(segment)) {
return map.get(segment);
}
}
return null;
}
private List trim(final int length, final List data) {
return new AbstractList() {
@Override
public Object[] get(int index) {
return Util.copyOf(data.get(index), length);
}
@Override
public int size() {
return data.size();
}
};
}
public void testLoadWithMockResultsForLoadingOnlyDetailedSegments()
throws ExecutionException, InterruptedException
{
GroupingSet groupingSetsInfo = getDefaultGroupingSet();
ArrayList groupingSets =
new ArrayList();
groupingSets.add(groupingSetsInfo);
SegmentLoader loader = new SegmentLoader(cacheMgr) {
SqlStatement createExecuteSql(
int cellRequestCount,
GroupingSetsList groupingSetsList,
List compoundPredicateList)
{
return new MockSqlStatement(
cellRequestCount,
groupingSetsList,
trim(5, getData(false)));
}
};
final List>> segmentFutures =
new ArrayList>>();
loader.load(0, groupingSets, null, segmentFutures);
SegmentAxis[] axes = groupingSetsInfo.getAxes();
verifyYearAxis(axes[0]);
verifyProductFamilyAxis(axes[1]);
verifyProductDepartmentAxis(axes[2]);
verifyGenderAxis(axes[3]);
verifyUnitSalesDetailed(
getFor(
segmentFutures,
groupingSetsInfo.getSegments().get(0)));
}
public void
testProcessDataForGettingGroupingSetsBitKeysAndLoadingAxisValueSet()
throws SQLException
{
GroupingSet groupableSetsInfo = getGroupingSetRollupOnGender();
GroupingSet groupingSetsInfo = getDefaultGroupingSet();
List groupingSets = new ArrayList();
groupingSets.add(groupingSetsInfo);
groupingSets.add(groupableSetsInfo);
final SqlStatement stmt =
new MockSqlStatement(
0,
new GroupingSetsList(groupingSets),
getData(true));
SegmentLoader loader = new SegmentLoader(cacheMgr) {
@Override
SqlStatement createExecuteSql(
int cellRequestCount,
GroupingSetsList groupingSetsList,
List compoundPredicateList)
{
return stmt;
}
};
int axisCount = 4;
SortedSet[] axisValueSet =
loader.getDistinctValueWorkspace(axisCount);
boolean[] axisContainsNull = new boolean[axisCount];
SegmentLoader.RowList list =
loader.processData(
stmt,
axisContainsNull,
axisValueSet,
new GroupingSetsList(groupingSets));
int totalNoOfRows = 12;
int lengthOfRowWithBitKey = 6;
assertEquals(totalNoOfRows, list.size());
assertEquals(lengthOfRowWithBitKey, list.getTypes().size());
list.first();
list.next();
assertEquals(BitKey.Factory.makeBitKey(0), list.getObject(5));
BitKey bitKeyForSummaryRow = BitKey.Factory.makeBitKey(0);
bitKeyForSummaryRow.set(0);
list.next();
list.next();
assertEquals(bitKeyForSummaryRow, list.getObject(5));
SortedSet yearAxis = axisValueSet[0];
assertEquals(1, yearAxis.size());
SortedSet productFamilyAxis = axisValueSet[1];
assertEquals(3, productFamilyAxis.size());
SortedSet productDepartmentAxis = axisValueSet[2];
assertEquals(4, productDepartmentAxis.size());
SortedSet genderAxis = axisValueSet[3];
assertEquals(2, genderAxis.size());
assertFalse(axisContainsNull[0]);
assertFalse(axisContainsNull[1]);
assertFalse(axisContainsNull[2]);
assertFalse(axisContainsNull[3]);
}
private GroupingSet getGroupingSetRollupOnGender() {
return
getGroupingSet(
execution,
new String[]{tableTime, tableProductClass, tableProductClass},
new String[]{
fieldYear, fieldProductFamily, fieldProductDepartment},
new String[][]{
fieldValuesYear,
fieldValuesProductFamily,
fieldValueProductDepartment},
cubeNameSales,
measureUnitSales);
}
public void testProcessDataForSettingNullAxis()
throws SQLException
{
GroupingSet groupingSetsInfo = getDefaultGroupingSet();
final SqlStatement stmt =
new MockSqlStatement(
0,
new GroupingSetsList(
Collections.singletonList(groupingSetsInfo)),
trim(5, getDataWithNullInAxisColumn(false)));
SegmentLoader loader = new SegmentLoader(cacheMgr) {
@Override
SqlStatement createExecuteSql(
int cellRequestCount,
GroupingSetsList groupingSetsList,
List compoundPredicateList)
{
return stmt;
}
};
int axisCount = 4;
SortedSet[] axisValueSet =
loader.getDistinctValueWorkspace(axisCount);
boolean[] axisContainsNull = new boolean[axisCount];
List groupingSets = new ArrayList();
groupingSets.add(groupingSetsInfo);
loader.processData(
stmt,
axisContainsNull,
axisValueSet,
new GroupingSetsList(groupingSets));
assertFalse(axisContainsNull[0]);
assertFalse(axisContainsNull[1]);
assertTrue(axisContainsNull[2]);
assertFalse(axisContainsNull[3]);
}
public void testProcessDataForNonGroupingSetsScenario()
throws SQLException
{
GroupingSet groupingSetsInfo = getDefaultGroupingSet();
final List data = new ArrayList();
data.add(new Object[]{"1997", "Food", "Deli", "F", "5990"});
data.add(new Object[]{"1997", "Food", "Deli", "M", "6047"});
data.add(new Object[]{"1997", "Food", "Canned_Products", "F", "867"});
final SqlStatement stmt =
new MockSqlStatement(
0,
new GroupingSetsList(
Collections.singletonList(groupingSetsInfo)),
data);
SegmentLoader loader = new SegmentLoader(cacheMgr) {
@Override
SqlStatement createExecuteSql(
int cellRequestCount,
GroupingSetsList groupingSetsList,
List compoundPredicateList)
{
return stmt;
}
};
List groupingSets = new ArrayList();
groupingSets.add(groupingSetsInfo);
SortedSet[] axisValueSet =
loader.getDistinctValueWorkspace(4);
SegmentLoader.RowList list =
loader.processData(
stmt,
new boolean[4],
axisValueSet,
new GroupingSetsList(groupingSets));
int totalNoOfRows = 3;
assertEquals(totalNoOfRows, list.size());
int lengthOfRowWithoutBitKey = 5;
assertEquals(lengthOfRowWithoutBitKey, list.getTypes().size());
SortedSet yearAxis = axisValueSet[0];
assertEquals(1, yearAxis.size());
SortedSet productFamilyAxis = axisValueSet[1];
assertEquals(1, productFamilyAxis.size());
SortedSet productDepartmentAxis = axisValueSet[2];
assertEquals(2, productDepartmentAxis.size());
SortedSet genderAxis = axisValueSet[3];
assertEquals(2, genderAxis.size());
}
private void verifyUnitSalesDetailed(SegmentWithData segment) {
Double[] unitSalesValues = {
null, null, null, null, 1987.0, 2199.0,
null, null, 867.0, 945.0, null, null, null, null, 5990.0,
6047.0, null, null, 368.0, 473.0, null, null, null, null
};
int index = 0;
for (Map.Entry x : segment.getData()) {
assertEquals(unitSalesValues[index++], x.getValue());
}
}
private void verifyUnitSalesDetailedForSparse(SegmentWithData segment) {
List cellKeys = new ArrayList();
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 2, 1, 0}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 0, 2, 0}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 1, 0, 0}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 2, 1, 1}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 1, 0, 1}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 1, 3, 0}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 0, 2, 1}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 1, 3, 1}));
Double[] unitSalesValues = {
368.0, 1987.0, 867.0, 473.0, 945.0, 5990.0, 2199.0,
6047.0
};
int index = 0;
for (Map.Entry x : segment.getData()) {
assertEquals(cellKeys.get(index), x.getKey());
assertEquals(unitSalesValues[index], x.getValue());
index++;
}
}
private void verifyUnitSalesAggregateForSparse(SegmentWithData segment) {
List cellKeys = new ArrayList();
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 2, 1}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 1, 0}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 1, 3}));
cellKeys.add(CellKey.Generator.newCellKey(new int[]{0, 0, 2}));
Double[] unitSalesValues = {841.0, 1812.0, 12037.0, 4186.0,};
int index = 0;
for (Map.Entry x : segment.getData()) {
assertEquals(cellKeys.get(index), x.getKey());
assertEquals(unitSalesValues[index], x.getValue());
index++;
}
}
private void verifyUnitSalesAggregate(SegmentWithData segment) {
Double[] unitSalesValues = {
null, null, 4186.0, null, 1812.0, null,
null, 12037.0, null, 841.0, null, null
};
int index = 0;
for (Map.Entry x : segment.getData()) {
assertEquals(unitSalesValues[index++], x.getValue());
}
}
public void testGetGroupingBitKey() throws SQLException {
Object[] data = {
"1997", "Food", "Deli", "M", "6047", 0, 0, 0, 0
};
ResultSet rowList =
toResultSet(Collections.singletonList(data));
assertTrue(rowList.next());
assertEquals(
BitKey.Factory.makeBitKey(4),
new SegmentLoader(cacheMgr).getRollupBitKey(4, rowList, 5));
data = new Object[]{
"1997", "Food", "Deli", null, "12037", 0, 0, 0, 1
};
rowList = toResultSet(Collections.singletonList(data));
BitKey key = BitKey.Factory.makeBitKey(4);
key.set(3);
assertEquals(
key,
new SegmentLoader(cacheMgr).getRollupBitKey(4, rowList, 5));
data = new Object[] {
"1997", null, "Deli", null, "12037", 0, 1, 0, 1
};
rowList = toResultSet(Collections.singletonList(data));
key = BitKey.Factory.makeBitKey(4);
key.set(1);
key.set(3);
assertEquals(
key,
new SegmentLoader(cacheMgr).getRollupBitKey(4, rowList, 5));
}
public void testGroupingSetsUtilForMissingGroupingBitKeys() {
List groupingSets = new ArrayList();
groupingSets.add(getDefaultGroupingSet());
groupingSets.add(getGroupingSetRollupOnGender());
GroupingSetsList detail = new GroupingSetsList(groupingSets);
List bitKeysList = detail.getRollupColumnsBitKeyList();
int columnsCount = 4;
assertEquals(
BitKey.Factory.makeBitKey(columnsCount),
bitKeysList.get(0));
BitKey key = BitKey.Factory.makeBitKey(columnsCount);
key.set(0);
assertEquals(key, bitKeysList.get(1));
groupingSets = new ArrayList();
groupingSets.add(getDefaultGroupingSet());
groupingSets.add(getGroupingSetRollupOnGenderAndProductFamily());
bitKeysList = new GroupingSetsList(groupingSets)
.getRollupColumnsBitKeyList();
assertEquals(
BitKey.Factory.makeBitKey(columnsCount),
bitKeysList.get(0));
key = BitKey.Factory.makeBitKey(columnsCount);
key.set(0);
key.set(1);
assertEquals(key, bitKeysList.get(1));
assertTrue(
new GroupingSetsList(
new ArrayList())
.getRollupColumnsBitKeyList().isEmpty());
}
private GroupingSet getGroupingSetRollupOnGenderAndProductFamily() {
return getGroupingSet(
execution, new String[]{tableTime, tableProductClass},
new String[]{fieldYear, fieldProductDepartment},
new String[][]{fieldValuesYear, fieldValueProductDepartment},
cubeNameSales, measureUnitSales);
}
public void testGroupingSetsUtilSetsDetailForRollupColumns() {
RolapStar.Measure measure = getMeasure(cubeNameSales, measureUnitSales);
RolapStar star = measure.getStar();
RolapStar.Column year = star.lookupColumn(tableTime, fieldYear);
RolapStar.Column productFamily =
star.lookupColumn(tableProductClass, fieldProductFamily);
RolapStar.Column productDepartment =
star.lookupColumn(tableProductClass, fieldProductDepartment);
RolapStar.Column gender = star.lookupColumn(tableCustomer, fieldGender);
List groupingSets = new ArrayList();
groupingSets.add(getDefaultGroupingSet());
groupingSets.add(getGroupingSetRollupOnProductDepartment());
groupingSets.add(getGroupingSetRollupOnGenderAndProductDepartment());
GroupingSetsList detail = new GroupingSetsList(groupingSets);
List rollupColumnsList = detail.getRollupColumns();
assertEquals(2, rollupColumnsList.size());
assertEquals(gender, rollupColumnsList.get(0));
assertEquals(productDepartment, rollupColumnsList.get(1));
groupingSets
.add(getGroupingSetRollupOnGenderAndProductDepartmentAndYear());
detail = new GroupingSetsList(groupingSets);
rollupColumnsList = detail.getRollupColumns();
assertEquals(3, rollupColumnsList.size());
assertEquals(gender, rollupColumnsList.get(0));
assertEquals(productDepartment, rollupColumnsList.get(1));
assertEquals(year, rollupColumnsList.get(2));
groupingSets
.add(getGroupingSetRollupOnProductFamilyAndProductDepartment());
detail = new GroupingSetsList(groupingSets);
rollupColumnsList = detail.getRollupColumns();
assertEquals(4, rollupColumnsList.size());
assertEquals(gender, rollupColumnsList.get(0));
assertEquals(productDepartment, rollupColumnsList.get(1));
assertEquals(productFamily, rollupColumnsList.get(2));
assertEquals(year, rollupColumnsList.get(3));
assertTrue(
new GroupingSetsList(new ArrayList())
.getRollupColumns().isEmpty());
}
private GroupingSet getGroupingSetRollupOnGenderAndProductDepartment() {
return getGroupingSet(
execution,
new String[]{tableProductClass, tableTime},
new String[]{fieldProductFamily, fieldYear},
new String[][]{fieldValuesProductFamily, fieldValuesYear},
cubeNameSales,
measureUnitSales);
}
private GroupingSet
getGroupingSetRollupOnProductFamilyAndProductDepartment()
{
return getGroupingSet(
execution,
new String[]{tableCustomer, tableTime},
new String[]{fieldGender, fieldYear},
new String[][]{fieldValuesGender, fieldValuesYear},
cubeNameSales,
measureUnitSales);
}
private GroupingSet
getGroupingSetRollupOnGenderAndProductDepartmentAndYear()
{
return getGroupingSet(
execution,
new String[]{tableProductClass},
new String[]{fieldProductFamily},
new String[][]{fieldValuesProductFamily},
cubeNameSales,
measureUnitSales);
}
private GroupingSet getGroupingSetRollupOnProductDepartment() {
return getGroupingSet(
execution,
new String[]{tableCustomer, tableProductClass, tableTime},
new String[]{fieldGender, fieldProductFamily, fieldYear},
new String[][]{
fieldValuesGender, fieldValuesProductFamily, fieldValuesYear},
cubeNameSales,
measureUnitSales);
}
public void testGroupingSetsUtilSetsForDetailForRollupColumns() {
RolapStar.Measure measure = getMeasure(cubeNameSales, measureUnitSales);
RolapStar star = measure.getStar();
RolapStar.Column year = star.lookupColumn(tableTime, fieldYear);
RolapStar.Column productFamily =
star.lookupColumn(tableProductClass, fieldProductFamily);
RolapStar.Column productDepartment =
star.lookupColumn(tableProductClass, fieldProductDepartment);
RolapStar.Column gender = star.lookupColumn(tableCustomer, fieldGender);
List groupingSets = new ArrayList();
groupingSets.add(getDefaultGroupingSet());
groupingSets.add(getGroupingSetRollupOnProductDepartment());
groupingSets.add(getGroupingSetRollupOnGenderAndProductDepartment());
GroupingSetsList detail = new GroupingSetsList(groupingSets);
List rollupColumnsList = detail.getRollupColumns();
assertEquals(2, rollupColumnsList.size());
assertEquals(gender, rollupColumnsList.get(0));
assertEquals(productDepartment, rollupColumnsList.get(1));
groupingSets
.add(getGroupingSetRollupOnGenderAndProductDepartmentAndYear());
detail = new GroupingSetsList(groupingSets);
rollupColumnsList = detail.getRollupColumns();
assertEquals(3, rollupColumnsList.size());
assertEquals(gender, rollupColumnsList.get(0));
assertEquals(productDepartment, rollupColumnsList.get(1));
assertEquals(year, rollupColumnsList.get(2));
groupingSets
.add(getGroupingSetRollupOnProductFamilyAndProductDepartment());
detail = new GroupingSetsList(groupingSets);
rollupColumnsList = detail.getRollupColumns();
assertEquals(4, rollupColumnsList.size());
assertEquals(gender, rollupColumnsList.get(0));
assertEquals(productDepartment, rollupColumnsList.get(1));
assertEquals(productFamily, rollupColumnsList.get(2));
assertEquals(year, rollupColumnsList.get(3));
assertTrue(
new GroupingSetsList(new ArrayList())
.getRollupColumns().isEmpty());
}
public void testGroupingSetsUtilSetsForGroupingFunctionIndex() {
List groupingSets = new ArrayList();
groupingSets.add(getDefaultGroupingSet());
groupingSets.add(getGroupingSetRollupOnProductDepartment());
groupingSets.add(getGroupingSetRollupOnGenderAndProductDepartment());
GroupingSetsList detail = new GroupingSetsList(groupingSets);
assertEquals(0, detail.findGroupingFunctionIndex(3));
assertEquals(1, detail.findGroupingFunctionIndex(2));
groupingSets
.add(getGroupingSetRollupOnGenderAndProductDepartmentAndYear());
detail = new GroupingSetsList(groupingSets);
assertEquals(0, detail.findGroupingFunctionIndex(3));
assertEquals(1, detail.findGroupingFunctionIndex(2));
assertEquals(2, detail.findGroupingFunctionIndex(0));
groupingSets
.add(getGroupingSetRollupOnProductFamilyAndProductDepartment());
detail = new GroupingSetsList(groupingSets);
assertEquals(0, detail.findGroupingFunctionIndex(3));
assertEquals(1, detail.findGroupingFunctionIndex(2));
assertEquals(2, detail.findGroupingFunctionIndex(1));
assertEquals(3, detail.findGroupingFunctionIndex(0));
}
public void testGetGroupingColumnsList() {
GroupingSet groupingSetsInfo = getDefaultGroupingSet();
GroupingSet groupableSetsInfo = getGroupingSetRollupOnGender();
RolapStar.Column[] detailedColumns =
groupingSetsInfo.getSegments().get(0).getColumns();
RolapStar.Column[] summaryColumns =
groupableSetsInfo.getSegments().get(0).getColumns();
List groupingSets = new ArrayList();
groupingSets.add(groupingSetsInfo);
groupingSets.add(groupableSetsInfo);
List groupingColumns =
new GroupingSetsList(groupingSets).getGroupingSetsColumns();
assertEquals(2, groupingColumns.size());
assertEquals(detailedColumns, groupingColumns.get(0));
assertEquals(summaryColumns, groupingColumns.get(1));
groupingColumns = new GroupingSetsList(
new ArrayList()).getGroupingSetsColumns();
assertEquals(0, groupingColumns.size());
}
private GroupingSet getDefaultGroupingSet() {
return getGroupingSet(
execution, new String[]{tableCustomer, tableProductClass,
tableProductClass, tableTime},
new String[]{fieldGender, fieldProductDepartment,
fieldProductFamily, fieldYear},
new String[][]{fieldValuesGender, fieldValueProductDepartment,
fieldValuesProductFamily, fieldValuesYear},
cubeNameSales,
measureUnitSales);
}
private void verifyYearAxis(SegmentAxis axis) {
Comparable[] keys = axis.getKeys();
assertEquals(1, keys.length);
assertEquals("1997", keys[0].toString());
}
private void verifyProductFamilyAxis(SegmentAxis axis) {
Comparable[] keys = axis.getKeys();
assertEquals(3, keys.length);
assertEquals("Drink", keys[0].toString());
assertEquals("Food", keys[1].toString());
assertEquals("Non-Consumable", keys[2].toString());
}
private void verifyProductDepartmentAxis(SegmentAxis axis) {
Comparable[] keys = axis.getKeys();
assertEquals(4, keys.length);
assertEquals("Canned_Products", keys[0].toString());
}
private void verifyGenderAxis(SegmentAxis axis) {
Comparable[] keys = axis.getKeys();
assertEquals(2, keys.length);
assertEquals("F", keys[0].toString());
assertEquals("M", keys[1].toString());
}
private List getData(boolean incSummaryData) {
List data = new ArrayList();
data.add(new Object[]{"1997", "Food", "Deli", "F", "5990", 0});
data.add(new Object[]{"1997", "Food", "Deli", "M", "6047", 0});
if (incSummaryData) {
data.add(new Object[]{"1997", "Food", "Deli", null, "12037", 1});
}
data.add(
new Object[]{"1997", "Food", "Canned_Products", "F", "867", 0});
data.add(
new Object[]{"1997", "Food", "Canned_Products", "M", "945", 0});
if (incSummaryData) {
data.add(
new Object[]{
"1997", "Food", "Canned_Products", null, "1812", 1});
}
data.add(new Object[]{"1997", "Drink", "Dairy", "F", "1987", 0});
data.add(new Object[]{"1997", "Drink", "Dairy", "M", "2199", 0});
if (incSummaryData) {
data.add(new Object[]{"1997", "Drink", "Dairy", null, "4186", 1});
}
data.add(
new Object[]{
"1997", "Non-Consumable", "Carousel", "F", "368", 0});
data.add(
new Object[]{
"1997", "Non-Consumable", "Carousel", "M", "473", 0});
if (incSummaryData) {
data.add(
new Object[]{
"1997", "Non-Consumable", "Carousel", null, "841", 1});
}
return data;
}
private List getDataWithNullInRollupColumn(
boolean incSummaryData)
{
List data = new ArrayList();
data.add(new Object[]{"1997", "Food", "Deli", "F", "5990", 0});
data.add(new Object[]{"1997", "Food", "Deli", "M", "6047", 0});
data.add(new Object[]{"1997", "Food", "Deli", null, "867", 0});
if (incSummaryData) {
data.add(new Object[]{"1997", "Food", "Deli", null, "12037", 1});
}
return data;
}
private List getDataWithNullInAxisColumn(
boolean incSummaryData)
{
List data = new ArrayList();
data.add(new Object[]{"1997", "Food", "Deli", "F", "5990", 0});
data.add(new Object[]{"1997", "Food", "Deli", "M", "6047", 0});
if (incSummaryData) {
data.add(new Object[]{"1997", "Food", "Deli", null, "12037", 1});
}
data.add(
new Object[]{"1997", "Food", null, "F", "867", 0});
return data;
}
public static class MyDelegatingInvocationHandler
extends DelegatingInvocationHandler
{
int row;
public boolean wasNull;
ResultSetMetaData resultSetMetaData;
private final List list;
public MyDelegatingInvocationHandler(List list) {
this.list = list;
row = -1;
}
protected Object getTarget() {
return null;
}
public ResultSetMetaData getMetaData() {
return resultSetMetaData;
}
// implement ResultSetMetaData
public int getColumnCount() {
return list.get(0).length;
}
// implement ResultSetMetaData
public int getColumnType(int column) {
return Types.VARCHAR;
}
public boolean next() {
if (row < list.size() - 1) {
++row;
return true;
}
return false;
}
public Object getObject(int column) {
return list.get(row)[column - 1];
}
public int getInt(int column) {
final Object o = list.get(row)[column - 1];
if (o == null) {
wasNull = true;
return 0;
} else {
wasNull = false;
return ((Number) o).intValue();
}
}
public double getDouble(int column) {
final Object o = list.get(row)[column - 1];
if (o == null) {
wasNull = true;
return 0D;
} else {
wasNull = false;
return ((Number) o).doubleValue();
}
}
public boolean wasNull() {
return wasNull;
}
}
private class MockSqlStatement extends SqlStatement {
private final List data;
public MockSqlStatement(
int cellRequestCount,
GroupingSetsList groupingSetsList,
List data)
{
super(
groupingSetsList.getStar().getDataSource(),
"",
null,
cellRequestCount,
0,
SegmentLoaderTest.this.locus,
0,
0);
this.data = data;
}
@Override
public List guessTypes() throws SQLException {
return Collections.nCopies(
getResultSet().getMetaData().getColumnCount(),
Type.OBJECT);
}
@Override
public ResultSet getResultSet() {
return toResultSet(data);
}
}
}
// End SegmentLoaderTest.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/agg/SegmentCacheTest.java 0000644 0001750 0001750 00000013215 11735330606 025356 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2011-2012 Pentaho and others
// All Rights Reserved.
*/
package mondrian.rolap.agg;
import mondrian.olap.CacheControl;
import mondrian.olap.Cube;
import mondrian.olap.MondrianProperties;
import mondrian.olap.MondrianServer;
import mondrian.spi.SegmentCache;
import mondrian.spi.SegmentHeader;
import mondrian.test.BasicQueryTest;
import java.util.ArrayList;
import java.util.List;
/**
* Test suite that runs the {@link BasicQueryTest} but with the
* {@link MockSegmentCache} active.
*
* @author LBoudreau
*/
public class SegmentCacheTest extends BasicQueryTest {
private SegmentCache mockCache;
private SegmentCacheWorker testWorker;
@Override
protected void setUp() throws Exception {
super.setUp();
propSaver.set(
MondrianProperties.instance().DisableCaching,
true);
this.mockCache = new MockSegmentCache();
this.testWorker = new SegmentCacheWorker(mockCache, null);
MondrianServer.forConnection(getTestContext().getConnection())
.getAggregationManager().cacheMgr.segmentCacheWorkers
.add(testWorker);
getTestContext().getConnection().getCacheControl(null)
.flushSchemaCache();
}
@Override
protected void tearDown() throws Exception {
propSaver.reset();
MondrianServer.forConnection(getTestContext().getConnection())
.getAggregationManager().cacheMgr.segmentCacheWorkers
.remove(testWorker);
getTestContext().getConnection().getCacheControl(null)
.flushSchemaCache();
this.mockCache = null;
this.testWorker = null;
super.tearDown();
}
public void testCompoundPredicatesCollision() {
String query =
"SELECT [Gender].[All Gender] ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES";
String query2 =
"WITH MEMBER GENDER.X AS 'AGGREGATE({[GENDER].[GENDER].members} * "
+ "{[STORE].[ALL STORES].[USA].[CA]})', solve_order=100 "
+ "SELECT GENDER.X ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES";
String result =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[All Gender]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 5,581\n";
String result2 =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[X]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 2,716\n";
assertQueryReturns(query, result);
assertQueryReturns(query2, result2);
}
public void testSegmentCacheEvents() throws Exception {
// Flush the cache before we start. Wait a second for the cache
// flush to propagate.
final CacheControl cc =
getTestContext().getConnection().getCacheControl(null);
Cube salesCube = getCube("Sales");
cc.flush(cc.createMeasuresRegion(salesCube));
Thread.sleep(1000);
final List createdHeaders =
new ArrayList();
final List deletedHeaders =
new ArrayList();
final SegmentCache.SegmentCacheListener listener =
new SegmentCache.SegmentCacheListener() {
public void handle(SegmentCacheEvent e) {
switch (e.getEventType()) {
case ENTRY_CREATED:
createdHeaders.add(e.getSource());
break;
case ENTRY_DELETED:
deletedHeaders.add(e.getSource());
break;
default:
throw new UnsupportedOperationException();
}
}
};
try {
// Register our custom listener.
mockCache.addListener(listener);
// Now execute a query and check the events
executeQuery(
"select {[Measures].[Unit Sales]} on columns from [Sales]");
// Wait for propagation.
Thread.sleep(2000);
assertEquals(1, createdHeaders.size());
assertEquals(0, deletedHeaders.size());
assertEquals("Sales", createdHeaders.get(0).cubeName);
assertEquals("FoodMart", createdHeaders.get(0).schemaName);
assertEquals("Unit Sales", createdHeaders.get(0).measureName);
createdHeaders.clear();
deletedHeaders.clear();
// Now flush the segment and check the events.
cc.flush(cc.createMeasuresRegion(salesCube));
// Wait for propagation.
Thread.sleep(2000);
assertEquals(0, createdHeaders.size());
assertEquals(1, deletedHeaders.size());
assertEquals("Sales", deletedHeaders.get(0).cubeName);
assertEquals("FoodMart", deletedHeaders.get(0).schemaName);
assertEquals("Unit Sales", deletedHeaders.get(0).measureName);
} finally {
mockCache.removeListener(listener);
}
}
private Cube getCube(String cubeName) {
for (Cube cube
: getConnection().getSchemaReader().withLocus().getCubes())
{
if (cube.getName().equals(cubeName)) {
return cube;
}
}
return null;
}
}
// End SegmentCacheTest.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/agg/MockSegmentCache.java 0000644 0001750 0001750 00000013654 11735330606 025337 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2011-2012 Pentaho and others
// All Rights Reserved.
*/
package mondrian.rolap.agg;
import mondrian.olap.Util;
import mondrian.spi.*;
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
/**
* Mock implementation of {@link SegmentCache} that is used for automated
* testing.
*
* It tries to marshall / unmarshall all {@link SegmentHeader} and
* {@link SegmentBody} objects that are sent to it.
*
* @author LBoudreau
*/
public class MockSegmentCache implements SegmentCache {
private static final Map cache =
new ConcurrentHashMap();
private final List listeners =
new CopyOnWriteArrayList();
private Random rnd;
private static final int maxElements = 100;
public boolean contains(SegmentHeader header) {
return cache.containsKey(header);
}
public SegmentBody get(SegmentHeader header) {
return cache.get(header);
}
public boolean put(
final SegmentHeader header,
final SegmentBody body)
{
// Try to serialize back and forth. if the tests fail because of this,
// then the objects could not be serialized properly.
// First try with the header
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(header);
oos.close();
// deserialize
byte[] pickled = out.toByteArray();
InputStream in = new ByteArrayInputStream(pickled);
ObjectInputStream ois = new ObjectInputStream(in);
SegmentHeader o = (SegmentHeader) ois.readObject();
Util.discard(o);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Now try it with the body.
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(body);
oos.close();
// deserialize
byte[] pickled = out.toByteArray();
InputStream in = new ByteArrayInputStream(pickled);
ObjectInputStream ois = new ObjectInputStream(in);
SegmentBody o = (SegmentBody) ois.readObject();
Util.discard(o);
} catch (NotSerializableException e) {
throw new RuntimeException(
"while serializing " + body,
e);
} catch (Exception e) {
throw new RuntimeException(e);
}
cache.put(header, body);
fireSegmentCacheEvent(
new SegmentCache.SegmentCacheListener.SegmentCacheEvent()
{
public boolean isLocal() {
return true;
}
public SegmentHeader getSource() {
return header;
}
public EventType getEventType() {
return
SegmentCacheListener.SegmentCacheEvent
.EventType.ENTRY_CREATED;
}
});
if (cache.size() > maxElements) {
// Cache is full. pop one out at random.
if (rnd == null) {
rnd = new Random();
}
int index = rnd.nextInt(maxElements);
for (Iterator iterator = cache.keySet().iterator();
iterator.hasNext();)
{
Util.discard(iterator.next());
if (index-- == 0) {
iterator.remove();
break;
}
}
fireSegmentCacheEvent(
new SegmentCache.SegmentCacheListener.SegmentCacheEvent()
{
public boolean isLocal() {
return true;
}
public SegmentHeader getSource() {
return header;
}
public EventType getEventType() {
return
SegmentCacheListener.SegmentCacheEvent
.EventType.ENTRY_DELETED;
}
});
}
return true;
}
public List getSegmentHeaders() {
return new ArrayList(cache.keySet());
}
public boolean remove(final SegmentHeader header) {
cache.remove(header);
fireSegmentCacheEvent(
new SegmentCache.SegmentCacheListener.SegmentCacheEvent()
{
public boolean isLocal() {
return true;
}
public SegmentHeader getSource() {
return header;
}
public EventType getEventType() {
return
SegmentCacheListener.SegmentCacheEvent
.EventType.ENTRY_DELETED;
}
});
return true;
}
public void tearDown() {
listeners.clear();
cache.clear();
}
public void addListener(SegmentCacheListener listener) {
listeners.add(listener);
}
public void removeListener(SegmentCacheListener listener) {
listeners.remove(listener);
}
public boolean supportsRichIndex() {
return true;
}
public void fireSegmentCacheEvent(
SegmentCache.SegmentCacheListener.SegmentCacheEvent event)
{
for (SegmentCacheListener listener : listeners) {
listener.handle(event);
}
}
}
// End MockSegmentCache.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/agg/AggregationOnDistinctCountMeasuresTest.java 0000644 0001750 0001750 00000177147 11735330606 032013 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2007-2011 Pentaho and others
// All Rights Reserved.
//
// ajogleka, 19 December, 2007
*/
package mondrian.rolap.agg;
import mondrian.calc.TupleList;
import mondrian.calc.impl.UnaryTupleList;
import mondrian.olap.*;
import mondrian.olap.fun.AggregateFunDef;
import mondrian.olap.fun.CrossJoinFunDef;
import mondrian.rolap.BatchTestCase;
import mondrian.rolap.RolapCube;
import mondrian.server.Execution;
import mondrian.server.Locus;
import mondrian.spi.Dialect;
import mondrian.test.SqlPattern;
import mondrian.test.TestContext;
import java.util.*;
/**
* AggregationOnDistinctCountMeasureTest tests the
* Distinct Count functionality with tuples and members.
*
* @author ajogleka
* @since 19 December, 2007
*/
public class AggregationOnDistinctCountMeasuresTest extends BatchTestCase {
private final MondrianProperties props = MondrianProperties.instance();
private SchemaReader salesCubeSchemaReader = null;
private SchemaReader schemaReader = null;
private RolapCube salesCube;
protected void setUp() throws Exception {
schemaReader =
getTestContext().getConnection().getSchemaReader().withLocus();
salesCube = (RolapCube) cubeByName(
getTestContext().getConnection(),
cubeNameSales);
salesCubeSchemaReader =
salesCube.getSchemaReader(
getTestContext().getConnection().getRole()).withLocus();
}
public TestContext getTestContext() {
return TestContext.instance().create(
null,
null,
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ ""
+ "\n"
+ " \n"
+ " "
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "",
null,
null,
null);
}
public void testTupleWithAllLevelMembersOnly() {
assertQueryReturns(
"WITH MEMBER GENDER.X AS 'AGGREGATE({([GENDER].DEFAULTMEMBER,\n"
+ "[STORE].DEFAULTMEMBER)})'\n"
+ "SELECT GENDER.X ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[X]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 5,581\n");
}
public void testCrossJoinOfAllMembers() {
assertQueryReturns(
"WITH MEMBER GENDER.X AS 'AGGREGATE({CROSSJOIN({[GENDER].DEFAULTMEMBER},\n"
+ "{[STORE].DEFAULTMEMBER})})'\n"
+ "SELECT GENDER.X ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[X]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 5,581\n");
}
public void testCrossJoinMembersWithASingleMember() {
String query =
"WITH MEMBER GENDER.X AS 'AGGREGATE({[GENDER].[GENDER].members} * "
+ "{[STORE].[ALL STORES].[USA].[CA]})', solve_order=100 "
+ "SELECT GENDER.X ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES";
String result =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[X]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 2,716\n";
assertQueryReturns(query, result);
// Check aggregate loading sql pattern
String derbySql =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" as \"time_by_day\", \"sales_fact_1997\" as \"sales_fact_1997\", \"store\" as \"store\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 "
+ "and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" and \"store\".\"store_state\" = 'CA' "
+ "group by \"time_by_day\".\"the_year\"";
String mysqlSql =
"select `time_by_day`.`the_year` as `c0`, "
+ "count(distinct `sales_fact_1997`.`customer_id`) as `m0` "
+ "from `time_by_day` as `time_by_day`, `sales_fact_1997` as `sales_fact_1997`, `store` as `store` "
+ "where `sales_fact_1997`.`time_id` = `time_by_day`.`time_id` "
+ "and `time_by_day`.`the_year` = 1997 "
+ "and `sales_fact_1997`.`store_id` = `store`.`store_id` and `store`.`store_state` = 'CA' "
+ "group by `time_by_day`.`the_year`";
String oraTeraSql =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" =as= \"time_by_day\", \"sales_fact_1997\" =as= \"sales_fact_1997\", \"store\" =as= \"store\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and \"time_by_day\".\"the_year\" = 1997 "
+ "and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" and \"store\".\"store_state\" = 'CA' "
+ "group by \"time_by_day\".\"the_year\"";
SqlPattern[] patterns = {
new SqlPattern(Dialect.DatabaseProduct.DERBY, derbySql, derbySql),
new SqlPattern(Dialect.DatabaseProduct.MYSQL, mysqlSql, mysqlSql),
new SqlPattern(
Dialect.DatabaseProduct.ORACLE, oraTeraSql, oraTeraSql),
new SqlPattern(
Dialect.DatabaseProduct.TERADATA, oraTeraSql, oraTeraSql),
};
assertQuerySql(query, patterns);
}
public void testCrossJoinMembersWithSetOfMembers() {
String query =
"WITH MEMBER GENDER.X AS 'AGGREGATE({[GENDER].[GENDER].members} * "
+ "{[STORE].[ALL STORES].[USA].[CA], [Store].[All Stores].[Canada]})', solve_order=100 "
+ "SELECT GENDER.X ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES";
String result =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[X]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 2,716\n";
assertQueryReturns(query, result);
// Check aggregate loading sql pattern. Note Derby does not support
// multicolumn IN list, so the predicates remain in AND/OR form.
String derbySql =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" as \"time_by_day\", \"sales_fact_1997\" as \"sales_fact_1997\", \"store\" as \"store\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 "
+ "and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and (\"store\".\"store_state\" = 'CA' or \"store\".\"store_country\" = 'Canada') "
+ "group by \"time_by_day\".\"the_year\"";
String mysqlSql =
"select `time_by_day`.`the_year` as `c0`, "
+ "count(distinct `sales_fact_1997`.`customer_id`) as `m0` "
+ "from `time_by_day` as `time_by_day`, `sales_fact_1997` as `sales_fact_1997`, `store` as `store` "
+ "where `sales_fact_1997`.`time_id` = `time_by_day`.`time_id` and `time_by_day`.`the_year` = 1997 "
+ "and `sales_fact_1997`.`store_id` = `store`.`store_id` "
+ "and (`store`.`store_state` = 'CA' or `store`.`store_country` = 'Canada') "
+ "group by `time_by_day`.`the_year`";
String oraTeraSql =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" =as= \"time_by_day\", \"sales_fact_1997\" =as= \"sales_fact_1997\", \"store\" =as= \"store\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and \"time_by_day\".\"the_year\" = 1997 "
+ "and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and (\"store\".\"store_state\" = 'CA' or \"store\".\"store_country\" = 'Canada') "
+ "group by \"time_by_day\".\"the_year\"";
SqlPattern[] patterns = {
new SqlPattern(Dialect.DatabaseProduct.DERBY, derbySql, derbySql),
new SqlPattern(Dialect.DatabaseProduct.MYSQL, mysqlSql, mysqlSql),
new SqlPattern(
Dialect.DatabaseProduct.ORACLE, oraTeraSql, oraTeraSql),
new SqlPattern(
Dialect.DatabaseProduct.TERADATA, oraTeraSql, oraTeraSql),
};
assertQuerySql(query, patterns);
}
public void testCrossJoinParticularMembersFromTwoDimensions() {
assertQueryReturns(
"WITH MEMBER GENDER.X AS 'AGGREGATE({[GENDER].M} * "
+ "{[STORE].[ALL STORES].[USA].[CA]})', solve_order=100 "
+ "SELECT GENDER.X ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[X]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 1,389\n");
}
public void testDistinctCountOnSetOfMembersFromOneDimension() {
assertQueryReturns(
"WITH MEMBER GENDER.X AS 'AGGREGATE({[GENDER].[GENDER].members})'"
+ "SELECT GENDER.X ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[X]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 5,581\n");
}
public void testDistinctCountWithAMeasureAsPartOfTuple() {
assertQueryReturns(
"SELECT [STORE].[ALL STORES].[USA].[CA] ON 0, "
+ "([MEASURES].[CUSTOMER COUNT], [Gender].[m]) ON 1 FROM SALES",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Store].[USA].[CA]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count], [Gender].[M]}\n"
+ "Row #0: 1,389\n");
}
public void testDistinctCountOnSetOfMembers() {
assertQueryReturns(
"WITH MEMBER STORE.X as 'Aggregate({[STORE].[ALL STORES].[USA].[CA],"
+ "[STORE].[ALL STORES].[USA].[WA]})'"
+ "SELECT STORE.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [SALES]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Store].[X]}\n"
+ "Row #0: 4,544\n");
}
public void testDistinctCountOnTuplesWithSomeNonJoiningDimensions() {
propSaver.set(
props.IgnoreMeasureForNonJoiningDimension, false);
String mdx =
"WITH MEMBER WAREHOUSE.X as 'Aggregate({WAREHOUSE.[STATE PROVINCE].MEMBERS}*"
+ "{[Gender].Members})'"
+ "SELECT WAREHOUSE.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [WAREHOUSE AND SALES2]";
String expectedResult =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse].[X]}\n"
+ "Row #0: \n";
assertQueryReturns(mdx, expectedResult);
propSaver.set(
props.IgnoreMeasureForNonJoiningDimension, true);
assertQueryReturns(mdx, expectedResult);
}
public void testAggregationListOptimizationForChildren() {
assertQueryReturns(
"WITH MEMBER GENDER.X AS 'AGGREGATE({[GENDER].[GENDER].members} * "
+ "{[STORE].[ALL STORES].[USA].[CA], [STORE].[ALL STORES].[USA].[OR], "
+ "[STORE].[ALL STORES].[USA].[WA], [Store].[All Stores].[Canada]})' "
+ "SELECT GENDER.X ON 0, [MEASURES].[CUSTOMER COUNT] ON 1 FROM SALES",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[X]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 5,581\n");
}
public void testDistinctCountOnMembersWithNonJoiningDimensionNotAtAllLevel()
{
assertQueryReturns(
"WITH MEMBER WAREHOUSE.X as "
+ "'Aggregate({WAREHOUSE.[STATE PROVINCE].MEMBERS})'"
+ "SELECT WAREHOUSE.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [WAREHOUSE AND SALES2]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse].[X]}\n"
+ "Row #0: \n");
}
public void testNonJoiningDimensionWithAllMember() {
assertQueryReturns(
"WITH MEMBER WAREHOUSE.X as 'Aggregate({WAREHOUSE.MEMBERS})'"
+ "SELECT WAREHOUSE.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [WAREHOUSE AND SALES2]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse].[X]}\n"
+ "Row #0: 5,581\n");
}
public void testCrossJoinOfJoiningAndNonJoiningDimensionWithAllMember() {
assertQueryReturns(
"WITH MEMBER WAREHOUSE.X AS "
+ "'AGGREGATE({GENDER.GENDER.MEMBERS} * {WAREHOUSE.MEMBERS})'"
+ "SELECT WAREHOUSE.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [WAREHOUSE AND SALES2]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse].[X]}\n"
+ "Row #0: 5,581\n");
assertQueryReturns(
"WITH MEMBER WAREHOUSE.X AS "
+ "'AGGREGATE({GENDER.GENDER.MEMBERS} * {WAREHOUSE.MEMBERS})'"
+ "SELECT WAREHOUSE.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [WAREHOUSE AND SALES3]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse].[X]}\n"
+ "Row #0: 5,581\n");
}
public void testCrossJoinOfJoiningAndNonJoiningDimension() {
assertQueryReturns(
"WITH MEMBER WAREHOUSE.X AS "
+ "'AGGREGATE({GENDER.GENDER.MEMBERS} * {WAREHOUSE.[STATE PROVINCE].MEMBERS})'"
+ "SELECT WAREHOUSE.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [WAREHOUSE AND SALES2]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse].[X]}\n"
+ "Row #0: \n");
assertQueryReturns(
"WITH MEMBER WAREHOUSE.X AS "
+ "'AGGREGATE({GENDER.GENDER.MEMBERS} * {WAREHOUSE.[STATE PROVINCE].MEMBERS})'"
+ "SELECT WAREHOUSE.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [WAREHOUSE AND SALES3]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse].[X]}\n"
+ "Row #0: 5,581\n");
}
public void testAggregationOverLargeListGeneratesError() {
int origMaxConstraint = props.MaxConstraints.get();
props.MaxConstraints.set(7);
String result;
final Dialect dialect = getTestContext().getDialect();
if (dialect.getDatabaseProduct() == Dialect.DatabaseProduct.LUCIDDB) {
// LucidDB has no limit on the size of IN list
result =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Product].[X]}\n"
+ "Row #0: 1,360\n";
} else {
result =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Product].[X]}\n"
+ "Row #0: #ERR: mondrian.olap.fun.MondrianEvaluationException: "
+ "Aggregation is not supported over a list with more than 7 predicates (see property mondrian.rolap.maxConstraints)\n";
}
assertQueryReturns(
"WITH MEMBER PRODUCT.X as 'Aggregate({"
+ "[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer].[Good],\n"
+ "[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer].[Portsmouth],\n"
+ "[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer].[Top Measure],\n"
+ "[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer].[Walrus],\n"
+ "[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Pearl],\n"
+ "[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Portsmouth],\n"
+ "[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Top Measure],\n"
+ "[Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Wine].[Walrus]})' "
+ "SELECT PRODUCT.X ON ROWS, "
+ "{[MEASURES].[CUSTOMER COUNT]} ON COLUMNS\n"
+ "FROM [WAREHOUSE AND SALES2]",
result);
props.MaxConstraints.set(origMaxConstraint);
}
public void testMultiLevelMembersNullParents() {
if (!isDefaultNullMemberRepresentation()) {
return;
}
String dimension =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n";
String cube =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "";
String query =
"with set [Filtered Warehouse Set] as "
+ "{[Warehouse2].[#null].[#null].[5617 Saclan Terrace].[Arnold and Sons],"
+ " [Warehouse2].[#null].[#null].[3377 Coachman Place].[Jones International]} "
+ "member [Warehouse2].[TwoMembers] as 'AGGREGATE([Filtered Warehouse Set])' "
+ "select {[Measures].[Cost Count]} on columns, {[Warehouse2].[TwoMembers]} on rows "
+ "from [Warehouse2]";
String necjSqlDerby =
"select count(distinct \"inventory_fact_1997\".\"warehouse_cost\") as \"m0\" "
+ "from \"warehouse\" as \"warehouse\", "
+ "\"inventory_fact_1997\" as \"inventory_fact_1997\" "
+ "where \"inventory_fact_1997\".\"warehouse_id\" = \"warehouse\".\"warehouse_id\" "
+ "and ((\"warehouse\".\"warehouse_name\" = 'Arnold and Sons' "
+ "and \"warehouse\".\"wa_address1\" = '5617 Saclan Terrace' "
+ "and \"warehouse\".\"wa_address2\" is null) "
+ "or (\"warehouse\".\"warehouse_name\" = 'Jones International' "
+ "and \"warehouse\".\"wa_address1\" = '3377 Coachman Place' "
+ "and \"warehouse\".\"wa_address2\" is null))";
String necjSqlMySql =
"select count(distinct `inventory_fact_1997`.`warehouse_cost`) as `m0` "
+ "from `warehouse` as `warehouse`, `inventory_fact_1997` as `inventory_fact_1997` "
+ "where `inventory_fact_1997`.`warehouse_id` = `warehouse`.`warehouse_id` "
+ "and ((`warehouse`.`wa_address2` is null "
+ "and (`warehouse`.`wa_address1`, `warehouse`.`warehouse_name`) "
+ "in (('5617 Saclan Terrace', 'Arnold and Sons'), "
+ "('3377 Coachman Place', 'Jones International'))))";
TestContext testContext =
TestContext.instance().create(
dimension,
cube,
null,
null,
null,
null);
SqlPattern[] patterns = {
new SqlPattern(
Dialect.DatabaseProduct.DERBY, necjSqlDerby, necjSqlDerby),
new SqlPattern(
Dialect.DatabaseProduct.MYSQL, necjSqlMySql, necjSqlMySql)
};
assertQuerySql(testContext, query, patterns);
}
public void testMultiLevelMembersMixedNullNonNullParent() {
if (!isDefaultNullMemberRepresentation()) {
return;
}
String dimension =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n";
String cube =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "";
String query =
"with\n"
+ "set [Filtered Warehouse Set] as "
+ "{[Warehouse2].[#null].[234 West Covina Pkwy].[Freeman And Co],"
+ " [Warehouse2].[971-555-6213].[3377 Coachman Place].[Jones International]} "
+ "member [Warehouse2].[TwoMembers] as 'AGGREGATE([Filtered Warehouse Set])' "
+ "select {[Measures].[Cost Count]} on columns, {[Warehouse2].[TwoMembers]} on rows "
+ "from [Warehouse2]";
String necjSqlMySql2 =
"select count(distinct `inventory_fact_1997`.`warehouse_cost`) as `m0` from `warehouse` as `warehouse`, `inventory_fact_1997` as `inventory_fact_1997` where `inventory_fact_1997`.`warehouse_id` = `warehouse`.`warehouse_id` and ((`warehouse`.`warehouse_name` = 'Freeman And Co' and `warehouse`.`wa_address1` = '234 West Covina Pkwy' and `warehouse`.`warehouse_fax` is null) or (`warehouse`.`warehouse_name` = 'Jones International' and `warehouse`.`wa_address1` = '3377 Coachman Place' and `warehouse`.`warehouse_fax` = '971-555-6213'))";
TestContext testContext =
TestContext.instance().create(
dimension,
cube,
null,
null,
null,
null);
String result =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Cost Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse2].[TwoMembers]}\n"
+ "Row #0: 220\n";
testContext.assertQueryReturns(query, result);
}
public void testMultiLevelsMixedNullNonNullChild() {
if (!isDefaultNullMemberRepresentation()) {
return;
}
String dimension =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n";
String cube =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "";
String query =
"with\n"
+ "set [Filtered Warehouse Set] as "
+ "{[Warehouse2].[#null].[#null].[#null],"
+ " [Warehouse2].[#null].[#null].[971-555-6213]} "
+ "member [Warehouse2].[TwoMembers] as 'AGGREGATE([Filtered Warehouse Set])' "
+ "select {[Measures].[Cost Count]} on columns, {[Warehouse2].[TwoMembers]} on rows "
+ "from [Warehouse2]";
String necjSqlMySql2 =
"select count(distinct `inventory_fact_1997`.`warehouse_cost`) as `m0` from `warehouse` as `warehouse`, `inventory_fact_1997` as `inventory_fact_1997` where `inventory_fact_1997`.`warehouse_id` = `warehouse`.`warehouse_id` and ((`warehouse`.`warehouse_fax` is null and `warehouse`.`wa_address2` is null and `warehouse`.`wa_address3` is null) or (`warehouse`.`warehouse_fax` = '971-555-6213' and `warehouse`.`wa_address2` is null and `warehouse`.`wa_address3` is null))";
TestContext testContext =
TestContext.instance().create(
dimension,
cube,
null,
null,
null,
null);
String result =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Cost Count]}\n"
+ "Axis #2:\n"
+ "{[Warehouse2].[TwoMembers]}\n"
+ "Row #0: 220\n";
testContext.assertQueryReturns(query, result);
}
public void testAggregationOnCJofMembersGeneratesOptimalQuery() {
// Mondrian does not use GROUPING SETS for distinct-count measures.
// So, this test should not use GROUPING SETS, even if they are enabled.
// See change 12310, bug MONDRIAN-470 (aka SF.net 2207515).
Util.discard(props.EnableGroupingSets);
String oraTeraSql =
"select \"store\".\"store_state\" as \"c0\","
+ " \"time_by_day\".\"the_year\" as \"c1\","
+ " count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"store\" =as= \"store\","
+ " \"sales_fact_1997\" =as= \"sales_fact_1997\","
+ " \"time_by_day\" =as= \"time_by_day\" "
+ "where \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 "
+ "group by \"store\".\"store_state\", \"time_by_day\".\"the_year\"";
SqlPattern[] patterns = {
new SqlPattern(
Dialect.DatabaseProduct.ORACLE, oraTeraSql, oraTeraSql),
new SqlPattern(
Dialect.DatabaseProduct.TERADATA, oraTeraSql, oraTeraSql),
};
assertQuerySql(
"WITH \n"
+ "SET [COG_OQP_INT_s2] AS 'CROSSJOIN({[Store].[Store].MEMBERS}, "
+ "{{[Gender].[Gender].MEMBERS}, "
+ "{([Gender].[COG_OQP_USR_Aggregate(Gender)])}})' \n"
+ "SET [COG_OQP_INT_s1] AS 'CROSSJOIN({[Store].[Store].MEMBERS}, "
+ "{[Gender].[Gender].MEMBERS})' \n"
+ "\n"
+ "MEMBER [Store].[COG_OQP_USR_Aggregate(Store)] AS '\n"
+ "AGGREGATE({COG_OQP_INT_s1})', SOLVE_ORDER = 4 \n"
+ "\n"
+ "MEMBER [Gender].[COG_OQP_USR_Aggregate(Gender)] AS '\n"
+ "AGGREGATE({[Gender].DEFAULTMEMBER})', SOLVE_ORDER = 8 \n"
+ "\n"
+ "\n"
+ "SELECT {[Measures].[Customer Count]} ON AXIS(0), \n"
+ "{[COG_OQP_INT_s2], HEAD({([Store].[COG_OQP_USR_Aggregate(Store)], "
+ "[Gender].DEFAULTMEMBER)}, "
+ "IIF(COUNT([COG_OQP_INT_s1], INCLUDEEMPTY) > 0, 1, 0))} ON AXIS(1) \n"
+ "FROM [sales]",
patterns);
}
public void testCanNotBatchForDifferentCompoundPredicate() {
boolean originalGroupingSetsPropertyValue =
props.EnableGroupingSets.get();
props.EnableGroupingSets.set(true);
String mdxQueryWithFewMembers =
"WITH "
+ "MEMBER [Store].[COG_OQP_USR_Aggregate(Store)] AS "
+ "'AGGREGATE({[Store].[All Stores].[USA].[CA], [Store].[All Stores].[USA].[OR],[Store].[All Stores].[USA].[WA]})', SOLVE_ORDER = 8"
+ "SELECT {[Measures].[Customer Count]} ON AXIS(0), "
+ "{[Store].[All Stores].[USA].[CA], [Store].[All Stores].[USA].[OR], [Store].[COG_OQP_USR_Aggregate(Store)]} "
+ "ON AXIS(1) "
+ "FROM [Sales]";
String desiredResult =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Store].[USA].[CA]}\n"
+ "{[Store].[USA].[OR]}\n"
+ "{[Store].[COG_OQP_USR_Aggregate(Store)]}\n"
+ "Row #0: 2,716\n"
+ "Row #1: 1,037\n"
+ "Row #2: 5,581\n";
String oraTeraSqlForAgg =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" =as= \"time_by_day\", "
+ "\"sales_fact_1997\" =as= \"sales_fact_1997\", \"store\" =as= \"store\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 and "
+ "\"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and \"store\".\"store_country\" = 'USA' "
+ "group by \"time_by_day\".\"the_year\"";
String oraTeraSqlForDetail =
"select \"store\".\"store_state\" as \"c0\", "
+ "\"time_by_day\".\"the_year\" as \"c1\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"store\" =as= \"store\", "
+ "\"sales_fact_1997\" =as= \"sales_fact_1997\", "
+ "\"time_by_day\" =as= \"time_by_day\" "
+ "where \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and \"store\".\"store_state\" in ('CA', 'OR') "
+ "and \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 "
+ "group by \"store\".\"store_state\", \"time_by_day\".\"the_year\"";
SqlPattern[] patterns = {
new SqlPattern(
Dialect.DatabaseProduct.ORACLE,
oraTeraSqlForAgg,
oraTeraSqlForAgg),
new SqlPattern(
Dialect.DatabaseProduct.TERADATA,
oraTeraSqlForAgg,
oraTeraSqlForAgg),
new SqlPattern(
Dialect.DatabaseProduct.ORACLE,
oraTeraSqlForDetail,
oraTeraSqlForDetail),
new SqlPattern(
Dialect.DatabaseProduct.TERADATA,
oraTeraSqlForDetail,
oraTeraSqlForDetail),
};
assertQueryReturns(mdxQueryWithFewMembers, desiredResult);
assertQuerySql(mdxQueryWithFewMembers, patterns);
props.EnableGroupingSets.set(originalGroupingSetsPropertyValue);
}
/**
* Test distinct count agg happens in non gs query for subset of members
* with mixed measures.
*/
public void testDistinctCountInNonGroupingSetsQuery() {
boolean originalGroupingSetsPropertyValue =
props.EnableGroupingSets.get();
props.EnableGroupingSets.set(true);
String mdxQueryWithFewMembers =
"WITH "
+ "MEMBER [Store].[COG_OQP_USR_Aggregate(Store)] AS "
+ "'AGGREGATE({[Store].[All Stores].[USA].[CA], [Store].[All Stores].[USA].[OR]})', SOLVE_ORDER = 8"
+ "SELECT {[Measures].[Customer Count],[Measures].[Unit Sales]} ON AXIS(0), "
+ "{[Store].[All Stores].[USA].[CA], [Store].[All Stores].[USA].[OR], [Store].[COG_OQP_USR_Aggregate(Store)]} "
+ "ON AXIS(1) "
+ "FROM [Sales]";
String desiredResult =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n"
+ "{[Store].[USA].[CA]}\n"
+ "{[Store].[USA].[OR]}\n"
+ "{[Store].[COG_OQP_USR_Aggregate(Store)]}\n"
+ "Row #0: 2,716\n"
+ "Row #0: 74,748\n"
+ "Row #1: 1,037\n"
+ "Row #1: 67,659\n"
+ "Row #2: 3,753\n"
+ "Row #2: 142,407\n";
String oraTeraSqlForDetail =
"select \"store\".\"store_state\" as \"c0\", "
+ "\"time_by_day\".\"the_year\" as \"c1\", "
+ "sum(\"sales_fact_1997\".\"unit_sales\") as \"m0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m1\" "
+ "from \"store\" =as= \"store\", \"sales_fact_1997\" =as= \"sales_fact_1997\", "
+ "\"time_by_day\" =as= \"time_by_day\" "
+ "where \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and \"store\".\"store_state\" in ('CA', 'OR') "
+ "and \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 "
+ "group by \"store\".\"store_state\", \"time_by_day\".\"the_year\"";
String oraTeraSqlForDistinctCountAgg =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" =as= \"time_by_day\", "
+ "\"sales_fact_1997\" =as= \"sales_fact_1997\", \"store\" =as= \"store\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 "
+ "and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and \"store\".\"store_state\" in ('CA', 'OR') "
+ "group by \"time_by_day\".\"the_year\"";
SqlPattern[] patterns = {
new SqlPattern(
Dialect.DatabaseProduct.ORACLE,
oraTeraSqlForDetail,
oraTeraSqlForDetail),
new SqlPattern(
Dialect.DatabaseProduct.TERADATA,
oraTeraSqlForDetail,
oraTeraSqlForDetail),
new SqlPattern(
Dialect.DatabaseProduct.ORACLE,
oraTeraSqlForDistinctCountAgg,
oraTeraSqlForDistinctCountAgg),
new SqlPattern(
Dialect.DatabaseProduct.TERADATA,
oraTeraSqlForDistinctCountAgg,
oraTeraSqlForDistinctCountAgg),
};
assertQueryReturns(mdxQueryWithFewMembers, desiredResult);
assertQuerySql(mdxQueryWithFewMembers, patterns);
props.EnableGroupingSets.set(originalGroupingSetsPropertyValue);
}
public void testAggregationOfMembersAndDefaultMemberWithoutGroupingSets() {
boolean originalGroupingSetsPropertyValue =
props.EnableGroupingSets.get();
props.EnableGroupingSets.set(false);
String mdxQueryWithMembers =
"WITH "
+ "MEMBER [Gender].[COG_OQP_USR_Aggregate(Gender)] AS "
+ "'AGGREGATE({[Gender].MEMBERS})', SOLVE_ORDER = 8"
+ "SELECT {[Measures].[Customer Count]} ON AXIS(0), "
+ "{[Gender].MEMBERS, [Gender].[COG_OQP_USR_Aggregate(Gender)]} "
+ "ON AXIS(1) "
+ "FROM [Sales]";
String mdxQueryWithDefaultMember =
"WITH "
+ "MEMBER [Gender].[COG_OQP_USR_Aggregate(Gender)] AS "
+ "'AGGREGATE({[Gender].DEFAULTMEMBER})', SOLVE_ORDER = 8"
+ "SELECT {[Measures].[Customer Count]} ON AXIS(0), \n"
+ "{[Gender].MEMBERS, [Gender].[COG_OQP_USR_Aggregate(Gender)]} "
+ "ON AXIS(1) \n"
+ "FROM [sales]";
String desiredResult =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Gender].[All Gender]}\n"
+ "{[Gender].[F]}\n"
+ "{[Gender].[M]}\n"
+ "{[Gender].[COG_OQP_USR_Aggregate(Gender)]}\n"
+ "Row #0: 5,581\n"
+ "Row #1: 2,755\n"
+ "Row #2: 2,826\n"
+ "Row #3: 5,581\n";
String oraTeraSql =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "\"customer\".\"gender\" as \"c1\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" =as= \"time_by_day\", "
+ "\"sales_fact_1997\" =as= \"sales_fact_1997\", \"customer\" =as= \"customer\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 "
+ "and \"sales_fact_1997\".\"customer_id\" = \"customer\".\"customer_id\" "
+ "group by \"time_by_day\".\"the_year\", \"customer\".\"gender\"";
SqlPattern[] patterns = {
new SqlPattern(
Dialect.DatabaseProduct.ORACLE, oraTeraSql, oraTeraSql),
new SqlPattern(
Dialect.DatabaseProduct.TERADATA, oraTeraSql, oraTeraSql),
};
assertQueryReturns(mdxQueryWithMembers, desiredResult);
assertQuerySql(mdxQueryWithMembers, patterns);
assertQueryReturns(mdxQueryWithDefaultMember, desiredResult);
assertQuerySql(mdxQueryWithDefaultMember, patterns);
props.EnableGroupingSets.set(originalGroupingSetsPropertyValue);
}
public void testOptimizeChildren() {
String query =
"with member gender.x as "
+ "'aggregate("
+ "{gender.gender.members * Store.[all stores].[usa].children})' "
+ "select {gender.x} on 0, measures.[customer count] on 1 from sales";
String expected =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[x]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 5,581\n";
assertQueryReturns(query, expected);
String derbySql =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" as \"time_by_day\", \"sales_fact_1997\" as \"sales_fact_1997\", \"store\" as \"store\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and \"time_by_day\".\"the_year\" = 1997 "
+ "and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and \"store\".\"store_country\" = 'USA' group by \"time_by_day\".\"the_year\"";
String accessSql =
"select `d0` as `c0`, count(`m0`) as `c1` "
+ "from (select distinct `time_by_day`.`the_year` as `d0`, `sales_fact_1997`.`customer_id` as `m0` "
+ "from `time_by_day` as `time_by_day`, `sales_fact_1997` as `sales_fact_1997`, `store` as `store` "
+ "where `sales_fact_1997`.`time_id` = `time_by_day`.`time_id` and `time_by_day`.`the_year` = 1997 "
+ "and `sales_fact_1997`.`store_id` = `store`.`store_id` "
+ "and `store`.`store_country` = 'USA') as `dummyname` group by `d0`";
// For LucidDB, we don't optimize since it supports
// unlimited IN list.
String luciddbSql =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" as \"time_by_day\", \"sales_fact_1997\" as \"sales_fact_1997\", \"customer\" as \"customer\", \"store\" as \"store\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and \"time_by_day\".\"the_year\" = 1997 and \"sales_fact_1997\".\"customer_id\" = \"customer\".\"customer_id\" "
+ "and \"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" "
+ "and (((\"store\".\"store_state\", \"customer\".\"gender\") in (('CA', 'F'), ('OR', 'F'), ('WA', 'F'), ('CA', 'M'), ('OR', 'M'), ('WA', 'M')))) group by \"time_by_day\".\"the_year\"";
SqlPattern[] patterns = {
new SqlPattern(Dialect.DatabaseProduct.DERBY, derbySql, derbySql),
new SqlPattern(
Dialect.DatabaseProduct.ACCESS, accessSql, accessSql),
new SqlPattern(
Dialect.DatabaseProduct.LUCIDDB, luciddbSql, luciddbSql),
};
assertQuerySql(query, patterns);
}
public void testOptimizeListWhenTuplesAreFormedWithDifferentLevels() {
String query =
"WITH\n"
+ "MEMBER Product.Agg AS \n"
+ "'Aggregate({[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pot Scrubbers].[Cormorant],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pot Scrubbers].[Denny],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pot Scrubbers].[High Quality],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pot Scrubbers].[Red Wing],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[Cormorant],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[Denny],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[High Quality],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[Red Wing],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[Sunset]} *\n"
+ "{[Gender].[Gender].Members})'\n"
+ "SELECT {Product.Agg} on 0, {[Measures].[Customer Count]} on 1\n"
+ "from Sales\n"
+ "where [Time.Weekly].[1997]";
String expected =
"Axis #0:\n"
+ "{[Time].[Weekly].[1997]}\n"
+ "Axis #1:\n"
+ "{[Product].[Agg]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 421\n";
assertQueryReturns(query, expected);
String derbySql =
"select \"time_by_day\".\"the_year\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"time_by_day\" as \"time_by_day\", \"sales_fact_1997\" as \"sales_fact_1997\", "
+ "\"product\" as \"product\", \"product_class\" as \"product_class\" "
+ "where \"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" "
+ "and \"time_by_day\".\"the_year\" = 1997 and \"sales_fact_1997\".\"product_id\" = \"product\".\"product_id\" "
+ "and \"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" "
+ "and (((\"product\".\"brand_name\" = 'Red Wing' and \"product_class\".\"product_subcategory\" = 'Pot Scrubbers' "
+ "and \"product_class\".\"product_category\" = 'Kitchen Products' "
+ "and \"product_class\".\"product_department\" = 'Household' "
+ "and \"product_class\".\"product_family\" = 'Non-Consumable') "
+ "or (\"product\".\"brand_name\" = 'Cormorant' and \"product_class\".\"product_subcategory\" = 'Pot Scrubbers' "
+ "and \"product_class\".\"product_category\" = 'Kitchen Products' "
+ "and \"product_class\".\"product_department\" = 'Household' "
+ "and \"product_class\".\"product_family\" = 'Non-Consumable') "
+ "or (\"product\".\"brand_name\" = 'Denny' and \"product_class\".\"product_subcategory\" = 'Pot Scrubbers' "
+ "and \"product_class\".\"product_category\" = 'Kitchen Products' "
+ "and \"product_class\".\"product_department\" = 'Household' "
+ "and \"product_class\".\"product_family\" = 'Non-Consumable') or (\"product\".\"brand_name\" = 'High Quality' "
+ "and \"product_class\".\"product_subcategory\" = 'Pot Scrubbers' "
+ "and \"product_class\".\"product_category\" = 'Kitchen Products' "
+ "and \"product_class\".\"product_department\" = 'Household' and \"product_class\".\"product_family\" = 'Non-Consumable')) "
+ "or (\"product_class\".\"product_subcategory\" = 'Pots and Pans' "
+ "and \"product_class\".\"product_category\" = 'Kitchen Products' and \"product_class\".\"product_department\" = 'Household' "
+ "and \"product_class\".\"product_family\" = 'Non-Consumable')) "
+ "group by \"time_by_day\".\"the_year\"";
String accessSql =
"select `d0` as `c0`, count(`m0`) as `c1` from (select distinct `time_by_day`.`the_year` as `d0`, `sales_fact_1997`.`customer_id` as `m0` "
+ "from `time_by_day` as `time_by_day`, `sales_fact_1997` as `sales_fact_1997`, `product` as `product`, `product_class` as `product_class` "
+ "where `sales_fact_1997`.`time_id` = `time_by_day`.`time_id` and `time_by_day`.`the_year` = 1997 "
+ "and `sales_fact_1997`.`product_id` = `product`.`product_id` and `product`.`product_class_id` = `product_class`.`product_class_id` "
+ "and (((`product`.`brand_name` = 'High Quality' and `product_class`.`product_subcategory` = 'Pot Scrubbers' "
+ "and `product_class`.`product_category` = 'Kitchen Products' and `product_class`.`product_department` = 'Household' "
+ "and `product_class`.`product_family` = 'Non-Consumable') or (`product`.`brand_name` = 'Denny' "
+ "and `product_class`.`product_subcategory` = 'Pot Scrubbers' and `product_class`.`product_category` = 'Kitchen Products' "
+ "and `product_class`.`product_department` = 'Household' "
+ "and `product_class`.`product_family` = 'Non-Consumable') or (`product`.`brand_name` = 'Red Wing' "
+ "and `product_class`.`product_subcategory` = 'Pot Scrubbers' and `product_class`.`product_category` = 'Kitchen Products' "
+ "and `product_class`.`product_department` = 'Household' "
+ "and `product_class`.`product_family` = 'Non-Consumable') or (`product`.`brand_name` = 'Cormorant' "
+ "and `product_class`.`product_subcategory` = 'Pot Scrubbers' and `product_class`.`product_category` = 'Kitchen Products' "
+ "and `product_class`.`product_department` = 'Household' "
+ "and `product_class`.`product_family` = 'Non-Consumable')) or (`product_class`.`product_subcategory` = 'Pots and Pans' "
+ "and `product_class`.`product_category` = 'Kitchen Products' and `product_class`.`product_department` = 'Household' "
+ "and `product_class`.`product_family` = 'Non-Consumable'))) as `dummyname` group by `d0`";
// FIXME jvs 20-Sept-2008: The Derby pattern fails, probably due to
// usage of non-order-deterministic Hash data structures in
// AggregateFunDef. (Access may be failing too; I haven't tried it.)
// So it is disabled for now. Perhaps this test should be calling
// directly into optimizeChildren like some of the tests below rather
// than using SQL pattern verification.
SqlPattern[] patterns = {
/*
new SqlPattern(SqlPattern.Dialect.DERBY, derbySql, derbySql),
*/
new SqlPattern(
Dialect.DatabaseProduct.ACCESS, accessSql, accessSql)};
assertQuerySql(query, patterns);
}
public void testOptimizeListWithTuplesOfLength3() {
String query =
"WITH\n"
+ "MEMBER Product.Agg AS \n"
+ "'Aggregate"
+ "({[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pot Scrubbers].[Cormorant],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pot Scrubbers].[Denny],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pot Scrubbers].[High Quality],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pot Scrubbers].[Red Wing],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[Cormorant],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[Denny],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[High Quality],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[Red Wing],\n"
+ "[Product].[All Products].[Non-Consumable].[Household].[Kitchen Products].[Pots and Pans].[Sunset]} *\n"
+ "{[Gender].[Gender].Members}*"
+ "{[Store].[All Stores].[USA].[CA].[Alameda],\n"
+ "[Store].[All Stores].[USA].[CA].[Alameda].[HQ],\n"
+ "[Store].[All Stores].[USA].[CA].[Beverly Hills],\n"
+ "[Store].[All Stores].[USA].[CA].[Beverly Hills].[Store 6],\n"
+ "[Store].[All Stores].[USA].[CA].[Los Angeles],\n"
+ "[Store].[All Stores].[USA].[OR].[Portland],\n"
+ "[Store].[All Stores].[USA].[OR].[Portland].[Store 11],\n"
+ "[Store].[All Stores].[USA].[OR].[Salem],\n"
+ "[Store].[All Stores].[USA].[OR].[Salem].[Store 13]})'\n"
+ "SELECT {Product.Agg} on 0, {[Measures].[Customer Count]} on 1 from Sales";
String expected =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Product].[Agg]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 189\n";
assertQueryReturns(query, expected);
}
public void testOptimizeChildrenForTuplesWithLength1() {
TupleList memberList =
productMembersPotScrubbersPotsAndPans(
salesCubeSchemaReader);
TupleList tuples = optimizeChildren(memberList);
assertTrue(
tuppleListContains(
tuples,
member(
Id.Segment.toList(
"Product", "All Products", "Non-Consumable",
"Household", "Kitchen Products", "Pot Scrubbers",
"Cormorant"),
salesCubeSchemaReader)));
assertFalse(
tuppleListContains(
tuples,
member(
Id.Segment.toList(
"Product", "All Products", "Non-Consumable",
"Household", "Kitchen Products", "Pot Scrubbers"),
salesCubeSchemaReader)));
assertFalse(
tuppleListContains(
tuples,
member(
Id.Segment.toList(
"Product", "All Products", "Non-Consumable",
"Household", "Kitchen Products", "Pots and Pans",
"Cormorant"),
salesCubeSchemaReader)));
assertTrue(
tuppleListContains(
tuples,
member(
Id.Segment.toList(
"Product", "All Products", "Non-Consumable",
"Household", "Kitchen Products", "Pots and Pans"),
salesCubeSchemaReader)));
assertEquals(4, tuples.size());
}
public void testOptimizeChildrenForTuplesWithLength3() {
TupleList memberList =
CrossJoinFunDef.mutableCrossJoin(
genderMembersIncludingAll(
false, salesCubeSchemaReader, salesCube),
productMembersPotScrubbersPotsAndPans(salesCubeSchemaReader));
memberList =
CrossJoinFunDef.mutableCrossJoin(
memberList, storeMembersCAAndOR(salesCubeSchemaReader));
TupleList tuples = optimizeChildren(memberList);
assertFalse(
tuppleListContains(
tuples,
member(
Id.Segment.toList(
"Store", "All Stores", "USA", "OR", "Portland"),
salesCubeSchemaReader)));
assertTrue(
tuppleListContains(
tuples,
member(
Id.Segment.toList("Store", "All Stores", "USA", "OR"),
salesCubeSchemaReader)));
assertEquals(16, tuples.size());
}
public void testOptimizeChildrenWhenTuplesAreFormedWithDifferentLevels() {
TupleList memberList =
CrossJoinFunDef.mutableCrossJoin(
genderMembersIncludingAll(
false, salesCubeSchemaReader, salesCube),
productMembersPotScrubbersPotsAndPans(salesCubeSchemaReader));
TupleList tuples = optimizeChildren(memberList);
assertEquals(4, tuples.size());
assertFalse(
tuppleListContains(
tuples,
member(
Id.Segment.toList(
"Product", "All Products", "Non-Consumable",
"Household", "Kitchen Products", "Pots and Pans",
"Cormorant"),
salesCubeSchemaReader)));
assertTrue(
tuppleListContains(
tuples,
member(
Id.Segment.toList(
"Product", "All Products", "Non-Consumable",
"Household", "Kitchen Products", "Pots and Pans"),
salesCubeSchemaReader)));
assertTrue(
tuppleListContains(
tuples,
member(
Id.Segment.toList(
"Product", "All Products", "Non-Consumable",
"Household", "Kitchen Products", "Pot Scrubbers",
"Cormorant"),
salesCubeSchemaReader)));
}
public void testWhetherCJOfChildren() {
TupleList memberList =
CrossJoinFunDef.mutableCrossJoin(
genderMembersIncludingAll(
false, salesCubeSchemaReader, salesCube),
storeMembersUsaAndCanada(
false, salesCubeSchemaReader, salesCube));
List tuples = optimizeChildren(memberList);
assertEquals(2, tuples.size());
}
public void testShouldNotRemoveDuplicateTuples() {
Member maleChildMember = member(
Id.Segment.toList("Gender", "All Gender", "M"),
salesCubeSchemaReader);
Member femaleChildMember = member(
Id.Segment.toList("Gender", "All Gender", "F"),
salesCubeSchemaReader);
List memberList = new ArrayList();
memberList.add(maleChildMember);
memberList.add(maleChildMember);
memberList.add(femaleChildMember);
TupleList tuples = new UnaryTupleList(memberList);
tuples = optimizeChildren(tuples);
assertEquals(3, tuples.size());
}
public void testMemberCountIsSameForAllMembersInTuple() {
TupleList memberList =
CrossJoinFunDef.mutableCrossJoin(
genderMembersIncludingAll(
false, salesCubeSchemaReader, salesCube),
storeMembersUsaAndCanada(
false, salesCubeSchemaReader, salesCube));
Map[] memberCounterMap =
AggregateFunDef.AggregateCalc.membersVersusOccurencesInTuple(
memberList);
assertTrue(
Util.areOccurencesEqual(
memberCounterMap[0].values()));
assertTrue(
Util.areOccurencesEqual(
memberCounterMap[1].values()));
}
public void testMemberCountIsNotSameForAllMembersInTuple() {
Member maleChild =
member(
Id.Segment.toList("Gender", "All Gender", "M"),
salesCubeSchemaReader);
Member femaleChild =
member(
Id.Segment.toList("Gender", "All Gender", "F"),
salesCubeSchemaReader);
Member mexicoMember =
member(
Id.Segment.toList("Store", "All Stores", "Mexico"),
salesCubeSchemaReader);
TupleList memberList =
new UnaryTupleList(
Collections.singletonList(maleChild));
memberList = CrossJoinFunDef.mutableCrossJoin(
memberList,
storeMembersUsaAndCanada(
false, salesCubeSchemaReader, salesCube));
memberList.addTuple(femaleChild, mexicoMember);
Map[] memberCounterMap =
AggregateFunDef.AggregateCalc.membersVersusOccurencesInTuple(
memberList);
assertFalse(
Util.areOccurencesEqual(
memberCounterMap[0].values()));
assertTrue(
Util.areOccurencesEqual(
memberCounterMap[1].values()));
}
public void testAggregatesAtTheSameLevelForNormalAndDistinctCountMeasure() {
boolean useGroupingSets = props.EnableGroupingSets.get();
props.EnableGroupingSets.set(true);
try {
assertQueryReturns(
"WITH "
+ "MEMBER GENDER.AGG AS 'AGGREGATE({ GENDER.[F] })' "
+ "MEMBER GENDER.AGG2 AS 'AGGREGATE({ GENDER.[M] })' "
+ "SELECT "
+ "{ MEASURES.[CUSTOMER COUNT], MEASURES.[UNIT SALES] } ON 0, "
+ "{ GENDER.AGG, GENDER.AGG2 } ON 1 \n"
+ "FROM SALES",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n"
+ "{[Gender].[AGG]}\n"
+ "{[Gender].[AGG2]}\n"
+ "Row #0: 2,755\n"
+ "Row #0: 131,558\n"
+ "Row #1: 2,826\n"
+ "Row #1: 135,215\n");
} finally {
props.EnableGroupingSets.set(useGroupingSets);
}
}
public void testDistinctCountForAggregatesAtTheSameLevel() {
boolean useGroupingSets = props.EnableGroupingSets.get();
props.EnableGroupingSets.set(true);
try {
assertQueryReturns(
"WITH "
+ "MEMBER GENDER.AGG AS 'AGGREGATE({ GENDER.[F], GENDER.[M] })' "
+ "SELECT "
+ "{MEASURES.[CUSTOMER COUNT]} ON 0, "
+ "{GENDER.AGG } ON 1 "
+ "FROM SALES",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Axis #2:\n"
+ "{[Gender].[AGG]}\n"
+ "Row #0: 5,581\n");
} finally {
props.EnableGroupingSets.set(useGroupingSets);
}
}
/**
* This test makes sure that the AggregateFunDef will not optimize a tuples
* list when the rollup policy is set to something else than FULL, as it
* results in wrong data for a distinct count operation when using roles to
* narrow down the members access.
*/
public void testMondrian906() {
final TestContext context =
TestContext.instance().create(
null, null, null, null, null,
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n");
final String mdx =
"select {[Customers].[USA], [Customers].[USA].[OR], [Customers].[USA].[WA]} on columns, {[Measures].[Customer Count]} on rows from [Sales]";
context
.withRole("Role1")
.assertQueryReturns(
mdx,
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Customers].[USA]}\n"
+ "{[Customers].[USA].[OR]}\n"
+ "{[Customers].[USA].[WA]}\n"
+ "Axis #2:\n"
+ "{[Measures].[Customer Count]}\n"
+ "Row #0: 2,865\n"
+ "Row #0: 1,037\n"
+ "Row #0: 1,828\n");
}
private boolean tuppleListContains(
TupleList tuples,
Member memberByUniqueName)
{
if (tuples.getArity() == 1) {
return tuples.contains(
Collections.singletonList(memberByUniqueName));
}
for (List tuple : tuples) {
if (tuple.contains(memberByUniqueName)) {
return true;
}
}
return false;
}
private TupleList optimizeChildren(final TupleList memberList) {
return Locus.execute(
Execution.NONE,
"AggregationOnDistinctCountMeasuresTest",
new Locus.Action() {
public TupleList execute() {
return AggregateFunDef.AggregateCalc.optimizeChildren(
memberList, schemaReader, salesCube);
}
}
);
}
}
// End AggregationOnDistinctCountMeasuresTest.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/CacheControlTest.java 0000644 0001750 0001750 00000133650 11735330606 024644 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2006-2012 Pentaho
// All Rights Reserved.
*/
package mondrian.rolap;
import mondrian.olap.*;
import mondrian.olap.CacheControl.CellRegion;
import mondrian.test.*;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;
/**
* Unit-test for cache-flushing functionality.
*
* @author jhyde
* @since Sep 27, 2006
*/
public class CacheControlTest extends FoodMartTestCase {
/**
* Creates a CacheControlTest.
*/
public CacheControlTest() {
}
/**
* Creates a CacheControlTest with the given name.
*/
public CacheControlTest(String name) {
super(name);
}
/**
* Returns the repository of result strings.
* @return repository of result strings
*/
DiffRepository getDiffRepos() {
return DiffRepository.lookup(CacheControlTest.class);
}
/**
* Flushes the entire contents of the cache. Utility method used to ensure
* that cache control tests are starting with a blank page.
*
* @param testContext Test context
*/
public static void flushCache(TestContext testContext) {
final CacheControl cacheControl =
testContext.getConnection().getCacheControl(null);
// Flush the entire cache.
CacheControl.CellRegion measuresRegion = null;
for (Cube cube
: testContext.getConnection().getSchema().getCubes())
{
measuresRegion =
cacheControl.createMeasuresRegion(cube);
cacheControl.flush(measuresRegion);
}
// Check the cache is empty.
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
cacheControl.printCacheState(pw, measuresRegion);
pw.flush();
assertEquals("", sw.toString());
}
/**
* Asserts that a cache state string is equal to an expected cache state,
* after segment ids have been masked out.
*
* @param tag Tag of resource in diff repository
* @param expected Expected state
* @param actual Actual state
*/
private void assertCacheStateEquals(
String tag, String expected, String actual)
{
String expected2 = expected.replaceAll("Segment #[0-9]+", "Segment ##");
String actual2 = actual.replaceAll("Segment #[0-9]+", "Segment ##");
getDiffRepos().assertEquals(tag, expected2, actual2);
}
/**
* Runs a simple query an asserts that the results are as expected.
*
* @param testContext Test context
*/
private void standardQuery(TestContext testContext) {
testContext.assertQueryReturns(
"select {[Time].[Time].Members} on columns,\n"
+ " {[Product].Children} on rows\n"
+ "from [Sales]",
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Time].[1997]}\n"
+ "{[Time].[1997].[Q1]}\n"
+ "{[Time].[1997].[Q1].[1]}\n"
+ "{[Time].[1997].[Q1].[2]}\n"
+ "{[Time].[1997].[Q1].[3]}\n"
+ "{[Time].[1997].[Q2]}\n"
+ "{[Time].[1997].[Q2].[4]}\n"
+ "{[Time].[1997].[Q2].[5]}\n"
+ "{[Time].[1997].[Q2].[6]}\n"
+ "{[Time].[1997].[Q3]}\n"
+ "{[Time].[1997].[Q3].[7]}\n"
+ "{[Time].[1997].[Q3].[8]}\n"
+ "{[Time].[1997].[Q3].[9]}\n"
+ "{[Time].[1997].[Q4]}\n"
+ "{[Time].[1997].[Q4].[10]}\n"
+ "{[Time].[1997].[Q4].[11]}\n"
+ "{[Time].[1997].[Q4].[12]}\n"
+ "{[Time].[1998]}\n"
+ "{[Time].[1998].[Q1]}\n"
+ "{[Time].[1998].[Q1].[1]}\n"
+ "{[Time].[1998].[Q1].[2]}\n"
+ "{[Time].[1998].[Q1].[3]}\n"
+ "{[Time].[1998].[Q2]}\n"
+ "{[Time].[1998].[Q2].[4]}\n"
+ "{[Time].[1998].[Q2].[5]}\n"
+ "{[Time].[1998].[Q2].[6]}\n"
+ "{[Time].[1998].[Q3]}\n"
+ "{[Time].[1998].[Q3].[7]}\n"
+ "{[Time].[1998].[Q3].[8]}\n"
+ "{[Time].[1998].[Q3].[9]}\n"
+ "{[Time].[1998].[Q4]}\n"
+ "{[Time].[1998].[Q4].[10]}\n"
+ "{[Time].[1998].[Q4].[11]}\n"
+ "{[Time].[1998].[Q4].[12]}\n"
+ "Axis #2:\n"
+ "{[Product].[Drink]}\n"
+ "{[Product].[Food]}\n"
+ "{[Product].[Non-Consumable]}\n"
+ "Row #0: 24,597\n"
+ "Row #0: 5,976\n"
+ "Row #0: 1,910\n"
+ "Row #0: 1,951\n"
+ "Row #0: 2,115\n"
+ "Row #0: 5,895\n"
+ "Row #0: 1,948\n"
+ "Row #0: 2,039\n"
+ "Row #0: 1,908\n"
+ "Row #0: 6,065\n"
+ "Row #0: 2,205\n"
+ "Row #0: 1,921\n"
+ "Row #0: 1,939\n"
+ "Row #0: 6,661\n"
+ "Row #0: 1,898\n"
+ "Row #0: 2,344\n"
+ "Row #0: 2,419\n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #0: \n"
+ "Row #1: 191,940\n"
+ "Row #1: 47,809\n"
+ "Row #1: 15,604\n"
+ "Row #1: 15,142\n"
+ "Row #1: 17,063\n"
+ "Row #1: 44,825\n"
+ "Row #1: 14,393\n"
+ "Row #1: 15,055\n"
+ "Row #1: 15,377\n"
+ "Row #1: 47,440\n"
+ "Row #1: 17,036\n"
+ "Row #1: 15,741\n"
+ "Row #1: 14,663\n"
+ "Row #1: 51,866\n"
+ "Row #1: 14,232\n"
+ "Row #1: 18,278\n"
+ "Row #1: 19,356\n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #2: 50,236\n"
+ "Row #2: 12,506\n"
+ "Row #2: 4,114\n"
+ "Row #2: 3,864\n"
+ "Row #2: 4,528\n"
+ "Row #2: 11,890\n"
+ "Row #2: 3,838\n"
+ "Row #2: 3,987\n"
+ "Row #2: 4,065\n"
+ "Row #2: 12,343\n"
+ "Row #2: 4,522\n"
+ "Row #2: 4,035\n"
+ "Row #2: 3,786\n"
+ "Row #2: 13,497\n"
+ "Row #2: 3,828\n"
+ "Row #2: 4,648\n"
+ "Row #2: 5,021\n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n"
+ "Row #2: \n");
}
// ---------------------
// Tests
/**
* Tests creation of a cell region against an abstract implementation of
* {@link CacheControl}.
*/
public void testCreateCellRegion() {
// Execute a query.
final TestContext testContext = getTestContext();
final RolapConnection connection =
((RolapConnection) testContext.getConnection());
final CacheControl cacheControl = new CacheControlImpl(connection);
final CacheControl.CellRegion region =
createCellRegion(testContext, cacheControl);
assertNotNull(region);
}
/**
* Creates a cell region, runs a query, then flushes the cache.
*/
public void testNormalize2() {
// Execute a query.
final TestContext testContext = getTestContext();
final CacheControl cacheControl =
testContext.getConnection().getCacheControl(null);
final CacheControl.CellRegion region =
createCellRegion(testContext, cacheControl);
CacheControlImpl.CellRegion normalizedRegion =
((CacheControlImpl) cacheControl).normalize(
(CacheControlImpl.CellRegionImpl) region);
assertEquals(
"Union("
+ "Crossjoin("
+ "Member([Product].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer]), "
+ "Member([Time].[1997].[Q1]), "
+ "Member([Measures].[Unit Sales], [Measures].[Store Cost], [Measures].[Store Sales], [Measures].[Sales Count], [Measures].[Customer Count], [Measures].[Promotion Sales])), "
+ "Crossjoin("
+ "Member([Product].[Drink].[Dairy]), "
+ "Member([Time].[1997].[Q1]), "
+ "Member([Measures].[Unit Sales], [Measures].[Store Cost], [Measures].[Store Sales], [Measures].[Sales Count], [Measures].[Customer Count], [Measures].[Promotion Sales])))",
normalizedRegion.toString());
}
/**
* Creates a cell region, runs a query, then flushes the cache.
*/
public void testFlush() {
assertQueryReturns(
"SELECT {[Product].[Product Department].MEMBERS} ON AXIS(0),\n"
+ "{{[Gender].[Gender].MEMBERS}, {[Gender].[All Gender]}} ON AXIS(1)\n"
+ "FROM [Sales 2] WHERE {[Measures].[Unit Sales]}",
"Axis #0:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #1:\n"
+ "{[Product].[Drink].[Alcoholic Beverages]}\n"
+ "{[Product].[Drink].[Beverages]}\n"
+ "{[Product].[Drink].[Dairy]}\n"
+ "{[Product].[Food].[Baked Goods]}\n"
+ "{[Product].[Food].[Baking Goods]}\n"
+ "{[Product].[Food].[Breakfast Foods]}\n"
+ "{[Product].[Food].[Canned Foods]}\n"
+ "{[Product].[Food].[Canned Products]}\n"
+ "{[Product].[Food].[Dairy]}\n"
+ "{[Product].[Food].[Deli]}\n"
+ "{[Product].[Food].[Eggs]}\n"
+ "{[Product].[Food].[Frozen Foods]}\n"
+ "{[Product].[Food].[Meat]}\n"
+ "{[Product].[Food].[Produce]}\n"
+ "{[Product].[Food].[Seafood]}\n"
+ "{[Product].[Food].[Snack Foods]}\n"
+ "{[Product].[Food].[Snacks]}\n"
+ "{[Product].[Food].[Starchy Foods]}\n"
+ "{[Product].[Non-Consumable].[Carousel]}\n"
+ "{[Product].[Non-Consumable].[Checkout]}\n"
+ "{[Product].[Non-Consumable].[Health and Hygiene]}\n"
+ "{[Product].[Non-Consumable].[Household]}\n"
+ "{[Product].[Non-Consumable].[Periodicals]}\n"
+ "Axis #2:\n"
+ "{[Gender].[F]}\n"
+ "{[Gender].[M]}\n"
+ "{[Gender].[All Gender]}\n"
+ "Row #0: 3,439\n"
+ "Row #0: 6,776\n"
+ "Row #0: 1,987\n"
+ "Row #0: 3,771\n"
+ "Row #0: 9,841\n"
+ "Row #0: 1,821\n"
+ "Row #0: 9,407\n"
+ "Row #0: 867\n"
+ "Row #0: 6,513\n"
+ "Row #0: 5,990\n"
+ "Row #0: 2,001\n"
+ "Row #0: 13,011\n"
+ "Row #0: 841\n"
+ "Row #0: 18,713\n"
+ "Row #0: 947\n"
+ "Row #0: 14,936\n"
+ "Row #0: 3,459\n"
+ "Row #0: 2,696\n"
+ "Row #0: 368\n"
+ "Row #0: 887\n"
+ "Row #0: 7,841\n"
+ "Row #0: 13,278\n"
+ "Row #0: 2,168\n"
+ "Row #1: 3,399\n"
+ "Row #1: 6,797\n"
+ "Row #1: 2,199\n"
+ "Row #1: 4,099\n"
+ "Row #1: 10,404\n"
+ "Row #1: 1,496\n"
+ "Row #1: 9,619\n"
+ "Row #1: 945\n"
+ "Row #1: 6,372\n"
+ "Row #1: 6,047\n"
+ "Row #1: 2,131\n"
+ "Row #1: 13,644\n"
+ "Row #1: 873\n"
+ "Row #1: 19,079\n"
+ "Row #1: 817\n"
+ "Row #1: 15,609\n"
+ "Row #1: 3,425\n"
+ "Row #1: 2,566\n"
+ "Row #1: 473\n"
+ "Row #1: 892\n"
+ "Row #1: 8,443\n"
+ "Row #1: 13,760\n"
+ "Row #1: 2,126\n"
+ "Row #2: 6,838\n"
+ "Row #2: 13,573\n"
+ "Row #2: 4,186\n"
+ "Row #2: 7,870\n"
+ "Row #2: 20,245\n"
+ "Row #2: 3,317\n"
+ "Row #2: 19,026\n"
+ "Row #2: 1,812\n"
+ "Row #2: 12,885\n"
+ "Row #2: 12,037\n"
+ "Row #2: 4,132\n"
+ "Row #2: 26,655\n"
+ "Row #2: 1,714\n"
+ "Row #2: 37,792\n"
+ "Row #2: 1,764\n"
+ "Row #2: 30,545\n"
+ "Row #2: 6,884\n"
+ "Row #2: 5,262\n"
+ "Row #2: 841\n"
+ "Row #2: 1,779\n"
+ "Row #2: 16,284\n"
+ "Row #2: 27,038\n"
+ "Row #2: 4,294\n");
if (MondrianProperties.instance().DisableCaching.get()) {
return;
}
final TestContext testContext = getTestContext();
flushCache(testContext);
// Make sure MaxConstraint is high enough
int minConstraints = 3;
if (MondrianProperties.instance().MaxConstraints.get()
< minConstraints)
{
propSaver.set(
MondrianProperties.instance().MaxConstraints,
minConstraints);
}
// Execute a query, to bring data into the cache.
standardQuery(testContext);
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
final CacheControl cacheControl =
testContext.getConnection().getCacheControl(pw);
// Flush the cache. This time, flush is successful.
final CacheControl.CellRegion region =
createCellRegion(testContext, cacheControl);
cacheControl.flush(region);
pw.flush();
String tag = "output";
String expected = "${output}";
String actual = sw.toString();
assertCacheStateEquals(tag, expected, actual);
// Run query again, then inspect the contents of the cache.
standardQuery(testContext);
sw.getBuffer().setLength(0);
cacheControl.printCacheState(pw, region);
pw.flush();
assertCacheStateEquals("output2", "${output2}", sw.toString());
}
/**
* Creates a partial cell region, runs a query, then flushes the cache.
*/
public void testPartialFlush() {
if (MondrianProperties.instance().DisableCaching.get()) {
return;
}
final TestContext testContext = getTestContext();
flushCache(testContext);
// Execute a query.
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
final CacheControl cacheControl =
testContext.getConnection().getCacheControl(pw);
// Create a region ([Measures].[Unit Sales], [Time].[1997].[Q1])
final CacheControl.CellRegion region =
createCellRegion1997_Q1_UnitSales(testContext, cacheControl);
// Execute a query, to bring data into the cache.
standardQuery(testContext);
// This time, flush is successful.
// The segment on "year" is entirely flushed.
// The segment on "year", "quarter" has "Q1" masked out.
// The segment on "year", "quarter", "month" has "Q1" masked out.
cacheControl.flush(region);
pw.flush();
assertCacheStateEquals("output", "${output}", sw.toString());
// Flush the same region again. Should be the same result.
sw.getBuffer().setLength(0);
cacheControl.flush(region);
pw.flush();
assertCacheStateEquals("output2", "${output2}", sw.toString());
// Create the region ([Time].[1997])
final CacheControl.CellRegion region2 =
createCellRegion1997(testContext, cacheControl);
// Flush a different region. Everything is in 1997, so the entire cache
// is emptied.
sw.getBuffer().setLength(0);
cacheControl.flush(region2);
pw.flush();
assertCacheStateEquals("output3", "${output3}", sw.toString());
// Create the region ([Gender].[F], [Product].[Drink] :
// [Product].[Food])
final CacheControl.CellRegion region3 =
createCellRegionFemaleFoodDrink(testContext, cacheControl);
// Flush a different region.
sw.getBuffer().setLength(0);
cacheControl.flush(region3);
pw.flush();
assertCacheStateEquals("output4", "${output4}", sw.toString());
// Run query again, just to make sure.
standardQuery(testContext);
}
/**
* Creates a partial cell region over a range, runs a query, then flushes
* the cache.
*/
public void testPartialFlushRange() {
if (MondrianProperties.instance().DisableCaching.get()) {
return;
}
final TestContext testContext = getTestContext();
flushCache(testContext);
// Execute a query.
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
final CacheControl cacheControl =
testContext.getConnection().getCacheControl(pw);
// Create a region
// ([Measures].[Unit Sales],
// [Time].[1997].[Q2].[4] .. infinity)
final CacheControl.CellRegion region =
createCellRegionAprilOnwards(testContext, cacheControl);
// Execute a query, to bring data into the cache.
standardQuery(testContext);
// This time, flush is successful.
// The segment on "year" is entirely flushed.
// The segment on "year", "quarter" has "Q2", "Q3", "Q4" masked out.
// The segment on "year", "quarter", "month" has "Q3", "Q4" masked out,
// and "Q2" masked out if month > 6.
cacheControl.flush(region);
pw.flush();
assertCacheStateEquals("output", "${output}", sw.toString());
// Flush the same region again. Should be the same result.
sw.getBuffer().setLength(0);
cacheControl.flush(region);
pw.flush();
assertCacheStateEquals("output2", "${output2}", sw.toString());
// Run query again, then inspect the contents of the cache.
standardQuery(testContext);
sw.getBuffer().setLength(0);
cacheControl.printCacheState(pw, region);
pw.flush();
assertCacheStateEquals("output3", "${output3}", sw.toString());
}
/**
* Creates a cell region using a given {@link CacheControl}, and runs some
* sanity checks.
*
* @param testContext Test context
* @param cacheControl Cache control
*/
private CacheControl.CellRegion createCellRegion(
TestContext testContext,
CacheControl cacheControl)
{
// Flush a region of the cache.
final Connection connection = testContext.getConnection();
final Cube salesCube = connection.getSchema().lookupCube("Sales", true);
// Region consists of [Time].[1997].[Q1] and its children, and products
// [Beer] and [Dairy].
final SchemaReader schemaReader =
salesCube.getSchemaReader(null).withLocus();
final Member memberQ1 = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Time", "1997", "Q1"), true);
final Member memberBeer = schemaReader.getMemberByUniqueName(
Id.Segment.toList(
"Product", "Drink", "Alcoholic Beverages", "Beer and Wine",
"Beer"),
true);
final Member memberDairy = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Product", "Drink", "Dairy"), true);
final CacheControl.CellRegion regionTimeQ1 =
cacheControl.createMemberRegion(memberQ1, true);
assertEquals("Member([Time].[1997].[Q1])", regionTimeQ1.toString());
final CacheControl.CellRegion regionProductBeer =
cacheControl.createMemberRegion(memberBeer, false);
assertEquals(
"Member([Product].[Drink]."
+ "[Alcoholic Beverages].[Beer and Wine].[Beer])",
regionProductBeer.toString());
final CacheControl.CellRegion regionProductDairy =
cacheControl.createMemberRegion(memberDairy, true);
final CacheControl.CellRegion regionProductUnion =
cacheControl.createUnionRegion(
regionProductBeer,
regionProductDairy);
assertEquals(
"Union(Member([Product].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer]), Member([Product].[Drink].[Dairy]))",
regionProductUnion.toString());
final CacheControl.CellRegion regionProductXTime =
cacheControl.createCrossjoinRegion(
regionProductUnion, regionTimeQ1);
assertEquals(
"Crossjoin(Union(Member([Product].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer]), Member([Product].[Drink].[Dairy])), Member([Time].[1997].[Q1]))",
regionProductXTime.toString());
try {
cacheControl.flush(regionProductXTime);
fail("expceted error");
} catch (RuntimeException e) {
assertContains(
"Region of cells to be flushed must contain measures.",
e.getMessage());
}
final CacheControl.CellRegion measuresRegion =
cacheControl.createMeasuresRegion(salesCube);
return cacheControl.createCrossjoinRegion(
regionProductXTime,
measuresRegion);
}
/**
* Creates a cell region using a given {@link CacheControl}, containing
* only [Time].[1997].[Q1] * {Measures}.
*
* @param testContext Test context
* @param cacheControl Cache control
*/
private CacheControl.CellRegion createCellRegion1997_Q1_UnitSales(
TestContext testContext,
CacheControl cacheControl)
{
final Connection connection = testContext.getConnection();
final Cube salesCube = connection.getSchema().lookupCube("Sales", true);
// Region consists of [Time].[1997].[Q1] and its children.
final SchemaReader schemaReader =
salesCube.getSchemaReader(null).withLocus();
final Member memberQ1 = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Time", "1997", "Q1"), true);
final CacheControl.CellRegion regionTimeQ1 =
cacheControl.createMemberRegion(memberQ1, true);
assertEquals("Member([Time].[1997].[Q1])", regionTimeQ1.toString());
final CacheControl.CellRegion measuresRegion =
cacheControl.createMeasuresRegion(salesCube);
return cacheControl.createCrossjoinRegion(
regionTimeQ1,
measuresRegion);
}
/**
* Creates a cell region using a given {@link CacheControl}, containing
* only [Time].[1997].[Q1] * {Measures}.
*
* @param testContext Test context
* @param cacheControl Cache control
*/
private CacheControl.CellRegion createCellRegionAprilOnwards(
TestContext testContext,
CacheControl cacheControl)
{
final Connection connection = testContext.getConnection();
final Cube salesCube = connection.getSchema().lookupCube("Sales", true);
// Region consists of [Time].[1997].[Q2].[4] and its children.
final SchemaReader schemaReader =
salesCube.getSchemaReader(null).withLocus();
final Member memberApril = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Time", "1997", "Q2", "4"), true);
final CacheControl.CellRegion regionTimeApril =
cacheControl.createMemberRegion(
true, memberApril, false, null, true);
assertEquals(
"Range([Time].[1997].[Q2].[4] inclusive to null)",
regionTimeApril.toString());
final CacheControl.CellRegion measuresRegion =
cacheControl.createMeasuresRegion(salesCube);
return cacheControl.createCrossjoinRegion(
regionTimeApril,
measuresRegion);
}
/**
* Creates a cell region using a given {@link CacheControl}, containing
* only [Time].[1997] * {Measures}.
*
* @param testContext Test context
* @param cacheControl Cache control
*/
private CacheControl.CellRegion createCellRegion1997(
TestContext testContext,
CacheControl cacheControl)
{
final Connection connection = testContext.getConnection();
final Cube salesCube = connection.getSchema().lookupCube("Sales", true);
// Region consists of [Time].[1997] and its children.
final SchemaReader schemaReader = salesCube.getSchemaReader(null);
final Member member1997 = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Time", "1997"), true);
final CacheControl.CellRegion region1997 =
cacheControl.createMemberRegion(member1997, true);
assertEquals(
"Member([Time].[1997])",
region1997.toString());
final CacheControl.CellRegion measuresRegion =
cacheControl.createMeasuresRegion(salesCube);
return cacheControl.createCrossjoinRegion(
region1997,
measuresRegion);
}
/**
* Creates a cell region using a given {@link CacheControl}, containing
* only [Gender].[F] * {[Product].[Food], [Product].[Drink]} * {Measures}.
*
* @param testContext Test context
* @param cacheControl Cache control
*/
private CacheControl.CellRegion createCellRegionFemaleFoodDrink(
TestContext testContext,
CacheControl cacheControl)
{
final Connection connection = testContext.getConnection();
final Cube salesCube = connection.getSchema().lookupCube("Sales", true);
// Region consists of [Product].[Food], [Product].[Drink] and their
// children.
final SchemaReader schemaReader =
salesCube.getSchemaReader(null).withLocus();
final Member memberFood = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Product", "Food"), true);
final Member memberDrink = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Product", "Drink"), true);
final Member memberFemale = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Gender", "F"), true);
final CacheControl.CellRegion regionProductFoodDrink =
cacheControl.createMemberRegion(
true, memberDrink, true, memberFood, true);
assertEquals(
"Range([Product].[Drink] inclusive to [Product].[Food] inclusive)",
regionProductFoodDrink.toString());
final CacheControl.CellRegion regionFemale =
cacheControl.createMemberRegion(memberFemale, true);
final CacheControl.CellRegion measuresRegion =
cacheControl.createMeasuresRegion(salesCube);
return cacheControl.createCrossjoinRegion(
regionProductFoodDrink,
measuresRegion,
regionFemale);
}
/**
* Asserts that a given string contains a given pattern.
*
* @param pattern Pattern to find
* @param message String
* @throws junit.framework.AssertionFailedError if pattern is not found
*/
static void assertContains(String pattern, String message) {
assertTrue(message, message.indexOf(pattern) > -1);
}
/**
* A number of negative tests, trying to do invalid things with cache
* flushing and getting errors.
*/
public void testNegative() {
final TestContext testContext = getTestContext();
final Connection connection = testContext.getConnection();
final Cube salesCube = connection.getSchema().lookupCube("Sales", true);
final SchemaReader schemaReader = salesCube.getSchemaReader(null);
final CacheControl cacheControl =
new CacheControlImpl((RolapConnection) connection);
final Member memberQ1 =
schemaReader.withLocus().getMemberByUniqueName(
Id.Segment.toList("Time", "1997", "Q1"), true);
final Member memberBeer =
schemaReader.withLocus().getMemberByUniqueName(
Id.Segment.toList(
"Product", "Drink", "Alcoholic Beverages", "Beer and Wine"),
true);
final Member memberDairy =
schemaReader.withLocus().getMemberByUniqueName(
Id.Segment.toList("Product", "Drink", "Dairy"), true);
final CacheControl.CellRegion regionTimeQ1 =
cacheControl.createMemberRegion(memberQ1, false);
final CacheControl.CellRegion regionProductBeer =
cacheControl.createMemberRegion(memberBeer, false);
final CacheControl.CellRegion regionProductDairy =
cacheControl.createMemberRegion(memberDairy, true);
// Try to combine [Time] region with [Product] region.
// Cannot union regions with different dimensionality.
try {
final CacheControl.CellRegion cellRegion =
cacheControl.createUnionRegion(
regionTimeQ1,
regionProductBeer);
fail("expected exception, got " + cellRegion);
} catch (RuntimeException e) {
assertContains(
"Cannot union cell regions of different dimensionalities. "
+ "(Dimensionalities are '[[Time]]', '[[Product]]'.)",
e.getMessage());
}
final CacheControl.CellRegion regionTimeXProduct =
cacheControl.createCrossjoinRegion(
regionTimeQ1,
regionProductBeer);
assertNotNull(regionTimeXProduct);
assertEquals(2, regionTimeXProduct.getDimensionality().size());
assertEquals(
"Crossjoin(Member([Time].[1997].[Q1]), "
+ "Member([Product].[Drink].[Alcoholic Beverages]."
+ "[Beer and Wine]))",
regionTimeXProduct.toString());
// Try to combine ([Time], [Product]) region with ([Time]) region.
try {
final CacheControl.CellRegion cellRegion =
cacheControl.createUnionRegion(
regionTimeXProduct,
regionTimeQ1);
fail("expected exception, got " + cellRegion);
} catch (RuntimeException e) {
assertContains(
"Cannot union cell regions of different dimensionalities. "
+ "(Dimensionalities are '[[Time], [Product]]', '[[Time]]'.)",
e.getMessage());
}
// Try to combine ([Time], [Product]) region with ([Product]) region.
try {
final CacheControl.CellRegion cellRegion =
cacheControl.createUnionRegion(
regionTimeXProduct,
regionProductBeer);
fail("expected exception, got " + cellRegion);
} catch (RuntimeException e) {
assertContains(
"Cannot union cell regions of different dimensionalities. "
+ "(Dimensionalities are '[[Time], [Product]]', "
+ "'[[Product]]'.)",
e.getMessage());
}
// Try to combine ([Time]) region with ([Time], [Product]) region.
try {
final CacheControl.CellRegion cellRegion =
cacheControl.createUnionRegion(
regionTimeQ1,
regionTimeXProduct);
fail("expected exception, got " + cellRegion);
} catch (RuntimeException e) {
assertContains(
"Cannot union cell regions of different dimensionalities. "
+ "(Dimensionalities are '[[Time]]', '[[Time], [Product]]'.)",
e.getMessage());
}
// Union [Time] region with itself -- OK.
final CacheControl.CellRegion regionTimeUnionTime =
cacheControl.createUnionRegion(
regionTimeQ1,
regionTimeQ1);
assertNotNull(regionTimeUnionTime);
assertEquals(1, regionTimeUnionTime.getDimensionality().size());
// Union [Time] region with itself -- OK.
final CacheControl.CellRegion regionTimeXProductUnionTimeXProduct =
cacheControl.createUnionRegion(
regionTimeXProduct,
regionTimeXProduct);
assertNotNull(regionTimeXProductUnionTimeXProduct);
assertEquals(
2, regionTimeXProductUnionTimeXProduct.getDimensionality().size());
// Cartesian product two [Product] regions - not OK.
try {
final CacheControl.CellRegion cellRegion =
cacheControl.createCrossjoinRegion(
regionProductBeer,
regionProductDairy);
fail("expected exception, got " + cellRegion);
} catch (RuntimeException e) {
assertContains(
"Cannot crossjoin cell regions which have dimensions in common."
+ " (Dimensionalities are '[[Product]]', '[[Product]]'.)",
e.getMessage());
}
// Cartesian product [Product] and [Time] x [Product] regions - not OK.
try {
final CacheControl.CellRegion cellRegion =
cacheControl.createCrossjoinRegion(
regionProductBeer,
regionTimeXProduct);
fail("expected exception, got " + cellRegion);
} catch (RuntimeException e) {
assertContains(
"Cannot crossjoin cell regions which have dimensions in common."
+ " (Dimensionalities are "
+ "'[[Product]]', '[[Time], [Product]]'.)",
e.getMessage());
}
}
/**
* Tests crossjoin of regions, {@link CacheControl#createCrossjoinRegion}.
*/
public void testCrossjoin() {
final TestContext testContext = getTestContext();
final Connection connection = testContext.getConnection();
final Cube salesCube = connection.getSchema().lookupCube("Sales", true);
final CacheControl cacheControl =
new CacheControlImpl((RolapConnection) connection);
// Region consists of [Time].[1997].[Q1] and its children, and products
// [Beer] and [Dairy].
final SchemaReader schemaReader =
salesCube.getSchemaReader(null).withLocus();
final Member memberQ1 = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Time", "1997", "Q1"), true);
final Member memberBeer = schemaReader.getMemberByUniqueName(
Id.Segment.toList(
"Product", "Drink", "Alcoholic Beverages", "Beer and Wine",
"Beer"),
true);
final CacheControl.CellRegion regionProductBeer =
cacheControl.createMemberRegion(memberBeer, false);
final Member memberFemale = schemaReader.getMemberByUniqueName(
Id.Segment.toList("Gender", "F"), true);
final CacheControl.CellRegion regionGenderFemale =
cacheControl.createMemberRegion(memberFemale, false);
final CacheControl.CellRegion regionTimeQ1 =
cacheControl.createMemberRegion(memberQ1, true);
final CacheControl.CellRegion regionTimeXProduct =
cacheControl.createCrossjoinRegion(
regionTimeQ1,
regionProductBeer);
// Compose a crossjoin with a non crossjoin
final CacheControl.CellRegion regionTimeXProductXGender =
cacheControl.createCrossjoinRegion(
regionTimeXProduct,
regionGenderFemale);
assertEquals(
"Crossjoin("
+ "Member([Time].[1997].[Q1]), "
+ "Member([Product].[Drink].[Alcoholic Beverages]."
+ "[Beer and Wine].[Beer]), "
+ "Member([Gender].[F]))",
regionTimeXProductXGender.toString());
assertEquals(
"[[Time], [Product], [Gender]]",
regionTimeXProductXGender.getDimensionality().toString());
// Three-way crossjoin, should be same as previous
final CacheControl.CellRegion regionTimeXProductXGender2 =
cacheControl.createCrossjoinRegion(
regionTimeQ1,
regionProductBeer,
regionGenderFemale);
assertEquals(
"Crossjoin("
+ "Member([Time].[1997].[Q1]), "
+ "Member([Product].[Drink].[Alcoholic Beverages]"
+ ".[Beer and Wine].[Beer]), "
+ "Member([Gender].[F]))",
regionTimeXProductXGender2.toString());
assertEquals(
"[[Time], [Product], [Gender]]",
regionTimeXProductXGender2.getDimensionality().toString());
// Compose a non crossjoin with a crossjoin
final CacheControl.CellRegion regionGenderXTimeXProduct =
cacheControl.createCrossjoinRegion(
regionGenderFemale,
regionTimeXProduct);
assertEquals(
"Crossjoin("
+ "Member([Gender].[F]), "
+ "Member([Time].[1997].[Q1]), "
+ "Member([Product].[Drink].[Alcoholic Beverages]"
+ ".[Beer and Wine].[Beer]))",
regionGenderXTimeXProduct.toString());
assertEquals(
"[[Gender], [Time], [Product]]",
regionGenderXTimeXProduct.getDimensionality().toString());
}
/**
* Helper method, creates a region consisting of a single member, given its
* unique name (e.g. "[Gender].[F]").
*/
CacheControl.CellRegion memberRegion(String uniqueName) {
final String[] names = uniqueName.split("\\.");
final List ids = new ArrayList(names.length);
for (int i = 0; i < names.length; i++) {
String name = names[i];
assert name.startsWith("[") && name.endsWith("]");
names[i] = name.substring(1, name.length() - 1);
ids.add(new Id.Segment(names[i], Id.Quoting.QUOTED));
}
final TestContext testContext = getTestContext();
final Connection connection = testContext.getConnection();
final Cube salesCube = connection.getSchema().lookupCube("Sales", true);
final CacheControl cacheControl =
new CacheControlImpl((RolapConnection) connection);
final SchemaReader schemaReader =
salesCube.getSchemaReader(null).withLocus();
final Member member = schemaReader.getMemberByUniqueName(ids, true);
return cacheControl.createMemberRegion(member, false);
}
/**
* Tests the algorithm which converts a cache region specification into
* normal form.
*/
public void testNormalize() {
// Create
// Union(
// Crossjoin(
// [Marital Status].[S],
// Union(
// Crossjoin(
// [Gender].[F]
// [Time].[1997].[Q1])
// Crossjoin(
// [Gender].[M]
// [Time].[1997].[Q2]))
// Crossjoin(
// Crossjoin(
// [Marital Status].[S],
// [Gender].[F])
// [Time].[1997].[Q1])
//
final CacheControl cacheControl =
new CacheControlImpl(
(RolapConnection) getTestContext().getConnection());
final CacheControl.CellRegion region =
cacheControl.createUnionRegion(
cacheControl.createCrossjoinRegion(
memberRegion("[Marital Status].[S]"),
cacheControl.createUnionRegion(
cacheControl.createCrossjoinRegion(
memberRegion("[Gender].[F]"),
memberRegion("[Time].[1997].[Q1]")),
cacheControl.createCrossjoinRegion(
memberRegion("[Gender].[M]"),
memberRegion("[Time].[1997].[Q2]")))),
cacheControl.createCrossjoinRegion(
cacheControl.createCrossjoinRegion(
memberRegion("[Marital Status].[S]"),
memberRegion("[Gender].[F]")),
memberRegion("[Time].[1997].[Q1]")));
assertEquals(
"Union("
+ "Crossjoin("
+ "Member([Marital Status].[S]), "
+ "Union("
+ "Crossjoin("
+ "Member([Gender].[F]), "
+ "Member([Time].[1997].[Q1])), "
+ "Crossjoin(Member([Gender].[M]), "
+ "Member([Time].[1997].[Q2])))), "
+ "Crossjoin("
+ "Member([Marital Status].[S]), "
+ "Member([Gender].[F]), "
+ "Member([Time].[1997].[Q1])))",
region.toString());
final CacheControl.CellRegion normalizedRegion =
((CacheControlImpl) cacheControl).normalize(
(CacheControlImpl.CellRegionImpl) region);
assertEquals(
"Union("
+ "Crossjoin(Member([Marital Status].[S]), Member([Gender].[F]), Member([Time].[1997].[Q1])), "
+ "Crossjoin(Member([Marital Status].[S]), Member([Gender].[M]), Member([Time].[1997].[Q2])), "
+ "Crossjoin(Member([Marital Status].[S]), Member([Gender].[F]), Member([Time].[1997].[Q1])))",
normalizedRegion.toString());
}
/**
* Test case for bug
* MONDRIAN-1077,
* "Cache flush for region that is not necessarily populated results in
* NullPointerException".
*/
public void testFlushNonPrimedContent() throws Exception {
final TestContext testContext = getTestContext();
flushCache(testContext);
final CacheControl cacheControl =
testContext.getConnection().getCacheControl(null);
final Cube cube =
testContext.getConnection()
.getSchema().lookupCube("Sales", true);
Hierarchy hier =
cube.getDimensions()[2].getHierarchies()[0];
Member hierMember = hier.getAllMember();
CellRegion measuresRegion = cacheControl.createMeasuresRegion(cube);
CellRegion hierRegion =
cacheControl.createMemberRegion(hierMember, true);
CellRegion flushRegion =
cacheControl.createCrossjoinRegion(measuresRegion, hierRegion);
cacheControl.flush(flushRegion);
}
public void testMondrian1094() throws Exception {
final String query =
"select NON EMPTY {[Measures].[Unit Sales]} ON COLUMNS, \n"
+ "NON EMPTY {[Store].[All Stores].Children} ON ROWS \n"
+ "from [Sales] \n";
flushCache(getTestContext());
assertQueryReturns(
query,
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n"
+ "{[Store].[USA]}\n"
+ "Row #0: 266,773\n");
if (MondrianProperties.instance().DisableCaching.get()) {
return;
}
// Make sure MaxConstraint is high enough
int minConstraints = 3;
if (MondrianProperties.instance().MaxConstraints.get()
< minConstraints)
{
propSaver.set(
MondrianProperties.instance().MaxConstraints,
minConstraints);
}
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
final CacheControl cacheControl =
getConnection().getCacheControl(pw);
// Flush the cache.
final Cube salesCube =
getConnection().getSchema().lookupCube("Sales", true);
final Hierarchy storeHierarchy =
salesCube.lookupHierarchy(
new Id.Segment(
"Store",
Id.Quoting.UNQUOTED),
false);
final CacheControl.CellRegion measuresRegion =
cacheControl.createMeasuresRegion(salesCube);
final CacheControl.CellRegion hierarchyRegion =
cacheControl.createMemberRegion(
storeHierarchy.getAllMember(), true);
final CacheControl.CellRegion region =
cacheControl.createCrossjoinRegion(
measuresRegion, hierarchyRegion);
cacheControl.flush(region);
pw.flush();
String tag = "output";
String expected = "${output}";
String actual = sw.toString();
assertCacheStateEquals(tag, expected, actual);
}
// todo: Test flushing a segment which is unconstrained
// todo: Test flushing a segment where 2 or more axes are reduced. E.g.
// Given segment
// (state={CA, OR}, quarter={Q1, Q2, Q3}, year=1997)
// flush
// (state=OR, quarter=Q2)
// which leaves
// (state={CA, OR}, quarter={Q1, Q3}, year=1997)
// (state=CA, quarter=Q2, year=1997)
// For now, we kill the slice of the segment with the fewest values, which
// is
// (quarter=Q2)
// leaving
// (state={CA, OR}, quarter={Q1, Q3}, year=1997)
// todo: Test flushing values which are not present in a segment. Need to
// reduce the scope of the segment.
// todo: Solve the fragmentation problem. Continually ask for later and
// later times. Two cases: the segment's specification contains the time
// asked for (and therefore the segment will later need to be pared back),
// and it doesn't. Either way, end up with a lot of segments which could
// be merged. Solve by triggering a coalesce or flush, but what should
// trigger that?
// todo: test which tries to constraint on calc member. Should get error.
// todo: test which tries to constrain on member of parent-child hierarchy
}
// End CacheControlTest.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/NonEmptyPropertyForAllAxisTest.java 0000644 0001750 0001750 00000021203 11735330606 027531 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2006-2010 Pentaho and others
// Copyright (C) 2005-2006 Thomson Medstat, Inc, Ann Arbor, MI.
// All Rights Reserved.
*/
package mondrian.rolap;
import mondrian.olap.MondrianProperties;
import mondrian.olap.Query;
import mondrian.test.FoodMartTestCase;
import mondrian.test.TestContext;
/**
* Tests the {@link MondrianProperties#EnableNonEmptyOnAllAxis} property.
*/
public class NonEmptyPropertyForAllAxisTest extends FoodMartTestCase {
public void testNonEmptyForAllAxesWithPropertySet() {
propSaver.set(
MondrianProperties.instance().EnableNonEmptyOnAllAxis, true);
final String MDX_QUERY =
"select {[Country].[USA].[OR].Children} on 0,"
+ " {[Promotions].Members} on 1 "
+ "from [Sales] "
+ "where [Product].[All Products].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer].[Good].[Good Light Beer]";
final String EXPECTED_RESULT =
"Axis #0:\n"
+ "{[Product].[Drink].[Alcoholic Beverages].[Beer and Wine].[Beer].[Good].[Good Light Beer]}\n"
+ "Axis #1:\n"
+ "{[Customers].[USA].[OR].[Albany]}\n"
+ "{[Customers].[USA].[OR].[Corvallis]}\n"
+ "{[Customers].[USA].[OR].[Lake Oswego]}\n"
+ "{[Customers].[USA].[OR].[Lebanon]}\n"
+ "{[Customers].[USA].[OR].[Portland]}\n"
+ "{[Customers].[USA].[OR].[Woodburn]}\n"
+ "Axis #2:\n"
+ "{[Promotions].[All Promotions]}\n"
+ "{[Promotions].[Cash Register Lottery]}\n"
+ "{[Promotions].[No Promotion]}\n"
+ "{[Promotions].[Saving Days]}\n"
+ "Row #0: 4\n"
+ "Row #0: 6\n"
+ "Row #0: 5\n"
+ "Row #0: 10\n"
+ "Row #0: 6\n"
+ "Row #0: 3\n"
+ "Row #1: \n"
+ "Row #1: 2\n"
+ "Row #1: \n"
+ "Row #1: 2\n"
+ "Row #1: \n"
+ "Row #1: \n"
+ "Row #2: 4\n"
+ "Row #2: 4\n"
+ "Row #2: 3\n"
+ "Row #2: 8\n"
+ "Row #2: 6\n"
+ "Row #2: 3\n"
+ "Row #3: \n"
+ "Row #3: \n"
+ "Row #3: 2\n"
+ "Row #3: \n"
+ "Row #3: \n"
+ "Row #3: \n";
assertQueryReturns(MDX_QUERY, EXPECTED_RESULT);
}
public void testNonEmptyForAllAxesWithOutPropertySet() {
final String MDX_QUERY =
"SELECT {customers.USA.CA.[Santa Cruz].[Brian Merlo]} on 0, "
+ "[product].[product category].members on 1 FROM [sales]";
final String EXPECTED_RESULT =
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Customers].[USA].[CA].[Santa Cruz].[Brian Merlo]}\n"
+ "Axis #2:\n"
+ "{[Product].[Drink].[Alcoholic Beverages].[Beer and Wine]}\n"
+ "{[Product].[Drink].[Beverages].[Carbonated Beverages]}\n"
+ "{[Product].[Drink].[Beverages].[Drinks]}\n"
+ "{[Product].[Drink].[Beverages].[Hot Beverages]}\n"
+ "{[Product].[Drink].[Beverages].[Pure Juice Beverages]}\n"
+ "{[Product].[Drink].[Dairy].[Dairy]}\n"
+ "{[Product].[Food].[Baked Goods].[Bread]}\n"
+ "{[Product].[Food].[Baking Goods].[Baking Goods]}\n"
+ "{[Product].[Food].[Baking Goods].[Jams and Jellies]}\n"
+ "{[Product].[Food].[Breakfast Foods].[Breakfast Foods]}\n"
+ "{[Product].[Food].[Canned Foods].[Canned Anchovies]}\n"
+ "{[Product].[Food].[Canned Foods].[Canned Clams]}\n"
+ "{[Product].[Food].[Canned Foods].[Canned Oysters]}\n"
+ "{[Product].[Food].[Canned Foods].[Canned Sardines]}\n"
+ "{[Product].[Food].[Canned Foods].[Canned Shrimp]}\n"
+ "{[Product].[Food].[Canned Foods].[Canned Soup]}\n"
+ "{[Product].[Food].[Canned Foods].[Canned Tuna]}\n"
+ "{[Product].[Food].[Canned Foods].[Vegetables]}\n"
+ "{[Product].[Food].[Canned Products].[Fruit]}\n"
+ "{[Product].[Food].[Dairy].[Dairy]}\n"
+ "{[Product].[Food].[Deli].[Meat]}\n"
+ "{[Product].[Food].[Deli].[Side Dishes]}\n"
+ "{[Product].[Food].[Eggs].[Eggs]}\n"
+ "{[Product].[Food].[Frozen Foods].[Breakfast Foods]}\n"
+ "{[Product].[Food].[Frozen Foods].[Frozen Desserts]}\n"
+ "{[Product].[Food].[Frozen Foods].[Frozen Entrees]}\n"
+ "{[Product].[Food].[Frozen Foods].[Meat]}\n"
+ "{[Product].[Food].[Frozen Foods].[Pizza]}\n"
+ "{[Product].[Food].[Frozen Foods].[Vegetables]}\n"
+ "{[Product].[Food].[Meat].[Meat]}\n"
+ "{[Product].[Food].[Produce].[Fruit]}\n"
+ "{[Product].[Food].[Produce].[Packaged Vegetables]}\n"
+ "{[Product].[Food].[Produce].[Specialty]}\n"
+ "{[Product].[Food].[Produce].[Vegetables]}\n"
+ "{[Product].[Food].[Seafood].[Seafood]}\n"
+ "{[Product].[Food].[Snack Foods].[Snack Foods]}\n"
+ "{[Product].[Food].[Snacks].[Candy]}\n"
+ "{[Product].[Food].[Starchy Foods].[Starchy Foods]}\n"
+ "{[Product].[Non-Consumable].[Carousel].[Specialty]}\n"
+ "{[Product].[Non-Consumable].[Checkout].[Hardware]}\n"
+ "{[Product].[Non-Consumable].[Checkout].[Miscellaneous]}\n"
+ "{[Product].[Non-Consumable].[Health and Hygiene].[Bathroom Products]}\n"
+ "{[Product].[Non-Consumable].[Health and Hygiene].[Cold Remedies]}\n"
+ "{[Product].[Non-Consumable].[Health and Hygiene].[Decongestants]}\n"
+ "{[Product].[Non-Consumable].[Health and Hygiene].[Hygiene]}\n"
+ "{[Product].[Non-Consumable].[Health and Hygiene].[Pain Relievers]}\n"
+ "{[Product].[Non-Consumable].[Household].[Bathroom Products]}\n"
+ "{[Product].[Non-Consumable].[Household].[Candles]}\n"
+ "{[Product].[Non-Consumable].[Household].[Cleaning Supplies]}\n"
+ "{[Product].[Non-Consumable].[Household].[Electrical]}\n"
+ "{[Product].[Non-Consumable].[Household].[Hardware]}\n"
+ "{[Product].[Non-Consumable].[Household].[Kitchen Products]}\n"
+ "{[Product].[Non-Consumable].[Household].[Paper Products]}\n"
+ "{[Product].[Non-Consumable].[Household].[Plastic Products]}\n"
+ "{[Product].[Non-Consumable].[Periodicals].[Magazines]}\n"
+ "Row #0: 2\n"
+ "Row #1: 2\n"
+ "Row #2: \n"
+ "Row #3: \n"
+ "Row #4: \n"
+ "Row #5: \n"
+ "Row #6: \n"
+ "Row #7: \n"
+ "Row #8: \n"
+ "Row #9: \n"
+ "Row #10: \n"
+ "Row #11: \n"
+ "Row #12: \n"
+ "Row #13: \n"
+ "Row #14: \n"
+ "Row #15: \n"
+ "Row #16: \n"
+ "Row #17: \n"
+ "Row #18: \n"
+ "Row #19: \n"
+ "Row #20: \n"
+ "Row #21: \n"
+ "Row #22: 1\n"
+ "Row #23: \n"
+ "Row #24: \n"
+ "Row #25: \n"
+ "Row #26: \n"
+ "Row #27: \n"
+ "Row #28: 1\n"
+ "Row #29: \n"
+ "Row #30: \n"
+ "Row #31: \n"
+ "Row #32: \n"
+ "Row #33: \n"
+ "Row #34: \n"
+ "Row #35: \n"
+ "Row #36: \n"
+ "Row #37: \n"
+ "Row #38: \n"
+ "Row #39: \n"
+ "Row #40: \n"
+ "Row #41: \n"
+ "Row #42: \n"
+ "Row #43: \n"
+ "Row #44: \n"
+ "Row #45: \n"
+ "Row #46: \n"
+ "Row #47: \n"
+ "Row #48: \n"
+ "Row #49: \n"
+ "Row #50: 1\n"
+ "Row #51: \n"
+ "Row #52: \n"
+ "Row #53: \n"
+ "Row #54: 2\n";
assertQueryReturns(MDX_QUERY, EXPECTED_RESULT);
}
public void testSlicerAxisDoesNotGetNonEmptyApplied() {
propSaver.set(
MondrianProperties.instance().EnableNonEmptyOnAllAxis, true);
String mdxQuery = "select from [Sales]\n"
+ "where [Time].[1997]\n";
Query query = getConnection().parseQuery(mdxQuery);
TestContext.assertEqualsVerbose(mdxQuery, query.toString());
}
}
// End NonEmptyPropertyForAllAxisTest.java
mondrian-3.4.1/testsrc/main/mondrian/rolap/TestAggregationManager.java 0000644 0001750 0001750 00000272313 11735330606 026022 0 ustar drazzib drazzib /*
// This software is subject to the terms of the Eclipse Public License v1.0
// Agreement, available at the following URL:
// http://www.eclipse.org/legal/epl-v10.html.
// You must accept the terms of that agreement to use this software.
//
// Copyright (C) 2002-2005 Julian Hyde
// Copyright (C) 2005-2012 Pentaho and others
// All Rights Reserved.
//
// jhyde, 28 September, 2002
*/
package mondrian.rolap;
import mondrian.olap.*;
import mondrian.rolap.agg.*;
import mondrian.server.*;
import mondrian.spi.Dialect;
import mondrian.test.SqlPattern;
import mondrian.test.TestContext;
import org.olap4j.impl.Olap4jUtil;
import java.util.*;
/**
* Unit test for {@link AggregationManager}.
*
* @author jhyde
* @since 21 March, 2002
*/
public class TestAggregationManager extends BatchTestCase {
private static final Set ACCESS_MYSQL =
Olap4jUtil.enumSetOf(
Dialect.DatabaseProduct.ACCESS,
Dialect.DatabaseProduct.MYSQL);
private Locus locus;
private Execution execution;
private AggregationManager aggMgr;
@Override
protected void setUp() throws Exception {
super.setUp();
final Statement statement =
((RolapConnection) getTestContext().getConnection())
.getInternalStatement();
execution = new Execution(statement, 0);
aggMgr =
execution.getMondrianStatement()
.getMondrianConnection()
.getServer().getAggregationManager();
locus = new Locus(execution, "TestAggregationManager", null);
Locus.push(locus);
}
@Override
protected void tearDown() throws Exception {
Locus.pop(locus);
// allow gc
locus = null;
execution = null;
aggMgr = null;
super.tearDown();
}
public TestAggregationManager(String name) {
super(name);
}
public TestAggregationManager() {
super();
}
public void testFemaleUnitSales() {
final FastBatchingCellReader fbcr =
new FastBatchingCellReader(execution, getCube("Sales"), aggMgr);
CellRequest request = createRequest(
"Sales", "[Measures].[Unit Sales]", "customer", "gender", "F");
Object value = aggMgr.getCellFromCache(request);
assertNull(value); // before load, the cell is not found
fbcr.recordCellRequest(request);
fbcr.loadAggregations();
value = aggMgr.getCellFromCache(request); // after load, cell found
assertTrue(value instanceof Number);
assertEquals(131558, ((Number) value).intValue());
}
public void testFemaleCustomerCount() {
final FastBatchingCellReader fbcr =
new FastBatchingCellReader(execution, getCube("Sales"), aggMgr);
CellRequest request =
createRequest(
"Sales", "[Measures].[Customer Count]",
"customer", "gender", "F");
Object value = aggMgr.getCellFromCache(request);
assertNull(value); // before load, the cell is not found
fbcr.recordCellRequest(request);
fbcr.loadAggregations();
value = aggMgr.getCellFromCache(request); // after load, cell found
assertTrue(value instanceof Number);
assertEquals(2755, ((Number) value).intValue());
}
public void testFemaleCustomerCountWithConstraints() {
List Q1M1 = new ArrayList ();
Q1M1.add(new String[] {"1997", "Q1", "1"});
List Q2M5 = new ArrayList ();
Q2M5.add(new String[] {"1997", "Q2", "5"});
List Q1M1Q2M5 = new ArrayList ();
Q1M1Q2M5.add(new String[] {"1997", "Q1", "1"});
Q1M1Q2M5.add(new String[] {"1997", "Q2", "5"});
CellRequest request1 =
createRequest(
"Sales", "[Measures].[Customer Count]",
"customer", "gender", "F",
makeConstraintYearQuarterMonth(Q1M1));
CellRequest request2 =
createRequest(
"Sales", "[Measures].[Customer Count]",
"customer", "gender", "F",
makeConstraintYearQuarterMonth(Q2M5));
CellRequest request3 =
createRequest(
"Sales", "[Measures].[Customer Count]",
"customer", "gender", "F",
makeConstraintYearQuarterMonth(Q1M1Q2M5));
FastBatchingCellReader fbcr =
new FastBatchingCellReader(execution, getCube("Sales"), aggMgr);
Object value = aggMgr.getCellFromCache(request1);
assertNull(value); // before load, the cell is not found
fbcr.recordCellRequest(request1);
fbcr.recordCellRequest(request2);
fbcr.recordCellRequest(request3);
fbcr.loadAggregations();
value = aggMgr.getCellFromCache(request1); // after load, found
assertTrue(value instanceof Number);
assertEquals(694, ((Number) value).intValue());
value = aggMgr.getCellFromCache(request2); // after load, found
assertTrue(value instanceof Number);
assertEquals(672, ((Number) value).intValue());
value = aggMgr.getCellFromCache(request3); // after load, found
assertTrue(value instanceof Number);
assertEquals(1122, ((Number) value).intValue());
// Note: 1122 != (694 + 672)
}
/**
* Tests that a request for ([Measures].[Unit Sales], [Gender].[F])
* generates the correct SQL.
*/
public void testFemaleUnitSalesSql() {
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
CellRequest request = createRequest(
"Sales", "[Measures].[Unit Sales]", "customer", "gender", "F");
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select `agg_g_ms_pcat_sales_fact_1997`.`gender` as `c0`,"
+ " sum(`agg_g_ms_pcat_sales_fact_1997`.`unit_sales`) as `m0` "
+ "from `agg_g_ms_pcat_sales_fact_1997` as `agg_g_ms_pcat_sales_fact_1997` "
+ "where `agg_g_ms_pcat_sales_fact_1997`.`gender` = 'F' "
+ "group by `agg_g_ms_pcat_sales_fact_1997`.`gender`",
26)
};
assertRequestSql(new CellRequest[]{request}, patterns);
}
/**
* As {@link #testFemaleUnitSalesSql()}, but with aggregate tables switched
* on.
*
* TODO: Enable this test.
*/
private void _testFemaleUnitSalesSql_withAggs() {
CellRequest request = createRequest(
"Sales", "[Measures].[Unit Sales]", "customer", "gender", "F");
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select `customer`.`gender` as `c0`,"
+ " sum(`agg_l_03_sales_fact_1997`.`unit_sales`) as `m0` "
+ "from `customer` as `customer`,"
+ " `agg_l_03_sales_fact_1997` as `agg_l_03_sales_fact_1997` "
+ "where `agg_l_03_sales_fact_1997`.`customer_id` = `customer`.`customer_id` "
+ "and `customer`.`gender` = 'F' "
+ "group by `customer`.`gender`",
26)
};
assertRequestSql(new CellRequest[]{request}, patterns);
}
/**
* Test a batch containing multiple measures:
* (store_state=CA, gender=F, measure=[Unit Sales])
* (store_state=CA, gender=M, measure=[Store Sales])
* (store_state=OR, gender=M, measure=[Unit Sales])
*/
public void testMultipleMeasures() {
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
CellRequest[] requests = new CellRequest[] {
createRequest(
"Sales",
"[Measures].[Unit Sales]",
new String[] {"customer", "store"},
new String[] {"gender", "store_state"},
new String[] {"F", "CA"}),
createRequest(
"Sales", "[Measures].[Store Sales]",
new String[] {"customer", "store"},
new String[] {"gender", "store_state"},
new String[] {"M", "CA"}),
createRequest(
"Sales", "[Measures].[Unit Sales]",
new String[] {"customer", "store"},
new String[] {"gender", "store_state"},
new String[] {"F", "OR"})};
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select `store`.`store_state` as `c0`,"
+ " `customer`.`gender` as `c1`,"
+ " sum(`agg_l_05_sales_fact_1997`.`unit_sales`) as `m0`,"
+ " sum(`agg_l_05_sales_fact_1997`.`store_sales`) as `m1` "
+ "from `store` as `store`,"
+ " `agg_l_05_sales_fact_1997` as `agg_l_05_sales_fact_1997`,"
+ " `customer` as `customer` "
+ "where `agg_l_05_sales_fact_1997`.`store_id` = `store`.`store_id` "
+ "and `store`.`store_state` in ('CA', 'OR') "
+ "and `agg_l_05_sales_fact_1997`.`customer_id` = `customer`.`customer_id` "
+ "group by `store`.`store_state`, "
+ "`customer`.`gender`",
29)
};
assertRequestSql(requests, patterns);
}
/**
* As {@link #testMultipleMeasures()}, but with aggregate tables switched
* on.
*
* TODO: Enable this test.
*/
private void _testMultipleMeasures_withAgg() {
CellRequest[] requests = new CellRequest[] {
createRequest(
"Sales",
"[Measures].[Unit Sales]",
new String[] {"customer", "store"},
new String[] {"gender", "store_state"},
new String[] {"F", "CA"}),
createRequest(
"Sales",
"[Measures].[Store Sales]",
new String[] {"customer", "store"},
new String[] {"gender", "store_state"},
new String[] {"M", "CA"}),
createRequest(
"Sales",
"[Measures].[Unit Sales]",
new String[] {"customer", "store"},
new String[] {"gender", "store_state"},
new String[] {"F", "OR"})};
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select `customer`.`gender` as `c0`,"
+ " `store`.`store_state` as `c1`,"
+ " sum(`agg_l_05_sales_fact_1997`.`unit_sales`) as `m0`,"
+ " sum(`agg_l_05_sales_fact_1997`.`store_sales`) as `m1` "
+ "from `customer` as `customer`,"
+ " `agg_l_05_sales_fact_1997` as `agg_l_05_sales_fact_1997`,"
+ " `store` as `store` "
+ "where `agg_l_05_sales_fact_1997`.`customer_id` = `customer`.`customer_id`"
+ " and `agg_l_05_sales_fact_1997`.`store_id` = `store`.`store_id`"
+ " and `store`.`store_state` in ('CA', 'OR') "
+ "group by `customer`.`gender`, `store`.`store_state`",
26)
};
assertRequestSql(requests, patterns);
}
/**
*/
private CellRequest createMultipleMeasureCellRequest() {
String cube = "Sales";
String measure = "[Measures].[Unit Sales]";
String table = "store";
String column = "store_state";
String value = "CA";
final Connection connection =
TestContext.instance().getConnection();
final boolean fail = true;
Cube salesCube = connection.getSchema().lookupCube(cube, fail);
Member storeSqftMeasure =
salesCube.getSchemaReader(null).getMemberByUniqueName(
Util.parseIdentifier(measure), fail);
RolapStar.Measure starMeasure =
RolapStar.getStarMeasure(storeSqftMeasure);
CellRequest request = new CellRequest(starMeasure, false, false);
final RolapStar star = starMeasure.getStar();
final RolapStar.Column storeTypeColumn =
star.lookupColumn(table, column);
request.addConstrainedColumn(
storeTypeColumn,
new ValueColumnPredicate(storeTypeColumn, value));
return request;
}
// todo: test unrestricted column, (Unit Sales, Gender=*)
// todo: test one unrestricted, one restricted, (UNit Sales, Gender=*,
// State={CA, OR})
// todo: test with 2 dimension columns on the same table, e.g.
// (Unit Sales, Gender={F}, MaritalStatus={S}) and make sure that the
// table only appears once in the from clause.
/**
* Tests that if a level is marked 'unique members', then its parent
* is not constrained.
*/
public void testUniqueMembers() {
// [Store].[Store State] is unique, so we don't expect to see any
// references to country.
final String mdxQuery =
"select {[Measures].[Unit Sales]} on columns,"
+ " {[Store].[USA].[CA], [Store].[USA].[OR]} on rows "
+ "from [Sales]";
SqlPattern[] patterns;
String accessMysqlSql, derbySql;
/*
* Note: the following aggregate loading sqls contain no
* references to the parent level column "store_country".
*/
if (MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get())
{
accessMysqlSql =
"select `store`.`store_state` as `c0`,"
+ " `agg_c_14_sales_fact_1997`.`the_year` as `c1`,"
+ " sum(`agg_c_14_sales_fact_1997`.`unit_sales`) as `m0` "
+ "from `store` as `store`,"
+ " `agg_c_14_sales_fact_1997` as `agg_c_14_sales_fact_1997` "
+ "where `agg_c_14_sales_fact_1997`.`store_id` = `store`.`store_id`"
+ " and `store`.`store_state` in ('CA', 'OR')"
+ " and `agg_c_14_sales_fact_1997`.`the_year` = 1997 "
+ "group by `store`.`store_state`,"
+ " `agg_c_14_sales_fact_1997`.`the_year`";
derbySql =
"select "
+ "\"store\".\"store_state\" as \"c0\", \"agg_c_14_sales_fact_1997\".\"the_year\" as \"c1\", "
+ "sum(\"agg_c_14_sales_fact_1997\".\"unit_sales\") as \"m0\" "
+ "from "
+ "\"store\" as \"store\", \"agg_c_14_sales_fact_1997\" as \"agg_c_14_sales_fact_1997\" "
+ "where "
+ "\"agg_c_14_sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" and "
+ "\"store\".\"store_state\" in ('CA', 'OR') and "
+ "\"agg_c_14_sales_fact_1997\".\"the_year\" = 1997 "
+ "group by "
+ "\"store\".\"store_state\", \"agg_c_14_sales_fact_1997\".\"the_year\"";
patterns = new SqlPattern[] {
new SqlPattern(
ACCESS_MYSQL,
accessMysqlSql, 50),
new SqlPattern(
Dialect.DatabaseProduct.DERBY, derbySql, derbySql)
};
} else {
accessMysqlSql =
"select `store`.`store_state` as `c0`,"
+ " `time_by_day`.`the_year` as `c1`,"
+ " sum(`sales_fact_1997`.`unit_sales`) as `m0` from `store` as `store`,"
+ " `sales_fact_1997` as `sales_fact_1997`,"
+ " `time_by_day` as `time_by_day` "
+ "where `sales_fact_1997`.`store_id` = `store`.`store_id`"
+ " and `store`.`store_state` in ('CA', 'OR')"
+ " and `sales_fact_1997`.`time_id` = `time_by_day`.`time_id`"
+ " and `time_by_day`.`the_year` = 1997 "
+ "group by `store`.`store_state`, `time_by_day`.`the_year`";
derbySql =
"select \"store\".\"store_state\" as \"c0\", \"time_by_day\".\"the_year\" as \"c1\", "
+ "sum(\"sales_fact_1997\".\"unit_sales\") as \"m0\" "
+ "from "
+ "\"store\" as \"store\", \"sales_fact_1997\" as \"sales_fact_1997\", "
+ "\"time_by_day\" as \"time_by_day\" "
+ "where "
+ "\"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" and "
+ "\"store\".\"store_state\" in ('CA', 'OR') and "
+ "\"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and "
+ "\"time_by_day\".\"the_year\" = 1997 "
+ "group by "
+ "\"store\".\"store_state\", \"time_by_day\".\"the_year\"";
patterns = new SqlPattern[] {
new SqlPattern(
ACCESS_MYSQL,
accessMysqlSql, 50),
new SqlPattern(
Dialect.DatabaseProduct.DERBY, derbySql, derbySql)
};
}
assertQuerySql(mdxQuery, patterns);
}
/**
* Tests that a NonEmptyCrossJoin uses the measure referenced by the query
* (Store Sales) instead of the default measure (Unit Sales) in the case
* where the query only has one result axis. The setup here is necessarily
* elaborate because the original bug was quite arbitrary.
*/
public void testNonEmptyCrossJoinLoneAxis() {
// Not sure what this test is checking.
// For now, only run it for derby.
final Dialect dialect = getTestContext().getDialect();
if (dialect.getDatabaseProduct() != Dialect.DatabaseProduct.DERBY) {
return;
}
String mdxQuery =
"With "
+ "Set [*NATIVE_CJ_SET] as "
+ "'NonEmptyCrossJoin([*BASE_MEMBERS_Store],[*BASE_MEMBERS_Product])' "
+ "Set [*BASE_MEMBERS_Store] as '{[Store].[All Stores].[USA]}' "
+ "Set [*GENERATED_MEMBERS_Store] as "
+ "'Generate([*NATIVE_CJ_SET], {[Store].CurrentMember})' "
+ "Set [*BASE_MEMBERS_Product] as "
+ "'{[Product].[All Products].[Food],[Product].[All Products].[Drink]}' "
+ "Set [*GENERATED_MEMBERS_Product] as "
+ "'Generate([*NATIVE_CJ_SET], {[Product].CurrentMember})' "
+ "Member [Store].[*FILTER_MEMBER] as 'Aggregate ([*GENERATED_MEMBERS_Store])' "
+ "Member [Product].[*FILTER_MEMBER] as 'Aggregate ([*GENERATED_MEMBERS_Product])' "
+ "Select {[Measures].[Store Sales]} on columns "
+ "From [Sales] "
+ "Where ([Store].[*FILTER_MEMBER], [Product].[*FILTER_MEMBER])";
String derbySql =
"select "
+ "\"store\".\"store_country\" as \"c0\", "
+ "\"time_by_day\".\"the_year\" as \"c1\", "
+ "\"product_class\".\"product_family\" as \"c2\", "
+ "sum(\"sales_fact_1997\".\"unit_sales\") as \"m0\" "
+ "from "
+ "\"store\" as \"store\", "
+ "\"sales_fact_1997\" as \"sales_fact_1997\", "
+ "\"time_by_day\" as \"time_by_day\", "
+ "\"product_class\" as \"product_class\", "
+ "\"product\" as \"product\" "
+ "where "
+ "\"sales_fact_1997\".\"store_id\" = \"store\".\"store_id\" and "
+ "\"store\".\"store_country\" = 'USA' and "
+ "\"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and "
+ "\"time_by_day\".\"the_year\" = 1997 and "
+ "\"sales_fact_1997\".\"product_id\" = \"product\".\"product_id\" and "
+ "\"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" "
+ "group by "
+ "\"store\".\"store_country\", \"time_by_day\".\"the_year\", "
+ "\"product_class\".\"product_family\"";
SqlPattern[] patterns = {
new SqlPattern(Dialect.DatabaseProduct.DERBY, derbySql, derbySql)};
// For derby, the TestAggregationManager.testNonEmptyCrossJoinLoneAxis
// test fails if the non-empty crossjoin optimizer is used.
// With it on one gets a recursive call coming through the
// RolapEvaluator.getCachedResult.
assertNoQuerySql(mdxQuery, patterns);
}
/**
* If a hierarchy lives in the fact table, we should not generate a join.
*/
public void testHierarchyInFactTable() {
CellRequest request = createRequest(
"Store",
"[Measures].[Store Sqft]",
"store",
"store_type",
"Supermarket");
String accessMysqlSql =
"select `store`.`store_type` as `c0`,"
+ " sum(`store`.`store_sqft`) as `m0` "
+ "from `store` as `store` "
+ "where `store`.`store_type` = 'Supermarket' "
+ "group by `store`.`store_type`";
String derbySql =
"select "
+ "\"store\".\"store_type\" as \"c0\", "
+ "sum(\"store\".\"store_sqft\") as \"m0\" "
+ "from "
+ "\"store\" as \"store\" "
+ "where "
+ "\"store\".\"store_type\" = 'Supermarket' "
+ "group by \"store\".\"store_type\"";
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL, accessMysqlSql, 26),
new SqlPattern(Dialect.DatabaseProduct.DERBY, derbySql, derbySql)
};
assertRequestSql(new CellRequest[]{request}, patterns);
}
public void testCountDistinctAggMiss() {
CellRequest request = createRequest(
"Sales",
"[Measures].[Customer Count]",
new String[]{"time_by_day", "time_by_day"},
new String[]{"the_year", "quarter"},
new String[]{"1997", "Q1"});
String accessSql =
"select"
+ " `d0` as `c0`,"
+ " `d1` as `c1`,"
+ " count(`m0`) as `c2` "
+ "from ("
+ "select distinct `time_by_day`.`the_year` as `d0`, "
+ "`time_by_day`.`quarter` as `d1`, "
+ "`sales_fact_1997`.`customer_id` as `m0` "
+ "from "
+ "`time_by_day` as `time_by_day`, "
+ "`sales_fact_1997` as `sales_fact_1997` "
+ "where "
+ "`sales_fact_1997`.`time_id` = `time_by_day`.`time_id` and "
+ "`time_by_day`.`the_year` = 1997 and "
+ "`time_by_day`.`quarter` = 'Q1'"
+ ") as `dummyname` "
+ "group by `d0`, `d1`";
String mysqlSql =
"select"
+ " `time_by_day`.`the_year` as `c0`,"
+ " `time_by_day`.`quarter` as `c1`,"
+ " count(distinct `sales_fact_1997`.`customer_id`) as `m0` "
+ "from `time_by_day` as `time_by_day`,"
+ " `sales_fact_1997` as `sales_fact_1997` "
+ "where `sales_fact_1997`.`time_id` = `time_by_day`.`time_id`"
+ " and `time_by_day`.`the_year` = 1997"
+ " and `time_by_day`.`quarter` = 'Q1' "
+ "group by `time_by_day`.`the_year`,"
+ " `time_by_day`.`quarter`";
String derbySql =
"select "
+ "\"time_by_day\".\"the_year\" as \"c0\", "
+ "\"time_by_day\".\"quarter\" as \"c1\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from "
+ "\"time_by_day\" as \"time_by_day\", "
+ "\"sales_fact_1997\" as \"sales_fact_1997\" "
+ "where "
+ "\"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and "
+ "\"time_by_day\".\"the_year\" = 1997 and "
+ "\"time_by_day\".\"quarter\" = 'Q1' "
+ "group by \"time_by_day\".\"the_year\", \"time_by_day\".\"quarter\"";
SqlPattern[] patterns = {
new SqlPattern(Dialect.DatabaseProduct.ACCESS, accessSql, 26),
new SqlPattern(Dialect.DatabaseProduct.MYSQL, mysqlSql, 26),
new SqlPattern(Dialect.DatabaseProduct.DERBY, derbySql, derbySql)
};
assertRequestSql(new CellRequest[]{request}, patterns);
}
public void testCountDistinctAggMatch() {
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
CellRequest request = createRequest(
"Sales", "[Measures].[Customer Count]",
new String[] { "time_by_day", "time_by_day", "time_by_day" },
new String[] { "the_year", "quarter", "month_of_year" },
new String[] { "1997", "Q1", "1" });
String accessSql =
"select "
+ "`agg_c_10_sales_fact_1997`.`the_year` as `c0`, "
+ "`agg_c_10_sales_fact_1997`.`quarter` as `c1`, "
+ "`agg_c_10_sales_fact_1997`.`month_of_year` as `c2`, "
+ "`agg_c_10_sales_fact_1997`.`customer_count` as `m0` "
+ "from "
+ "`agg_c_10_sales_fact_1997` as `agg_c_10_sales_fact_1997` "
+ "where "
+ "`agg_c_10_sales_fact_1997`.`the_year` = 1997 and "
+ "`agg_c_10_sales_fact_1997`.`quarter` = 'Q1' and "
+ "`agg_c_10_sales_fact_1997`.`month_of_year` = 1";
SqlPattern[] patterns = {
new SqlPattern(Dialect.DatabaseProduct.ACCESS, accessSql, 26)};
assertRequestSql(new CellRequest[]{request}, patterns);
}
public void testCountDistinctCannotRollup() {
// Summary "agg_g_ms_pcat_sales_fact_1997" doesn't match,
// because we'd need to roll-up the distinct-count measure over
// "month_of_year".
CellRequest request = createRequest(
"Sales", "[Measures].[Customer Count]",
new String[] { "time_by_day", "time_by_day", "product_class" },
new String[] { "the_year", "quarter", "product_family" },
new String[] { "1997", "Q1", "Food" });
SqlPattern[] patterns = {
new SqlPattern(
Dialect.DatabaseProduct.MYSQL,
"select"
+ " `time_by_day`.`the_year` as `c0`,"
+ " `time_by_day`.`quarter` as `c1`,"
+ " `product_class`.`product_family` as `c2`,"
+ " count(distinct `sales_fact_1997`.`customer_id`) as `m0` "
+ "from `time_by_day` as `time_by_day`,"
+ " `sales_fact_1997` as `sales_fact_1997`,"
+ " `product_class` as `product_class`,"
+ " `product` as `product` "
+ "where `sales_fact_1997`.`time_id` = `time_by_day`.`time_id`"
+ " and `time_by_day`.`the_year` = 1997"
+ " and `time_by_day`.`quarter` = `Q1`"
+ " and `sales_fact_1997`.`product_id` = `product`.`product_id`"
+ " and `product`.`product_class_id` = `product_class`.`product_class_id`"
+ " and `product_class`.`product_family` = `Food` "
+ "group by `time_by_day`.`the_year`,"
+ " `time_by_day`.`quarter`,"
+ " `product_class`.`product_family`",
23),
new SqlPattern(
Dialect.DatabaseProduct.ACCESS,
"select"
+ " `d0` as `c0`,"
+ " `d1` as `c1`,"
+ " `d2` as `c2`,"
+ " count(`m0`) as `c3` "
+ "from ("
+ "select distinct `time_by_day`.`the_year` as `d0`,"
+ " `time_by_day`.`quarter` as `d1`,"
+ " `product_class`.`product_family` as `d2`,"
+ " `sales_fact_1997`.`customer_id` as `m0` "
+ "from `time_by_day` as `time_by_day`,"
+ " `sales_fact_1997` as `sales_fact_1997`,"
+ " `product_class` as `product_class`,"
+ " `product` as `product` "
+ "where `sales_fact_1997`.`time_id` = `time_by_day`.`time_id`"
+ " and `time_by_day`.`the_year` = 1997"
+ " and `time_by_day`.`quarter` = 'Q1'"
+ " and `sales_fact_1997`.`product_id` = `product`.`product_id`"
+ " and `product`.`product_class_id` = `product_class`.`product_class_id`"
+ " and `product_class`.`product_family` = 'Food') as `dummyname` "
+ "group by `d0`, `d1`, `d2`",
23),
new SqlPattern(
Dialect.DatabaseProduct.DERBY,
"select "
+ "\"time_by_day\".\"the_year\" as \"c0\", \"time_by_day\".\"quarter\" as \"c1\", "
+ "\"product_class\".\"product_family\" as \"c2\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from "
+ "\"time_by_day\" as \"time_by_day\", \"sales_fact_1997\" as \"sales_fact_1997\", "
+ "\"product_class\" as \"product_class\", \"product\" as \"product\" "
+ "where "
+ "\"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and "
+ "\"time_by_day\".\"the_year\" = 1997 and "
+ "\"time_by_day\".\"quarter\" = 'Q1' and "
+ "\"sales_fact_1997\".\"product_id\" = \"product\".\"product_id\" and "
+ "\"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" and "
+ "\"product_class\".\"product_family\" = 'Food' "
+ "group by \"time_by_day\".\"the_year\", \"time_by_day\".\"quarter\", "
+ "\"product_class\".\"product_family\"",
23)
};
assertRequestSql(new CellRequest[]{request}, patterns);
}
/**
* Now, here's a funny thing. Usually you can't roll up a distinct-count
* aggregate. But if you're rolling up along the dimension which the
* count is counting, it's OK. In this case, you know that every member
* can only belong to one group.
*/
public void testCountDistinctRollupAlongDim() {
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
// Request has granularity
// [Time].[Month]
// [Product].[Category]
//
// whereas agg table "agg_g_ms_pcat_sales_fact_1997" has
// granularity
//
// [Time].[Month]
// [Product].[Category]
// [Gender].[Gender]
// [Marital Status].[Marital Status]
//
// Because [Gender] and [Marital Status] come from the [Customer]
// table (the same as the distinct-count measure), we can roll up.
CellRequest request = createRequest(
"Sales", "[Measures].[Customer Count]",
new String[] {
"time_by_day", "time_by_day", "time_by_day",
"product_class", "product_class", "product_class" },
new String[] {
"the_year", "quarter", "month_of_year",
"product_family", "product_department", "product_category" },
new String[] { "1997", "Q1", "1", "Food", "Deli", "Meat" });
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select `agg_g_ms_pcat_sales_fact_1997`.`the_year` as `c0`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`quarter` as `c1`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`month_of_year` as `c2`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_family` as `c3`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_department` as `c4`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_category` as `c5`,"
+ " sum(`agg_g_ms_pcat_sales_fact_1997`.`customer_count`) as `m0` "
+ "from `agg_g_ms_pcat_sales_fact_1997` as `agg_g_ms_pcat_sales_fact_1997` "
+ "where `agg_g_ms_pcat_sales_fact_1997`.`the_year` = 1997"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`quarter` = 'Q1'"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`month_of_year` = 1"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`product_family` = 'Food'"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`product_department` = 'Deli'"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`product_category` = 'Meat' "
+ "group by `agg_g_ms_pcat_sales_fact_1997`.`the_year`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`quarter`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`month_of_year`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_family`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_department`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_category`",
58)
};
assertRequestSql(new CellRequest[]{request}, patterns);
}
/**
* As above, but we rollup [Marital Status] but not [Gender].
*/
public void testCountDistinctRollup2() {
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
CellRequest request = createRequest(
"Sales", "[Measures].[Customer Count]",
new String[] {
"time_by_day", "time_by_day", "time_by_day",
"product_class", "product_class", "product_class", "customer" },
new String[] {
"the_year", "quarter", "month_of_year", "product_family",
"product_department", "product_category", "gender" },
new String[] { "1997", "Q1", "1", "Food", "Deli", "Meat", "F" });
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select `agg_g_ms_pcat_sales_fact_1997`.`the_year` as `c0`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`quarter` as `c1`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`month_of_year` as `c2`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_family` as `c3`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_department` as `c4`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_category` as `c5`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`gender` as `c6`,"
+ " sum(`agg_g_ms_pcat_sales_fact_1997`.`customer_count`) as `m0` "
+ "from `agg_g_ms_pcat_sales_fact_1997` as `agg_g_ms_pcat_sales_fact_1997` "
+ "where `agg_g_ms_pcat_sales_fact_1997`.`the_year` = 1997"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`quarter` = 'Q1'"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`month_of_year` = 1"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`product_family` = 'Food'"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`product_department` = 'Deli'"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`product_category` = 'Meat'"
+ " and `agg_g_ms_pcat_sales_fact_1997`.`gender` = 'F' "
+ "group by `agg_g_ms_pcat_sales_fact_1997`.`the_year`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`quarter`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`month_of_year`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_family`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_department`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`product_category`,"
+ " `agg_g_ms_pcat_sales_fact_1997`.`gender`",
58)
};
assertRequestSql(new CellRequest[]{request}, patterns);
}
/*
* Test that cells with the same compound member constraints are
* loaded in one Sql statement.
*
* Cells [Food] and [Drink] have the same constraint:
*
* {[1997].[Q1].[1], [1997].[Q3].[7]}
*/
public void testCountDistinctBatchLoading() {
List compoundMembers = new ArrayList();
compoundMembers.add(new String[] {"1997", "Q1", "1"});
compoundMembers.add(new String[] {"1997", "Q3", "7"});
CellRequestConstraint aggConstraint =
makeConstraintYearQuarterMonth(compoundMembers);
CellRequest request1 = createRequest(
"Sales", "[Measures].[Customer Count]",
new String[] {"product_class"},
new String[] {"product_family"},
new String[] {"Food"},
aggConstraint);
CellRequest request2 = createRequest(
"Sales", "[Measures].[Customer Count]",
new String[] {"product_class"},
new String[] {"product_family"},
new String[] {"Drink"},
aggConstraint);
String mysqlSql =
"select `product_class`.`product_family` as `c0`, "
+ "count(distinct `sales_fact_1997`.`customer_id`) as `m0` "
+ "from `product_class` as `product_class`, `product` as `product`, "
+ "`sales_fact_1997` as `sales_fact_1997`, `time_by_day` as `time_by_day` "
+ "where `sales_fact_1997`.`product_id` = `product`.`product_id` and "
+ "`product`.`product_class_id` = `product_class`.`product_class_id` and "
+ "`sales_fact_1997`.`time_id` = `time_by_day`.`time_id` and "
+ "(((`time_by_day`.`the_year`, `time_by_day`.`quarter`, `time_by_day`.`month_of_year`) "
+ "in ((1997, 'Q1', 1), (1997, 'Q3', 7)))) "
+ "group by `product_class`.`product_family`";
String derbySql =
"select \"product_class\".\"product_family\" as \"c0\", "
+ "count(distinct \"sales_fact_1997\".\"customer_id\") as \"m0\" "
+ "from \"product_class\" as \"product_class\", \"product\" as \"product\", "
+ "\"sales_fact_1997\" as \"sales_fact_1997\", \"time_by_day\" as \"time_by_day\" "
+ "where \"sales_fact_1997\".\"product_id\" = \"product\".\"product_id\" and "
+ "\"product\".\"product_class_id\" = \"product_class\".\"product_class_id\" and "
+ "\"sales_fact_1997\".\"time_id\" = \"time_by_day\".\"time_id\" and "
+ "((\"time_by_day\".\"the_year\" = 1997 and \"time_by_day\".\"quarter\" = 'Q1' and \"time_by_day\".\"month_of_year\" = 1) or "
+ "(\"time_by_day\".\"the_year\" = 1997 and \"time_by_day\".\"quarter\" = 'Q3' and \"time_by_day\".\"month_of_year\" = 7)) "
+ "group by \"product_class\".\"product_family\"";
SqlPattern[] patterns = {
new SqlPattern(Dialect.DatabaseProduct.MYSQL, mysqlSql, mysqlSql),
new SqlPattern(Dialect.DatabaseProduct.DERBY, derbySql, derbySql)
};
assertRequestSql(new CellRequest[]{request1, request2}, patterns);
}
/**
* Tests that an aggregate table is used to speed up a
* <Member>.Children expression.
*/
public void testAggMembers() {
if (MondrianProperties.instance().TestExpDependencies.get() > 0) {
return;
}
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
if (!(MondrianProperties.instance().EnableNativeCrossJoin.get())) {
return;
}
SqlPattern[] patterns = {
new SqlPattern(
Dialect.DatabaseProduct.ACCESS,
"select `store`.`store_country` as `c0` "
+ "from `agg_c_14_sales_fact_1997` as `agg_c_14_sales_fact_1997`,"
+ " `store` as `store` "
+ "where `agg_c_14_sales_fact_1997`.`the_year` = 1998 "
+ "and `agg_c_14_sales_fact_1997`.`store_id` = `store`.`store_id` "
+ "group by `store`.`store_country` "
+ "order by Iif(`store`.`store_country` IS NULL, 1, 0),"
+ " `store`.`store_country` ASC",
26),
new SqlPattern(
Dialect.DatabaseProduct.MYSQL,
"select `store`.`store_country` as `c0` "
+ "from `agg_c_14_sales_fact_1997` as `agg_c_14_sales_fact_1997`,"
+ " `store` as `store` "
+ "where `agg_c_14_sales_fact_1997`.`the_year` = 1998 "
+ "and `agg_c_14_sales_fact_1997`.`store_id` = `store`.`store_id` "
+ "group by `store`.`store_country` "
+ "order by ISNULL(`store`.`store_country`) ASC, `store`.`store_country` ASC",
26)};
assertQuerySql(
"select NON EMPTY {[Customers].[USA]} ON COLUMNS,\n"
+ " NON EMPTY Crossjoin(Hierarchize(Union({[Store].[All Stores]},\n"
+ " [Store].[All Stores].Children)), {[Product].[All Products]}) \n"
+ " ON ROWS\n"
+ " from [Sales]\n"
+ " where ([Measures].[Unit Sales], [Time].[1998])",
patterns);
}
/**
* As {@link #testAggMembers()}, but asks for children of a leaf level.
* Rewrite using an aggregate table is not possible, so just check that it
* gets the right result.
*/
public void testAggChildMembersOfLeaf() {
assertQueryReturns(
"select NON EMPTY {[Time].[1997]} ON COLUMNS,\n"
+ " NON EMPTY Crossjoin(Hierarchize(Union({[Store].[All Stores]},\n"
+ " [Store].[USA].[CA].[San Francisco].[Store 14].Children)), {[Product].[All Products]}) \n"
+ " ON ROWS\n"
+ " from [Sales]\n"
+ " where [Measures].[Unit Sales]",
"Axis #0:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #1:\n"
+ "{[Time].[1997]}\n"
+ "Axis #2:\n"
+ "{[Store].[All Stores], [Product].[All Products]}\n"
+ "Row #0: 266,773\n");
}
/**
* This test case tests for a null pointer that was being thrown
* inside of CellRequest.
*/
public void testNoNullPtrInCellRequest() {
TestContext testContext = TestContext.instance().createSubstitutingCube(
"Sales",
"\n"
+ " "
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "");
testContext.assertQueryReturns(
"select {[Measures].[Unit Sales]} on columns, "
+ "Filter ({ "
+ "[Store2].[All Stores].[USA].[CA].[Beverly Hills], "
+ "[Store2].[All Stores].[USA].[CA].[Beverly Hills].[Gourmet Supermarket] "
+ "},[Measures].[Unit Sales] > 0) on rows "
+ "from [Sales] "
+ "where [Store Type].[Store Type].[Small Grocery]",
"Axis #0:\n"
+ "{[Store Type].[Small Grocery]}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n");
}
/**
* Test that once fetched, column cardinality can be shared between
* different queries using the same connection.
*
* Test also that expressions with only table alias difference do not
* share cardinality result.
*/
public void testColumnCadinalityCache() {
String query1 =
"select "
+ "NonEmptyCrossJoin("
+ "[Product].[Product Family].Members, "
+ "[Gender].[Gender].Members) on columns "
+ "from [Sales]";
String query2 =
"select "
+ "NonEmptyCrossJoin("
+ "[Store].[Store Country].Members, "
+ "[Product].[Product Family].Members) on columns "
+ "from [Warehouse]";
String cardinalitySqlDerby =
"select "
+ "count(distinct \"product_class\".\"product_family\") "
+ "from \"product_class\" as \"product_class\"";
String cardinalitySqlMySql =
"select "
+ "count(distinct `product_class`.`product_family`) as `c0` "
+ "from `product_class` as `product_class`";
SqlPattern[] patterns =
new SqlPattern[] {
new SqlPattern(
Dialect.DatabaseProduct.DERBY,
cardinalitySqlDerby,
cardinalitySqlDerby),
new SqlPattern(
Dialect.DatabaseProduct.MYSQL,
cardinalitySqlMySql,
cardinalitySqlMySql)
};
final TestContext context = getTestContext().withFreshConnection();
// This MDX gets the [Product].[Product Family] cardinality from the DB.
context.executeQuery(query1);
// This MDX should be able to reuse the cardinality for
// [Product].[Product Family]; and should not issue a SQL to fetch
// that from DB again.
assertQuerySqlOrNot(context, query2, patterns, true, false, false);
}
public void testKeyExpressionCardinalityCache() {
String storeDim1 =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "`store_country`\n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "store_country\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n";
String storeDim2 =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "\"store_country\"\n"
+ " \n"
+ " \n"
+ "`store_country`\n"
+ " \n"
+ " \n"
+ "store_country\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n";
String salesCube1 =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n";
String salesCube2 =
"\n"
+ " \n"
+ " \n"
+ " \n"
+ "\n";
String query =
"select {[Measures].[Unit Sales]} ON COLUMNS, {[Store1].members} ON ROWS FROM [Sales1]";
String query1 =
"select {[Measures].[Store Sales]} ON COLUMNS, {[Store1].members} ON ROWS FROM [Sales1]";
String query2 =
"select {[Measures].[Unit Sales]} ON COLUMNS, {[Store2].members} ON ROWS FROM [Sales2]";
String cardinalitySqlDerby1 =
"select count(distinct \"store_country\") from \"store\" as \"store\"";
String cardinalitySqlMySql1 =
"select count(distinct `store_country`) as `c0` from `store` as `store`";
String cardinalitySqlDerby2 =
"select count(distinct \"store_country\") from \"store_ragged\" as \"store_ragged\"";
String cardinalitySqlMySql2 =
"select count(distinct `store_country`) as `c0` from `store_ragged` as `store_ragged`";
SqlPattern[] patterns1 =
new SqlPattern[] {
new SqlPattern(
Dialect.DatabaseProduct.DERBY,
cardinalitySqlDerby1,
cardinalitySqlDerby1),
new SqlPattern(
Dialect.DatabaseProduct.MYSQL,
cardinalitySqlMySql1,
cardinalitySqlMySql1)
};
SqlPattern[] patterns2 =
new SqlPattern[] {
new SqlPattern(
Dialect.DatabaseProduct.DERBY,
cardinalitySqlDerby2,
cardinalitySqlDerby2),
new SqlPattern(
Dialect.DatabaseProduct.MYSQL,
cardinalitySqlMySql2,
cardinalitySqlMySql2)
};
TestContext testContext =
TestContext.instance().create(
storeDim1 + storeDim2,
salesCube1 + salesCube2,
null,
null,
null,
null);
// This query causes "store"."store_country" cardinality to be
// retrieved.
testContext.executeQuery(query);
// Query1 will find the "store"."store_country" cardinality in cache.
assertQuerySqlOrNot(testContext, query1, patterns1, true, false, false);
// Query2 again will not find the "store_ragged"."store_country"
// cardinality in cache.
assertQuerySqlOrNot(
testContext, query2, patterns2, false, false, false);
}
/*
* Test that using compound member constrant disables using AggregateTable
*/
public void testCountDistinctWithConstraintAggMiss() {
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
// Request has granularity
// [Product].[Category]
// and the compound constraint on
// [Time].[Quarter]
//
// whereas agg table "agg_g_ms_pcat_sales_fact_1997" has
// granularity
//
// [Time].[Quarter]
// [Product].[Category]
// [Gender].[Gender]
// [Marital Status].[Marital Status]
//
// The presence of compound constraint causes agg table not used.
//
// Note ideally we should also test that non distinct measures could be
// loaded from Aggregate table; however, the testing framework here uses
// CellRequest directly which causes any compound constraint to be kept
// separately. This will cause Aggregate tables not to be used.
//
// CellRequest generated by the code form MDX will in this case not
// separate out the compound constraint from the "regular" constraints
// and Aggregate tables can still be used.
List compoundMembers = new ArrayList ();
compoundMembers.add(new String[] {"1997", "Q1", "1"});
CellRequest request = createRequest(
"Sales", "[Measures].[Customer Count]",
new String[] { "product_class", "product_class", "product_class" },
new String[] {
"product_family", "product_department", "product_category" },
new String[] { "Food", "Deli", "Meat" },
makeConstraintYearQuarterMonth(compoundMembers));
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select "
+ "`product_class`.`product_family` as `c0`, "
+ "`product_class`.`product_department` as `c1`, "
+ "`product_class`.`product_category` as `c2`, "
+ "count(distinct `sales_fact_1997`.`customer_id`) as `m0` "
+ "from "
+ "`product_class` as `product_class`, `product` as `product`, "
+ "`sales_fact_1997` as `sales_fact_1997`, `time_by_day` as `time_by_day` "
+ "where "
+ "`sales_fact_1997`.`product_id` = `product`.`product_id` and "
+ "`product`.`product_class_id` = `product_class`.`product_class_id` and "
+ "`product_class`.`product_family` = 'Food' and "
+ "`product_class`.`product_department` = 'Deli' and "
+ "`product_class`.`product_category` = 'Meat' and "
+ "`sales_fact_1997`.`time_id` = `time_by_day`.`time_id` and "
+ "(`time_by_day`.`the_year` = 1997 and `time_by_day`.`quarter` = 'Q1' and "
+ "`time_by_day`.`month_of_year` = 1) "
+ "group by "
+ "`product_class`.`product_family`, `product_class`.`product_department`, "
+ "`product_class`.`product_category`",
58)
};
assertRequestSql(new CellRequest[]{request}, patterns);
}
public void testOrdinalExprAggTuplesAndChildren() {
// this verifies that we can load properties, ordinals, etc out of
// agg tables in member lookups (tuples and children)
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
if (!(MondrianProperties.instance().EnableNativeCrossJoin.get())) {
return;
}
TestContext.instance().flushSchemaCache();
String cube = "\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " "
+ " \n"
+ " \n"
+ "";
TestContext testContext =
TestContext.instance().create(
null,
cube,
null,
null,
null,
null);
String query =
"select {[Measures].[Unit Sales]} on columns, "
+ "non empty CrossJoin({[Product].[Food].[Deli].[Meat]},{[Gender].[M]}) on rows "
+ "from [Sales_Prod_Ord] ";
// first check that the sql is generated correctly
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select `agg_g_ms_pcat_sales_fact_1997`.`product_family` as `c0`, `agg_g_ms_pcat_sales_fact_1997`.`product_department` as `c1`, `product_class`.`product_category` as `c2`, `product_class`.`product_family` as `c3`, `agg_g_ms_pcat_sales_fact_1997`.`gender` as `c4` from `agg_g_ms_pcat_sales_fact_1997` as `agg_g_ms_pcat_sales_fact_1997`, `product_class` as `product_class` where `product_class`.`product_category` = `agg_g_ms_pcat_sales_fact_1997`.`product_category` and (`agg_g_ms_pcat_sales_fact_1997`.`product_category` = 'Meat' and `agg_g_ms_pcat_sales_fact_1997`.`product_department` = 'Deli' and `agg_g_ms_pcat_sales_fact_1997`.`product_family` = 'Food') and (`agg_g_ms_pcat_sales_fact_1997`.`gender` = 'M') group by `agg_g_ms_pcat_sales_fact_1997`.`product_family`, `agg_g_ms_pcat_sales_fact_1997`.`product_department`, `product_class`.`product_category`, `product_class`.`product_family`, `agg_g_ms_pcat_sales_fact_1997`.`gender` order by ISNULL(`agg_g_ms_pcat_sales_fact_1997`.`product_family`) ASC, `agg_g_ms_pcat_sales_fact_1997`.`product_family` ASC, ISNULL(`agg_g_ms_pcat_sales_fact_1997`.`product_department`) ASC, `agg_g_ms_pcat_sales_fact_1997`.`product_department` ASC, ISNULL(`product_class`.`product_category`) ASC, `product_class`.`product_category` ASC, ISNULL(`agg_g_ms_pcat_sales_fact_1997`.`gender`) ASC, `agg_g_ms_pcat_sales_fact_1997`.`gender` ASC",
null)
};
assertQuerySqlOrNot(
testContext, query, patterns, false, false, false);
testContext.assertQueryReturns(
query,
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n"
+ "{[Product].[Food].[Deli].[Meat], [Gender].[M]}\n"
+ "Row #0: 4,705\n");
Result result = testContext.executeQuery(query);
// this verifies that the caption for meat is Food
assertEquals(
"Meat",
result.getAxes()[1].getPositions().get(0).get(0).getName());
assertEquals(
"Food",
result.getAxes()[1].getPositions().get(0).get(0).getCaption());
// Test children
query =
"select {[Measures].[Unit Sales]} on columns, "
+ "non empty [Product].[Food].[Deli].Children on rows "
+ "from [Sales_Prod_Ord] ";
testContext.assertQueryReturns(
query,
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n"
+ "{[Product].[Food].[Deli].[Meat]}\n"
+ "{[Product].[Food].[Deli].[Side Dishes]}\n"
+ "Row #0: 4,728\n"
+ "Row #1: 1,262\n");
}
public void testAggregatingTuples() {
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
if (!(MondrianProperties.instance().EnableNativeCrossJoin.get())) {
return;
}
// flush cache, to be sure sql is executed
TestContext.instance().flushSchemaCache();
// This first query verifies that simple collapsed levels in aggregate
// tables load as tuples correctly. The collapsed levels appear
// in the aggregate table SQL below.
// also note that at the time of this writing, this exercising the high
// cardinality tuple reader
String query =
"select {[Measures].[Unit Sales]} on columns, "
+ "non empty CrossJoin({[Gender].[M]},{[Marital Status].[M]}) on rows "
+ "from [Sales] ";
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select "
+ "`agg_g_ms_pcat_sales_fact_1997`.`gender` as `c0`, "
+ "`agg_g_ms_pcat_sales_fact_1997`.`marital_status` as `c1` "
+ "from "
+ "`agg_g_ms_pcat_sales_fact_1997` as `agg_g_ms_pcat_sales_fact_1997` "
+ "where "
+ "(`agg_g_ms_pcat_sales_fact_1997`.`gender` = 'M') "
+ "and (`agg_g_ms_pcat_sales_fact_1997`.`marital_status` = 'M') "
+ "group by "
+ "`agg_g_ms_pcat_sales_fact_1997`.`gender`, "
+ "`agg_g_ms_pcat_sales_fact_1997`.`marital_status` "
+ "order by "
+ "ISNULL(`agg_g_ms_pcat_sales_fact_1997`.`gender`) ASC, "
+ "`agg_g_ms_pcat_sales_fact_1997`.`gender` ASC, "
+ "ISNULL(`agg_g_ms_pcat_sales_fact_1997`.`marital_status`) ASC, "
+ "`agg_g_ms_pcat_sales_fact_1997`.`marital_status` ASC",
null)
};
assertQuerySqlOrNot(
getTestContext(), query, patterns, false, false, false);
assertQueryReturns(
query,
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n"
+ "{[Gender].[M], [Marital Status].[M]}\n"
+ "Row #0: 66,460\n");
// This second query verifies that joined levels on aggregate tables
// load correctly.
String query2 =
"select {[Measures].[Unit Sales]} ON COLUMNS, "
+ "NON EMPTY {[Store].[Store State].Members} ON ROWS "
+ "from [Sales] where [Time].[1997].[Q1]";
SqlPattern[] patterns2 = {
new SqlPattern(
ACCESS_MYSQL,
"select "
+ "`store`.`store_country` as `c0`, "
+ "`store`.`store_state` as `c1` "
+ "from "
+ "`store` as `store`, "
+ "`agg_c_14_sales_fact_1997` as `agg_c_14_sales_fact_1997` "
+ "where "
+ "`agg_c_14_sales_fact_1997`.`store_id` = `store`.`store_id` and "
+ "`agg_c_14_sales_fact_1997`.`the_year` = 1997 and "
+ "`agg_c_14_sales_fact_1997`.`quarter` = 'Q1' "
+ "group by "
+ "`store`.`store_country`, `store`.`store_state` "
+ "order by "
+ "ISNULL(`store`.`store_country`) ASC, "
+ "`store`.`store_country` ASC, "
+ "ISNULL(`store`.`store_state`) ASC, "
+ "`store`.`store_state` ASC",
null)
};
assertQuerySqlOrNot(
getTestContext(), query2, patterns2, false, false, false);
assertQueryReturns(
query2,
"Axis #0:\n"
+ "{[Time].[1997].[Q1]}\n"
+ "Axis #1:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #2:\n"
+ "{[Store].[USA].[CA]}\n"
+ "{[Store].[USA].[OR]}\n"
+ "{[Store].[USA].[WA]}\n"
+ "Row #0: 16,890\n"
+ "Row #1: 19,287\n"
+ "Row #2: 30,114\n");
}
/**
* this test verifies the collapsed children code in SqlMemberSource
*/
public void testCollapsedChildren() {
if (!(MondrianProperties.instance().UseAggregates.get()
&& MondrianProperties.instance().ReadAggregates.get()))
{
return;
}
if (!(MondrianProperties.instance().EnableNativeCrossJoin.get())) {
return;
}
// flush cache to be sure sql is executed
TestContext.instance().flushSchemaCache();
SqlPattern[] patterns = {
new SqlPattern(
ACCESS_MYSQL,
"select "
+ "`agg_g_ms_pcat_sales_fact_1997`.`gender` as `c0` "
+ "from `agg_g_ms_pcat_sales_fact_1997` "
+ "as `agg_g_ms_pcat_sales_fact_1997` "
+ "group by "
+ "`agg_g_ms_pcat_sales_fact_1997`.`gender`"
+ " order by ISNULL(`agg_g_ms_pcat_sales_fact_1997`.`gender`) ASC, `agg_g_ms_pcat_sales_fact_1997`.`gender` ASC",
null)
};
String query =
"select non empty [Gender].Children on columns\n"
+ "from [Sales]";
assertQuerySqlOrNot(
getTestContext(), query, patterns, false, false, false);
assertQueryReturns(
query,
"Axis #0:\n"
+ "{}\n"
+ "Axis #1:\n"
+ "{[Gender].[F]}\n"
+ "{[Gender].[M]}\n"
+ "Row #0: 131,558\n"
+ "Row #0: 135,215\n");
}
/**
* Testcase for
* bug MONDRIAN-812. Using a key expression for a level
* element would make aggregate tables fail to be used.
*/
public void testLevelKeyAsSqlExpWithAgg() {
propSaver.set(MondrianProperties.instance().UseAggregates, true);
propSaver.set(MondrianProperties.instance().ReadAggregates, true);
final String mdxQuery =
"select non empty{[Promotions].[All Promotions].Children} ON rows, "
+ "non empty {[Store].[All Stores]} ON columns "
+ "from [Sales] "
+ "where {[Measures].[Unit Sales]}";
// Provoke an error in the key resolution to prove it uses it.
final String colName =
TestContext.instance().getDialect()
.quoteIdentifier("promotion_name");
TestContext testContext = TestContext.instance().createSubstitutingCube(
"Sales",
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " ERROR_TEST_FUNCTION_NAME("
+ colName + ")\n"
+ " \n"
+ " \n"
+ "");
testContext.assertQueryThrows(
mdxQuery,
"ERROR_TEST_FUNCTION_NAME");
// Run for real this time
testContext = TestContext.instance().createSubstitutingCube(
"Sales",
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " RTRIM("
+ colName + ")\n"
+ " \n"
+ " \n"
+ "");
testContext.assertQueryReturns(
"select non empty{[Promotions].[All Promotions].Children} ON rows, "
+ "non empty {[Store].[All Stores]} ON columns "
+ "from [Sales] "
+ "where {[Measures].[Unit Sales]}",
"Axis #0:\n"
+ "{[Measures].[Unit Sales]}\n"
+ "Axis #1:\n"
+ "{[Store].[All Stores]}\n"
+ "Axis #2:\n"
+ "{[Promotions].[Bag Stuffers]}\n"
+ "{[Promotions].[Best Savings]}\n"
+ "{[Promotions].[Big Promo]}\n"
+ "{[Promotions].[Big Time Discounts]}\n"
+ "{[Promotions].[Big Time Savings]}\n"
+ "{[Promotions].[Bye Bye Baby]}\n"
+ "{[Promotions].[Cash Register Lottery]}\n"
+ "{[Promotions].[Dimes Off]}\n"
+ "{[Promotions].[Dollar Cutters]}\n"
+ "{[Promotions].[Dollar Days]}\n"
+ "{[Promotions].[Double Down Sale]}\n"
+ "{[Promotions].[Double Your Savings]}\n"
+ "{[Promotions].[Free For All]}\n"
+ "{[Promotions].[Go For It]}\n"
+ "{[Promotions].[Green Light Days]}\n"
+ "{[Promotions].[Green Light Special]}\n"
+ "{[Promotions].[High Roller Savings]}\n"
+ "{[Promotions].[I Cant Believe It Sale]}\n"
+ "{[Promotions].[Money Savers]}\n"
+ "{[Promotions].[Mystery Sale]}\n"
+ "{[Promotions].[No Promotion]}\n"
+ "{[Promotions].[One Day Sale]}\n"
+ "{[Promotions].[Pick Your Savings]}\n"
+ "{[Promotions].[Price Cutters]}\n"
+ "{[Promotions].[Price Destroyers]}\n"
+ "{[Promotions].[Price Savers]}\n"
+ "{[Promotions].[Price Slashers]}\n"
+ "{[Promotions].[Price Smashers]}\n"
+ "{[Promotions].[Price Winners]}\n"
+ "{[Promotions].[Sale Winners]}\n"
+ "{[Promotions].[Sales Days]}\n"
+ "{[Promotions].[Sales Galore]}\n"
+ "{[Promotions].[Save-It Sale]}\n"
+ "{[Promotions].[Saving Days]}\n"
+ "{[Promotions].[Savings Galore]}\n"
+ "{[Promotions].[Shelf Clearing Days]}\n"
+ "{[Promotions].[Shelf Emptiers]}\n"
+ "{[Promotions].[Super Duper Savers]}\n"
+ "{[Promotions].[Super Savers]}\n"
+ "{[Promotions].[Super Wallet Savers]}\n"
+ "{[Promotions].[Three for One]}\n"
+ "{[Promotions].[Tip Top Savings]}\n"
+ "{[Promotions].[Two Day Sale]}\n"
+ "{[Promotions].[Two for One]}\n"
+ "{[Promotions].[Unbeatable Price Savers]}\n"
+ "{[Promotions].[Wallet Savers]}\n"
+ "{[Promotions].[Weekend Markdown]}\n"
+ "{[Promotions].[You Save Days]}\n"
+ "Row #0: 901\n"
+ "Row #1: 2,081\n"
+ "Row #2: 1,789\n"
+ "Row #3: 932\n"
+ "Row #4: 700\n"
+ "Row #5: 921\n"
+ "Row #6: 4,792\n"
+ "Row #7: 1,219\n"
+ "Row #8: 781\n"
+ "Row #9: 1,652\n"
+ "Row #10: 1,959\n"
+ "Row #11: 843\n"
+ "Row #12: 1,638\n"
+ "Row #13: 689\n"
+ "Row #14: 1,607\n"
+ "Row #15: 436\n"
+ "Row #16: 2,654\n"
+ "Row #17: 253\n"
+ "Row #18: 899\n"
+ "Row #19: 1,021\n"
+ "Row #20: 195,448\n"
+ "Row #21: 1,973\n"
+ "Row #22: 323\n"
+ "Row #23: 1,624\n"
+ "Row #24: 2,173\n"
+ "Row #25: 4,094\n"
+ "Row #26: 1,148\n"
+ "Row #27: 504\n"
+ "Row #28: 1,294\n"
+ "Row #29: 444\n"
+ "Row #30: 2,055\n"
+ "Row #31: 2,572\n"
+ "Row #32: 2,203\n"
+ "Row #33: 1,446\n"
+ "Row #34: 1,382\n"
+ "Row #35: 754\n"
+ "Row #36: 2,118\n"
+ "Row #37: 2,628\n"
+ "Row #38: 2,497\n"
+ "Row #39: 1,183\n"
+ "Row #40: 1,155\n"
+ "Row #41: 525\n"
+ "Row #42: 2,053\n"
+ "Row #43: 335\n"
+ "Row #44: 2,100\n"
+ "Row #45: 916\n"
+ "Row #46: 914\n"
+ "Row #47: 3,145\n");
}
/**
* This is a test for MONDRIAN-918 and MONDRIAN-903. We have added
* an attribute to AggName called approxRowCount so that the
* aggregation manager can optimize the aggregation tables without
* having to issue a select count() query.
*/
public void testAggNameApproxRowCount() {
propSaver.set(MondrianProperties.instance().UseAggregates, true);
propSaver.set(MondrianProperties.instance().ReadAggregates, true);
final TestContext context =
TestContext.instance().withSchema(
"\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "
\n"
+ "\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n"
+ "\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "`customer`.`fullname`\n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "fname + ' ' + lname\n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "CONCAT(`customer`.`fname`, ' ', `customer`.`lname`)\n"
+ " \n"
+ " \n"
+ "fname + ' ' + lname\n"
+ " \n"
+ " \n"
+ "\"customer\".\"fullname\"\n"
+ " \n"
+ " \n"
+ "CONCAT(CONCAT(\"customer\".\"fname\", ' '), \"customer\".\"lname\")\n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "\"customer\".\"fullname\"\n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "fullname\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "fname + ' ' + lname\n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "CONCAT(`customer`.`fname`, ' ', `customer`.`lname`)\n"
+ " \n"
+ " \n"
+ "fname + ' ' + lname\n"
+ " \n"
+ " \n"
+ "\"customer\".\"fullname\"\n"
+ " \n"
+ " \n"
+ "\"customer\".\"fullname\"\n"
+ " \n"
+ " \n"
+ "CONCAT(CONCAT(\"customer\".\"fname\", ' '), \"customer\".\"lname\")\n"
+ " \n"
+ " \n"
+ "\"fname\" || ' ' || \"lname\"\n"
+ " \n"
+ " \n"
+ "fullname\n"
+ " \n"
+ " \n"
+ " \n"
+ " \n"
+ "