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 static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT;
 import static com.facebook.presto.util.Failures.checkCondition;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 public final class StringFunctions
 {
     private StringFunctions() {}
 
     @Description("convert Unicode code point to a string")
     @ScalarFunction
     public static Slice chr(@SqlType(.long codepoint)
     {
         char[] utf16 = codePointChars(codepoint);
         ByteBuffer utf8 = .encode(CharBuffer.wrap(utf16));
         return Slices.wrappedBuffer(utf8.array(), 0, utf8.limit());
     }
 
     private static char[] codePointChars(long codepoint)
     {
         try {
             return Character.toChars(Ints.checkedCast(codepoint));
         }
         catch (IllegalArgumentException e) {
             throw new PrestoException("Not a valid Unicode code point: " + codepoint);
         }
     }
 
     @Description("concatenates given strings")
     @ScalarFunction
     public static Slice concat(@SqlType(.Slice str1, @SqlType(.Slice str2)
     {
         Slice concat = Slices.allocate(str1.length() + str2.length());
         concat.setBytes(0, str1);
         concat.setBytes(str1.length(), str2);
         return concat;
     }
 
     @Description("length of the given string")
     @ScalarFunction
     public static long length(@SqlType(.Slice slice)
     {
         return slice.length();
     }
 
     @Description("greedily removes occurrences of a pattern in a string")
     @ScalarFunction
     public static Slice replace(@SqlType(.Slice str, @SqlType(.Slice search)
     {
         return replace(strsearch.);
     }
 
     @Description("greedily replaces occurrences of a pattern with a string")
     @ScalarFunction
     public static Slice replace(@SqlType(.Slice str, @SqlType(.Slice search, @SqlType(.Slice replace)
     {
         String replaced = str.toString().replace(
                 search.toString(),
                 replace.toString());
         return Slices.copiedBuffer(replaced);
     }
 
     @Description("reverses the given string")
     @ScalarFunction
     public static Slice reverse(@SqlType(.Slice slice)
    {
        Slice reverse = Slices.allocate(slice.length());
        for (int i = 0, j = slice.length() - 1; i < slice.length(); i++, j--) {
            reverse.setByte(jslice.getByte(i));
        }
        return reverse;
    }
    @Description("returns index of first occurrence of a substring (or 0 if not found)")
    @ScalarFunction("strpos")
    public static long stringPosition(@SqlType(.Slice string, @SqlType(.Slice substring)
    {
        if (substring.length() > string.length()) {
            return 0;
        }
        for (int i = 0; i <= (string.length() - substring.length()); i++) {
            if (string.equals(isubstring.length(), substring, 0, substring.length())) {
                return i + 1;
            }
        }
        return 0;
    }
    @Description("suffix starting at given index")
    public static Slice substr(@SqlType(.Slice slice, @SqlType(.long start)
    {
        return substr(slicestartslice.length());
    }
    @Description("substring of given length starting at an index")
    public static Slice substr(@SqlType(.Slice slice, @SqlType(.long start, @SqlType(.long length)
    {
        if ((start == 0) || (length <= 0)) {
            return .;
        }
        if (start > 0) {
            // make start zero-based
            start--;
        }
        else {
            // negative start is relative to end of string
            start += slice.length();
            if (start < 0) {
                return .;
            }
        }
        if ((start + length) > slice.length()) {
            length = slice.length() - start;
        }
        if (start >= slice.length()) {
            return .;
        }
        return slice.slice((intstart, (intlength);
    }
    // TODO: Implement a more efficient string search
    @Nullable
    @Description("splits a string by a delimiter and returns the specified field (counting from one)")
    public static Slice splitPart(@SqlType(.Slice string, @SqlType(.Slice delimiter, @SqlType(.long index)
    {
        checkCondition(index > 0, "Index must be greater than zero");
        if (delimiter.length() == 0) {
            if (index > string.length()) {
                // index is too big, null is returned
                return null;
            }
            return string.slice((int) (index - 1), 1);
        }
        int previousIndex = 0;
        int matchCount = 0;
        for (int i = 0; i <= (string.length() - delimiter.length()); i++) {
            if (string.equals(idelimiter.length(), delimiter, 0, delimiter.length())) {
                matchCount++;
                if (matchCount == index) {
                    return string.slice(previousIndexi - previousIndex);
                }
                // noinspection AssignmentToForLoopParameter
                i += (delimiter.length() - 1);
                previousIndex = i + 1;
            }
        }
        if (matchCount == index - 1) {
            // returns last section of the split
            return string.slice(previousIndexstring.length() - previousIndex);
        }
        // index is too big, null is returned
        return null;
    }
    @Description("removes spaces from the beginning of a string")
    @ScalarFunction("ltrim")
    public static Slice leftTrim(@SqlType(.Slice slice)
    {
        int start = firstNonSpace(slice);
        return slice.slice(startslice.length() - start);
    }
    @Description("removes spaces from the end of a string")
    @ScalarFunction("rtrim")
    public static Slice rightTrim(@SqlType(.Slice slice)
    {
        int end = lastNonSpace(slice);
        return slice.slice(0, end + 1);
    }
    @Description("removes spaces from the beginning and end of a string")
    public static Slice trim(@SqlType(.Slice slice)
    {
        int start = firstNonSpace(slice);
        if (start == slice.length()) {
            return .;
        }
        int end = lastNonSpace(slice);
        assert (end >= 0) && (end >= start);
        return slice.slice(start, (end - start) + 1);
    }
    private static int firstNonSpace(Slice slice)
    {
        for (int i = 0; i < slice.length(); i++) {
            if (slice.getByte(i) != ' ') {
                return i;
            }
        }
        return slice.length();
    }
    private static int lastNonSpace(Slice slice)
    {
        for (int i = slice.length() - 1; i >= 0; i--) {
            if (slice.getByte(i) != ' ') {
                return i;
            }
        }
        return -1;
    }
    @Description("converts the alphabets in a string to lower case")
    public static Slice lower(@SqlType(.Slice slice)
    {
        Slice upper = Slices.allocate(slice.length());
        for (int i = 0; i < slice.length(); i++) {
            upper.setByte(i, Ascii.toLowerCase((charslice.getByte(i)));
        }
        return upper;
    }
    @Description("converts all the alphabets in the string to upper case")
    public static Slice upper(@SqlType(.Slice slice)
    {
        Slice upper = Slices.allocate(slice.length());
        for (int i = 0; i < slice.length(); i++) {
            upper.setByte(i, Ascii.toUpperCase((charslice.getByte(i)));
        }
        return upper;
    }
New to GrepCode? Check out our FAQ X