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

```
public class DruidAdapterIT2
extends java.lang.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
These tests use TIMESTAMP type for the Druid timestamp column, instead of TIMESTAMP WITH LOCAL TIME ZONE type as DruidAdapterIT.

Field Summary

Fields
Modifier and Type	Field	Description
`static boolean`	`ENABLED`	Whether to run Druid tests.
`static java.net.URL`	`FOODMART`	URL of the "druid-foodmart" model.
`private static java.lang.String`	`FOODMART_TABLE`
`private static java.lang.String`	`VARCHAR_TYPE`

Constructor Summary

Constructors
Constructor Description

DruidAdapterIT2()

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private CalciteAssert.AssertQuery`	`approxQuery(java.net.URL url, java.lang.String sql)`
`private void`	`checkGroupBySingleSortLimit(boolean approx)`
`private static java.util.function.Consumer<java.util.List>`	`druidChecker(java.lang.String... lines)`	Returns a function that checks that a particular Druid query is generated to implement a query.
`protected boolean`	`enabled()`	Whether to run this test.
`private CalciteAssert.AssertQuery`	`foodmartApprox(java.lang.String sql)`	Creates a query against FOODMART with approximate parameters
`private CalciteAssert.AssertQuery`	`sql(java.lang.String sql)`	Creates a query against the `FOODMART` data set.
`private CalciteAssert.AssertQuery`	`sql(java.lang.String sql, java.net.URL url)`	Creates a query against a data set given by a map.
`void`	`testAggOnArithmeticProject()`
`void`	`testAggOnArithmeticProject2()`
`void`	`testAggOnArithmeticProject3()`
`void`	`testAggOnTimeExtractColumn2()`
`void`	`testAggOverStringToLong()`
`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`	`testCastTimestamp()`
`void`	`testCeilFilterExpression()`
`void`	`testColumnAEqColumnB()`
`void`	`testColumnANotEqColumnB()`
`void`	`testCombinationOfValidAndNotValidAndInterval()`	Test case for [CALCITE-2122] DateRangeRules issues.
`void`	`testCombinationOfValidAndNotValidFilters()`
`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`	`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
`private void`	`testCountWithApproxDistinct(boolean approx, java.lang.String sql, java.lang.String expectedExplain)`
`private void`	`testCountWithApproxDistinct(boolean approx, java.lang.String sql, java.lang.String expectedExplain, java.lang.String expectedDruidQuery)`
`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`	`testExtractMonthFilterExpression()`
`void`	`testExtractQuarter()`
`void`	`testExtractQuarterPlusDim()`
`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`	`testFilterTimestamp()`	Tests that conditions applied to time units extracted via the EXTRACT function become ranges on the timestamp column
`void`	`testFilterUnionPlan()`
`void`	`testFilterWithFloorOnTime()`
`void`	`testFloorQuarter()`
`void`	`testFloorQuarterPlusDim()`
`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`	`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`	`testRecursiveArithmeticOperation()`
`void`	`testSelectCount()`	Test case for [CALCITE-1281] Druid adapter wrongly returns all numeric values as int or float.
`void`	`testSelectDistinct()`
`void`	`testSelectExtractMonth()`
`void`	`testSelectFloorOnTimeWithFilterOnFloorOnTime()`
`void`	`testSelectGroupBySum()`
`void`	`testSingleAverageFunction()`
`void`	`testSort()`
`void`	`testSortLimit()`
`void`	`testStackedAggregateFilters()`
`void`	`testSubStringExpressionFilter()`
`void`	`testSubStringOverPostAggregates()`
`void`	`testSubStringWithNonConstantIndex()`
`void`	`testSubStringWithNonConstantIndexes()`
`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`	`testTopNDayGranularityFiltered()`
`void`	`testTopNMonthGranularity()`
`void`	`testTransposableHavingFilter()`
`void`	`testTrigonometryMathFunctions()`
`void`	`testTrueFilter()`
`void`	`testUnionPlan()`

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

- Field Detail
  - FOODMART
```
public static final java.net.URL FOODMART
```
    URL of the "druid-foodmart" model.
  - 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.
  - VARCHAR_TYPE
```
private static final java.lang.String VARCHAR_TYPE
```
    See Also:
    
    Constant Field Values
  - FOODMART_TABLE
```
private static final java.lang.String FOODMART_TABLE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - DruidAdapterIT2
```
public DruidAdapterIT2()
```
- Method Detail
  - enabled
