Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.operator.aggregation;
 
 
 import java.util.List;
 import java.util.Set;
 
 import static com.facebook.presto.spi.type.DoubleType.DOUBLE;
 import static io.airlift.testing.Assertions.assertLessThan;
 import static org.testng.Assert.assertEquals;
 
 public abstract class AbstractTestApproximateCountDistinct
 {
 
     public abstract Type getValueType();
 
     public abstract Object randomValue();
 
     @DataProvider(name = "provideStandardErrors")
     public Object[][] provideStandardErrors()
     {
         return new Object[][] {
                 { 0.0230 }, // 2k buckets
                 { 0.0115 }, // 8k buckets
         };
     }
 
     @Test(dataProvider = "provideStandardErrors")
     public void testNoPositions(double maxStandardError)
             throws Exception
     {
         assertCount(ImmutableList.of(), maxStandardError, 0);
     }
 
     @Test(dataProvider = "provideStandardErrors")
     public void testSinglePosition(double maxStandardError)
             throws Exception
     {
         assertCount(ImmutableList.of(randomValue()), maxStandardError, 1);
     }
 
     @Test(dataProvider = "provideStandardErrors")
     public void testAllPositionsNull(double maxStandardError)
             throws Exception
     {
         assertCount(Collections.nCopies(100, null), maxStandardError, 0);
     }
 
     @Test(dataProvider = "provideStandardErrors")
     public void testMixedNullsAndNonNulls(double maxStandardError)
             throws Exception
     {
         List<Objectbaseline = createRandomSample(10000, 15000);
 
         // Randomly insert nulls
         // We need to retain the preexisting order to ensure that the HLL can generate the same estimates.
         Iterator<Objectiterator = baseline.iterator();
         List<Objectmixed = new ArrayList<>();
         while (iterator.hasNext()) {
             mixed.add(ThreadLocalRandom.current().nextBoolean() ? null : iterator.next());
         }
 
         assertCount(mixedmaxStandardErrorestimateGroupByCount(baselinemaxStandardError));
     }
 
     @Test(dataProvider = "provideStandardErrors")
     public void testMultiplePositions(double maxStandardError)
             throws Exception
     {
        DescriptiveStatistics stats = new DescriptiveStatistics();
        for (int i = 0; i < 500; ++i) {
            int uniques = ThreadLocalRandom.current().nextInt(20000) + 1;
            List<Objectvalues = createRandomSample(uniques, (int) (uniques * 1.5));
            long actual = estimateGroupByCount(valuesmaxStandardError);
            double error = (actual - uniques) * 1.0 / uniques;
            stats.addValue(error);
        }
        assertLessThan(stats.getMean(), 1.0e-2);
        assertLessThan(Math.abs(stats.getStandardDeviation() - maxStandardError), 1.0e-2);
    }
    @Test(dataProvider = "provideStandardErrors")
    public void testMultiplePositionsPartial(double maxStandardError)
            throws Exception
    {
        for (int i = 0; i < 100; ++i) {
            int uniques = ThreadLocalRandom.current().nextInt(20000) + 1;
            List<Objectvalues = createRandomSample(uniques, (int) (uniques * 1.5));
            assertEquals(estimateCountPartial(valuesmaxStandardError), estimateGroupByCount(valuesmaxStandardError));
        }
    }
    private void assertCount(List<Objectvaluesdouble maxStandardErrorlong expectedCount)
    {
        if (!values.isEmpty()) {
            assertEquals(estimateGroupByCount(valuesmaxStandardError), expectedCount);
        }
        assertEquals(estimateCount(valuesmaxStandardError), expectedCount);
        assertEquals(estimateCountPartial(valuesmaxStandardError), expectedCount);
    }
    private long estimateGroupByCount(List<Objectvaluesdouble maxStandardError)
    {
        Object result = AggregationTestUtils.groupedAggregation(getAggregationFunction(), 1.0, createPage(valuesmaxStandardError));
        return (longresult;
    }
    private long estimateCount(List<Objectvaluesdouble maxStandardError)
    {
        Object result = AggregationTestUtils.aggregation(getAggregationFunction(), 1.0, createPage(valuesmaxStandardError));
        return (longresult;
    }
    private long estimateCountPartial(List<Objectvaluesdouble maxStandardError)
    {
        Object result = AggregationTestUtils.partialAggregation(getAggregationFunction(), 1.0, createPage(valuesmaxStandardError));
        return (longresult;
    }
    private Page createPage(List<Objectvaluesdouble maxStandardError)
    {
        if (values.isEmpty()) {
            return new Page(0);
        }
        else {
            return new Page(values.size(),
                    createBlock(getValueType(), values),
                    createBlock(, ImmutableList.copyOf(Collections.nCopies(values.size(), maxStandardError))));
        }
    }

    
Produce a block with the given values in the last field.
    private static Block createBlock(Type typeList<Objectvalues)
    {
        BlockBuilder blockBuilder = type.createBlockBuilder(new BlockBuilderStatus(), values.size());
        for (Object value : values) {
            Class<?> javaType = type.getJavaType();
            if (value == null) {
                blockBuilder.appendNull();
            }
            else if (javaType == boolean.class) {
                type.writeBoolean(blockBuilder, (Booleanvalue);
            }
            else if (javaType == long.class) {
                type.writeLong(blockBuilder, (Longvalue);
            }
            else if (javaType == double.class) {
                type.writeDouble(blockBuilder, (Doublevalue);
            }
            else if (javaType == Slice.class) {
                Slice slice = (Slicevalue;
                type.writeSlice(blockBuilderslice, 0, slice.length());
            }
            else {
                throw new UnsupportedOperationException("not yet implemented: " + javaType);
            }
        }
        return blockBuilder.build();
    }
    private List<ObjectcreateRandomSample(int uniquesint total)
    {
        Preconditions.checkArgument(uniques <= total"uniques (%s) must be <= total (%s)"uniquestotal);
        List<Objectresult = new ArrayList<>(total);
        result.addAll(makeRandomSet(uniques));
        Random random = ThreadLocalRandom.current();
        while (result.size() < total) {
            int index = random.nextInt(result.size());
            result.add(result.get(index));
        }
        return result;
    }
    private Set<ObjectmakeRandomSet(int count)
    {
        Set<Objectresult = new HashSet<>();
        while (result.size() < count) {
            result.add(randomValue());
        }
        return result;
    }
New to GrepCode? Check out our FAQ X