GroupByTest (Apache Derby V10.10 Test Javadoc)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - org.apache.derbyTesting.junit.BaseTestCase
    - - org.apache.derbyTesting.junit.BaseJDBCTestCase
      - org.apache.derbyTesting.functionTests.tests.lang.GroupByTest

All Implemented Interfaces:

junit.framework.Test
```
public class GroupByTest
extends BaseJDBCTestCase
```
Many of these test cases were converted from the old groupBy.sql using the DERBY-2151 SQLToJUnit conversion utility.

Field Summary

Fields
Modifier and Type Field and Description

private static char[] chars

(package private) java.lang.String[] expColNames

(package private) java.lang.String[][] expRS
- Fields inherited from class org.apache.derbyTesting.junit.BaseTestCase
  DEFAULT_DB_DIR, DERBY_LOG, ERRORSTACKTRACEFILE

Fields
Modifier and Type	Field and Description
`private static char[]`	`chars`
`(package private) java.lang.String[]`	`expColNames`
`(package private) java.lang.String[][]`	`expRS`

Constructor Summary

Constructors
Constructor and Description

GroupByTest(java.lang.String name)

Constructors
Constructor and Description
`GroupByTest(java.lang.String name)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private static void`	`assertSetOpErrors(java.lang.String sqlState, java.sql.Statement s, java.lang.String[] queries1, java.lang.String[] queries2)` Try all set operations with queries from `queries1` in the left operand and queries from `queries2` in the right operand.
`private static void`	`createSchemaObjects(java.sql.Statement st)` Creates a variety of tables used by the various GroupBy tests
`private static void`	`doAllSetOperations(java.sql.Statement s, java.lang.String[] queries, java.lang.String[][][] expectedResults)` Try all set operations (UNION [ALL], EXCEPT [ALL], INTERSECT [ALL]) on all combinations of the specified queries.
`private static java.lang.String[][]`	`except(java.util.Collection rows1, java.util.Collection rows2, boolean all)` Find the difference between two collections of rows (each row is a list of strings).
`private static java.lang.String`	`genString(int len)`
`private static java.lang.String[][]`	`intersect(java.util.Collection rows1, java.util.Collection rows2, boolean all)` Find the intersection between two collections of rows (each row is a list of strings).
`private void`	`loadRows()` Load enough rows into the table to get some externalized MaxMinAggregator instances.
`private static java.util.Collection`	`newBagOrSet(boolean bag)` Create a `Collection` that can be used as a bag or a set.
`private static java.util.List`	`resultArrayToList(java.lang.String[][] results)` Return a list of lists containing the same values as the specified array of string arrays.
`static junit.framework.Test`	`suite()`
`void`	`testColumnAliasInGroupByAndHaving()` DERBY-2457: Derby does not support column aliases in the GROUP BY and HAVING clauses.
`void`	`testCorrelatedSubqueryInHavingClause()` correlated subquery in having clause.
`void`	`testDERBY2937()` DERBY-2397 showed incorrect typing of aggregate nodes that lead to a SUBSTR throwing an exception that its position/length were out of range.
`void`	`testDerby3631AggregateInGroupByQuery()` Test aggregate used in group by query.
`void`	`testDerby3904MinMaxOptimization()` DERBY-3904: Min/Max optimization needs to be aware of joins.
`void`	`testDerby4071AggregateOnGroupByColumnInHaving()` Test aggregate function on a GROUP BY column also present in a HAVING clause.
`void`	`testDerby4450()` GROUP BY in an IN-subquery inside HAVING clause whose select list is subset of group by columns.
`void`	`testDerby4698()` HAVING with an aggregate function in presence of join flattening DERBY-4698.
`void`	`testDerby5584()` DISTINCT aggregates in result sets which are opened multiple times.
`void`	`testDerbyOrderByOnAggregate()`
`void`	`testDistinctGroupBy()` DERBY-3613 check combinations of DISTINCT and GROUP BY
`void`	`testGroupByColumnsNotInSelectList()` additional columns in group by list not in select list.
`void`	`testGroupByCorrelatedSubquery()` Test using GROUP BY in a correlated subquery.
`void`	`testGroupByDistinct()` Test GROUP BY and DISTINCT.
`void`	`testGroupByErrors()` Test various invalid GROUP BY statements.
`void`	`testGroupByExpression()` Test the use of a subquery to group by an expression.
`void`	`testGroupByInSubquery()` group by without having in from subquery.
`void`	`testGroupByMaxWithEmptyString()` DERBY-3219: Check that MaxMinAggregator's external format works properly with a string of length 0.
`void`	`testGroupByOrderBy()` Test combinations of GROUP BY and ORDER BY.
`void`	`testGroupByWithAdditionalColumns()` additional columns in group by list not in select list.
`void`	`testGroupByWithAliasToSameName()` DERBY-280: Wrong result from select when aliasing to same name as used in group by
`void`	`testGroupByWithTempTable()` DERBY-578: select with group by on a temp table caused NPE
`void`	`testGroupByWithUsingClause()` DERBY-5613: Queries with group by column not included in the column list for JOIN(INNER or OUTER) with NATURAL or USING does not fail Derby does not replace join columns in the select list with coalesce as suggested by SQL spec, instead it binds the join column with the left table when working with natural left outer join or inner join and it binds the join column with the right table when working with natural right outer join.
`void`	`testGroupByWithVariousDatatypes()` Verify the correct behavior of GROUP BY with various datatypes.
`void`	`testHavingClauseColumnRef()` column references in having clause match columns in group by list.
`void`	`testHavingClauseInSubquery()` group by with having in from subquery.
`void`	`testHavingClauseRestrictions5653()` Tests for Bug 5653 restrictions.
`void`	`testHavingWithInnerJoinDerby3880()`
`void`	`testHavingWithoutGroupBy5920()` bug 5920 test that HAVING without GROUPBY makes one group.
`void`	`testInvalidHavingClauses()` negative tests for selects with a having clause without a group by.
`void`	`testMulticolumnGrouping()` Test multicolumn grouping.
`void`	`testOrderByNonGroupedColumn()` DERBY-2085 check message on order by of non-grouped column
`void`	`testOrNodeInHavingClause()` DERBY-3257 check for correct number of rows returned with or in having clause.
`void`	`testParameterMarkersInHavingClause()` Test parameter markers in the having clause.
`void`	`testSetOperationsAndGroupBy()` Test that GROUP BY can be used in the sub-expressions of set operations (DERBY-3764).
`private static java.lang.String[][]`	`toResultArray(java.util.Collection rows)` Convert a `Collection` of rows to an array of string arrays that can be passed as an argument with expected results to `JDBC.assertUnorderedResultSet(ResultSet,String[][])`.
`private static java.lang.String[][]`	`union(java.util.Collection rows1, java.util.Collection rows2, boolean all)` Find the union between two collections of rows (each row is a list of strings).

