testdiskhashtable.java

derby database source code.good for you.

        dht.close();
    } // end of testOneVariant

    private void testLargeTable( DiskHashtable dht,
                                 int[] keyCols,
                                 DataValueDescriptor[] aRow)
        throws StandardException
    {
        // Add a lot of elements
        // If there are two or more key columns then we will vary the first two key columns, using an approximately
        // square matrix of integer key values. Because the hash generator is commutative key (i,j) hashes into the
        // same bucket as key (j,i), testing the case where different keys hash into the same bucket.
        int key1Count = (keyCols.length > 1) ? ((int) Math.round( Math.sqrt( (double) LOTS_OF_ROWS_COUNT))) : 1;
        int key0Count = (LOTS_OF_ROWS_COUNT + key1Count - 1)/key1Count;

        DataValueDescriptor[] row = new DataValueDescriptor[ aRow.length];
        for( int i = 0; i < row.length; i++)
            row[i] = aRow[i].getClone();
        
        for( int key0Idx = 0; key0Idx < key0Count; key0Idx++)
        {
            row[ keyCols[0]].setValue( key0Idx);
            for( int key1Idx = 0; key1Idx < key1Count; key1Idx++)
            {
                if( keyCols.length > 1)
                    row[ keyCols[1]].setValue( key1Idx);
                Object key = KeyHasher.buildHashKey( row, keyCols);
                if( ! dht.put( key, row))
                {
                    REPORT_FAILURE( "  put returned wrong value for key(" + key0Idx + "," + key1Idx + ")");
                    key0Idx = key0Count;
                    break;
                }
            }
        }
        for( int key0Idx = 0; key0Idx < key0Count; key0Idx++)
        {
            row[ keyCols[0]].setValue( key0Idx);
            for( int key1Idx = 0; key1Idx < key1Count; key1Idx++)
            {
                if( keyCols.length > 1)
                    row[ keyCols[1]].setValue( key1Idx);
                Object key = KeyHasher.buildHashKey( row, keyCols);
                if( ! rowsEqual( dht.get( key), row))
                {
                    REPORT_FAILURE( "  large table get returned wrong value for key(" + key0Idx + "," + key1Idx + ")");
                    key0Idx = key0Count;
                    break;
                }
            }
        }
        BitSet found = new BitSet(key0Count * key1Count);
        Enumeration elements = dht.elements();
        while( elements.hasMoreElements())
        {
            Object el = elements.nextElement();
            if( ! (el instanceof DataValueDescriptor[]))
            {
                REPORT_FAILURE( "  large table enumeration returned wrong element type");
                break;
            }
            DataValueDescriptor[] fetchedRow = (DataValueDescriptor[]) el;
            
            int i = fetchedRow[ keyCols[0]].getInt() * key1Count;
            if( keyCols.length > 1)
                i += fetchedRow[ keyCols[1]].getInt();
            if( i >= key0Count * key1Count)
            {
                REPORT_FAILURE( "  large table enumeration returned invalid element");
                break;
            }
                
            if( found.get(i))
            {
                REPORT_FAILURE( "  large table enumeration returned same element twice");
                break;
            }
            found.set(i);
        }
        for( int i = key0Count * key1Count - 1; i >= 0; i--)
        {
            if( !found.get(i))
            {
                REPORT_FAILURE( "  large table enumeration missed at least one element");
                break;
            }
        }
    } // end of testLargeTable

    private void testElements( boolean removeDups,
                               DiskHashtable dht,
                               int[] keyCols,
                               int rowCount,
                               DataValueDescriptor[][] rows,
                               HashMap simpleHash,
                               boolean[] isDuplicate,
                               boolean[] found)
        throws StandardException
    {
        for( int i = 0; i < rowCount; i++)
            found[i] = false;
        
        for( Enumeration e = dht.elements(); e.hasMoreElements();)
        {
            Object el = e.nextElement();
            if( el == null)
            {
                REPORT_FAILURE( "  table enumeration returned a null element");
                return;
            }
            if( el instanceof DataValueDescriptor[])
                checkElement( (DataValueDescriptor[]) el, rowCount, rows, found);
            else if( el instanceof Vector)
            {
                Vector v = (Vector) el;
                for( int i = 0; i < v.size(); i++)
                    checkElement( (DataValueDescriptor[]) v.get(i), rowCount, rows, found);
            }
            else if( el == null)
            {
                REPORT_FAILURE( "  table enumeration returned an incorrect element type");
                return;
            }
        }
        for( int i = 0; i < rowCount; i++)
        {
            if( (removeDups && isDuplicate[i]))
            {
                if( found[i])
                {
                    REPORT_FAILURE( "  table enumeration did not remove duplicates");
                    return;
                }
            }
            else if( ! found[i])
            {
                REPORT_FAILURE( "  table enumeration missed at least one element");
                return;
            }
        }
    } // end of testElements

    private void checkElement( DataValueDescriptor[] fetchedRow,
                               int rowCount,
                               DataValueDescriptor[][] rows,
                               boolean[] found)
        throws StandardException
    {
        for( int i = 0; i < rowCount; i++)
        {
            if( rowsEqual( fetchedRow, rows[i]))
            {
                if( found[i])
                {
                    REPORT_FAILURE( "  table enumeration returned the same element twice");
                    return;
                }
                found[i] = true;
                return;
            }
        }
        REPORT_FAILURE( "  table enumeration returned an incorrect element");
    } // end of checkElement

    private boolean rowsEqual( Object r1, Object r2)
        throws StandardException
    {
        if( r1 == null)
            return r2 == null;

        if( r1 instanceof DataValueDescriptor[])
        {
            DataValueDescriptor[] row1 = (DataValueDescriptor[]) r1;
            DataValueDescriptor[] row2;
            
            if( r2 instanceof Vector)
            {
                Vector v2 = (Vector) r2;
                if( v2.size() != 1)
                    return false;
                row2 = (DataValueDescriptor[]) v2.elementAt(0);
            }
            else if( r2 instanceof DataValueDescriptor[])
                row2 = (DataValueDescriptor[]) r2;
            else
                return false;
            
            if( row1.length != row2.length)
                return false;
            for( int i = 0; i < row1.length; i++)
            {
                if( ! row1[i].compare( Orderable.ORDER_OP_EQUALS, row2[i], true, true))
                    return false;
            }
            return true;
        }
        if( r1 instanceof Vector)
        {
            if( !(r2 instanceof Vector))
                return false;
            Vector v1 = (Vector) r1;
            Vector v2 = (Vector) r2;
            if( v1.size() != v2.size())
                return false;
            for( int i = v1.size() - 1; i >= 0; i--)
            {
                if( ! rowsEqual( v1.elementAt( i), v2.elementAt(i)))
                    return false;
            }
            return true;
        }
        // What is it then?
        return r1.equals( r2);
    } // end of rowsEqual
}