MS SQL - take 3 (#94)

This PR builds on the work in #29 and #60 by @kiendang and
@jtjeferreira.

What it does:
- rebase previous works on top of current `main`
- fix table name escape
- fix `DataTypesTests` and `OptionalsTests` with the point of contention
being the lack of a dedicated boolean column type
- add more tests (inserting both values of boolean, updating BIT
columns) and document any result deviations

How this is achieved:

T-SQL (the dialect used by MS SQL Server) does have `Boolean`s as part
of filter expressions, but not as column data, with `BIT`s being used as
a substitute. Hence, these uses which are both `Boolean` on the Scala
side, need to be distinguished. To this end, a marker was introduced in
`Context`, explicitly designating `InsertValues`, `InsertSelect`,
`InsertColumns` and `Update` expression as using them as values. This
was done globally, because overloading would lead to a lot more
boilerplate, while simply disregarding the flags value leave the
existing dialects intact.

Known omissions:
- `ExprBooleanOps` for `BIT` values: small edge case, it's possible and
there's syntax for it (bitwise operators), but it needs another
branching of the above kind, to not break the normal OR/AND/NOT syntax.
Bitwise operators are also already tested as part of NumericOps.
- RETURNING: this is not a thing in T-SQL, however it does have OUTPUT,
which could be used to achieve similar results
- ON CONFLICT: similarly, not present in T-SQL, there is MERGE in the
standard, but the opinions are mixed on whether it achieves the adequate
level of isolation as Postgres's ON CONFLICT does.
- LATERAL JOIN: again, very Postgres, maybe CROSS APPLY could be used to
achieve similar effect.
- bare VALUES: not supported. However, it is not it's own `Dialect`
trait yet, which would indicate this more cleanly,

---------

Co-authored-by: Kien Dang <[email protected]>
Co-authored-by: João Ferreira <[email protected]>

Author: 3 people

build.mill

@@ -54,6 +54,8 @@ trait CommonBase extends ScalaModule with PublishModule with ScalafixModule { co
       ivy"org.postgresql:postgresql:42.6.0",
       ivy"org.testcontainers:mysql:1.19.1",
       ivy"mysql:mysql-connector-java:8.0.33",
+      ivy"org.testcontainers:mssqlserver:1.19.1",
+      ivy"com.microsoft.sqlserver:mssql-jdbc:12.8.1.jre11",
       ivy"com.zaxxer:HikariCP:5.1.0"
     )
 

docs/reference.md

@@ -236,7 +236,10 @@ dbClient.transaction { db =>
       LocalDate.parse("2000-01-01")
     )
   )
