record SimpleTable tests in reference.md

Author: bishabosha

docs/generateDocs.mill

@@ -69,11 +69,14 @@ def generateTutorial(sourcePath: os.Path, destPath: os.Path) =  {
 }
 def generateReference(dest: os.Path, scalafmtCallback: (Seq[os.Path], os.Path) => Unit) =  {
   def dropExprPrefix(s: String) = s.split('.').drop(2).mkString(".")
+  def dropNTExprPrefix(s: String) = s.split('.').drop(3).mkString(".")
   val records = upickle.default.read[Seq[Record]](os.read.stream(mill.api.WorkspaceRoot.workspaceRoot / "out" / "recordedTests.json"))
+  val ntRecords = upickle.default.read[Seq[Record]](os.read.stream(mill.api.WorkspaceRoot.workspaceRoot / "out" / "recordedTestsNT.json"))
   val suiteDescriptions = upickle.default.read[Map[String, String]](os.read.stream(mill.api.WorkspaceRoot.workspaceRoot / "out" / "recordedSuiteDescriptions.json"))
     .map{case (k, v) => (dropExprPrefix(k), v)}
 
-  val rawScalaStrs = records.flatMap(r => Seq(r.queryCodeString) ++ r.resultCodeString)
+  val rawScalaStrs = (records ++ ntRecords)
+    .flatMap(r => Seq(r.queryCodeString) ++ r.resultCodeString)
   val formattedScalaStrs = {
     val tmps = rawScalaStrs.map(os.temp(_, suffix = ".scala"))
     scalafmtCallback(tmps, mill.api.WorkspaceRoot.workspaceRoot / ".scalafmt.conf")
@@ -155,15 +158,26 @@ def generateReference(dest: os.Path, scalafmtCallback: (Seq[os.Path], os.Path) =
     .sortBy(_._2.head.suiteLine)
     .distinctBy { case (k, v) => dropExprPrefix(k)}
     .map{case (k, vs) => (dropExprPrefix(k), vs.map(r => r.copy(suiteName = dropExprPrefix(r.suiteName))))}
+  val ntRecordsWithoutDuplicateSuites = ntRecords
+    .groupBy(_.suiteName)
+    .toSeq
+    .sortBy(_._2.head.suiteLine)
+    .distinctBy { case (k, v) => dropNTExprPrefix(k)}
+    .map{case (k, vs) => (dropNTExprPrefix(k), vs.map(r => r.copy(suiteName = dropNTExprPrefix(r.suiteName))))}
+    .toMap
 
   for((suiteName, suiteGroup) <- recordsWithoutDuplicateSuites) {
     val seen = mutable.Set.empty[String]
     outputLines.append(s"## $suiteName")
     outputLines.append(suiteDescriptions(suiteName))
     var lastSeen = ""
-    for(r <- suiteGroup){
-
-      val prettyName = (r.suiteName +: r.testPath).mkString(".")
+    var remainingNTRecords = ntRecordsWithoutDuplicateSuites
+      .get(suiteName)
+      .getOrElse(Seq.empty).groupBy {r =>
+        val prettyName = (r.suiteName +: r.testPath).mkString(".")
+        prettyName
+      }
+    def addRecord(r: Record, prettyName: String) = {
       val titleOpt =
         if (prettyName == lastSeen) Some("----")
         else if (!seen(prettyName)) Some(s"### $prettyName")
@@ -174,21 +188,29 @@ def generateReference(dest: os.Path, scalafmtCallback: (Seq[os.Path], os.Path) =
         lastSeen = prettyName
         outputLines.append(
           s"""$title
-             |
-             |${dedent(r.docs, "")}
-             |
-             |```scala
-             |${scalafmt(r.queryCodeString)}
-             |```
-             |
-             |${sqlFormat(r.sqlString)}
-             |
-             |${renderResult(r.resultCodeString)}
-             |
-             |""".stripMargin
+            |
+            |${dedent(r.docs, "")}
+            |
+            |```scala
+            |${scalafmt(r.queryCodeString)}
+            |```
+            |
+            |${sqlFormat(r.sqlString)}
+            |
+            |${renderResult(r.resultCodeString)}
+            |
+            |""".stripMargin
         )
       }
     }
+    for(r <- suiteGroup){
+      val prettyName = (r.suiteName +: r.testPath).mkString(".")
+      addRecord(r, prettyName)
+      remainingNTRecords -= prettyName
+    }
+    for((prettyName, rs) <- remainingNTRecords; r <- rs) {
+      addRecord(r, prettyName)
+    }
   }
   os.write.over(dest, outputLines.mkString("\n"))
 }

docs/reference.md

@@ -10286,6 +10286,80 @@ result._2 ==> None
 
 
 
+### DataTypes.enclosing - with SimpleTable
+
+You can nest `case class`es in other `case class`es to DRY up common sets of
+table columns. These nested `case class`es have their columns flattened out
+into the enclosing `case class`'s columns, such that at the SQL level it is
+all flattened out without nesting.
+
+**Important**: When using nested `case class`es with `SimpleTable`,
+make sure to extend `SimpleTable.Nested` in the nested class.
+
+```scala
+// case class Nested(
+//   fooId: Int,
+//   myBoolean: Boolean,
+// ) extends SimpleTable.Nested
+// object Nested extends SimpleTable[Nested]
+//
+// case class Enclosing(
+//     barId: Int,
+//     myString: String,
+//     foo: Nested
+// )
+// object Enclosing extends SimpleTable[Enclosing]
+val value1 = Enclosing(
+  barId = 1337,
+  myString = "hello",
+  foo = Nested(
+    fooId = 271828,
+    myBoolean = true
+  )
+)
+val value2 = Enclosing(
+  barId = 31337,
+  myString = "world",
+  foo = Nested(
+    fooId = 1618,
+    myBoolean = false
+  )
+)
+
+val insertColumns = Enclosing.insert.columns(
+  _.barId := value1.barId,
+  _.myString := value1.myString,
+  _.foo.fooId := value1.foo.fooId,
+  _.foo.myBoolean := value1.foo.myBoolean
+)
+db.renderSql(insertColumns) ==>
+  "INSERT INTO enclosing (bar_id, my_string, foo_id, my_boolean) VALUES (?, ?, ?, ?)"
+
+db.run(insertColumns) ==> 1
+
+val insertValues = Enclosing.insert.values(value2)
+db.renderSql(insertValues) ==>
+  "INSERT INTO enclosing (bar_id, my_string, foo_id, my_boolean) VALUES (?, ?, ?, ?)"
+
+db.run(insertValues) ==> 1
+
+db.renderSql(Enclosing.select) ==> """
+          SELECT
+            enclosing0.bar_id AS bar_id,
+            enclosing0.my_string AS my_string,
+            enclosing0.foo_id AS foo_id,
+            enclosing0.my_boolean AS my_boolean
+          FROM enclosing enclosing0
+        """
+
+db.run(Enclosing.select) ==> Seq(value1, value2)
+```
+
+
+
+
+
+
 ## Optional
 Queries using columns that may be `NULL`, `Expr[Option[T]]` or `Option[T]` in Scala
 ### Optional

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

@@ -146,18 +146,22 @@ trait SimpleTableDataTypesTests extends ScalaSqlSuite {
       }
     )
 
-    test("enclosing") - checker.recorded(
+    // !! Important: '- with SimpleTable' so it will be detected by generateDocs.mill
+    test("enclosing - with SimpleTable") - checker.recorded(
       """
       You can nest `case class`es in other `case class`es to DRY up common sets of
       table columns. These nested `case class`es have their columns flattened out
       into the enclosing `case class`'s columns, such that at the SQL level it is
       all flattened out without nesting.
+
+      **Important**: When using nested `case class`es with `SimpleTable`,
+      make sure to extend `SimpleTable.Nested` in the nested class.
       """,
       Text {
         // case class Nested(
         //   fooId: Int,
         //   myBoolean: Boolean,
-        // )
+        // ) extends SimpleTable.Nested
         // object Nested extends SimpleTable[Nested]
         //
         // case class Enclosing(
@@ -213,7 +217,7 @@ trait SimpleTableDataTypesTests extends ScalaSqlSuite {
 
       }
     )
-    test("JoinNullable proper type mappingg") - checker.recorded(
+    test("JoinNullable proper type mapping") - checker.recorded(
       "",
       Text {
         case class A(id: Int, bId: Option[Int])