Escape table names (#73)

This PR here is somewhat a beginning of a conversation about how do we
want to make proper sql identifiers when it comes to schemas, tables and
columns, particularly for my use case I want this in order to use sql
reserved words for table names. I'll try to split this into 2 logical
parts:

**How do we know how to escape depending on db variant?**
A SQL 1999 rfc says that double quotes should be used in order to escape
an identifier, nevertheless:
- in mysql it is backticks
- in h2 when you escape you suddenly loose the ability to refer to a
table ignoring it's definition case: defining a table `T`, `SELECT *
from t` will work, `SELECT * from "t"` will not

Therefore it felt logical to make an escaping mechanism based on
`Dialect`. I didn't want to propagate `DialectConfig` together with
`Context` down the call chain, it seemed to me kinda redundant, so I
made `DialectConfig` part of `Context`. That's how we can access
escaping mechanism in various places as long as you have `Context`

**How do we decide which table to escape?**
With this PR I want to stick with tables, otherwise it can become too
big. I see three options:
1. escape all tables
2. escape based on list of reserved words per database variant
3. let user decide to escape

First options we already discarded as one that will change too much
tests. As for a second option - I looked into lists of reserved words,
and they are very different based on database, also it will not be fun
to maintain them, that's why most of the libs resolve to escape all
tables. Third option is most simple for now, since it will allow users
to opt-in when they want/bump into this issue, also it will allow us to
test mechanism first without changing all 1k+ tests, and perhaps we can
start with option 3 and then eventually move to option 1. Therefore in
this draft PR I made a flag in `Table` to opt in for escaping table
name.

_Optional_:
At the moment `DialectConfig` is kinda part of the `Dialect`, and I
don't feel entirely good about including whole `Dialect` in `Context`. I
kinda want to move `DialectConfig` into case class and make a separate
implicit for it as a part of `Dialect` so that when we need to construct
`Context` only `DialectConfig` case class will be picked up

It is a draft PR yet, so obviously I haven't written tests for all
cases, only for a simple `FROM` expression. This will follow when we
come to consensus about the implementation.
What do you guys think?
fixes #53

Author: NPCRUS

docs/reference.md

@@ -6552,11 +6552,13 @@ Buyer.select
 
 
 ## Schema
-Additional tests to ensure schema mapping produces valid SQL
+
+    If your table belongs to a schema other than the default schema of your database, you can specify this in your table definition with
+    `override def schemaName = "otherschema"`
+  
 ### Schema.schema.select
 
-If your table belongs to a schema other than the default schema of your database,
-you can specify this in your table definition with table.schemaName
+
 
 ```scala
 Invoice.select
@@ -6584,8 +6586,7 @@ Invoice.select
 
 ### Schema.schema.insert.columns
 
-If your table belongs to a schema other than the default schema of your database,
-you can specify this in your table definition with table.schemaName
+
 
 ```scala
 Invoice.insert.columns(
@@ -6611,8 +6612,7 @@ Invoice.insert.columns(
 
 ### Schema.schema.insert.values
 
-If your table belongs to a schema other than the default schema of your database,
-you can specify this in your table definition with table.schemaName
+
 
 ```scala
 Invoice.insert
@@ -6643,8 +6643,7 @@ Invoice.insert
 
 ### Schema.schema.update
 
-If your table belongs to a schema other than the default schema of your database,
-you can specify this in your table definition with table.schemaName
+
 
 ```scala
 Invoice
@@ -6677,8 +6676,7 @@ Invoice
 
 ### Schema.schema.delete
 
-If your table belongs to a schema other than the default schema of your database,
-you can specify this in your table definition with table.schemaName
+
 
 ```scala
 Invoice.delete(_.id === 1)
@@ -6701,8 +6699,7 @@ Invoice.delete(_.id === 1)
 
 ### Schema.schema.insert into
 
-If your table belongs to a schema other than the default schema of your database,
-you can specify this in your table definition with table.schemaName
+
 
 ```scala
 Invoice.insert.select(
@@ -6734,8 +6731,7 @@ Invoice.insert.select(
 
 ### Schema.schema.join
 
-If your table belongs to a schema other than the default schema of your database,
-you can specify this in your table definition with table.schemaName
+
 
 ```scala
 Invoice.select.join(Invoice)(_.id `=` _.id).map(_._1.id)
@@ -6760,6 +6756,139 @@ Invoice.select.join(Invoice)(_.id `=` _.id).map(_._1.id)
 
 
 
+## EscapedTableName
+
+    If your table name is a reserved sql world, e.g. `order`, you can specify this in your table definition with
+    `override def escape = true`
+  
+### EscapedTableName.escape table name.select
+
+
+
+```scala
+Select.select
+```
+
+
+*
+    ```sql
+    SELECT select0.id AS id, select0.name AS name
+    FROM "select" select0
+    ```
+
+
+
+*
+    ```scala
+    Seq.empty[Select[Sc]]
+    ```
+
+
+
+### EscapedTableName.escape table name.delete
+
+
+
+```scala
+Select.delete(_ => true)
+```
+
+
+*
+    ```sql
+    DELETE FROM "select" WHERE ?
+    ```
+
+
+
+*
+    ```scala
+    0
+    ```
+
+
+
+### EscapedTableName.escape table name.join
+
+
+
+```scala
+Select.select.join(Select)(_.id `=` _.id)
+```
+
+
+*
+    ```sql
+    SELECT
+      select0.id AS res_0_id,
+      select0.name AS res_0_name,
+      select1.id AS res_1_id,
+      select1.name AS res_1_name
+    FROM
+      "select" select0
+      JOIN "select" select1 ON (select0.id = select1.id)
+    ```
+
+
+
+*
+    ```scala
+    Seq.empty[(Select[Sc], Select[Sc])]
+    ```
+
+
+
+### EscapedTableName.escape table name.update
+
+
+
+```scala
+Select.update(_ => true).set(_.name := "hello")
+```
+
+
+*
+    ```sql
+    UPDATE "select" SET name = ?
+    ```
+
+
+
+*
+    ```scala
+    0
+    ```
+
+
+
+### EscapedTableName.escape table name.insert
+
+
+
+```scala
+Select.insert.values(
+  Select[Sc](
+    id = 0,
+    name = "hello"
+  )
+)
+```
+
+
+*
+    ```sql
+    INSERT INTO "select" (id, name) VALUES (?, ?)
+    ```
+
+
+
+*
+    ```scala
+    1
+    ```
+
+
+
 ## SubQuery
 Queries that explicitly use subqueries (e.g. for `JOIN`s) or require subqueries to preserve the Scala semantics of the various operators
 ### SubQuery.sortTakeJoin

scalasql/core/src/Context.scala

@@ -24,6 +24,8 @@ trait Context {
    */
   def config: Config
 
+  def dialectConfig: DialectConfig
+
   def withFromNaming(fromNaming: Map[Context.From, String]): Context
   def withExprNaming(exprNaming: Map[Expr.Identity, SqlStr]): Context
 }
@@ -56,7 +58,8 @@ object Context {
   case class Impl(
       fromNaming: Map[From, String],
       exprNaming: Map[Expr.Identity, SqlStr],
-      config: Config
+      config: Config,
+      dialectConfig: DialectConfig
   ) extends Context {
     def withFromNaming(fromNaming: Map[From, String]): Context = copy(fromNaming = fromNaming)
 
@@ -93,7 +96,7 @@ object Context {
               .map { case (e, s) => (e, sql"${SqlStr.raw(newFromNaming(t), Array(e))}.$s") }
           }
 
-    Context.Impl(newFromNaming, newExprNaming, prevContext.config)
+    Context.Impl(newFromNaming, newExprNaming, prevContext.config, prevContext.dialectConfig)
   }
 
 }

scalasql/core/src/DbApi.scala

@@ -125,17 +125,22 @@ trait DbApi extends AutoCloseable {
 
 object DbApi {
 
-  def unpackQueryable[R, Q](query: Q, qr: Queryable[Q, R], config: Config) = {
-    val ctx = Context.Impl(Map(), Map(), config)
+  def unpackQueryable[R, Q](
+      query: Q,
+      qr: Queryable[Q, R],
+      config: Config,
+      dialectConfig: DialectConfig
+  ) = {
+    val ctx = Context.Impl(Map(), Map(), config, dialectConfig)
     val flattened = SqlStr.flatten(qr.renderSql(query, ctx))
     flattened
   }
 
-  def renderSql[Q, R](query: Q, config: Config, castParams: Boolean = false)(
+  def renderSql[Q, R](query: Q, config: Config, dialectConfig: DialectConfig)(
       implicit qr: Queryable[Q, R]
   ): String = {
-    val flattened = unpackQueryable(query, qr, config)
-    flattened.renderSql(castParams)
+    val flattened = unpackQueryable(query, qr, config, dialectConfig)
+    flattened.renderSql(dialectConfig.castParams)
   }
 
   /**
@@ -254,7 +259,7 @@ object DbApi {
         lineNum: sourcecode.Line
     ): R = {
 
-      val flattened = unpackQueryable(query, qr, config)
+      val flattened = unpackQueryable(query, qr, config, dialect)
       if (qr.isGetGeneratedKeys(query).nonEmpty)
         updateGetGeneratedKeysSql(flattened)(qr.isGetGeneratedKeys(query).get, fileName, lineNum)
           .asInstanceOf[R]
@@ -284,7 +289,7 @@ object DbApi {
         fileName: sourcecode.FileName,
         lineNum: sourcecode.Line
     ): Generator[R] = {
-      val flattened = unpackQueryable(query, qr, config)
+      val flattened = unpackQueryable(query, qr, config, dialect)
       streamFlattened0(
         r => {
           qr.asInstanceOf[Queryable[Q, R]].construct(query, r) match {
@@ -335,7 +340,7 @@ object DbApi {
     ): Int = {
       val flattened = SqlStr.flatten(sql)
       runRawUpdate0(
-        flattened.renderSql(DialectConfig.castParams(dialect)),
+        flattened.renderSql(dialect.castParams),
         flattenParamPuts(flattened),
         fetchSize,
         queryTimeoutSeconds,
@@ -355,7 +360,7 @@ object DbApi {
     ): IndexedSeq[R] = {
       val flattened = SqlStr.flatten(sql)
       runRawUpdateGetGeneratedKeys0(
-        flattened.renderSql(DialectConfig.castParams(dialect)),
+        flattened.renderSql(dialect.castParams),
         flattenParamPuts(flattened),
         fetchSize,
         queryTimeoutSeconds,
@@ -441,7 +446,7 @@ object DbApi {
         lineNum: sourcecode.Line
     ) = streamRaw0(
       construct,
-      flattened.renderSql(DialectConfig.castParams(dialect)),
+      flattened.renderSql(dialect.castParams),
       flattenParamPuts(flattened),
       fetchSize,
       queryTimeoutSeconds,
@@ -567,7 +572,7 @@ object DbApi {
     def renderSql[Q, R](query: Q, castParams: Boolean = false)(
         implicit qr: Queryable[Q, R]
     ): String = {
-      DbApi.renderSql(query, config, castParams)
+      DbApi.renderSql(query, config, dialect.withCastParams(castParams))
     }
 
     val savepointStack = collection.mutable.ArrayDeque.empty[java.sql.Savepoint]

scalasql/core/src/DbClient.scala

@@ -68,7 +68,7 @@ object DbClient {
     def renderSql[Q, R](query: Q, castParams: Boolean = false)(
         implicit qr: Queryable[Q, R]
     ): String = {
-      DbApi.renderSql(query, config, castParams)
+      DbApi.renderSql(query, config, dialect.withCastParams(castParams))
     }
 
     def transaction[T](block: DbApi.Txn => T): T = {
@@ -127,7 +127,7 @@ object DbClient {
     def renderSql[Q, R](query: Q, castParams: Boolean = false)(
         implicit qr: Queryable[Q, R]
     ): String = {
-      DbApi.renderSql(query, config, castParams)
+      DbApi.renderSql(query, config, dialect.withCastParams(castParams))
     }
 
     private def withConnection[T](f: DbClient.Connection => T): T = {

scalasql/core/src/DialectConfig.scala

@@ -1,9 +1,13 @@
 package scalasql.core
 
-trait DialectConfig {
-  protected def dialectCastParams: Boolean
-}
+trait DialectConfig { that =>
+  def castParams: Boolean
+  def escape(str: String): String
+
+  def withCastParams(params: Boolean) = new DialectConfig {
+    def castParams: Boolean = params
+
+    def escape(str: String): String = that.escape(str)
 
-object DialectConfig {
-  def castParams(d: DialectConfig) = d.dialectCastParams
+  }
 }

scalasql/query/src/Delete.scala

@@ -24,7 +24,7 @@ object Delete {
   class Renderer(table: TableRef, expr: Expr[Boolean], prevContext: Context) {
     implicit val implicitCtx: Context = Context.compute(prevContext, Nil, Some(table))
     lazy val tableNameStr =
-      SqlStr.raw(Table.resolve(table.value))
+      SqlStr.raw(Table.fullIdentifier(table.value))
 
     def render() = sql"DELETE FROM $tableNameStr WHERE $expr"
   }

scalasql/query/src/From.scala

@@ -15,7 +15,7 @@ class TableRef(val value: Table.Base) extends From {
   def fromExprAliases(prevContext: Context): Seq[(Expr.Identity, SqlStr)] = Nil
 
   def renderSql(name: SqlStr, prevContext: Context, liveExprs: LiveExprs) = {
-    val resolvedTable = Table.resolve(value)(prevContext)
+    val resolvedTable = Table.fullIdentifier(value)(prevContext)
     SqlStr.raw(resolvedTable + sql" " + name)
   }
 }

scalasql/query/src/InsertColumns.scala

@@ -24,7 +24,7 @@ object InsertColumns {
     protected def expr: V[Column] = WithSqlExpr.get(insert)
 
     private[scalasql] override def renderSql(ctx: Context) =
-      new Renderer(columns, ctx, valuesLists, Table.resolve(table.value)(ctx)).render()
+      new Renderer(columns, ctx, valuesLists, Table.fullIdentifier(table.value)(ctx)).render()
 
     override protected def queryConstruct(args: Queryable.ResultSetIterator): Int =
       args.get(IntType)