Methods inherited from class org.apache.derbyTesting.junit.BaseJDBCTestCase
assertCallError, assertCheckTable, assertCompileError, assertEquals, assertEquals, assertEquals, assertEquivalentDataType, assertErrorCode, assertGetIntError, assertNextError, assertPreparedStatementError, assertSQLExceptionEquals, assertSQLState, assertSQLState, assertStatementError, assertStatementError, assertStatementError, assertStatementError, assertStatementErrorUnordered, assertTableRowCount, assertUpdateCount, assertUpdateCount, assertWarning, checkAllConsistency, checkEstimatedRowCount, closeStatement, commit, createStatement, createStatement, createStatement, dropTable, dropTable, dropView, dropView, emptyStatementCache, getClientTransactionID, getConnection, getDatabaseProperty, getLastSQLException, initializeConnection, openConnection, openDefaultConnection, openDefaultConnection, openDefaultConnection, openUserConnection, prepareCall, prepareCall, prepareCall, prepareStatement, prepareStatement, prepareStatement, prepareStatement, prepareStatement, prepareStatement, rollback, runBare, runBareOverridable, runScript, runScript, runSQLCommands, setAutoCommit, tearDown, usingDB2Client, usingDerbyNetClient, usingEmbedded

Methods inherited from class org.apache.derbyTesting.junit.BaseTestCase
alarm, assertDirectoryDeleted, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertExecJavaCmdAsExpected, assertLaunchedJUnitTestMethod, assertLaunchedJUnitTestMethod, assertSecurityManager, assertThrowableEquals, currentDirectory, execJavaCmd, execJavaCmd, fail, getClassVersionMajor, getEmmaJar, getFailureFolder, getFilesWith, getJavaExecutableName, getSystemProperty, getTestConfiguration, getTestResource, hasInterruptibleIO, isCVM, isIBMJVM, isJ9Platform, isJava5, isJava7, isJava8, isPhoneME, isPlatform, isSunJVM, isWindowsPlatform, openTestResource, println, printStackTrace, readProcessOutput, removeDirectory, removeDirectory, removeFiles, removeSystemProperty, runsWithEmma, runsWithJaCoCo, setSystemProperty, sleep, sleepAtLeastOneTick, traceit

