add 0-based array indexing

Author: belamenso

src/main/scala/tyql/expr/Expr.scala

@@ -320,14 +320,15 @@ object Expr:
     assert(strs.nonEmpty, "concatWith requires at least one argument")
     StrConcatSeparator(sep, strs.head, strs.tail)
 
-  extension [A](x: Expr[List[A], NonScalarExpr])(using ResultTag[List[A]])
+  extension [A](x: Expr[List[A], NonScalarExpr])(using ResultTag[A], ResultTag[List[A]])
     def prepend(elem: Expr[A, NonScalarExpr]): Expr[List[A], NonScalarExpr] = ListPrepend(elem, x)
     def append(elem: Expr[A, NonScalarExpr]): Expr[List[A], NonScalarExpr] = ListAppend(x, elem)
     // XXX Due to Scala overloading bugs, there can be no two extensions methods named `contains` with similar arguments.
     // XXX Because the list one is less used, this one is called `containsElement` instead.
     def containsElement(elem: Expr[A, NonScalarExpr]): Expr[Boolean, NonScalarExpr] = ListContains(x, elem)
     def length: Expr[Int, NonScalarExpr] = ListLength(x)
     def ++(other: Expr[List[A], NonScalarExpr]): Expr[List[A], NonScalarExpr] = ListConcat(x, other)
+    def apply(i: Expr[Int, NonScalarExpr]): Expr[A, NonScalarExpr] = ListGet(x, Expr.Plus(i, Expr.IntLit(1)))
 
   // Aggregations
   def sum[T : ResultTag : Numeric](x: Expr[T, ?]): AggregationExpr[T] = AggregationExpr.Sum(x)
@@ -524,6 +525,8 @@ object Expr:
   case class ListContains[A]($list: Expr[List[A], NonScalarExpr], $x: Expr[A, NonScalarExpr])(using ResultTag[Boolean])
       extends Expr[Boolean, NonScalarExpr]
   case class ListLength[A]($list: Expr[List[A], NonScalarExpr])(using ResultTag[Int]) extends Expr[Int, NonScalarExpr]
+  case class ListGet[A]($list: Expr[List[A], NonScalarExpr], $i: Expr[Int, NonScalarExpr])(using ResultTag[A])
+      extends Expr[A, NonScalarExpr]
   case class ListConcat[A]
     ($xs: Expr[List[A], NonScalarExpr], $ys: Expr[List[A], NonScalarExpr])
     (using ResultTag[List[A]])

src/main/scala/tyql/ir/QueryIRTree.scala

@@ -890,6 +890,15 @@ object QueryIRTree:
       case a: AggregationExpr[?]  => generateAggregation(a, symbols)
       case a: Aggregation[?, ?]   => generateQuery(a, symbols).appendFlag(SelectFlags.ExprLevel)
       case list: Expr.ListExpr[?] => ListTypeExpr(list.$elements.map(generateExpr(_, symbols)), list)
+      case g: Expr.ListGet[?] => BinExprOp(
+          "",
+          generateExpr(g.$list, symbols),
+          "[",
+          generateExpr(g.$i, symbols),
+          "]",
+          Precedence.Comparison,
+          g
+        )
       case c: Expr.ListConcat[?] =>
         BinExprOp(
           "",

src/test/scala/test/integration/ArrayTests.scala

@@ -53,6 +53,32 @@ class ArrayTest extends FunSuite {
     }
   }
 
+  test("array indexing") {
+    withDB.allWithArraySupport { conn =>
+      val db = tyql.DB(conn)
+      val q = Exprs[(a: String)](Tuple1(lit(List("a", "b", "c", "e"))(0)))
+      val got = db.run(q)
+      assertEquals(got.length, 1)
+      assertEquals(got.head.toList.head, "a")
+    }
+
+    withDB.allWithArraySupport { conn =>
+      val db = tyql.DB(conn)
+      val q = Exprs[(a: String)](Tuple1(lit(List("a", "b", "c", "e"))(2)))
+      val got = db.run(q)
+      assertEquals(got.length, 1)
+      assertEquals(got.head.toList.head, "c")
+    }
+
+    withDB.allWithArraySupport { conn =>
+      val db = tyql.DB(conn)
+      val q = Exprs[(a: String)](Tuple1(lit(List("a", "b", "c", "e"))(3)))
+      val got = db.run(q)
+      assertEquals(got.length, 1)
+      assertEquals(got.head.toList.head, "e")
+    }
+  }
+
   test("array concat") {
     withDB.allWithArraySupport { conn =>
       val db = tyql.DB(conn)