experiment with pre-computing tuple type

evidence not to go with plain named tuples

further wip

work with projecting named tupke type into the record

Author: bishabosha

build.mill

@@ -76,7 +76,7 @@ trait Common extends CommonBase with CrossScalaModule
 object `scalasql-namedtuples` extends CommonBase {
   def scalaVersion: T[String] = scala3NamedTuples
   def millSourcePath: os.Path = scalasql(scala3).millSourcePath / "namedtuples"
-  def moduleDeps: Seq[PublishModule] = Seq(scalasql(scala3).query)
+  def moduleDeps: Seq[PublishModule] = Seq(scalasql(scala3))
 
   // override def scalacOptions: Target[Seq[String]] = T {
   //   super.scalacOptions() :+ "-Xprint:inlining"

scalasql/namedtuples/src/SimpleTable.scala

@@ -1,48 +1,89 @@
 package scalasql.namedtuples
 
-import scala.NamedTuple.AnyNamedTuple
-
-import scalasql.query.Table
+import scalasql.core.DbApi.Impl
 import scalasql.core.DialectTypeMappers
+import scalasql.core.Expr
 import scalasql.core.Queryable
-import scalasql.query.Column
+import scalasql.core.Queryable.ResultSetIterator
 import scalasql.core.Sc
-import scalasql.core.Expr
+import scalasql.dialects.Dialect
+import scalasql.dialects.TableOps
+import scalasql.namedtuples.SimpleTable.Internal.Tombstone
+import scalasql.query.Column
+import scalasql.query.Query
+import scalasql.query.Table
+import scalasql.query.Table.ImplicitMetadata
+import sourcecode.Name
+
+import scala.NamedTuple.AnyNamedTuple
+import scala.language.implicitConversions
+
+class SimpleTable[C]()(
+    using val name0: sourcecode.Name,
+    metadata0: => SimpleTable.Metadata[C]
+) extends Table.Base
+    with SimpleTable.LowPri[C] {
+
+  lazy val metadata: SimpleTable.Metadata[C] = metadata0
+
+  override protected[scalasql] def tableName: String = name0.value
+
+  override protected[scalasql] def schemaName: String = ""
+
+  override protected[scalasql] def tableLabels: Seq[String] = {
+    metadata.metadata0.walkLabels0()
+  }
+
+  override protected[scalasql] def escape: Boolean = false
 
-class SimpleTable[C <: SimpleTable.Source]()(
-    using name: sourcecode.Name,
-    metadata0: SimpleTable.Metadata[C]
-) extends Table[SimpleTable.Lift[C]](using name, metadata0.metadata0) {
   given simpleTableImplicitMetadata: SimpleTable.WrappedMetadata[C] =
-    SimpleTable.WrappedMetadata(metadata0)
+    SimpleTable.WrappedMetadata(metadata)
+
+  implicit def containerQr(
+      implicit dialect: DialectTypeMappers,
+      f: SimpleTableMacros.Mask[C]
+  ): Queryable.Row[f.Result[Expr], C] =
+    val tableMetadata = metadata.metadata0
+    tableMetadata
+      .queryable(
+        tableMetadata.walkLabels0,
+        dialect,
+        new Table.Metadata.QueryableProxy(tableMetadata.queryables(dialect, _))
+      )
+      .asInstanceOf[Queryable.Row[f.Result[Expr], C]]
 }
 
 object SimpleTable {
 
-  /**
-   * Marker class that signals that a data type is convertable to an SQL table row.
-   * @note this must be a class to convince the match type reducer that it provably can't be mixed
-   *  into various column types such as java.util.Date, geny.Bytes, or scala.Option.
-   */
-  abstract class Source
-
-  type Lift[C] = [T[_]] =>> T[Internal.Tombstone.type] match {
-    case Expr[?] => Record[C, T]
-    case _ => C
+  trait LowPri[C] { this: SimpleTable[C] =>
+    implicit def containerQr2(
+        implicit dialect: DialectTypeMappers,
+        f: SimpleTableMacros.Mask[C]
+    ): Queryable.Row[f.Result[Column], C] =
+      containerQr.asInstanceOf[Queryable.Row[f.Result[Column], C]]
   }
 
-  final class Record[C, T[_]](data: IArray[AnyRef]) extends Selectable:
-    type Fields = NamedTuple.Map[
-      NamedTuple.From[C],
-      [X] =>> X match {
-        case Source => Record[X, T]
-        case _ => T[X]
-      }
-    ]
+  implicit def TableOpsConv[C: {SimpleTableMacros.Mask as f}](
+      t: SimpleTable[C]
+  )(using dialect: Dialect): TableOps[f.Result] =
+    // assume types in f.Result matches
+    val tableMetadata = t.metadata.metadata0.asInstanceOf[Table.Metadata[f.Result]]
+    dialect.TableOpsConv(new Table[f.Result](using t.name0, tableMetadata) {
+      override protected[scalasql] def tableName: String = t.tableName
+
+      override protected[scalasql] def schemaName: String = t.schemaName
+
+      override protected[scalasql] def tableLabels: Seq[String] = t.tableLabels
+
+      override protected[scalasql] def escape: Boolean = t.escape
+    })
+
+  final class Record[C, Mask <: AnyNamedTuple](data: IArray[AnyRef]) extends Selectable:
+    type Fields = Mask
     def recordIterator: Iterator[Any] = data.iterator.asInstanceOf[Iterator[Any]]
     def apply(i: Int): AnyRef = data(i)
-    def updates(fs: ((u: RecordUpdater[C, T]) => u.Patch)*): Record[C, T] =
-      val u = recordUpdater[C, T]
+    def updates(fs: ((u: RecordUpdater[C, Mask]) => u.Patch)*): Record[C, Mask] =
+      val u = recordUpdater[C, Mask]
       val arr = IArray.genericWrapArray(data).toArray
       fs.foreach: f =>
         val patch = f(u)
@@ -53,17 +94,14 @@ object SimpleTable {
     inline def selectDynamic(name: String): AnyRef =
       apply(compiletime.constValue[Record.IndexOf[name.type, Record.Names[C], 0]])
 
-  private object RecordUpdaterImpl extends RecordUpdater[Any, [T] =>> Any]
-  def recordUpdater[C, T[_]]: RecordUpdater[C, T] =
-    RecordUpdaterImpl.asInstanceOf[RecordUpdater[C, T]]
-  sealed trait RecordUpdater[C, T[_]] extends Selectable:
+  private object RecordUpdaterImpl extends RecordUpdater[Any, AnyNamedTuple]
+  def recordUpdater[C, Mask <: AnyNamedTuple]: RecordUpdater[C, Mask] =
+    RecordUpdaterImpl.asInstanceOf[RecordUpdater[C, Mask]]
+  sealed trait RecordUpdater[C, Mask <: AnyNamedTuple] extends Selectable:
     final case class Patch(idx: Int, f: AnyRef => AnyRef)
     type Fields = NamedTuple.Map[
-      NamedTuple.From[C],
-      [X] =>> X match {
-        case Source => (Record[X, T] => Record[X, T]) => Patch
-        case _ => (T[X] => T[X]) => Patch
-      }
+      Mask,
+      [X] =>> (X => X) => Patch
     ]
     def apply(i: Int): (AnyRef => AnyRef) => Patch =
       f => Patch(i, f)
@@ -78,7 +116,7 @@ object SimpleTable {
       case N *: _ => Acc
       case _ *: t => IndexOf[N, t, S[Acc]]
     }
-    def fromIArray(data: IArray[AnyRef]): Record[Any, [T] =>> Any] =
+    def fromIArray(data: IArray[AnyRef]): Record[Any, AnyNamedTuple] =
       Record(data)
 
   object Internal {
@@ -92,17 +130,19 @@ object SimpleTable {
       def metadata: Metadata[C] = m
     }
   }
-  class Metadata[C](val metadata0: Table.Metadata[Lift[C]]):
+  class Metadata[C](val f: SimpleTableMacros.Mask[C])(
+      val metadata0: Table.Metadata[f.Result]
+  ):
     def rowExpr(
         mappers: DialectTypeMappers
-    ): Queryable.Row[Record[C, Expr], C] =
+    ): Queryable.Row[f.Result[Expr], C] =
       metadata0
         .queryable(
           metadata0.walkLabels0,
           mappers,
           new Table.Metadata.QueryableProxy(metadata0.queryables(mappers, _))
         )
-        .asInstanceOf[Queryable.Row[Record[C, Expr], C]]
+        .asInstanceOf[Queryable.Row[f.Result[Expr], C]]
 
   object Metadata extends SimpleTableMacros
 }

scalasql/namedtuples/src/SimpleTableMacros.scala

@@ -15,8 +15,78 @@ import java.util.function.UnaryOperator
 import scala.annotation.nowarn
 import scalasql.namedtuples.SimpleTableMacros.BaseLabels
 import scalasql.core.TypeMapper
+import scala.annotation.tailrec
 
 object SimpleTableMacros {
+
+  trait Mask[C]:
+    type Result[T[_]] <: SimpleTable.Record[C, ?] | C
+
+  object Mask:
+    import scala.quoted.{Expr as QExpr, *}
+    object Impl extends Mask[Any]:
+      type Result[T[_]] = Any
+
+    transparent inline given [C]: Mask[C] = ${ compute[C, NamedTuple.From[C]] }
+
+    def compute[C: Type, A <: AnyNamedTuple: Type](using Quotes): QExpr[Mask[C]] =
+      computeRoot[C, NamedTuple.Names[A], NamedTuple.DropNames[A]]
+
+    def computeRoot[C: Type, N <: Tuple: Type, V <: Tuple: Type](
+        using Quotes
+    ): QExpr[Mask[C]] =
+      compute1[C, N, V](Nil) match
+        case Some('[type res[T[_]] <: SimpleTable.Record[C, ?]; res]) =>
+          '{
+            Impl.asInstanceOf[
+              Mask[
+                C
+              ] {
+                type Result[T[_]] = T[SimpleTable.Internal.Tombstone.type] match
+                  case Expr[?] => res[T]
+                  case _ => C
+              }
+            ]
+          }
+        case _ =>
+          '{
+            compiletime.error(
+              "Cannot find a Mask instance for the given type. Please ensure that the type is a case class or a named tuple."
+            )
+          }
+
+    @tailrec
+    def compute1[C: Type, N <: Tuple: Type, V <: Tuple: Type](acc: List[Type[?]])(
+        using Quotes
+    ): Option[Type[?]] =
+      Type.of[V] match
+        case '[type vs <: Tuple; (v *: `vs`)] =>
+          QExpr.summon[SimpleTable.WrappedMetadata[v]] match
+            case Some(_) =>
+              computeRec[v] match
+                case Some(res) =>
+                  compute1[C, N, vs](res :: acc)
+                case _ =>
+                  None
+            case _ =>
+              compute1[C, N, vs](Type.of[[T[_]] =>> T[v]] :: acc)
+        case '[EmptyTuple] =>
+          val tpes =
+            acc.reverse.foldRight(Type.of[[T[_]] =>> EmptyTuple].asInstanceOf[Type[?]])(
+              (tpe, acc) =>
+                ((tpe, acc): @unchecked) match {
+                  case ('[type tpe[T[_]]; `tpe`], '[type acc[T[_]] <: Tuple; `acc`]) =>
+                    Type.of[[T[_]] =>> tpe[T] *: acc[T]]
+                }
+            )
+          tpes match
+            case '[type tpes[T[_]] <: Tuple; `tpes`] =>
+              Some(Type.of[[T[_]] =>> SimpleTable.Record[C, NamedTuple.NamedTuple[N, tpes[T]]]])
+
+    def computeRec[V: Type](using Quotes): Option[Type[?]] =
+      type vNT = NamedTuple.From[V]
+      compute1[V, NamedTuple.Names[vNT], NamedTuple.DropNames[vNT]](Nil)
+
   def asIArray[T: ClassTag](t: Tuple): IArray[T] = {
     IArray.from(t.productIterator.asInstanceOf[Iterator[T]])
   }
@@ -143,9 +213,9 @@ object SimpleTableMacros {
     factory(buf.result())
   }
 
-  def deconstruct[R <: SimpleTable.Record[?, ?]](
+  def deconstruct(
       queryable: Table.Metadata.QueryableProxy
-  )(c: Product): R = {
+  )(c: Product): SimpleTable.Record[?, ?] = {
     var i = 0
     val buf = IArray.newBuilder[AnyRef]
     val fields = c.productIterator
@@ -156,15 +226,16 @@ object SimpleTableMacros {
       val row = queryable[Field, T](i)
       buf += row.deconstruct(field).asInstanceOf[AnyRef]
       i += 1
-    SimpleTable.Record.fromIArray(buf.result()).asInstanceOf[R]
+    SimpleTable.Record.fromIArray(buf.result())
   }
 
 }
 
 trait SimpleTableMacros {
-  inline given initTableMetadata[C <: Product & SimpleTable.Source]: SimpleTable.Metadata[C] =
+  inline given initTableMetadata: [C <: Product]
+    => (f: SimpleTableMacros.Mask[C]) => SimpleTable.Metadata[C] =
     def m = compiletime.summonInline[Mirror.ProductOf[C]]
-    type Impl = SimpleTable.Lift[C]
+    type Impl = f.Result
     type Labels = NamedTuple.Names[NamedTuple.From[C]]
     type Values = NamedTuple.DropNames[NamedTuple.From[C]]
     type Size = NamedTuple.Size[NamedTuple.From[C]]
@@ -197,17 +268,19 @@ trait SimpleTableMacros {
         walkLabels0: () => Seq[String],
         @nowarn("msg=unused") mappers: DialectTypeMappers,
         queryable: Table.Metadata.QueryableProxy
-    ): Queryable[Impl[Expr], Impl[Sc]] = Table.Internal.TableQueryable(
-      walkLabels0,
-      walkExprs0 = SimpleTableMacros.walkAllExprs(queryable),
-      construct0 = args =>
-        SimpleTableMacros.construct(queryable)(
-          size = compiletime.constValue[Size],
-          args = args,
-          factory = SimpleTableMacros.make(m, _)
-        ),
-      deconstruct0 = values => SimpleTableMacros.deconstruct[Impl[Expr]](queryable)(values)
-    )
+    ): Queryable[Impl[Expr], Impl[Sc]] = Table.Internal
+      .TableQueryable(
+        walkLabels0,
+        walkExprs0 = SimpleTableMacros.walkAllExprs(queryable),
+        construct0 = args =>
+          SimpleTableMacros.construct(queryable)(
+            size = compiletime.constValue[Size],
+            args = args,
+            factory = SimpleTableMacros.make(m, _)
+          ),
+        deconstruct0 = values => SimpleTableMacros.deconstruct(queryable)(values)
+      )
+      .asInstanceOf[Queryable[Impl[Expr], Impl[Sc]]]
 
     def vExpr0(
         tableRef: TableRef,
@@ -221,5 +294,5 @@ trait SimpleTableMacros {
 
     val metadata0 = Table.Metadata[Impl](queryables, walkLabels0, queryable, vExpr0)
 
-    SimpleTable.Metadata(metadata0)
+    SimpleTable.Metadata(f)(metadata0)
 }

scalasql/namedtuples/test/src/datatypes/LargeObjectTest.scala

@@ -220,7 +220,7 @@ case class LargeObjectA(
     a198: Int,
     a199: Int,
     b: LargeObjectB
-) extends SimpleTable.Source
+)
 object LargeObjectA extends SimpleTable[LargeObjectA]
 
 case class LargeObjectB(
@@ -424,7 +424,7 @@ case class LargeObjectB(
     b197: Int,
     b198: Int,
     b199: Int
-) extends SimpleTable.Source
+)
 object LargeObjectB extends SimpleTable[LargeObjectB]
 
 case class LargeObjectC(
@@ -628,5 +628,5 @@ case class LargeObjectC(
     c197: Int,
     c198: Int,
     c199: Int
-) extends SimpleTable.Source
+)
 object LargeObjectC extends SimpleTable[LargeObjectC]