Methods inherited from class junit.framework.TestCase
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, countTestCases, createResult, fail, fail, failNotEquals, failNotSame, failSame, format, getName, run, run, runTest, setName, setUp, toString

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

- Field Detail
  - expRS
```
java.lang.String[][] expRS
```
  - expColNames
```
java.lang.String[] expColNames
```
  - chars
```
private static char[] chars
```
- Constructor Detail
  - GroupByTest
```
public GroupByTest(java.lang.String name)
```
- Method Detail
  - suite
```
public static junit.framework.Test suite()
```
  - createSchemaObjects
```
private static void createSchemaObjects(java.sql.Statement st)
                                 throws java.sql.SQLException
```
    Creates a variety of tables used by the various GroupBy tests
    
    Throws:
    
    java.sql.SQLException
  - testGroupByErrors
```
public void testGroupByErrors()
                       throws java.lang.Exception
```
    Test various invalid GROUP BY statements.
    
    Throws:
    
    java.lang.Exception
  - testGroupByWithVariousDatatypes
```
public void testGroupByWithVariousDatatypes()
                                     throws java.lang.Exception
```
    Verify the correct behavior of GROUP BY with various datatypes.
    
    Throws:
    
    java.lang.Exception
  - testMulticolumnGrouping
```
public void testMulticolumnGrouping()
                             throws java.lang.Exception
```
    Test multicolumn grouping.
    
    Throws:
    
    java.lang.Exception
  - testGroupByExpression
```
public void testGroupByExpression()
                           throws java.lang.Exception
```
    Test the use of a subquery to group by an expression.
    
    Throws:
    
    java.lang.Exception
  - testGroupByCorrelatedSubquery
```
public void testGroupByCorrelatedSubquery()
                                   throws java.lang.Exception
```
    Test using GROUP BY in a correlated subquery.
    
    Throws:
    
    java.lang.Exception
  - testGroupByDistinct
```
public void testGroupByDistinct()
                         throws java.lang.Exception
```
    Test GROUP BY and DISTINCT.
    
    Throws:
    
    java.lang.Exception
  - testGroupByOrderBy
```
public void testGroupByOrderBy()
                        throws java.lang.Exception
```
    Test combinations of GROUP BY and ORDER BY.
    
    Throws:
    
    java.lang.Exception
  - testGroupByInSubquery
```
public void testGroupByInSubquery()
                           throws java.lang.Exception
```
    group by without having in from subquery.
    
    Throws:
    
    java.lang.Exception
  - testGroupByWithAdditionalColumns
```
public void testGroupByWithAdditionalColumns()
                                      throws java.lang.Exception
```
    additional columns in group by list not in select list.
    
    Throws:
    
    java.lang.Exception
  - testParameterMarkersInHavingClause
```
public void testParameterMarkersInHavingClause()
                                        throws java.lang.Exception
```
    Test parameter markers in the having clause.
    
    Throws:
    
    java.lang.Exception
  - testHavingClauseInSubquery
```
public void testHavingClauseInSubquery()
                                throws java.lang.Exception
```
    group by with having in from subquery.
    
    Throws:
    
    java.lang.Exception
  - testCorrelatedSubqueryInHavingClause
```
public void testCorrelatedSubqueryInHavingClause()
                                          throws java.lang.Exception
```
    correlated subquery in having clause.
    
    Throws:
    
    java.lang.Exception
  - testHavingClauseColumnRef
