zio#154: Implement renderUpdate for Oracle (zio#700)

* 154: (Draft) Implement `renderUpate` for Oracle

* zio#154: (Draft) Implement `renderUpdate` for Oracle

* zio#154: Implement `renderUpdate` for Oracle

* zio#154: Extend tests of `renderUpdate` for Oracle

* zio#154: fix formatting

* zio#154: fix 2.12.15 compatibility

* zio#154: adjust docs

* zio#154: fix non-related flaky test

README.md

@@ -26,15 +26,15 @@ Connection pool | :white_check_mark:
 
 #### Db-specific features:
 
-Feature | PostgreSQL | SQL Server | Oracle | MySQL
-:------------ | :-------------| :-------------| :-------------| :-------------
+Feature | PostgreSQL | SQL Server | Oracle             | MySQL
+:------------ | :-------------| :-------------|:-------------------| :-------------
 Render Read | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
-Render Delete | :heavy_check_mark: | :heavy_check_mark: | | :white_check_mark: | 
-Render Update | :heavy_check_mark: |  | | :white_check_mark: |
-Render Insert | :heavy_check_mark: |  | |
+Render Delete | :heavy_check_mark: | :heavy_check_mark: | :white_check_mark: | :white_check_mark: | 
+Render Update | :heavy_check_mark: |  | :white_check_mark: | :white_check_mark: |
+Render Insert | :heavy_check_mark: |  |                    |
 Functions     | :heavy_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: |
-Types         | :white_check_mark: | | | :white_check_mark: |
-Operators     | | | |
+Types         | :white_check_mark: | |                    | :white_check_mark: |
+Operators     | | |                    |
 
 ## What is ZIO SQL?
 ZIO SQL lets you write type-safe, type-inferred, and composable SQL queries in ordinary Scala, helping you prevent persistence bugs before they happen, and leverage your IDE to make writing SQL productive, safe, and fun. 

driver/src/main/scala/zio/sql/driver/Renderer.scala

