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.scalar;
 
 
 import java.util.List;
 import java.util.Map;
 
 import static com.facebook.presto.metadata.OperatorType.EQUAL;
 import static com.facebook.presto.metadata.Signature.comparableTypeParameter;
 import static com.facebook.presto.spi.StandardErrorCode.INTERNAL_ERROR;
 import static com.facebook.presto.type.TypeUtils.buildStructuralSlice;
 import static com.facebook.presto.type.TypeUtils.castValue;
 import static com.facebook.presto.type.TypeUtils.parameterizedTypeName;
 import static com.facebook.presto.type.TypeUtils.readStructuralBlock;
 import static com.facebook.presto.util.Reflection.methodHandle;
 import static com.google.common.base.Preconditions.checkArgument;
 import static java.lang.String.format;
 
 public final class ArrayRemoveFunction
         extends ParametricScalar
 {
     public static final ArrayRemoveFunction ARRAY_REMOVE_FUNCTION = new ArrayRemoveFunction();
     private static final String FUNCTION_NAME = "array_remove";
     private static final Signature SIGNATURE = new Signature(, ImmutableList.of(comparableTypeParameter("E")), "array<E>", ImmutableList.of("array<E>""E"), falsefalse);
 
     @Override
     public Signature getSignature()
     {
         return ;
     }
 
     @Override
     public boolean isHidden()
     {
         return false;
     }
 
     @Override
     public boolean isDeterministic()
     {
         return true;
     }
 
     @Override
     public String getDescription()
     {
         return "Remove specified values from the given array";
     }
 
     @Override
     public FunctionInfo specialize(Map<StringTypetypesint arityTypeManager typeManagerFunctionRegistry functionRegistry)
     {
         checkArgument(types.size() == 1, format("%s expects only one argument"));
         Type type = types.get("E");
         TypeSignature valueType = type.getTypeSignature();
         TypeSignature arrayType = parameterizedTypeName(.valueType);
 
         MethodHandle equalsFunction = functionRegistry.resolveOperator(, ImmutableList.of(typetype)).getMethodHandle();
         MethodHandle baseMethodHandle = methodHandle(ArrayRemoveFunction.class"remove"MethodHandle.classType.classSlice.classtype.getJavaType());
         MethodHandle methodHandle = baseMethodHandle.bindTo(equalsFunction).bindTo(type);
         Signature signature = new Signature(arrayTypearrayTypevalueType);
         return new FunctionInfo(signaturegetDescription(), isHidden(), methodHandleisDeterministic(), false, ImmutableList.of(falsefalse));
     }
 
     public static Slice remove(MethodHandle equalsFunctionType typeSlice arraySlice value)
     {
         return remove(equalsFunctiontypearray, (Objectvalue);
     }
 
    public static Slice remove(MethodHandle equalsFunctionType typeSlice arraylong value)
    {
        return remove(equalsFunctiontypearray, (Objectvalue);
    }
    public static Slice remove(MethodHandle equalsFunctionType typeSlice arraydouble value)
    {
        return remove(equalsFunctiontypearray, (Objectvalue);
    }
    public static Slice remove(MethodHandle equalsFunctionType typeSlice arrayboolean value)
    {
        return remove(equalsFunctiontypearray, (Objectvalue);
    }
    private static Slice remove(MethodHandle equalsFunctionType typeSlice arrayObject value)
    {
        Block elementsBlock = readStructuralBlock(array);
        int sizeAfterRemove = 0;
        List<Integerpositions = new ArrayList<>();
        for (int i = 0; i < elementsBlock.getPositionCount(); i++) {
            Object element = castValue(typeelementsBlocki);
            try {
                if (element == null || !(booleanequalsFunction.invoke(elementvalue)) {
                    positions.add(i);
                    sizeAfterRemove += elementsBlock.getLength(i);
                }
            }
            catch (Throwable t) {
                Throwables.propagateIfInstanceOf(tError.class);
                Throwables.propagateIfInstanceOf(tPrestoException.class);
                throw new PrestoException(t);
            }
        }
        if (elementsBlock.getPositionCount() == positions.size()) {
            return array;
        }
        BlockBuilder blockBuilder = new VariableWidthBlockBuilder(new BlockBuilderStatus(), sizeAfterRemove);
        for (int position : positions) {
            type.appendTo(elementsBlockpositionblockBuilder);
        }
        return buildStructuralSlice(blockBuilder);
    }
New to GrepCode? Check out our FAQ X