Transpile simple choice-type regular expressions into lists of choices to use with string replace multi #7967
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -16,10 +16,18 @@ | |
| package com.nvidia.spark.rapids | ||
|
|
||
| import org.apache.spark.sql.catalyst.expressions.{Expression, Literal, RegExpReplace} | ||
| import org.apache.spark.sql.rapids.{GpuRegExpReplace, GpuRegExpReplaceWithBackref, GpuRegExpUtils} | ||
| import org.apache.spark.sql.types.DataTypes | ||
| import org.apache.spark.unsafe.types.UTF8String | ||
|
|
||
| trait GpuRegExpReplaceOpt extends Serializable | ||
|
|
||
| @SerialVersionUID(100L) | ||
| object GpuRegExpStringReplace extends GpuRegExpReplaceOpt | ||
|
|
||
| @SerialVersionUID(100L) | ||
| object GpuRegExpStringReplaceMulti extends GpuRegExpReplaceOpt | ||
|
|
||
| class GpuRegExpReplaceMeta( | ||
| expr: RegExpReplace, | ||
| conf: RapidsConf, | ||
|
|
@@ -30,37 +38,44 @@ class GpuRegExpReplaceMeta( | |
| private var javaPattern: Option[String] = None | ||
| private var cudfPattern: Option[String] = None | ||
| private var replacement: Option[String] = None | ||
| private var searchList: Option[Seq[String]] = None | ||
| private var replaceOpt: Option[GpuRegExpReplaceOpt] = None | ||
| private var containsBackref: Boolean = false | ||
|
|
||
| override def tagExprForGpu(): Unit = { | ||
| replacement = expr.rep match { | ||
| case Literal(s: UTF8String, DataTypes.StringType) if s != null => Some(s.toString) | ||
| case _ => None | ||
| } | ||
|
|
||
| expr.regexp match { | ||
| case Literal(s: UTF8String, DataTypes.StringType) if s != null => | ||
| javaPattern = Some(s.toString()) | ||
| try { | ||
| val (pat, repl) = | ||
| new CudfRegexTranspiler(RegexReplaceMode).getTranspiledAST(s.toString, None, | ||
| replacement) | ||
| repl.map { r => GpuRegExpUtils.backrefConversion(r.toRegexString) }.foreach { | ||
| case (hasBackref, convertedRep) => | ||
| containsBackref = hasBackref | ||
| replacement = Some(GpuRegExpUtils.unescapeReplaceString(convertedRep)) | ||
| } | ||
| if (!containsBackref && GpuOverrides.isSupportedStringReplacePattern(expr.regexp)) { | ||
| replaceOpt = Some(GpuRegExpStringReplace) | ||
| } else { | ||
| searchList = GpuRegExpUtils.getChoicesFromRegex(pat) | ||
| searchList match { | ||
| case Some(_) if !containsBackref => | ||
| replaceOpt = Some(GpuRegExpStringReplaceMulti) | ||
| case _ => | ||
| GpuRegExpUtils.tagForRegExpEnabled(this) | ||
| GpuRegExpUtils.validateRegExpComplexity(this, pat) | ||
| cudfPattern = Some(pat.toRegexString) | ||
| } | ||
| } | ||
| } catch { | ||
| case e: RegexUnsupportedException => | ||
| willNotWorkOnGpu(e.getMessage) | ||
| } | ||
|
|
||
| case _ => | ||
|
|
@@ -82,19 +97,27 @@ class GpuRegExpReplaceMeta( | |
| // ignore the pos expression which must be a literal 1 after tagging check | ||
| require(childExprs.length == 4, | ||
| s"Unexpected child count for RegExpReplace: ${childExprs.length}") | ||
| replaceOpt match { | ||
| case None => | ||
| (javaPattern, cudfPattern, replacement) match { | ||
| case (Some(javaPattern), Some(cudfPattern), Some(cudfReplacement)) => | ||
| if (containsBackref) { | ||
| GpuRegExpReplaceWithBackref(lhs, cudfPattern, cudfReplacement) | ||
| } else { | ||
| GpuRegExpReplace(lhs, regexp, rep, javaPattern, cudfPattern, cudfReplacement, | ||
| None, None) | ||
| } | ||
| case _ => | ||
| throw new IllegalStateException("Expression has not been tagged correctly") | ||
| } | ||
| case _ => | ||
| (javaPattern, replacement) match { | ||
| case (Some(javaPattern), Some(replacement)) => | ||
| GpuRegExpReplace(lhs, regexp, rep, javaPattern, javaPattern, replacement, | ||
| searchList, replaceOpt) | ||
| case _ => | ||
| throw new IllegalStateException("Expression has not been tagged correctly") | ||
| } | ||
| } | ||
| } | ||
| } | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -742,11 +742,39 @@ case class GpuStringRepeat(input: Expression, repeatTimes: Expression) | |
|
|
||
| } | ||
|
|
||
| trait HasGpuStringReplace extends Arm { | ||
| def doStringReplace( | ||
| strExpr: GpuColumnVector, | ||
| searchExpr: GpuScalar, | ||
| replaceExpr: GpuScalar): ColumnVector = { | ||
| // When search or replace string is null, return all nulls like the CPU does. | ||
| if (!searchExpr.isValid || !replaceExpr.isValid) { | ||
| GpuColumnVector.columnVectorFromNull(strExpr.getRowCount.toInt, StringType) | ||
| } else if (searchExpr.getValue.asInstanceOf[UTF8String].numChars() == 0) { | ||
| // Return original string if search string is empty | ||
| strExpr.getBase.asStrings() | ||
| } else { | ||
| strExpr.getBase.stringReplace(searchExpr.getBase, replaceExpr.getBase) | ||
| } | ||
| } | ||
|
|
||
| def doStringReplaceMulti( | ||
| strExpr: GpuColumnVector, | ||
| search: Seq[String], | ||
| replacement: String): ColumnVector = { | ||
| withResource(ColumnVector.fromStrings(search: _*)) { targets => | ||
| withResource(ColumnVector.fromStrings(replacement)) { repls => | ||
| strExpr.getBase.stringReplace(targets, repls) | ||
| } | ||
| } | ||
| } | ||
| } | ||
|
|
||
| case class GpuStringReplace( | ||
| srcExpr: Expression, | ||
| searchExpr: Expression, | ||
| replaceExpr: Expression) | ||
| extends GpuTernaryExpression with ImplicitCastInputTypes with HasGpuStringReplace { | ||
|
|
||
| override def dataType: DataType = srcExpr.dataType | ||
|
|
||
|
|
@@ -794,15 +822,7 @@ case class GpuStringReplace( | |
| strExpr: GpuColumnVector, | ||
| searchExpr: GpuScalar, | ||
| replaceExpr: GpuScalar): ColumnVector = { | ||
| doStringReplace(strExpr, searchExpr, replaceExpr) | ||
| } | ||
|
|
||
| override def doColumnar(numRows: Int, val0: GpuScalar, val1: GpuScalar, | ||
|
|
@@ -996,6 +1016,40 @@ object GpuRegExpUtils { | |
| countGroups(parseAST(pattern)) | ||
| } | ||
|
|
||
| def getChoicesFromRegex(regex: RegexAST): Option[Seq[String]] = { | ||
NVnavkumar marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| regex match { | ||
| case RegexGroup(_, t, None) => | ||
| if (GpuOverrides.isSupportedStringReplacePattern(t.toRegexString)) { | ||
| Some(Seq(t.toRegexString)) | ||
| } else { | ||
| None | ||
| } | ||
| case RegexChoice(a, b) => | ||
| getChoicesFromRegex(a) match { | ||
| case Some(la) => | ||
| getChoicesFromRegex(b) match { | ||
| case Some(lb) => Some(la ++ lb) | ||
| case _ => None | ||
| } | ||
| case _ => None | ||
| } | ||
| case RegexSequence(parts) => | ||
| if (GpuOverrides.isSupportedStringReplacePattern(regex.toRegexString)) { | ||
| Some(Seq(regex.toRegexString)) | ||
| } else { | ||
| parts.foldLeft(Some(Seq[String]()): Option[Seq[String]]) { (m: Option[Seq[String]], r) => | ||
| getChoicesFromRegex(r) match { | ||
| case Some(l) => m.map(_ ++ l) | ||
| case _ => None | ||
| } | ||
| } | ||
| } | ||
| case _ => | ||
| None | ||
| } | ||
| } | ||
|
|
||
|
|
||
| } | ||
|
|
||
| class GpuRLikeMeta( | ||
|
|
@@ -1114,8 +1168,10 @@ case class GpuRegExpReplace( | |
| replaceExpr: Expression, | ||
| javaRegexpPattern: String, | ||
| cudfRegexPattern: String, | ||
| cudfReplacementString: String, | ||
| searchList: Option[Seq[String]], | ||
| replaceOpt: Option[GpuRegExpReplaceOpt]) | ||
| extends GpuRegExpTernaryBase with ImplicitCastInputTypes with HasGpuStringReplace { | ||
|
|
||
| override def inputTypes: Seq[DataType] = Seq(StringType, StringType, StringType) | ||
|
|
||
|
|
@@ -1127,7 +1183,7 @@ case class GpuRegExpReplace( | |
| cudfRegexPattern: String, cudfReplacementString: String) = { | ||
|
|
||
| this(srcExpr, searchExpr, GpuLiteral("", StringType), javaRegexpPattern, | ||
| cudfRegexPattern, cudfReplacementString, None, None) | ||
| } | ||
|
|
||
| override def doColumnar( | ||
|
|
@@ -1137,28 +1193,41 @@ case class GpuRegExpReplace( | |
| // For empty strings and a regex containing only a zero-match repetition, | ||
| // the behavior in some versions of Spark is different. | ||
| // see https://github.com/NVIDIA/spark-rapids/issues/5456 | ||
| replaceOpt match { | ||
| case Some(GpuRegExpStringReplace) => | ||
| doStringReplace(strExpr, searchExpr, replaceExpr) | ||
| case Some(GpuRegExpStringReplaceMulti) => | ||
| searchList match { | ||
| case Some(searches) => | ||
| doStringReplaceMulti(strExpr, searches, cudfReplacementString) | ||
| case _ => | ||
| throw new IllegalStateException("Need a replace") | ||
| } | ||
| case _ => | ||
| val prog = new RegexProgram(cudfRegexPattern, CaptureGroups.NON_CAPTURE) | ||
| if (SparkShimImpl.reproduceEmptyStringBug && | ||
| GpuRegExpUtils.isEmptyRepetition(javaRegexpPattern)) { | ||
| val isEmpty = withResource(strExpr.getBase.getCharLengths) { len => | ||
| withResource(Scalar.fromInt(0)) { zero => | ||
| len.equalTo(zero) | ||
| } | ||
| } | ||
| withResource(isEmpty) { _ => | ||
| withResource(GpuScalar.from("", DataTypes.StringType)) { emptyString => | ||
| withResource(GpuScalar.from(cudfReplacementString, DataTypes.StringType)) { rep => | ||
| withResource(strExpr.getBase.replaceRegex(prog, rep)) { replacement => | ||
| isEmpty.ifElse(emptyString, replacement) | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } else { | ||
| withResource(Scalar.fromString(cudfReplacementString)) { rep => | ||
| strExpr.getBase.replaceRegex(prog, rep) | ||
| } | ||
| } | ||
| } | ||
|
|
||
| } | ||
|
|
||
| } | ||
|
|
||
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
nit, here and other places, could use typed constants