```
public void testHavingClauseColumnRef()
                               throws java.lang.Exception
```
    column references in having clause match columns in group by list.
    
    Throws:
    
    java.lang.Exception
  - testGroupByColumnsNotInSelectList
```
public void testGroupByColumnsNotInSelectList()
                                       throws java.lang.Exception
```
    additional columns in group by list not in select list.
    
    Throws:
    
    java.lang.Exception
  - testInvalidHavingClauses
```
public void testInvalidHavingClauses()
                              throws java.lang.Exception
```
    negative tests for selects with a having clause without a group by.
    
    Throws:
    
    java.lang.Exception
  - testHavingClauseRestrictions5653
```
public void testHavingClauseRestrictions5653()
                                      throws java.lang.Exception
```
    Tests for Bug 5653 restrictions.
    
    Throws:
    
    java.lang.Exception
  - testHavingWithoutGroupBy5920
```
public void testHavingWithoutGroupBy5920()
                                  throws java.lang.Exception
```
    bug 5920 test that HAVING without GROUPBY makes one group.
    
    Throws:
    
    java.lang.Exception
  - testGroupByWithUsingClause
```
public void testGroupByWithUsingClause()
                                throws java.sql.SQLException
```
    DERBY-5613: Queries with group by column not included in the column list for JOIN(INNER or OUTER) with NATURAL or USING does not fail Derby does not replace join columns in the select list with coalesce as suggested by SQL spec, instead it binds the join column with the left table when working with natural left outer join or inner join and it binds the join column with the right table when working with natural right outer join. This causes incorrect GROUP BY and HAVING queries to pass as shown below. The tests below show that GROUP BY and HAVING clauses are able to use a column which is not part of the SELECT list. This happens for USING clause & NATURAL joins with queries using INNER JOINS and OUTER JOINS. When using the JOIN with ON clause, we do not run into this problem because we are expected to qualify the JOIN column with table name in the SELECT list when using thw ON clause.
    
    Throws:
    
    java.sql.SQLException
  - testGroupByWithTempTable
```
public void testGroupByWithTempTable()
                              throws java.sql.SQLException
```
    DERBY-578: select with group by on a temp table caused NPE
    
    Throws:
    
    java.sql.SQLException
  - testHavingWithInnerJoinDerby3880
```
public void testHavingWithInnerJoinDerby3880()
                                      throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - testGroupByWithAliasToSameName
```
public void testGroupByWithAliasToSameName()
                                    throws java.sql.SQLException
```
    DERBY-280: Wrong result from select when aliasing to same name as used in group by
    
    Throws:
    
    java.sql.SQLException
  - testDERBY2937
```
public void testDERBY2937()
                   throws java.sql.SQLException
```
    DERBY-2397 showed incorrect typing of aggregate nodes that lead to a SUBSTR throwing an exception that its position/length were out of range.
    
    Throws:
    
    java.sql.SQLException
  - testDerbyOrderByOnAggregate
```
public void testDerbyOrderByOnAggregate()
                                 throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - testOrNodeInHavingClause
```
public void testOrNodeInHavingClause()
                              throws java.sql.SQLException
```
    DERBY-3257 check for correct number of rows returned with or in having clause.
    
    Throws:
    
    java.sql.SQLException
  - testDistinctGroupBy
```
public void testDistinctGroupBy()
                         throws java.sql.SQLException
```
    DERBY-3613 check combinations of DISTINCT and GROUP BY
    
    Throws:
    
    java.sql.SQLException
  - testOrderByNonGroupedColumn
```
public void testOrderByNonGroupedColumn()
                                 throws java.sql.SQLException
```
    DERBY-2085 check message on order by of non-grouped column
    
    Throws:
    
    java.sql.SQLException
  - testGroupByMaxWithEmptyString
```
public void testGroupByMaxWithEmptyString()
                                   throws java.sql.SQLException
```
    DERBY-3219: Check that MaxMinAggregator's external format works properly with a string of length 0.
    
    Throws:
    
    java.sql.SQLException
  - loadRows
