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.CAST;
 import static com.facebook.presto.metadata.Signature.internalOperator;
 import static com.facebook.presto.metadata.Signature.typeParameter;
 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.Failures.checkCondition;
 import static com.facebook.presto.util.Reflection.methodHandle;
 import static java.lang.String.format;
 
 public final class ArrayJoin
         extends ParametricScalar
 {
     public static final ArrayJoin ARRAY_JOIN = new ArrayJoin();
 
     private static final String FUNCTION_NAME = "array_join";
     private static final String DESCRIPTION = "Concatenates the elements of the given array using a delimiter and an optional string to replace nulls";
     private static final Signature SIGNATURE = new Signature(,  ImmutableList.of(typeParameter("T")), ., ImmutableList.of("array<T>".), falsefalse);
 
     public static class ArrayJoinWithNullReplacement
             extends ParametricScalar
     {
         private final Signature signature = new Signature(, ImmutableList.of(typeParameter("T")), ., ImmutableList.of("array<T>"..), falsefalse);
 
         @Override
         public Signature getSignature()
         {
             return ;
         }
 
         @Override
         public boolean isHidden()
         {
             return false;
         }
 
         @Override
         public boolean isDeterministic()
         {
             return true;
         }
 
         @Override
         public String getDescription()
         {
             return ;
         }
 
         @Override
         public FunctionInfo specialize(Map<StringTypetypesint arityTypeManager typeManagerFunctionRegistry functionRegistry)
         {
             Type type = types.get("T");
             TypeSignature arrayType = parameterizedTypeName(.type.getTypeSignature());
             Signature signature = new Signature(arrayType);
             MethodHandle methodHandle = methodHandle(ArrayJoin.class"arrayJoin"FunctionInfo.classType.classConnectorSession.classSlice.classSlice.classSlice.class);
             return specializeArrayJoin(typesfunctionRegistry, ImmutableList.of(falsefalsefalse), signaturemethodHandle);
         }
     }
 
     @Override
    public Signature getSignature()
    {
        return ;
    }
    @Override
    public boolean isHidden()
    {
        return false;
    }
    @Override
    public boolean isDeterministic()
    {
        return true;
    }
    @Override
    public String getDescription()
    {
        return ;
    }
    @Override
    public FunctionInfo specialize(Map<StringTypetypesint arityTypeManager typeManagerFunctionRegistry functionRegistry)
    {
        Type type = types.get("T");
        Signature signature = new Signature(arrayType);
        MethodHandle methodHandle = methodHandle(ArrayJoin.class"arrayJoin"FunctionInfo.classType.classConnectorSession.classSlice.classSlice.class);
        return specializeArrayJoin(typesfunctionRegistry, ImmutableList.of(falsefalse), signaturemethodHandle);
    }
    private static FunctionInfo specializeArrayJoin(Map<StringTypetypesFunctionRegistry functionRegistryList<BooleannullableArgumentsSignature signatureMethodHandle methodHandle)
    {
        Type type = types.get("T");
        FunctionInfo castFunction = functionRegistry.getExactFunction(internalOperator(.name(), , ImmutableList.of(type.getTypeSignature())));
        if (!(type instanceof UnknownType)) {
            checkCondition(castFunction != null"Input type %s not supported"type);
        }
        return new FunctionInfo(signaturefalsemethodHandle.bindTo(castFunction).bindTo(type), truefalsenullableArguments);
    }
    public static Slice arrayJoin(FunctionInfo castFunctionType elementTypeConnectorSession sessionSlice arraySlice delimiter)
    {
        return arrayJoin(castFunctionelementTypesessionarraydelimiternull);
    }
    public static Slice arrayJoin(FunctionInfo castFunctionType elementTypeConnectorSession sessionSlice arraySlice delimiterSlice nullReplacement)
    {
        Block arrayBlock = readStructuralBlock(array);
        int numElements = arrayBlock.getPositionCount();
        DynamicSliceOutput sliceOutput = new DynamicSliceOutput(array.length());
        Class<?> javaType = elementType.getJavaType();
        Class<?>[] parameters = null;
        MethodHandle castFunctionHandle = null;
        // can be null for the unknown type
        if (castFunction != null) {
            parameters = castFunction.getMethodHandle().type().parameterArray();
            castFunctionHandle = castFunction.getMethodHandle();
        }
        for (int i = 0; i < numElementsi++) {
            if (arrayBlock.isNull(i)) {
                if (nullReplacement != null) {
                    sliceOutput.appendBytes(nullReplacement);
                }
                else {
                    continue;
                }
            }
            else {
                if (javaType == boolean.class) {
                    sliceOutput.appendBytes(invokeCast(parameterscastFunctionHandlesessionelementType.getBoolean(arrayBlocki)));
                }
                else if (javaType == double.class) {
                    sliceOutput.appendBytes(invokeCast(parameterscastFunctionHandlesessionelementType.getDouble(arrayBlocki)));
                }
                else if (javaType == long.class) {
                    sliceOutput.appendBytes(invokeCast(parameterscastFunctionHandlesessionelementType.getLong(arrayBlocki)));
                }
                else if (javaType == Slice.class) {
                    sliceOutput.appendBytes(invokeCast(parameterscastFunctionHandlesessionelementType.getSlice(arrayBlocki)));
                }
                else {
                    throw new PrestoException(format("Unexpected type %s"javaType.getName()));
                }
            }
            if (i != numElements - 1) {
                sliceOutput.appendBytes(delimiter);
            }
        }
        return sliceOutput.slice();
    }
    private static Slice invokeCast(Class<?>[] castFunctionParametersMethodHandle castFunctionHandleConnectorSession sessionObject arg)
    {
        Slice slice;
        try {
            if (castFunctionParameters[0] == ConnectorSession.class) {
                slice = (SlicecastFunctionHandle.invokeWithArguments(sessionarg);
            }
            else {
                slice = (SlicecastFunctionHandle.invokeWithArguments(arg);
            }
        }
        catch (Throwable throwable) {
            throw new PrestoException(format("Error casting array element %s to VARCHAR"arg));
        }
        return slice;
    }
New to GrepCode? Check out our FAQ X