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.Map;
 
 import static com.facebook.presto.metadata.Signature.comparableTypeParameter;
 import static com.facebook.presto.spi.StandardErrorCode.INTERNAL_ERROR;
 import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT;
 import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature;
 import static com.facebook.presto.type.TypeUtils.parameterizedTypeName;
 import static com.facebook.presto.type.TypeUtils.readStructuralBlock;
 import static com.facebook.presto.util.Reflection.methodHandle;
 
 public final class ArrayPositionFunction
         extends ParametricScalar
 {
     public static final ArrayPositionFunction ARRAY_POSITION = new ArrayPositionFunction();
     private static final Signature SIGNATURE = new Signature("array_position", ImmutableList.of(comparableTypeParameter("E")), "bigint", ImmutableList.of("array<E>""E"), falsefalse);
     private static final MethodHandle METHOD_HANDLE_BOOLEAN = methodHandle(ArrayPositionFunction.class"arrayPosition"Type.classMethodHandle.classSlice.classboolean.class);
     private static final MethodHandle METHOD_HANDLE_LONG = methodHandle(ArrayPositionFunction.class"arrayPosition"Type.classMethodHandle.classSlice.classlong.class);
     private static final MethodHandle METHOD_HANDLE_DOUBLE = methodHandle(ArrayPositionFunction.class"arrayPosition"Type.classMethodHandle.classSlice.classdouble.class);
     private static final MethodHandle METHOD_HANDLE_SLICE = methodHandle(ArrayPositionFunction.class"arrayPosition"Type.classMethodHandle.classSlice.classSlice.class);
 
     @Override
     public Signature getSignature()
     {
         return ;
     }
 
     @Override
     public boolean isHidden()
     {
         return false;
     }
 
     @Override
     public boolean isDeterministic()
     {
         return true;
     }
 
     @Override
     public String getDescription()
     {
         return "Returns the position of the first occurrence of the given value in array (or 0 if not found)";
     }
 
     @Override
     public FunctionInfo specialize(Map<StringTypetypesint arityTypeManager typeManagerFunctionRegistry functionRegistry)
     {
         Type type = types.get("E");
         MethodHandle equalMethodHandle = functionRegistry.resolveOperator(., ImmutableList.of(typetype)).getMethodHandle();
         MethodHandle arrayPositionMethodHandle;
         if (type.getJavaType() == boolean.class) {
             arrayPositionMethodHandle = ;
         }
         else if (type.getJavaType() == long.class) {
             arrayPositionMethodHandle = ;
         }
         else if (type.getJavaType() == double.class) {
             arrayPositionMethodHandle = ;
         }
         else if (type.getJavaType() == Slice.class) {
             arrayPositionMethodHandle = ;
         }
         else {
             throw new PrestoException("Argument type to array_position unsupported");
         }
         return new FunctionInfo(
                 new Signature("array_position"parseTypeSignature(.), parameterizedTypeName("array"type.getTypeSignature()), type.getTypeSignature()),
                 getDescription(),
                 isHidden(),
                arrayPositionMethodHandle.bindTo(type).bindTo(equalMethodHandle),
                isDeterministic(),
                false,
                ImmutableList.of(falsefalse));
    }
    public static long arrayPosition(Type typeMethodHandle equalMethodHandleSlice arrayboolean element)
    {
        Block block = readStructuralBlock(array);
        int size = block.getPositionCount();
        for (int i = 0; i < sizei++) {
            if (!block.isNull(i)) {
                boolean arrayValue = type.getBoolean(blocki);
                try {
                    if ((booleanequalMethodHandle.invokeExact(arrayValueelement)) {
                        return i + 1; // result is 1-based (instead of 0)
                    }
                }
                catch (Throwable t) {
                    Throwables.propagateIfInstanceOf(tError.class);
                    Throwables.propagateIfInstanceOf(tPrestoException.class);
                    throw new PrestoException(t);
                }
            }
        }
        return 0;
    }
    public static long arrayPosition(Type typeMethodHandle equalMethodHandleSlice arraylong element)
    {
        Block block = readStructuralBlock(array);
        int size = block.getPositionCount();
        for (int i = 0; i < sizei++) {
            if (!block.isNull(i)) {
                long arrayValue = type.getLong(blocki);
                try {
                    if ((booleanequalMethodHandle.invokeExact(arrayValueelement)) {
                        return i + 1; // result is 1-based (instead of 0)
                    }
                }
                catch (Throwable t) {
                    Throwables.propagateIfInstanceOf(tError.class);
                    Throwables.propagateIfInstanceOf(tPrestoException.class);
                    throw new PrestoException(t);
                }
            }
        }
        return 0;
    }
    public static long arrayPosition(Type typeMethodHandle equalMethodHandleSlice arraydouble element)
    {
        Block block = readStructuralBlock(array);
        int size = block.getPositionCount();
        for (int i = 0; i < sizei++) {
            if (!block.isNull(i)) {
                double arrayValue = type.getDouble(blocki);
                try {
                    if ((booleanequalMethodHandle.invokeExact(arrayValueelement)) {
                        return i + 1; // result is 1-based (instead of 0)
                    }
                }
                catch (Throwable t) {
                    Throwables.propagateIfInstanceOf(tError.class);
                    Throwables.propagateIfInstanceOf(tPrestoException.class);
                    throw new PrestoException(t);
                }
            }
        }
        return 0;
    }
    public static long arrayPosition(Type typeMethodHandle equalMethodHandleSlice arraySlice element)
    {
        Block block = readStructuralBlock(array);
        int size = block.getPositionCount();
        for (int i = 0; i < sizei++) {
            if (!block.isNull(i)) {
                Slice arrayValue = type.getSlice(blocki);
                try {
                    if ((booleanequalMethodHandle.invokeExact(arrayValueelement)) {
                        return i + 1; // result is 1-based (instead of 0)
                    }
                }
                catch (Throwable t) {
                    Throwables.propagateIfInstanceOf(tError.class);
                    Throwables.propagateIfInstanceOf(tPrestoException.class);
                    throw new PrestoException(t);
                }
            }
        }
        return 0;
    }
New to GrepCode? Check out our FAQ X