* mixed case names are now lower cased unless they are quoted or contain other non-standard characters

* unified naming - columnName(s) is used all around

Author: benedeki

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

@@ -51,18 +51,18 @@ case class DBTable(tableName: String) extends DBQuerySupport{
    *
    * @param keyName     - the name of the key column
    * @param keyValue    - the value of the key column
-   * @param fieldName   - the name of the field to be returned
+   * @param columnName  - the name of the field to be returned
    * @param connection  - a database connection used for the SELECT operation.
    * @tparam K          - the type of the key value
    * @tparam T          - the type of the returned field value
    * @return            - the value of the field, if the value is NULL, then `Some(None)` is returned; if no row is found,
    *                    then `None` is returned.
    */
-  def fieldValue[K: QueryParamType, T](keyName: String, keyValue: K, fieldName: String)
+  def fieldValue[K: QueryParamType, T](keyName: String, keyValue: K, columnName: String)
                                          (implicit connection: DBConnection): Option[Option[T]] = {
     where(Params.add(keyName, keyValue)){resultSet =>
       if (resultSet.hasNext) {
-        Some(resultSet.next().getAs[T](fieldName))
+        Some(resultSet.next().getAs[T](columnName))
       } else {
         None
       }

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

@@ -31,7 +31,7 @@ class QueryResult(resultSet: ResultSet) extends Iterator[QueryResultRow] {
 
   private [this] var nextRow: Option[QueryResultRow] = None
 
-  private [this] implicit val fieldNames: ColumnNames = QueryResultRow.fieldNamesFromMetadata(resultSetMetaData)
+  private [this] implicit val columnNames: ColumnNames = QueryResultRow.columnNamesFromMetadata(resultSetMetaData)
   private [this] implicit val extractors: Extractors = QueryResultRow.createExtractors(resultSetMetaData)
 
   override def hasNext: Boolean = {

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

@@ -18,6 +18,7 @@ package za.co.absa.db.balta.classes
 
 import QueryResultRow._
 import za.co.absa.db.balta.implicits.MapImplicits.MapEnhancements
+import za.co.absa.db.mag.core.ColumnName
 
 import java.sql
 import java.sql.{Date, ResultSet, ResultSetMetaData, Time, Types}
@@ -29,26 +30,16 @@ import java.util.UUID
  *
  * @param rowNumber     - the number of the row in the result set
  * @param fields        - the values of the row
- * @param columnLabels  - the names of the columns; class uses `columnLabel(s)` to refer to the column names in accordance
- *                      to `java.sql.ResultSet`, which is is build around and that despite that aliases are not expected
- *                      to appear here
+ * @param columnNames   - the names of the columns
  */
 class QueryResultRow private[classes](val rowNumber: Int,
                                       private val fields: Vector[Option[Object]],
-                                      private val columnLabels: ColumnNames) {
+                                      private val columnNames: ColumnNames) {
 
   def columnCount: Int = fields.length
-  def columnNumber(columnLabel: String): Int = {
-    val quotedRegex = """^"(.+)"$""".r
-    columnLabel match {
-      case quotedRegex(innerLabel) => // in case the column label is quoted, first try to find it as is, then without quotes
-        columnLabels.getOrElse(
-          columnLabel,
-          columnLabels.getOrThrow(innerLabel, new NoSuchElementException(s"Column '$columnLabel' not found"))
-        )
-      case _ => columnLabels.getOrThrow(columnLabel, new NoSuchElementException(s"Column '$columnLabel' not found"))
-    }
-
+  def columnNumber(columnName: String): Int = {
+    val columnNameQuoteless = ColumnName(columnName).quoteLess
+    columnNames.getOrThrow(columnNameQuoteless, new NoSuchElementException(s"Column '$columnNameQuoteless' not found"))
   }
 
   /**
@@ -59,22 +50,22 @@ class QueryResultRow private[classes](val rowNumber: Int,
   def apply(column: Int): Option[Any] = getObject(column - 1)
   /**
    * Extracts a value from the row by column name.
-   * @param columnLabel - the name of the column
+   * @param columnName - the name of the column
    * @return            - the value stored in the column, type `Any` is for warningless comparison with any type
    */
-  def apply(columnLabel: String): Option[Any] = getObject(columnNumber(columnLabel))
+  def apply(columnName: String): Option[Any] = getObject(columnNumber(columnName))
 
   def getAs[T](column: Int, transformer: TransformerFnc[T]): Option[T] = getObject(column).map(transformer)
   def getAs[T](column: Int): Option[T] = getObject(column)map(_.asInstanceOf[T])
 
-  def getAs[T](columnLabel: String, transformer: TransformerFnc[T]): Option[T] = getAs(columnNumber(columnLabel), transformer)
-  def getAs[T](columnLabel: String): Option[T] = getObject(columnNumber(columnLabel)).map(_.asInstanceOf[T])
+  def getAs[T](columnName: String, transformer: TransformerFnc[T]): Option[T] = getAs(columnNumber(columnName), transformer)
+  def getAs[T](columnName: String): Option[T] = getObject(columnNumber(columnName)).map(_.asInstanceOf[T])
 
   def getObject(column: Int): Option[Object] = fields(column - 1)
-  def getObject(columnLabel: String): Option[Object] = getObject(columnNumber(columnLabel))
+  def getObject(columnName: String): Option[Object] = getObject(columnNumber(columnName))
 
   def getBoolean(column: Int): Option[Boolean] = getAs(column: Int, {item: Object => item.asInstanceOf[Boolean]})
-  def getBoolean(columnLabel: String): Option[Boolean] = getBoolean(columnNumber(columnLabel))
+  def getBoolean(columnName: String): Option[Boolean] = getBoolean(columnNumber(columnName))
 
   def getChar(column: Int): Option[Char] = {
     getString(column) match {
@@ -84,45 +75,45 @@ class QueryResultRow private[classes](val rowNumber: Int,
         None
     }
   }
-  def getChar(columnLabel: String): Option[Char] = getChar(columnNumber(columnLabel))
+  def getChar(columnName: String): Option[Char] = getChar(columnNumber(columnName))
 
   def getString(column: Int): Option[String] = getAs(column: Int, {item: Object => item.asInstanceOf[String]})
-  def getString(columnLabel: String): Option[String] = getString(columnNumber(columnLabel))
+  def getString(columnName: String): Option[String] = getString(columnNumber(columnName))
 
   def getInt(column: Int): Option[Int] = getAs(column: Int, {item: Object => item.asInstanceOf[Int]})
-  def getInt(columnLabel: String): Option[Int] = getInt(columnNumber(columnLabel))
+  def getInt(columnName: String): Option[Int] = getInt(columnNumber(columnName))
 
   def getLong(column: Int): Option[Long] = getAs(column: Int, {item: Object => item.asInstanceOf[Long]})
-  def getLong(columnLabel: String): Option[Long] = getLong(columnNumber(columnLabel))
+  def getLong(columnName: String): Option[Long] = getLong(columnNumber(columnName))
 
   def getDouble(column: Int): Option[Double] = getAs(column: Int, {item: Object => item.asInstanceOf[Double]})
-  def getDouble(columnLabel: String): Option[Double] = getDouble(columnNumber(columnLabel))
+  def getDouble(columnName: String): Option[Double] = getDouble(columnNumber(columnName))
 
   def getFloat(column: Int): Option[Float] = getAs(column: Int, {item: Object => item.asInstanceOf[Float]})
-  def getFloat(columnLabel: String): Option[Float] = getFloat(columnNumber(columnLabel))
+  def getFloat(columnName: String): Option[Float] = getFloat(columnNumber(columnName))
 
   def getBigDecimal(column: Int): Option[BigDecimal] =
     getAs(column: Int, {item: Object => item.asInstanceOf[java.math.BigDecimal]})
       .map(scala.math.BigDecimal(_))
-  def getBigDecimal(columnLabel: String): Option[BigDecimal] = getBigDecimal(columnNumber(columnLabel))
+  def getBigDecimal(columnName: String): Option[BigDecimal] = getBigDecimal(columnNumber(columnName))
 
   def getTime(column: Int): Option[Time] = getAs(column: Int, {item: Object => item.asInstanceOf[Time]})
-  def getTime(columnLabel: String): Option[Time] = getTime(columnNumber(columnLabel))
+  def getTime(columnName: String): Option[Time] = getTime(columnNumber(columnName))
 
   def getDate(column: Int): Option[Date] = getAs(column: Int, {item: Object => item.asInstanceOf[Date]})
-  def getDate(columnLabel: String): Option[Date] = getDate(columnNumber(columnLabel))
+  def getDate(columnName: String): Option[Date] = getDate(columnNumber(columnName))
 
   def getLocalDateTime(column: Int): Option[LocalDateTime] = getAs(column: Int, {item: Object => item.asInstanceOf[LocalDateTime]})
-  def getLocalDateTime(columnLabel: String): Option[LocalDateTime] = getLocalDateTime(columnNumber(columnLabel))
+  def getLocalDateTime(columnName: String): Option[LocalDateTime] = getLocalDateTime(columnNumber(columnName))
 
   def getOffsetDateTime(column: Int): Option[OffsetDateTime] = getAs(column: Int, {item: Object => item.asInstanceOf[OffsetDateTime]})
-  def getOffsetDateTime(columnLabel: String): Option[OffsetDateTime] = getOffsetDateTime(columnNumber(columnLabel))
+  def getOffsetDateTime(columnName: String): Option[OffsetDateTime] = getOffsetDateTime(columnNumber(columnName))
 
   def getInstant(column: Int): Option[Instant] = getOffsetDateTime(column).map(_.toInstant)
-  def getInstant(columnLabel: String): Option[Instant] = getOffsetDateTime(columnLabel).map(_.toInstant)
+  def getInstant(columnName: String): Option[Instant] = getOffsetDateTime(columnName).map(_.toInstant)
 
   def getUUID(column: Int): Option[UUID] = getAs(column: Int, {item: Object => item.asInstanceOf[UUID]})
-  def getUUID(columnLabel: String): Option[UUID] = getUUID(columnNumber(columnLabel))
+  def getUUID(columnName: String): Option[UUID] = getUUID(columnNumber(columnName))
 
   def getArray[T](column: Int): Option[Vector[T]] = {
     def transformerFnc(obj: Object): Vector[T] = {
@@ -131,7 +122,7 @@ class QueryResultRow private[classes](val rowNumber: Int,
     getAs(column: Int, transformerFnc _)
   }
 
-  def getArray[T](columnLabel: String): Option[Vector[T]] = getArray[T](columnNumber(columnLabel))
+  def getArray[T](columnName: String): Option[Vector[T]] = getArray[T](columnNumber(columnName))
 
   def getArray[T](column: Int, itemTransformerFnc: TransformerFnc[T]): Option[Vector[T]] = {
     def transformerFnc(obj: Object): Vector[T] = {
@@ -159,7 +150,7 @@ object QueryResultRow {
     new QueryResultRow(resultSet.getRow, fields, columnNames)
   }
 
-  def fieldNamesFromMetadata(metaData: ResultSetMetaData): ColumnNames = {
+  def columnNamesFromMetadata(metaData: ResultSetMetaData): ColumnNames = {
     Range.inclusive(1, metaData.getColumnCount).map(i => metaData.getColumnName(i) -> i).toMap
   }
 

balta/src/main/scala/za/co/absa/db/balta/classes/inner/Params.scala

@@ -115,7 +115,7 @@ object Params {
      * @param paramName - the name of the parameter
      * @return          - a list parameters to be used in an SQL prepared statement
      */
-    @deprecated("Use add(NULL)", "balta 0.3.0")
+    @deprecated("Use add(paramName, NULL)", "balta 0.3.0")
     def addNull(paramName: String): NamedParams = {
       add(paramName, QueryParamType.NULL)
     }

balta/src/main/scala/za/co/absa/db/balta/implicits/QueryResultRowImplicits.scala

@@ -72,18 +72,19 @@ object QueryResultRowImplicits {
       constructor.paramLists.flatten.map { param =>
         val name = param.name.decodedName.toString
         val paramType = param.typeSignature
-        val columnLabel = namingConvention.stringPerConvention(name)
-        getParamValue(columnLabel, paramType)
+        val columnName = namingConvention.stringPerConvention(name)
+        getParamValue(columnName, paramType)
       }
 
     }
 
-    private def getParamValue[T: TypeTag](columnLabel: String, expectedType: Type): Any = {
-      val value = row(columnLabel)
+    private def getParamValue[T: TypeTag](columnName: String, expectedType: Type): Any = {
+      //TODO TypeTag is not used, consider removing it https://github.com/AbsaOSS/balta/issues/64
+      val value = row(columnName)
       if (isOptionType(expectedType)) {
         value
       } else {
-        value.getOrThrow(new NullPointerException(s"Column '$columnLabel' is null"))
+        value.getOrThrow(new NullPointerException(s"Column '$columnName' is null"))
       }
     }
   }

balta/src/main/scala/za/co/absa/db/balta/postgres/implicits/Postgres.scala

@@ -25,11 +25,11 @@ object Postgres {
     private def simpleJsonStringTransformer(obj: Object): SimpleJsonString = SimpleJsonString(obj.asInstanceOf[PGobject].toString)
 
     def getSimpleJsonString(column: Int): Option[SimpleJsonString] = row.getAs[SimpleJsonString](column: Int, simpleJsonStringTransformer _)
-    def getSimpleJsonString(columnLabel: String): Option[SimpleJsonString] = getSimpleJsonString(row.columnNumber(columnLabel))
+    def getSimpleJsonString(columnName: String): Option[SimpleJsonString] = getSimpleJsonString(row.columnNumber(columnName))
 
     def getSJSArray(column: Int): Option[Vector[SimpleJsonString]] =
       row.getArray(column: Int, item => SimpleJsonString(item.asInstanceOf[String]))
-    def getSJSArray(columnLabel: String): Option[Vector[SimpleJsonString]] = getSJSArray(row.columnNumber(columnLabel))
+    def getSJSArray(columnName: String): Option[Vector[SimpleJsonString]] = getSJSArray(row.columnNumber(columnName))
 
   }
 }

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

@@ -18,9 +18,10 @@ package za.co.absa.db.mag.core
 
 trait ColumnReference extends SqlItem
 
-abstract class ColumnName extends ColumnReference{
-  def enteredName: String
-  def sqlEntry: String
+case class ColumnName private(enteredName: String,
+                              sqlEntry: String,
+                              quoteLess: String
+                             ) extends ColumnReference{
   override def equals(obj: Any): Boolean = {
     obj match {
       case that: ColumnName => this.sqlEntry == that.sqlEntry
@@ -32,40 +33,48 @@ abstract class ColumnName extends ColumnReference{
 
 object ColumnReference {
   private val regularColumnNamePattern = "^([a-z_][a-z0-9_]*)$".r
+  private val mixedCaseColumnNamePattern = "^[a-zA-Z_][a-zA-Z0-9_]*$".r
   private val quotedRegularColumnNamePattern = "^\"([a-z_][a-z0-9_]*)\"$".r
   private val quotedColumnNamePattern = "^\"(.+)\"$".r
 
-  private def quote(stringToQuote: String): String = s""""$stringToQuote""""
-  private def escapeQuote(stringToEscape: String): String = stringToEscape.replace("\"", "\"\"")
+  private[core] def quote(stringToQuote: String): String = s""""$stringToQuote""""
+  private[core] def escapeQuote(stringToEscape: String): String = stringToEscape.replace("\"", "\"\"")
+  private[core] def hasUnescapedQuotes(name: String): Boolean = {
+    val reduced = name.replace("\"\"", "")
+    reduced.contains('"')
+  }
 
   def apply(name: String): ColumnName = {
     val trimmedName = name.trim
     trimmedName match {
-      case regularColumnNamePattern(columnName) => ColumnNameSimple(columnName) // column name per SQL standard, no quoting needed
-      case quotedRegularColumnNamePattern(columnName) => ColumnNameExact(trimmedName, columnName) // quoted but regular name, remove quotes
-      case quotedColumnNamePattern(_)  => ColumnNameSimple(trimmedName) // quoted name, use as is
-      case _ => ColumnNameExact(trimmedName, quote(escapeQuote(trimmedName))) // needs quoting and perhaps escaping
+      case regularColumnNamePattern(columnName) =>
+        ColumnName(columnName, columnName, columnName) // column name per SQL standard, no quoting needed
+      case mixedCaseColumnNamePattern() =>
+        val loweredColumnName = trimmedName.toLowerCase
+        ColumnName(trimmedName, loweredColumnName, loweredColumnName) // mixed case name, turn to lower case for sql entry (per standard)
+      case quotedRegularColumnNamePattern(columnName) =>
+        ColumnName(trimmedName, columnName, columnName) // quoted but regular name, remove quotes
+      case quotedColumnNamePattern(actualColumnName)  =>
+        if (hasUnescapedQuotes(actualColumnName)) {
+          throw new IllegalArgumentException(s"Column name '$actualColumnName' has unescaped quotes. Use double quotes as escape sequence.")
+        }
+        val unescapedColumnName = actualColumnName.replace("\"\"", "\"")
+        ColumnName(trimmedName, trimmedName, unescapedColumnName) // quoted name, use as is
+      case _ =>
+        ColumnName(trimmedName, quote(escapeQuote(trimmedName)), trimmedName) // needs quoting and perhaps escaping
     }
   }
 
   def apply(index: Int): ColumnReference = {
     ColumnIndex(index)
   }
 
-  def unapply(columnName: ColumnName): String = columnName.enteredName
-
-  final case class ColumnNameSimple private(enteredName: String) extends ColumnName {
-    override def sqlEntry: String = enteredName
-  }
-
-  final case class ColumnNameExact private(enteredName: String, sqlEntry: String) extends ColumnName
-
   final case class ColumnIndex private(index: Int) extends ColumnReference {
     val sqlEntry: String = index.toString
   }
 }
 
 object ColumnName {
   def apply(name: String): ColumnName = ColumnReference(name)
-  def unapply(columnName: ColumnName): String = columnName.enteredName
+  def unapply(columnName: ColumnName): Option[String] = Option(columnName.enteredName)
 }