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.operator.aggregation.AggregationMetadata.ParameterMetadata.ParameterType.BLOCK_INDEX;
 import static com.facebook.presto.operator.aggregation.AggregationMetadata.ParameterMetadata.ParameterType.BLOCK_INPUT_CHANNEL;
 import static com.facebook.presto.operator.aggregation.AggregationMetadata.ParameterMetadata.ParameterType.INPUT_CHANNEL;
 import static com.facebook.presto.operator.aggregation.AggregationMetadata.ParameterMetadata.ParameterType.NULLABLE_BLOCK_INPUT_CHANNEL;
 import static com.facebook.presto.operator.aggregation.AggregationMetadata.ParameterMetadata.ParameterType.SAMPLE_WEIGHT;
 import static com.facebook.presto.operator.aggregation.AggregationMetadata.ParameterMetadata.ParameterType.STATE;
 import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature;
 import static com.facebook.presto.util.ImmutableCollectors.toImmutableList;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public class AggregationMetadata
 {
     public static final Set<Class<?>> SUPPORTED_PARAMETER_TYPES = ImmutableSet.of(Block.classlong.classdouble.classboolean.classSlice.class);
 
     private final String name;
     private final List<ParameterMetadatainputMetadata;
     private final MethodHandle inputFunction;
     @Nullable
     private final MethodHandle intermediateInputFunction;
     @Nullable
     private final MethodHandle combineFunction;
     @Nullable
     private final MethodHandle outputFunction;
     private final AccumulatorStateSerializer<?> stateSerializer;
     private final AccumulatorStateFactory<?> stateFactory;
     private final Type outputType;
     private final boolean approximate;
 
     public AggregationMetadata(
             String name,
             List<ParameterMetadatainputMetadata,
             MethodHandle inputFunction,
             @Nullable List<ParameterMetadataintermediateInputMetadata,
             @Nullable MethodHandle intermediateInputFunction,
             @Nullable MethodHandle combineFunction,
             @Nullable MethodHandle outputFunction,
             Class<?> stateInterface,
             AccumulatorStateSerializer<?> stateSerializer,
             AccumulatorStateFactory<?> stateFactory,
             Type outputType,
             boolean approximate)
     {
         this. = checkNotNull(outputType);
         this. = ImmutableList.copyOf(checkNotNull(inputMetadata"inputMetadata is null"));
         checkArgument((intermediateInputFunction == null) == (intermediateInputMetadata == null), "intermediate input parameters must be specified iff an intermediate function is provided");
         if (intermediateInputMetadata != null) {
             this. = ImmutableList.copyOf(intermediateInputMetadata);
         }
         else {
             this. = null;
         }
         this. = checkNotNull(name"name is null");
         this. = checkNotNull(inputFunction"inputFunction is null");
         checkArgument(combineFunction == null || intermediateInputFunction == null"Aggregation cannot have both a combine and a intermediate input method");
         checkArgument(combineFunction != null || intermediateInputFunction != null"Aggregation must have either a combine or a intermediate input method");
         this. = intermediateInputFunction;
         this. = combineFunction;
         this. = outputFunction;
         this. = checkNotNull(stateSerializer"stateSerializer is null");
         this. = checkNotNull(stateFactory"stateFactory is null");
         this. = approximate;
 
        verifyInputFunctionSignature(inputFunctioninputMetadatastateInterface);
        if (intermediateInputFunction != null) {
            checkArgument(countInputChannels(intermediateInputMetadata) == 1, "Intermediate input function may only have one input channel");
            verifyInputFunctionSignature(intermediateInputFunctionintermediateInputMetadatastateInterface);
        }
        if (combineFunction != null) {
            verifyCombineFunction(combineFunctionstateInterface);
        }
        if (approximate) {
            verifyApproximateOutputFunction(outputFunctionstateInterface);
        }
        else {
            verifyExactOutputFunction(outputFunctionstateInterface);
        }
    }
    public Type getOutputType()
    {
        return ;
    }
    {
        return ;
    }
    {
        return ;
    }
    public String getName()
    {
        return ;
    }
    {
        return ;
    }
    @Nullable
    {
        return ;
    }
    @Nullable
    {
        return ;
    }
    @Nullable
    {
        return ;
    }
    {
        return ;
    }
    {
        return ;
    }
    public boolean isApproximate()
    {
        return ;
    }
    private static void verifyInputFunctionSignature(MethodHandle methodList<ParameterMetadataparameterMetadatasClass<?> stateInterface)
    {
        Class<?>[] parameters = method.type().parameterArray();
        checkArgument(stateInterface == parameters[0], "First argument of aggregation input function must be %s"stateInterface.getSimpleName());
        checkArgument(parameters.length > 0, "Aggregation input function must have at least one parameter");
        checkArgument(parameterMetadatas.get(0).getParameterType() == "First parameter must be state");
        for (int i = 1; i < parameters.lengthi++) {
            ParameterMetadata metadata = parameterMetadatas.get(i);
            switch (metadata.getParameterType()) {
                case :
                case :
                    checkArgument(parameters[i] == Block.class"Parameter must be Block if it has @BlockPosition");
                    break;
                case :
                    checkArgument(.contains(parameters[i]), "Unsupported type: %s"parameters[i].getSimpleName());
                    checkArgument(parameters[i] == metadata.getSqlType().getJavaType(),
                            "Expected method %s parameter %s type to be %s (%s)",
                            method,
                            i,
                            metadata.getSqlType().getJavaType().getName(),
                            metadata.getSqlType());
                    break;
                case :
                    checkArgument(parameters[i] == int.class"Block index parameter must be an int");
                    break;
                case :
                    checkArgument(parameters[i] == long.class"Sample weight parameter must be a long");
                    break;
                default:
                    throw new IllegalArgumentException("Unsupported parameter: " + metadata.getParameterType());
            }
        }
    }
    private static void verifyCombineFunction(MethodHandle methodClass<?> stateInterface)
    {
        Class<?>[] parameterTypes = method.type().parameterArray();
        checkArgument(parameterTypes.length == 2 && parameterTypes[0] == stateInterface && parameterTypes[1] == stateInterface"Combine function must have the signature (%s, %s)"stateInterface.getSimpleName(), stateInterface.getSimpleName());
    }
    private static void verifyApproximateOutputFunction(MethodHandle methodClass<?> stateInterface)
    {
        checkNotNull(method"Approximate aggregations must specify an output function");
        Class<?>[] parameterTypes = method.type().parameterArray();
        checkArgument(parameterTypes.length == 3 && parameterTypes[0] == stateInterface && parameterTypes[1] == double.class && parameterTypes[2] == BlockBuilder.class"Output function must have the signature (%s, double, BlockBuilder)"stateInterface.getSimpleName());
    }
    private static void verifyExactOutputFunction(MethodHandle methodClass<?> stateInterface)
    {
        if (method == null) {
            return;
        }
        Class<?>[] parameterTypes = method.type().parameterArray();
        checkArgument(parameterTypes.length == 2 && parameterTypes[0] == stateInterface && parameterTypes[1] == BlockBuilder.class"Output function must have the signature (%s, BlockBuilder)"stateInterface.getSimpleName());
    }
    public static int countInputChannels(List<ParameterMetadatametadatas)
    {
        int parameters = 0;
        for (ParameterMetadata metadata : metadatas) {
            if (metadata.getParameterType() ==  ||
                    metadata.getParameterType() ==  ||
                    metadata.getParameterType() == ) {
                parameters++;
            }
        }
        return parameters;
    }
    public static class ParameterMetadata
    {
        private final ParameterType parameterType;
        private final Type sqlType;
        public ParameterMetadata(ParameterType parameterType)
        {
            this(parameterTypenull);
        }
        public ParameterMetadata(ParameterType parameterTypeType sqlType)
        {
            checkArgument((sqlType == null) == (parameterType ==  || parameterType ==  || parameterType == ),
                    "sqlType must be provided only for input channels");
            this. = parameterType;
            this. = sqlType;
        }
        public static ParameterMetadata fromAnnotations(Annotation[] annotationsString methodNameTypeManager typeManagerboolean sampleWeightAllowed)
        {
            List<AnnotationbaseTypes = Arrays.asList(annotations).stream()
                    .filter(annotation -> annotation instanceof SqlType || annotation instanceof BlockIndex || annotation instanceof SampleWeight)
                    .collect(toImmutableList());
            checkArgument(baseTypes.size() == 1, "Parameter of %s must have exactly one of @SqlType, @BlockIndex, and @SampleWeight"methodName);
            boolean nullable = Arrays.asList(annotations).stream().anyMatch(annotation -> annotation instanceof NullablePosition);
            boolean isBlock = Arrays.asList(annotations).stream().anyMatch(annotation -> annotation instanceof BlockPosition);
            Annotation annotation = baseTypes.get(0);
            checkArgument((!isBlock  && !nullable) || (annotation instanceof SqlType),
                    "%s contains a parameter with @BlockPosition and/or @NullablePosition that is not @SqlType"methodName);
            if (annotation instanceof SqlType) {
                TypeSignature signature = parseTypeSignature(((SqlTypeannotation).value());
                if (isBlock) {
                    if (nullable) {
                        return new ParameterMetadata(typeManager.getType(signature));
                    }
                    else {
                        return new ParameterMetadata(typeManager.getType(signature));
                    }
                }
                else {
                    if (nullable) {
                        throw new IllegalArgumentException(methodName + " contains a parameter with @NullablePosition that is not @BlockPosition");
                    }
                    else {
                        return new ParameterMetadata(typeManager.getType(signature));
                    }
                }
            }
            else if (annotation instanceof BlockIndex) {
                return new ParameterMetadata();
            }
            else if (annotation instanceof SampleWeight) {
                checkArgument(sampleWeightAllowed"@SampleWeight only allowed in approximate aggregations");
                return new ParameterMetadata();
            }
            else {
                throw new IllegalArgumentException("Unsupported annotation: " + annotation);
            }
        }
        public ParameterType getParameterType()
        {
            return ;
        }
        public Type getSqlType()
        {
            return ;
        }
        public enum ParameterType
        {
            INPUT_CHANNEL,
            BLOCK_INPUT_CHANNEL,
            NULLABLE_BLOCK_INPUT_CHANNEL,
            BLOCK_INDEX,
            SAMPLE_WEIGHT,
            STATE
        }
    }
New to GrepCode? Check out our FAQ X