```
protected boolean enabled()
```
    Whether to run this test.
  - druidChecker
```
private static java.util.function.Consumer<java.util.List> druidChecker(java.lang.String... lines)
```
    Returns a function that checks that a particular Druid query is generated to implement a query.
  - foodmartApprox
```
private CalciteAssert.AssertQuery foodmartApprox(java.lang.String sql)
```
    Creates a query against FOODMART with approximate parameters
  - approxQuery
```
private CalciteAssert.AssertQuery approxQuery(java.net.URL url,
                                              java.lang.String sql)
```
  - sql
```
private CalciteAssert.AssertQuery sql(java.lang.String sql,
                                      java.net.URL url)
```
    Creates a query against a data set given by a map.
  - sql
```
private CalciteAssert.AssertQuery sql(java.lang.String sql)
```
    Creates a query against the FOODMART data set.
  - testMetadataColumns
```
public void testMetadataColumns()
                         throws java.lang.Exception
```
    Throws:
    
    java.lang.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.
  - checkGroupBySingleSortLimit
```
private void checkGroupBySingleSortLimit(boolean approx)
```
  - 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()
```
  - 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
  - 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()
```
  - testCountWithApproxDistinct
```
private void testCountWithApproxDistinct(boolean approx,
                                         java.lang.String sql,
                                         java.lang.String expectedExplain)
```
  - testCountWithApproxDistinct
```
private void testCountWithApproxDistinct(boolean approx,
                                         java.lang.String sql,
                                         java.lang.String expectedExplain,
                                         java.lang.String expectedDruidQuery)
```
  - 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.
  - 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()
```
  - 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()
```
  - 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()
```
  - testCombinationOfValidAndNotValidFilters
```
public void testCombinationOfValidAndNotValidFilters()
```
  - testCeilFilterExpression
```
public void testCeilFilterExpression()
```
  - testSubStringExpressionFilter
```
public void testSubStringExpressionFilter()
```
  - testSubStringWithNonConstantIndexes
```
public void testSubStringWithNonConstantIndexes()
```
  - testSubStringWithNonConstantIndex
```
public void testSubStringWithNonConstantIndex()
```
  - 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()
```
  - 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()
```
  - 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()
```
  - testFloorQuarter
```
public void testFloorQuarter()
```
  - testFloorQuarterPlusDim
```
public void testFloorQuarterPlusDim()
```
  - testExtractQuarterPlusDim
```
public void testExtractQuarterPlusDim()
```
  - testExtractQuarter
```
public void testExtractQuarter()
```
  - testCastTimestamp
```
public void testCastTimestamp()
```

Class DruidAdapterIT2

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

FOODMART

ENABLED

VARCHAR_TYPE

FOODMART_TABLE

Constructor Detail

DruidAdapterIT2

Method Detail

enabled

druidChecker

foodmartApprox

approxQuery

sql

sql

testMetadataColumns

testSelectDistinct

testSelectGroupBySum

testGroupbyMetric

testPushSimpleGroupBy

testComplexPushGroupBy

testSelectCount

testSort

testSortLimit

testOffsetLimit

testLimit

testDistinctLimit

testGroupBySortLimit

testGroupBySingleSortLimit

testGroupBySingleSortLimitApprox

checkGroupBySingleSortLimit

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

testGroupByMetricAndExtractTime

testFilterOnDouble

testPushAggregateOnTime

testPushAggregateOnTimeWithExtractYear

testPushAggregateOnTimeWithExtractMonth

testPushAggregateOnTimeWithExtractDay

testPushAggregateOnTimeWithExtractHourOfDay

testPushAggregateOnTimeWithExtractYearMonthDay

testPushAggregateOnTimeWithExtractYearMonthDayWithOutRenaming

testPushAggregateOnTimeWithExtractWithOutRenaming

testPushComplexFilter

testPushOfFilterExtractionOnDayAndMonth