```
private void loadRows()
               throws java.sql.SQLException
```
    Load enough rows into the table to get some externalized MaxMinAggregator instances. To ensure that the values are externalized, we set up this test to run with -Dderby.debug.true=testSort. Note that we load the column 'a' with a string of length 0, because DERBY-3219 occurs when the computed MAX value is a string of length 0.
    
    Throws:
    
    java.sql.SQLException
  - genString
```
private static java.lang.String genString(int len)
```
  - testColumnAliasInGroupByAndHaving
```
public void testColumnAliasInGroupByAndHaving()
                                       throws java.sql.SQLException
```
    DERBY-2457: Derby does not support column aliases in the GROUP BY and HAVING clauses.
    
    Throws:
    
    java.sql.SQLException
  - testSetOperationsAndGroupBy
```
public void testSetOperationsAndGroupBy()
                                 throws java.sql.SQLException
```
    Test that GROUP BY can be used in the sub-expressions of set operations (DERBY-3764).
    
    Throws:
    
    java.sql.SQLException
  - doAllSetOperations
```
private static void doAllSetOperations(java.sql.Statement s,
                                       java.lang.String[] queries,
                                       java.lang.String[][][] expectedResults)
                                throws java.sql.SQLException
```
    Try all set operations (UNION [ALL], EXCEPT [ALL], INTERSECT [ALL]) on all combinations of the specified queries.
    
    Parameters:
    
    s - the statement used to execute the queries
    
    queries - the different queries to use, all of which must be union compatible
    
    expectedResults - the expected results from the different queries
    
    Throws:
    
    java.sql.SQLException
  - assertSetOpErrors
```
private static void assertSetOpErrors(java.lang.String sqlState,
                                      java.sql.Statement s,
                                      java.lang.String[] queries1,
                                      java.lang.String[] queries2)
                               throws java.sql.SQLException
```
    Try all set operations with queries from queries1 in the left operand and queries from queries2 in the right operand. All the set operations are expected to fail with the same SQLState.
    
    Parameters:
    
    sqlState - the expected SQLState
    
    s - the statement used to execute the queries
    
    queries1 - queries to use as the left operand
    
    queries2 - queries to use as the right operand
    
    Throws:
    
    java.sql.SQLException
  - union
```
private static java.lang.String[][] union(java.util.Collection rows1,
                                          java.util.Collection rows2,
                                          boolean all)
```
    Find the union between two collections of rows (each row is a list of strings). Return the union as an array of string arrays.
    
    Parameters:
    
    rows1 - the first collection of rows
    
    rows2 - the second collection of rows
    
    all - whether or not bag semantics (as in UNION ALL) should be used instead of set semantics
    
    Returns:
    
    the union of rows1 and rows2, as a String[][]
  - except
```
private static java.lang.String[][] except(java.util.Collection rows1,
                                           java.util.Collection rows2,
                                           boolean all)
```
    Find the difference between two collections of rows (each row is a list of strings). Return the difference as an array of string arrays.
    
    Parameters:
    
    rows1 - the first operand to the set difference operator
    
    rows2 - the second operand to the set difference operator
    
    all - whether or not bag semantics (as in EXCEPT ALL) should be used instead of set semantics
    
    Returns:
    
    the difference between rows1 and rows2, as a String[][]
  - intersect
```
private static java.lang.String[][] intersect(java.util.Collection rows1,
                                              java.util.Collection rows2,
                                              boolean all)
```
    Find the intersection between two collections of rows (each row is a list of strings). Return the intersection as an array of string arrays.
    
    Parameters:
    
    rows1 - the first collection of rows
    
    rows2 - the second collection of rows
    
    all - whether or not bag semantics (as in INTERSECT ALL) should be used instead of set semantics
    
    Returns:
    
    the intersection between rows1 and rows2, as a String[][]
  - newBagOrSet
```
private static java.util.Collection newBagOrSet(boolean bag)
```
    Create a Collection that can be used as a bag or a set.
    
    Parameters:
    
    bag - tells whether or not the collection should be a bag
    
    Returns:
    
    a List if a bag is requested, or a Set otherwise
  - toResultArray
