Assert sql

src/main/scala/minisql/Quoted.scala

@@ -199,7 +199,7 @@ private def compileImpl[I <: Idiom, N <: NamingStrategy](
         .getOrElse(report.errorAndAbort(s"NamingStrategy not known at compile"))
 
       val stmt = idiom.translate(ast)(using naming)
-      report.info(s"Static Query: ${stmt}")
+      report.info(s"Static Query: ${stmt._2}")
       Expr(stmt._2)
     case None =>
       report.info("Dynamic Query")

src/main/scala/minisql/ast/Ast.scala

@@ -85,13 +85,14 @@ case class SortBy(query: Ast, alias: Ident, criterias: Ast, ordering: Ordering)
 sealed trait Ordering                           extends Ast
 case class TupleOrdering(elems: List[Ordering]) extends Ordering
 
-sealed trait PropertyOrdering extends Ordering
-case object Asc               extends PropertyOrdering
-case object Desc              extends PropertyOrdering
-case object AscNullsFirst     extends PropertyOrdering
-case object DescNullsFirst    extends PropertyOrdering
-case object AscNullsLast      extends PropertyOrdering
-case object DescNullsLast     extends PropertyOrdering
+enum PropertyOrdering extends Ordering {
+  case Asc
+  case Desc
+  case AscNullsFirst
+  case DescNullsFirst
+  case AscNullsLast
+  case DescNullsLast
+}
 
 case class GroupBy(query: Ast, alias: Ident, body: Ast) extends Query
 

src/main/scala/minisql/ast/FromExprs.scala

@@ -77,6 +77,7 @@ private given FromExpr[Property] with {
 
 private given FromExpr[Ordering] with {
   def unapply(x: Expr[Ordering])(using Quotes): Option[Ordering] = {
+    import PropertyOrdering.*
     x match {
       case '{ Asc }                => Some(Asc)
       case '{ Desc }               => Some(Desc)

src/main/scala/minisql/context/sql/SqlIdiom.scala

@@ -356,15 +356,17 @@ trait SqlIdiom extends Idiom {
     astTokenizer: Tokenizer[Ast],
     strategy: NamingStrategy
   ): Tokenizer[OrderByCriteria] = Tokenizer[OrderByCriteria] {
-    case OrderByCriteria(ast, Asc)  => stmt"${scopedTokenizer(ast)} ASC"
-    case OrderByCriteria(ast, Desc) => stmt"${scopedTokenizer(ast)} DESC"
-    case OrderByCriteria(ast, AscNullsFirst) =>
+    case OrderByCriteria(ast, PropertyOrdering.Asc) =>
+      stmt"${scopedTokenizer(ast)} ASC"
+    case OrderByCriteria(ast, PropertyOrdering.Desc) =>
+      stmt"${scopedTokenizer(ast)} DESC"
+    case OrderByCriteria(ast, PropertyOrdering.AscNullsFirst) =>
       stmt"${scopedTokenizer(ast)} ASC NULLS FIRST"
-    case OrderByCriteria(ast, DescNullsFirst) =>
+    case OrderByCriteria(ast, PropertyOrdering.DescNullsFirst) =>
       stmt"${scopedTokenizer(ast)} DESC NULLS FIRST"
-    case OrderByCriteria(ast, AscNullsLast) =>
+    case OrderByCriteria(ast, PropertyOrdering.AscNullsLast) =>
       stmt"${scopedTokenizer(ast)} ASC NULLS LAST"
-    case OrderByCriteria(ast, DescNullsLast) =>
+    case OrderByCriteria(ast, PropertyOrdering.DescNullsLast) =>
       stmt"${scopedTokenizer(ast)} DESC NULLS LAST"
   }
 

src/main/scala/minisql/idiom/MirrorIdiom.scala

@@ -141,13 +141,13 @@ trait MirrorIdiomBase extends Idiom {
   }
 
   implicit val orderingTokenizer: Tokenizer[Ordering] = Tokenizer[Ordering] {
-    case TupleOrdering(elems) => stmt"Ord(${elems.token})"
-    case Asc                  => stmt"Ord.asc"
-    case Desc                 => stmt"Ord.desc"
-    case AscNullsFirst        => stmt"Ord.ascNullsFirst"
-    case DescNullsFirst       => stmt"Ord.descNullsFirst"
-    case AscNullsLast         => stmt"Ord.ascNullsLast"
-    case DescNullsLast        => stmt"Ord.descNullsLast"
+    case TupleOrdering(elems)            => stmt"Ord(${elems.token})"
+    case PropertyOrdering.Asc            => stmt"Ord.asc"
+    case PropertyOrdering.Desc           => stmt"Ord.desc"
+    case PropertyOrdering.AscNullsFirst  => stmt"Ord.ascNullsFirst"
+    case PropertyOrdering.DescNullsFirst => stmt"Ord.descNullsFirst"
+    case PropertyOrdering.AscNullsLast   => stmt"Ord.ascNullsLast"
+    case PropertyOrdering.DescNullsLast  => stmt"Ord.descNullsLast"
   }
 
   implicit def optionOperationTokenizer(implicit

src/test/scala/minisql/ast/FromExprsSuite.scala

@@ -44,11 +44,11 @@ class FromExprsSuite extends FunSuite {
   }
 
   testFor("Ordering") {
-    Asc
+    PropertyOrdering.Asc
   }
 
   testFor("TupleOrdering") {
-    TupleOrdering(List(Asc, Desc))
+    TupleOrdering(List(PropertyOrdering.Asc, PropertyOrdering.Desc))
   }
 
   testFor("Entity") {

src/test/scala/minisql/context/sql/QuotedSuite.scala

@@ -20,16 +20,18 @@ class QuotedSuite extends munit.FunSuite {
       query[Foo](
         "foo",
         alias("id", "id1")
-      ).filter(_.id > 0)
+      ).filter(x => x.id > 0)
     )
-    println(o)
+    assertEquals(o.sql, "SELECT x.id1, x.name FROM foo x WHERE x.id1 > 0")
   }
 
   test("Insert") {
     val v: Foo = Foo(0L, "foo")
 
     val o = testContext.io(Foos.insert(v))
-    println(o)
-    ???
+    assertEquals(
+      o.sql,
+      "INSERT INTO foo (id,name) VALUES (?, ?)"
+    )
   }
 }