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.type;
 
 
 
 import static com.facebook.presto.metadata.OperatorType.BETWEEN;
 import static com.facebook.presto.metadata.OperatorType.CAST;
 import static com.facebook.presto.metadata.OperatorType.EQUAL;
 import static com.facebook.presto.metadata.OperatorType.GREATER_THAN;
 import static com.facebook.presto.metadata.OperatorType.GREATER_THAN_OR_EQUAL;
 import static com.facebook.presto.metadata.OperatorType.HASH_CODE;
 import static com.facebook.presto.metadata.OperatorType.LESS_THAN;
 import static com.facebook.presto.metadata.OperatorType.LESS_THAN_OR_EQUAL;
 import static com.facebook.presto.metadata.OperatorType.NOT_EQUAL;
 import static com.facebook.presto.spi.StandardErrorCode.INVALID_CAST_ARGUMENT;
 import static com.fasterxml.jackson.databind.SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS;
 import static java.lang.String.format;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 public final class VarcharOperators
 {
     private static final ObjectMapper SORTED_MAPPER = new ObjectMapperProvider().get().configure(true);
 
     private VarcharOperators()
     {
     }
 
     public static boolean equal(@SqlType(.Slice left, @SqlType(.Slice right)
     {
         return left.equals(right);
     }
 
     public static boolean notEqual(@SqlType(.Slice left, @SqlType(.Slice right)
     {
         return !left.equals(right);
     }
 
     public static boolean lessThan(@SqlType(.Slice left, @SqlType(.Slice right)
     {
         return left.compareTo(right) < 0;
     }
 
     public static boolean lessThanOrEqual(@SqlType(.Slice left, @SqlType(.Slice right)
     {
         return left.compareTo(right) <= 0;
     }
 
     public static boolean greaterThan(@SqlType(.Slice left, @SqlType(.Slice right)
     {
         return left.compareTo(right) > 0;
     }
 
     public static boolean greaterThanOrEqual(@SqlType(.Slice left, @SqlType(.Slice right)
     {
         return left.compareTo(right) >= 0;
     }
 
     public static boolean between(@SqlType(.Slice value, @SqlType(.Slice min, @SqlType(.Slice max)
     {
         return min.compareTo(value) <= 0 && value.compareTo(max) <= 0;
     }
 
    public static boolean castToBoolean(@SqlType(.Slice value)
    {
        if (value.length() == 1) {
            byte character = toUpperCase(value.getByte(0));
            if (character == 'T' || character == '1') {
                return true;
            }
            if (character == 'F' || character == '0') {
                return false;
            }
        }
        if ((value.length() == 4) &&
                (toUpperCase(value.getByte(0)) == 'T') &&
                (toUpperCase(value.getByte(1)) == 'R') &&
                (toUpperCase(value.getByte(2)) == 'U') &&
                (toUpperCase(value.getByte(3)) == 'E')) {
            return true;
        }
        if ((value.length() == 5) &&
                (toUpperCase(value.getByte(0)) == 'F') &&
                (toUpperCase(value.getByte(1)) == 'A') &&
                (toUpperCase(value.getByte(2)) == 'L') &&
                (toUpperCase(value.getByte(3)) == 'S') &&
                (toUpperCase(value.getByte(4)) == 'E')) {
            return false;
        }
        throw new PrestoException(format("Cannot cast '%s' to BOOLEAN"value.toString()));
    }
    private static byte toUpperCase(byte b)
    {
        return isLowerCase(b) ? ((byte) (b - 32)) : b;
    }
    private static boolean isLowerCase(byte b)
    {
        return (b >= 'a') && (b <= 'z');
    }
    public static double castToDouble(@SqlType(.Slice slice)
    {
        try {
            return Double.parseDouble(slice.toString());
        }
        catch (Exception e) {
            throw new PrestoException(format("Can not cast '%s' to DOUBLE"slice.toString()));
        }
    }
    public static long castToBigint(@SqlType(.Slice slice)
    {
        try {
            return Long.parseLong(slice.toString());
        }
        catch (Exception e) {
            throw new PrestoException(format("Can not cast '%s' to BIGINT"slice.toString()));
        }
    }
    public static Slice castToBinary(@SqlType(.Slice slice)
    {
        return slice;
    }
    public static Slice castToJson(@SqlType(.Slice slicethrows IOException
    {
        try {
            byte[] in = slice.getBytes();
            SliceOutput dynamicSliceOutput = new DynamicSliceOutput(in.length);
            .writeValue(dynamicSliceOutput.readValue(inObject.class));
            return dynamicSliceOutput.slice();
        }
        catch (Exception e) {
            throw new PrestoException(format("Cannot cast '%s' to JSON"slice.toStringUtf8()));
        }
    }
    public static long hashCode(@SqlType(.Slice value)
    {
        return value.hashCode();
    }
New to GrepCode? Check out our FAQ X