DruidAdapterIT (Calcite 1.16.0 Test API)

java.lang.Object
- org.apache.calcite.test.DruidAdapterIT

```
public class DruidAdapterIT
extends Object
```
Tests for the org.apache.calcite.adapter.druid package.
Before calling this test, you need to populate Druid, as follows:
git clone https://github.com/vlsi/calcite-test-dataset cd calcite-test-dataset mvn install

This will create a virtual machine with Druid and test data set.
Features not yet implemented:
- push LIMIT into "select" query
- push SORT and/or LIMIT into "groupBy" query
- push HAVING into "groupBy" query

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`ENABLED` Whether to run Druid tests.
`static URL`	`FOODMART` URL of the "druid-foodmart" model.
`static URL`	`WIKI` URL of the "druid-wiki" model and the "wikiticker" data set.
`static URL`	`WIKI_AUTO` URL of the "druid-wiki-no-columns" model and the "wikiticker" data set.
`static URL`	`WIKI_AUTO2` URL of the "druid-wiki-no-tables" model and the "wikiticker" data set.

Constructor Summary

Constructors
Constructor and Description

DruidAdapterIT()

Constructors
Constructor and Description
`DruidAdapterIT()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`enabled()` Whether to run this test.
`void`	`testAggOnArithmeticProject()`
`void`	`testAggOnArithmeticProject2()`
`void`	`testAggOnArithmeticProject3()`
`void`	`testAggOnTimeExtractColumn()`
`void`	`testAggOnTimeExtractColumn2()`
`void`	`testAggOverStringToLong()`
`void`	`testAggregationsWithComplexColumns()` Tests the use of other aggregations with complex columns
`void`	`testAggSameColumnMultipleTimes()`
`void`	`testAndCombinationOfComplexExpAndSimpleFilter()`
`void`	`testAndCombinationOfExpAndSimpleFilter()`
`void`	`testBetweenFilterWithCastOverNumeric()` Test case for https://issues.apache.org/jira/browse/CALCITE-2123
`void`	`testBooleanFilterExpressions()`
`void`	`testCastConcatOverPostAggregates()`
`void`	`testCastLiteralToTimestamp()`
`void`	`testCastOverPostAggregates()`
`void`	`testCastPlusMathOps()`
`void`	`testCeilFilterExpression()`
`void`	`testColumnAEqColumnB()`
`void`	`testColumnANotEqColumnB()`
`void`	`testCombinationOfValidAndNotValidAndInterval()` Test case for [CALCITE-2122] DateRangeRules issues.
`void`	`testCombinationOfValidAndNotValidFilterts()`
`void`	`testComplexExpressionsIsNull()`
`void`	`testComplexMetricAlsoDimension()` Test to make sure that if a complex metric is also a dimension, then `DruidTable` should allow it to be used like any other column.
`void`	`testComplexPushGroupBy()`
`void`	`testConstantPostAggregator()`
`void`	`testCountColumn()` [CALCITE-1805] Druid adapter cannot handle count column without adding support for nested queries.
`void`	`testCountColumn2()`
`void`	`testCountDistinctOnComplexColumn()` Tests the use of count(distinct ...) on a complex metric column in SELECT
`void`	`testCountGroupByEmpty()`
`void`	`testCountOnMetric()` Test to ensure that a count on a metric does not get pushed into Druid
`void`	`testCountOnMetricRenamed()`
`void`	`testCountOverVirtualColumn()`
`void`	`testCountStar()` Test to ensure that count(*) is pushed into Druid
`void`	`testCountWithNonNull()`
`void`	`testDistinctCount()` Tests that distinct-count is pushed down to Druid and evaluated using "cardinality".
`void`	`testDistinctCountOnMetric()`
`void`	`testDistinctCountOnMetricRenamed()`
`void`	`testDistinctCountWhenApproxResultsAccepted()` Test to ensure that count(distinct ...) gets pushed to Druid when approximate results are acceptable
`void`	`testDistinctCountWhenApproxResultsNotAccepted()` Test to ensure that count(distinct ...) doesn't get pushed to Druid when approximate results are not acceptable
`void`	`testDistinctLimit()`
`void`	`testDivideArithmeticOperation()`
`void`	`testDivideByZeroDoubleTypeInfinity()`
`void`	`testDivideByZeroDoubleTypeNaN()`
`void`	`testDivideByZeroDoubleTypeNegInfinity()`
`void`	`testDivideByZeroIntegerType()`
`void`	`testDruidTimeFloorAndTimeParseExpressions()`
`void`	`testDruidTimeFloorAndTimeParseExpressions2()`
`void`	`testDuplicateReferenceOnPostAggregation()`
`void`	`testExpressionFilterSimpleColumnAEqColumnB()`
`void`	`testExpressionsConcatFilter()`
`void`	`testExpressionsConcatFilterMultipleColumns()`
`void`	`testExpressionsFilter()`
`void`	`testExpressionsFilter2()`
`void`	`testExpressionsFilterWithCast()`
`void`	`testExpressionsFilterWithCastTimeToDateToChar()`
`void`	`testExpressionsFilterWithExtract()`
`void`	`testExpressionsLikeFilter()`
`void`	`testExpressionsLowerFilterMatching()`
`void`	`testExpressionsLowerFilterNotMatching()`
`void`	`testExpressionsLowerUpperFilter()`
`void`	`testExpressionsNotNull()`
`void`	`testExpressionsSTRLENFilter()`
`void`	`testExpressionsUpperFilterMatching()`
`void`	`testExpressionsUpperFilterNotMatching()`
`void`	`testExpressionsUpperLowerFilter()`
`void`	`testExtractFilterWorkWithPostAggregations()`
`void`	`testExtractFilterWorkWithPostAggregationsWithConstant()`
`void`	`testExtractHourFilterExpression()`
`void`	`testExtractMonthFilterExpression()`
`void`	`testExtractYearFilterExpression()`
`void`	`testFalseFilter()`
`void`	`testFalseFilterCaseConjectionWithTrue()`
`void`	`testFilter()`
`void`	`testFilterClauseAlwaysFalseNotPushed()` Tests that an aggregate with a filter clause that is always false does not get pushed in
`void`	`testFilterClauseAlwaysFalseNotPushedWithFilter()` Tests that an aggregate with a filter clause that is always false does not get pushed when there is already an outer filter
`void`	`testFilterClauseAlwaysTrueGone()` Tests whether filter clauses with filters that are always true disappear or not
`void`	`testFilterClauseAlwaysTrueWithAggGone1()` Tests whether filter clauses with filters that are always true disappear in the presence of another aggregate without a filter clause
`void`	`testFilterClauseAlwaysTrueWithAggGone2()` Tests whether filter clauses with filters that are always true disappear in the presence of another aggregate with a filter clause
`void`	`testFilterClauseFactoredOut()` Tests whether an aggregate with a filter clause has it's filter factored out when there is no outer filter
`void`	`testFilterClauseNotFactoredOut1()` Test to ensure that an aggregate with a filter clause in the presence of another aggregate without a filter clause does not have it's filter factored out into the outer filter
`void`	`testFilterClauseNotFactoredOut2()` Test to ensure that an aggregate with a filter clause in the presence of another aggregate without a filter clause, and an outer filter does not have it's filter factored out into the outer filter
`void`	`testFilterClauseNotPushable()` Test to ensure that aggregates with filter clauses that Druid cannot handle are not pushed in as filtered aggregates.
`void`	`testFilterClauseSameAsOuterFilterGone()` Tests that an aggregate with a filter clause that is the same as the outer filter has no references to that filter, and that the original outer filter remains
`void`	`testFilterClausesFactoredForPruning1()` Test to ensure that multiple aggregates with filter clauses have their filters extracted to the outer filter field for data pruning
`void`	`testFilterClausesFactoredForPruning2()` Test to ensure that multiple aggregates with filter clauses have their filters extracted to the outer filter field for data pruning in the presence of an outer filter
`void`	`testFilterClauseWithMetricAndTimeAndAggregates()`
`void`	`testFilterClauseWithMetricRef()`
`void`	`testFilterClauseWithMetricRefAndAggregates()`
`void`	`testFilterClauseWithNoConjunction()` Test case for https://issues.apache.org/jira/browse/CALCITE-2098.
`void`	`testFilterDistinct()`
`void`	`testFilterExtractionOnMonthWithBetween()`
`void`	`testFilterExtractionOnMonthWithIn()`
`void`	`testFilterFloorOnMetricColumn()`
`void`	`testFilterOnDouble()`
`void`	`testFilterOutEverything()` Tests a query whose filter removes all rows.
`void`	`testFilterSortDesc()` Tests a query that contains no GROUP BY and is therefore executed as a Druid "select" query.
`void`	`testFilterSortDescNumeric()` As `testFilterSortDesc()` but the bounds are numeric.
`void`	`testFilterSwapped()`
`void`	`testFilterTime()` Test case for [CALCITE-1617] Druid adapter: Send timestamp literals to Druid as local time, not UTC.
`void`	`testFilterTimeDistinct()`
`void`	`testFilterTimestamp()` Tests that conditions applied to time units extracted via the EXTRACT function become ranges on the timestamp column
`void`	`testFilterUnionPlan()`
`void`	`testFilterWithFloorOnTime()`
`void`	`testFloorToDateRangeWithTimeZone()`
`void`	`testGroupBy1()`
`void`	`testGroupByAvgSumCount()`
`void`	`testGroupByDayGranularity()`
`void`	`testGroupByDaySortDescLimit()` Test case for [CALCITE-1578] Druid adapter: wrong semantics of groupBy query limit with granularity.
`void`	`testGroupByDaySortDimension()` Test case for [CALCITE-1580] Druid adapter: Wrong semantics for ordering within groupBy queries.
`void`	`testGroupByDaySortLimit()` Test case for [CALCITE-1579] Druid adapter: wrong semantics of groupBy query limit with granularity.
`void`	`testGroupByFloorTimeWithLimit()`
`void`	`testGroupByFloorTimeWithoutLimit()`
`void`	`testGroupByHaving()`
`void`	`testGroupbyMetric()`
`void`	`testGroupByMetricAndExtractTime()`
`void`	`testGroupByMonthGranularity()`
`void`	`testGroupByMonthGranularityFiltered()`
`void`	`testGroupByMonthGranularitySort()` Test case for [CALCITE-1577] Druid adapter: Incorrect result - limit on timestamp disappears.
`void`	`testGroupByMonthGranularitySortLimit()`
`void`	`testGroupByOneColumn()`
`void`	`testGroupByOneColumnNotProjected()`
`void`	`testGroupByOneColumnReversed()`
`void`	`testGroupBySingleSortLimit()` Test case for [CALCITE-1587] Druid adapter: topN returns approximate results.
`void`	`testGroupBySingleSortLimitApprox()` As `testGroupBySingleSortLimit()`, but allowing approximate results due to `CalciteConnectionConfig.approximateDistinctCount()`.
`void`	`testGroupBySortLimit()` Test case for [CALCITE-1578] Druid adapter: wrong semantics of topN query limit with granularity.
`void`	`testGroupByTimeAndOneColumnNotProjected()`
`void`	`testGroupByTimeAndOneColumnNotProjectedWithLimit()` Unlike `testGroupByTimeAndOneColumnNotProjected()`, we cannot use "topN" because we have a global limit, and that requires `granularity: all`.
`void`	`testGroupByTimeAndOneMetricNotProjected()`
`void`	`testGroupByTimeSortOverMetrics()`
`void`	`testGroupByVirtualColumn()`
`void`	`testGroupByWeekExtract()`
`void`	`testGroupComposite()`
`void`	`testHavingSpecs()`
`void`	`testHyperUniquePostAggregator()` Turn on now count(distinct )
`void`	`testInterleaveBetweenAggregateAndGroupOrderByOnDimension()`
`void`	`testInterleaveBetweenAggregateAndGroupOrderByOnMetrics()`
`void`	`testIsNotNull()`
`void`	`testIsNull()`
`void`	`testLimit()`
`void`	`testMetadataColumns()`
`void`	`testMinusArithmeticOperation()`
`void`	`testMultipleFiltersFactoredOutWithOuterFilter()` Test to ensure that multiple aggregates with the same filter clause have them factored out in the presence of an outer filter, and that they no longer refer to those filters
`void`	`testMultiplyArithmeticOperation()`
`void`	`testNestedFilterClauseFactored()` Test to ensure that an aggregate with a nested filter clause has it's filter factored out
`void`	`testNestedFilterClauseInAggregates()` Test to ensure that aggregates with nested filters have their filters factored out into the outer filter for data pruning while still holding a reference to the filter clause
`void`	`testNonPushableFilterSortDesc()` As `testFilterSortDescNumeric()` but with a filter that cannot be pushed down to Druid.
`void`	`testNotFilterForm()` Test to make sure the "not" filter has only 1 field, rather than an array of fields.
`void`	`testNotTrueSimpleFilter()`
`void`	`testNumericOrderingOfOrderByOperatorFullTime()`
`void`	`testNumericOrderingOfOrderByOperatorStringDims()`
`void`	`testNumericOrderingOfOrderByOperatorTimeExtract()`
`void`	`testOffsetLimit()`
`void`	`testOrCombinationOfExpAndSimpleFilter()`
`void`	`testOrderByOneColumnNotProjected()`
`void`	`testOrderByOnMetricsInSelectDruidQuery()`
`void`	`testOuterFilterFalseAfterFactorSimplification()` Tests that when the resulting filter from factoring filter clauses out is always false, that they are still pushed to Druid to handle.
`void`	`testOuterFilterRemainsWithAlwaysTrueClause()` Tests whether an existing outer filter is untouched when an aggregate has a filter clause that is always true
`void`	`testPartiallyPostAggregation()`
`void`	`testPlusArithmeticOperation()`
`void`	`testPostAggregationWithComplexColumns()` Test post aggregation support with +, -, /, * operators
`void`	`testProject()` Tests that projections of columns are pushed into the DruidQuery, and projections of expressions that Druid cannot handle (in this case, a literal 0) stay up.
`void`	`testProjectSameColumnMultipleTimes()`
`void`	`testProjectSameMetricsColumnMultipleTimes()`
`void`	`testPushAggregateOnTime()`
`void`	`testPushAggregateOnTimeWithExtractDay()`
`void`	`testPushAggregateOnTimeWithExtractHourOfDay()`
`void`	`testPushAggregateOnTimeWithExtractMonth()`
`void`	`testPushAggregateOnTimeWithExtractWithOutRenaming()`
`void`	`testPushAggregateOnTimeWithExtractYear()`
`void`	`testPushAggregateOnTimeWithExtractYearMonthDay()`
`void`	`testPushAggregateOnTimeWithExtractYearMonthDayWithOutRenaming()`
`void`	`testPushCast()` Test case for [CALCITE-1770] Druid adapter: CAST(NULL AS ...) gives NPE.
`void`	`testPushCastNumeric()` Test case for [CALCITE-1769] Druid adapter: Push down filters involving numeric cast of literals.
`void`	`testPushComplexFilter()`
`void`	`testPushEqualsCastDimension()`
`void`	`testPushFieldEqualsLiteral()`
`void`	`testPushNotEqualsCastDimension()`
`void`	`testPushOfFilterExtractionOnDayAndMonth()`
`void`	`testPushOfFilterExtractionOnDayAndMonthAndYear()`
`void`	`testPushofOrderByMetricWithYearMonthExtract()`
`void`	`testPushOfOrderByWithMonthExtract()`
`void`	`testPushofOrderByYearWithYearMonthExtract()`
`void`	`testPushOfSimpleColumnAPlusColumnB()`
`void`	`testPushOfSimpleMathOps()`
`void`	`testPushSimpleGroupBy()`
`void`	`testQueryWithExtractsTimes()`
`void`	`testRecursiveArithmeticOperation()`
`void`	`testSelectCount()` Test case for [CALCITE-1281] Druid adapter wrongly returns all numeric values as int or float.
`void`	`testSelectDistinct()`
`void`	`testSelectDistinctWiki()` Tests a query against the `WIKI` data set.
`void`	`testSelectDistinctWikiNoColumns()`
`void`	`testSelectDistinctWikiNoTables()`
`void`	`testSelectExtractMonth()`
`void`	`testSelectFloorOnTimeWithFilterOnFloorOnTime()`
`void`	`testSelectGroupBySum()`
`void`	`testSelectStarWithRollUp()` Test to make sure that SELECT * doesn't fail, and that the rolled up column is not requested in the JSON query.
`void`	`testSelectTimestampColumnNoTables1()`
`void`	`testSelectTimestampColumnNoTables2()`
`void`	`testSelectTimestampColumnNoTables3()`
`void`	`testSelectTimestampColumnNoTables4()`
`void`	`testSingleAverageFunction()`
`void`	`testSkipEmptyBuckets()`
`void`	`testSort()`
`void`	`testSortLimit()`
`void`	`testStackedAggregateFilters()`
`void`	`testSubStringExpressionFilter()`
`void`	`testSubStringOverPostAggregates()`
`void`	`testTableauQueryExtractMonthDayYear()`
`void`	`testTableauQueryMinutesSecondsExtract()`
`void`	`testTableauQuerySubStringHourMinutes()`
`void`	`testTableMapReused()` Test to make sure that the mapping from a Table name to a Table returned from `DruidSchema` is always the same Java object.
`void`	`testTableQueryExtractYearQuarter()`
`void`	`testTimeExtractThatCannotBePushed()` Test case for [CALCITE-1765] Druid adapter: Gracefully handle granularity that cannot be pushed to extraction function.
`void`	`testTimeFloorExpressions()`
`void`	`testTimeWithFilterOnFloorOnTimeAndCastToTimestamp()`
`void`	`testTimeWithFilterOnFloorOnTimeWithTimezone()`
`void`	`testTimeWithFilterOnFloorOnTimeWithTimezoneConversion()`
`void`	`testTopNDayGranularityFiltered()`
`void`	`testTopNMonthGranularity()`
`void`	`testTransposableHavingFilter()`
`void`	`testTrigonometryMathFunctions()`
`void`	`testTrueFilter()`
`void`	`testUnionPlan()`
`void`	`testWhereGroupBy()` Tests a query that exposed several bugs in the interpreter.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - FOODMART
```
public static final URL FOODMART
```
    URL of the "druid-foodmart" model.
  - WIKI
```
public static final URL WIKI
```
    URL of the "druid-wiki" model and the "wikiticker" data set.
  - WIKI_AUTO
```
public static final URL WIKI_AUTO
```
    URL of the "druid-wiki-no-columns" model and the "wikiticker" data set.
  - WIKI_AUTO2
```
public static final URL WIKI_AUTO2
```
    URL of the "druid-wiki-no-tables" model and the "wikiticker" data set.
  - ENABLED
```
public static final boolean ENABLED
```
    Whether to run Druid tests. Enabled by default, however test is only included if "it" profile is activated (-Pit). To disable, specify -Dcalcite.test.druid=false on the Java command line.
- Constructor Detail
  - DruidAdapterIT
```
public DruidAdapterIT()
```
- Method Detail
  - enabled
```
protected boolean enabled()
```
    Whether to run this test.
  - testSelectDistinctWiki
```
public void testSelectDistinctWiki()
```
    Tests a query against the WIKI data set.
    Most of the others in this suite are against FOODMART, but our examples in "druid-adapter.md" use wikiticker.
  - testSelectDistinctWikiNoColumns
```
public void testSelectDistinctWikiNoColumns()
```
  - testSelectDistinctWikiNoTables
```
public void testSelectDistinctWikiNoTables()
```
  - testSelectTimestampColumnNoTables1
```
public void testSelectTimestampColumnNoTables1()
```
  - testSelectTimestampColumnNoTables2
```
public void testSelectTimestampColumnNoTables2()
```
  - testSelectTimestampColumnNoTables3
```
public void testSelectTimestampColumnNoTables3()
```
  - testSelectTimestampColumnNoTables4
```
public void testSelectTimestampColumnNoTables4()
```
  - testSkipEmptyBuckets
```
public void testSkipEmptyBuckets()
```
  - testFilterTime
```
public void testFilterTime()
```
    Test case for [CALCITE-1617] Druid adapter: Send timestamp literals to Druid as local time, not UTC.
  - testFilterTimeDistinct
```
public void testFilterTimeDistinct()
```
  - testMetadataColumns
```
public void testMetadataColumns()
                         throws Exception
