* fixed IT tests

* code improvements

Author: benedeki

balta/src/main/scala/za/co/absa/db/balta/classes/DBFunction.scala

@@ -44,8 +44,7 @@ sealed abstract class DBFunction private(functionName: SqlEntry,
       columnName.sqlEntry := queryParamValue.sqlEntry
     }
     val paramEntries = positionedParamEntries ++ namedParamEntries
-    val paramsLine = paramEntries.mkString(",")
-    SELECT(ALL) FROM functionName(paramsLine) ORDER BY (orderBy)
+    SELECT(ALL) FROM functionName(paramEntries) ORDER BY (orderBy)
   }
 
   /**

balta/src/main/scala/za/co/absa/db/balta/classes/DBQuerySupport.scala

@@ -29,6 +29,7 @@ trait DBQuerySupport {
                  (implicit connection: DBConnection): R = {
     val preparedStatement = connection.connection.prepareStatement(sql.entry)
 
+    println(sql)
     queryValues.foldLeft(1) { case (parameterIndex, queryValue) =>
       queryValue.assign match { // this is better readable-wise than map + getOrElse
         case Some(assignFnc) =>

balta/src/main/scala/za/co/absa/db/balta/classes/DBTable.scala

@@ -39,12 +39,14 @@ case class DBTable(tableName: String) extends DBQuerySupport{
     */
   def insert(values: Params)(implicit connection: DBConnection): QueryResultRow = {
     val columns = values match {
-      case namedParams: NamedParams => namedParams.paramNames.map(_.sqlEntry).mkString("(", ",", ")")
-      case _: OrderedParams => ""
+      case namedParams: NamedParams =>
+        val x = namedParams.paramNames.map(_.sqlEntry)
+        x
+      case _: OrderedParams => Vector.empty
     }
 
-    val paramStr = values.values.map(_.sqlEntry).mkString(",")
-    val sql = INSERT INTO table(columns) VALUES(paramStr) RETURNING ALL
+    val paramValues = values.values.map(_.sqlEntry)
+    val sql = INSERT INTO table(columns) VALUES(paramValues) RETURNING ALL
     runQuery(sql, values.values){_.next()}
   }
 
@@ -243,6 +245,6 @@ case class DBTable(tableName: String) extends DBQuerySupport{
       val condition = columnName.sqlEntry + value.equalityOperator + value.sqlEntry
       condition :: acc
     }
-    resultList.toSqlEntry(" AND ")
+    resultList.mkSqlEntry(" AND ")
   }
 }

balta/src/main/scala/za/co/absa/db/mag/core/SqlEntry.scala

