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 static com.fasterxml.jackson.core.JsonFactory.Feature.CANONICALIZE_FIELD_NAMES;
 import static com.fasterxml.jackson.core.JsonParser.NumberType;
 import static com.fasterxml.jackson.core.JsonToken.END_ARRAY;
 import static com.fasterxml.jackson.core.JsonToken.START_ARRAY;
 import static com.fasterxml.jackson.core.JsonToken.START_OBJECT;
 import static com.fasterxml.jackson.core.JsonToken.VALUE_FALSE;
 import static com.fasterxml.jackson.core.JsonToken.VALUE_NUMBER_FLOAT;
 import static com.fasterxml.jackson.core.JsonToken.VALUE_NUMBER_INT;
 import static com.fasterxml.jackson.core.JsonToken.VALUE_STRING;
 import static com.fasterxml.jackson.core.JsonToken.VALUE_TRUE;
 import static io.airlift.slice.Slices.utf8Slice;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 public final class JsonFunctions
 {
     private static final JsonFactory JSON_FACTORY = new JsonFactory()
             .disable();
 
     private static final JsonFactory MAPPING_JSON_FACTORY = new MappingJsonFactory()
             .disable();
 
     private JsonFunctions() {}
 
     public static JsonPath castToJsonPath(@SqlType(.Slice pattern)
     {
         return new JsonPath(pattern.toString());
     }
 
     public static Slice castToVarchar(@SqlType(.Slice slice)
     {
         return slice;
     }
 
     @Nullable
     @ScalarFunction("json_array_length")
     public static Long varcharJsonArrayLength(@SqlType(.Slice json)
     {
         return jsonArrayLength(json);
     }
 
     @Nullable
     @ScalarFunction
     public static Long jsonArrayLength(@SqlType(.Slice json)
     {
         try (JsonParser parser = .createJsonParser(json.getInput())) {
             if (parser.nextToken() != ) {
                 return null;
             }
 
             long length = 0;
             while (true) {
                 JsonToken token = parser.nextToken();
                 if (token == null) {
                     return null;
                 }
                 if (token == ) {
                     return length;
                 }
                 parser.skipChildren();
 
                 length++;
            }
        }
        catch (IOException e) {
            return null;
        }
    }
    @Nullable
    @ScalarFunction("json_array_contains")
    public static Boolean varcharJsonArrayContains(@SqlType(.Slice json, @SqlType(.boolean value)
    {
        return jsonArrayContains(jsonvalue);
    }
    @Nullable
    public static Boolean jsonArrayContains(@SqlType(.Slice json, @SqlType(.boolean value)
    {
        try (JsonParser parser = .createJsonParser(json.getInput())) {
            if (parser.nextToken() != ) {
                return null;
            }
            while (true) {
                JsonToken token = parser.nextToken();
                if (token == null) {
                    return null;
                }
                if (token == ) {
                    return false;
                }
                parser.skipChildren();
                if (((token == ) && value) ||
                        ((token == ) && (!value))) {
                    return true;
                }
            }
        }
        catch (IOException e) {
            return null;
        }
    }
    @Nullable
    @ScalarFunction("json_array_contains")
    {
        return jsonArrayContains(jsonvalue);
    }
    @Nullable
    public static Boolean jsonArrayContains(@SqlType(.Slice json, @SqlType(.long value)
    {
        try (JsonParser parser = .createJsonParser(json.getInput())) {
            if (parser.nextToken() != ) {
                return null;
            }
            while (true) {
                JsonToken token = parser.nextToken();
                if (token == null) {
                    return null;
                }
                if (token == ) {
                    return false;
                }
                parser.skipChildren();
                if ((token == ) &&
                        ((parser.getNumberType() == .) || (parser.getNumberType() == .)) &&
                        (parser.getLongValue() == value)) {
                    return true;
                }
            }
        }
        catch (IOException e) {
            return null;
        }
    }
    @Nullable
    @ScalarFunction("json_array_contains")
    public static Boolean varcharJsonArrayContains(@SqlType(.Slice json, @SqlType(.double value)
    {
        return jsonArrayContains(jsonvalue);
    }
    @Nullable
    public static Boolean jsonArrayContains(@SqlType(.Slice json, @SqlType(.double value)
    {
        if (!Doubles.isFinite(value)) {
            return false;
        }
        try (JsonParser parser = .createJsonParser(json.getInput())) {
            if (parser.nextToken() != ) {
                return null;
            }
            while (true) {
                JsonToken token = parser.nextToken();
                if (token == null) {
                    return null;
                }
                if (token == ) {
                    return false;
                }
                parser.skipChildren();
                // noinspection FloatingPointEquality
                if ((token == ) && (parser.getDoubleValue() == value) &&
                        (Doubles.isFinite(parser.getDoubleValue()))) {
                    return true;
                }
            }
        }
        catch (IOException e) {
            return null;
        }
    }
    @Nullable
    @ScalarFunction("json_array_contains")
    {
        return jsonArrayContains(jsonvalue);
    }
    @Nullable
    {
        String valueString = value.toString();
        try (JsonParser parser = .createJsonParser(json.getInput())) {
            if (parser.nextToken() != ) {
                return null;
            }
            while (true) {
                JsonToken token = parser.nextToken();
                if (token == null) {
                    return null;
                }
                if (token == ) {
                    return false;
                }
                parser.skipChildren();
                if (token ==  && valueString.equals(parser.getValueAsString())) {
                    return true;
                }
            }
        }
        catch (IOException e) {
            return null;
        }
    }
    @Nullable
    @ScalarFunction("json_array_get")
    public static Slice varcharJsonArrayGet(@SqlType(.Slice json, @SqlType(.long index)
    {
        return jsonArrayGet(jsonindex);
    }
    @Nullable
    public static Slice jsonArrayGet(@SqlType(.Slice json, @SqlType(.long index)
    {
        try (JsonParser parser = .createJsonParser(json.getInput())) {
            if (parser.nextToken() != ) {
                return null;
            }
            List<Stringtokens = null;
            if (index < 0) {
                tokens = new LinkedList<>();
            }
            long count = 0;
            while (true) {
                JsonToken token = parser.nextToken();
                if (token == null) {
                    return null;
                }
                if (token == ) {
                    if (tokens != null && count >= index * -1) {
                        return utf8Slice(tokens.get(0));
                    }
                    return null;
                }
                String arrayElement;
                if (token ==  || token == ) {
                    arrayElement = parser.readValueAsTree().toString();
                }
                else {
                    arrayElement = parser.getValueAsString();
                }
                if (count == index) {
                    return arrayElement == null ? null : utf8Slice(arrayElement);
                }
                if (tokens != null) {
                    tokens.add(arrayElement);
                    if (count >= index * -1) {
                        tokens.remove(0);
                    }
                }
                count++;
            }
        }
        catch (IOException e) {
            return null;
        }
    }
    @ScalarFunction("json_extract_scalar")
    @Nullable
    {
        return JsonExtract.extract(jsonjsonPath.getScalarExtractor());
    }
    @Nullable
    public static Slice jsonExtractScalar(@SqlType(.Slice json, @SqlType(.JsonPath jsonPath)
    {
        return JsonExtract.extract(jsonjsonPath.getScalarExtractor());
    }
    @ScalarFunction("json_extract")
    @Nullable
    {
        return JsonExtract.extract(jsonjsonPath.getObjectExtractor());
    }
    @Nullable
    public static Slice jsonExtract(@SqlType(.Slice json, @SqlType(.JsonPath jsonPath)
    {
        return JsonExtract.extract(jsonjsonPath.getObjectExtractor());
    }
    @ScalarFunction("json_size")
    @Nullable
    public static Long varcharJsonSize(@SqlType(.Slice json, @SqlType(.JsonPath jsonPath)
    {
        return JsonExtract.extract(jsonjsonPath.getSizeExtractor());
    }
    @Nullable
    public static Long jsonSize(@SqlType(.Slice json, @SqlType(.JsonPath jsonPath)
    {
        return JsonExtract.extract(jsonjsonPath.getSizeExtractor());
    }
New to GrepCode? Check out our FAQ X