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.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT;
 import static com.facebook.presto.type.ArrayType.toStackRepresentation;
 import static com.facebook.presto.type.TypeJsonUtils.createBlock;
 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);
     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapperProvider().get();
     private static final CollectionType COLLECTION_TYPE = .getTypeFactory().constructCollectionType(List.classObject.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(final Type typeSlice jsonArray)
     {
         List<Objectelements;
         try {
             elements = .readValue(jsonArray.getInput(), );
         }
         catch (IOException e) {
             throw new PrestoException(e);
         }
        Collections.sort(elementsnew Comparator<Object>()
        {
            @Override
            public int compare(Object o1Object o2)
            {
                return type.compareTo(createBlock(typeo1), 0, createBlock(typeo2), 0);
            }
        });
        return toStackRepresentation(elements);
    }
New to GrepCode? Check out our FAQ X