```
private static java.lang.String[][] toResultArray(java.util.Collection rows)
```
    Convert a Collection of rows to an array of string arrays that can be passed as an argument with expected results to JDBC.assertUnorderedResultSet(ResultSet,String[][]).
    
    Parameters:
    
    rows - a collection of rows, where each row is a list of strings
    
    Returns:
    
    a String[][] containing the same values as rows
  - resultArrayToList
```
private static java.util.List resultArrayToList(java.lang.String[][] results)
```
    Return a list of lists containing the same values as the specified array of string arrays. This method can be used to make it easier to perform set operations on a two-dimensional array of strings.
    
    Parameters:
    
    results - a two dimensional array of strings (typically expected results from a query}
    
    Returns:
    
    the values of results in a list of lists
  - testDerby3904MinMaxOptimization
```
public void testDerby3904MinMaxOptimization()
                                     throws java.sql.SQLException
```
    DERBY-3904: Min/Max optimization needs to be aware of joins.
    
    Throws:
    
    java.sql.SQLException
  - testDerby3631AggregateInGroupByQuery
```
public void testDerby3631AggregateInGroupByQuery()
                                          throws java.sql.SQLException
```
    Test aggregate used in group by query.
    
    Throws:
    
    java.sql.SQLException
  - testDerby4071AggregateOnGroupByColumnInHaving
```
public void testDerby4071AggregateOnGroupByColumnInHaving()
                                                   throws java.sql.SQLException
```
    Test aggregate function on a GROUP BY column also present in a HAVING clause. Iff the GROUP BY column is not the first column in the table, this would fail before DERBY-4071 was fixed.
    
    Throws:
    
    java.sql.SQLException
  - testDerby4450
```
public void testDerby4450()
                   throws java.sql.SQLException
```
    GROUP BY in an IN-subquery inside HAVING clause whose select list is subset of group by columns.
    
    Throws:
    
    java.sql.SQLException
  - testDerby4698
```
public void testDerby4698()
                   throws java.sql.SQLException
```
    HAVING with an aggregate function in presence of join flattening DERBY-4698. See also DERBY-3880.
    
    Throws:
    
    java.sql.SQLException
  - testDerby5584
```
public void testDerby5584()
                   throws java.sql.SQLException
```
    DISTINCT aggregates in result sets which are opened multiple times. DERBY-5584.
    
    Throws:
    
    java.sql.SQLException

Class GroupByTest

Field Summary

Fields inherited from class org.apache.derbyTesting.junit.BaseTestCase

Constructor Summary

Method Summary

Methods inherited from class org.apache.derbyTesting.junit.BaseJDBCTestCase

Methods inherited from class org.apache.derbyTesting.junit.BaseTestCase

Methods inherited from class junit.framework.TestCase

Methods inherited from class java.lang.Object

Field Detail

expRS

expColNames

chars

Constructor Detail

GroupByTest

Method Detail

suite

createSchemaObjects

testGroupByErrors

testGroupByWithVariousDatatypes

testMulticolumnGrouping

testGroupByExpression

testGroupByCorrelatedSubquery

testGroupByDistinct

testGroupByOrderBy

testGroupByInSubquery

testGroupByWithAdditionalColumns

testParameterMarkersInHavingClause

testHavingClauseInSubquery

testCorrelatedSubqueryInHavingClause

testHavingClauseColumnRef

testGroupByColumnsNotInSelectList

testInvalidHavingClauses

testHavingClauseRestrictions5653

testHavingWithoutGroupBy5920

testGroupByWithUsingClause

testGroupByWithTempTable

testHavingWithInnerJoinDerby3880

testGroupByWithAliasToSameName

testDERBY2937

testDerbyOrderByOnAggregate

testOrNodeInHavingClause

testDistinctGroupBy

testOrderByNonGroupedColumn

testGroupByMaxWithEmptyString

loadRows

genString

testColumnAliasInGroupByAndHaving

testSetOperationsAndGroupBy

doAllSetOperations

assertSetOpErrors

union

except

intersect

newBagOrSet

toResultArray

resultArrayToList

testDerby3904MinMaxOptimization

testDerby3631AggregateInGroupByQuery

testDerby4071AggregateOnGroupByColumnInHaving

testDerby4450

testDerby4698

testDerby5584