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.Signature.orderableTypeParameter;
 import static com.facebook.presto.type.TypeUtils.readStructuralBlock;
 import static com.facebook.presto.type.TypeUtils.buildStructuralSlice;
 import static com.facebook.presto.type.TypeUtils.parameterizedTypeName;
 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 ArraySortFunction
         extends ParametricScalar
 {
     public static final ArraySortFunction ARRAY_SORT_FUNCTION = new ArraySortFunction();
     private static final String FUNCTION_NAME = "array_sort";
     private static final Signature SIGNATURE = new Signature(, ImmutableList.of(orderableTypeParameter("E")), "array<E>", ImmutableList.of("array<E>"), falsefalse);
     private static final MethodHandle METHOD_HANDLE = methodHandle(ArraySortFunction.class"sort"Type.classSlice.class);
 
     @Override
     public Signature getSignature()
     {
         return ;
     }
 
     @Override
     public boolean isHidden()
     {
         return false;
     }
 
     @Override
     public boolean isDeterministic()
     {
         return true;
     }
 
     @Override
     public String getDescription()
     {
         return "Sorts the given array in ascending order according to the natural ordering of its elements.";
     }
 
     @Override
     public FunctionInfo specialize(Map<StringTypetypesint arityTypeManager typeManagerFunctionRegistry functionRegistry)
     {
         checkArgument(types.size() == 1, format("%s expects only one argument"));
         Type type = types.get("E");
         MethodHandle methodHandle = .bindTo(type);
         Signature signature = new Signature(,
                 parameterizedTypeName("array"type.getTypeSignature()),
                 parameterizedTypeName("array"type.getTypeSignature()));
         return new FunctionInfo(signaturegetDescription(), isHidden(), methodHandleisDeterministic(), false, ImmutableList.of(false));
     }
 
     public static Slice sort(Type typeSlice encodedArray)
     {
         Block block = readStructuralBlock(encodedArray);
 
         List<Integerpositions = Ints.asList(new int[block.getPositionCount()]);
         for (int i = 0; i < block.getPositionCount(); i++) {
             positions.set(ii);
         }
 
         Collections.sort(positionsnew Comparator<Integer>()
         {
             @Override
            public int compare(Integer p1Integer p2)
            {
                //TODO: This could be quite slow, it should use parametric equals
                return type.compareTo(blockp1blockp2);
            }
        });
        BlockBuilder blockBuilder = new VariableWidthBlockBuilder(new BlockBuilderStatus(), block.getSizeInBytes());
        for (int position : positions) {
            type.appendTo(blockpositionblockBuilder);
        }
        return buildStructuralSlice(blockBuilder);
    }
New to GrepCode? Check out our FAQ X