```
    Throws:
    
    Exception
  - testSelectDistinct
```
public void testSelectDistinct()
```
  - testSelectGroupBySum
```
public void testSelectGroupBySum()
```
  - testGroupbyMetric
```
public void testGroupbyMetric()
```
  - testPushSimpleGroupBy
```
public void testPushSimpleGroupBy()
```
  - testComplexPushGroupBy
```
public void testComplexPushGroupBy()
```
  - testSelectCount
```
public void testSelectCount()
```
    Test case for [CALCITE-1281] Druid adapter wrongly returns all numeric values as int or float.
  - testSort
```
public void testSort()
```
  - testSortLimit
```
public void testSortLimit()
```
  - testOffsetLimit
```
public void testOffsetLimit()
```
  - testLimit
```
public void testLimit()
```
  - testDistinctLimit
```
public void testDistinctLimit()
```
  - testGroupBySortLimit
```
public void testGroupBySortLimit()
```
    Test case for [CALCITE-1578] Druid adapter: wrong semantics of topN query limit with granularity.
  - testGroupBySingleSortLimit
```
public void testGroupBySingleSortLimit()
```
    Test case for [CALCITE-1587] Druid adapter: topN returns approximate results.
  - testGroupBySingleSortLimitApprox
```
public void testGroupBySingleSortLimitApprox()
```
    As testGroupBySingleSortLimit(), but allowing approximate results due to CalciteConnectionConfig.approximateDistinctCount(). Therefore we send a "topN" query to Druid.
  - testGroupByDaySortDescLimit
```
public void testGroupByDaySortDescLimit()
```
    Test case for [CALCITE-1578] Druid adapter: wrong semantics of groupBy query limit with granularity.
    Before CALCITE-1578 was fixed, this would use a "topN" query but return the wrong results.
  - testGroupByDaySortLimit
```
public void testGroupByDaySortLimit()
```
    Test case for [CALCITE-1579] Druid adapter: wrong semantics of groupBy query limit with granularity.
    Before CALCITE-1579 was fixed, this would use a "groupBy" query but wrongly try to use a limitSpec to sort and filter. (A "topN" query was not possible because the sort was ASC.)
  - testGroupByDaySortDimension
```
public void testGroupByDaySortDimension()
```
    Test case for [CALCITE-1580] Druid adapter: Wrong semantics for ordering within groupBy queries.
  - testFilterSortDesc
```
public void testFilterSortDesc()
```
    Tests a query that contains no GROUP BY and is therefore executed as a Druid "select" query.
  - testFilterSortDescNumeric
```
public void testFilterSortDescNumeric()
```
    As testFilterSortDesc() but the bounds are numeric.
  - testFilterOutEverything
```
public void testFilterOutEverything()
```
    Tests a query whose filter removes all rows.
  - testNonPushableFilterSortDesc
```
public void testNonPushableFilterSortDesc()
```
    As testFilterSortDescNumeric() but with a filter that cannot be pushed down to Druid.
  - testUnionPlan
```
public void testUnionPlan()
```
  - testFilterUnionPlan
```
public void testFilterUnionPlan()
```
  - testCountGroupByEmpty
```
public void testCountGroupByEmpty()
```
  - testGroupByOneColumnNotProjected
```
public void testGroupByOneColumnNotProjected()
```
  - testGroupByTimeAndOneColumnNotProjectedWithLimit
```
public void testGroupByTimeAndOneColumnNotProjectedWithLimit()
```
    Unlike testGroupByTimeAndOneColumnNotProjected(), we cannot use "topN" because we have a global limit, and that requires granularity: all.
  - testGroupByTimeAndOneMetricNotProjected
```
public void testGroupByTimeAndOneMetricNotProjected()
```
  - testGroupByTimeAndOneColumnNotProjected
```
public void testGroupByTimeAndOneColumnNotProjected()
```
  - testOrderByOneColumnNotProjected
```
public void testOrderByOneColumnNotProjected()
```
  - testGroupByOneColumn
```
public void testGroupByOneColumn()
```
  - testGroupByOneColumnReversed
```
public void testGroupByOneColumnReversed()
```
  - testGroupByAvgSumCount
```
public void testGroupByAvgSumCount()
```
  - testGroupByMonthGranularity
```
public void testGroupByMonthGranularity()
```
  - testGroupByMonthGranularitySort
```
public void testGroupByMonthGranularitySort()
```
    Test case for [CALCITE-1577] Druid adapter: Incorrect result - limit on timestamp disappears.
  - testGroupByMonthGranularitySortLimit
```
public void testGroupByMonthGranularitySortLimit()
```
  - testGroupByDayGranularity
```
public void testGroupByDayGranularity()
```
  - testGroupByMonthGranularityFiltered
```
public void testGroupByMonthGranularityFiltered()
```
  - testTopNMonthGranularity
```
public void testTopNMonthGranularity()
```
  - testTopNDayGranularityFiltered
```
public void testTopNDayGranularityFiltered()
```
  - testGroupByHaving
```
public void testGroupByHaving()
```
  - testGroupComposite
```
public void testGroupComposite()
```
  - testDistinctCount
```
public void testDistinctCount()
```
    Tests that distinct-count is pushed down to Druid and evaluated using "cardinality". The result is approximate, but gives the correct result in this example when rounded down using FLOOR.
  - testProject
```
public void testProject()
```
    Tests that projections of columns are pushed into the DruidQuery, and projections of expressions that Druid cannot handle (in this case, a literal 0) stay up.
  - testFilterDistinct
```
public void testFilterDistinct()
```
  - testFilter
```
public void testFilter()
```
  - testFilterTimestamp
```
public void testFilterTimestamp()
```
    Tests that conditions applied to time units extracted via the EXTRACT function become ranges on the timestamp column
    Test case for [CALCITE-1334] Convert predicates on EXTRACT function calls into date ranges.
  - testFilterSwapped
```
public void testFilterSwapped()
```
  - testWhereGroupBy
```
public void testWhereGroupBy()
```
    Tests a query that exposed several bugs in the interpreter.
  - testGroupByMetricAndExtractTime
```
public void testGroupByMetricAndExtractTime()
```
  - testFilterOnDouble
```
public void testFilterOnDouble()
```
  - testPushAggregateOnTime
```
public void testPushAggregateOnTime()
```
  - testPushAggregateOnTimeWithExtractYear
```
public void testPushAggregateOnTimeWithExtractYear()
```
  - testPushAggregateOnTimeWithExtractMonth
```
public void testPushAggregateOnTimeWithExtractMonth()
```
  - testPushAggregateOnTimeWithExtractDay
```
public void testPushAggregateOnTimeWithExtractDay()
```
  - testPushAggregateOnTimeWithExtractHourOfDay
```
public void testPushAggregateOnTimeWithExtractHourOfDay()
```
  - testPushAggregateOnTimeWithExtractYearMonthDay
```
public void testPushAggregateOnTimeWithExtractYearMonthDay()
```
  - testPushAggregateOnTimeWithExtractYearMonthDayWithOutRenaming
```
public void testPushAggregateOnTimeWithExtractYearMonthDayWithOutRenaming()
```
  - testPushAggregateOnTimeWithExtractWithOutRenaming
```
public void testPushAggregateOnTimeWithExtractWithOutRenaming()
```
  - testPushComplexFilter
```
public void testPushComplexFilter()
```
  - testPushOfFilterExtractionOnDayAndMonth
```
public void testPushOfFilterExtractionOnDayAndMonth()
```
  - testPushOfFilterExtractionOnDayAndMonthAndYear
```
public void testPushOfFilterExtractionOnDayAndMonthAndYear()
```
  - testFilterExtractionOnMonthWithBetween
```
public void testFilterExtractionOnMonthWithBetween()
```
  - testFilterExtractionOnMonthWithIn
```
public void testFilterExtractionOnMonthWithIn()
```
  - testPushOfOrderByWithMonthExtract
```
public void testPushOfOrderByWithMonthExtract()
```
  - testGroupByFloorTimeWithoutLimit
```
public void testGroupByFloorTimeWithoutLimit()
```
  - testGroupByFloorTimeWithLimit
```
public void testGroupByFloorTimeWithLimit()
```
  - testPushofOrderByYearWithYearMonthExtract
```
public void testPushofOrderByYearWithYearMonthExtract()
```
  - testPushofOrderByMetricWithYearMonthExtract
```
public void testPushofOrderByMetricWithYearMonthExtract()
```
  - testGroupByTimeSortOverMetrics
```
public void testGroupByTimeSortOverMetrics()
```
  - testNumericOrderingOfOrderByOperatorFullTime
```
public void testNumericOrderingOfOrderByOperatorFullTime()
```
  - testNumericOrderingOfOrderByOperatorTimeExtract
```
public void testNumericOrderingOfOrderByOperatorTimeExtract()
```
  - testNumericOrderingOfOrderByOperatorStringDims
```
public void testNumericOrderingOfOrderByOperatorStringDims()
```
  - testGroupByWeekExtract
```
public void testGroupByWeekExtract()
```
  - testTimeExtractThatCannotBePushed
```
public void testTimeExtractThatCannotBePushed()
```
    Test case for [CALCITE-1765] Druid adapter: Gracefully handle granularity that cannot be pushed to extraction function.
  - testPushCast
```
public void testPushCast()
```
    Test case for [CALCITE-1770] Druid adapter: CAST(NULL AS ...) gives NPE.
  - testFalseFilter
```
public void testFalseFilter()
```
  - testTrueFilter
```
public void testTrueFilter()
```
  - testFalseFilterCaseConjectionWithTrue
```
public void testFalseFilterCaseConjectionWithTrue()
```
  - testPushCastNumeric
```
public void testPushCastNumeric()
```
    Test case for [CALCITE-1769] Druid adapter: Push down filters involving numeric cast of literals.
  - testPushFieldEqualsLiteral
```
public void testPushFieldEqualsLiteral()
```
  - testPlusArithmeticOperation
```
public void testPlusArithmeticOperation()
```
  - testDivideArithmeticOperation
```
public void testDivideArithmeticOperation()
```
  - testMultiplyArithmeticOperation
```
public void testMultiplyArithmeticOperation()
```
  - testMinusArithmeticOperation
```
public void testMinusArithmeticOperation()
```
  - testConstantPostAggregator
```
public void testConstantPostAggregator()
```
  - testRecursiveArithmeticOperation
```
public void testRecursiveArithmeticOperation()
```
  - testHyperUniquePostAggregator
```
public void testHyperUniquePostAggregator()
```
    Turn on now count(distinct )
  - testExtractFilterWorkWithPostAggregations
```
public void testExtractFilterWorkWithPostAggregations()
```
  - testExtractFilterWorkWithPostAggregationsWithConstant
```
public void testExtractFilterWorkWithPostAggregationsWithConstant()
```
  - testSingleAverageFunction
```
public void testSingleAverageFunction()
```
  - testPartiallyPostAggregation
```
public void testPartiallyPostAggregation()
```
  - testDuplicateReferenceOnPostAggregation
```
public void testDuplicateReferenceOnPostAggregation()
```
  - testDivideByZeroDoubleTypeInfinity
```
public void testDivideByZeroDoubleTypeInfinity()
```
  - testDivideByZeroDoubleTypeNegInfinity
```
public void testDivideByZeroDoubleTypeNegInfinity()
```
  - testDivideByZeroDoubleTypeNaN
```
public void testDivideByZeroDoubleTypeNaN()
```
  - testDivideByZeroIntegerType
```
public void testDivideByZeroIntegerType()
```
  - testInterleaveBetweenAggregateAndGroupOrderByOnMetrics
```
public void testInterleaveBetweenAggregateAndGroupOrderByOnMetrics()
```
  - testInterleaveBetweenAggregateAndGroupOrderByOnDimension
```
public void testInterleaveBetweenAggregateAndGroupOrderByOnDimension()
```
  - testOrderByOnMetricsInSelectDruidQuery
```
public void testOrderByOnMetricsInSelectDruidQuery()
```
  - testFilterClauseFactoredOut
```
public void testFilterClauseFactoredOut()
```
    Tests whether an aggregate with a filter clause has it's filter factored out when there is no outer filter
  - testFilterClauseAlwaysTrueGone
```
public void testFilterClauseAlwaysTrueGone()
```
    Tests whether filter clauses with filters that are always true disappear or not
  - testFilterClauseAlwaysTrueWithAggGone1
```
public void testFilterClauseAlwaysTrueWithAggGone1()
```
    Tests whether filter clauses with filters that are always true disappear in the presence of another aggregate without a filter clause
  - testFilterClauseAlwaysTrueWithAggGone2
```
public void testFilterClauseAlwaysTrueWithAggGone2()
```
    Tests whether filter clauses with filters that are always true disappear in the presence of another aggregate with a filter clause
  - testOuterFilterRemainsWithAlwaysTrueClause
```
public void testOuterFilterRemainsWithAlwaysTrueClause()
```
    Tests whether an existing outer filter is untouched when an aggregate has a filter clause that is always true
  - testFilterClauseAlwaysFalseNotPushed
```
public void testFilterClauseAlwaysFalseNotPushed()
```
    Tests that an aggregate with a filter clause that is always false does not get pushed in
  - testFilterClauseAlwaysFalseNotPushedWithFilter
```
public void testFilterClauseAlwaysFalseNotPushedWithFilter()
```
    Tests that an aggregate with a filter clause that is always false does not get pushed when there is already an outer filter
  - testFilterClauseSameAsOuterFilterGone
```
public void testFilterClauseSameAsOuterFilterGone()
```
    Tests that an aggregate with a filter clause that is the same as the outer filter has no references to that filter, and that the original outer filter remains
  - testFilterClauseNotFactoredOut1
```
public void testFilterClauseNotFactoredOut1()
```
    Test to ensure that an aggregate with a filter clause in the presence of another aggregate without a filter clause does not have it's filter factored out into the outer filter
  - testFilterClauseNotFactoredOut2
```
public void testFilterClauseNotFactoredOut2()
```
    Test to ensure that an aggregate with a filter clause in the presence of another aggregate without a filter clause, and an outer filter does not have it's filter factored out into the outer filter
  - testFilterClausesFactoredForPruning1
```
public void testFilterClausesFactoredForPruning1()
```
    Test to ensure that multiple aggregates with filter clauses have their filters extracted to the outer filter field for data pruning
  - testFilterClausesFactoredForPruning2
```
public void testFilterClausesFactoredForPruning2()
```
    Test to ensure that multiple aggregates with filter clauses have their filters extracted to the outer filter field for data pruning in the presence of an outer filter
  - testMultipleFiltersFactoredOutWithOuterFilter
```
public void testMultipleFiltersFactoredOutWithOuterFilter()
```
    Test to ensure that multiple aggregates with the same filter clause have them factored out in the presence of an outer filter, and that they no longer refer to those filters
  - testOuterFilterFalseAfterFactorSimplification
```
public void testOuterFilterFalseAfterFactorSimplification()
```
    Tests that when the resulting filter from factoring filter clauses out is always false, that they are still pushed to Druid to handle.
  - testFilterClauseNotPushable
```
public void testFilterClauseNotPushable()
```
    Test to ensure that aggregates with filter clauses that Druid cannot handle are not pushed in as filtered aggregates.
  - testFilterClauseWithMetricRef
```
public void testFilterClauseWithMetricRef()
```
  - testFilterClauseWithMetricRefAndAggregates
```
public void testFilterClauseWithMetricRefAndAggregates()
```
  - testFilterClauseWithMetricAndTimeAndAggregates
```
public void testFilterClauseWithMetricAndTimeAndAggregates()
```
  - testNestedFilterClauseFactored
```
public void testNestedFilterClauseFactored()
```
    Test to ensure that an aggregate with a nested filter clause has it's filter factored out
  - testNestedFilterClauseInAggregates
```
public void testNestedFilterClauseInAggregates()
```
    Test to ensure that aggregates with nested filters have their filters factored out into the outer filter for data pruning while still holding a reference to the filter clause
  - testCountColumn
```
public void testCountColumn()
```
    [CALCITE-1805] Druid adapter cannot handle count column without adding support for nested queries.
  - testCountColumn2
```
public void testCountColumn2()
```
  - testCountWithNonNull
```
public void testCountWithNonNull()
```
  - testNotFilterForm
```
public void testNotFilterForm()
```
    Test to make sure the "not" filter has only 1 field, rather than an array of fields.
  - testDistinctCountWhenApproxResultsAccepted
```
public void testDistinctCountWhenApproxResultsAccepted()
```
    Test to ensure that count(distinct ...) gets pushed to Druid when approximate results are acceptable
  - testDistinctCountWhenApproxResultsNotAccepted
```
public void testDistinctCountWhenApproxResultsNotAccepted()
```
    Test to ensure that count(distinct ...) doesn't get pushed to Druid when approximate results are not acceptable
  - testDistinctCountOnMetric
```
public void testDistinctCountOnMetric()
```
  - testCountOnMetric
```
public void testCountOnMetric()
```
    Test to ensure that a count on a metric does not get pushed into Druid
  - testCountStar
```
public void testCountStar()
```
    Test to ensure that count(*) is pushed into Druid
  - testCountOnMetricRenamed
```
public void testCountOnMetricRenamed()
```
  - testDistinctCountOnMetricRenamed
```
public void testDistinctCountOnMetricRenamed()
```
  - testCountDistinctOnComplexColumn
```
public void testCountDistinctOnComplexColumn()
```
    Tests the use of count(distinct ...) on a complex metric column in SELECT
  - testAggregationsWithComplexColumns
```
public void testAggregationsWithComplexColumns()
```
    Tests the use of other aggregations with complex columns
  - testPostAggregationWithComplexColumns
```
public void testPostAggregationWithComplexColumns()
```
    Test post aggregation support with +, -, /, * operators
  - testComplexMetricAlsoDimension
```
public void testComplexMetricAlsoDimension()
```
    Test to make sure that if a complex metric is also a dimension, then DruidTable should allow it to be used like any other column.
  - testSelectStarWithRollUp
```
public void testSelectStarWithRollUp()
```
    Test to make sure that SELECT * doesn't fail, and that the rolled up column is not requested in the JSON query.
  - testTableMapReused
```
public void testTableMapReused()
```
    Test to make sure that the mapping from a Table name to a Table returned from DruidSchema is always the same Java object.
  - testPushEqualsCastDimension
```
public void testPushEqualsCastDimension()
```
  - testPushNotEqualsCastDimension
```
public void testPushNotEqualsCastDimension()
```
  - testIsNull
```
public void testIsNull()
```
  - testIsNotNull
```
public void testIsNotNull()
```
  - testFilterWithFloorOnTime
```
public void testFilterWithFloorOnTime()
```
  - testSelectFloorOnTimeWithFilterOnFloorOnTime
```
public void testSelectFloorOnTimeWithFilterOnFloorOnTime()
```
  - testTimeWithFilterOnFloorOnTimeAndCastToTimestamp
```
public void testTimeWithFilterOnFloorOnTimeAndCastToTimestamp()
```
  - testTimeWithFilterOnFloorOnTimeWithTimezone
```
public void testTimeWithFilterOnFloorOnTimeWithTimezone()
```
  - testTimeWithFilterOnFloorOnTimeWithTimezoneConversion
```
public void testTimeWithFilterOnFloorOnTimeWithTimezoneConversion()
```
  - testCombinationOfValidAndNotValidAndInterval
```
public void testCombinationOfValidAndNotValidAndInterval()
```
    Test case for [CALCITE-2122] DateRangeRules issues.
  - testFloorToDateRangeWithTimeZone
```
public void testFloorToDateRangeWithTimeZone()
```
  - testExpressionsFilter
```
public void testExpressionsFilter()
```
  - testExpressionsFilter2
```
public void testExpressionsFilter2()
```
  - testExpressionsLikeFilter
```
public void testExpressionsLikeFilter()
```
  - testExpressionsSTRLENFilter
```
public void testExpressionsSTRLENFilter()
```
  - testExpressionsUpperLowerFilter
```
public void testExpressionsUpperLowerFilter()
```
  - testExpressionsLowerUpperFilter
```
public void testExpressionsLowerUpperFilter()
```
  - testExpressionsLowerFilterNotMatching
```
public void testExpressionsLowerFilterNotMatching()
```
  - testExpressionsLowerFilterMatching
```
public void testExpressionsLowerFilterMatching()
```
  - testExpressionsUpperFilterNotMatching
```
public void testExpressionsUpperFilterNotMatching()
```
  - testExpressionsUpperFilterMatching
```
public void testExpressionsUpperFilterMatching()
```
  - testExpressionsConcatFilter
```
public void testExpressionsConcatFilter()
```
  - testExpressionsNotNull
```
public void testExpressionsNotNull()
```
  - testComplexExpressionsIsNull
```
public void testComplexExpressionsIsNull()
```
  - testExpressionsConcatFilterMultipleColumns
```
public void testExpressionsConcatFilterMultipleColumns()
```
  - testAndCombinationOfExpAndSimpleFilter
```
public void testAndCombinationOfExpAndSimpleFilter()
```
  - testOrCombinationOfExpAndSimpleFilter
```
public void testOrCombinationOfExpAndSimpleFilter()
```
  - testColumnAEqColumnB
```
public void testColumnAEqColumnB()
```
  - testColumnANotEqColumnB
```
public void testColumnANotEqColumnB()
```
  - testAndCombinationOfComplexExpAndSimpleFilter
```
public void testAndCombinationOfComplexExpAndSimpleFilter()
```
  - testExpressionsFilterWithCast
```
public void testExpressionsFilterWithCast()
```
  - testExpressionsFilterWithCastTimeToDateToChar
```
public void testExpressionsFilterWithCastTimeToDateToChar()
```
  - testExpressionsFilterWithExtract
```
public void testExpressionsFilterWithExtract()
```
  - testExtractYearFilterExpression
```
public void testExtractYearFilterExpression()
```
  - testExtractMonthFilterExpression
```
public void testExtractMonthFilterExpression()
```
  - testExtractHourFilterExpression
```
public void testExtractHourFilterExpression()
```
  - testTimeFloorExpressions
```
public void testTimeFloorExpressions()
```
  - testDruidTimeFloorAndTimeParseExpressions
```
public void testDruidTimeFloorAndTimeParseExpressions()
```
  - testDruidTimeFloorAndTimeParseExpressions2
```
public void testDruidTimeFloorAndTimeParseExpressions2()
```
  - testFilterFloorOnMetricColumn
```
public void testFilterFloorOnMetricColumn()
```
  - testExpressionFilterSimpleColumnAEqColumnB
```
public void testExpressionFilterSimpleColumnAEqColumnB()
```
  - testCastPlusMathOps
```
public void testCastPlusMathOps()
```
  - testBooleanFilterExpressions
```
public void testBooleanFilterExpressions()
```
  - testCombinationOfValidAndNotValidFilterts
```
public void testCombinationOfValidAndNotValidFilterts()
```
  - testCeilFilterExpression
```
public void testCeilFilterExpression()
```
  - testSubStringExpressionFilter
```
public void testSubStringExpressionFilter()
```
  - testFilterClauseWithNoConjunction
```
public void testFilterClauseWithNoConjunction()
```
    Test case for https://issues.apache.org/jira/browse/CALCITE-2098. Need to make sure that when there we have a valid filter with no conjunction we still push all the valid filters.
  - testBetweenFilterWithCastOverNumeric
```
public void testBetweenFilterWithCastOverNumeric()
```
    Test case for https://issues.apache.org/jira/browse/CALCITE-2123
  - testTrigonometryMathFunctions
```
public void testTrigonometryMathFunctions()
```
  - testCastLiteralToTimestamp
```
public void testCastLiteralToTimestamp()
```
  - testNotTrueSimpleFilter
```
public void testNotTrueSimpleFilter()
```
  - testPushOfSimpleMathOps
```
public void testPushOfSimpleMathOps()
```
  - testPushOfSimpleColumnAPlusColumnB
```
public void testPushOfSimpleColumnAPlusColumnB()
```
  - testSelectExtractMonth
```
public void testSelectExtractMonth()
```
  - testAggOnArithmeticProject
```
public void testAggOnArithmeticProject()
```
  - testAggOnArithmeticProject2
```
public void testAggOnArithmeticProject2()
```
  - testAggOnArithmeticProject3
```
public void testAggOnArithmeticProject3()
```
  - testGroupByVirtualColumn
```
public void testGroupByVirtualColumn()
```
  - testCountOverVirtualColumn
```
public void testCountOverVirtualColumn()
```
  - testAggOverStringToLong
```
public void testAggOverStringToLong()
```
  - testAggOnTimeExtractColumn
```
public void testAggOnTimeExtractColumn()
```
  - testAggOnTimeExtractColumn2
```
public void testAggOnTimeExtractColumn2()
```
  - testStackedAggregateFilters
```
public void testStackedAggregateFilters()
```
  - testCastOverPostAggregates
```
public void testCastOverPostAggregates()
```
  - testSubStringOverPostAggregates
```
public void testSubStringOverPostAggregates()
```
  - testTableQueryExtractYearQuarter
```
public void testTableQueryExtractYearQuarter()
```
  - testTableauQueryExtractMonthDayYear
```
public void testTableauQueryExtractMonthDayYear()
```
  - testTableauQuerySubStringHourMinutes
```
public void testTableauQuerySubStringHourMinutes()
```
  - testTableauQueryMinutesSecondsExtract
```
public void testTableauQueryMinutesSecondsExtract()
```
  - testQueryWithExtractsTimes
```
public void testQueryWithExtractsTimes()
```
  - testCastConcatOverPostAggregates
```
public void testCastConcatOverPostAggregates()
```
  - testHavingSpecs
```
public void testHavingSpecs()
```
  - testTransposableHavingFilter
```
public void testTransposableHavingFilter()
```
  - testProjectSameColumnMultipleTimes
```
public void testProjectSameColumnMultipleTimes()
```
  - testProjectSameMetricsColumnMultipleTimes
```
public void testProjectSameMetricsColumnMultipleTimes()
```
  - testAggSameColumnMultipleTimes
```
public void testAggSameColumnMultipleTimes()
```
  - testGroupBy1
```
public void testGroupBy1()
```

Class DruidAdapterIT

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

FOODMART

WIKI

WIKI_AUTO

WIKI_AUTO2

ENABLED

Constructor Detail

DruidAdapterIT

Method Detail

enabled

testSelectDistinctWiki

testSelectDistinctWikiNoColumns

testSelectDistinctWikiNoTables

testSelectTimestampColumnNoTables1

testSelectTimestampColumnNoTables2

testSelectTimestampColumnNoTables3

testSelectTimestampColumnNoTables4

testSkipEmptyBuckets

testFilterTime

testFilterTimeDistinct

testMetadataColumns

testSelectDistinct

testSelectGroupBySum

testGroupbyMetric

testPushSimpleGroupBy

testComplexPushGroupBy

testSelectCount

testSort

testSortLimit

testOffsetLimit

testLimit

testDistinctLimit

testGroupBySortLimit

testGroupBySingleSortLimit

testGroupBySingleSortLimitApprox

testGroupByDaySortDescLimit

testGroupByDaySortLimit

testGroupByDaySortDimension

testFilterSortDesc

testFilterSortDescNumeric

testFilterOutEverything

testNonPushableFilterSortDesc

testUnionPlan

testFilterUnionPlan

testCountGroupByEmpty

testGroupByOneColumnNotProjected

testGroupByTimeAndOneColumnNotProjectedWithLimit

testGroupByTimeAndOneMetricNotProjected

testGroupByTimeAndOneColumnNotProjected

testOrderByOneColumnNotProjected

testGroupByOneColumn

testGroupByOneColumnReversed

testGroupByAvgSumCount

testGroupByMonthGranularity

testGroupByMonthGranularitySort

testGroupByMonthGranularitySortLimit

testGroupByDayGranularity

testGroupByMonthGranularityFiltered

testTopNMonthGranularity

testTopNDayGranularityFiltered

testGroupByHaving

testGroupComposite

testDistinctCount

testProject

testFilterDistinct

testFilter

testFilterTimestamp

testFilterSwapped

testWhereGroupBy

testGroupByMetricAndExtractTime

testFilterOnDouble

testPushAggregateOnTime

testPushAggregateOnTimeWithExtractYear

testPushAggregateOnTimeWithExtractMonth

testPushAggregateOnTimeWithExtractDay