Flatten simple 4+ nesting of withResource

sql-plugin/src/main/330+/scala/com/nvidia/spark/rapids/shims/GpuIntervalUtils.scala

@@ -22,6 +22,7 @@ import scala.collection.mutable.ArrayBuffer
 
 import ai.rapids.cudf.{ColumnVector, ColumnView, DType, Scalar}
 import com.nvidia.spark.rapids.{Arm, BoolUtils, CloseableHolder}
+import com.nvidia.spark.rapids.RapidsPluginImplicits._
 
 import org.apache.spark.sql.catalyst.util.DateTimeConstants.{MICROS_PER_DAY, MICROS_PER_HOUR, MICROS_PER_MINUTE, MICROS_PER_SECOND, MONTHS_PER_YEAR}
 import org.apache.spark.sql.rapids.shims.IntervalUtils
@@ -292,17 +293,15 @@ object GpuIntervalUtils extends Arm {
   // not close firstSignInTable and secondSignInTable here, outer table.close will close them
   private def finalSign(
       firstSignInTable: ColumnVector, secondSignInTable: ColumnVector): ColumnVector = {
-    withResource(Scalar.fromString("-")) { negScalar =>
-      withResource(negScalar.equalTo(firstSignInTable)) { neg1 =>
-        withResource(negScalar.equalTo(secondSignInTable)) { neg2 =>
-          withResource(neg1.bitXor(neg2)) { s =>
-            withResource(Scalar.fromLong(1L)) { one =>
-              withResource(Scalar.fromLong(-1L)) { negOne =>
-                s.ifElse(negOne, one)
-              }
-            }
-          }
-        }
+    val negatives = withResource(Scalar.fromString("-")) { negScalar =>
+      withResource(Seq(firstSignInTable, secondSignInTable).safeMap(negScalar.equalTo)) {
+        case Seq(neg1, neg2) => neg1.bitXor(neg2)
+      }
+    }
+
+    withResource(negatives) { _ =>
+      withResource(Seq(1L, -1L).safeMap(Scalar.fromLong)) { case Seq(posOne, negOne) =>
+        negatives.ifElse(negOne, posOne)
       }
     }
   }
@@ -315,15 +314,18 @@ object GpuIntervalUtils extends Arm {
    * @return micros column
    */
   private def getMicrosFromDecimal(sign: ColumnVector, decimal: ColumnVector): ColumnVector = {
-    withResource(decimal.castTo(DType.create(DType.DTypeEnum.DECIMAL64, -6))) { decimal =>
-      withResource(Scalar.fromLong(1000000L)) { million =>
-        withResource(decimal.mul(million)) { r =>
-          withResource(r.asLongs()) { l =>
-            l.mul(sign)
-          }
-        }
+    val decimalType64_6 = DType.create(DType.DTypeEnum.DECIMAL64, -6)
+    val timesMillion = withResource(Scalar.fromLong(1000000L)) { million =>
+      withResource(decimal.castTo(decimalType64_6)) {
+        _.mul(million)
       }
     }
+    val timesMillionLongs = withResource(timesMillion) {
+      _.asLongs()
+    }
+    withResource(timesMillionLongs) {
+      _.mul(sign)
+    }
   }
 
   private def addFromDayToDay(

sql-plugin/src/main/scala/com/nvidia/spark/RebaseHelper.scala

@@ -30,12 +30,14 @@ object RebaseHelper extends Arm {
     //  https://github.com/NVIDIA/spark-rapids/issues/1126
     val dtype = column.getType
     if (dtype == DType.TIMESTAMP_DAYS) {
-      withResource(Scalar.timestampDaysFromInt(startDay)) { minGood =>
-        withResource(column.lessThan(minGood)) { hasBad =>
-          withResource(hasBad.any()) { a =>
-            a.isValid && a.getBoolean
-          }
-        }
+      val hasBad = withResource(Scalar.timestampDaysFromInt(startDay)) {
+        column.lessThan
+      }
+      val anyBad = withResource(hasBad) {
+        _.any()
+      }
+      withResource(anyBad) { _ =>
+        anyBad.isValid && anyBad.getBoolean
       }
     } else {
       false

sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuCSVScan.scala

@@ -340,22 +340,25 @@ class CSVPartitionReader(
    * CSV supports "true" and "false" (case-insensitive) as valid boolean values.
    */
   override def castStringToBool(input: ColumnVector): ColumnVector = {
-    withResource(input.strip()) { stripped =>
-      withResource(stripped.lower()) { lower =>
-        withResource(Scalar.fromString("true")) { t =>
-          withResource(Scalar.fromString("false")) { f =>
-            withResource(lower.equalTo(t)) { isTrue =>
-              withResource(lower.equalTo(f)) { isFalse =>
-                withResource(isTrue.or(isFalse)) { isValidBool =>
-                  withResource(Scalar.fromNull(DType.BOOL8)) { nullBool =>
-                    isValidBool.ifElse(isTrue, nullBool)
-                  }
-                }
-              }
-            }
-          }
+    val lowerStripped = withResource(input.strip()) {
+      _.lower()
+    }
+
+    val (isTrue, isValidBool) = withResource(lowerStripped) { _ =>
+      val isTrueRes = withResource(Scalar.fromString(true.toString)) {
+        lowerStripped.equalTo
+      }
+      val isValidBoolRes = closeOnExcept(isTrueRes) { _ =>
+        withResource(ColumnVector.fromStrings(true.toString, false.toString)) {
+          lowerStripped.contains
         }
       }
+      (isTrueRes, isValidBoolRes)
+    }
+    withResource(Seq(isTrue, isValidBool)) { _ =>
+      withResource(Scalar.fromNull(DType.BOOL8)) {
+        isValidBool.ifElse(isTrue, _)
+      }
     }
   }