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.type.TypeUtils.buildStructuralSlice;
 import static java.lang.String.format;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 public final class RegexpFunctions
 {
     private RegexpFunctions()
     {
     }
 
     public static Pattern castToRegexp(@SqlType(.Slice pattern)
     {
         try {
             return Pattern.compile(pattern.toString());
         }
         catch (PatternSyntaxException e) {
             throw new PrestoException(e);
         }
     }
 
     @Description("returns substrings matching a regular expression")
     @ScalarFunction
     public static boolean regexpLike(@SqlType(.Slice source, @SqlType(.Pattern pattern)
     {
         return pattern.matcher(source.toString()).find();
     }
 
     @Description("removes substrings matching a regular expression")
     @ScalarFunction
     public static Slice regexpReplace(@SqlType(.Slice source, @SqlType(.Pattern pattern)
     {
         return regexpReplace(sourcepattern.);
     }
 
     @Description("replaces substrings matching a regular expression by given string")
     @ScalarFunction
     public static Slice regexpReplace(@SqlType(.Slice source, @SqlType(.Pattern pattern, @SqlType(.Slice replacement)
     {
         Matcher matcher = pattern.matcher(source.toString());
         String replaced = matcher.replaceAll(replacement.toString());
         return Slices.copiedBuffer(replaced);
     }
 
     @Description("string(s) extracted using the given pattern")
     @ScalarFunction
     @SqlType("array<varchar>")
     public static Slice regexpExtractAll(@SqlType(.Slice source, @SqlType(.Pattern pattern)
     {
         return regexpExtractAll(sourcepattern, 0);
     }
 
     @Description("group(s) extracted using the given pattern")
     @ScalarFunction
     @SqlType("array<varchar>")
     public static Slice regexpExtractAll(@SqlType(.Slice source, @SqlType(.Pattern pattern, @SqlType(.long group)
     {
         Matcher matcher = pattern.matcher(source.toString());
         validateGroup(groupmatcher);
        BlockBuilder blockBuilder = new VariableWidthBlockBuilder(new BlockBuilderStatus(), 1024);
        while (matcher.find()) {
            String string = matcher.group(Ints.checkedCast(group));
            if (string == null) {
                blockBuilder.appendNull();
            }
            else {
                ..writeString(blockBuilderstring);
            }
        }
        return buildStructuralSlice(blockBuilder);
    }
    @Nullable
    @Description("string extracted using the given pattern")
    public static Slice regexpExtract(@SqlType(.Slice source, @SqlType(.Pattern pattern)
    {
        return regexpExtract(sourcepattern, 0);
    }
    @Nullable
    @Description("returns regex group of extracted string with a pattern")
    public static Slice regexpExtract(@SqlType(.Slice source, @SqlType(.Pattern pattern, @SqlType(.long group)
    {
        Matcher matcher = pattern.matcher(source.toString());
        validateGroup(groupmatcher);
        if (!matcher.find()) {
            return null;
        }
        String extracted = matcher.group(Ints.checkedCast(group));
        if (extracted == null) {
            return null;
        }
        return Slices.utf8Slice(extracted);
    }
    private static void validateGroup(long groupMatcher matcher)
    {
        if (group < 0) {
            throw new PrestoException("Group cannot be negative");
        }
        if (group > matcher.groupCount()) {
            throw new PrestoException(format("Pattern has %d groups. Cannot access group %d"matcher.groupCount(), group));
        }
    }
New to GrepCode? Check out our FAQ X