@@ -20,4 +20,9 @@ private[sql] class Renderer(val builder: StringBuilder) extends AnyVal {
 
 private[sql] object Renderer {
   def apply(): Renderer = new Renderer(new StringBuilder)
+
+  implicit class Extensions(val value: String) {
+    def doubleQuoted: String = s""""$value""""
+    def singleQuoted: String = s"'$value'"
+  }
 }

oracle/src/main/scala/zio/sql/oracle/OracleRenderModule.scala

@@ -1,6 +1,10 @@
 package zio.sql.oracle
 
 import zio.schema.Schema
+import zio.sql.driver.Renderer
+import zio.sql.driver.Renderer.Extensions
+
+import scala.collection.mutable
 
 trait OracleRenderModule extends OracleSqlModule { self =>
 
@@ -18,8 +22,13 @@ trait OracleRenderModule extends OracleSqlModule { self =>
     builder.toString()
   }
 
-  override def renderUpdate(update: self.Update[_]): String = ???
+  override def renderUpdate(update: self.Update[_]): String = {
+    implicit val render: Renderer = Renderer()
+    OracleRender.renderUpdateImpl(update)
+    render.toString
+  }
 
+  // TODO: to consider the refactoring and using the implicit `Renderer`, see `renderExpr` in `PostgresRenderModule`
   private def buildExpr[A, B](expr: self.Expr[_, A, B], builder: StringBuilder): Unit = expr match {
     case Expr.Subselect(subselect)                                                            =>
       builder.append(" (")
@@ -49,16 +58,20 @@ trait OracleRenderModule extends OracleSqlModule { self =>
     case Expr.Relational(left, right, op)                                                     =>
       buildExpr(left, builder)
       builder.append(" ").append(op.symbol).append(" ")
-      buildExpr(right, builder)
+      right.asInstanceOf[Expr[_, A, B]] match {
+        case Expr.Literal(true)  => val _ = builder.append("1")
+        case Expr.Literal(false) => val _ = builder.append("0")
+        case otherValue          => buildExpr(otherValue, builder)
+      }
     case Expr.In(value, set)                                                                  =>
       buildExpr(value, builder)
       buildReadString(set, builder)
     case Expr.Literal(true)                                                                   =>
-      val _ = builder.append("1")
+      val _ = builder.append("1 = 1")
     case Expr.Literal(false)                                                                  =>
-      val _ = builder.append("0")
+      val _ = builder.append("0 = 1")
     case Expr.Literal(value)                                                                  =>
-      val _ = builder.append(value.toString) // todo fix escaping
+      val _ = builder.append(value.toString.singleQuoted)
     case Expr.AggregationCall(param, aggregation)                                             =>
       builder.append(aggregation.name.name)
       builder.append("(")
@@ -313,7 +326,7 @@ trait OracleRenderModule extends OracleSqlModule { self =>
         val _ = builder.append(" ")
     }
 
-  private def buildDeleteString(delete: Delete[_], builder: StringBuilder) = {
+  private def buildDeleteString(delete: Delete[_], builder: mutable.StringBuilder): Unit = {
     builder.append("DELETE FROM ")
     buildTable(delete.table, builder)
     delete.whereExpr match {
@@ -324,4 +337,42 @@ trait OracleRenderModule extends OracleSqlModule { self =>
     }
   }
 
+  private[oracle] object OracleRender {
+
+    def renderUpdateImpl(update: Update[_])(implicit render: Renderer): Unit =
+      update match {
+        case Update(table, set, whereExpr) =>
+          render("UPDATE ")
+          buildTable(table, render.builder)
+          render(" SET ")
+          renderSet(set)
+          render(" WHERE ")
+          buildExpr(whereExpr, render.builder)
+      }
+
+    def renderSet(set: List[Set[_, _]])(implicit render: Renderer): Unit =
+      set match {
+        case head :: tail =>
+          renderSetLhs(head.lhs)
+          render(" = ")
+          buildExpr(head.rhs, render.builder)
+          tail.foreach { setEq =>
+            render(", ")
+            renderSetLhs(setEq.lhs)
+            render(" = ")
+            buildExpr(setEq.rhs, render.builder)
+          }
+        case Nil          => // TODO restrict Update to not allow empty set
+      }
+
+    private[zio] def renderSetLhs[A, B](expr: self.Expr[_, A, B])(implicit render: Renderer): Unit =
+      expr match {
+        case Expr.Source(table, column) =>
+          (table, column.name) match {
+            case (tableName, Some(columnName)) => val _ = render(tableName, ".", columnName)
+            case _                             => ()
+          }
+        case _                          => ()
+      }
+  }
 }

oracle/src/test/scala/zio/sql/oracle/OracleSqlModuleSpec.scala

@@ -0,0 +1,62 @@
+package zio.sql.oracle
+
+import zio.test.Assertion._
+import zio.test.TestAspect._
+import zio.test._
+
+import scala.language.postfixOps
+
+object OracleSqlModuleSpec extends OracleRunnableSpec with ShopSchema {
+
+  import Customers._
+
+  override def specLayered: Spec[SqlDriver, Exception] = suite("Oracle module")(
+    test("Can update selected rows") {
+
+      /**
+       * UPDATE customers SET customers.first_name = 'Antek'
+       * WHERE 1 = 1 and customers.verified = 0 and customers.verified <> 1
+       */
+      val query =
+        update(customers)
+          .set(fName, "Antek")
+          .where(verified isNotTrue)
+          .where(verified <> true) // we intentionally verify two syntax variants
+
+      assertZIO(execute(query))(equalTo(1))
+    },
+    test("Can update all rows") {
+
+      /**
+       * UPDATE customers SET customers.first_name = 'Antek' WHERE 1 = 1
+       */
+      val query = update(customers).set(fName, "Antek")
+
+      assertZIO(execute(query))(equalTo(5))
+    },
+    test("Can delete from single table with a condition") {
+
+      /**
+       * DELETE FROM customers WHERE customers.verified = 0
+       */
+      val query = deleteFrom(customers) where (verified isNotTrue)
+
+      val expected = 1
+      val result   = execute(query)
+
+      assertZIO(result)(equalTo(expected))
+    },
+    test("Can delete all from a single table") {
+
+      /**
+       * DELETE FROM customers
+       */
+      val query = deleteFrom(customers)
+
+      val expected = 4
+      val result   = execute(query)
+
+      assertZIO(result)(equalTo(expected))
+    }
+  ) @@ sequential
+}

oracle/src/test/scala/zio/sql/oracle/ShopSchema.scala

@@ -5,12 +5,14 @@ import zio.sql.Jdbc
 trait ShopSchema extends Jdbc { self =>
   import self.ColumnSet._
 
-  object Customers     {
+  object Customers {
+
     val customers =
-      (uuid("id") ++ localDate("dob") ++ string("first_name") ++ string("last_name") ++ boolean("verified"))
+      (uuid("id") ++ localDate("dob") ++ string("first_name") ++ string("last_name") ++
+        boolean("verified") ++ zonedDateTime("Created_timestamp"))
         .table("customers")
 
-    val (customerId, dob, fName, lName, verified) = customers.columns
+    val (customerId, dob, fName, lName, verified, createdTimestamp) = customers.columns
   }
   object Orders        {
     val orders = (uuid("id") ++ uuid("customer_id") ++ localDate("order_date")).table("orders")

postgres/src/test/scala/zio/sql/postgresql/FunctionDefSpec.scala

@@ -298,10 +298,10 @@ object FunctionDefSpec extends PostgresRunnableSpec with DbSchema {
       )
     },
     test("localtime with precision") {
-      val precision = 0
+      val precision = 3
       assertZIO(execute(select(LocaltimeWithPrecision(precision))).runHead.some.map(_.toString))(
         matchesRegex(
-          s"([0-9]{2}):[0-9]{2}:[0-9].[0-9]{$precision}"
+          s"\\d{2}:\\d{2}:\\d{2}\\.\\d{$precision}"
         )
       )
     },

postgres/src/test/scala/zio/sql/postgresql/PostgresModuleSpec.scala → postgres/src/test/scala/zio/sql/postgresql/PostgresSqlModuleSpec.scala

@@ -11,7 +11,7 @@ import scala.language.postfixOps
 import zio.schema.Schema
 import java.time.format.DateTimeFormatter
 
-object PostgresModuleSpec extends PostgresRunnableSpec with DbSchema {
+object PostgresSqlModuleSpec extends PostgresRunnableSpec with DbSchema {
 
   import AggregationDef._
   import Customers._

sqlserver/src/main/scala/zio/sql/sqlserver/SqlServerRenderModule.scala

@@ -2,6 +2,7 @@ package zio.sql.sqlserver
 
 import zio.schema.Schema
 import zio.sql.driver.Renderer
+import zio.sql.driver.Renderer.Extensions
 
 trait SqlServerRenderModule extends SqlServerSqlModule { self =>
 
@@ -153,7 +154,7 @@ trait SqlServerRenderModule extends SqlServerSqlModule { self =>
               .asInstanceOf[java.time.OffsetDateTime]
               .format(java.time.format.DateTimeFormatter.ofPattern("YYYY-MM-dd HH:mm:ss"))
             s"'$x'"
-          case _                       => s"'${value.toString}'"
+          case _                       => value.toString.singleQuoted
         }
         render(lit)
       case Expr.AggregationCall(param, aggregation)                                             =>