-  assert(generatedKeys == Seq(4, 5))
+  if (!this.isInstanceOf[MsSqlSuite])
+    assert(generatedKeys == Seq(4, 5))
+  else
+    assert(generatedKeys == Seq(5))
 
   db.run(Buyer.select) ==> List(
     Buyer[Sc](1, "James Bond", LocalDate.parse("2001-02-03")),
@@ -1997,7 +2000,6 @@ Buyer.select
   .leftJoin(ShippingInfo)(_.id `=` _.buyerId)
   .map { case (b, si) => (b.name, si.map(_.shippingDate)) }
   .sortBy(_._2)
-  .nullsFirst
 ```
 
 
@@ -2006,7 +2008,7 @@ Buyer.select
     SELECT buyer0.name AS res_0, shipping_info1.shipping_date AS res_1
     FROM buyer buyer0
     LEFT JOIN shipping_info shipping_info1 ON (buyer0.id = shipping_info1.buyer_id)
-    ORDER BY res_1 NULLS FIRST
+    ORDER BY res_1
     ```
 
 
@@ -3395,7 +3397,7 @@ Purchase.delete(_ => true)
 
 *
     ```sql
-    DELETE FROM purchase WHERE ?
+    DELETE FROM purchase
     ```
 
 
@@ -4003,7 +4005,7 @@ Product.select
 
 
 ## UpdateJoin
-`UPDATE` queries that use `JOIN`s
+Basic `UPDATE` queries
 ### UpdateJoin.join
 
 ScalaSql supports performing `UPDATE`s with `FROM`/`JOIN` clauses using the
@@ -6951,7 +6953,7 @@ Select.delete(_ => true)
 
 *
     ```sql
-    DELETE FROM "select" WHERE ?
+    DELETE FROM "select"
     ```
 
 
@@ -9774,7 +9776,7 @@ Expr(Bytes("Hello")).contains(Bytes("ll"))
 
 
 ## ExprMathOps
-Math operations; supported by H2/Postgres/MySql, not supported by Sqlite
+Math operations; supported by H2/Postgres/MySql/MsSql, not supported by Sqlite
 ### ExprMathOps.power
 
 
@@ -10111,7 +10113,7 @@ val value = DataTypes[Sc](
   myInt = 12345678,
   myBigInt = 12345678901L,
   myDouble = 3.14,
-  myBoolean = true,
+  myBoolean = false,
   myLocalDate = LocalDate.parse("2023-12-20"),
   myLocalTime = LocalTime.parse("10:15:30"),
   myLocalDateTime = LocalDateTime.parse("2011-12-03T10:15:30"),
@@ -10122,6 +10124,23 @@ val value = DataTypes[Sc](
   myEnum = MyEnum.bar
 )
 
+val value2 = DataTypes[Sc](
+  67.toByte,
+  mySmallInt = 32767.toShort,
+  myInt = 12345678,
+  myBigInt = 9876543210L,
+  myDouble = 2.71,
+  myBoolean = true,
+  myLocalDate = LocalDate.parse("2020-02-22"),
+  myLocalTime = LocalTime.parse("03:05:01"),
+  myLocalDateTime = LocalDateTime.parse("2021-06-07T02:01:03"),
+  myUtilDate = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS").parse("2021-06-07T02:01:03.000"),
+  myInstant = Instant.parse("2021-06-07T02:01:03Z"),
+  myVarBinary = new geny.Bytes(Array[Byte](9, 8, 7, 6, 5, 4, 3, 2)),
+  myUUID = new java.util.UUID(9876543210L, 1234567890L),
+  myEnum = MyEnum.baz
+)
+
 db.run(
   DataTypes.insert.columns(
     _.myTinyInt := value.myTinyInt,
@@ -10140,8 +10159,26 @@ db.run(
     _.myEnum := value.myEnum
   )
 ) ==> 1
+db.run(
+  DataTypes.insert.columns(
+    _.myTinyInt := value2.myTinyInt,
+    _.mySmallInt := value2.mySmallInt,
+    _.myInt := value2.myInt,
+    _.myBigInt := value2.myBigInt,
+    _.myDouble := value2.myDouble,
+    _.myBoolean := value2.myBoolean,
+    _.myLocalDate := value2.myLocalDate,
+    _.myLocalTime := value2.myLocalTime,
+    _.myLocalDateTime := value2.myLocalDateTime,
+    _.myUtilDate := value2.myUtilDate,
+    _.myInstant := value2.myInstant,
+    _.myVarBinary := value2.myVarBinary,
+    _.myUUID := value2.myUUID,
+    _.myEnum := value2.myEnum
+  )
+) ==> 1
 
-db.run(DataTypes.select) ==> Seq(value)
+db.run(DataTypes.select) ==> Seq(value, value2)
 ```
 
 
@@ -11181,6 +11218,24 @@ val rowSome = OptDataTypes[Sc](
   myUUID = Some(new java.util.UUID(1234567890L, 9876543210L)),
   myEnum = Some(MyEnum.bar)
 )
+val rowSome2 = OptDataTypes[Sc](
+  myTinyInt = Some(67.toByte),
+  mySmallInt = Some(32767.toShort),
+  myInt = Some(23456789),
+  myBigInt = Some(9876543210L),
+  myDouble = Some(2.71),
+  myBoolean = Some(false),
+  myLocalDate = Some(LocalDate.parse("2020-02-22")),
+  myLocalTime = Some(LocalTime.parse("03:05:01")),
+  myLocalDateTime = Some(LocalDateTime.parse("2021-06-07T02:01:03")),
+  myUtilDate = Some(
+    new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS").parse("2021-06-07T02:01:03.000")
+  ),
+  myInstant = Some(Instant.parse("2021-06-07T02:01:03Z")),
+  myVarBinary = Some(new geny.Bytes(Array[Byte](9, 8, 7, 6, 5, 4, 3, 2))),
+  myUUID = Some(new java.util.UUID(9876543210L, 1234567890L)),
+  myEnum = Some(MyEnum.baz)
+)
 
 val rowNone = OptDataTypes[Sc](
   myTinyInt = None,
@@ -11198,12 +11253,11 @@ val rowNone = OptDataTypes[Sc](
   myUUID = None,
   myEnum = None
 )
-
 db.run(
-  OptDataTypes.insert.values(rowSome, rowNone)
-) ==> 2
+  OptDataTypes.insert.values(rowSome, rowSome2, rowNone)
+) ==> 3
 
-db.run(OptDataTypes.select) ==> Seq(rowSome, rowNone)
+db.run(OptDataTypes.select) ==> Seq(rowSome, rowSome2, rowNone)
 ```
 
 
@@ -12376,3 +12430,80 @@ db.concatWs(" ", "i", "am", "cow", 1337)
     ```
 
 
+
+## MsSqlDialect
+Operations specific to working with Microsoft SQL Databases
+### MsSqlDialect.top
+
+For ScalaSql's Microsoft SQL dialect provides, the `.take(n)` operator translates
+into a SQL `TOP(n)` clause
+
+```scala
+Buyer.select.take(0)
+```
+
+
+*
+    ```sql
+    SELECT TOP(?) buyer0.id AS id, buyer0.name AS name, buyer0.date_of_birth AS date_of_birth
+    FROM buyer buyer0
+    ```
+
+
+
+*
+    ```scala
+    Seq[Buyer[Sc]]()
+    ```
+
+
+
+### MsSqlDialect.bool vs bit
+
+Insert rows with BIT values
+
+```scala
+db.run(
+  BoolTypes.insert.columns(
+    _.nullable := value.nullable,
+    _.nonNullable := value.nonNullable,
+    _.a := value.a,
+    _.b := value.b,
+    _.comment := value.comment
+  )
+) ==> 1
+db.run(
+  BoolTypes.insert.columns(
+    _.nullable := value2.nullable,
+    _.nonNullable := value2.nonNullable,
+    _.a := value2.a,
+    _.b := value2.b,
+    _.comment := value2.comment
+  )
+) ==> 1
+```
+
+
+
+
+
+
+### MsSqlDialect.uodate BIT
+
+
+
+```scala
+BoolTypes
+  .update(_.a `=` 1)
+  .set(_.nonNullable := true)
+```
+
+
+*
+    ```sql
+    UPDATE bool_types SET non_nullable = ? WHERE (bool_types.a = ?)
+    ```
+
+
+
+

scalasql/core/src/Context.scala

@@ -19,6 +19,11 @@ trait Context {
    */
   def exprNaming: Map[Expr.Identity, SqlStr]
 
+  /**
+   * Mark [[Expr]]s as a raw value for an INSERT or UPDATE context
+   */
+  def valueMarker: Boolean
+
   /**
    * The ScalaSql configuration
    */
@@ -28,9 +33,11 @@ trait Context {
 
   def withFromNaming(fromNaming: Map[Context.From, String]): Context
   def withExprNaming(exprNaming: Map[Expr.Identity, SqlStr]): Context
+  def markAsValue: Context
 }
 
 object Context {
+
   trait From {
 
     /**
@@ -58,13 +65,18 @@ object Context {
   case class Impl(
       fromNaming: Map[From, String],
       exprNaming: Map[Expr.Identity, SqlStr],
+      valueMarker: Boolean,
       config: Config,
       dialectConfig: DialectConfig
   ) extends Context {
     def withFromNaming(fromNaming: Map[From, String]): Context = copy(fromNaming = fromNaming)
 
     def withExprNaming(exprNaming: Map[Expr.Identity, SqlStr]): Context =
       copy(exprNaming = exprNaming)
+
+    def markAsValue: Context = copy(
+      valueMarker = true
+    )
   }
 
   /**
@@ -96,7 +108,13 @@ object Context {
               .map { case (e, s) => (e, sql"${SqlStr.raw(newFromNaming(t), Array(e))}.$s") }
           }
 
-    Context.Impl(newFromNaming, newExprNaming, prevContext.config, prevContext.dialectConfig)
+    Context.Impl(
+      newFromNaming,
+      newExprNaming,
+      prevContext.valueMarker,
+      prevContext.config,
+      prevContext.dialectConfig
+    )
   }
 
 }

scalasql/core/src/DbApi.scala

@@ -131,7 +131,7 @@ object DbApi {
       config: Config,
       dialectConfig: DialectConfig
   ) = {
-    val ctx = Context.Impl(Map(), Map(), config, dialectConfig)
+    val ctx = Context.Impl(Map(), Map(), false, config, dialectConfig)
     val flattened = SqlStr.flatten(qr.renderSql(query, ctx))
     flattened
   }
@@ -583,7 +583,7 @@ object DbApi {
 
       try {
         val res = block(new DbApi.SavepointImpl(savepoint, () => rollbackSavepoint(savepoint)))
-        if (savepointStack.lastOption.exists(_ eq savepoint)) {
+        if (dialect.supportSavepointRelease && savepointStack.lastOption.exists(_ eq savepoint)) {
           // Only release if this savepoint has not been rolled back,
           // directly or indirectly
           connection.releaseSavepoint(savepoint)

scalasql/core/src/DialectConfig.scala

@@ -3,11 +3,13 @@ package scalasql.core
 trait DialectConfig { that =>
   def castParams: Boolean
   def escape(str: String): String
+  def supportSavepointRelease: Boolean
 
   def withCastParams(params: Boolean) = new DialectConfig {
     def castParams: Boolean = params
 
-    def escape(str: String): String = that.escape(str)
+    def supportSavepointRelease = that.supportSavepointRelease
 
+    def escape(str: String): String = that.escape(str)
   }
 }

scalasql/query/src/CompoundSelect.scala

@@ -112,7 +112,7 @@ object CompoundSelect {
     // columns are duplicates or not, and thus what final set of rows is returned
     lazy val preserveAll = query.compoundOps.exists(_.op != "UNION ALL")
 
-    def render(liveExprs: LiveExprs) = {
+    protected def prerender(liveExprs: LiveExprs) = {
       val innerLiveExprs =
         if (preserveAll) LiveExprs.none
         else liveExprs.map(_ ++ newReferencedExpressions)
@@ -138,7 +138,14 @@ object CompoundSelect {
         SqlStr.join(compoundStrs)
       }
 
-      lhsStr + compound + sortOpt + limitOpt + offsetOpt
+      (lhsStr, compound, sortOpt, limitOpt, offsetOpt)
+    }
+
+    def render(liveExprs: LiveExprs) = {
+      prerender(liveExprs) match {
+        case (lhsStr, compound, sortOpt, limitOpt, offsetOpt) =>
+          lhsStr + compound + sortOpt + limitOpt + offsetOpt
+      }
     }
     def orderToSqlStr(newCtx: Context) =
       CompoundSelect.orderToSqlStr(query.orderBy, newCtx, gap = true)

scalasql/query/src/Delete.scala

@@ -1,8 +1,6 @@
 package scalasql.query
 
-import scalasql.core.DialectTypeMappers
-import scalasql.core.Context
-import scalasql.core.{Queryable, SqlStr, Expr}
+import scalasql.core.{Context, DialectTypeMappers, Expr, ExprsToSql, Queryable, SqlStr}
 import scalasql.core.SqlStr.SqlStringSyntax
 
 /**
@@ -26,6 +24,8 @@ object Delete {
     lazy val tableNameStr =
       SqlStr.raw(Table.fullIdentifier(table.value))
 
-    def render() = sql"DELETE FROM $tableNameStr WHERE $expr"
+    lazy val filtersOpt = SqlStr.flatten(ExprsToSql.booleanExprs(sql" WHERE ", expr :: Nil))
+
+    def render() = sql"DELETE FROM $tableNameStr$filtersOpt"
   }
 }