@@ -33,9 +33,20 @@ class SqlEntry(val entry: String) extends AnyVal {
   def ==(other: String): Boolean = this.entry == other
   def :=(other: SqlEntry): SqlEntry = this + SqlEntry(":=") + other
   def apply(params: String*): SqlEntry = {
-    val paramsStr = params.mkString(", ")
-    val paramsEntry = SqlEntry(paramsStr).toOption.encase("(", ")")
-    this + paramsEntry.getOrElse(SqlEntry(""))
+    val paramsStr = params.mkString("(", ",", ")")
+    this + SqlEntry(paramsStr)
+  }
+
+  /** Translates a sequence of SqlEntry entries into a single SqlEntry formatted as a parameter list
+    *
+    * @param params - A sequence of SqlEntry to be included as parameters.
+    * @param foo    - A bogus parameter do differentiate this method from the `apply(params: String*)` method, as their
+   *                  signatures would be same otherwise after type erasure.
+    * @return         A new SqlEntry that combines the input as a list of parameters/columns for a function or table.
+    */
+  def apply(params: Seq[SqlEntry], foo: String = ""): SqlEntry = {
+    val paramsEntry = params.mkSqlEntry("(", ",", ")")
+    this + paramsEntry
   }
 
   def toOption: Option[SqlEntry] = {
@@ -56,11 +67,7 @@ object SqlEntry {
   def apply(maybeEntry: Option[String]): Option[SqlEntry] = maybeEntry.map(SqlEntry(_))
 
   implicit class SqlEntryOptionEnhancement(val sqlEntry: Option[SqlEntry]) extends AnyVal {
-    def prefix(withEntry: String): Option[SqlEntry] = sqlEntry.map(SqlEntry(withEntry) + _)
-    def suffix(withEntry: String): Option[SqlEntry] = sqlEntry.map(_ + SqlEntry(withEntry))
-    def encase(withEntryLeft: String, withEntryRight: String): Option[SqlEntry] = {
-      sqlEntry.map(SqlEntry(withEntryLeft) + _ + SqlEntry(withEntryRight))
-    }
+    def prefix(withEntry: SqlEntry): Option[SqlEntry] = sqlEntry.map(withEntry + _)
 
     def + (other: Option[SqlEntry]): Option[SqlEntry] = concat(sqlEntry, other)
 
@@ -71,9 +78,12 @@ object SqlEntry {
     }
   }
 
-  implicit class SqlEntryListEnhancement(val sqlEntries: List[SqlEntry]) extends AnyVal {
-    def toSqlEntry(separator: String = ", "): SqlEntry = {
-      val entriesStr = sqlEntries.map(_.entry).mkString(separator)
+  implicit class SqlEntryListEnhancement(val sqlEntries: Seq[SqlEntry]) extends AnyVal {
+    def mkSqlEntry(separator: String): SqlEntry = {
+      mkSqlEntry("", separator, "")
+    }
+    def mkSqlEntry(start: String, separator: String = ", ", end: String): SqlEntry = {
+      val entriesStr = sqlEntries.map(_.entry).mkString(start, separator, end)
       SqlEntry(entriesStr)
     }
   }

balta/src/main/scala/za/co/absa/db/mag/core/SqlEntryComposition.scala

@@ -1,56 +1,49 @@
 package za.co.absa.db.mag.core
 
 import scala.language.implicitConversions
+import za.co.absa.db.mag.core.SqlEntry._
 
 object SqlEntryComposition {
 
-  private def columnsToSqlEntry(fields: Seq[ColumnReference]): Option[SqlEntry] = {
-    if (fields.isEmpty) {
-      None
-    } else {
-      val fieldEntries = fields.map(_.sqlEntry.entry)
-      Some(SqlEntry(fieldEntries.mkString(", ")))
-    }
-  }
-
   sealed class SelectFragment private[SqlEntryComposition]() {
-    private val select = SqlEntry("SELECT")
-
     def apply(firstField: ColumnReference, fields: ColumnReference*): SelectWithFieldsFragment = {
       val allFields = firstField +: fields
-      new SelectWithFieldsFragment(select + columnsToSqlEntry(allFields))
+      new SelectWithFieldsFragment(select + allFields.map(_.sqlEntry).mkSqlEntry(", "))
     }
 
     def apply(sqlConstant: SqlEntryConstant): SelectWithFieldsFragment = new SelectWithFieldsFragment(select + sqlConstant.sqlConstant)
   }
 
   sealed class InsertFragment private[SqlEntryComposition]() {
     def INTO(intoEntry: SqlEntry): QueryInsertIntoFragment = {
-      new QueryInsertIntoFragment(SqlEntry("INSERT INTO") + intoEntry)
+      new QueryInsertIntoFragment(insertInto + intoEntry)
     }
   }
 
   sealed class QueryInsertIntoFragment private[SqlEntryComposition](sqlEntry: SqlEntry) {
-    def VALUES(firstValue: String, otherValues: String*): QueryInsert = {
-      val valuesLine = (firstValue +: otherValues).mkString(", ")
-      new QueryInsert(sqlEntry + SqlEntry(s"VALUES($valuesLine)"))
+    def VALUES(firstValue: SqlEntry, otherValues: SqlEntry*): QueryInsert = {
+      VALUES(firstValue +: otherValues)
+    }
+    def VALUES(values: Seq[SqlEntry]): QueryInsert = {
+      val valuesEntry = values.mkSqlEntry("VALUES(", ", ", ")")
+      new QueryInsert(sqlEntry + valuesEntry)
     }
   }
 
   sealed class DeleteFragment private[SqlEntryComposition]() {
-    def FROM(fromEntry: SqlEntry): QueryDelete = new QueryDelete(SqlEntry("DELETE FROM") + fromEntry)
+    def FROM(fromEntry: SqlEntry): QueryDelete = new QueryDelete(deleteFrom + fromEntry)
   }
 
   private object SelectFragment extends SelectFragment()
   private object InsertFragment extends InsertFragment()
   private object DeleteFragment extends DeleteFragment
 
   sealed class SelectWithFieldsFragment private[SqlEntryComposition](val sql: SqlEntry) {
-    def FROM(fromEntry: SqlEntry): QuerySelect = new QuerySelect(sql + SqlEntry("FROM") + fromEntry)
+    def FROM(fromEntry: SqlEntry): QuerySelect = new QuerySelect(sql + from + fromEntry)
   }
 
   sealed class OrderByFragment private[SqlEntryComposition](orderingEntry: Option[SqlEntry]) {
-    val sqlEntry: Option[SqlEntry] = orderingEntry.prefix("ORDER BY")
+    val sqlEntry: Option[SqlEntry] = orderingEntry.prefix(orderBy)
   }
 
   trait OrderByMixIn {
@@ -60,12 +53,12 @@ object SqlEntryComposition {
 
   trait ReturningMixIn {
     def sqlEntry: SqlEntry
-    def RETURNING(returning: SqlEntryConstant): QueryWithReturning = {
-      new QueryWithReturning(sqlEntry + SqlEntry("RETURNING") + returning.sqlConstant)
+    def RETURNING(returningFields: SqlEntryConstant): QueryWithReturning = {
+      new QueryWithReturning(sqlEntry + returning + returningFields.sqlConstant)
     }
     def RETURNING(firstField: ColumnReference, otherFields: ColumnReference*): QueryWithReturning = {
       val allFields = firstField +: otherFields
-      new QueryWithReturning(sqlEntry + SqlEntry("RETURNING") + columnsToSqlEntry(allFields))
+      new QueryWithReturning(sqlEntry + returning + columnsToSqlEntry(allFields))
     }
   }
 
@@ -75,9 +68,8 @@ object SqlEntryComposition {
     extends Query(sqlEntry) with OrderByMixIn {
     def WHERE(condition: SqlEntry): QuerySelectConditioned = WHERE(condition.toOption)
     def WHERE(condition: Option[SqlEntry]): QuerySelectConditioned = {
-      new QuerySelectConditioned(sqlEntry + condition.prefix("WHERE"))
+      new QuerySelectConditioned(sqlEntry + condition.prefix(where))
     }
-//    def apply(paramsLine: String): QuerySelectWithParams = new QuerySelectWithParams(sqlEntry + SqlEntry(s"($paramsLine)"))
   }
 
   sealed class QuerySelectConditioned private[SqlEntryComposition](sqlEntry: SqlEntry)
@@ -91,7 +83,7 @@ object SqlEntryComposition {
   sealed class QueryDelete private[SqlEntryComposition](sqlEntry: SqlEntry) extends Query(sqlEntry) with ReturningMixIn {
     def WHERE(condition: SqlEntry): QueryDeleteConditioned = WHERE(condition.toOption)
     def WHERE(condition: Option[SqlEntry]): QueryDeleteConditioned = {
-      new QueryDeleteConditioned(sqlEntry + condition.prefix("WHERE"))
+      new QueryDeleteConditioned(sqlEntry + condition.prefix(where))
     }
   }
 
@@ -116,5 +108,23 @@ object SqlEntryComposition {
   def BY(columns: ColumnReference*): OrderByFragment= new OrderByFragment(columnsToSqlEntry(columns))
 
   implicit def QueryToSqlEntry(query: Query): SqlEntry = query.sqlEntry
+  implicit def StringToSqlEntry(string: String): SqlEntry = SqlEntry(string)
+
+  private val select = SqlEntry("SELECT")
+  private val insertInto = SqlEntry("INSERT INTO")
+  private val deleteFrom = SqlEntry("DELETE FROM")
+  private val from = SqlEntry("FROM")
+  private val where = SqlEntry("WHERE")
+  private val orderBy = SqlEntry("ORDER BY")
+  private val returning = SqlEntry("RETURNING")
+
+  private def columnsToSqlEntry(fields: Seq[ColumnReference]): Option[SqlEntry] = {
+    if (fields.isEmpty) {
+      None
+    } else {
+      val fieldEntries = fields.map(_.sqlEntry.entry)
+      Some(SqlEntry(fieldEntries.mkString(", ")))
+    }
+  }
 
 }

balta/src/test/scala/za/co/absa/db/balta/classes/DBTableIntegrationTests.scala

@@ -65,9 +65,9 @@ class DBTableIntegrationTests extends AnyFunSuiteLike with DBTestingConnection{
       queryResult.next().assertTo(1, "textA", booleanField = true)
       queryResult.next().assertTo(4, "textA", booleanField = false)
       assert(queryResult.noMore)
-      "Hello world"
+      "Some returned value"
     }
-    assert(returnedValue == "Hello world")
+    assert(returnedValue == "Some returned value")
 
     table.where(Params.add("text_field", "textB").add("boolean_field", false)) { queryResult =>
       queryResult.next().assertTo(2, "textB", booleanField = false)

balta/src/test/scala/za/co/absa/db/mag/core/SqlEntryCompositionUnitTests.scala

@@ -57,13 +57,20 @@ class SqlEntryCompositionUnitTests extends AnyFunSuiteLike {
     assert(query.sqlEntry.entry == expectedSql)
   }
 
+  test("Composition of `SELECT ... FROM ...` using function call without providing parameters") {
+    val query  = SELECT(ALL) FROM functionName()
+    val expectedSql = "SELECT * FROM my_function()"
+    assert(query.sqlEntry.entry == expectedSql)
+  }
+
+
   test("Composition of `INSERT INTO ...`") {
     val query  = INSERT INTO tableName VALUES("100", "'Sample Text'")
     val expectedSql = "INSERT INTO my_table VALUES(100, 'Sample Text')"
     assert(query.sqlEntry.entry == expectedSql)
   }
 
-  test("Composition of `INSERT INTO ... VALUES RETURNING ...`") {
+  test("Composition of `INSERT INTO ... VALUES RETURNING ...` not providing any field names") {
     val query  = INSERT INTO tableName VALUES(param) RETURNING(ALL)
     val expectedSql = "INSERT INTO my_table VALUES(42) RETURNING *"
     assert(query.sqlEntry.entry == expectedSql)
@@ -76,12 +83,6 @@ class SqlEntryCompositionUnitTests extends AnyFunSuiteLike {
     assert(query.sqlEntry.entry == expectedSql)
   }
 
-  test("Composition of `INSERT INTO ...() VALUES ... RETURNING ...` not providing any field names") {
-    val query  = INSERT INTO tableName() VALUES("42") RETURNING(field1)
-    val expectedSql = "INSERT INTO my_table VALUES(42) RETURNING field1"
-    assert(query.sqlEntry.entry == expectedSql)
-  }
-
   test("Composition of `DELETE ... FROM ...`") {
     val query  = DELETE FROM tableName
     val expectedSql = "DELETE FROM my_table"