eliminate joinableToSelect and joinableIsTrivial

scalasql/query/src/CompoundSelect.scala

@@ -92,6 +92,12 @@ class CompoundSelect[Q, R](
   override protected def selectExprAliases(prevContext: Context): Map[Expr.Identity, SqlStr] = {
     SubqueryRef.Wrapped.exprAliases(lhs, prevContext)
   }
+
+  override def joinFromExpr = {
+    val otherSelect = joinableToSelect
+    val otherFrom = new SubqueryRef(otherSelect)
+    (otherFrom, WithSqlExpr.get(otherSelect))
+  }
 }
 
 object CompoundSelect {

scalasql/query/src/JoinOps.scala

@@ -32,7 +32,7 @@ trait JoinOps[C[_, _], Q, R] extends WithSqlExpr[Q] {
       on: Option[(Q, Q2) => Expr[Boolean]]
   ) = {
 
-    val (otherFrom, otherExpr) = other.joinFrom
+    val (otherFrom, otherExpr) = other.joinFromExpr
 
     val otherOn = on.map(_(expr, otherExpr))
     val otherJoin = Join(joinPrefix, Seq(Join.From(otherFrom, otherOn)))

scalasql/query/src/Joinable.scala

@@ -6,19 +6,10 @@ import scalasql.core.{Context, Expr, JoinNullable, WithSqlExpr}
  * Something that can be joined; typically a [[Select]] or a [[Table]]
  */
 trait Joinable[Q, R] {
-  protected def joinableToSelect: Select[Q, R]
-  protected def joinableIsTrivial: Boolean
 
   protected def joinableToFromExpr: (Context.From, Q)
 
-  def joinFrom = {
-    val otherSelect = joinableToSelect
-    val otherFrom =
-      if (joinableIsTrivial) otherSelect.asInstanceOf[SimpleSelect[_, _]].from.head
-      else new SubqueryRef(otherSelect)
-
-    (otherFrom, WithSqlExpr.get(otherSelect))
-  }
+  def joinFromExpr: (Context.From, Q)
   /**
    * Version of `crossJoin` meant for usage in `for`-comprehensions
    */
@@ -52,6 +43,4 @@ trait Joinable[Q, R] {
 }
 object Joinable {
   def toFromExpr[Q, R](x: Joinable[Q, R]) = x.joinableToFromExpr
-  def toSelect[Q, R](x: Joinable[Q, R]) = x.joinableToSelect
-  def isTrivial[Q, R](x: Joinable[Q, R]) = x.joinableIsTrivial
 }

scalasql/query/src/SimpleSelect.scala

@@ -232,6 +232,8 @@ class SimpleSelect[Q, R](
   override protected def queryConstruct(args: Queryable.ResultSetIterator): Seq[R] = {
     Seq(qr.construct(args))
   }
+
+  override def joinFromExpr = (from.head, expr)
 }
 
 object SimpleSelect {

scalasql/query/src/Values.scala

@@ -1,14 +1,6 @@
 package scalasql.query
 
-import scalasql.core.{
-  Context,
-  DialectTypeMappers,
-  LiveSqlExprs,
-  Queryable,
-  Expr,
-  SqlStr,
-  TypeMapper
-}
+import scalasql.core.{Context, DialectTypeMappers, Expr, LiveSqlExprs, Queryable, SqlStr, TypeMapper, WithSqlExpr}
 import scalasql.core.SqlStr.{Renderable, SqlStringSyntax}
 
 /**
@@ -37,6 +29,12 @@ class Values[Q, R](val ts: Seq[R])(
       .map { case (e, i) => (Expr.identity(e), SqlStr.raw(columnName(i))) }
       .toMap
   }
+
+  override def joinFromExpr = {
+    val otherSelect = joinableToSelect
+    val otherFrom = new SubqueryRef(otherSelect)
+    (otherFrom, WithSqlExpr.get(otherSelect))
+  }
 }
 
 object Values {

scalasql/query/src/WithCte.scala

@@ -51,6 +51,11 @@ class WithCte[Q, R](
 
   override protected def queryConstruct(args: Queryable.ResultSetIterator): Seq[R] =
     Query.construct(rhs, args)
+
+  def joinFromExpr = {
+    val otherSelect = joinableToSelect
+    (new SubqueryRef(otherSelect), WithSqlExpr.get(otherSelect))
+  }
 }
 
 object WithCte {
@@ -60,6 +65,13 @@ object WithCte {
       val qr: Queryable.Row[Q, R],
       protected val dialect: DialectTypeMappers
   ) extends Select.Proxy[Q, R] {
+
+    def joinFromExpr = {
+      val otherSelect = joinableToSelect
+      val otherFrom = otherSelect.asInstanceOf[SimpleSelect[_, _]].from.head
+      (otherFrom, WithSqlExpr.get(otherSelect))
+    }
+
     override def joinableIsTrivial = true
     protected override def joinableToSelect = selectToSimpleSelect()
     override protected def selectToSimpleSelect(): SimpleSelect[Q, R] = {

scalasql/src/dialects/TableOps.scala

@@ -1,9 +1,9 @@
 package scalasql.dialects
 
 import scalasql.dialects.Dialect
-import scalasql.core.Expr
+import scalasql.core.{Expr, WithSqlExpr}
 import scalasql.Sc
-import scalasql.query.{Column, Delete, Insert, Joinable, Select, SimpleSelect, Table, Update}
+import scalasql.query.{Column, Delete, Insert, Joinable, Select, SimpleSelect, SubqueryRef, Table, Update}
 
 class TableOps[V[_[_]]](val t: Table[V])(implicit dialect: Dialect)
     extends Joinable[V[Expr], V[Sc]] {
@@ -63,4 +63,10 @@ class TableOps[V[_[_]]](val t: Table[V])(implicit dialect: Dialect)
   }
 
   protected def joinableIsTrivial = true
+
+  override def joinFromExpr = {
+    val (ref, expr) = toFromExpr0
+
+    (ref, expr.asInstanceOf[V[Expr]])
+  }
 }