continue

quill-sql/src/main/scala/io/getquill/MyTestSql.scala

@@ -0,0 +1,22 @@
+package io.getquill
+
+object MyTestSql {
+
+  val ctx = new SqlMirrorContext(MirrorSqlDialect, Literal)
+  import ctx._
+
+  case class Holder(value: String, sv: Int)
+
+  def main(args: Array[String]): Unit = {
+
+    val q = quote {
+      query[Holder].join(query[Holder])
+        .on(_.value == _.value)
+        .map({case (a,b) => ((a.value, a.sv), (b.value, b.sv))})
+        .map(_._1._2)
+    }
+
+    println(run(q).string)
+
+  }
+}

quill-sql/src/main/scala/io/getquill/OracleDialect.scala

@@ -32,6 +32,29 @@ trait OracleDialect
     case other                      => super.sourceTokenizer.token(other)
   }
 
+  override implicit def identTokenizer(implicit astTokenizer: Tokenizer[Ast], strategy: NamingStrategy): Tokenizer[Ident] =
+    Tokenizer[Ident](e =>
+      if (e.name.startsWith("_"))
+        Escape.default(e.name).token
+      else
+        strategy.default(e.name).token
+    )
+
+  override implicit def propertyTokenizer(implicit astTokenizer: Tokenizer[Ast], strategy: NamingStrategy): Tokenizer[Property] = {
+    Tokenizer[Property] {
+      case Property(ast, name) =>
+        unnest(ast) match {
+          case (ast, prefix) => {
+            val column = prefix.mkString + name
+            if (column.startsWith("_"))
+              stmt"${scopedTokenizer(ast)}.${Escape.column(column).token}"
+            else
+              stmt"${scopedTokenizer(ast)}.${strategy.column(column).token}"
+          }
+        }
+    }
+  }
+
   override def prepareForProbing(string: String) = string
 }
 

quill-sql/src/main/scala/io/getquill/context/sql/idiom/SqlIdiom.scala

@@ -273,21 +273,21 @@ trait SqlIdiom extends Idiom {
     case SetOperator.`contains`      => stmt"IN"
   }
 
-  implicit def propertyTokenizer(implicit astTokenizer: Tokenizer[Ast], strategy: NamingStrategy): Tokenizer[Property] = {
+  protected def unnest(ast: Ast): (Ast, List[String]) =
+    ast match {
+      case Property(a, name) if (name.matches("_[0-9]*")) =>
+        unnest(a) match {
+          case (ast, nestedName) =>
+            (ast, nestedName :+ name)
+        }
+      case Property(a, name) =>
+        unnest(a) match {
+          case (a, nestedName) => (a, nestedName)
+        }
+      case a => (a, Nil)
+    }
 
-    def unnest(ast: Ast): (Ast, List[String]) =
-      ast match {
-        case Property(a, name) if (name.matches("_[0-9]*")) =>
-          unnest(a) match {
-            case (ast, nestedName) =>
-              (ast, nestedName :+ name)
-          }
-        case Property(a, name) =>
-          unnest(a) match {
-            case (a, nestedName) => (a, nestedName)
-          }
-        case a => (a, Nil)
-      }
+  implicit def propertyTokenizer(implicit astTokenizer: Tokenizer[Ast], strategy: NamingStrategy): Tokenizer[Property] = {
     Tokenizer[Property] {
       case Property(ast, name) =>
         unnest(ast) match {