deusaquilus

// Sample report base-class:
trait Report {
  type T
  def apply(runtimeConf:MyConf)(encoder:spark.sql.Encoder[T]):Unit
}

// Sample implementation:
class OrdersReport {
  type T = OrderRecord
  def runReport(runtimeConf:MyConf)(encoder:spark.sql.Encoder[OrderRecord]):Unit

deusaquilus

package io.getquill

import io.getquill.context.ContextEffect
import io.getquill.context.jdbc.JdbcContextBase
import io.getquill.context.sql.idiom.SqlIdiom

// Need this to be able to defined 'effect' since that's a package-private so this file needs to reside in the 
// `io.getquill` package but it's the only thing that does.
trait JdbcContextBaseStub[Dialect <: SqlIdiom, Naming <: NamingStrategy] extends JdbcContextBase[Dialect, Naming] {
  private[getquill] val effect: ContextEffect[Result] = null

deusaquilus

import io.getquill._
import io.getquill.context.sql.norm._
import io.getquill.norm.capture.AvoidCapture
import io.getquill.ast._
import io.getquill.norm._ 
import io.getquill.context.sql._
import scala.annotation.tailrec 
import io.getquill.context.sql.idiom.VerifySqlQuery
import io.getquill.norm.capture.DemarcateExternalAliases

deusaquilus

implicit def astEq[T <: io.getquill.ast.Ast](implicit tt: scala.reflect.runtime.universe.TypeTag[T]) =
    new Equality[T] {
      def areEqual(a: T, b: Any): Boolean =
        b match {
          case p: io.getquill.ast.Ast => p.neutralize == a.neutralize
          case _                      => false
        }
    }

deusaquilus

// When doing a query like this (this is in the unit tests)
val q = quote {
        qr1.leftJoin(qr2).on {
          (a, b) =>
            a.i == b.i
        }.filter {
          ab => {
            val (a, b) = ab
            b.map(bv => bv.l).contains(3L)
          }

deusaquilus

trait FieldCollector[T] {
  def collect(fields: Collector): Collector
}
  
object FieldCollector {

  inline def collectFromChild[T](fields: ArrayBuffer[String]): Collector =
    summonFrom {
      case fc: FieldCollector[T] => fc.collect(fields)
    }

deusaquilus

// ********** Before: **********
// a.map(b => c).*join(d).on((iA, iB) => on)
//    a.*join(d).on((b, iB) => on[iA := c]).map(t => (c[b := t._1], t._2))
// Quat Equivalence: a.quat == b.quat == iA.quat
case Join(tpe, DetachableMap(a, b, c), d, iA, iB, on) =>
  val onr = BetaReduction(on, iA -> c)
  val t = Ident("t")
  val t1 = BetaReduction(c, b -> Property(t, "_1"))
  val t2 = Property(t, "_2")
  Some(Map(Join(tpe, a, d, b, iB, onr), t, Tuple(List(t1, t2))))

deusaquilus

/**
 * Only runtime, only for Direct entity Types. Do not support things with generic parameters like Query[T] etc...
 * This is needed because the quill-core/quill-sql JS use Scala JS which does not support TypeTags via the Dynamic Query API,
 * (the Macro API is fine to use them).
 */
object RuntimeEntityQuat {
  def apply[T](implicit ct: ClassTag[T]): Quat =
    forClassTopLevel(ct.runtimeClass)

deusaquilus

package io.getquill.sql.norm

import io.getquill.ast._
import io.getquill.ast.Implicits._
import io.getquill.norm.BetaReduction
import io.getquill.norm.TypeBehavior.{ ReplaceWithReduction => RWR }
import io.getquill.norm.Normalize
import io.getquill.quat.Quat

//    def nestedWithRenames(): Unit = {

deusaquilus

resolvers ++= Seq(
  ("OSS-Snapshots" at "https://oss.sonatype.org/service/local/repositories/snapshots/content/")
)
  
libraryDependencies ++= Seq(
  "io.getquill" %% "quill-sql" % "3.5.3-SNAPSHOT",
)