From a4ef7a9f9e3a75526572180f4d7d55ca23338f5f Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 7 Apr 2026 13:15:19 +0200
Subject: [PATCH 01/13] feat: add unit tests for JMF rules and improve
 documentation in copilot instructions and review rules

---
 .github/copilot-instructions.md | 101 ++++++++++++++++++++++
 .github/copilot-review-rules.md |  47 +++++++++++
 .gitignore                      |   1 +
 jmf-rules.txt                   | 144 +++++++-------------------------
 4 files changed, 180 insertions(+), 113 deletions(-)
 create mode 100644 .github/copilot-instructions.md
 create mode 100644 .github/copilot-review-rules.md

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000..3b64025
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,101 @@
+Copilot instructions
+
+Purpose
+- Define consistent style; keep externally-visible behavior stable unless intentionally changing the contract.
+- Sections order, bullet lists, and constraint words (Must / Must not / Prefer / Avoid) must be consistent across repos.
+- Must keep one blank line at end of file.
+
+Context
+- Scala library consumed via sbt in CI/CD; treat JDBC connections and DB state as boundary concerns.
+- Must keep library API backward-compatible unless a version bump is intentional.
+
+Coding guidelines
+- Must keep changes small and focused; prefer explicit over clever.
+- Must keep pure logic free of environment access; route I/O through a single boundary module.
+- Must keep externally-visible strings, formats, and exit codes stable unless intentional.
+
+Output discipline
+- Aim ≤ 10 lines in final recap; link and summarize deltas rather than pasting large content.
+- Prefer actionable bullets; avoid deep rationale unless requested.
+- Code changes must end with: what changed / why / how to verify.
+
+PR Body Management
+- Treat PR description as a changelog; append under `## Update [YYYY-MM-DD]` or `## Changes Added`.
+- Must not rewrite the entire PR body; must reference the commit hash that introduced the change.
+
+Configuration
+- Must read DB connection details from `database.properties` test resource; centralize in `ConnectionInfo`.
+- Must not hard-code credentials; document required vs optional `ConnectionInfo` fields with defaults.
+
+Language and style
+- Must target Scala 2.12 primary; cross-compile 2.11 and 2.13 where configured.
+- Must add ScalaDoc for new public methods and classes.
+- Must use slf4j (`LazyLogging` or explicit `Logger`), not `println`/`print`; pass logger arguments lazily (call-by-name), never pre-build interpolated strings.
+- Must keep imports at top of file, grouped: stdlib → third-party → project-internal.
+- Must include the Apache 2.0 copyright/license header in every source file using the project first-copyright year.
+- Prefer `s"..."` interpolation for non-logging templates; avoid interpolation inside `logger.*` calls.
+
+Docstrings and comments
+- ScalaDoc: short summary line first; prefer Parameters/Returns/Raises sections; avoid tutorials and long prose.
+- Comments: comment intent/edge cases only; avoid restating the code.
+
+Patterns
+- Prefer raising exceptions in leaf modules; translate to test/library failure at the entry point (`DBTestSuite.test()`).
+- Must keep boundaries mockable; must not call real external systems (DB, APIs) in unit tests.
+
+Testing
+- Must use ScalaTest under `balta/src/test/scala/`.
+- Must test return values, exceptions, and error messages.
+- Unit test files: name ends with `UnitTests`; must not require a DB connection; mock JDBC (`PreparedStatement`/`ResultSet`) if needed.
+- Integration test files: name ends with `IntegrationTests`; must extend `DBTestSuite` or mix in `DBTestingConnection`.
+- Must not access private members of the class under test.
+- Prefer `AnyFunSuite`/`AnyFunSuiteLike`; use `AnyWordSpec` only when given/when/then adds clarity.
+- Must place shared test helpers and fixtures in a dedicated `testing` sub-package and reuse them across tests.
+- Must not add top-level comments in `*Tests.scala` outside test methods; use nested `describe`/`"..."` blocks to separate groups.
+- Prefer TDD workflow:
+  - Must create or update `SPEC.md` before writing any code, listing scenarios, inputs, and expected outputs.
+  - Must propose the full test case set (name + intent + input + expected output) and wait for user confirmation before coding.
+  - Must write all failing tests first (red), then implement until all pass (green).
+  - Must cover all distinct combinations; each test must state its scenario in the ScalaDoc.
+  - Must update `SPEC.md` after all tests pass with the confirmed test case table.
+
+Tooling
+- Must format with scalafmt (`.scalafmt.conf`); lint with scalastyle (`scalastyle-config.xml`) or wartremover as configured.
+- Compiler warnings treated as errors where configured; coverage ≥ 80% via sbt-jacoco (excluding JMF-filtered methods in `jmf-rules.txt`).
+
+Coverage filtering (JMF)
+- A method qualifies for a JMF filter rule if it meets at least one criterion:
+  - No added value: trivial delegate, one-liner factory, or pure field accessor — a test adds no assurance beyond testing the delegated method.
+  - Not coverable without integration tests: requires a DB/external system; same path already exercised by integration tests.
+- Qualifying patterns: deprecated single-call delegates; `columnLabel: String` overloads that only call `columnNumber(label)` + Int-based overload; one-liner factory wrappers; implicit single-field accessors.
+- Must not add JMF rules for methods with branching logic, error handling, or non-trivial transformations.
+
+Quality gates
+- sbt "testOnly *UnitTests"   # unit tests, no DB needed
+- sbt test                     # all tests, DB must be running
+- sbt jacoco                   # coverage → balta/target/scala-*/jacoco/
+- sbt scalafmtCheck            # format check
+- sbt scalastyle               # lint
+
+Common pitfalls to avoid
+- Dependencies: verify compatibility across all cross-compiled Scala versions.
+- Unsafe casts: avoid `.asInstanceOf`; document why when unavoidable.
+- Logging: never pre-build log strings; always pass args lazily (call-by-name).
+- Cleanup: remove unused imports/variables (scalac `-Ywarn-unused`).
+- Stability: avoid changing externally-visible method signatures, SQL output, or parameter binding order.
+
+Learned rules
+- Must not change `QueryResultRow` getter return types or `stringPerConvention` output for existing scenarios.
+- Must not change externally-visible SQL generation patterns without updating dependent tests.
+
+Repo additions
+- Project name: balta
+- Entry points: `build.sbt`, `balta/src/main/scala/za/co/absa/db/balta/DBTestSuite.scala`
+- Core package: `za.co.absa.db.balta`; supporting: `za.co.absa.db.mag` (naming conventions)
+- DB boundary: `DBConnection` (JDBC wrapper), `DBTestSuite` (transaction rollback/commit)
+- Contract-sensitive: SQL generation in `DBTable`/`DBFunction`; parameter binding order; `QueryResultRow` getter return types; `stringPerConvention` output
+- Coverage tool: sbt-jacoco with JMF filter rules in `jmf-rules.txt`
+- Commands:
+  - sbt "testOnly *UnitTests"   # unit tests, no DB needed
+  - sbt test                     # all tests, DB must be running
+  - sbt jacoco                   # coverage report
diff --git a/.github/copilot-review-rules.md b/.github/copilot-review-rules.md
new file mode 100644
index 0000000..47fe590
--- /dev/null
+++ b/.github/copilot-review-rules.md
@@ -0,0 +1,47 @@
+# Copilot Review Rules
+
+Purpose
+- Define consistent, concise, action-oriented review behavior.
+- Use short headings and bullet lists; prefer do/avoid constraints over prose; point to code and impact.
+
+Mode: Default review
+- Scope: single PR, normal risk.
+- Priority order: correctness → security → tests → maintainability → style.
+- Checks:
+  - Correctness: logic bugs, missing edge cases, regressions, contract changes.
+  - Security: unsafe input handling, secrets exposure, auth/authz issues, insecure defaults.
+  - Tests: tests exist for changed logic; success + failure paths covered.
+  - Maintainability: unnecessary complexity, duplication, unclear naming/structure.
+  - Style: flag only when readability or repo conventions are broken.
+- Response format: short bullets; files + line ranges; severity groups (Blocker / Important / Nit); minimal actionable suggestions; no rewrites.
+
+Mode: Double-check review
+- Scope: higher-risk PRs (security, infra/CI, wide refactors, data migrations, auth changes).
+- Additional focus:
+  - Confirm previous review comments were addressed.
+  - Re-check: auth, permissions, secrets, persistence, external calls, concurrency.
+  - Hidden side effects: backward compatibility, failure modes, retries, idempotency.
+  - Safe defaults: least privilege, secure logging, safe error messages, missing-input behavior.
+- Response format: comment only where risk/impact is non-trivial; no repeated style notes; call out explicit risk acceptance (what / why acceptable / mitigation).
+
+Commenting rules (all modes)
+- Every comment must state: what the issue is · why it matters · minimal fix suggestion.
+- Prefer linking to existing repo patterns over introducing new ones.
+- If context is missing, ask a targeted question instead of assuming.
+
+Non-goals
+- No refactors unrelated to the PR's intent.
+- No formatting bikeshedding when the formatter/linter handles it.
+- No architectural rewrites unless explicitly requested.
+
+Repo additions
+- High-risk areas:
+  - DB transactions: `DBTestSuite` rollback/commit; do not change `persistData` behavior unintentionally.
+  - SQL injection: parameter binding uses `PreparedStatement`; no raw string concatenation of untrusted input.
+  - JDBC lifecycle: connections must be rolled back or committed; validate `try/finally` in `DBQuerySupport`.
+  - Contract-sensitive: `QueryResultRow` getter signatures; `stringPerConvention` output; `jmf-rules.txt`.
+  - Deprecations: do not extend `setParamNull`/`addNull` deprecated API surface.
+- Required tests:
+  - `*UnitTests`: no DB connection; mock `PreparedStatement`/`ResultSet` if needed.
+  - `*IntegrationTests`: extend `DBTestSuite` or `DBTestingConnection`.
+  - New naming convention implementations must have a `UnitTests` covering all `LettersCase` variants.
diff --git a/.gitignore b/.gitignore
index 0a71d64..fbd2fef 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,3 +55,4 @@ build.log
 .hg*
 
 .bsp
+TODO.md
diff --git a/jmf-rules.txt b/jmf-rules.txt
index 7c2ade2..5aa1b75 100644
--- a/jmf-rules.txt
+++ b/jmf-rules.txt
@@ -1,123 +1,13 @@
 # jacoco-method-filter — Default Rules & HowTo (Scala)
 # [jmf:1.0.0]
-#
-# This file defines which methods should be annotated as *Generated so JaCoCo ignores them.
-# One rule per line.
-#
-# ─────────────────────────────────────────────────────────────────────────────
-# HOW TO USE (quick)
-# 1) Replace YOUR.PACKAGE.ROOT with your project’s package root (e.g., com.example.app).
-# 2) Start with the CONSERVATIVE section only.
-# 3) If clean, enable STANDARD. Use AGGRESSIVE only inside DTO/auto‑generated packages.
-# 4) Keep rules narrow (by package), prefer flags (synthetic/bridge) for compiler artifacts,
-#    and add `id:` labels so logs are easy to read.
-#
-# ─────────────────────────────────────────────────────────────────────────────
-# ALLOWED SYNTAX (cheat sheet)
-#
-# General form:
-#   <FQCN_glob>#<method_glob>(<descriptor_glob>) [FLAGS and PREDICATES...]
-#
-# FQCN_glob (dot form; $ allowed for inner classes):
-#   Examples:  *.model.*,  com.example.*,  *
-#
-# method_glob (glob on method name):
-#   Examples:  copy   |   $anonfun$*   |   get*   |   *_$eq
-#
-# descriptor_glob (JVM descriptor in (args)ret). You may omit it entirely.
-#   • Omitting descriptor ⇒ treated as "(*)*" (any args, any return).
-#   • Short/empty forms "", "()", "(*)" normalize to "(*)*".
-#   Examples:
-#     (I)I                      # takes int, returns int
-#     (Ljava/lang/String;)V     # takes String, returns void
-#     ()  or  (*)  or omitted  # any args, any return
-#
-# FLAGS (optional) — space or comma separated:
-#   public | protected | private | synthetic | bridge | static | abstract
-#
-# PREDICATES (optional):
-#   ret:<glob>          # match return type only (e.g., ret:V, ret:I, ret:Lcom/example/*;)
-#   id:<string>         # identifier shown in logs/reports
-#   name-contains:<s>   # method name must contain <s>
-#   name-starts:<s>     # method name must start with <s>
-#   name-ends:<s>       # method name must end with <s>
-#
-# Notes
-# - Always use dot-form (com.example.Foo) for class names.
-# - Comments (# …) and blank lines are ignored.
-#
-# ─────────────────────────────────────────────────────────────────────────────
-# QUICK EXAMPLES
-#
-# Simple wildcards
-#   *#*(*)
-#     → Match EVERY method in EVERY class (any package). Useful only for diagnostics.
-#       "(*)" normalizes to "(*)*" ⇒ any args, any return.
-#   *.dto.*#*(*)
-#     → Match every method on any class under any package segment named "dto".
-#       Good when you treat DTOs as generated/boilerplate.
 
-# Scala case class helpers
-#   *.model.*#copy(*)
-#     → Matches Scala case-class `copy` methods under `*.model.*`.
-#       Hides boilerplate clones with any parameter list and any return.
-#   *.model.*#productArity()
-#     → Matches zero-arg `productArity` (case-class/Product API).
-#   *.model.*#productElement(*)
-#     → Matches `productElement(int)` (or any descriptor form) on case classes.
-#   *.model.*#productPrefix()
-#     → Matches `productPrefix()`; returns the case class' constructor name.
-
-# Companion objects and defaults
-#   *.model.*$*#apply(*)
-#     → Matches companion `apply` factories under `*.model.*` (any args).
-#       BE CAREFUL: can hide real factory logic; keep the package scope narrow.
-#   *.model.*$*#unapply(*)
-#     → Matches extractor `unapply` methods in companions under `*.model.*`.
-#   *#*$default$*(*)
-#     → Matches Scala-generated default-argument helpers everywhere.
-#       Safe to keep enabled; they’re compiler-synthesized.
-
-# Anonymous / synthetic / bridge
-#   *#$anonfun$*
-#     → Matches any method whose name contains `$anonfun$` (Scala lambdas).
-#       Consider adding `synthetic` and/or a package scope in real configs.
-#   *#*(*):synthetic            # any synthetic
-#     → Matches ANY method marked `synthetic` (compiler-generated).
-#       Powerful; scope by package to avoid hiding intentional glue code.
-#   *#*(*):bridge               # any bridge
-#     → Matches Java generic bridge methods the compiler inserts.
-#       Usually safe globally, but scoping is still recommended.
-
-# Setters / fluent APIs
-#   *.dto.*#*_$eq(*)
-#     → Matches Scala var setters in DTO packages (e.g., `name_=(...)`).
-#       Good for excluding trivial field writes.
-#   *.builder.*#with*(*)
-#     → Matches builder-style fluent setters (`withXxx(...)`) in builder pkgs.
-#       Treats chainable configuration as boilerplate.
-#   *.client.*#with*(*) ret:Lcom/api/client/*
-#     → Like above but ONLY when the return type matches your client package.
-#       The `ret:` predicate protects real logic that returns other types.
-
-# Return-type constraints
-#   *.jobs.*#*(*):ret:V
-#     → Any method under `*.jobs.*` returning `void` (`V`). Often orchestration.
-#   *.math.*#*(*):ret:I
-#     → Any method under `*.math.*` returning primitive int (`I`).
-#   *.model.*#*(*):ret:Lcom/example/model/*
-#     → Any method under `*.model.*` that returns a type in `com.example.model`.
-#       Handy when the *return type* uniquely identifies boilerplate.
-
-# ─────────────────────────────────────────────────────────────────────────────
 # GLOBALS RULES
-# ─────────────────────────────────────────────────────────────────────────────
 # ** all case class boilerplate
 
 # Scala case class helpers
 *#canEqual(*)                                           id:case-canequal
 *#equals(*)                                             id:case-equals
-*#apply(*)                                              id:case-apply
+#*#apply(*)                                              id:case-apply      - disabled: method used in code
 *#unapply(*)                                            id:case-unapply
 *#hashCode(*)                                           id:case-hashcode
 *#copy(*)                                               id:case-copy
@@ -150,6 +40,34 @@
 # lambda
 *#*  synthetic name-contains:$anonfun$                  id:scala-anonfun
 
-# ─────────────────────────────────────────────────────────────────────────────
 # PROJECT RULES
-# ─────────────────────────────────────────────────────────────────────────────
\ No newline at end of file
+
+# proposal to new globals
+*#productElementName(*)                                 id:case-prod-element-name
+*#productElementNames()                                 id:case-prod-element-names
+
+# Deprecated single-call delegates: setParamNull / addNull instance methods
+# Each method body is a single call to the non-deprecated replacement.
+# A unit test would only re-test the replacement method; no assurance is added.
+# Note: Params$ companion factory addNull methods are NOT filtered — they contain logic.
+*#setParamNull(*)                                       id:balta-deprecated-setnull
+Params$NamedParams#addNull(*)                           id:balta-deprecated-addnull-named
+Params$OrderedParams#addNull(*)                         id:balta-deprecated-addnull-ordered
+DBTestSuite#addNull(*)                                  id:balta-deprecated-addnull-suite
+
+# One-liner factory wrappers in DBTestSuite
+# Each method is a single constructor call delegating to DBTable / DBFunction with no logic of its own.
+DBTestSuite#table(*)                                    id:balta-factory-table
+DBTestSuite#function(*)                                 id:balta-factory-function
+
+# Trivial implicit conversion: DBConnection → JDBC Connection
+# Entire body returns in.connection; no branching or transformation; a test would only assert identity.
+DBConnection$#dbConnectionToJdbcConnection(*)           id:balta-implicit-dbconn
+
+# columnLabel: String overloads in QueryResultRow — pure label-resolution delegates
+# Each overload resolves the column label to an index via columnNumber(label) then forwards to the
+# Int-based overload. The Int-based overloads hold the extraction logic and are covered by integration tests.
+# apply(String) and the 2-param getAs(String, transformer) follow the same delegation pattern.
+QueryResultRow#get*(java.lang.String)                   id:balta-colname-getter
+QueryResultRow#getAs(java.lang.String,*)                id:balta-colname-getas-transformer
+QueryResultRow#apply(java.lang.String)                  id:balta-colname-apply

From 3c552dc778011056200f3ea88d795e316560499c Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 7 Apr 2026 14:40:15 +0200
Subject: [PATCH 02/13] Fixed tests folder structure. Partial test coverage of
 QueryResultRow. Fixes from self-review using copilot.

---
 .../classes => }/DBTestingConnection.scala    |   4 +-
 .../za/co/absa/db/balta/MockResultSets.scala  | 279 ++++++++++++++++++
 .../classes/DBTableIntegrationTests.scala     |   2 +-
 .../classes/QueryResultIntegrationTests.scala |  37 +++
 .../QueryResultRowIntegrationTests.scala      |   2 +-
 .../balta/classes/QueryResultUnitTests.scala  |  93 ++++++
 .../PostgresRowIntegrationTests.scala         |   2 +-
 ...ryResultRowImplicitsIntegrationTests.scala |   2 +-
 jmf-rules.txt                                 |   9 +
 9 files changed, 424 insertions(+), 6 deletions(-)
 rename balta/src/test/scala/za/co/absa/db/balta/{testing/classes => }/DBTestingConnection.scala (96%)
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/MockResultSets.scala
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultIntegrationTests.scala
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultUnitTests.scala

diff --git a/balta/src/test/scala/za/co/absa/db/balta/testing/classes/DBTestingConnection.scala b/balta/src/test/scala/za/co/absa/db/balta/DBTestingConnection.scala
similarity index 96%
rename from balta/src/test/scala/za/co/absa/db/balta/testing/classes/DBTestingConnection.scala
rename to balta/src/test/scala/za/co/absa/db/balta/DBTestingConnection.scala
index fd53ccc..27f2ccb 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/testing/classes/DBTestingConnection.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/DBTestingConnection.scala
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package za.co.absa.db.balta.testing.classes
+package za.co.absa.db.balta
 
 import za.co.absa.db.balta.classes.{DBConnection, QueryResult}
 import za.co.absa.db.balta.classes.inner.ConnectionInfo
@@ -31,7 +31,7 @@ trait DBTestingConnection {
     val preparedStatement = connection.connection.prepareStatement("SELECT now() AS now")
     val prep = preparedStatement.executeQuery()
     val result = new QueryResult(prep).next().getOffsetDateTime("now").get
-    prep.close()
+    preparedStatement.close()
     result
   }
 
diff --git a/balta/src/test/scala/za/co/absa/db/balta/MockResultSets.scala b/balta/src/test/scala/za/co/absa/db/balta/MockResultSets.scala
new file mode 100644
index 0000000..b7d77c2
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/MockResultSets.scala
@@ -0,0 +1,279 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta
+
+import java.io.{InputStream, Reader}
+import java.math.BigDecimal
+import java.net.URL
+import java.sql._
+
+/**
+ * Provides factory methods for minimal JDBC ResultSet stubs.
+ * Mix into any unit test suite that needs to construct a [[za.co.absa.db.balta.classes.QueryResult]]
+ * without a real database connection.
+ *
+ * Each factory method returns a fresh instance so tests do not share mutable state.
+ */
+trait MockResultSets {
+
+  /** Returns a ResultSet that immediately reports no more rows. */
+  def emptyMockResultSet: MockResultSets.MockResultSet = new MockResultSets.MockResultSet(0)
+
+  /** Returns a ResultSet that emits exactly one row (rowNumber = 1). */
+  def singleRowMockResultSet: MockResultSets.MockResultSet = new MockResultSets.MockResultSet(0) {
+    private var consumed = false
+    override def next(): Boolean = if (!consumed) { consumed = true; row = 1; true } else false
+  }
+
+  /** Returns a ResultSet that emits exactly two rows (rowNumbers 1 and 2). */
+  def twoRowMockResultSet: MockResultSets.MockResultSet = new MockResultSets.MockResultSet(0) {
+    private var count = 0
+    override def next(): Boolean = if (count < 2) { count += 1; row = count; true } else false
+  }
+
+  /** Returns an empty ResultSet with the given number of columns. */
+  def mockResultSetWithCols(cols: Int): MockResultSets.MockResultSet = new MockResultSets.MockResultSet(cols)
+}
+
+object MockResultSets {
+
+  private class MockMetaData(cols: Int) extends ResultSetMetaData {
+    override def getColumnCount: Int                        = cols
+    override def getColumnName(column: Int): String        = s"col$column"
+    override def getColumnType(column: Int): Int           = Types.VARCHAR
+    override def getColumnTypeName(column: Int): String    = "varchar"
+    override def isNullable(column: Int): Int              = ResultSetMetaData.columnNullable
+    override def getColumnLabel(column: Int): String       = getColumnName(column)
+    override def isAutoIncrement(column: Int): Boolean     = false
+    override def isCaseSensitive(column: Int): Boolean     = false
+    override def isSearchable(column: Int): Boolean        = false
+    override def isCurrency(column: Int): Boolean          = false
+    override def isSigned(column: Int): Boolean            = false
+    override def getColumnDisplaySize(column: Int): Int    = 0
+    override def getSchemaName(column: Int): String        = ""
+    override def getPrecision(column: Int): Int            = 0
+    override def getScale(column: Int): Int                = 0
+    override def getTableName(column: Int): String         = ""
+    override def getCatalogName(column: Int): String       = ""
+    override def isReadOnly(column: Int): Boolean          = false
+    override def isWritable(column: Int): Boolean          = false
+    override def isDefinitelyWritable(column: Int): Boolean = false
+    override def getColumnClassName(column: Int): String   = "java.lang.String"
+    override def unwrap[T](iface: Class[T]): T             = throw new UnsupportedOperationException
+    override def isWrapperFor(iface: Class[_]): Boolean    = false
+  }
+
+  /**
+   * Minimal ResultSet stub whose `next()` always returns false.
+   * Subclasses override `next()` to control row availability.
+   * `getObject(Int)` returns null so that the general extractor wraps each field as None.
+   */
+  class MockResultSet(cols: Int) extends ResultSet {
+    protected var row: Int = 0
+    override def getMetaData: ResultSetMetaData                           = new MockMetaData(cols)
+    override def getRow: Int                                              = row
+    override def next(): Boolean                                          = false
+    override def getObject(columnIndex: Int): AnyRef                     = null
+    override def getObject[T](columnIndex: Int, `type`: Class[T]): T     = null.asInstanceOf[T]
+    override def getArray(columnIndex: Int): java.sql.Array              = null
+    override def getArray(columnLabel: String): java.sql.Array           = null
+    override def close(): Unit                                            = ()
+    override def wasNull(): Boolean                                       = false
+    override def getString(columnIndex: Int): String                     = null
+    override def getBoolean(columnIndex: Int): Boolean                   = false
+    override def getByte(columnIndex: Int): Byte                         = 0
+    override def getShort(columnIndex: Int): Short                       = 0
+    override def getInt(columnIndex: Int): Int                           = 0
+    override def getLong(columnIndex: Int): Long                         = 0L
+    override def getFloat(columnIndex: Int): Float                       = 0f
+    override def getDouble(columnIndex: Int): Double                     = 0d
+    override def getBigDecimal(columnIndex: Int, scale: Int): BigDecimal = null
+    override def getBytes(columnIndex: Int): scala.Array[Byte]           = null
+    override def getDate(columnIndex: Int): Date                         = null
+    override def getTime(columnIndex: Int): Time                         = null
+    override def getTimestamp(columnIndex: Int): Timestamp               = null
+    override def getAsciiStream(columnIndex: Int): InputStream           = null
+    override def getUnicodeStream(columnIndex: Int): InputStream         = null
+    override def getBinaryStream(columnIndex: Int): InputStream          = null
+    override def getString(columnLabel: String): String                  = null
+    override def getBoolean(columnLabel: String): Boolean                = false
+    override def getByte(columnLabel: String): Byte                      = 0
+    override def getShort(columnLabel: String): Short                    = 0
+    override def getInt(columnLabel: String): Int                        = 0
+    override def getLong(columnLabel: String): Long                      = 0L
+    override def getFloat(columnLabel: String): Float                    = 0f
+    override def getDouble(columnLabel: String): Double                  = 0d
+    override def getBigDecimal(columnLabel: String, scale: Int): BigDecimal = null
+    override def getBytes(columnLabel: String): scala.Array[Byte]        = null
+    override def getDate(columnLabel: String): Date                      = null
+    override def getTime(columnLabel: String): Time                      = null
+    override def getTimestamp(columnLabel: String): Timestamp            = null
+    override def getAsciiStream(columnLabel: String): InputStream        = null
+    override def getUnicodeStream(columnLabel: String): InputStream      = null
+    override def getBinaryStream(columnLabel: String): InputStream       = null
+    override def getWarnings: SQLWarning                                  = null
+    override def clearWarnings(): Unit                                    = ()
+    override def getCursorName: String                                    = null
+    override def getObject(columnLabel: String): AnyRef                  = null
+    override def findColumn(columnLabel: String): Int                    = 0
+    override def getCharacterStream(columnIndex: Int): Reader            = null
+    override def getCharacterStream(columnLabel: String): Reader         = null
+    override def getBigDecimal(columnIndex: Int): BigDecimal             = null
+    override def getBigDecimal(columnLabel: String): BigDecimal          = null
+    override def isBeforeFirst: Boolean                                   = false
+    override def isAfterLast: Boolean                                     = false
+    override def isFirst: Boolean                                         = false
+    override def isLast: Boolean                                          = false
+    override def beforeFirst(): Unit                                      = ()
+    override def afterLast(): Unit                                        = ()
+    override def first(): Boolean                                         = false
+    override def last(): Boolean                                          = false
+    override def absolute(row: Int): Boolean                             = false
+    override def relative(rows: Int): Boolean                            = false
+    override def previous(): Boolean                                     = false
+    override def setFetchDirection(direction: Int): Unit                 = ()
+    override def getFetchDirection: Int                                  = 0
+    override def setFetchSize(rows: Int): Unit                           = ()
+    override def getFetchSize: Int                                       = 0
+    override def getType: Int                                            = ResultSet.TYPE_FORWARD_ONLY
+    override def getConcurrency: Int                                     = ResultSet.CONCUR_READ_ONLY
+    override def rowUpdated(): Boolean                                   = false
+    override def rowInserted(): Boolean                                  = false
+    override def rowDeleted(): Boolean                                   = false
+    override def updateNull(columnIndex: Int): Unit                      = ()
+    override def updateBoolean(columnIndex: Int, x: Boolean): Unit      = ()
+    override def updateByte(columnIndex: Int, x: Byte): Unit            = ()
+    override def updateShort(columnIndex: Int, x: Short): Unit          = ()
+    override def updateInt(columnIndex: Int, x: Int): Unit              = ()
+    override def updateLong(columnIndex: Int, x: Long): Unit            = ()
+    override def updateFloat(columnIndex: Int, x: Float): Unit          = ()
+    override def updateDouble(columnIndex: Int, x: Double): Unit        = ()
+    override def updateBigDecimal(columnIndex: Int, x: BigDecimal): Unit = ()
+    override def updateString(columnIndex: Int, x: String): Unit        = ()
+    override def updateBytes(columnIndex: Int, x: scala.Array[Byte]): Unit = ()
+    override def updateDate(columnIndex: Int, x: Date): Unit            = ()
+    override def updateTime(columnIndex: Int, x: Time): Unit            = ()
+    override def updateTimestamp(columnIndex: Int, x: Timestamp): Unit  = ()
+    override def updateAsciiStream(columnIndex: Int, x: InputStream, length: Int): Unit    = ()
+    override def updateBinaryStream(columnIndex: Int, x: InputStream, length: Int): Unit   = ()
+    override def updateCharacterStream(columnIndex: Int, x: Reader, length: Int): Unit     = ()
+    override def updateObject(columnIndex: Int, x: AnyRef, scaleOrLength: Int): Unit       = ()
+    override def updateObject(columnIndex: Int, x: AnyRef): Unit        = ()
+    override def updateNull(columnLabel: String): Unit                   = ()
+    override def updateBoolean(columnLabel: String, x: Boolean): Unit   = ()
+    override def updateByte(columnLabel: String, x: Byte): Unit         = ()
+    override def updateShort(columnLabel: String, x: Short): Unit       = ()
+    override def updateInt(columnLabel: String, x: Int): Unit           = ()
+    override def updateLong(columnLabel: String, x: Long): Unit         = ()
+    override def updateFloat(columnLabel: String, x: Float): Unit       = ()
+    override def updateDouble(columnLabel: String, x: Double): Unit     = ()
+    override def updateBigDecimal(columnLabel: String, x: BigDecimal): Unit = ()
+    override def updateString(columnLabel: String, x: String): Unit     = ()
+    override def updateBytes(columnLabel: String, x: scala.Array[Byte]): Unit = ()
+    override def updateDate(columnLabel: String, x: Date): Unit         = ()
+    override def updateTime(columnLabel: String, x: Time): Unit         = ()
+    override def updateTimestamp(columnLabel: String, x: Timestamp): Unit = ()
+    override def updateAsciiStream(columnLabel: String, x: InputStream, length: Int): Unit   = ()
+    override def updateBinaryStream(columnLabel: String, x: InputStream, length: Int): Unit  = ()
+    override def updateCharacterStream(columnLabel: String, x: Reader, length: Int): Unit    = ()
+    override def updateObject(columnLabel: String, x: AnyRef, scaleOrLength: Int): Unit      = ()
+    override def updateObject(columnLabel: String, x: AnyRef): Unit     = ()
+    override def insertRow(): Unit                                       = ()
+    override def updateRow(): Unit                                       = ()
+    override def deleteRow(): Unit                                       = ()
+    override def refreshRow(): Unit                                      = ()
+    override def cancelRowUpdates(): Unit                                = ()
+    override def moveToInsertRow(): Unit                                 = ()
+    override def moveToCurrentRow(): Unit                                = ()
+    override def getStatement: Statement                                 = null
+    override def getObject(columnIndex: Int, map: java.util.Map[String, Class[_]]): AnyRef = null
+    override def getRef(columnIndex: Int): Ref                          = null
+    override def getBlob(columnIndex: Int): Blob                        = null
+    override def getClob(columnIndex: Int): Clob                        = null
+    override def getObject(columnLabel: String, map: java.util.Map[String, Class[_]]): AnyRef = null
+    override def getRef(columnLabel: String): Ref                       = null
+    override def getBlob(columnLabel: String): Blob                     = null
+    override def getClob(columnLabel: String): Clob                     = null
+    override def getDate(columnIndex: Int, cal: java.util.Calendar): Date   = null
+    override def getDate(columnLabel: String, cal: java.util.Calendar): Date = null
+    override def getTime(columnIndex: Int, cal: java.util.Calendar): Time   = null
+    override def getTime(columnLabel: String, cal: java.util.Calendar): Time = null
+    override def getTimestamp(columnIndex: Int, cal: java.util.Calendar): Timestamp   = null
+    override def getTimestamp(columnLabel: String, cal: java.util.Calendar): Timestamp = null
+    override def getURL(columnIndex: Int): URL                          = null
+    override def getURL(columnLabel: String): URL                       = null
+    override def updateRef(columnIndex: Int, x: Ref): Unit              = ()
+    override def updateRef(columnLabel: String, x: Ref): Unit           = ()
+    override def updateBlob(columnIndex: Int, x: Blob): Unit            = ()
+    override def updateBlob(columnLabel: String, x: Blob): Unit         = ()
+    override def updateClob(columnIndex: Int, x: Clob): Unit            = ()
+    override def updateClob(columnLabel: String, x: Clob): Unit         = ()
+    override def updateArray(columnIndex: Int, x: java.sql.Array): Unit = ()
+    override def updateArray(columnLabel: String, x: java.sql.Array): Unit = ()
+    override def getRowId(columnIndex: Int): RowId                      = null
+    override def getRowId(columnLabel: String): RowId                   = null
+    override def updateRowId(columnIndex: Int, x: RowId): Unit          = ()
+    override def updateRowId(columnLabel: String, x: RowId): Unit       = ()
+    override def getHoldability: Int                                     = 0
+    override def isClosed: Boolean                                       = false
+    override def updateNString(columnIndex: Int, nString: String): Unit  = ()
+    override def updateNString(columnLabel: String, nString: String): Unit = ()
+    override def updateNClob(columnIndex: Int, nClob: NClob): Unit       = ()
+    override def updateNClob(columnLabel: String, nClob: NClob): Unit    = ()
+    override def getNClob(columnIndex: Int): NClob                       = null
+    override def getNClob(columnLabel: String): NClob                    = null
+    override def getSQLXML(columnIndex: Int): SQLXML                     = null
+    override def getSQLXML(columnLabel: String): SQLXML                  = null
+    override def updateSQLXML(columnIndex: Int, xmlObject: SQLXML): Unit  = ()
+    override def updateSQLXML(columnLabel: String, xmlObject: SQLXML): Unit = ()
+    override def getNString(columnIndex: Int): String                    = null
+    override def getNString(columnLabel: String): String                 = null
+    override def getNCharacterStream(columnIndex: Int): Reader           = null
+    override def getNCharacterStream(columnLabel: String): Reader        = null
+    override def updateNCharacterStream(columnIndex: Int, x: Reader, length: Long): Unit    = ()
+    override def updateNCharacterStream(columnLabel: String, x: Reader, length: Long): Unit = ()
+    override def updateAsciiStream(columnIndex: Int, x: InputStream, length: Long): Unit    = ()
+    override def updateBinaryStream(columnIndex: Int, x: InputStream, length: Long): Unit   = ()
+    override def updateCharacterStream(columnIndex: Int, x: Reader, length: Long): Unit     = ()
+    override def updateAsciiStream(columnLabel: String, x: InputStream, length: Long): Unit  = ()
+    override def updateBinaryStream(columnLabel: String, x: InputStream, length: Long): Unit = ()
+    override def updateCharacterStream(columnLabel: String, x: Reader, length: Long): Unit   = ()
+    override def updateBlob(columnIndex: Int, inputStream: InputStream, length: Long): Unit  = ()
+    override def updateBlob(columnLabel: String, inputStream: InputStream, length: Long): Unit = ()
+    override def updateClob(columnIndex: Int, reader: Reader, length: Long): Unit    = ()
+    override def updateClob(columnLabel: String, reader: Reader, length: Long): Unit = ()
+    override def updateNClob(columnIndex: Int, reader: Reader, length: Long): Unit    = ()
+    override def updateNClob(columnLabel: String, reader: Reader, length: Long): Unit = ()
+    override def updateNCharacterStream(columnIndex: Int, x: Reader): Unit    = ()
+    override def updateNCharacterStream(columnLabel: String, x: Reader): Unit = ()
+    override def updateAsciiStream(columnIndex: Int, x: InputStream): Unit    = ()
+    override def updateBinaryStream(columnIndex: Int, x: InputStream): Unit   = ()
+    override def updateCharacterStream(columnIndex: Int, x: Reader): Unit     = ()
+    override def updateAsciiStream(columnLabel: String, x: InputStream): Unit  = ()
+    override def updateBinaryStream(columnLabel: String, x: InputStream): Unit = ()
+    override def updateCharacterStream(columnLabel: String, x: Reader): Unit   = ()
+    override def updateBlob(columnIndex: Int, inputStream: InputStream): Unit  = ()
+    override def updateBlob(columnLabel: String, inputStream: InputStream): Unit = ()
+    override def updateClob(columnIndex: Int, reader: Reader): Unit    = ()
+    override def updateClob(columnLabel: String, reader: Reader): Unit = ()
+    override def updateNClob(columnIndex: Int, reader: Reader): Unit    = ()
+    override def updateNClob(columnLabel: String, reader: Reader): Unit = ()
+    override def getObject[T](columnLabel: String, `type`: Class[T]): T = null.asInstanceOf[T]
+    override def unwrap[T](iface: Class[T]): T = throw new UnsupportedOperationException
+    override def isWrapperFor(iface: Class[_]): Boolean = false
+  }
+}
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/DBTableIntegrationTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/DBTableIntegrationTests.scala
index b84902c..94a3045 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/DBTableIntegrationTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/DBTableIntegrationTests.scala
@@ -18,7 +18,7 @@ package za.co.absa.db.balta.classes
 
 import org.scalatest.funsuite.AnyFunSuiteLike
 import za.co.absa.db.balta.classes.inner.Params
-import za.co.absa.db.balta.testing.classes.DBTestingConnection
+import za.co.absa.db.balta.DBTestingConnection
 import za.co.absa.db.balta.implicits.OptionImplicits.OptionEnhancements
 import DBTableIntegrationTests.QueryResultRowAssertion
 
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultIntegrationTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultIntegrationTests.scala
new file mode 100644
index 0000000..42dfb0f
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultIntegrationTests.scala
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta.classes
+
+import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.DBTestingConnection
+
+class QueryResultIntegrationTests extends AnyFunSuiteLike with DBTestingConnection {
+
+  test("noMore is true after all rows are consumed") {
+    DBTable("testing.base_types").all() { qr =>
+      while (qr.hasNext) qr.next()
+      assert(qr.noMore)
+    }
+  }
+
+  test("resultSetMetaData exposes the correct column count") {
+    DBTable("testing.base_types").all() { qr =>
+      assert(qr.resultSetMetaData.getColumnCount == 14)
+    }
+  }
+
+}
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowIntegrationTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowIntegrationTests.scala
index bd82773..6cc163d 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowIntegrationTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowIntegrationTests.scala
@@ -17,7 +17,7 @@
 package za.co.absa.db.balta.classes
 
 import org.scalatest.funsuite.AnyFunSuiteLike
-import za.co.absa.db.balta.testing.classes.DBTestingConnection
+import za.co.absa.db.balta.DBTestingConnection
 
 import java.sql.{Date, ResultSetMetaData, Time}
 import java.text.SimpleDateFormat
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultUnitTests.scala
new file mode 100644
index 0000000..43facdf
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultUnitTests.scala
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta.classes
+
+import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.MockResultSets
+
+import java.sql.SQLException
+
+class QueryResultUnitTests extends AnyFunSuiteLike with MockResultSets {
+
+  test("hasNext returns false for an empty result set") {
+    val qr = new QueryResult(emptyMockResultSet)
+    assert(!qr.hasNext)
+  }
+
+  test("hasNext returns true when at least one row is available") {
+    val qr = new QueryResult(singleRowMockResultSet)
+    assert(qr.hasNext)
+  }
+
+  test("hasNext returns true after repeated calls without consuming the row") {
+    val qr = new QueryResult(singleRowMockResultSet)
+    assert(qr.hasNext)
+    assert(qr.hasNext)
+  }
+
+  test("hasNext returns false after the only row has been consumed") {
+    val qr = new QueryResult(singleRowMockResultSet)
+    qr.next()
+    assert(!qr.hasNext)
+  }
+
+  test("hasNext swallows SQLException and returns false") {
+    val throwingResultSet = new MockResultSets.MockResultSet(0) {
+      private var called = false
+      override def next(): Boolean = {
+        if (!called) {
+          called = true
+          throw new SQLException("simulated failure")
+        }
+        false
+      }
+    }
+    val qr = new QueryResult(throwingResultSet)
+    assert(!qr.hasNext)
+  }
+
+  test("next returns the first row when result set is non-empty") {
+    val qr = new QueryResult(singleRowMockResultSet)
+    val row = qr.next()
+    assert(row.rowNumber == 1)
+  }
+
+  test("next advances through all rows in order") {
+    val qr = new QueryResult(twoRowMockResultSet)
+    val first  = qr.next()
+    val second = qr.next()
+    assert(first.rowNumber  == 1)
+    assert(second.rowNumber == 2)
+  }
+
+  test("next throws NoSuchElementException when result set is exhausted") {
+    val qr = new QueryResult(emptyMockResultSet)
+    assertThrows[NoSuchElementException](qr.next())
+  }
+
+  test("next throws NoSuchElementException after consuming all rows") {
+    val qr = new QueryResult(singleRowMockResultSet)
+    qr.next()
+    assertThrows[NoSuchElementException](qr.next())
+  }
+
+  test("columnCount reflects the value reported by ResultSetMetaData") {
+    val qr = new QueryResult(mockResultSetWithCols(3))
+    assert(qr.columnCount == 3)
+  }
+
+}
diff --git a/balta/src/test/scala/za/co/absa/db/balta/implicits/PostgresRowIntegrationTests.scala b/balta/src/test/scala/za/co/absa/db/balta/implicits/PostgresRowIntegrationTests.scala
index e2bb630..fb18d3d 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/implicits/PostgresRowIntegrationTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/implicits/PostgresRowIntegrationTests.scala
@@ -20,7 +20,7 @@ import org.scalatest.funsuite.AnyFunSuiteLike
 import za.co.absa.db.balta.classes.{DBTable, QueryResultRow}
 import za.co.absa.db.balta.postgres.implicits.Postgres.PostgresRow
 import za.co.absa.db.balta.postgres.classes.SimpleJsonString
-import za.co.absa.db.balta.testing.classes.DBTestingConnection
+import za.co.absa.db.balta.DBTestingConnection
 
 import java.sql.ResultSetMetaData
 
diff --git a/balta/src/test/scala/za/co/absa/db/balta/implicits/QueryResultRowImplicitsIntegrationTests.scala b/balta/src/test/scala/za/co/absa/db/balta/implicits/QueryResultRowImplicitsIntegrationTests.scala
index 65e8b0d..fdd7676 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/implicits/QueryResultRowImplicitsIntegrationTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/implicits/QueryResultRowImplicitsIntegrationTests.scala
@@ -21,7 +21,7 @@ import java.util.UUID
 import org.scalatest.funsuite.AnyFunSuiteLike
 import za.co.absa.db.balta.classes.DBFunction
 import za.co.absa.db.balta.implicits.QueryResultRowImplicits.ProductTypeConvertor
-import za.co.absa.db.balta.testing.classes.DBTestingConnection
+import za.co.absa.db.balta.DBTestingConnection
 import za.co.absa.db.mag.naming.NamingConvention
 import za.co.absa.db.mag.naming.implementations.MapBasedNaming
 
diff --git a/jmf-rules.txt b/jmf-rules.txt
index 5aa1b75..d5323fb 100644
--- a/jmf-rules.txt
+++ b/jmf-rules.txt
@@ -71,3 +71,12 @@ DBConnection$#dbConnectionToJdbcConnection(*)           id:balta-implicit-dbconn
 QueryResultRow#get*(java.lang.String)                   id:balta-colname-getter
 QueryResultRow#getAs(java.lang.String,*)                id:balta-colname-getas-transformer
 QueryResultRow#apply(java.lang.String)                  id:balta-colname-apply
+
+# QueryResult#noMore — trivial negation of hasNext
+# Body is exactly `!hasNext`; testing it adds no assurance beyond the hasNext unit tests.
+QueryResult#noMore()                                    id:balta-nomore
+
+# QueryResult#resultSetMetaData — implicit field accessor (public val)
+# Scala compiles a public val to a 0-arg getter that returns the backing field.
+# No logic; a test would only assert identity of what was passed to the constructor.
+QueryResult#resultSetMetaData()                         id:balta-resultsetmetadata-accessor

From 8ca828514cc6d273746dae799072cb54cefd9426 Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 7 Apr 2026 15:10:05 +0200
Subject: [PATCH 03/13] fix: update testing guidelines and filename exclusions
 in workflows

---
 .github/copilot-instructions.md            | 4 ++--
 .github/workflows/test_filenames_check.yml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 3b64025..37e28ed 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -50,8 +50,8 @@ Testing
 - Integration test files: name ends with `IntegrationTests`; must extend `DBTestSuite` or mix in `DBTestingConnection`.
 - Must not access private members of the class under test.
 - Prefer `AnyFunSuite`/`AnyFunSuiteLike`; use `AnyWordSpec` only when given/when/then adds clarity.
-- Must place shared test helpers and fixtures in a dedicated `testing` sub-package and reuse them across tests.
-- Must not add top-level comments in `*Tests.scala` outside test methods; use nested `describe`/`"..."` blocks to separate groups.
+- Must place shared test helpers and fixtures in the root test package (`za.co.absa.db.balta`) and reuse them across tests; shared files are excluded from the filename-inspector check.
+- Must not add top-level comments in `*Tests.scala` outside test methods; use nested `"..."` / `should` / `when` blocks (idiomatic to the chosen suite style) to separate groups.
 - Prefer TDD workflow:
   - Must create or update `SPEC.md` before writing any code, listing scenarios, inputs, and expected outputs.
   - Must propose the full test case set (name + intent + input + expected output) and wait for user confirmation before coding.
diff --git a/.github/workflows/test_filenames_check.yml b/.github/workflows/test_filenames_check.yml
index 804f280..0fe8418 100644
--- a/.github/workflows/test_filenames_check.yml
+++ b/.github/workflows/test_filenames_check.yml
@@ -36,6 +36,6 @@ jobs:
           name-patterns: '*UnitTests.*,*IntegrationTests.*'
           paths: '**/src/test/scala/**'
           report-format: 'console'
-          excludes: 'balta/src/test/scala/za/co/absa/db/balta/testing/*'
+          excludes: 'balta/src/test/scala/za/co/absa/db/balta/DBTestingConnection.scala,balta/src/test/scala/za/co/absa/db/balta/MockResultSets.scala'
           verbose-logging: 'false'
           fail-on-violation: 'true'

From 0c236f75b011ba244fdb23041f0d69bda771d39f Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Mon, 13 Apr 2026 19:24:28 +0200
Subject: [PATCH 04/13] Improved to clean solution as reaction to review
 comment.

---
 .github/workflows/test_filenames_check.yml                      | 2 +-
 .../za/co/absa/db/balta/{ => testing}/DBTestingConnection.scala | 0
 .../za/co/absa/db/balta/{ => testing}/MockResultSets.scala      | 0
 3 files changed, 1 insertion(+), 1 deletion(-)
 rename balta/src/test/scala/za/co/absa/db/balta/{ => testing}/DBTestingConnection.scala (100%)
 rename balta/src/test/scala/za/co/absa/db/balta/{ => testing}/MockResultSets.scala (100%)

diff --git a/.github/workflows/test_filenames_check.yml b/.github/workflows/test_filenames_check.yml
index 0fe8418..44d296c 100644
--- a/.github/workflows/test_filenames_check.yml
+++ b/.github/workflows/test_filenames_check.yml
@@ -36,6 +36,6 @@ jobs:
           name-patterns: '*UnitTests.*,*IntegrationTests.*'
           paths: '**/src/test/scala/**'
           report-format: 'console'
-          excludes: 'balta/src/test/scala/za/co/absa/db/balta/DBTestingConnection.scala,balta/src/test/scala/za/co/absa/db/balta/MockResultSets.scala'
+          excludes: 'balta/src/test/scala/za/co/absa/db/balta/testing/**'
           verbose-logging: 'false'
           fail-on-violation: 'true'
diff --git a/balta/src/test/scala/za/co/absa/db/balta/DBTestingConnection.scala b/balta/src/test/scala/za/co/absa/db/balta/testing/DBTestingConnection.scala
similarity index 100%
rename from balta/src/test/scala/za/co/absa/db/balta/DBTestingConnection.scala
rename to balta/src/test/scala/za/co/absa/db/balta/testing/DBTestingConnection.scala
diff --git a/balta/src/test/scala/za/co/absa/db/balta/MockResultSets.scala b/balta/src/test/scala/za/co/absa/db/balta/testing/MockResultSets.scala
similarity index 100%
rename from balta/src/test/scala/za/co/absa/db/balta/MockResultSets.scala
rename to balta/src/test/scala/za/co/absa/db/balta/testing/MockResultSets.scala

From 992f929d8da873a13a9401b25379a4c564c2d908 Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 14 Apr 2026 08:17:30 +0200
Subject: [PATCH 05/13] Add unit tests and database configuration for
 DBFunction and QueryResultRow

- Introduced `database-persist.properties` for test database configuration.
- Added `DBFunctionUnitTests` to validate the behavior of DBFunction with named and positioned parameters.
- Created `QueryResultRowUnitTests` to test the functionality of QueryResultRow, including handling of various SQL types and conversion to case classes.
- Implemented `ParamsUnitTests` to ensure correct behavior of named and ordered parameters.
- Developed `RecordingPreparedStatement` to facilitate testing of parameter assignments without a real database.
- Added `QueryParamTypeUnitTests` and `QueryParamValueUnitTests` to verify the correct assignment of various parameter types to the prepared statement.
---
 .github/copilot-instructions.md               |  26 +-
 JMF-NOTES.md                                  | 429 ++++++++++++++++++
 .../resources/database-persist.properties     |   7 +
 .../absa/db/balta/DBTestSuiteUnitTests.scala  |  31 ++
 .../balta/classes/DBFunctionUnitTests.scala   |  71 +++
 .../classes/QueryResultRowUnitTests.scala     | 310 +++++++++++++
 .../balta/classes/inner/ParamsUnitTests.scala |  94 ++++
 .../testing/RecordingPreparedStatement.scala  | 134 ++++++
 .../typeclasses/QueryParamTypeUnitTests.scala | 131 ++++++
 .../QueryParamValueUnitTests.scala            |  67 +++
 .../SnakeCaseNamingUnitTests.scala            |  13 +
 jmf-rules.txt                                 | 321 ++++++++++++-
 12 files changed, 1618 insertions(+), 16 deletions(-)
 create mode 100644 JMF-NOTES.md
 create mode 100644 balta/src/test/resources/database-persist.properties
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/classes/DBFunctionUnitTests.scala
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
 create mode 100644 balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 37e28ed..2af2f79 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -58,17 +58,32 @@ Testing
   - Must write all failing tests first (red), then implement until all pass (green).
   - Must cover all distinct combinations; each test must state its scenario in the ScalaDoc.
   - Must update `SPEC.md` after all tests pass with the confirmed test case table.
+- When a unit test adds value — write one:
+  - Method has any own logic: branching (`if`/`match`), exception handling or swallowing, non-trivial transformation, config/resource read, or reflection.
+- When to add to `jmf-rules.txt` instead of writing a unit test:
+  - Body is a single call with no own logic: forwards to another overload, calls its non-deprecated replacement, returns a field, or wraps a constructor with no transformation.
+  - Litmus: "Does this method have any logic of its own?" — No → JMF.
+- Review rule — JMF drift check: when modifying a method that appears in `jmf-rules.txt`, verify its body still qualifies; if own logic has been added, remove the JMF rule and write a unit test instead.
 
 Tooling
 - Must format with scalafmt (`.scalafmt.conf`); lint with scalastyle (`scalastyle-config.xml`) or wartremover as configured.
 - Compiler warnings treated as errors where configured; coverage ≥ 80% via sbt-jacoco (excluding JMF-filtered methods in `jmf-rules.txt`).
 
 Coverage filtering (JMF)
-- A method qualifies for a JMF filter rule if it meets at least one criterion:
-  - No added value: trivial delegate, one-liner factory, or pure field accessor — a test adds no assurance beyond testing the delegated method.
-  - Not coverable without integration tests: requires a DB/external system; same path already exercised by integration tests.
-- Qualifying patterns: deprecated single-call delegates; `columnLabel: String` overloads that only call `columnNumber(label)` + Int-based overload; one-liner factory wrappers; implicit single-field accessors.
+- A method qualifies when its body is a single call with no own logic (see Testing section for the full decision rule and qualifying patterns).
 - Must not add JMF rules for methods with branching logic, error handling, or non-trivial transformations.
+- Rules file: `jmf-rules.txt` (version `[jmf:1.0.0]`); one rule per line, `#` comments and blank lines ignored.
+- Rule syntax: `<FQCN_glob>#<method_glob>(<descriptor_glob>) [FLAGS] [PREDICATES]`
+  - FQCN_glob: dot-form class pattern (`*`, `*.model.*`, `com.example.*`; `$` for inner/companion classes).
+  - method_glob: glob on method name (`copy`, `get*`, `$anonfun$*`, `*_$eq`).
+  - descriptor_glob: JVM descriptor `(args)ret`; omitting or `(*)` means any args/any return. Must use JVM internal format: `(I)*` not `(int)`, `(Z)*` not `(boolean)`, `(Ljava/lang/String;)*` not `(java.lang.String)`. Non-matching descriptors are silently ignored — no warning is emitted.
+  - FLAGS (space/comma separated): `public`, `protected`, `private`, `synthetic`, `bridge`, `static`, `abstract`.
+  - PREDICATES: `ret:<glob>` (return type), `id:<string>` (log label), `name-contains:<s>`, `name-starts:<s>`, `name-ends:<s>`.
+- Every rule Must include an `id:` label for traceability.
+- Adoption order: start with CONSERVATIVE (case-class boilerplate, compiler synthetics), then STANDARD; use AGGRESSIVE only for DTO/auto-generated packages.
+- Prefer narrow package scopes; prefer `synthetic`/`bridge` flags for compiler artifacts over broad wildcards.
+- Must prefix project-specific FQCN globs with `*` so they match the full qualified class name (e.g. `*QueryResult#noMore()`, not `QueryResult#noMore()`).
+- When adding a project-specific rule, add it under the `# PROJECT RULES` section with a comment explaining why the method qualifies.
 
 Quality gates
 - sbt "testOnly *UnitTests"   # unit tests, no DB needed
@@ -83,10 +98,13 @@ Common pitfalls to avoid
 - Logging: never pre-build log strings; always pass args lazily (call-by-name).
 - Cleanup: remove unused imports/variables (scalac `-Ywarn-unused`).
 - Stability: avoid changing externally-visible method signatures, SQL output, or parameter binding order.
+- JMF silent failures: rules with non-matching FQCN or descriptor globs are silently ignored; always verify new rules take effect by comparing JaCoCo method-level output before and after.
+- Scala reflection: case classes used with `currentMirror.reflectClass` in tests must be top-level (package scope), not inner classes — Scala reflection cannot handle inner class mirrors.
 
 Learned rules
 - Must not change `QueryResultRow` getter return types or `stringPerConvention` output for existing scenarios.
 - Must not change externally-visible SQL generation patterns without updating dependent tests.
+- Scala 2.12 compiler artifacts that generate coverable bytecode: `$anonfun$` lambdas (ACC_SYNTHETIC), `$deserializeLambda$` (private static, not synthetic), Function1 mixin forwarders (`andThen`/`compose`), value class `$extension` methods, `$default$` parameter methods, Iterator trait mixin (~80+ forwarders). These are JMF candidates, not unit-test candidates.
 
 Repo additions
 - Project name: balta
diff --git a/JMF-NOTES.md b/JMF-NOTES.md
new file mode 100644
index 0000000..fa0df4c
--- /dev/null
+++ b/JMF-NOTES.md
@@ -0,0 +1,429 @@
+# JMF (jacoco-method-filter) — Lessons Learned
+
+Practical notes for anyone maintaining or extending `jmf-rules.txt` in this project.
+Accumulated from real debugging sessions; each entry caused at least one silent coverage regression.
+
+---
+
+## 1. Descriptor format must be JVM internal, not human-readable
+
+**Wrong:**
+```
+*QueryResultRow#apply(int)*          id:qrr-apply-int
+*QueryResultRow#getAs(java.lang.String,*)*  id:qrr-getas-str
+```
+**Right:**
+```
+*QueryResultRow#apply(I)*            id:qrr-apply-int
+*QueryResultRow#getAs(Ljava/lang/String;*)*  id:qrr-getas-str
+```
+
+JMF compares against raw JVM bytecode descriptors, not source-level types.
+Common type mappings:
+
+| Source type    | JVM descriptor               |
+|----------------|------------------------------|
+| `int`          | `I`                          |
+| `boolean`      | `Z`                          |
+| `long`         | `J`                          |
+| `double`       | `D`                          |
+| `String`       | `Ljava/lang/String;`         |
+| `Option[A]`    | `Lscala/Option;`             |
+| `Unit` / void  | `V`                          |
+| array of int   | `[I`                         |
+
+Use `javap -p -verbose <ClassFile.class>` to see the actual descriptors for any method.
+
+---
+
+## 2. FQCN globs must start with `*` to match qualified class names
+
+**Wrong:**
+```
+QueryResult#noMore()   id:qr-nomore
+```
+**Right:**
+```
+*QueryResult#noMore()  id:qr-nomore
+```
+
+Without the leading `*`, the glob is matched literally and will never match
+`za.co.absa.db.balta.classes.QueryResult`.
+
+---
+
+## 3. Non-matching rules are silently ignored — no warning, no error
+
+JMF does not report unmatched rules. A rule can be completely wrong and the tool will
+load it, count it, and do nothing — while JaCoCo continues to count the method as missed.
+
+**Consequence:** Coverage numbers may look fine if another test happens to cover the same
+method via a different path (e.g., an integration test). The rule appears to work for months,
+then suddenly "breaks" when that test is removed or the method is called less often.
+
+**How to verify a rule is actually filtering:**
+1. Run `sbt ++2.12.18 jacoco` and note the JMF log line: `Marked N methods`.
+2. Add the new rule.
+3. Run again and confirm `N` increased.
+4. Cross-reference `balta/target/scala-2.12/jacoco/jacoco.xml` to confirm the specific
+   method now has `mi="0"` (missed instructions = 0) AND `ci` dropped by the expected amount.
+
+---
+
+## 4. Diagnosing a missed-coverage method
+
+When JaCoCo reports missed instructions after you believe you have a rule:
+
+1. Find the method in `jacoco.xml`:
+   ```
+   grep -A2 'name="myMethod"' balta/target/scala-2.12/jacoco/jacoco.xml
+   ```
+2. Check `mi` (missed instructions) and `nr` (not-reached branches).
+3. Get the actual bytecode descriptor:
+   ```
+   javap -p -verbose balta/target/scala-2.12/classes/za/co/absa/.../MyClass.class \
+     | grep -A4 "myMethod"
+   ```
+4. Compare the descriptor in your rule against the bytecode output.
+   Common mistakes: `(int)` vs `(I)`, missing `;` after object type, `*` vs explicit return type.
+
+---
+
+## 5. Scala 2.12 compiler-generated methods that produce coverable bytecode
+
+These arise automatically and are JMF candidates (no own logic), not unit-test candidates:
+
+| Pattern | Description |
+|---------|-------------|
+| `$anonfun$*` (ACC_SYNTHETIC) | Lambda bodies lifted to class methods |
+| `$deserializeLambda$` (private static, NOT synthetic) | SerializedLambda support |
+| `andThen` / `compose` | Function1 trait mixin forwarders |
+| `*$extension` | Value class extension methods (boxed path) |
+| `*$default$*` | Default parameter methods (`$default$1`, `$default$2`, …) |
+| Iterator trait mixins (~80+) | `hasNext`, `next`, `drop`, `take`, `sliding`, etc. |
+| `writeReplace` | Java serialization hook for case classes |
+
+When a method's coverage is missed and its source is compiler-generated, add a JMF rule
+rather than writing a test.
+
+---
+
+## 6. Verifying new rules end-to-end
+
+Minimal workflow before committing any new JMF rule:
+
+```bash
+# 1. baseline — note "Marked N methods" in sbt output
+sbt '++2.12.18; jacoco'
+
+# 2. add rule to jmf-rules.txt
+
+# 3. re-run — "Marked N+k methods" confirms the rule matched
+sbt '++2.12.18; jacoco'
+
+# 4. quick coverage check
+awk -F',' 'NR>1{m+=$5; c+=$6} END{printf "Missed: %d  Covered: %d  Total: %d  Coverage: %.1f%%\n", m, c, m+c, c*100/(m+c)}' \
+  balta/target/scala-2.12/jacoco/jacoco.csv
+```
+
+---
+
+## 7. Avoid broad wildcards — prefer `synthetic`/`bridge` flags
+
+A rule like `*#*$anonfun$*(*)` with the `synthetic` flag is safer than an unqualified
+glob that might accidentally suppress coverage for hand-written lambdas.
+
+```
+*#$anonfun$*(*)  synthetic  id:scala-anonfun
+```
+
+The `synthetic` flag restricts the rule to bytecode methods with ACC_SYNTHETIC set,
+which is exactly what the Scala compiler emits for lifted lambdas.
+
+---
+
+## 8. Scala reflection in tests — case classes must be top-level
+
+When writing unit tests that call `currentMirror.reflectClass` (e.g., for
+`toProductType`-style tests), the case class **must** be declared at package scope,
+not as a nested/inner class inside the test class.
+
+```scala
+// WRONG: inner class, reflection fails at runtime
+class MyUnitTests extends AnyFunSuite {
+  case class MyRecord(id: Int, name: String)
+  test("...") { ... currentMirror.reflectClass(mirror) ... } // NoHostException
+}
+
+// RIGHT: top-level, reflection works
+case class MyRecord(id: Int, name: String)
+class MyUnitTests extends AnyFunSuite {
+  test("...") { ... currentMirror.reflectClass(mirror) ... } // OK
+}
+```
+
+---
+
+## 9. Rule file version header
+
+The first non-comment line must be `[jmf:1.0.0]` (or the appropriate version).
+Missing or malformed version headers cause the entire rule file to be skipped silently.
+Confirm the file is loaded by checking the sbt jacoco log for `Loaded N rules`.
+
+---
+
+## 10. Misleading or incorrect hints in the official JMF tutorial
+
+The bundled HowTo comment block (`jmf-rules.txt` header) contains several claims that are
+inconsistent, misleading, or contradicted by tested behaviour. Do not copy examples from it
+without checking below.
+
+### 10a. Colon-prefix flag syntax in Quick Examples is wrong
+
+The Quick Examples section writes:
+```
+*#*(*):synthetic            # any synthetic
+*#*(*):bridge               # any bridge
+```
+The colon before `synthetic`/`bridge` does **not** match the FLAGS syntax described just
+above it, which says "space or comma separated". Our confirmed working syntax is:
+```
+*#*  synthetic  id:some-label
+*#$anonfun$*(*)  synthetic  name-contains:$anonfun$  id:scala-anonfun
+```
+The colon-prefix format may be silently ignored (rule loads but never matches), which is
+the same failure mode as wrong descriptors. Do not use `:<flag>` — use space-separated flags.
+
+### 10b. `ret:` predicate syntax is inconsistent within the tutorial
+
+The tutorial shows `ret:` two different ways:
+```
+# inconsistent — colon-prefixed
+*.jobs.*#*(*):ret:V
+
+# inconsistent — space-separated
+*.client.*#with*(*) ret:Lcom/api/client/*;
+```
+The space-separated form matches the PREDICATES spec. Use space-separated:
+```
+*MyClass#myMethod(*)  ret:V  id:my-label
+```
+Never use `:ret:` (double colon, colon-prefixed).
+
+### 10c. Tutorial does not warn about the FQCN `*` prefix requirement
+
+All Quick Examples use fully-anchored package globs like `*.model.*#copy(*)`, which
+implicitly start with `*`. The tutorial never states that a bare class name
+(`QueryResult#noMore()`) will NOT match a fully-qualified name
+(`za.co.absa.db.balta.classes.QueryResult`).
+
+This silence has caused real bugs: rules written as `ClassName#method()` compile and load,
+appear in the "N rules loaded" count, but never filter anything.
+
+**Always prefix project-specific class names with `*`:**
+```
+# WRONG — silently never matches
+QueryResult#noMore()  id:qr-nomore
+
+# RIGHT
+*QueryResult#noMore()  id:qr-nomore
+```
+
+### 10d. Tutorial descriptor examples do not demonstrate JVM-format requirement
+
+The ALLOWED SYNTAX section correctly shows JVM format (`(I)I`, `(Ljava/lang/String;)V`)
+but the Quick Examples section uses only `(*)` everywhere, giving the impression that
+type-specific descriptors are rarely needed. In practice:
+
+- Any rule targeting a method that takes `int`, `boolean`, or any object type by specific
+  type **must** use JVM format.
+- Writing `(int)`, `(boolean)`, `(java.lang.String)` will silently not match.
+- The tutorial provides no warning that human-readable types produce silent failures.
+
+See section 1 of this file for the correct mapping table.
+
+### 10e. Tutorial claims empty/short descriptor forms are equivalent — verify before trusting
+
+The tutorial states: `"(*)" normalizes to "(*)*" ⇒ any args, any return.`
+This is consistent with our tested experience for wildcard rules. However, when mixing
+`(*)` with typed descriptors in the same class, `(*)` may match more broadly than intended.
+Prefer an explicit descriptor when targeting a specific overload.
+
+### 10f. Empty parens `()` reads as "no args" but means "any args" due to normalisation
+
+The tutorial global rule examples include:
+```
+*#productElement()
+*#productArity()
+*#productIterator()
+```
+A reader naturally interprets `()` as "this method takes no arguments". But `productElement`
+has the signature `def productElement(n: Int): Any` — its JVM descriptor is `(I)Ljava/lang/Object;`.
+The rule still works because `()` normalises to `(*)*` (any args, any return).
+
+**Consequence:** These rules match more than you think. A rule written as `*#myMethod()` to
+target a specific no-arg overload will also match every overload of `myMethod`, including
+ones you may want to test. Use an explicit descriptor when targeting a single overload:
+```
+*#mySpecificMethod()V          # actually no-arg, returns void
+*#myOverloadedMethod(I)*       # specifically the int overload
+```
+
+### 10g. Tutorial's own Quick Example comments use human-readable types
+
+The formal ALLOWED SYNTAX section correctly shows JVM format, but the very next section's
+inline explanatory comments contradict it:
+```
+*.model.*#productElement(*)
+    → Matches `productElement(int)` (or any descriptor form) on case classes.
+                            ^^^^ human-readable — not valid if used in a rule
+```
+The parenthetical "(or any descriptor form)" hints at the issue but does not explain it.
+Any reader who copies the comment text into a rule will get a silently non-matching rule.
+
+### 10h. `ret:` object type globs — semicolon inconsistency
+
+The tutorial shows `ret:` for object types with and without a trailing `;`:
+```
+*.client.*#with*(*) ret:Lcom/api/client/*;       # has semicolon
+*.model.*#*(*):ret:Lcom/example/model/*          # missing semicolon
+```
+JVM object type descriptors always end with `;` (e.g., `Ljava/lang/String;`). The form
+without `;` may silently fail to match for the same reason a wrong descriptor does.
+Always include the trailing semicolon for object return type globs:
+```
+*MyClass#myMethod(*)  ret:Lcom/example/model/*;  id:my-label
+```
+
+### 10i. `id:` listed under PREDICATES implies it is optional — it is not
+
+The tutorial lists `id:<string>` in the PREDICATES section alongside `ret:`, `name-contains:`,
+etc., with the description "identifier shown in logs/reports". Nothing in the tutorial says
+it is required.
+
+In practice, omitting `id:` makes log output unreadable when rules fire — you see only the
+method descriptor with no human-readable label. Treat `id:` as mandatory on every rule.
+This project's instructions reflect this: "Every rule Must include an `id:` label for
+traceability."
+
+### 10j. `#` is both the comment marker and the FQCN/method separator — inline comments are ambiguous
+
+The tutorial states "Comments (# …) and blank lines are ignored" but never clarifies that
+`#` in the middle of a rule is the FQCN/method separator, not a comment.
+
+This creates an ambiguity for inline trailing comments:
+```
+*$#<init>(*)  id:gen-ctor # constructors
+```
+Is `# constructors` an inline comment that JMF drops, or does it confuse the parser?
+In our tested rules it appears to be harmless, but the tutorial is completely silent on
+this. To be safe, keep `#`-style inline comments only on dedicated comment lines.
+Use the `id:` label as the sole annotation on rule lines:
+```
+# constructors
+*$#<init>(*)  id:gen-ctor
+```
+
+### 10k. CONSERVATIVE / STANDARD / AGGRESSIVE labels mentioned in intro but never applied to examples
+
+The Quick Start says:
+> "2) Start with the CONSERVATIVE section only. 3) If clean, enable STANDARD. Use AGGRESSIVE
+> only inside DTO/auto-generated packages."
+
+But the rule examples that follow are not labelled CONSERVATIVE, STANDARD, or AGGRESSIVE.
+There is no way to know which category `*.model.*#copy(*)` or `*#$anonfun$*` belongs to
+without guessing. In our project we use the section header comments to mark intent instead:
+`# GLOBALS RULES`, `# PROJECT RULES`.
+
+### 10l. "Always use dot-form" note contradicts necessary `$` usage
+
+The "Notes" section says:
+> "Always use dot-form (com.example.Foo) for class names."
+
+But inner classes and companion objects require `$`, not `.`:
+- `com.example.Foo$Bar` — inner class `Bar` of `Foo`
+- `com.example.Foo$` — companion object of `Foo`
+
+Both are used throughout the tutorial's own examples (`*.model.*$*#apply(*)`). The "dot-form"
+note means "use `.` as the package separator" (not `/`), not "never use `$`". The note needs
+the clarification: `$` is the required inner-class/companion separator and must be used as-is.
+
+### 10m. Universal wildcard `*#*(*)` missing warning about falsely inflated coverage
+
+The tutorial says:
+> "`*#*(*)` — Match EVERY method in EVERY class. Useful only for diagnostics."
+
+It does not warn that enabling this globally will suppress JaCoCo for every method in the
+codebase, producing artificially inflated (up to 100%) coverage numbers. This rule left
+enabled in a CI pipeline would silently mask all regressions. It should carry an explicit
+**DO NOT commit** warning.
+
+### 10n. Scala var setter compiled name not explained for `_$eq` glob
+
+The tutorial shows:
+```
+*.dto.*#*_$eq(*)
+    → Matches Scala var setters in DTO packages (e.g., `name_=(...)`).
+```
+The source-level name `name_=` is compiled to `name_$eq` in bytecode. The tutorial
+uses `_$eq` as the glob suffix but never explains *why* — a reader unfamiliar with
+Scala's name mangling might try `*_=(*)` (the source form), which will never match.
+Always use the bytecode name in JMF globs, not the source name.
+
+---
+
+## 12. Real bugs found in this project's own jmf-rules.txt via audit
+
+These were discovered by running the same JVM-descriptor audit described in section 1
+and cross-referencing against the knowledge in section 10d. Both rules silently failed
+to match and were only "covered" because integration tests happened to exercise the
+same methods. **Fixed in jmf-rules.txt.**
+
+| Rule (before fix) | Problem | Fix |
+|---|---|---|
+| `*DBFunction#execute(scala.Function1)` | Human-readable class name | `(Lscala/Function1;)*` |
+| `*NamingConvention#fromClassNamePerConvention(java.lang.Object)` | Human-readable class name | `(Ljava/lang/Object;)*` |
+
+Audit command used to find these:
+```bash
+grep -n '[a-z]\.[A-Z]' jmf-rules.txt | grep -v '^#'
+```
+This finds lines where a lower-case package segment is followed by an upper-case class
+name in descriptor position — a strong indicator of human-readable format.
+
+---
+
+## 13. Scala source name vs bytecode name — glob always targets bytecode
+
+JMF operates on bytecodes, so any glob must use the compiled method name, not the source
+name. Common Scala name-mangling patterns:
+
+| Source name | Bytecode name |
+|---|---|
+| `name_=` (var setter) | `name_$eq` |
+| `a_+_b` (operator) | `a_$plus_b` |
+| `?` | `$qmark` |
+| `!` | `$bang` |
+| `++` | `$plus$plus` |
+| `::` | `$colon$colon` |
+| Inner class `Foo.Bar` | `Foo$Bar` |
+| Companion object `Foo` | `Foo$` |
+| Lambda lifted from `foo` | `$anonfun$foo$1` |
+
+Use `javap -p classfile` to confirm the exact bytecode name before writing a glob.
+
+---
+
+
+## 11. Quick reference — JMF rule anatomy
+
+```
+<FQCN_glob>#<method_glob>(<descriptor_glob>)  [FLAGS]  [PREDICATES]  id:<label>
+```
+
+- `FQCN_glob`: `*MyClass`, `*.model.*`, `com.example.*`; `$` for inner/companion.
+- `method_glob`: `copy`, `get*`, `$anonfun$*`, `*_$eq`.
+- `descriptor_glob`: JVM bytes, e.g., `(I)*`, `(Ljava/lang/String;)*`, `(*)`.
+- `FLAGS`: `public`, `protected`, `private`, `synthetic`, `bridge`, `static`, `abstract`.
+- `PREDICATES`: `ret:<glob>`, `name-contains:<s>`, `name-starts:<s>`, `name-ends:<s>`.
+- Every rule must have `id:<label>` for traceability.
diff --git a/balta/src/test/resources/database-persist.properties b/balta/src/test/resources/database-persist.properties
new file mode 100644
index 0000000..1cf8437
--- /dev/null
+++ b/balta/src/test/resources/database-persist.properties
@@ -0,0 +1,7 @@
+# jdbc settings — test fixture with persist=true
+test.jdbc.url=jdbc:postgresql://localhost:5432/mag_db
+
+test.jdbc.username=mag_owner
+test.jdbc.password=changeme
+
+test.persist.db=true
diff --git a/balta/src/test/scala/za/co/absa/db/balta/DBTestSuiteUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/DBTestSuiteUnitTests.scala
index 93f2a1e..dc917ea 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/DBTestSuiteUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/DBTestSuiteUnitTests.scala
@@ -17,8 +17,10 @@
 package za.co.absa.db.balta
 
 import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.classes.inner.ConnectionInfo
 
 class DBTestSuiteUnitTests extends AnyFunSuiteLike {
+
   test("connectionInfoFromResourceConfig reads local resource file correctly") {
     val connectionInfo = DBTestSuite.connectionInfoFromResourceConfig("/database.properties")
     assert(connectionInfo.dbUrl == "jdbc:postgresql://localhost:5432/mag_db")
@@ -26,4 +28,33 @@ class DBTestSuiteUnitTests extends AnyFunSuiteLike {
     assert(connectionInfo.password == "changeme")
     assert(!connectionInfo.persistData)
   }
+
+  test("connectionInfoFromResourceConfig reads persistData true when configured") {
+    val connectionInfo = DBTestSuite.connectionInfoFromResourceConfig("/database-persist.properties")
+    assert(connectionInfo.persistData)
+  }
+
+  test("connectionInfo with persistDataOverride=Some(true) overrides config value") {
+    val suite = new ConcreteSuite(Some(true))
+    val info = suite.exposedConnectionInfo
+    assert(info.persistData)
+  }
+
+  test("connectionInfo with persistDataOverride=Some(false) overrides config value") {
+    val suite = new ConcreteSuite(Some(false))
+    val info = suite.exposedConnectionInfo
+    assert(!info.persistData)
+  }
+
+  test("connectionInfo with persistDataOverride=None uses config value") {
+    val suite = new ConcreteSuite(None)
+    val info = suite.exposedConnectionInfo
+    assert(!info.persistData)
+  }
+
+  private class ConcreteSuite(override val persistDataOverride: Option[Boolean])
+    extends DBTestSuite(persistDataOverride) {
+    def exposedConnectionInfo: ConnectionInfo = connectionInfo
+  }
 }
+
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/DBFunctionUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/DBFunctionUnitTests.scala
new file mode 100644
index 0000000..321a17f
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/DBFunctionUnitTests.scala
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta.classes
+
+import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.classes.DBFunction.{DBFunctionWithNamedParamsToo, DBFunctionWithPositionedParamsOnly}
+
+class DBFunctionUnitTests extends AnyFunSuiteLike {
+
+  test("DBFunction.apply creates a positioned-params instance with no params") {
+    val fn = DBFunction("my_schema.my_function")
+    assert(fn.isInstanceOf[DBFunctionWithPositionedParamsOnly])
+    assert(fn.params.isEmpty)
+    assert(fn.functionName == "my_schema.my_function")
+  }
+
+  test("setParam by position auto-increments the key") {
+    val fn = DBFunction("fn")
+      .setParam(10)
+      .setParam("hello")
+      .setParam(true)
+    assert(fn.params.size == 3)
+    assert(fn.params.keys.toList == List(Left(1), Left(2), Left(3)))
+  }
+
+  test("setParam by position returns DBFunctionWithPositionedParamsOnly") {
+    val fn = DBFunction("fn").setParam(42)
+    assert(fn.isInstanceOf[DBFunctionWithPositionedParamsOnly])
+  }
+
+  test("setParam by name creates a named-params instance") {
+    val fn = DBFunction("fn").setParam("p_name", "value")
+    assert(fn.isInstanceOf[DBFunctionWithNamedParamsToo])
+    assert(fn.params.size == 1)
+    assert(fn.params.keys.head == Right("p_name"))
+  }
+
+  test("mixing positioned and named params preserves order") {
+    val fn = DBFunction("fn")
+      .setParam(1)
+      .setParam(2)
+      .setParam("named", "val")
+    assert(fn.params.size == 3)
+    assert(fn.params.keys.toList == List(Left(1), Left(2), Right("named")))
+  }
+
+  test("clear resets params to empty") {
+    val fn = DBFunction("fn").setParam(1).setParam(2).clear()
+    assert(fn.params.isEmpty)
+    assert(fn.functionName == "fn")
+  }
+
+  test("clear returns DBFunctionWithPositionedParamsOnly") {
+    val fn = DBFunction("fn").setParam("p", "v").clear()
+    assert(fn.isInstanceOf[DBFunctionWithPositionedParamsOnly])
+  }
+}
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
new file mode 100644
index 0000000..aeccfb1
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
@@ -0,0 +1,310 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta.classes
+
+import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.classes.QueryResultRow.FieldNames
+import za.co.absa.db.balta.implicits.QueryResultRowImplicits.ProductTypeConvertor
+import za.co.absa.db.mag.naming.LettersCase.AsIs
+import za.co.absa.db.mag.naming.implementations.AsIsNaming
+
+import java.sql.{ResultSetMetaData, Types}
+
+/** Case classes for toProductType tests — must be top-level for Scala reflection. */
+case class SimpleRecord(name: String, age: Int)
+case class OptionalRecord(label: String, value: Option[Int])
+
+/** Case class with auxiliary constructor — tests the multi-constructor branch in getConstructor. */
+case class MultiCtorRecord(x: Int, y: String) {
+  def this(x: Int) = this(x, "default")
+}
+
+class QueryResultRowUnitTests extends AnyFunSuiteLike {
+
+  private implicit val naming: AsIsNaming = new AsIsNaming(AsIs)
+
+  private val sampleFields: Vector[Option[Object]] = Vector(
+    Some("hello".asInstanceOf[Object]),
+    Some(java.lang.Integer.valueOf(42).asInstanceOf[Object]),
+    None,
+    Some("".asInstanceOf[Object])
+  )
+
+  private val sampleColumnLabels: FieldNames = Map(
+    "name" -> 1,
+    "age" -> 2,
+    "nullable" -> 3,
+    "empty" -> 4
+  )
+
+  private def mkRow(fields: Vector[Option[Object]] = sampleFields,
+                    labels: FieldNames = sampleColumnLabels,
+                    rowNum: Int = 1): QueryResultRow = {
+    new QueryResultRow(rowNum, fields, labels)
+  }
+
+  test("columnNumber returns correct index for existing column") {
+    val row = mkRow()
+    assert(row.columnNumber("name") == 1)
+    assert(row.columnNumber("age") == 2)
+  }
+
+  test("columnNumber is case-insensitive") {
+    val row = mkRow()
+    assert(row.columnNumber("NAME") == 1)
+    assert(row.columnNumber("Age") == 2)
+  }
+
+  test("columnNumber throws NoSuchElementException for missing column") {
+    val row = mkRow()
+    val ex = intercept[NoSuchElementException] {
+      row.columnNumber("nonexistent")
+    }
+    assert(ex.getMessage.contains("nonexistent"))
+  }
+
+  test("getChar returns first character of a non-empty string") {
+    val row = mkRow()
+    assert(row.getChar(1).contains('h'))
+  }
+
+  test("getChar returns None for empty string") {
+    val row = mkRow()
+    assert(row.getChar(4).isEmpty)
+  }
+
+  test("getChar returns None for null column") {
+    val row = mkRow()
+    assert(row.getChar(3).isEmpty)
+  }
+
+  test("getAs with transformer applies the function") {
+    val row = mkRow()
+    val result = row.getAs[Int](2, { obj: Object => obj.asInstanceOf[java.lang.Integer].intValue() })
+    assert(result.contains(42))
+  }
+
+  test("getAs with transformer returns None for null column") {
+    val row = mkRow()
+    val result = row.getAs[String](3, { obj: Object => obj.toString })
+    assert(result.isEmpty)
+  }
+
+  test("getObject returns Some for non-null column") {
+    val row = mkRow()
+    assert(row.getObject(1).isDefined)
+  }
+
+  test("getObject returns None for null column") {
+    val row = mkRow()
+    assert(row.getObject(3).isEmpty)
+  }
+
+  test("fieldNamesFromMetadata builds correct map") {
+    val metaData = new StubMetaData(
+      List(("id", Types.INTEGER, "int4"), ("name", Types.VARCHAR, "varchar"))
+    )
+    val result = QueryResultRow.fieldNamesFromMetadata(metaData)
+    assert(result == Map("id" -> 1, "name" -> 2))
+  }
+
+  test("fieldNamesFromMetadata returns empty map for zero columns") {
+    val metaData = new StubMetaData(Nil)
+    val result = QueryResultRow.fieldNamesFromMetadata(metaData)
+    assert(result.isEmpty)
+  }
+
+  test("createExtractors returns correct number of extractors") {
+    val metaData = new StubMetaData(
+      List(("a", Types.VARCHAR, "varchar"), ("b", Types.INTEGER, "int4"), ("c", Types.TIMESTAMP, "timestamp"))
+    )
+    val extractors = QueryResultRow.createExtractors(metaData)
+    assert(extractors.size == 3)
+  }
+
+  test("createExtractors dispatches timestamptz to OffsetDateTime extractor") {
+    val metaData = new StubMetaData(
+      List(("ts", Types.TIMESTAMP, "timestamptz"))
+    )
+    val extractors = QueryResultRow.createExtractors(metaData)
+    assert(extractors.size == 1)
+  }
+
+  test("createExtractors dispatches timetz to OffsetTime extractor") {
+    val metaData = new StubMetaData(
+      List(("t", Types.TIME, "timetz"))
+    )
+    val extractors = QueryResultRow.createExtractors(metaData)
+    assert(extractors.size == 1)
+  }
+
+  test("createExtractors dispatches ARRAY type") {
+    val metaData = new StubMetaData(
+      List(("arr", Types.ARRAY, "_int4"))
+    )
+    val extractors = QueryResultRow.createExtractors(metaData)
+    assert(extractors.size == 1)
+  }
+
+  test("getArray returns Vector from sql.Array column") {
+    val arr: Array[Object] = Array(
+      java.lang.Integer.valueOf(1),
+      java.lang.Integer.valueOf(2),
+      java.lang.Integer.valueOf(3)
+    )
+    val sqlArray = new StubSqlArray(arr)
+    val fields: Vector[Option[Object]] = Vector(Some(sqlArray.asInstanceOf[Object]))
+    val labels: FieldNames = Map("nums" -> 1)
+    val row = new QueryResultRow(1, fields, labels)
+    val result = row.getArray[Int](1)
+    assert(result.contains(Vector(1, 2, 3)))
+  }
+
+  test("getArray returns None for null column") {
+    val fields: Vector[Option[Object]] = Vector(None)
+    val labels: FieldNames = Map("nums" -> 1)
+    val row = new QueryResultRow(1, fields, labels)
+    val result = row.getArray[Int](1)
+    assert(result.isEmpty)
+  }
+
+  test("getArray with transformer applies itemTransformerFnc") {
+    val arr: Array[Object] = Array(
+      java.lang.Integer.valueOf(10),
+      java.lang.Integer.valueOf(20)
+    )
+    val sqlArray = new StubSqlArray(arr)
+    val fields: Vector[Option[Object]] = Vector(Some(sqlArray.asInstanceOf[Object]))
+    val labels: FieldNames = Map("nums" -> 1)
+    val row = new QueryResultRow(1, fields, labels)
+    val result = row.getArray[String](1, { obj: Object => obj.toString })
+    assert(result.contains(Vector("10", "20")))
+  }
+
+  test("getArray by column label delegates to int overload") {
+    val arr: Array[Object] = Array(java.lang.Integer.valueOf(5))
+    val sqlArray = new StubSqlArray(arr)
+    val fields: Vector[Option[Object]] = Vector(Some(sqlArray.asInstanceOf[Object]))
+    val labels: FieldNames = Map("data" -> 1)
+    val row = new QueryResultRow(1, fields, labels)
+    val result = row.getArray[Int]("data")
+    assert(result.contains(Vector(5)))
+  }
+
+  test("toProductType converts a row to a case class") {
+    val fields: Vector[Option[Object]] = Vector(
+      Some("Alice".asInstanceOf[Object]),
+      Some(java.lang.Integer.valueOf(30).asInstanceOf[Object])
+    )
+    val labels: FieldNames = Map("name" -> 1, "age" -> 2)
+    val row = new QueryResultRow(1, fields, labels)
+    val result = row.toProductType[SimpleRecord]
+    assert(result == SimpleRecord("Alice", 30))
+  }
+
+  test("toProductType handles Option field with value") {
+    val fields: Vector[Option[Object]] = Vector(
+      Some("test".asInstanceOf[Object]),
+      Some(java.lang.Integer.valueOf(42).asInstanceOf[Object])
+    )
+    val labels: FieldNames = Map("label" -> 1, "value" -> 2)
+    val row = new QueryResultRow(1, fields, labels)
+    val result = row.toProductType[OptionalRecord]
+    assert(result == OptionalRecord("test", Some(42)))
+  }
+
+  test("toProductType handles Option field with null") {
+    val fields: Vector[Option[Object]] = Vector(
+      Some("test".asInstanceOf[Object]),
+      None
+    )
+    val labels: FieldNames = Map("label" -> 1, "value" -> 2)
+    val row = new QueryResultRow(1, fields, labels)
+    val result = row.toProductType[OptionalRecord]
+    assert(result == OptionalRecord("test", None))
+  }
+
+  test("toProductType throws NullPointerException for null non-Option field") {
+    val fields: Vector[Option[Object]] = Vector(
+      None,
+      Some(java.lang.Integer.valueOf(1).asInstanceOf[Object])
+    )
+    val labels: FieldNames = Map("name" -> 1, "age" -> 2)
+    val row = new QueryResultRow(1, fields, labels)
+    val ex = intercept[NullPointerException] {
+      row.toProductType[SimpleRecord]
+    }
+    assert(ex.getMessage.contains("name"))
+  }
+
+  test("toProductType works with case class having auxiliary constructor") {
+    val fields: Vector[Option[Object]] = Vector(
+      Some(java.lang.Integer.valueOf(99).asInstanceOf[Object]),
+      Some("alt".asInstanceOf[Object])
+    )
+    val labels: FieldNames = Map("x" -> 1, "y" -> 2)
+    val row = new QueryResultRow(1, fields, labels)
+    val result = row.toProductType[MultiCtorRecord]
+    assert(result == MultiCtorRecord(99, "alt"))
+  }
+
+  /**
+   * Stub ResultSetMetaData for unit testing.
+   */
+  private class StubMetaData(columns: List[(String, Int, String)]) extends ResultSetMetaData {
+    override def getColumnCount: Int = columns.size
+    override def getColumnName(column: Int): String = columns(column - 1)._1
+    override def getColumnType(column: Int): Int = columns(column - 1)._2
+    override def getColumnTypeName(column: Int): String = columns(column - 1)._3
+    override def getColumnLabel(column: Int): String = getColumnName(column)
+    override def isAutoIncrement(column: Int): Boolean = false
+    override def isCaseSensitive(column: Int): Boolean = false
+    override def isSearchable(column: Int): Boolean = false
+    override def isCurrency(column: Int): Boolean = false
+    override def isNullable(column: Int): Int = ResultSetMetaData.columnNullable
+    override def isSigned(column: Int): Boolean = false
+    override def getColumnDisplaySize(column: Int): Int = 0
+    override def getSchemaName(column: Int): String = ""
+    override def getPrecision(column: Int): Int = 0
+    override def getScale(column: Int): Int = 0
+    override def getTableName(column: Int): String = ""
+    override def getCatalogName(column: Int): String = ""
+    override def isReadOnly(column: Int): Boolean = false
+    override def isWritable(column: Int): Boolean = false
+    override def isDefinitelyWritable(column: Int): Boolean = false
+    override def getColumnClassName(column: Int): String = "java.lang.Object"
+    override def unwrap[T](iface: Class[T]): T = throw new UnsupportedOperationException
+    override def isWrapperFor(iface: Class[_]): Boolean = false
+  }
+
+  /**
+   * Stub java.sql.Array for unit testing getArray methods.
+   */
+  private class StubSqlArray(data: Array[Object]) extends java.sql.Array {
+    override def getBaseTypeName: String = "int4"
+    override def getBaseType: Int = Types.INTEGER
+    override def getArray: AnyRef = data
+    override def getArray(map: java.util.Map[String, Class[_]]): AnyRef = data
+    override def getArray(index: Long, count: Int): AnyRef = data
+    override def getArray(index: Long, count: Int, map: java.util.Map[String, Class[_]]): AnyRef = data
+    override def getResultSet: java.sql.ResultSet = throw new UnsupportedOperationException
+    override def getResultSet(map: java.util.Map[String, Class[_]]): java.sql.ResultSet = throw new UnsupportedOperationException
+    override def getResultSet(index: Long, count: Int): java.sql.ResultSet = throw new UnsupportedOperationException
+    override def getResultSet(index: Long, count: Int, map: java.util.Map[String, Class[_]]): java.sql.ResultSet = throw new UnsupportedOperationException
+    override def free(): Unit = ()
+  }
+}
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
new file mode 100644
index 0000000..14da1f7
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta.classes.inner
+
+import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.typeclasses.QueryParamType
+
+class ParamsUnitTests extends AnyFunSuiteLike {
+
+  test("NamedParams add creates a single-entry list with correct key") {
+    val params = Params.add("name", "Alice")
+    assert(params.size == 1)
+    assert(params.keys.contains(List("name")))
+  }
+
+  test("NamedParams add preserves insertion order across multiple adds") {
+    val params = Params.add("a", 1).add("b", 2).add("c", 3)
+    assert(params.size == 3)
+    assert(params.keys.contains(List("a", "b", "c")))
+  }
+
+  test("NamedParams values returns parameter values in insertion order") {
+    val params = Params.add("x", 10).add("y", 20)
+    val values = params.values
+    assert(values.size == 2)
+    assert(values.head.sqlEntry == "?")
+    assert(values(1).sqlEntry == "?")
+  }
+
+  test("NamedParams addNull creates a NULL parameter") {
+    val params = Params.addNull("missing")
+    assert(params.size == 1)
+    assert(params("missing").sqlEntry == "NULL")
+    assert(params("missing").equalityOperator == "IS")
+  }
+
+  test("NamedParams pairs returns key-value list") {
+    val params = Params.add("k1", "v1").add("k2", "v2")
+    val pairs = params.pairs
+    assert(pairs.size == 2)
+    assert(pairs.head._1 == "k1")
+    assert(pairs(1)._1 == "k2")
+  }
+
+  test("NamedParams apply retrieves value by parameter name") {
+    val params = Params.add("id", 42)
+    val value = params("id")
+    assert(value.sqlEntry == "?")
+  }
+
+  test("NamedParams apply throws NoSuchElementException for missing key") {
+    val params = Params.add("id", 42)
+    assertThrows[NoSuchElementException] {
+      params("nonexistent")
+    }
+  }
+
+  test("OrderedParams add creates a single-entry list") {
+    val params = Params.add(100)
+    assert(params.size == 1)
+    assert(params.keys.isEmpty)
+  }
+
+  test("OrderedParams add preserves order across multiple adds") {
+    val params = Params.add(1).add(2).add(3)
+    assert(params.size == 3)
+    assert(params.values.size == 3)
+  }
+
+  test("OrderedParams addNull creates a NULL parameter") {
+    val params = Params.addNull[QueryParamType.NULL.type]()
+    assert(params.size == 1)
+    assert(params.values.head.sqlEntry == "NULL")
+  }
+
+  test("OrderedParams keys returns None") {
+    val params = Params.add("hello")
+    assert(params.keys.isEmpty)
+  }
+}
diff --git a/balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala b/balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
new file mode 100644
index 0000000..a43eaa6
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta
+
+import java.io.{InputStream, Reader}
+import java.net.URL
+import java.sql._
+import java.util.Calendar
+
+/**
+ * Minimal PreparedStatement stub that records the last setter call.
+ * Used by unit tests that verify QueryParamType / QueryParamValue binding without a real DB.
+ */
+class RecordingPreparedStatement extends PreparedStatement {
+  var lastCall: (String, Any, Any) = _
+
+  override def setBoolean(parameterIndex: Int, x: Boolean): Unit      = { lastCall = ("setBoolean", parameterIndex, x) }
+  override def setInt(parameterIndex: Int, x: Int): Unit              = { lastCall = ("setInt", parameterIndex, x) }
+  override def setLong(parameterIndex: Int, x: Long): Unit            = { lastCall = ("setLong", parameterIndex, x) }
+  override def setString(parameterIndex: Int, x: String): Unit        = { lastCall = ("setString", parameterIndex, x) }
+  override def setDouble(parameterIndex: Int, x: Double): Unit        = { lastCall = ("setDouble", parameterIndex, x) }
+  override def setFloat(parameterIndex: Int, x: Float): Unit          = { lastCall = ("setFloat", parameterIndex, x) }
+  override def setBigDecimal(parameterIndex: Int, x: java.math.BigDecimal): Unit = { lastCall = ("setBigDecimal", parameterIndex, x) }
+  override def setDate(parameterIndex: Int, x: Date): Unit            = { lastCall = ("setDate", parameterIndex, x) }
+  override def setTime(parameterIndex: Int, x: Time): Unit            = { lastCall = ("setTime", parameterIndex, x) }
+  override def setObject(parameterIndex: Int, x: AnyRef): Unit        = { lastCall = ("setObject", parameterIndex, x) }
+
+  // Remaining PreparedStatement methods — no-op stubs
+  override def executeQuery(): ResultSet = null
+  override def executeUpdate(): Int = 0
+  override def setNull(parameterIndex: Int, sqlType: Int): Unit = ()
+  override def setByte(parameterIndex: Int, x: Byte): Unit = ()
+  override def setShort(parameterIndex: Int, x: Short): Unit = ()
+  override def setBytes(parameterIndex: Int, x: scala.Array[Byte]): Unit = ()
+  override def setTimestamp(parameterIndex: Int, x: Timestamp): Unit = ()
+  override def setAsciiStream(parameterIndex: Int, x: InputStream, length: Int): Unit = ()
+  override def setUnicodeStream(parameterIndex: Int, x: InputStream, length: Int): Unit = ()
+  override def setBinaryStream(parameterIndex: Int, x: InputStream, length: Int): Unit = ()
+  override def clearParameters(): Unit = ()
+  override def setObject(parameterIndex: Int, x: AnyRef, targetSqlType: Int): Unit = ()
+  override def execute(): Boolean = false
+  override def addBatch(): Unit = ()
+  override def setCharacterStream(parameterIndex: Int, reader: Reader, length: Int): Unit = ()
+  override def setRef(parameterIndex: Int, x: Ref): Unit = ()
+  override def setBlob(parameterIndex: Int, x: Blob): Unit = ()
+  override def setClob(parameterIndex: Int, x: Clob): Unit = ()
+  override def setArray(parameterIndex: Int, x: java.sql.Array): Unit = ()
+  override def getMetaData: ResultSetMetaData = null
+  override def setDate(parameterIndex: Int, x: Date, cal: Calendar): Unit = ()
+  override def setTime(parameterIndex: Int, x: Time, cal: Calendar): Unit = ()
+  override def setTimestamp(parameterIndex: Int, x: Timestamp, cal: Calendar): Unit = ()
+  override def setNull(parameterIndex: Int, sqlType: Int, typeName: String): Unit = ()
+  override def setURL(parameterIndex: Int, x: URL): Unit = ()
+  override def getParameterMetaData: ParameterMetaData = null
+  override def setRowId(parameterIndex: Int, x: RowId): Unit = ()
+  override def setNString(parameterIndex: Int, value: String): Unit = ()
+  override def setNCharacterStream(parameterIndex: Int, value: Reader, length: Long): Unit = ()
+  override def setNClob(parameterIndex: Int, value: NClob): Unit = ()
+  override def setClob(parameterIndex: Int, reader: Reader, length: Long): Unit = ()
+  override def setBlob(parameterIndex: Int, inputStream: InputStream, length: Long): Unit = ()
+  override def setNClob(parameterIndex: Int, reader: Reader, length: Long): Unit = ()
+  override def setSQLXML(parameterIndex: Int, xmlObject: SQLXML): Unit = ()
+  override def setObject(parameterIndex: Int, x: AnyRef, targetSqlType: Int, scaleOrLength: Int): Unit = ()
+  override def setAsciiStream(parameterIndex: Int, x: InputStream, length: Long): Unit = ()
+  override def setBinaryStream(parameterIndex: Int, x: InputStream, length: Long): Unit = ()
+  override def setCharacterStream(parameterIndex: Int, reader: Reader, length: Long): Unit = ()
+  override def setAsciiStream(parameterIndex: Int, x: InputStream): Unit = ()
+  override def setBinaryStream(parameterIndex: Int, x: InputStream): Unit = ()
+  override def setCharacterStream(parameterIndex: Int, reader: Reader): Unit = ()
+  override def setNCharacterStream(parameterIndex: Int, value: Reader): Unit = ()
+  override def setClob(parameterIndex: Int, reader: Reader): Unit = ()
+  override def setBlob(parameterIndex: Int, inputStream: InputStream): Unit = ()
+  override def setNClob(parameterIndex: Int, reader: Reader): Unit = ()
+
+  // Statement methods
+  override def executeQuery(sql: String): ResultSet = null
+  override def executeUpdate(sql: String): Int = 0
+  override def close(): Unit = ()
+  override def getMaxFieldSize: Int = 0
+  override def setMaxFieldSize(max: Int): Unit = ()
+  override def getMaxRows: Int = 0
+  override def setMaxRows(max: Int): Unit = ()
+  override def setEscapeProcessing(enable: Boolean): Unit = ()
+  override def getQueryTimeout: Int = 0
+  override def setQueryTimeout(seconds: Int): Unit = ()
+  override def cancel(): Unit = ()
+  override def getWarnings: SQLWarning = null
+  override def clearWarnings(): Unit = ()
+  override def setCursorName(name: String): Unit = ()
+  override def execute(sql: String): Boolean = false
+  override def getResultSet: ResultSet = null
+  override def getUpdateCount: Int = 0
+  override def getMoreResults: Boolean = false
+  override def setFetchDirection(direction: Int): Unit = ()
+  override def getFetchDirection: Int = 0
+  override def setFetchSize(rows: Int): Unit = ()
+  override def getFetchSize: Int = 0
+  override def getResultSetConcurrency: Int = 0
+  override def getResultSetType: Int = 0
+  override def addBatch(sql: String): Unit = ()
+  override def clearBatch(): Unit = ()
+  override def executeBatch(): scala.Array[Int] = scala.Array.empty
+  override def getConnection: Connection = null
+  override def getMoreResults(current: Int): Boolean = false
+  override def getGeneratedKeys: ResultSet = null
+  override def executeUpdate(sql: String, autoGeneratedKeys: Int): Int = 0
+  override def executeUpdate(sql: String, columnIndexes: scala.Array[Int]): Int = 0
+  override def executeUpdate(sql: String, columnNames: scala.Array[String]): Int = 0
+  override def execute(sql: String, autoGeneratedKeys: Int): Boolean = false
+  override def execute(sql: String, columnIndexes: scala.Array[Int]): Boolean = false
+  override def execute(sql: String, columnNames: scala.Array[String]): Boolean = false
+  override def getResultSetHoldability: Int = 0
+  override def isClosed: Boolean = false
+  override def setPoolable(poolable: Boolean): Unit = ()
+  override def isPoolable: Boolean = false
+  override def closeOnCompletion(): Unit = ()
+  override def isCloseOnCompletion: Boolean = false
+  override def unwrap[T](iface: Class[T]): T = throw new UnsupportedOperationException
+  override def isWrapperFor(iface: Class[_]): Boolean = false
+}
diff --git a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
new file mode 100644
index 0000000..aad283e
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta.typeclasses
+
+import java.time.{Instant, LocalDate, LocalTime, OffsetDateTime, ZoneOffset}
+import java.util.UUID
+
+import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.RecordingPreparedStatement
+
+class QueryParamTypeUnitTests extends AnyFunSuiteLike {
+
+  test("QueryParamBoolean sets boolean on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val qpv = QueryParamType.QueryParamBoolean.toQueryParamValue(true)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setBoolean", 1, true))
+  }
+
+  test("QueryParamInt sets int on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val qpv = QueryParamType.QueryParamInt.toQueryParamValue(42)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setInt", 1, 42))
+  }
+
+  test("QueryParamLong sets long on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val qpv = QueryParamType.QueryParamLong.toQueryParamValue(123L)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setLong", 1, 123L))
+  }
+
+  test("QueryParamString sets string on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val qpv = QueryParamType.QueryParamString.toQueryParamValue("hello")
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setString", 1, "hello"))
+  }
+
+  test("QueryParamDouble sets double on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val qpv = QueryParamType.QueryParamDouble.toQueryParamValue(3.14)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setDouble", 1, 3.14))
+  }
+
+  test("QueryParamFloat sets float on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val qpv = QueryParamType.QueryParamFloat.toQueryParamValue(2.5f)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setFloat", 1, 2.5f))
+  }
+
+  test("QueryParamBigDecimal sets BigDecimal on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val bd = BigDecimal("99.99")
+    val qpv = QueryParamType.QueryParamBigDecimal.toQueryParamValue(bd)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setBigDecimal", 1, bd.bigDecimal))
+  }
+
+  test("QueryParamChar sets string representation on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val qpv = QueryParamType.QueryParamChar.toQueryParamValue('A')
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setString", 1, "A"))
+  }
+
+  test("QueryParamInstant sets OffsetDateTime via setObject") {
+    val ps = new RecordingPreparedStatement
+    val instant = Instant.parse("2024-01-15T10:30:00Z")
+    val qpv = QueryParamType.QueryParamInstant.toQueryParamValue(instant)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setObject", 1, OffsetDateTime.ofInstant(instant, ZoneOffset.UTC)))
+  }
+
+  test("QueryParamOffsetDateTime sets object on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val odt = OffsetDateTime.of(2024, 1, 15, 10, 30, 0, 0, ZoneOffset.UTC)
+    val qpv = QueryParamType.QueryParamOffsetDateTime.toQueryParamValue(odt)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setObject", 1, odt))
+  }
+
+  test("QueryParamLocalTime sets Time on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val lt = LocalTime.of(14, 30, 0)
+    val qpv = QueryParamType.QueryParamLocalTime.toQueryParamValue(lt)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setTime", 1, java.sql.Time.valueOf(lt)))
+  }
+
+  test("QueryParamLocalDate sets Date on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val ld = LocalDate.of(2024, 6, 15)
+    val qpv = QueryParamType.QueryParamLocalDate.toQueryParamValue(ld)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setDate", 1, java.sql.Date.valueOf(ld)))
+  }
+
+  test("QueryParamUUID sets object on PreparedStatement") {
+    val ps = new RecordingPreparedStatement
+    val uuid = UUID.fromString("550e8400-e29b-41d4-a716-446655440000")
+    val qpv = QueryParamType.QueryParamUUID.toQueryParamValue(uuid)
+    qpv.assign.get(ps, 1)
+    assert(ps.lastCall == ("setObject", 1, uuid))
+  }
+
+  test("QueryParamNull returns NullParamValue with no assign function") {
+    val qpv = QueryParamType.QueryParamNull.toQueryParamValue(QueryParamType.NULL)
+    assert(qpv.assign.isEmpty)
+    assert(qpv.sqlEntry == "NULL")
+    assert(qpv.equalityOperator == "IS")
+  }
+
+}
diff --git a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala
new file mode 100644
index 0000000..d0c94e6
--- /dev/null
+++ b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2023 ABSA Group Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package za.co.absa.db.balta.typeclasses
+
+import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.RecordingPreparedStatement
+import za.co.absa.db.balta.typeclasses.QueryParamValue._
+
+class QueryParamValueUnitTests extends AnyFunSuiteLike {
+
+  test("ObjectQueryParamValue.assign calls setObject with the wrapped object") {
+    val obj = java.lang.Integer.valueOf(42)
+    val qpv = new ObjectQueryParamValue(obj)
+    assert(qpv.assign.isDefined)
+    val ps = new RecordingPreparedStatement
+    qpv.assign.get(ps, 3)
+    assert(ps.lastCall == ("setObject", 3, obj))
+  }
+
+  test("ObjectQueryParamValue uses default sqlEntry and equalityOperator") {
+    val qpv = new ObjectQueryParamValue("test")
+    assert(qpv.sqlEntry == "?")
+    assert(qpv.equalityOperator == "=")
+  }
+
+  test("SimpleQueryParamValue.assign invokes the provided function") {
+    var called = false
+    val qpv = new SimpleQueryParamValue((ps, pos) => { called = true })
+    assert(qpv.assign.isDefined)
+    val ps = new RecordingPreparedStatement
+    qpv.assign.get(ps, 1)
+    assert(called)
+  }
+
+  test("SimpleQueryParamValue uses default sqlEntry and equalityOperator") {
+    val qpv = new SimpleQueryParamValue((_, _) => ())
+    assert(qpv.sqlEntry == "?")
+    assert(qpv.equalityOperator == "=")
+  }
+
+  test("NullParamValue.assign is None") {
+    assert(NullParamValue.assign.isEmpty)
+  }
+
+  test("NullParamValue.sqlEntry is NULL") {
+    assert(NullParamValue.sqlEntry == "NULL")
+  }
+
+  test("NullParamValue.equalityOperator is IS") {
+    assert(NullParamValue.equalityOperator == "IS")
+  }
+
+}
diff --git a/balta/src/test/scala/za/co/absa/db/mag/naming/implementations/SnakeCaseNamingUnitTests.scala b/balta/src/test/scala/za/co/absa/db/mag/naming/implementations/SnakeCaseNamingUnitTests.scala
index fdd555d..939021a 100644
--- a/balta/src/test/scala/za/co/absa/db/mag/naming/implementations/SnakeCaseNamingUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/mag/naming/implementations/SnakeCaseNamingUnitTests.scala
@@ -29,6 +29,14 @@ class SnakeCaseNamingUnitTests extends AnyWordSpec with Matchers {
       val nm = new SnakeCaseNaming(AsIs)
       nm.stringPerConvention("") should be("")
     }
+    "handle string starting with uppercase" in {
+      val nm = new SnakeCaseNaming(AsIs)
+      nm.stringPerConvention("Name") should be("Name")
+    }
+    "handle single lowercase word" in {
+      val nm = new SnakeCaseNaming(LowerCase)
+      nm.stringPerConvention("hello") should be("hello")
+    }
   }
 
   "fromClassNamePerConvention" should {
@@ -49,5 +57,10 @@ class SnakeCaseNamingUnitTests extends AnyWordSpec with Matchers {
         result should be("THIS_IS_A_TEST_CLASS")
       }
     }
+    "strip trailing $ from companion object class names" in {
+      val nm = new SnakeCaseNaming(LowerCase)
+      val result = nm.fromClassNamePerConvention(SnakeCaseNaming)
+      result should include("snake")
+    }
   }
 }
diff --git a/jmf-rules.txt b/jmf-rules.txt
index d5323fb..966a033 100644
--- a/jmf-rules.txt
+++ b/jmf-rules.txt
@@ -11,7 +11,7 @@
 *#unapply(*)                                            id:case-unapply
 *#hashCode(*)                                           id:case-hashcode
 *#copy(*)                                               id:case-copy
-*#copy$default$*(*)                                     id:case-copy-defaults
+#*#copy$default$*(*)                                     id:case-copy-defaults  — subsumed by gen-defaults
 *#productElement()                                      id:case-prod-element
 *#productArity()                                        id:case-prod-arity
 *#productPrefix()                                       id:case-prod-prefix
@@ -40,6 +40,28 @@
 # lambda
 *#*  synthetic name-contains:$anonfun$                  id:scala-anonfun
 
+# lambda serialization helper — compiler-generated, no project logic
+*#$deserializeLambda$(*)                                id:scala-deser-lambda
+
+# value class companion extension bridges — compiler-generated identity operations
+*#hashCode$extension(*)                                 id:valclass-hashcode-ext
+*#equals$extension(*)                                   id:valclass-equals-ext
+*#toString$extension(*)                                 id:valclass-tostring-ext
+*#canEqual$extension(*)                                 id:valclass-canequal-ext
+*#productIterator$extension(*)                          id:valclass-proditer-ext
+*#productElement$extension(*)                           id:valclass-prodelem-ext
+*#productArity$extension(*)                             id:valclass-prodarity-ext
+*#productPrefix$extension(*)                            id:valclass-prodprefix-ext
+*#copy$extension(*)                                     id:valclass-copy-ext
+*#copy$default$*$extension(*)                           id:valclass-copydef-ext
+
+# Function1 trait mixin delegates — single-call forwarders
+*#andThen(*)                                            id:fn1-andthen
+*#compose(*)                                            id:fn1-compose
+
+# Default parameter accessors — compiler-generated constant-returning methods
+*#*$default$*(*)                                        id:gen-defaults
+
 # PROJECT RULES
 
 # proposal to new globals
@@ -51,32 +73,307 @@
 # A unit test would only re-test the replacement method; no assurance is added.
 # Note: Params$ companion factory addNull methods are NOT filtered — they contain logic.
 *#setParamNull(*)                                       id:balta-deprecated-setnull
-Params$NamedParams#addNull(*)                           id:balta-deprecated-addnull-named
-Params$OrderedParams#addNull(*)                         id:balta-deprecated-addnull-ordered
-DBTestSuite#addNull(*)                                  id:balta-deprecated-addnull-suite
+*Params$NamedParams#addNull(*)                           id:balta-deprecated-addnull-named
+*Params$OrderedParams#addNull(*)                         id:balta-deprecated-addnull-ordered
+*DBTestSuite#addNull(*)                                  id:balta-deprecated-addnull-suite
 
 # One-liner factory wrappers in DBTestSuite
 # Each method is a single constructor call delegating to DBTable / DBFunction with no logic of its own.
-DBTestSuite#table(*)                                    id:balta-factory-table
-DBTestSuite#function(*)                                 id:balta-factory-function
+*DBTestSuite#table(*)                                    id:balta-factory-table
+*DBTestSuite#function(*)                                 id:balta-factory-function
 
 # Trivial implicit conversion: DBConnection → JDBC Connection
 # Entire body returns in.connection; no branching or transformation; a test would only assert identity.
-DBConnection$#dbConnectionToJdbcConnection(*)           id:balta-implicit-dbconn
+*DBConnection$#dbConnectionToJdbcConnection(*)           id:balta-implicit-dbconn
 
 # columnLabel: String overloads in QueryResultRow — pure label-resolution delegates
 # Each overload resolves the column label to an index via columnNumber(label) then forwards to the
 # Int-based overload. The Int-based overloads hold the extraction logic and are covered by integration tests.
 # apply(String) and the 2-param getAs(String, transformer) follow the same delegation pattern.
-QueryResultRow#get*(java.lang.String)                   id:balta-colname-getter
-QueryResultRow#getAs(java.lang.String,*)                id:balta-colname-getas-transformer
-QueryResultRow#apply(java.lang.String)                  id:balta-colname-apply
+# NOTE: JMF descriptors must use JVM format — (Ljava/lang/String;)* not (java.lang.String).
+*QueryResultRow#get*(Ljava/lang/String;)*                id:balta-colname-getter
+*QueryResultRow#getAs(Ljava/lang/String;Lscala/Function1;)* id:balta-colname-getas-transformer
+*QueryResultRow#apply(Ljava/lang/String;)*               id:balta-colname-apply
 
 # QueryResult#noMore — trivial negation of hasNext
 # Body is exactly `!hasNext`; testing it adds no assurance beyond the hasNext unit tests.
-QueryResult#noMore()                                    id:balta-nomore
+*QueryResult#noMore()                                    id:balta-nomore
 
 # QueryResult#resultSetMetaData — implicit field accessor (public val)
 # Scala compiles a public val to a 0-arg getter that returns the backing field.
 # No logic; a test would only assert identity of what was passed to the constructor.
-QueryResult#resultSetMetaData()                         id:balta-resultsetmetadata-accessor
+*QueryResult#resultSetMetaData()                         id:balta-resultsetmetadata-accessor
+
+# QueryResult#columnCount — public val backed by metaData.getColumnCount
+# Scala val getter; no logic.
+*QueryResult#columnCount()                               id:balta-columncount-accessor
+
+# QueryResultRow field accessors and single-call getters
+*QueryResultRow#rowNumber()                              id:balta-row-rownumber
+*QueryResultRow#columnCount()                            id:balta-row-columncount
+# NOTE: JMF descriptors must use JVM format.  (I)* matches single-int-param overloads.
+*QueryResultRow#apply(I)*                                id:balta-row-apply-int
+*QueryResultRow#getObject(I)*                            id:balta-row-getobject-int
+*QueryResultRow#getObject(Ljava/lang/String;)*           id:balta-row-getobject-str
+*QueryResultRow#getAs(I)*                                id:balta-row-getas-int
+*QueryResultRow#getBoolean(I)*                           id:balta-row-getboolean-int
+*QueryResultRow#getString(I)*                            id:balta-row-getstring-int
+*QueryResultRow#getInt(I)*                               id:balta-row-getint-int
+*QueryResultRow#getLong(I)*                              id:balta-row-getlong-int
+*QueryResultRow#getDouble(I)*                            id:balta-row-getdouble-int
+*QueryResultRow#getFloat(I)*                             id:balta-row-getfloat-int
+*QueryResultRow#getBigDecimal(I)*                        id:balta-row-getbigdecimal-int
+*QueryResultRow#getTime(I)*                              id:balta-row-gettime-int
+*QueryResultRow#getDate(I)*                              id:balta-row-getdate-int
+*QueryResultRow#getLocalDateTime(I)*                     id:balta-row-getlocaldatetime-int
+*QueryResultRow#getOffsetDateTime(I)*                    id:balta-row-getoffsetdatetime-int
+*QueryResultRow#getInstant(I)*                           id:balta-row-getinstant-int
+*QueryResultRow#getUUID(I)*                              id:balta-row-getuuid-int
+
+# DBTestSuite — single-call delegates to Params
+*DBTestSuite#add(*)                                      id:balta-suite-add
+*DBTestSuite#<init>(Z)*                                  id:balta-suite-ctor-bool
+*DBTestSuite#dbConnection()                              id:balta-suite-dbconn
+
+# DBFunction — single-call overloads and factories
+*DBFunction#perform(*)                                   id:balta-func-perform
+*DBFunction#getResult(*)                                 id:balta-func-getresult
+*DBFunction#execute(Lscala/Function1;)*                  id:balta-func-execute-1arg
+*DBFunction#clear(*)                                     id:balta-func-clear
+*DBFunctionWithPositionedParamsOnly#setParamNull(*)      id:balta-func-pos-setnull
+
+# DBConnection — second factory overload delegates to primary
+*DBConnection$#apply(Ljava/lang/String;*)               id:balta-dbconn-apply-str
+
+# Params — factory-level addNull delegates (call add with NULL)
+*Params$#addNull(*)                                      id:balta-params-addnull
+*Params$NamedParams#pairs()                              id:balta-params-named-pairs
+
+# Postgres implicit class — single-call delegates
+*PostgresRow#get*(*)                                     id:balta-postgres-getters
+
+# SimpleJsonString — implicit conversion and param type factory
+*SimpleJsonString$#fromString(*)                         id:balta-sjs-fromstring
+*SimpleJsonString$ParamTypeSimpleJsonString#toQueryParamValue(*)  id:balta-sjs-paramtype
+
+# QueryParamType implicit objects — each returns new SimpleQueryParamValue / ObjectQueryParamValue
+*QueryParamType$QueryParamDouble#toQueryParamValue(*)    id:balta-qpt-double
+*QueryParamType$QueryParamFloat#toQueryParamValue(*)     id:balta-qpt-float
+*QueryParamType$QueryParamBigDecimal#toQueryParamValue(*) id:balta-qpt-bigdecimal
+*QueryParamType$QueryParamChar#toQueryParamValue(*)      id:balta-qpt-char
+*QueryParamType$QueryParamInstant#toQueryParamValue(*)   id:balta-qpt-instant
+*QueryParamType$QueryParamOffsetDateTime#toQueryParamValue(*) id:balta-qpt-offsetdatetime
+*QueryParamType$QueryParamLocalTime#toQueryParamValue(*) id:balta-qpt-localtime
+*QueryParamType$QueryParamLocalDate#toQueryParamValue(*) id:balta-qpt-localdate
+*QueryParamType$QueryParamUUID#toQueryParamValue(*)      id:balta-qpt-uuid
+*QueryParamType$QueryParamLong#toQueryParamValue(*)      id:balta-qpt-long
+
+# QueryParamValue — ObjectQueryParamValue constructor + assign accessor
+*ObjectQueryParamValue#assign(*)                         id:balta-qpv-obj-assign
+*ObjectQueryParamValue#assignFunc(*)                     id:balta-qpv-obj-assignfunc
+
+# PostgresObjectQueryParamValue — constructor + assign accessor
+*PostgresObjectQueryParamValue#assign(*)                 id:balta-pqpv-assign
+*PostgresObjectQueryParamValue#assignFunc(*)             id:balta-pqpv-assignfunc
+
+# AsIsNaming / ExplicitNamingRequired — singleton implicit vals
+*AsIsNaming$Implicits$#namingConvention()                id:balta-asis-implicit
+*ExplicitNamingRequired$Implicits$#namingConvention()    id:balta-explicit-implicit
+
+# NamingConvention — fromClassNamePerConvention(instance) delegates to Class overload
+*NamingConvention#fromClassNamePerConvention(Ljava/lang/Object;)* id:balta-naming-from-instance
+
+# OptionImplicits / MapImplicits — implicit class wrapper constructors (value class)
+*OptionImplicits$OptionEnhancements#<init>(*)            id:balta-opt-ctor
+*MapImplicits$MapEnhancements#<init>(*)                  id:balta-map-ctor
+*QueryResultRowImplicits$ProductTypeConvertor#<init>(*)  id:balta-qrri-ctor
+*Postgres$PostgresRow#<init>(*)                          id:balta-pgrow-ctor
+
+# OptionImplicits / MapImplicits / QueryResultRowImplicits / Postgres — implicit class outer wrappers
+*OptionImplicits#<init>(*)                               id:balta-opt-outer
+*MapImplicits#<init>(*)                                  id:balta-map-outer
+*QueryResultRowImplicits#<init>(*)                       id:balta-qrri-outer
+*Postgres#<init>(*)                                      id:balta-pg-outer
+
+# LettersCase.convert — trivial identity/toLowerCase/toUpperCase
+*LettersCase$AsIs$#convert(*)                            id:balta-lc-asis
+*LettersCase$LowerCase$#convert(*)                       id:balta-lc-lower
+*LettersCase$UpperCase$#convert(*)                       id:balta-lc-upper
+
+# QueryResult — Iterator trait mixin forwarders (no project logic)
+# QueryResult extends Iterator[QueryResultRow]; the compiler generates ~80 mixin
+# forwarders for inherited Iterator/TraversableOnce methods.  Only hasNext, next,
+# noMore, resultSetMetaData, and columnCount carry project logic (tested elsewhere).
+*QueryResult#to*(*)                                      id:balta-qr-iter-to
+*QueryResult#mk*(*)                                      id:balta-qr-iter-mk
+*QueryResult#addString(*)                                id:balta-qr-iter-addstr
+*QueryResult#copy*(*)                                    id:balta-qr-iter-copy
+*QueryResult#reduce*(*)                                  id:balta-qr-iter-reduce
+*QueryResult#fold*(*)                                    id:balta-qr-iter-fold
+*QueryResult#scan*(*)                                    id:balta-qr-iter-scan
+*QueryResult#zip*(*)                                     id:balta-qr-iter-zip
+*QueryResult#take*(*)                                    id:balta-qr-iter-take
+*QueryResult#drop*(*)                                    id:balta-qr-iter-drop
+*QueryResult#filter*(*)                                  id:balta-qr-iter-filter
+*QueryResult#collect*(*)                                 id:balta-qr-iter-collect
+*QueryResult#slice*(*)                                   id:balta-qr-iter-slice
+*QueryResult#index*(*)                                   id:balta-qr-iter-index
+*QueryResult#min*(*)                                     id:balta-qr-iter-min
+*QueryResult#max*(*)                                     id:balta-qr-iter-max
+*QueryResult#pad*(*)                                     id:balta-qr-iter-pad
+*QueryResult#for*(*)                                     id:balta-qr-iter-for
+*QueryResult#is*(*)                                      id:balta-qr-iter-is
+*QueryResult#size*(*)                                    id:balta-qr-iter-size
+*QueryResult#non*(*)                                     id:balta-qr-iter-non
+*QueryResult#map(*)                                      id:balta-qr-iter-map
+*QueryResult#flatMap(*)                                  id:balta-qr-iter-flatmap
+*QueryResult#find(*)                                     id:balta-qr-iter-find
+*QueryResult#contains(*)                                 id:balta-qr-iter-contains
+*QueryResult#count(*)                                    id:balta-qr-iter-count
+*QueryResult#corresponds(*)                              id:balta-qr-iter-corr
+*QueryResult#withFilter(*)                               id:balta-qr-iter-withfilter
+*QueryResult#partition(*)                                id:balta-qr-iter-partition
+*QueryResult#span(*)                                     id:balta-qr-iter-span
+*QueryResult#patch(*)                                    id:balta-qr-iter-patch
+*QueryResult#buffered(*)                                 id:balta-qr-iter-buffered
+*QueryResult#grouped(*)                                  id:balta-qr-iter-grouped
+*QueryResult#duplicate(*)                                id:balta-qr-iter-duplicate
+*QueryResult#sameElements(*)                             id:balta-qr-iter-same
+*QueryResult#$plus$plus(*)                               id:balta-qr-iter-plusplus
+*QueryResult#$div$colon(*)                               id:balta-qr-iter-divcolon
+*QueryResult#$colon$bslash(*)                            id:balta-qr-iter-colonbslash
+*QueryResult#aggregate(*)                                id:balta-qr-iter-aggregate
+*QueryResult#sum(*)                                      id:balta-qr-iter-sum
+*QueryResult#product(*)                                  id:balta-qr-iter-product
+*QueryResult#seq(*)                                      id:balta-qr-iter-seq
+*QueryResult#exists(*)                                   id:balta-qr-iter-exists
+*QueryResult#length(*)                                   id:balta-qr-iter-length
+*QueryResult#reversed(*)                                 id:balta-qr-iter-reversed
+*QueryResult#hasDefiniteSize(*)                          id:balta-qr-iter-defsize
+
+# Value class body methods — never boxed at runtime; compiler always uses static extensions
+# Filtering the boxed-path class methods (excluding ctor/hashCode/equals already filtered globally)
+*MapImplicits$MapEnhancements#map(*)                     id:balta-valclass-me-map
+*MapImplicits$MapEnhancements#getOrThrow(*)              id:balta-valclass-me-got
+*OptionImplicits$OptionEnhancements#option(*)             id:balta-valclass-oe-opt
+*OptionImplicits$OptionEnhancements#getOrThrow(*)         id:balta-valclass-oe-got
+*OptionImplicits$OptionEnhancements#$at$eq(*)             id:balta-valclass-oe-ateq
+*QueryResultRowImplicits$ProductTypeConvertor#row(*)      id:balta-valclass-ptc-row
+*QueryResultRowImplicits$ProductTypeConvertor#toProductType(*) id:balta-valclass-ptc-tpt
+*Postgres$PostgresRow#row(*)                              id:balta-valclass-pg-row
+*Postgres$PostgresRow#getSimpleJsonString(*)              id:balta-valclass-pg-gsjs
+*Postgres$PostgresRow#getSJSArray(*)                      id:balta-valclass-pg-gsja
+*Postgres$PostgresRow#simpleJsonStringTransformer(*)      id:balta-valclass-pg-sjst
+
+# ObjectQueryParamValue — trait-mixin defaults (return "?" and "=", no project logic)
+*ObjectQueryParamValue#sqlEntry(*)                       id:balta-qpv-obj-sqlentry
+*ObjectQueryParamValue#equalityOperator(*)               id:balta-qpv-obj-eqop
+*ObjectQueryParamValue#<init>(*)                         id:balta-qpv-obj-init
+
+# PostgresObjectQueryParamValue — trait-mixin defaults and constructor
+*PostgresObjectQueryParamValue#sqlEntry(*)               id:balta-pqpv-sqlentry
+*PostgresObjectQueryParamValue#equalityOperator(*)       id:balta-pqpv-eqop
+*PostgresObjectQueryParamValue#<init>(*)                 id:balta-pqpv-init
+
+# DBConnection — value class body (wraps java.sql.Connection; never boxed)
+*DBConnection#connection(*)                              id:balta-dbconn-val
+*DBConnection#<init>(*)                                  id:balta-dbconn-init
+*DBConnection#hashCode(*)                                id:balta-dbconn-hash
+*DBConnection#equals(*)                                  id:balta-dbconn-eq
+
+# DBConnection$ companion — primary apply has DriverManager logic (boundary);
+# filters only the trivial methods (boundary factory not unit-testable without DB)
+*DBConnection$#apply(*)                                  id:balta-dbconn-apply
+
+# Implicit wrapper parent objects — outer object with only the implicit class definition
+*MapImplicits#*(*)                                       id:balta-map-outer-all
+*OptionImplicits#*(*)                                    id:balta-opt-outer-all
+*QueryResultRowImplicits#*(*)                            id:balta-qrri-outer-all
+*Postgres#*(*)                                           id:balta-pg-outer-all
+
+# SimpleJsonString — value class body (wraps String; never boxed)
+*SimpleJsonString#value(*)                               id:balta-sjs-value
+*SimpleJsonString#<init>(*)                              id:balta-sjs-init
+
+# Static companion forwarders — compiler-generated single-call delegates on main class
+# Each static method on FooClass forwards to FooClass$.MODULE$.method()
+*DBConnection#apply(*)                                   id:balta-dbconn-apply-fwd
+*DBConnection#dbConnectionToJdbcConnection(*)            id:balta-dbconn-impl-fwd
+*DBTestSuite#persistDataOverride()                       id:balta-suite-persist
+*DBTestSuite#connectionInfoFromResourceConfig(*)         id:balta-suite-configfwd
+*QueryResultRow#createExtractors(*)                      id:balta-row-extractors-fwd
+*QueryResultRow#fieldNamesFromMetadata(*)                id:balta-row-fieldnames-fwd
+*NamingException#message(*)                              id:balta-naming-exc-msg
+*NamingException#apply(*)                                id:balta-naming-exc-apply
+*MapBasedNaming#apply(*)                                 id:balta-mapnaming-apply-fwd
+*DBFunction#apply(*)                                     id:balta-dbfunc-apply-fwd
+*DBTable#apply(*)                                        id:balta-dbtable-apply-fwd
+*Params#add(*)                                           id:balta-params-add-fwd
+*Params#addNull(*)                                       id:balta-params-addnull-fwd
+*SimpleJsonString#apply(*)                               id:balta-sjs-apply-fwd
+*SimpleJsonString#fromString(*)                          id:balta-sjs-fromstring-fwd
+
+# Trait mixin forwarders — implementing class calls trait default method (no own logic)
+*MapBasedNaming#fromClassNamePerConvention(*)            id:balta-mapnaming-fromclass
+*ExplicitNamingRequired#fromClassNamePerConvention(*)    id:balta-explicit-fromclass
+*AsIsNaming#fromClassNamePerConvention(*)                id:balta-asis-fromclass
+
+# Private field accessors — compiler-generated single-return methods
+*QueryResultRow#fields()                                 id:balta-row-fields
+*QueryResultRow#columnLabels()                           id:balta-row-columnlabels
+*AsIsNaming#lettersCase(*)                               id:balta-asis-letterscase
+
+# Params abstract class — instance methods are single-call delegates to ListMap
+*Params#values(*)                                        id:balta-params-values
+*Params#apply(*)                                         id:balta-params-apply
+*Params#size(*)                                          id:balta-params-size
+*Params#<init>(*)                                        id:balta-params-init
+
+# DBTestSuite#now — boundary method (SQL query, can't unit test without DB)
+*DBTestSuite#now(*)                                      id:balta-suite-now
+
+# DBTestSuite — lazy val computation (boundary: calls DriverManager.getConnection)
+*DBTestSuite#dbConnection$lzycompute(*)                  id:balta-suite-dbconn-lazy
+
+# DBTestSuite — test() override wraps testFun in a lambda + delegates to super.test()
+# The try/finally/commit/rollback logic lives in the $anonfun$test$1 synthetic (already filtered).
+# The test() method itself contains only closure creation + super.test() call — a delegation wrapper.
+*DBTestSuite#test(*)                                     id:balta-suite-test
+
+# DBTestSuite — constructor (Lscala/Option;) overload — sets fields, calls super
+*DBTestSuite#<init>(Lscala/Option;)*                     id:balta-suite-ctor-opt
+
+# DBTestSuite — connectionInfo lazy val accessor (compiler-generated check + delegate)
+*DBTestSuite#connectionInfo(*)                           id:balta-suite-conninfo
+
+# ProductTypeConvertor value class body — private helpers (never boxed at runtime)
+*QueryResultRowImplicits$ProductTypeConvertor#getConstructor(*)    id:balta-valclass-ptc-gc
+*QueryResultRowImplicits$ProductTypeConvertor#getConstructorMirror(*)  id:balta-valclass-ptc-gcm
+*QueryResultRowImplicits$ProductTypeConvertor#readParamsFromRow(*)  id:balta-valclass-ptc-rpr
+*QueryResultRowImplicits$ProductTypeConvertor#getParamValue(*)     id:balta-valclass-ptc-gpv
+
+# SimpleJsonString$ParamTypeSimpleJsonString$ companion — single new() call
+*SimpleJsonString$ParamTypeSimpleJsonString$#toQueryParamValue(*)  id:balta-sjs-ptsjs-tqpv
+
+# PostgresObjectQueryParamValue — private field accessor
+*PostgresQueryParamValue$PostgresObjectQueryParamValue#pgObject(*) id:balta-pqpv-pgobj
+
+# DBFunction$DBFunctionWithNamedParamsToo — case class field accessor
+*DBFunction$DBFunctionWithNamedParamsToo#functionName(*) id:balta-func-named-funcname
+
+# ConnectionInfo — static apply forwarder on main class (delegates to ConnectionInfo$.apply)
+*ConnectionInfo#apply(*)                                 id:balta-conninfo-apply
+
+# QueryResult — missed Iterator mixin forwarder
+*QueryResult#sliding(*)                                  id:balta-qr-iter-sliding
+
+# QueryResultRow$ — timeTzExtractor: private extractor used only when column type is timetz
+# Exercised through integration tests with the actual DB; not unit-testable.
+*QueryResultRow$#timeTzExtractor$1(*)                    id:balta-row-timetz-ext
+
+# DBTable — boundary methods (fieldValue/count need DB connection for SQL execution)
+*DBTable#fieldValue(*)                                   id:balta-dbtable-fieldvalue
+*DBTable#count(*)                                        id:balta-dbtable-count
+
+# DBFunction — execute(String, verify) partially covered; uncovered branch is empty-orderBy path
+*DBFunction#execute(Ljava/lang/String;*)*                id:balta-func-execute-orderby

From e6087b44102ea4e9da95a49103ab0ba51960cce6 Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Mon, 20 Apr 2026 16:06:35 +0200
Subject: [PATCH 06/13] Add unit tests for setParamNull and noMore methods;
 update jacoco-method-filter plugin version

- Added tests for DBFunction to verify behavior of setParamNull by name and position.
- Enhanced QueryResult tests to check noMore method functionality.
- Included tests for Params class to validate addNull method for both NamedParams and OrderedParams.
- Updated jacoco-method-filter plugin from version 2.0.1 to 2.1.0 for improved coverage filtering.
---
 .github/copilot-instructions.md               |   6 +
 JMF-NOTES.md                                  | 429 ----------------
 .../absa/db/balta/DBTestSuiteUnitTests.scala  |  53 ++
 .../balta/classes/DBFunctionUnitTests.scala   |  16 +
 .../balta/classes/QueryResultUnitTests.scala  |  11 +
 .../balta/classes/inner/ParamsUnitTests.scala |  14 +
 jmf-rules.txt                                 | 476 ++++++++++--------
 project/plugins.sbt                           |   2 +-
 8 files changed, 370 insertions(+), 637 deletions(-)
 delete mode 100644 JMF-NOTES.md

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 2af2f79..c511ca4 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -63,6 +63,12 @@ Testing
 - When to add to `jmf-rules.txt` instead of writing a unit test:
   - Body is a single call with no own logic: forwards to another overload, calls its non-deprecated replacement, returns a field, or wraps a constructor with no transformation.
   - Litmus: "Does this method have any logic of its own?" — No → JMF.
+- Global rule collision check (CRITICAL):
+  - When adding any new method, check if it matches a pattern in the `# GLOBALS RULES` section of `jmf-rules.txt` (line ~22+).
+  - If method name matches a global rule AND the method has domain logic: immediately create an INCLUDE rescue rule (`+FQCN#method(*)`) in the `# INCLUDE RULES` section of `jmf-rules.txt`.
+  - High-risk method names: refer to `jmf-rules.txt` GLOBALS RULES section for complete list; most common collisions: `apply()`, `toString()`, `equals()`, `copy()`, `name()`, `groups()`, `optionalAttributes()`.
+  - Rationale: Broad global rules designed for compiler-generated boilerplate can silently hide coverage for domain methods. INCLUDE rules rescue specific methods from broad exclusions.
+  - Example: If adding `def apply(id: String): Record`, add `+*Record$#apply(*)  id:keep-record-factory` to rescue from the `*$*#apply(*)` global rule in GLOBALS RULES section.
 - Review rule — JMF drift check: when modifying a method that appears in `jmf-rules.txt`, verify its body still qualifies; if own logic has been added, remove the JMF rule and write a unit test instead.
 
 Tooling
diff --git a/JMF-NOTES.md b/JMF-NOTES.md
deleted file mode 100644
index fa0df4c..0000000
--- a/JMF-NOTES.md
+++ /dev/null
@@ -1,429 +0,0 @@
-# JMF (jacoco-method-filter) — Lessons Learned
-
-Practical notes for anyone maintaining or extending `jmf-rules.txt` in this project.
-Accumulated from real debugging sessions; each entry caused at least one silent coverage regression.
-
----
-
-## 1. Descriptor format must be JVM internal, not human-readable
-
-**Wrong:**
-```
-*QueryResultRow#apply(int)*          id:qrr-apply-int
-*QueryResultRow#getAs(java.lang.String,*)*  id:qrr-getas-str
-```
-**Right:**
-```
-*QueryResultRow#apply(I)*            id:qrr-apply-int
-*QueryResultRow#getAs(Ljava/lang/String;*)*  id:qrr-getas-str
-```
-
-JMF compares against raw JVM bytecode descriptors, not source-level types.
-Common type mappings:
-
-| Source type    | JVM descriptor               |
-|----------------|------------------------------|
-| `int`          | `I`                          |
-| `boolean`      | `Z`                          |
-| `long`         | `J`                          |
-| `double`       | `D`                          |
-| `String`       | `Ljava/lang/String;`         |
-| `Option[A]`    | `Lscala/Option;`             |
-| `Unit` / void  | `V`                          |
-| array of int   | `[I`                         |
-
-Use `javap -p -verbose <ClassFile.class>` to see the actual descriptors for any method.
-
----
-
-## 2. FQCN globs must start with `*` to match qualified class names
-
-**Wrong:**
-```
-QueryResult#noMore()   id:qr-nomore
-```
-**Right:**
-```
-*QueryResult#noMore()  id:qr-nomore
-```
-
-Without the leading `*`, the glob is matched literally and will never match
-`za.co.absa.db.balta.classes.QueryResult`.
-
----
-
-## 3. Non-matching rules are silently ignored — no warning, no error
-
-JMF does not report unmatched rules. A rule can be completely wrong and the tool will
-load it, count it, and do nothing — while JaCoCo continues to count the method as missed.
-
-**Consequence:** Coverage numbers may look fine if another test happens to cover the same
-method via a different path (e.g., an integration test). The rule appears to work for months,
-then suddenly "breaks" when that test is removed or the method is called less often.
-
-**How to verify a rule is actually filtering:**
-1. Run `sbt ++2.12.18 jacoco` and note the JMF log line: `Marked N methods`.
-2. Add the new rule.
-3. Run again and confirm `N` increased.
-4. Cross-reference `balta/target/scala-2.12/jacoco/jacoco.xml` to confirm the specific
-   method now has `mi="0"` (missed instructions = 0) AND `ci` dropped by the expected amount.
-
----
-
-## 4. Diagnosing a missed-coverage method
-
-When JaCoCo reports missed instructions after you believe you have a rule:
-
-1. Find the method in `jacoco.xml`:
-   ```
-   grep -A2 'name="myMethod"' balta/target/scala-2.12/jacoco/jacoco.xml
-   ```
-2. Check `mi` (missed instructions) and `nr` (not-reached branches).
-3. Get the actual bytecode descriptor:
-   ```
-   javap -p -verbose balta/target/scala-2.12/classes/za/co/absa/.../MyClass.class \
-     | grep -A4 "myMethod"
-   ```
-4. Compare the descriptor in your rule against the bytecode output.
-   Common mistakes: `(int)` vs `(I)`, missing `;` after object type, `*` vs explicit return type.
-
----
-
-## 5. Scala 2.12 compiler-generated methods that produce coverable bytecode
-
-These arise automatically and are JMF candidates (no own logic), not unit-test candidates:
-
-| Pattern | Description |
-|---------|-------------|
-| `$anonfun$*` (ACC_SYNTHETIC) | Lambda bodies lifted to class methods |
-| `$deserializeLambda$` (private static, NOT synthetic) | SerializedLambda support |
-| `andThen` / `compose` | Function1 trait mixin forwarders |
-| `*$extension` | Value class extension methods (boxed path) |
-| `*$default$*` | Default parameter methods (`$default$1`, `$default$2`, …) |
-| Iterator trait mixins (~80+) | `hasNext`, `next`, `drop`, `take`, `sliding`, etc. |
-| `writeReplace` | Java serialization hook for case classes |
-
-When a method's coverage is missed and its source is compiler-generated, add a JMF rule
-rather than writing a test.
-
----
-
-## 6. Verifying new rules end-to-end
-
-Minimal workflow before committing any new JMF rule:
-
-```bash
-# 1. baseline — note "Marked N methods" in sbt output
-sbt '++2.12.18; jacoco'
-
-# 2. add rule to jmf-rules.txt
-
-# 3. re-run — "Marked N+k methods" confirms the rule matched
-sbt '++2.12.18; jacoco'
-
-# 4. quick coverage check
-awk -F',' 'NR>1{m+=$5; c+=$6} END{printf "Missed: %d  Covered: %d  Total: %d  Coverage: %.1f%%\n", m, c, m+c, c*100/(m+c)}' \
-  balta/target/scala-2.12/jacoco/jacoco.csv
-```
-
----
-
-## 7. Avoid broad wildcards — prefer `synthetic`/`bridge` flags
-
-A rule like `*#*$anonfun$*(*)` with the `synthetic` flag is safer than an unqualified
-glob that might accidentally suppress coverage for hand-written lambdas.
-
-```
-*#$anonfun$*(*)  synthetic  id:scala-anonfun
-```
-
-The `synthetic` flag restricts the rule to bytecode methods with ACC_SYNTHETIC set,
-which is exactly what the Scala compiler emits for lifted lambdas.
-
----
-
-## 8. Scala reflection in tests — case classes must be top-level
-
-When writing unit tests that call `currentMirror.reflectClass` (e.g., for
-`toProductType`-style tests), the case class **must** be declared at package scope,
-not as a nested/inner class inside the test class.
-
-```scala
-// WRONG: inner class, reflection fails at runtime
-class MyUnitTests extends AnyFunSuite {
-  case class MyRecord(id: Int, name: String)
-  test("...") { ... currentMirror.reflectClass(mirror) ... } // NoHostException
-}
-
-// RIGHT: top-level, reflection works
-case class MyRecord(id: Int, name: String)
-class MyUnitTests extends AnyFunSuite {
-  test("...") { ... currentMirror.reflectClass(mirror) ... } // OK
-}
-```
-
----
-
-## 9. Rule file version header
-
-The first non-comment line must be `[jmf:1.0.0]` (or the appropriate version).
-Missing or malformed version headers cause the entire rule file to be skipped silently.
-Confirm the file is loaded by checking the sbt jacoco log for `Loaded N rules`.
-
----
-
-## 10. Misleading or incorrect hints in the official JMF tutorial
-
-The bundled HowTo comment block (`jmf-rules.txt` header) contains several claims that are
-inconsistent, misleading, or contradicted by tested behaviour. Do not copy examples from it
-without checking below.
-
-### 10a. Colon-prefix flag syntax in Quick Examples is wrong
-
-The Quick Examples section writes:
-```
-*#*(*):synthetic            # any synthetic
-*#*(*):bridge               # any bridge
-```
-The colon before `synthetic`/`bridge` does **not** match the FLAGS syntax described just
-above it, which says "space or comma separated". Our confirmed working syntax is:
-```
-*#*  synthetic  id:some-label
-*#$anonfun$*(*)  synthetic  name-contains:$anonfun$  id:scala-anonfun
-```
-The colon-prefix format may be silently ignored (rule loads but never matches), which is
-the same failure mode as wrong descriptors. Do not use `:<flag>` — use space-separated flags.
-
-### 10b. `ret:` predicate syntax is inconsistent within the tutorial
-
-The tutorial shows `ret:` two different ways:
-```
-# inconsistent — colon-prefixed
-*.jobs.*#*(*):ret:V
-
-# inconsistent — space-separated
-*.client.*#with*(*) ret:Lcom/api/client/*;
-```
-The space-separated form matches the PREDICATES spec. Use space-separated:
-```
-*MyClass#myMethod(*)  ret:V  id:my-label
-```
-Never use `:ret:` (double colon, colon-prefixed).
-
-### 10c. Tutorial does not warn about the FQCN `*` prefix requirement
-
-All Quick Examples use fully-anchored package globs like `*.model.*#copy(*)`, which
-implicitly start with `*`. The tutorial never states that a bare class name
-(`QueryResult#noMore()`) will NOT match a fully-qualified name
-(`za.co.absa.db.balta.classes.QueryResult`).
-
-This silence has caused real bugs: rules written as `ClassName#method()` compile and load,
-appear in the "N rules loaded" count, but never filter anything.
-
-**Always prefix project-specific class names with `*`:**
-```
-# WRONG — silently never matches
-QueryResult#noMore()  id:qr-nomore
-
-# RIGHT
-*QueryResult#noMore()  id:qr-nomore
-```
-
-### 10d. Tutorial descriptor examples do not demonstrate JVM-format requirement
-
-The ALLOWED SYNTAX section correctly shows JVM format (`(I)I`, `(Ljava/lang/String;)V`)
-but the Quick Examples section uses only `(*)` everywhere, giving the impression that
-type-specific descriptors are rarely needed. In practice:
-
-- Any rule targeting a method that takes `int`, `boolean`, or any object type by specific
-  type **must** use JVM format.
-- Writing `(int)`, `(boolean)`, `(java.lang.String)` will silently not match.
-- The tutorial provides no warning that human-readable types produce silent failures.
-
-See section 1 of this file for the correct mapping table.
-
-### 10e. Tutorial claims empty/short descriptor forms are equivalent — verify before trusting
-
-The tutorial states: `"(*)" normalizes to "(*)*" ⇒ any args, any return.`
-This is consistent with our tested experience for wildcard rules. However, when mixing
-`(*)` with typed descriptors in the same class, `(*)` may match more broadly than intended.
-Prefer an explicit descriptor when targeting a specific overload.
-
-### 10f. Empty parens `()` reads as "no args" but means "any args" due to normalisation
-
-The tutorial global rule examples include:
-```
-*#productElement()
-*#productArity()
-*#productIterator()
-```
-A reader naturally interprets `()` as "this method takes no arguments". But `productElement`
-has the signature `def productElement(n: Int): Any` — its JVM descriptor is `(I)Ljava/lang/Object;`.
-The rule still works because `()` normalises to `(*)*` (any args, any return).
-
-**Consequence:** These rules match more than you think. A rule written as `*#myMethod()` to
-target a specific no-arg overload will also match every overload of `myMethod`, including
-ones you may want to test. Use an explicit descriptor when targeting a single overload:
-```
-*#mySpecificMethod()V          # actually no-arg, returns void
-*#myOverloadedMethod(I)*       # specifically the int overload
-```
-
-### 10g. Tutorial's own Quick Example comments use human-readable types
-
-The formal ALLOWED SYNTAX section correctly shows JVM format, but the very next section's
-inline explanatory comments contradict it:
-```
-*.model.*#productElement(*)
-    → Matches `productElement(int)` (or any descriptor form) on case classes.
-                            ^^^^ human-readable — not valid if used in a rule
-```
-The parenthetical "(or any descriptor form)" hints at the issue but does not explain it.
-Any reader who copies the comment text into a rule will get a silently non-matching rule.
-
-### 10h. `ret:` object type globs — semicolon inconsistency
-
-The tutorial shows `ret:` for object types with and without a trailing `;`:
-```
-*.client.*#with*(*) ret:Lcom/api/client/*;       # has semicolon
-*.model.*#*(*):ret:Lcom/example/model/*          # missing semicolon
-```
-JVM object type descriptors always end with `;` (e.g., `Ljava/lang/String;`). The form
-without `;` may silently fail to match for the same reason a wrong descriptor does.
-Always include the trailing semicolon for object return type globs:
-```
-*MyClass#myMethod(*)  ret:Lcom/example/model/*;  id:my-label
-```
-
-### 10i. `id:` listed under PREDICATES implies it is optional — it is not
-
-The tutorial lists `id:<string>` in the PREDICATES section alongside `ret:`, `name-contains:`,
-etc., with the description "identifier shown in logs/reports". Nothing in the tutorial says
-it is required.
-
-In practice, omitting `id:` makes log output unreadable when rules fire — you see only the
-method descriptor with no human-readable label. Treat `id:` as mandatory on every rule.
-This project's instructions reflect this: "Every rule Must include an `id:` label for
-traceability."
-
-### 10j. `#` is both the comment marker and the FQCN/method separator — inline comments are ambiguous
-
-The tutorial states "Comments (# …) and blank lines are ignored" but never clarifies that
-`#` in the middle of a rule is the FQCN/method separator, not a comment.
-
-This creates an ambiguity for inline trailing comments:
-```
-*$#<init>(*)  id:gen-ctor # constructors
-```
-Is `# constructors` an inline comment that JMF drops, or does it confuse the parser?
-In our tested rules it appears to be harmless, but the tutorial is completely silent on
-this. To be safe, keep `#`-style inline comments only on dedicated comment lines.
-Use the `id:` label as the sole annotation on rule lines:
-```
-# constructors
-*$#<init>(*)  id:gen-ctor
-```
-
-### 10k. CONSERVATIVE / STANDARD / AGGRESSIVE labels mentioned in intro but never applied to examples
-
-The Quick Start says:
-> "2) Start with the CONSERVATIVE section only. 3) If clean, enable STANDARD. Use AGGRESSIVE
-> only inside DTO/auto-generated packages."
-
-But the rule examples that follow are not labelled CONSERVATIVE, STANDARD, or AGGRESSIVE.
-There is no way to know which category `*.model.*#copy(*)` or `*#$anonfun$*` belongs to
-without guessing. In our project we use the section header comments to mark intent instead:
-`# GLOBALS RULES`, `# PROJECT RULES`.
-
-### 10l. "Always use dot-form" note contradicts necessary `$` usage
-
-The "Notes" section says:
-> "Always use dot-form (com.example.Foo) for class names."
-
-But inner classes and companion objects require `$`, not `.`:
-- `com.example.Foo$Bar` — inner class `Bar` of `Foo`
-- `com.example.Foo$` — companion object of `Foo`
-
-Both are used throughout the tutorial's own examples (`*.model.*$*#apply(*)`). The "dot-form"
-note means "use `.` as the package separator" (not `/`), not "never use `$`". The note needs
-the clarification: `$` is the required inner-class/companion separator and must be used as-is.
-
-### 10m. Universal wildcard `*#*(*)` missing warning about falsely inflated coverage
-
-The tutorial says:
-> "`*#*(*)` — Match EVERY method in EVERY class. Useful only for diagnostics."
-
-It does not warn that enabling this globally will suppress JaCoCo for every method in the
-codebase, producing artificially inflated (up to 100%) coverage numbers. This rule left
-enabled in a CI pipeline would silently mask all regressions. It should carry an explicit
-**DO NOT commit** warning.
-
-### 10n. Scala var setter compiled name not explained for `_$eq` glob
-
-The tutorial shows:
-```
-*.dto.*#*_$eq(*)
-    → Matches Scala var setters in DTO packages (e.g., `name_=(...)`).
-```
-The source-level name `name_=` is compiled to `name_$eq` in bytecode. The tutorial
-uses `_$eq` as the glob suffix but never explains *why* — a reader unfamiliar with
-Scala's name mangling might try `*_=(*)` (the source form), which will never match.
-Always use the bytecode name in JMF globs, not the source name.
-
----
-
-## 12. Real bugs found in this project's own jmf-rules.txt via audit
-
-These were discovered by running the same JVM-descriptor audit described in section 1
-and cross-referencing against the knowledge in section 10d. Both rules silently failed
-to match and were only "covered" because integration tests happened to exercise the
-same methods. **Fixed in jmf-rules.txt.**
-
-| Rule (before fix) | Problem | Fix |
-|---|---|---|
-| `*DBFunction#execute(scala.Function1)` | Human-readable class name | `(Lscala/Function1;)*` |
-| `*NamingConvention#fromClassNamePerConvention(java.lang.Object)` | Human-readable class name | `(Ljava/lang/Object;)*` |
-
-Audit command used to find these:
-```bash
-grep -n '[a-z]\.[A-Z]' jmf-rules.txt | grep -v '^#'
-```
-This finds lines where a lower-case package segment is followed by an upper-case class
-name in descriptor position — a strong indicator of human-readable format.
-
----
-
-## 13. Scala source name vs bytecode name — glob always targets bytecode
-
-JMF operates on bytecodes, so any glob must use the compiled method name, not the source
-name. Common Scala name-mangling patterns:
-
-| Source name | Bytecode name |
-|---|---|
-| `name_=` (var setter) | `name_$eq` |
-| `a_+_b` (operator) | `a_$plus_b` |
-| `?` | `$qmark` |
-| `!` | `$bang` |
-| `++` | `$plus$plus` |
-| `::` | `$colon$colon` |
-| Inner class `Foo.Bar` | `Foo$Bar` |
-| Companion object `Foo` | `Foo$` |
-| Lambda lifted from `foo` | `$anonfun$foo$1` |
-
-Use `javap -p classfile` to confirm the exact bytecode name before writing a glob.
-
----
-
-
-## 11. Quick reference — JMF rule anatomy
-
-```
-<FQCN_glob>#<method_glob>(<descriptor_glob>)  [FLAGS]  [PREDICATES]  id:<label>
-```
-
-- `FQCN_glob`: `*MyClass`, `*.model.*`, `com.example.*`; `$` for inner/companion.
-- `method_glob`: `copy`, `get*`, `$anonfun$*`, `*_$eq`.
-- `descriptor_glob`: JVM bytes, e.g., `(I)*`, `(Ljava/lang/String;)*`, `(*)`.
-- `FLAGS`: `public`, `protected`, `private`, `synthetic`, `bridge`, `static`, `abstract`.
-- `PREDICATES`: `ret:<glob>`, `name-contains:<s>`, `name-starts:<s>`, `name-ends:<s>`.
-- Every rule must have `id:<label>` for traceability.
diff --git a/balta/src/test/scala/za/co/absa/db/balta/DBTestSuiteUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/DBTestSuiteUnitTests.scala
index dc917ea..019f175 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/DBTestSuiteUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/DBTestSuiteUnitTests.scala
@@ -17,7 +17,11 @@
 package za.co.absa.db.balta
 
 import org.scalatest.funsuite.AnyFunSuiteLike
+import za.co.absa.db.balta.classes.DBFunction.DBFunctionWithPositionedParamsOnly
+import za.co.absa.db.balta.classes.DBTable
 import za.co.absa.db.balta.classes.inner.ConnectionInfo
+import za.co.absa.db.balta.classes.inner.Params.{NamedParams, OrderedParams}
+import za.co.absa.db.balta.typeclasses.QueryParamType
 
 class DBTestSuiteUnitTests extends AnyFunSuiteLike {
 
@@ -52,9 +56,58 @@ class DBTestSuiteUnitTests extends AnyFunSuiteLike {
     assert(!info.persistData)
   }
 
+  test("table helper creates DBTable with provided name") {
+    val suite = new ConcreteSuite(None)
+    val table = suite.exposedTable("my_table")
+    assert(table == DBTable("my_table"))
+  }
+
+  test("function helper creates DBFunction with provided name") {
+    val suite = new ConcreteSuite(None)
+    val fn = suite.exposedFunction("my_fn")
+    assert(fn.isInstanceOf[DBFunctionWithPositionedParamsOnly])
+    assert(fn.functionName == "my_fn")
+  }
+
+  test("named add helper delegates to Params.add") {
+    val suite = new ConcreteSuite(None)
+    val params: NamedParams = suite.exposedAdd("id", 7)
+    assert(params.size == 1)
+    assert(params("id").sqlEntry == "?")
+  }
+
+  test("named addNull helper delegates to Params.addNull") {
+    val suite = new ConcreteSuite(None)
+    val params: NamedParams = suite.exposedAddNull("missing")
+    assert(params.size == 1)
+    assert(params("missing").sqlEntry == "NULL")
+    assert(params("missing").equalityOperator == "IS")
+  }
+
+  test("ordered add helper delegates to Params.add") {
+    val suite = new ConcreteSuite(None)
+    val params: OrderedParams = suite.exposedAdd(1)
+    assert(params.size == 1)
+    assert(params.values.head.sqlEntry == "?")
+  }
+
+  test("ordered addNull helper delegates to Params.addNull") {
+    val suite = new ConcreteSuite(None)
+    val params: OrderedParams = suite.exposedAddNull[QueryParamType.NULL.type]()
+    assert(params.size == 1)
+    assert(params.values.head.sqlEntry == "NULL")
+    assert(params.values.head.equalityOperator == "IS")
+  }
+
   private class ConcreteSuite(override val persistDataOverride: Option[Boolean])
     extends DBTestSuite(persistDataOverride) {
     def exposedConnectionInfo: ConnectionInfo = connectionInfo
+    def exposedTable(tableName: String): DBTable = table(tableName)
+    def exposedFunction(functionName: String): DBFunctionWithPositionedParamsOnly = function(functionName)
+    def exposedAdd[T: QueryParamType](name: String, value: T): NamedParams = add(name, value)
+    def exposedAddNull(name: String): NamedParams = addNull(name)
+    def exposedAdd[T: QueryParamType](value: T): OrderedParams = add(value)
+    def exposedAddNull[T: QueryParamType](): OrderedParams = addNull[T]()
   }
 }
 
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/DBFunctionUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/DBFunctionUnitTests.scala
index 321a17f..354d252 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/DBFunctionUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/DBFunctionUnitTests.scala
@@ -68,4 +68,20 @@ class DBFunctionUnitTests extends AnyFunSuiteLike {
     val fn = DBFunction("fn").setParam("p", "v").clear()
     assert(fn.isInstanceOf[DBFunctionWithPositionedParamsOnly])
   }
+
+  test("setParamNull by name adds NULL param with named key") {
+    val fn = DBFunction("fn").setParamNull("p_null")
+    assert(fn.params.size == 1)
+    assert(fn.params.keys.head == Right("p_null"))
+    assert(fn.params.values.head.sqlEntry == "NULL")
+    assert(fn.params.values.head.equalityOperator == "IS")
+  }
+
+  test("setParamNull by position appends NULL as next index") {
+    val fn = DBFunction("fn").setParam(10).setParamNull()
+    assert(fn.params.size == 2)
+    assert(fn.params.keys.toList == List(Left(1), Left(2)))
+    assert(fn.params.values.toList.last.sqlEntry == "NULL")
+    assert(fn.params.values.toList.last.equalityOperator == "IS")
+  }
 }
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultUnitTests.scala
index 43facdf..b4dfdf5 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultUnitTests.scala
@@ -90,4 +90,15 @@ class QueryResultUnitTests extends AnyFunSuiteLike with MockResultSets {
     assert(qr.columnCount == 3)
   }
 
+  test("noMore returns false when rows are still available") {
+    val qr = new QueryResult(singleRowMockResultSet)
+    assert(!qr.noMore)
+  }
+
+  test("noMore returns true after rows are consumed") {
+    val qr = new QueryResult(singleRowMockResultSet)
+    qr.next()
+    assert(qr.noMore)
+  }
+
 }
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
index 14da1f7..2f05a72 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
@@ -48,6 +48,13 @@ class ParamsUnitTests extends AnyFunSuiteLike {
     assert(params("missing").equalityOperator == "IS")
   }
 
+  test("NamedParams instance addNull appends NULL parameter") {
+    val params = Params.add("id", 42).addNull("missing")
+    assert(params.size == 2)
+    assert(params("missing").sqlEntry == "NULL")
+    assert(params("missing").equalityOperator == "IS")
+  }
+
   test("NamedParams pairs returns key-value list") {
     val params = Params.add("k1", "v1").add("k2", "v2")
     val pairs = params.pairs
@@ -87,6 +94,13 @@ class ParamsUnitTests extends AnyFunSuiteLike {
     assert(params.values.head.sqlEntry == "NULL")
   }
 
+  test("OrderedParams instance addNull appends NULL parameter") {
+    val params = Params.add(1).addNull[QueryParamType.NULL.type]()
+    assert(params.size == 2)
+    assert(params.values.last.sqlEntry == "NULL")
+    assert(params.values.last.equalityOperator == "IS")
+  }
+
   test("OrderedParams keys returns None") {
     val params = Params.add("hello")
     assert(params.keys.isEmpty)
diff --git a/jmf-rules.txt b/jmf-rules.txt
index 966a033..14dbe27 100644
--- a/jmf-rules.txt
+++ b/jmf-rules.txt
@@ -1,17 +1,35 @@
-# jacoco-method-filter — Default Rules & HowTo (Scala)
-# [jmf:1.0.0]
-
+# jacoco-method-filter — Rules Template (Scala / sbt)
+# [jmf:2.1.0]
+#
+# Syntax reference, pitfalls, examples, and workflows: docs/rules-reference.md
+#
+# ─────────────────────────────────────────────────────────────────────────────
+# HOW TO USE
+# ─────────────────────────────────────────────────────────────────────────────
+#
+# 1) Review the GLOBAL RULES below — they cover compiler-generated boilerplate.
+# 2) Add project-specific patterns in the PROJECT RULES section.
+# 3) Keep rules narrow; add id: labels so logs are readable.
+#    Every rule must have an id:<label>. Unlabelled rules emit a [warn] at load
+#    time. CLI users: pass --strict to enforce id: as a hard CI requirement.
+#    (sbt/Maven plugins do not yet expose --strict as a configuration key.)
+# 4) Use --verify mode to confirm rules match before committing.
+#
+# ─────────────────────────────────────────────────────────────────────────────
 # GLOBALS RULES
-# ** all case class boilerplate
+# ─────────────────────────────────────────────────────────────────────────────
+# Global rules match ALL packages. Verify they do not suppress real logic.
+# See docs/rules-reference.md#global-rule-safety-warning for details.
 
 # Scala case class helpers
 *#canEqual(*)                                           id:case-canequal
 *#equals(*)                                             id:case-equals
-#*#apply(*)                                              id:case-apply      - disabled: method used in code
+*#apply(*)                                              id:case-apply
 *#unapply(*)                                            id:case-unapply
 *#hashCode(*)                                           id:case-hashcode
 *#copy(*)                                               id:case-copy
-#*#copy$default$*(*)                                     id:case-copy-defaults  — subsumed by gen-defaults
+# Subsumed by gen-defaults below; kept for clarity. Safe to remove if gen-defaults is enabled.
+*#copy$default$*(*)                                     id:case-copy-defaults
 *#productElement()                                      id:case-prod-element
 *#productArity()                                        id:case-prod-arity
 *#productPrefix()                                       id:case-prod-prefix
@@ -19,13 +37,19 @@
 *#tupled()                                              id:case-tupled
 *#curried()                                             id:case-curried
 *#toString()                                            id:case-tostring
+# Scala 2.13+ case class boilerplate — safe to enable; no-op in 2.11/2.12
+*#productElementName(*)                                 id:case-prod-element-name
+*#productElementNames()                                 id:case-prod-element-names
+# WARNING: may collide with domain methods named `name` — rescue with + include rule if needed
 *#name()                                                id:case-name
+# WARNING: may collide with domain methods named `groups` — rescue with + include rule if needed
 *#groups()                                              id:case-groups
+# WARNING: may collide with domain methods named `optionalAttributes` — rescue with + include rule if needed
 *#optionalAttributes()                                  id:case-optionalAttributes
 
 # Companion objects, constructors, and static definitions
-*$#<init>(*)                                            id:gen-ctor         # constructors
-*$#<clinit>()                                           id:gen-clinit       # static initializer blocks
+*$#<init>(*)                                            id:gen-ctor
+*$#<clinit>()                                           id:gen-clinit
 
 # Companion objects and defaults
 *$*#apply(*)                                            id:comp-apply
@@ -33,6 +57,11 @@
 *$*#toString(*)                                         id:comp-tostring
 *$*#readResolve(*)                                      id:comp-readresolve
 
+# Java serialization hook — compiler-generated on the case class itself (not the companion)
+# Body is a single expression returning a serialization proxy; no project logic.
+# WARNING: if a class overrides writeReplace with custom logic, rescue with + include rule.
+*#writeReplace(*)                                       id:case-writereplace
+
 # anonymous class created by a macro expansion
 *$macro$*#$anonfun$inst$macro$*                         id:macro-inst
 *$macro$*#inst$macro$*                                  id:macro-inst
@@ -40,10 +69,25 @@
 # lambda
 *#*  synthetic name-contains:$anonfun$                  id:scala-anonfun
 
-# lambda serialization helper — compiler-generated, no project logic
+# Lazy val compute — compiler-generated synchronization wrapper
+# Scala compiles `lazy val foo = expr` into an accessor + a `foo$lzycompute()` method.
+# The $lzycompute method body IS the lazy initializer (expr). If the initializer contains
+# real business logic, filtering this method hides it. Only enable when the lazy val is a
+# trivial constant, a boundary call not unit-testable, or an already-tested computation.
+# Rescue any lazy vals with real logic via + include rules.
+# DISABLED — enable with + include rules to rescue lazy vals whose initializer has real logic
+*#*$lzycompute(*)                                      id:scala-lzycompute
+
+# Lambda serialization helper — compiler-generated private static method
+# Emitted by scalac/javac to support SerializedLambda deserialization.
+# NOT marked ACC_SYNTHETIC (unlike $anonfun$*), so the synthetic flag does not catch it.
+# Body contains only a series of instanceof/handle comparisons — no project logic.
 *#$deserializeLambda$(*)                                id:scala-deser-lambda
 
-# value class companion extension bridges — compiler-generated identity operations
+# Value class companion extension bridges — compiler-generated identity operations
+# When a value class (AnyVal) is used in a boxed context, the Scala compiler emits
+# these *$extension methods on the companion object. Each is a single-expression
+# delegate to the unboxed static method; no project logic is present.
 *#hashCode$extension(*)                                 id:valclass-hashcode-ext
 *#equals$extension(*)                                   id:valclass-equals-ext
 *#toString$extension(*)                                 id:valclass-tostring-ext
@@ -55,325 +99,343 @@
 *#copy$extension(*)                                     id:valclass-copy-ext
 *#copy$default$*$extension(*)                           id:valclass-copydef-ext
 
-# Function1 trait mixin delegates — single-call forwarders
+# Function1 trait mixin delegates — single-call forwarders to scala.Function1
+# These arise when a class mixes in Function1. Each is a one-liner forwarding to
+# the trait default. Rarely contain project logic.
+# CAUTION: if your code defines andThen/compose with custom logic in a non-Function1
+# class, rescue those methods with + include rules.
 *#andThen(*)                                            id:fn1-andthen
 *#compose(*)                                            id:fn1-compose
 
 # Default parameter accessors — compiler-generated constant-returning methods
+# The Scala compiler emits a $default$N method for every parameter with a default
+# value. Each method body returns the constant default expression; no logic.
+# This rule supersedes `case-copy-defaults` above; both are safe to keep active.
 *#*$default$*(*)                                        id:gen-defaults
 
+# ─────────────────────────────────────────────────────────────────────────────
+# INCLUDE RULES (rescue methods from broad exclusions above)
+# ─────────────────────────────────────────────────────────────────────────────
+# Prefix a rule with "+" to rescue a method. Include always wins over exclude.
+#
+# RESCUE: Domain factory/accessor methods that collide with broad *#apply(*) rule
+# These are real domain methods with business logic, not case-class helpers.
++*Params#apply(*)                                        id:keep-params-apply
++*QueryResultRow#apply(*)                               id:keep-queryresult-accessors
++*QueryResultRow$#apply(*)                              id:keep-queryresult-factory
++*DBConnection$#apply(*)                                id:keep-dbconn-apply
++*DBFunction$#apply(*)                                  id:keep-dbfunction-apply
++*MapBasedNaming$#apply(*)                              id:keep-naming-transform
+
+# ─────────────────────────────────────────────────────────────────────────────
 # PROJECT RULES
-
-# proposal to new globals
-*#productElementName(*)                                 id:case-prod-element-name
-*#productElementNames()                                 id:case-prod-element-names
-
+# ─────────────────────────────────────────────────────────────────────────────
 # Deprecated single-call delegates: setParamNull / addNull instance methods
 # Each method body is a single call to the non-deprecated replacement.
 # A unit test would only re-test the replacement method; no assurance is added.
 # Note: Params$ companion factory addNull methods are NOT filtered — they contain logic.
-*#setParamNull(*)                                       id:balta-deprecated-setnull
-*Params$NamedParams#addNull(*)                           id:balta-deprecated-addnull-named
-*Params$OrderedParams#addNull(*)                         id:balta-deprecated-addnull-ordered
-*DBTestSuite#addNull(*)                                  id:balta-deprecated-addnull-suite
+# *#setParamNull(*)                                       id:balta-deprecated-setnull
+# *Params$NamedParams#addNull(*)                           id:balta-deprecated-addnull-named
+# *Params$OrderedParams#addNull(*)                         id:balta-deprecated-addnull-ordered
+# *DBTestSuite#addNull(*)                                  id:balta-deprecated-addnull-suite
 
 # One-liner factory wrappers in DBTestSuite
 # Each method is a single constructor call delegating to DBTable / DBFunction with no logic of its own.
-*DBTestSuite#table(*)                                    id:balta-factory-table
-*DBTestSuite#function(*)                                 id:balta-factory-function
+# *DBTestSuite#table(*)                                    id:balta-factory-table
+# *DBTestSuite#function(*)                                 id:balta-factory-function
 
 # Trivial implicit conversion: DBConnection → JDBC Connection
 # Entire body returns in.connection; no branching or transformation; a test would only assert identity.
-*DBConnection$#dbConnectionToJdbcConnection(*)           id:balta-implicit-dbconn
+# *DBConnection$#dbConnectionToJdbcConnection(*)           id:balta-implicit-dbconn
 
 # columnLabel: String overloads in QueryResultRow — pure label-resolution delegates
 # Each overload resolves the column label to an index via columnNumber(label) then forwards to the
 # Int-based overload. The Int-based overloads hold the extraction logic and are covered by integration tests.
 # apply(String) and the 2-param getAs(String, transformer) follow the same delegation pattern.
 # NOTE: JMF descriptors must use JVM format — (Ljava/lang/String;)* not (java.lang.String).
-*QueryResultRow#get*(Ljava/lang/String;)*                id:balta-colname-getter
-*QueryResultRow#getAs(Ljava/lang/String;Lscala/Function1;)* id:balta-colname-getas-transformer
-*QueryResultRow#apply(Ljava/lang/String;)*               id:balta-colname-apply
+# *QueryResultRow#get*(Ljava/lang/String;)*                id:balta-colname-getter
+# *QueryResultRow#getAs(Ljava/lang/String;Lscala/Function1;)* id:balta-colname-getas-transformer
+# *QueryResultRow#apply(Ljava/lang/String;)*               id:balta-colname-apply
 
 # QueryResult#noMore — trivial negation of hasNext
 # Body is exactly `!hasNext`; testing it adds no assurance beyond the hasNext unit tests.
-*QueryResult#noMore()                                    id:balta-nomore
+# *QueryResult#noMore()                                    id:balta-nomore
 
 # QueryResult#resultSetMetaData — implicit field accessor (public val)
 # Scala compiles a public val to a 0-arg getter that returns the backing field.
 # No logic; a test would only assert identity of what was passed to the constructor.
-*QueryResult#resultSetMetaData()                         id:balta-resultsetmetadata-accessor
+# *QueryResult#resultSetMetaData()                         id:balta-resultsetmetadata-accessor
 
 # QueryResult#columnCount — public val backed by metaData.getColumnCount
 # Scala val getter; no logic.
-*QueryResult#columnCount()                               id:balta-columncount-accessor
+# *QueryResult#columnCount()                               id:balta-columncount-accessor
 
 # QueryResultRow field accessors and single-call getters
-*QueryResultRow#rowNumber()                              id:balta-row-rownumber
-*QueryResultRow#columnCount()                            id:balta-row-columncount
+# *QueryResultRow#rowNumber()                              id:balta-row-rownumber
+# *QueryResultRow#columnCount()                            id:balta-row-columncount
 # NOTE: JMF descriptors must use JVM format.  (I)* matches single-int-param overloads.
-*QueryResultRow#apply(I)*                                id:balta-row-apply-int
-*QueryResultRow#getObject(I)*                            id:balta-row-getobject-int
-*QueryResultRow#getObject(Ljava/lang/String;)*           id:balta-row-getobject-str
-*QueryResultRow#getAs(I)*                                id:balta-row-getas-int
-*QueryResultRow#getBoolean(I)*                           id:balta-row-getboolean-int
-*QueryResultRow#getString(I)*                            id:balta-row-getstring-int
-*QueryResultRow#getInt(I)*                               id:balta-row-getint-int
-*QueryResultRow#getLong(I)*                              id:balta-row-getlong-int
-*QueryResultRow#getDouble(I)*                            id:balta-row-getdouble-int
-*QueryResultRow#getFloat(I)*                             id:balta-row-getfloat-int
-*QueryResultRow#getBigDecimal(I)*                        id:balta-row-getbigdecimal-int
-*QueryResultRow#getTime(I)*                              id:balta-row-gettime-int
-*QueryResultRow#getDate(I)*                              id:balta-row-getdate-int
-*QueryResultRow#getLocalDateTime(I)*                     id:balta-row-getlocaldatetime-int
-*QueryResultRow#getOffsetDateTime(I)*                    id:balta-row-getoffsetdatetime-int
-*QueryResultRow#getInstant(I)*                           id:balta-row-getinstant-int
-*QueryResultRow#getUUID(I)*                              id:balta-row-getuuid-int
+# *QueryResultRow#apply(I)*                                id:balta-row-apply-int
+# *QueryResultRow#getObject(I)*                            id:balta-row-getobject-int
+# *QueryResultRow#getObject(Ljava/lang/String;)*           id:balta-row-getobject-str
+# *QueryResultRow#getAs(I)*                                id:balta-row-getas-int
+# *QueryResultRow#getBoolean(I)*                           id:balta-row-getboolean-int
+# *QueryResultRow#getString(I)*                            id:balta-row-getstring-int
+# *QueryResultRow#getInt(I)*                               id:balta-row-getint-int
+# *QueryResultRow#getLong(I)*                              id:balta-row-getlong-int
+# *QueryResultRow#getDouble(I)*                            id:balta-row-getdouble-int
+# *QueryResultRow#getFloat(I)*                             id:balta-row-getfloat-int
+# *QueryResultRow#getBigDecimal(I)*                        id:balta-row-getbigdecimal-int
+# *QueryResultRow#getTime(I)*                              id:balta-row-gettime-int
+# *QueryResultRow#getDate(I)*                              id:balta-row-getdate-int
+# *QueryResultRow#getLocalDateTime(I)*                     id:balta-row-getlocaldatetime-int
+# *QueryResultRow#getOffsetDateTime(I)*                    id:balta-row-getoffsetdatetime-int
+# *QueryResultRow#getInstant(I)*                           id:balta-row-getinstant-int
+# *QueryResultRow#getUUID(I)*                              id:balta-row-getuuid-int
 
 # DBTestSuite — single-call delegates to Params
-*DBTestSuite#add(*)                                      id:balta-suite-add
-*DBTestSuite#<init>(Z)*                                  id:balta-suite-ctor-bool
-*DBTestSuite#dbConnection()                              id:balta-suite-dbconn
+# *DBTestSuite#add(*)                                      id:balta-suite-add
+# *DBTestSuite#<init>(Z)*                                  id:balta-suite-ctor-bool
+# *DBTestSuite#dbConnection()                              id:balta-suite-dbconn
 
 # DBFunction — single-call overloads and factories
-*DBFunction#perform(*)                                   id:balta-func-perform
-*DBFunction#getResult(*)                                 id:balta-func-getresult
-*DBFunction#execute(Lscala/Function1;)*                  id:balta-func-execute-1arg
-*DBFunction#clear(*)                                     id:balta-func-clear
-*DBFunctionWithPositionedParamsOnly#setParamNull(*)      id:balta-func-pos-setnull
+# *DBFunction#perform(*)                                   id:balta-func-perform
+# *DBFunction#getResult(*)                                 id:balta-func-getresult
+# *DBFunction#execute(Lscala/Function1;)*                  id:balta-func-execute-1arg
+# *DBFunction#clear(*)                                     id:balta-func-clear
+# *DBFunctionWithPositionedParamsOnly#setParamNull(*)      id:balta-func-pos-setnull
 
 # DBConnection — second factory overload delegates to primary
-*DBConnection$#apply(Ljava/lang/String;*)               id:balta-dbconn-apply-str
+# *DBConnection$#apply(Ljava/lang/String;*)               id:balta-dbconn-apply-str
 
 # Params — factory-level addNull delegates (call add with NULL)
-*Params$#addNull(*)                                      id:balta-params-addnull
-*Params$NamedParams#pairs()                              id:balta-params-named-pairs
+# *Params$#addNull(*)                                      id:balta-params-addnull
+# *Params$NamedParams#pairs()                              id:balta-params-named-pairs
 
 # Postgres implicit class — single-call delegates
-*PostgresRow#get*(*)                                     id:balta-postgres-getters
+# *PostgresRow#get*(*)                                     id:balta-postgres-getters
 
 # SimpleJsonString — implicit conversion and param type factory
-*SimpleJsonString$#fromString(*)                         id:balta-sjs-fromstring
-*SimpleJsonString$ParamTypeSimpleJsonString#toQueryParamValue(*)  id:balta-sjs-paramtype
+# *SimpleJsonString$#fromString(*)                         id:balta-sjs-fromstring
+# *SimpleJsonString$ParamTypeSimpleJsonString#toQueryParamValue(*)  id:balta-sjs-paramtype
 
 # QueryParamType implicit objects — each returns new SimpleQueryParamValue / ObjectQueryParamValue
-*QueryParamType$QueryParamDouble#toQueryParamValue(*)    id:balta-qpt-double
-*QueryParamType$QueryParamFloat#toQueryParamValue(*)     id:balta-qpt-float
-*QueryParamType$QueryParamBigDecimal#toQueryParamValue(*) id:balta-qpt-bigdecimal
-*QueryParamType$QueryParamChar#toQueryParamValue(*)      id:balta-qpt-char
-*QueryParamType$QueryParamInstant#toQueryParamValue(*)   id:balta-qpt-instant
-*QueryParamType$QueryParamOffsetDateTime#toQueryParamValue(*) id:balta-qpt-offsetdatetime
-*QueryParamType$QueryParamLocalTime#toQueryParamValue(*) id:balta-qpt-localtime
-*QueryParamType$QueryParamLocalDate#toQueryParamValue(*) id:balta-qpt-localdate
-*QueryParamType$QueryParamUUID#toQueryParamValue(*)      id:balta-qpt-uuid
-*QueryParamType$QueryParamLong#toQueryParamValue(*)      id:balta-qpt-long
+# *QueryParamType$QueryParamDouble#toQueryParamValue(*)    id:balta-qpt-double
+# *QueryParamType$QueryParamFloat#toQueryParamValue(*)     id:balta-qpt-float
+# *QueryParamType$QueryParamBigDecimal#toQueryParamValue(*) id:balta-qpt-bigdecimal
+# *QueryParamType$QueryParamChar#toQueryParamValue(*)      id:balta-qpt-char
+# *QueryParamType$QueryParamInstant#toQueryParamValue(*)   id:balta-qpt-instant
+# *QueryParamType$QueryParamOffsetDateTime#toQueryParamValue(*) id:balta-qpt-offsetdatetime
+# *QueryParamType$QueryParamLocalTime#toQueryParamValue(*) id:balta-qpt-localtime
+# *QueryParamType$QueryParamLocalDate#toQueryParamValue(*) id:balta-qpt-localdate
+# *QueryParamType$QueryParamUUID#toQueryParamValue(*)      id:balta-qpt-uuid
+# *QueryParamType$QueryParamLong#toQueryParamValue(*)      id:balta-qpt-long
 
 # QueryParamValue — ObjectQueryParamValue constructor + assign accessor
-*ObjectQueryParamValue#assign(*)                         id:balta-qpv-obj-assign
-*ObjectQueryParamValue#assignFunc(*)                     id:balta-qpv-obj-assignfunc
+# *ObjectQueryParamValue#assign(*)                         id:balta-qpv-obj-assign
+# *ObjectQueryParamValue#assignFunc(*)                     id:balta-qpv-obj-assignfunc
 
 # PostgresObjectQueryParamValue — constructor + assign accessor
-*PostgresObjectQueryParamValue#assign(*)                 id:balta-pqpv-assign
-*PostgresObjectQueryParamValue#assignFunc(*)             id:balta-pqpv-assignfunc
+# *PostgresObjectQueryParamValue#assign(*)                 id:balta-pqpv-assign
+# *PostgresObjectQueryParamValue#assignFunc(*)             id:balta-pqpv-assignfunc
 
 # AsIsNaming / ExplicitNamingRequired — singleton implicit vals
-*AsIsNaming$Implicits$#namingConvention()                id:balta-asis-implicit
-*ExplicitNamingRequired$Implicits$#namingConvention()    id:balta-explicit-implicit
+# *AsIsNaming$Implicits$#namingConvention()                id:balta-asis-implicit
+# *ExplicitNamingRequired$Implicits$#namingConvention()    id:balta-explicit-implicit
 
 # NamingConvention — fromClassNamePerConvention(instance) delegates to Class overload
-*NamingConvention#fromClassNamePerConvention(Ljava/lang/Object;)* id:balta-naming-from-instance
+# *NamingConvention#fromClassNamePerConvention(Ljava/lang/Object;)* id:balta-naming-from-instance
 
 # OptionImplicits / MapImplicits — implicit class wrapper constructors (value class)
-*OptionImplicits$OptionEnhancements#<init>(*)            id:balta-opt-ctor
-*MapImplicits$MapEnhancements#<init>(*)                  id:balta-map-ctor
-*QueryResultRowImplicits$ProductTypeConvertor#<init>(*)  id:balta-qrri-ctor
-*Postgres$PostgresRow#<init>(*)                          id:balta-pgrow-ctor
+# *OptionImplicits$OptionEnhancements#<init>(*)            id:balta-opt-ctor
+# *MapImplicits$MapEnhancements#<init>(*)                  id:balta-map-ctor
+# *QueryResultRowImplicits$ProductTypeConvertor#<init>(*)  id:balta-qrri-ctor
+# *Postgres$PostgresRow#<init>(*)                          id:balta-pgrow-ctor
 
 # OptionImplicits / MapImplicits / QueryResultRowImplicits / Postgres — implicit class outer wrappers
-*OptionImplicits#<init>(*)                               id:balta-opt-outer
-*MapImplicits#<init>(*)                                  id:balta-map-outer
-*QueryResultRowImplicits#<init>(*)                       id:balta-qrri-outer
-*Postgres#<init>(*)                                      id:balta-pg-outer
+# *OptionImplicits#<init>(*)                               id:balta-opt-outer
+# *MapImplicits#<init>(*)                                  id:balta-map-outer
+# *QueryResultRowImplicits#<init>(*)                       id:balta-qrri-outer
+# *Postgres#<init>(*)                                      id:balta-pg-outer
 
 # LettersCase.convert — trivial identity/toLowerCase/toUpperCase
-*LettersCase$AsIs$#convert(*)                            id:balta-lc-asis
-*LettersCase$LowerCase$#convert(*)                       id:balta-lc-lower
-*LettersCase$UpperCase$#convert(*)                       id:balta-lc-upper
+# *LettersCase$AsIs$#convert(*)                            id:balta-lc-asis
+# *LettersCase$LowerCase$#convert(*)                       id:balta-lc-lower
+# *LettersCase$UpperCase$#convert(*)                       id:balta-lc-upper
 
 # QueryResult — Iterator trait mixin forwarders (no project logic)
 # QueryResult extends Iterator[QueryResultRow]; the compiler generates ~80 mixin
 # forwarders for inherited Iterator/TraversableOnce methods.  Only hasNext, next,
 # noMore, resultSetMetaData, and columnCount carry project logic (tested elsewhere).
-*QueryResult#to*(*)                                      id:balta-qr-iter-to
-*QueryResult#mk*(*)                                      id:balta-qr-iter-mk
-*QueryResult#addString(*)                                id:balta-qr-iter-addstr
-*QueryResult#copy*(*)                                    id:balta-qr-iter-copy
-*QueryResult#reduce*(*)                                  id:balta-qr-iter-reduce
-*QueryResult#fold*(*)                                    id:balta-qr-iter-fold
-*QueryResult#scan*(*)                                    id:balta-qr-iter-scan
-*QueryResult#zip*(*)                                     id:balta-qr-iter-zip
-*QueryResult#take*(*)                                    id:balta-qr-iter-take
-*QueryResult#drop*(*)                                    id:balta-qr-iter-drop
-*QueryResult#filter*(*)                                  id:balta-qr-iter-filter
-*QueryResult#collect*(*)                                 id:balta-qr-iter-collect
-*QueryResult#slice*(*)                                   id:balta-qr-iter-slice
-*QueryResult#index*(*)                                   id:balta-qr-iter-index
-*QueryResult#min*(*)                                     id:balta-qr-iter-min
-*QueryResult#max*(*)                                     id:balta-qr-iter-max
-*QueryResult#pad*(*)                                     id:balta-qr-iter-pad
-*QueryResult#for*(*)                                     id:balta-qr-iter-for
-*QueryResult#is*(*)                                      id:balta-qr-iter-is
-*QueryResult#size*(*)                                    id:balta-qr-iter-size
-*QueryResult#non*(*)                                     id:balta-qr-iter-non
-*QueryResult#map(*)                                      id:balta-qr-iter-map
-*QueryResult#flatMap(*)                                  id:balta-qr-iter-flatmap
-*QueryResult#find(*)                                     id:balta-qr-iter-find
-*QueryResult#contains(*)                                 id:balta-qr-iter-contains
-*QueryResult#count(*)                                    id:balta-qr-iter-count
-*QueryResult#corresponds(*)                              id:balta-qr-iter-corr
-*QueryResult#withFilter(*)                               id:balta-qr-iter-withfilter
-*QueryResult#partition(*)                                id:balta-qr-iter-partition
-*QueryResult#span(*)                                     id:balta-qr-iter-span
-*QueryResult#patch(*)                                    id:balta-qr-iter-patch
-*QueryResult#buffered(*)                                 id:balta-qr-iter-buffered
-*QueryResult#grouped(*)                                  id:balta-qr-iter-grouped
-*QueryResult#duplicate(*)                                id:balta-qr-iter-duplicate
-*QueryResult#sameElements(*)                             id:balta-qr-iter-same
-*QueryResult#$plus$plus(*)                               id:balta-qr-iter-plusplus
-*QueryResult#$div$colon(*)                               id:balta-qr-iter-divcolon
-*QueryResult#$colon$bslash(*)                            id:balta-qr-iter-colonbslash
-*QueryResult#aggregate(*)                                id:balta-qr-iter-aggregate
-*QueryResult#sum(*)                                      id:balta-qr-iter-sum
-*QueryResult#product(*)                                  id:balta-qr-iter-product
-*QueryResult#seq(*)                                      id:balta-qr-iter-seq
-*QueryResult#exists(*)                                   id:balta-qr-iter-exists
-*QueryResult#length(*)                                   id:balta-qr-iter-length
-*QueryResult#reversed(*)                                 id:balta-qr-iter-reversed
-*QueryResult#hasDefiniteSize(*)                          id:balta-qr-iter-defsize
+# *QueryResult#to*(*)                                      id:balta-qr-iter-to
+# *QueryResult#mk*(*)                                      id:balta-qr-iter-mk
+# *QueryResult#addString(*)                                id:balta-qr-iter-addstr
+# *QueryResult#copy*(*)                                    id:balta-qr-iter-copy
+# *QueryResult#reduce*(*)                                  id:balta-qr-iter-reduce
+# *QueryResult#fold*(*)                                    id:balta-qr-iter-fold
+# *QueryResult#scan*(*)                                    id:balta-qr-iter-scan
+# *QueryResult#zip*(*)                                     id:balta-qr-iter-zip
+# *QueryResult#take*(*)                                    id:balta-qr-iter-take
+# *QueryResult#drop*(*)                                    id:balta-qr-iter-drop
+# *QueryResult#filter*(*)                                  id:balta-qr-iter-filter
+# *QueryResult#collect*(*)                                 id:balta-qr-iter-collect
+# *QueryResult#slice*(*)                                   id:balta-qr-iter-slice
+# *QueryResult#index*(*)                                   id:balta-qr-iter-index
+# *QueryResult#min*(*)                                     id:balta-qr-iter-min
+# *QueryResult#max*(*)                                     id:balta-qr-iter-max
+# *QueryResult#pad*(*)                                     id:balta-qr-iter-pad
+# *QueryResult#for*(*)                                     id:balta-qr-iter-for
+# *QueryResult#is*(*)                                      id:balta-qr-iter-is
+# *QueryResult#size*(*)                                    id:balta-qr-iter-size
+# *QueryResult#non*(*)                                     id:balta-qr-iter-non
+# *QueryResult#map(*)                                      id:balta-qr-iter-map
+# *QueryResult#flatMap(*)                                  id:balta-qr-iter-flatmap
+# *QueryResult#find(*)                                     id:balta-qr-iter-find
+# *QueryResult#contains(*)                                 id:balta-qr-iter-contains
+# *QueryResult#count(*)                                    id:balta-qr-iter-count
+# *QueryResult#corresponds(*)                              id:balta-qr-iter-corr
+# *QueryResult#withFilter(*)                               id:balta-qr-iter-withfilter
+# *QueryResult#partition(*)                                id:balta-qr-iter-partition
+# *QueryResult#span(*)                                     id:balta-qr-iter-span
+# *QueryResult#patch(*)                                    id:balta-qr-iter-patch
+# *QueryResult#buffered(*)                                 id:balta-qr-iter-buffered
+# *QueryResult#grouped(*)                                  id:balta-qr-iter-grouped
+# *QueryResult#duplicate(*)                                id:balta-qr-iter-duplicate
+# *QueryResult#sameElements(*)                             id:balta-qr-iter-same
+# *QueryResult#$plus$plus(*)                               id:balta-qr-iter-plusplus
+# *QueryResult#$div$colon(*)                               id:balta-qr-iter-divcolon
+# *QueryResult#$colon$bslash(*)                            id:balta-qr-iter-colonbslash
+# *QueryResult#aggregate(*)                                id:balta-qr-iter-aggregate
+# *QueryResult#sum(*)                                      id:balta-qr-iter-sum
+# *QueryResult#product(*)                                  id:balta-qr-iter-product
+# *QueryResult#seq(*)                                      id:balta-qr-iter-seq
+# *QueryResult#exists(*)                                   id:balta-qr-iter-exists
+# *QueryResult#length(*)                                   id:balta-qr-iter-length
+# *QueryResult#reversed(*)                                 id:balta-qr-iter-reversed
+# *QueryResult#hasDefiniteSize(*)                          id:balta-qr-iter-defsize
 
 # Value class body methods — never boxed at runtime; compiler always uses static extensions
 # Filtering the boxed-path class methods (excluding ctor/hashCode/equals already filtered globally)
-*MapImplicits$MapEnhancements#map(*)                     id:balta-valclass-me-map
-*MapImplicits$MapEnhancements#getOrThrow(*)              id:balta-valclass-me-got
-*OptionImplicits$OptionEnhancements#option(*)             id:balta-valclass-oe-opt
-*OptionImplicits$OptionEnhancements#getOrThrow(*)         id:balta-valclass-oe-got
-*OptionImplicits$OptionEnhancements#$at$eq(*)             id:balta-valclass-oe-ateq
-*QueryResultRowImplicits$ProductTypeConvertor#row(*)      id:balta-valclass-ptc-row
-*QueryResultRowImplicits$ProductTypeConvertor#toProductType(*) id:balta-valclass-ptc-tpt
-*Postgres$PostgresRow#row(*)                              id:balta-valclass-pg-row
-*Postgres$PostgresRow#getSimpleJsonString(*)              id:balta-valclass-pg-gsjs
-*Postgres$PostgresRow#getSJSArray(*)                      id:balta-valclass-pg-gsja
-*Postgres$PostgresRow#simpleJsonStringTransformer(*)      id:balta-valclass-pg-sjst
+# *MapImplicits$MapEnhancements#map(*)                     id:balta-valclass-me-map
+# *MapImplicits$MapEnhancements#getOrThrow(*)              id:balta-valclass-me-got
+# *OptionImplicits$OptionEnhancements#option(*)             id:balta-valclass-oe-opt
+# *OptionImplicits$OptionEnhancements#getOrThrow(*)         id:balta-valclass-oe-got
+# *OptionImplicits$OptionEnhancements#$at$eq(*)             id:balta-valclass-oe-ateq
+# *QueryResultRowImplicits$ProductTypeConvertor#row(*)      id:balta-valclass-ptc-row
+# *QueryResultRowImplicits$ProductTypeConvertor#toProductType(*) id:balta-valclass-ptc-tpt
+# *Postgres$PostgresRow#row(*)                              id:balta-valclass-pg-row
+# *Postgres$PostgresRow#getSimpleJsonString(*)              id:balta-valclass-pg-gsjs
+# *Postgres$PostgresRow#getSJSArray(*)                      id:balta-valclass-pg-gsja
+# *Postgres$PostgresRow#simpleJsonStringTransformer(*)      id:balta-valclass-pg-sjst
 
 # ObjectQueryParamValue — trait-mixin defaults (return "?" and "=", no project logic)
-*ObjectQueryParamValue#sqlEntry(*)                       id:balta-qpv-obj-sqlentry
-*ObjectQueryParamValue#equalityOperator(*)               id:balta-qpv-obj-eqop
-*ObjectQueryParamValue#<init>(*)                         id:balta-qpv-obj-init
+# *ObjectQueryParamValue#sqlEntry(*)                       id:balta-qpv-obj-sqlentry
+# *ObjectQueryParamValue#equalityOperator(*)               id:balta-qpv-obj-eqop
+# *ObjectQueryParamValue#<init>(*)                         id:balta-qpv-obj-init
 
 # PostgresObjectQueryParamValue — trait-mixin defaults and constructor
-*PostgresObjectQueryParamValue#sqlEntry(*)               id:balta-pqpv-sqlentry
-*PostgresObjectQueryParamValue#equalityOperator(*)       id:balta-pqpv-eqop
-*PostgresObjectQueryParamValue#<init>(*)                 id:balta-pqpv-init
+# *PostgresObjectQueryParamValue#sqlEntry(*)               id:balta-pqpv-sqlentry
+# *PostgresObjectQueryParamValue#equalityOperator(*)       id:balta-pqpv-eqop
+# *PostgresObjectQueryParamValue#<init>(*)                 id:balta-pqpv-init
 
 # DBConnection — value class body (wraps java.sql.Connection; never boxed)
-*DBConnection#connection(*)                              id:balta-dbconn-val
-*DBConnection#<init>(*)                                  id:balta-dbconn-init
-*DBConnection#hashCode(*)                                id:balta-dbconn-hash
-*DBConnection#equals(*)                                  id:balta-dbconn-eq
+# *DBConnection#connection(*)                              id:balta-dbconn-val
+# *DBConnection#<init>(*)                                  id:balta-dbconn-init
+# *DBConnection#hashCode(*)                                id:balta-dbconn-hash
+# *DBConnection#equals(*)                                  id:balta-dbconn-eq
 
 # DBConnection$ companion — primary apply has DriverManager logic (boundary);
 # filters only the trivial methods (boundary factory not unit-testable without DB)
-*DBConnection$#apply(*)                                  id:balta-dbconn-apply
+# *DBConnection$#apply(*)                                  id:balta-dbconn-apply
 
 # Implicit wrapper parent objects — outer object with only the implicit class definition
-*MapImplicits#*(*)                                       id:balta-map-outer-all
-*OptionImplicits#*(*)                                    id:balta-opt-outer-all
-*QueryResultRowImplicits#*(*)                            id:balta-qrri-outer-all
-*Postgres#*(*)                                           id:balta-pg-outer-all
+# *MapImplicits#*(*)                                       id:balta-map-outer-all
+# *OptionImplicits#*(*)                                    id:balta-opt-outer-all
+# *QueryResultRowImplicits#*(*)                            id:balta-qrri-outer-all
+# *Postgres#*(*)                                           id:balta-pg-outer-all
 
 # SimpleJsonString — value class body (wraps String; never boxed)
-*SimpleJsonString#value(*)                               id:balta-sjs-value
-*SimpleJsonString#<init>(*)                              id:balta-sjs-init
+# *SimpleJsonString#value(*)                               id:balta-sjs-value
+# *SimpleJsonString#<init>(*)                              id:balta-sjs-init
 
 # Static companion forwarders — compiler-generated single-call delegates on main class
 # Each static method on FooClass forwards to FooClass$.MODULE$.method()
-*DBConnection#apply(*)                                   id:balta-dbconn-apply-fwd
-*DBConnection#dbConnectionToJdbcConnection(*)            id:balta-dbconn-impl-fwd
-*DBTestSuite#persistDataOverride()                       id:balta-suite-persist
-*DBTestSuite#connectionInfoFromResourceConfig(*)         id:balta-suite-configfwd
-*QueryResultRow#createExtractors(*)                      id:balta-row-extractors-fwd
-*QueryResultRow#fieldNamesFromMetadata(*)                id:balta-row-fieldnames-fwd
-*NamingException#message(*)                              id:balta-naming-exc-msg
-*NamingException#apply(*)                                id:balta-naming-exc-apply
-*MapBasedNaming#apply(*)                                 id:balta-mapnaming-apply-fwd
-*DBFunction#apply(*)                                     id:balta-dbfunc-apply-fwd
-*DBTable#apply(*)                                        id:balta-dbtable-apply-fwd
-*Params#add(*)                                           id:balta-params-add-fwd
-*Params#addNull(*)                                       id:balta-params-addnull-fwd
-*SimpleJsonString#apply(*)                               id:balta-sjs-apply-fwd
-*SimpleJsonString#fromString(*)                          id:balta-sjs-fromstring-fwd
+# *DBConnection#apply(*)                                   id:balta-dbconn-apply-fwd
+# *DBConnection#dbConnectionToJdbcConnection(*)            id:balta-dbconn-impl-fwd
+# *DBTestSuite#persistDataOverride()                       id:balta-suite-persist
+# *DBTestSuite#connectionInfoFromResourceConfig(*)         id:balta-suite-configfwd
+# *QueryResultRow#createExtractors(*)                      id:balta-row-extractors-fwd
+# *QueryResultRow#fieldNamesFromMetadata(*)                id:balta-row-fieldnames-fwd
+# *NamingException#message(*)                              id:balta-naming-exc-msg
+# *NamingException#apply(*)                                id:balta-naming-exc-apply
+# *MapBasedNaming#apply(*)                                 id:balta-mapnaming-apply-fwd
+# *DBFunction#apply(*)                                     id:balta-dbfunc-apply-fwd
+# *DBTable#apply(*)                                        id:balta-dbtable-apply-fwd
+# *Params#add(*)                                           id:balta-params-add-fwd
+# *Params#addNull(*)                                       id:balta-params-addnull-fwd
+# *SimpleJsonString#apply(*)                               id:balta-sjs-apply-fwd
+# *SimpleJsonString#fromString(*)                          id:balta-sjs-fromstring-fwd
 
 # Trait mixin forwarders — implementing class calls trait default method (no own logic)
-*MapBasedNaming#fromClassNamePerConvention(*)            id:balta-mapnaming-fromclass
-*ExplicitNamingRequired#fromClassNamePerConvention(*)    id:balta-explicit-fromclass
-*AsIsNaming#fromClassNamePerConvention(*)                id:balta-asis-fromclass
+# *MapBasedNaming#fromClassNamePerConvention(*)            id:balta-mapnaming-fromclass
+# *ExplicitNamingRequired#fromClassNamePerConvention(*)    id:balta-explicit-fromclass
+# *AsIsNaming#fromClassNamePerConvention(*)                id:balta-asis-fromclass
 
 # Private field accessors — compiler-generated single-return methods
-*QueryResultRow#fields()                                 id:balta-row-fields
-*QueryResultRow#columnLabels()                           id:balta-row-columnlabels
-*AsIsNaming#lettersCase(*)                               id:balta-asis-letterscase
+# *QueryResultRow#fields()                                 id:balta-row-fields
+# *QueryResultRow#columnLabels()                           id:balta-row-columnlabels
+# *AsIsNaming#lettersCase(*)                               id:balta-asis-letterscase
 
 # Params abstract class — instance methods are single-call delegates to ListMap
-*Params#values(*)                                        id:balta-params-values
-*Params#apply(*)                                         id:balta-params-apply
-*Params#size(*)                                          id:balta-params-size
-*Params#<init>(*)                                        id:balta-params-init
+# *Params#values(*)                                        id:balta-params-values
+# *Params#apply(*)                                         id:balta-params-apply
+# *Params#size(*)                                          id:balta-params-size
+# *Params#<init>(*)                                        id:balta-params-init
 
 # DBTestSuite#now — boundary method (SQL query, can't unit test without DB)
-*DBTestSuite#now(*)                                      id:balta-suite-now
+# *DBTestSuite#now(*)                                      id:balta-suite-now
 
 # DBTestSuite — lazy val computation (boundary: calls DriverManager.getConnection)
-*DBTestSuite#dbConnection$lzycompute(*)                  id:balta-suite-dbconn-lazy
+# *DBTestSuite#dbConnection$lzycompute(*)                  id:balta-suite-dbconn-lazy
 
 # DBTestSuite — test() override wraps testFun in a lambda + delegates to super.test()
 # The try/finally/commit/rollback logic lives in the $anonfun$test$1 synthetic (already filtered).
 # The test() method itself contains only closure creation + super.test() call — a delegation wrapper.
-*DBTestSuite#test(*)                                     id:balta-suite-test
+# *DBTestSuite#test(*)                                     id:balta-suite-test
 
 # DBTestSuite — constructor (Lscala/Option;) overload — sets fields, calls super
-*DBTestSuite#<init>(Lscala/Option;)*                     id:balta-suite-ctor-opt
+# *DBTestSuite#<init>(Lscala/Option;)*                     id:balta-suite-ctor-opt
 
 # DBTestSuite — connectionInfo lazy val accessor (compiler-generated check + delegate)
-*DBTestSuite#connectionInfo(*)                           id:balta-suite-conninfo
+# *DBTestSuite#connectionInfo(*)                           id:balta-suite-conninfo
 
 # ProductTypeConvertor value class body — private helpers (never boxed at runtime)
-*QueryResultRowImplicits$ProductTypeConvertor#getConstructor(*)    id:balta-valclass-ptc-gc
-*QueryResultRowImplicits$ProductTypeConvertor#getConstructorMirror(*)  id:balta-valclass-ptc-gcm
-*QueryResultRowImplicits$ProductTypeConvertor#readParamsFromRow(*)  id:balta-valclass-ptc-rpr
-*QueryResultRowImplicits$ProductTypeConvertor#getParamValue(*)     id:balta-valclass-ptc-gpv
+# *QueryResultRowImplicits$ProductTypeConvertor#getConstructor(*)    id:balta-valclass-ptc-gc
+# *QueryResultRowImplicits$ProductTypeConvertor#getConstructorMirror(*)  id:balta-valclass-ptc-gcm
+# *QueryResultRowImplicits$ProductTypeConvertor#readParamsFromRow(*)  id:balta-valclass-ptc-rpr
+# *QueryResultRowImplicits$ProductTypeConvertor#getParamValue(*)     id:balta-valclass-ptc-gpv
 
 # SimpleJsonString$ParamTypeSimpleJsonString$ companion — single new() call
-*SimpleJsonString$ParamTypeSimpleJsonString$#toQueryParamValue(*)  id:balta-sjs-ptsjs-tqpv
+# *SimpleJsonString$ParamTypeSimpleJsonString$#toQueryParamValue(*)  id:balta-sjs-ptsjs-tqpv
 
 # PostgresObjectQueryParamValue — private field accessor
-*PostgresQueryParamValue$PostgresObjectQueryParamValue#pgObject(*) id:balta-pqpv-pgobj
+# *PostgresQueryParamValue$PostgresObjectQueryParamValue#pgObject(*) id:balta-pqpv-pgobj
 
 # DBFunction$DBFunctionWithNamedParamsToo — case class field accessor
-*DBFunction$DBFunctionWithNamedParamsToo#functionName(*) id:balta-func-named-funcname
+# *DBFunction$DBFunctionWithNamedParamsToo#functionName(*) id:balta-func-named-funcname
 
 # ConnectionInfo — static apply forwarder on main class (delegates to ConnectionInfo$.apply)
-*ConnectionInfo#apply(*)                                 id:balta-conninfo-apply
+# *ConnectionInfo#apply(*)                                 id:balta-conninfo-apply
 
 # QueryResult — missed Iterator mixin forwarder
-*QueryResult#sliding(*)                                  id:balta-qr-iter-sliding
+# *QueryResult#sliding(*)                                  id:balta-qr-iter-sliding
 
 # QueryResultRow$ — timeTzExtractor: private extractor used only when column type is timetz
 # Exercised through integration tests with the actual DB; not unit-testable.
-*QueryResultRow$#timeTzExtractor$1(*)                    id:balta-row-timetz-ext
+# *QueryResultRow$#timeTzExtractor$1(*)                    id:balta-row-timetz-ext
 
 # DBTable — boundary methods (fieldValue/count need DB connection for SQL execution)
-*DBTable#fieldValue(*)                                   id:balta-dbtable-fieldvalue
-*DBTable#count(*)                                        id:balta-dbtable-count
+# *DBTable#fieldValue(*)                                   id:balta-dbtable-fieldvalue
+# *DBTable#count(*)                                        id:balta-dbtable-count
 
 # DBFunction — execute(String, verify) partially covered; uncovered branch is empty-orderBy path
-*DBFunction#execute(Ljava/lang/String;*)*                id:balta-func-execute-orderby
+# *DBFunction#execute(Ljava/lang/String;*)*                id:balta-func-execute-orderby
diff --git a/project/plugins.sbt b/project/plugins.sbt
index c6aa8e6..426feed 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,3 +1,3 @@
 lazy val sbtCiReleaseVersion = "1.11.2"
 
-addSbtPlugin("io.github.moranaapps" % "jacoco-method-filter-sbt" % "2.0.1")
+addSbtPlugin("io.github.moranaapps" % "jacoco-method-filter-sbt" % "2.1.0")

From ddf5af6b1d56f8227f9055db6a8e6cb8763784a4 Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 21 Apr 2026 10:31:24 +0200
Subject: [PATCH 07/13] Update jacoco-method-filter plugin version to 2.1.1;
 add JMF report configuration in build.sbt

---
 build.sbt           |   2 +
 jmf-rules.txt       | 413 +++++++++++---------------------------------
 project/plugins.sbt |   2 +-
 3 files changed, 101 insertions(+), 316 deletions(-)

diff --git a/build.sbt b/build.sbt
index fac35c2..9b9abac 100644
--- a/build.sbt
+++ b/build.sbt
@@ -38,4 +38,6 @@ lazy val balta = (project in file("balta"))
     ),
     crossScalaVersions := supportedScalaVersions,
     libraryDependencies ++= libDependencies,
+    jmfReportFile   := Some(target.value / "jmf-report.json"),
+    jmfReportFormat := "json",
   )
diff --git a/jmf-rules.txt b/jmf-rules.txt
index 14dbe27..a8adfec 100644
--- a/jmf-rules.txt
+++ b/jmf-rules.txt
@@ -38,14 +38,18 @@
 *#curried()                                             id:case-curried
 *#toString()                                            id:case-tostring
 # Scala 2.13+ case class boilerplate — safe to enable; no-op in 2.11/2.12
-*#productElementName(*)                                 id:case-prod-element-name
-*#productElementNames()                                 id:case-prod-element-names
+# Note: unmatched
+#*#productElementName(*)                                 id:case-prod-element-name
+#*#productElementNames()                                 id:case-prod-element-names
 # WARNING: may collide with domain methods named `name` — rescue with + include rule if needed
-*#name()                                                id:case-name
+# Note: unmatched
+#*#name()                                                id:case-name
 # WARNING: may collide with domain methods named `groups` — rescue with + include rule if needed
-*#groups()                                              id:case-groups
+# Note: unmatched
+#*#groups()                                              id:case-groups
 # WARNING: may collide with domain methods named `optionalAttributes` — rescue with + include rule if needed
-*#optionalAttributes()                                  id:case-optionalAttributes
+# Note: unmatched
+#*#optionalAttributes()                                  id:case-optionalAttributes
 
 # Companion objects, constructors, and static definitions
 *$#<init>(*)                                            id:gen-ctor
@@ -60,11 +64,13 @@
 # Java serialization hook — compiler-generated on the case class itself (not the companion)
 # Body is a single expression returning a serialization proxy; no project logic.
 # WARNING: if a class overrides writeReplace with custom logic, rescue with + include rule.
-*#writeReplace(*)                                       id:case-writereplace
+# Note: unmatched
+#*#writeReplace(*)                                       id:case-writereplace
 
 # anonymous class created by a macro expansion
-*$macro$*#$anonfun$inst$macro$*                         id:macro-inst
-*$macro$*#inst$macro$*                                  id:macro-inst
+# Note: unmatched
+#*$macro$*#$anonfun$inst$macro$*                         id:macro-inst
+#*$macro$*#inst$macro$*                                  id:macro-inst
 
 # lambda
 *#*  synthetic name-contains:$anonfun$                  id:scala-anonfun
@@ -130,312 +136,89 @@
 # ─────────────────────────────────────────────────────────────────────────────
 # PROJECT RULES
 # ─────────────────────────────────────────────────────────────────────────────
-# Deprecated single-call delegates: setParamNull / addNull instance methods
-# Each method body is a single call to the non-deprecated replacement.
-# A unit test would only re-test the replacement method; no assurance is added.
-# Note: Params$ companion factory addNull methods are NOT filtered — they contain logic.
-# *#setParamNull(*)                                       id:balta-deprecated-setnull
-# *Params$NamedParams#addNull(*)                           id:balta-deprecated-addnull-named
-# *Params$OrderedParams#addNull(*)                         id:balta-deprecated-addnull-ordered
-# *DBTestSuite#addNull(*)                                  id:balta-deprecated-addnull-suite
 
-# One-liner factory wrappers in DBTestSuite
-# Each method is a single constructor call delegating to DBTable / DBFunction with no logic of its own.
-# *DBTestSuite#table(*)                                    id:balta-factory-table
-# *DBTestSuite#function(*)                                 id:balta-factory-function
+*DBFunction#perform(*)                                   id:balta-func-perform
+*DBFunction#getResult(*)                                 id:balta-func-getresult
+*DBFunction#execute(Ljava/lang/String;*)*                id:balta-func-execute-orderby
+
+*DBConnection$#apply(Ljava/lang/String;*)               id:balta-dbconn-apply-str
+*DBConnection#connection(*)                              id:balta-dbconn-val
+*DBConnection#<init>(*)                                  id:balta-dbconn-init
+*DBConnection#dbConnectionToJdbcConnection(*)            id:balta-dbconn-impl-fwd
+
+*QueryResult#mk*(*)                                      id:balta-qr-iter-mk
+*QueryResult#addString(*)                                id:balta-qr-iter-addstr
+*QueryResult#copy*(*)                                    id:balta-qr-iter-copy
+*QueryResult#reduce*(*)                                  id:balta-qr-iter-reduce
+*QueryResult#fold*(*)                                    id:balta-qr-iter-fold
+*QueryResult#scan*(*)                                    id:balta-qr-iter-scan
+*QueryResult#zip*(*)                                     id:balta-qr-iter-zip
+*QueryResult#take*(*)                                    id:balta-qr-iter-take
+*QueryResult#drop*(*)                                    id:balta-qr-iter-drop
+*QueryResult#filter*(*)                                  id:balta-qr-iter-filter
+*QueryResult#collect*(*)                                 id:balta-qr-iter-collect
+*QueryResult#slice*(*)                                   id:balta-qr-iter-slice
+*QueryResult#index*(*)                                   id:balta-qr-iter-index
+*QueryResult#min*(*)                                     id:balta-qr-iter-min
+*QueryResult#max*(*)                                     id:balta-qr-iter-max
+*QueryResult#pad*(*)                                     id:balta-qr-iter-pad
+*QueryResult#for*(*)                                     id:balta-qr-iter-for
+*QueryResult#is*(*)                                      id:balta-qr-iter-is
+*QueryResult#size*(*)                                    id:balta-qr-iter-size
+*QueryResult#non*(*)                                     id:balta-qr-iter-non
+*QueryResult#map(*)                                      id:balta-qr-iter-map
+*QueryResult#flatMap(*)                                  id:balta-qr-iter-flatmap
+*QueryResult#find(*)                                     id:balta-qr-iter-find
+*QueryResult#contains(*)                                 id:balta-qr-iter-contains
+*QueryResult#count(*)                                    id:balta-qr-iter-count
+*QueryResult#corresponds(*)                              id:balta-qr-iter-corr
+*QueryResult#withFilter(*)                               id:balta-qr-iter-withfilter
+*QueryResult#partition(*)                                id:balta-qr-iter-partition
+*QueryResult#span(*)                                     id:balta-qr-iter-span
+*QueryResult#patch(*)                                    id:balta-qr-iter-patch
+*QueryResult#buffered(*)                                 id:balta-qr-iter-buffered
+*QueryResult#grouped(*)                                  id:balta-qr-iter-grouped
+*QueryResult#duplicate(*)                                id:balta-qr-iter-duplicate
+*QueryResult#sameElements(*)                             id:balta-qr-iter-same
+*QueryResult#$plus$plus(*)                               id:balta-qr-iter-plusplus
+*QueryResult#$div$colon(*)                               id:balta-qr-iter-divcolon
+*QueryResult#$colon$bslash(*)                            id:balta-qr-iter-colonbslash
+*QueryResult#aggregate(*)                                id:balta-qr-iter-aggregate
+*QueryResult#sum(*)                                      id:balta-qr-iter-sum
+*QueryResult#product(*)                                  id:balta-qr-iter-product
+*QueryResult#exists(*)                                   id:balta-qr-iter-exists
+*QueryResult#length(*)                                   id:balta-qr-iter-length
+*QueryResult#reversed(*)                                 id:balta-qr-iter-reversed
+*QueryResult#hasDefiniteSize(*)                          id:balta-qr-iter-defsize
+*QueryResult#toArray(*)                                  id:balta-qr-iter-toarray
+*QueryResult#toMap(*)                                    id:balta-qr-iter-tomap
+*QueryResult#toTraversable(*)                            id:balta-qr-iter-totraversable
+*QueryResult#toIterator(*)                               id:balta-qr-iter-toiterator
+*QueryResult#toStream(*)                                 id:balta-qr-iter-tostream
+*QueryResult#toIterable(*)                               id:balta-qr-iter-toiterable
+*QueryResult#toSeq(*)                                    id:balta-qr-iter-toseq
+*QueryResult#toIndexedSeq(*)                             id:balta-qr-iter-toindexedseq
+*QueryResult#toBuffer(*)                                 id:balta-qr-iter-tobuffer
+*QueryResult#toSet(*)                                    id:balta-qr-iter-toset
+*QueryResult#toVector(*)                                 id:balta-qr-iter-tovector
+*QueryResult#sliding(*)                                  id:balta-qr-iter-sliding
+
+*QueryResultRowImplicits$ProductTypeConvertor#row(*)        id:balta-valclass-ptc-row
+*QueryResultRowImplicits$ProductTypeConvertor#toProductType(*) id:balta-valclass-ptc-tpt
+
+*QueryResultRow#createExtractors(*)                        id:balta-row-extractors-fwd
+*QueryResultRow#fieldNamesFromMetadata(*)                  id:balta-row-fieldnames-fwd
+*QueryResultRow#getChar(*)*                                 id:balta-colname-get-char
+*QueryResultRow#getObject(*)*                               id:balta-colname-get-char
+*QueryResultRow#getAs(Ljava/lang/String;Lscala/Function1;)* id:balta-colname-getas-transformer
+
+*QueryResultRowImplicits$ProductTypeConvertor#<init>(*)    id:balta-qrri-ctor
+*QueryResultRowImplicits$ProductTypeConvertor#getConstructor(*)      id:balta-valclass-ptc-gc
+*QueryResultRowImplicits$ProductTypeConvertor#getConstructorMirror(*) id:balta-valclass-ptc-gcm
+*QueryResultRowImplicits$ProductTypeConvertor#readParamsFromRow(*)    id:balta-valclass-ptc-rpr
+*QueryResultRowImplicits$ProductTypeConvertor#getParamValue(*)        id:balta-valclass-ptc-gpv
+
+*DBTable#fieldValue(*)                                   id:balta-dbtable-fieldvalue
+*DBTable#count(Lza/co/absa/db/balta/classes/inner/Params$NamedParams;Ljava/sql/Connection;)* id:balta-dbtable-count-named
+*DBTable#count(Ljava/lang/String;Ljava/sql/Connection;)*  id:balta-dbtable-count-str
 
-# Trivial implicit conversion: DBConnection → JDBC Connection
-# Entire body returns in.connection; no branching or transformation; a test would only assert identity.
-# *DBConnection$#dbConnectionToJdbcConnection(*)           id:balta-implicit-dbconn
-
-# columnLabel: String overloads in QueryResultRow — pure label-resolution delegates
-# Each overload resolves the column label to an index via columnNumber(label) then forwards to the
-# Int-based overload. The Int-based overloads hold the extraction logic and are covered by integration tests.
-# apply(String) and the 2-param getAs(String, transformer) follow the same delegation pattern.
-# NOTE: JMF descriptors must use JVM format — (Ljava/lang/String;)* not (java.lang.String).
-# *QueryResultRow#get*(Ljava/lang/String;)*                id:balta-colname-getter
-# *QueryResultRow#getAs(Ljava/lang/String;Lscala/Function1;)* id:balta-colname-getas-transformer
-# *QueryResultRow#apply(Ljava/lang/String;)*               id:balta-colname-apply
-
-# QueryResult#noMore — trivial negation of hasNext
-# Body is exactly `!hasNext`; testing it adds no assurance beyond the hasNext unit tests.
-# *QueryResult#noMore()                                    id:balta-nomore
-
-# QueryResult#resultSetMetaData — implicit field accessor (public val)
-# Scala compiles a public val to a 0-arg getter that returns the backing field.
-# No logic; a test would only assert identity of what was passed to the constructor.
-# *QueryResult#resultSetMetaData()                         id:balta-resultsetmetadata-accessor
-
-# QueryResult#columnCount — public val backed by metaData.getColumnCount
-# Scala val getter; no logic.
-# *QueryResult#columnCount()                               id:balta-columncount-accessor
-
-# QueryResultRow field accessors and single-call getters
-# *QueryResultRow#rowNumber()                              id:balta-row-rownumber
-# *QueryResultRow#columnCount()                            id:balta-row-columncount
-# NOTE: JMF descriptors must use JVM format.  (I)* matches single-int-param overloads.
-# *QueryResultRow#apply(I)*                                id:balta-row-apply-int
-# *QueryResultRow#getObject(I)*                            id:balta-row-getobject-int
-# *QueryResultRow#getObject(Ljava/lang/String;)*           id:balta-row-getobject-str
-# *QueryResultRow#getAs(I)*                                id:balta-row-getas-int
-# *QueryResultRow#getBoolean(I)*                           id:balta-row-getboolean-int
-# *QueryResultRow#getString(I)*                            id:balta-row-getstring-int
-# *QueryResultRow#getInt(I)*                               id:balta-row-getint-int
-# *QueryResultRow#getLong(I)*                              id:balta-row-getlong-int
-# *QueryResultRow#getDouble(I)*                            id:balta-row-getdouble-int
-# *QueryResultRow#getFloat(I)*                             id:balta-row-getfloat-int
-# *QueryResultRow#getBigDecimal(I)*                        id:balta-row-getbigdecimal-int
-# *QueryResultRow#getTime(I)*                              id:balta-row-gettime-int
-# *QueryResultRow#getDate(I)*                              id:balta-row-getdate-int
-# *QueryResultRow#getLocalDateTime(I)*                     id:balta-row-getlocaldatetime-int
-# *QueryResultRow#getOffsetDateTime(I)*                    id:balta-row-getoffsetdatetime-int
-# *QueryResultRow#getInstant(I)*                           id:balta-row-getinstant-int
-# *QueryResultRow#getUUID(I)*                              id:balta-row-getuuid-int
-
-# DBTestSuite — single-call delegates to Params
-# *DBTestSuite#add(*)                                      id:balta-suite-add
-# *DBTestSuite#<init>(Z)*                                  id:balta-suite-ctor-bool
-# *DBTestSuite#dbConnection()                              id:balta-suite-dbconn
-
-# DBFunction — single-call overloads and factories
-# *DBFunction#perform(*)                                   id:balta-func-perform
-# *DBFunction#getResult(*)                                 id:balta-func-getresult
-# *DBFunction#execute(Lscala/Function1;)*                  id:balta-func-execute-1arg
-# *DBFunction#clear(*)                                     id:balta-func-clear
-# *DBFunctionWithPositionedParamsOnly#setParamNull(*)      id:balta-func-pos-setnull
-
-# DBConnection — second factory overload delegates to primary
-# *DBConnection$#apply(Ljava/lang/String;*)               id:balta-dbconn-apply-str
-
-# Params — factory-level addNull delegates (call add with NULL)
-# *Params$#addNull(*)                                      id:balta-params-addnull
-# *Params$NamedParams#pairs()                              id:balta-params-named-pairs
-
-# Postgres implicit class — single-call delegates
-# *PostgresRow#get*(*)                                     id:balta-postgres-getters
-
-# SimpleJsonString — implicit conversion and param type factory
-# *SimpleJsonString$#fromString(*)                         id:balta-sjs-fromstring
-# *SimpleJsonString$ParamTypeSimpleJsonString#toQueryParamValue(*)  id:balta-sjs-paramtype
-
-# QueryParamType implicit objects — each returns new SimpleQueryParamValue / ObjectQueryParamValue
-# *QueryParamType$QueryParamDouble#toQueryParamValue(*)    id:balta-qpt-double
-# *QueryParamType$QueryParamFloat#toQueryParamValue(*)     id:balta-qpt-float
-# *QueryParamType$QueryParamBigDecimal#toQueryParamValue(*) id:balta-qpt-bigdecimal
-# *QueryParamType$QueryParamChar#toQueryParamValue(*)      id:balta-qpt-char
-# *QueryParamType$QueryParamInstant#toQueryParamValue(*)   id:balta-qpt-instant
-# *QueryParamType$QueryParamOffsetDateTime#toQueryParamValue(*) id:balta-qpt-offsetdatetime
-# *QueryParamType$QueryParamLocalTime#toQueryParamValue(*) id:balta-qpt-localtime
-# *QueryParamType$QueryParamLocalDate#toQueryParamValue(*) id:balta-qpt-localdate
-# *QueryParamType$QueryParamUUID#toQueryParamValue(*)      id:balta-qpt-uuid
-# *QueryParamType$QueryParamLong#toQueryParamValue(*)      id:balta-qpt-long
-
-# QueryParamValue — ObjectQueryParamValue constructor + assign accessor
-# *ObjectQueryParamValue#assign(*)                         id:balta-qpv-obj-assign
-# *ObjectQueryParamValue#assignFunc(*)                     id:balta-qpv-obj-assignfunc
-
-# PostgresObjectQueryParamValue — constructor + assign accessor
-# *PostgresObjectQueryParamValue#assign(*)                 id:balta-pqpv-assign
-# *PostgresObjectQueryParamValue#assignFunc(*)             id:balta-pqpv-assignfunc
-
-# AsIsNaming / ExplicitNamingRequired — singleton implicit vals
-# *AsIsNaming$Implicits$#namingConvention()                id:balta-asis-implicit
-# *ExplicitNamingRequired$Implicits$#namingConvention()    id:balta-explicit-implicit
-
-# NamingConvention — fromClassNamePerConvention(instance) delegates to Class overload
-# *NamingConvention#fromClassNamePerConvention(Ljava/lang/Object;)* id:balta-naming-from-instance
-
-# OptionImplicits / MapImplicits — implicit class wrapper constructors (value class)
-# *OptionImplicits$OptionEnhancements#<init>(*)            id:balta-opt-ctor
-# *MapImplicits$MapEnhancements#<init>(*)                  id:balta-map-ctor
-# *QueryResultRowImplicits$ProductTypeConvertor#<init>(*)  id:balta-qrri-ctor
-# *Postgres$PostgresRow#<init>(*)                          id:balta-pgrow-ctor
-
-# OptionImplicits / MapImplicits / QueryResultRowImplicits / Postgres — implicit class outer wrappers
-# *OptionImplicits#<init>(*)                               id:balta-opt-outer
-# *MapImplicits#<init>(*)                                  id:balta-map-outer
-# *QueryResultRowImplicits#<init>(*)                       id:balta-qrri-outer
-# *Postgres#<init>(*)                                      id:balta-pg-outer
-
-# LettersCase.convert — trivial identity/toLowerCase/toUpperCase
-# *LettersCase$AsIs$#convert(*)                            id:balta-lc-asis
-# *LettersCase$LowerCase$#convert(*)                       id:balta-lc-lower
-# *LettersCase$UpperCase$#convert(*)                       id:balta-lc-upper
-
-# QueryResult — Iterator trait mixin forwarders (no project logic)
-# QueryResult extends Iterator[QueryResultRow]; the compiler generates ~80 mixin
-# forwarders for inherited Iterator/TraversableOnce methods.  Only hasNext, next,
-# noMore, resultSetMetaData, and columnCount carry project logic (tested elsewhere).
-# *QueryResult#to*(*)                                      id:balta-qr-iter-to
-# *QueryResult#mk*(*)                                      id:balta-qr-iter-mk
-# *QueryResult#addString(*)                                id:balta-qr-iter-addstr
-# *QueryResult#copy*(*)                                    id:balta-qr-iter-copy
-# *QueryResult#reduce*(*)                                  id:balta-qr-iter-reduce
-# *QueryResult#fold*(*)                                    id:balta-qr-iter-fold
-# *QueryResult#scan*(*)                                    id:balta-qr-iter-scan
-# *QueryResult#zip*(*)                                     id:balta-qr-iter-zip
-# *QueryResult#take*(*)                                    id:balta-qr-iter-take
-# *QueryResult#drop*(*)                                    id:balta-qr-iter-drop
-# *QueryResult#filter*(*)                                  id:balta-qr-iter-filter
-# *QueryResult#collect*(*)                                 id:balta-qr-iter-collect
-# *QueryResult#slice*(*)                                   id:balta-qr-iter-slice
-# *QueryResult#index*(*)                                   id:balta-qr-iter-index
-# *QueryResult#min*(*)                                     id:balta-qr-iter-min
-# *QueryResult#max*(*)                                     id:balta-qr-iter-max
-# *QueryResult#pad*(*)                                     id:balta-qr-iter-pad
-# *QueryResult#for*(*)                                     id:balta-qr-iter-for
-# *QueryResult#is*(*)                                      id:balta-qr-iter-is
-# *QueryResult#size*(*)                                    id:balta-qr-iter-size
-# *QueryResult#non*(*)                                     id:balta-qr-iter-non
-# *QueryResult#map(*)                                      id:balta-qr-iter-map
-# *QueryResult#flatMap(*)                                  id:balta-qr-iter-flatmap
-# *QueryResult#find(*)                                     id:balta-qr-iter-find
-# *QueryResult#contains(*)                                 id:balta-qr-iter-contains
-# *QueryResult#count(*)                                    id:balta-qr-iter-count
-# *QueryResult#corresponds(*)                              id:balta-qr-iter-corr
-# *QueryResult#withFilter(*)                               id:balta-qr-iter-withfilter
-# *QueryResult#partition(*)                                id:balta-qr-iter-partition
-# *QueryResult#span(*)                                     id:balta-qr-iter-span
-# *QueryResult#patch(*)                                    id:balta-qr-iter-patch
-# *QueryResult#buffered(*)                                 id:balta-qr-iter-buffered
-# *QueryResult#grouped(*)                                  id:balta-qr-iter-grouped
-# *QueryResult#duplicate(*)                                id:balta-qr-iter-duplicate
-# *QueryResult#sameElements(*)                             id:balta-qr-iter-same
-# *QueryResult#$plus$plus(*)                               id:balta-qr-iter-plusplus
-# *QueryResult#$div$colon(*)                               id:balta-qr-iter-divcolon
-# *QueryResult#$colon$bslash(*)                            id:balta-qr-iter-colonbslash
-# *QueryResult#aggregate(*)                                id:balta-qr-iter-aggregate
-# *QueryResult#sum(*)                                      id:balta-qr-iter-sum
-# *QueryResult#product(*)                                  id:balta-qr-iter-product
-# *QueryResult#seq(*)                                      id:balta-qr-iter-seq
-# *QueryResult#exists(*)                                   id:balta-qr-iter-exists
-# *QueryResult#length(*)                                   id:balta-qr-iter-length
-# *QueryResult#reversed(*)                                 id:balta-qr-iter-reversed
-# *QueryResult#hasDefiniteSize(*)                          id:balta-qr-iter-defsize
-
-# Value class body methods — never boxed at runtime; compiler always uses static extensions
-# Filtering the boxed-path class methods (excluding ctor/hashCode/equals already filtered globally)
-# *MapImplicits$MapEnhancements#map(*)                     id:balta-valclass-me-map
-# *MapImplicits$MapEnhancements#getOrThrow(*)              id:balta-valclass-me-got
-# *OptionImplicits$OptionEnhancements#option(*)             id:balta-valclass-oe-opt
-# *OptionImplicits$OptionEnhancements#getOrThrow(*)         id:balta-valclass-oe-got
-# *OptionImplicits$OptionEnhancements#$at$eq(*)             id:balta-valclass-oe-ateq
-# *QueryResultRowImplicits$ProductTypeConvertor#row(*)      id:balta-valclass-ptc-row
-# *QueryResultRowImplicits$ProductTypeConvertor#toProductType(*) id:balta-valclass-ptc-tpt
-# *Postgres$PostgresRow#row(*)                              id:balta-valclass-pg-row
-# *Postgres$PostgresRow#getSimpleJsonString(*)              id:balta-valclass-pg-gsjs
-# *Postgres$PostgresRow#getSJSArray(*)                      id:balta-valclass-pg-gsja
-# *Postgres$PostgresRow#simpleJsonStringTransformer(*)      id:balta-valclass-pg-sjst
-
-# ObjectQueryParamValue — trait-mixin defaults (return "?" and "=", no project logic)
-# *ObjectQueryParamValue#sqlEntry(*)                       id:balta-qpv-obj-sqlentry
-# *ObjectQueryParamValue#equalityOperator(*)               id:balta-qpv-obj-eqop
-# *ObjectQueryParamValue#<init>(*)                         id:balta-qpv-obj-init
-
-# PostgresObjectQueryParamValue — trait-mixin defaults and constructor
-# *PostgresObjectQueryParamValue#sqlEntry(*)               id:balta-pqpv-sqlentry
-# *PostgresObjectQueryParamValue#equalityOperator(*)       id:balta-pqpv-eqop
-# *PostgresObjectQueryParamValue#<init>(*)                 id:balta-pqpv-init
-
-# DBConnection — value class body (wraps java.sql.Connection; never boxed)
-# *DBConnection#connection(*)                              id:balta-dbconn-val
-# *DBConnection#<init>(*)                                  id:balta-dbconn-init
-# *DBConnection#hashCode(*)                                id:balta-dbconn-hash
-# *DBConnection#equals(*)                                  id:balta-dbconn-eq
-
-# DBConnection$ companion — primary apply has DriverManager logic (boundary);
-# filters only the trivial methods (boundary factory not unit-testable without DB)
-# *DBConnection$#apply(*)                                  id:balta-dbconn-apply
-
-# Implicit wrapper parent objects — outer object with only the implicit class definition
-# *MapImplicits#*(*)                                       id:balta-map-outer-all
-# *OptionImplicits#*(*)                                    id:balta-opt-outer-all
-# *QueryResultRowImplicits#*(*)                            id:balta-qrri-outer-all
-# *Postgres#*(*)                                           id:balta-pg-outer-all
-
-# SimpleJsonString — value class body (wraps String; never boxed)
-# *SimpleJsonString#value(*)                               id:balta-sjs-value
-# *SimpleJsonString#<init>(*)                              id:balta-sjs-init
-
-# Static companion forwarders — compiler-generated single-call delegates on main class
-# Each static method on FooClass forwards to FooClass$.MODULE$.method()
-# *DBConnection#apply(*)                                   id:balta-dbconn-apply-fwd
-# *DBConnection#dbConnectionToJdbcConnection(*)            id:balta-dbconn-impl-fwd
-# *DBTestSuite#persistDataOverride()                       id:balta-suite-persist
-# *DBTestSuite#connectionInfoFromResourceConfig(*)         id:balta-suite-configfwd
-# *QueryResultRow#createExtractors(*)                      id:balta-row-extractors-fwd
-# *QueryResultRow#fieldNamesFromMetadata(*)                id:balta-row-fieldnames-fwd
-# *NamingException#message(*)                              id:balta-naming-exc-msg
-# *NamingException#apply(*)                                id:balta-naming-exc-apply
-# *MapBasedNaming#apply(*)                                 id:balta-mapnaming-apply-fwd
-# *DBFunction#apply(*)                                     id:balta-dbfunc-apply-fwd
-# *DBTable#apply(*)                                        id:balta-dbtable-apply-fwd
-# *Params#add(*)                                           id:balta-params-add-fwd
-# *Params#addNull(*)                                       id:balta-params-addnull-fwd
-# *SimpleJsonString#apply(*)                               id:balta-sjs-apply-fwd
-# *SimpleJsonString#fromString(*)                          id:balta-sjs-fromstring-fwd
-
-# Trait mixin forwarders — implementing class calls trait default method (no own logic)
-# *MapBasedNaming#fromClassNamePerConvention(*)            id:balta-mapnaming-fromclass
-# *ExplicitNamingRequired#fromClassNamePerConvention(*)    id:balta-explicit-fromclass
-# *AsIsNaming#fromClassNamePerConvention(*)                id:balta-asis-fromclass
-
-# Private field accessors — compiler-generated single-return methods
-# *QueryResultRow#fields()                                 id:balta-row-fields
-# *QueryResultRow#columnLabels()                           id:balta-row-columnlabels
-# *AsIsNaming#lettersCase(*)                               id:balta-asis-letterscase
-
-# Params abstract class — instance methods are single-call delegates to ListMap
-# *Params#values(*)                                        id:balta-params-values
-# *Params#apply(*)                                         id:balta-params-apply
-# *Params#size(*)                                          id:balta-params-size
-# *Params#<init>(*)                                        id:balta-params-init
-
-# DBTestSuite#now — boundary method (SQL query, can't unit test without DB)
-# *DBTestSuite#now(*)                                      id:balta-suite-now
-
-# DBTestSuite — lazy val computation (boundary: calls DriverManager.getConnection)
-# *DBTestSuite#dbConnection$lzycompute(*)                  id:balta-suite-dbconn-lazy
-
-# DBTestSuite — test() override wraps testFun in a lambda + delegates to super.test()
-# The try/finally/commit/rollback logic lives in the $anonfun$test$1 synthetic (already filtered).
-# The test() method itself contains only closure creation + super.test() call — a delegation wrapper.
-# *DBTestSuite#test(*)                                     id:balta-suite-test
-
-# DBTestSuite — constructor (Lscala/Option;) overload — sets fields, calls super
-# *DBTestSuite#<init>(Lscala/Option;)*                     id:balta-suite-ctor-opt
-
-# DBTestSuite — connectionInfo lazy val accessor (compiler-generated check + delegate)
-# *DBTestSuite#connectionInfo(*)                           id:balta-suite-conninfo
-
-# ProductTypeConvertor value class body — private helpers (never boxed at runtime)
-# *QueryResultRowImplicits$ProductTypeConvertor#getConstructor(*)    id:balta-valclass-ptc-gc
-# *QueryResultRowImplicits$ProductTypeConvertor#getConstructorMirror(*)  id:balta-valclass-ptc-gcm
-# *QueryResultRowImplicits$ProductTypeConvertor#readParamsFromRow(*)  id:balta-valclass-ptc-rpr
-# *QueryResultRowImplicits$ProductTypeConvertor#getParamValue(*)     id:balta-valclass-ptc-gpv
-
-# SimpleJsonString$ParamTypeSimpleJsonString$ companion — single new() call
-# *SimpleJsonString$ParamTypeSimpleJsonString$#toQueryParamValue(*)  id:balta-sjs-ptsjs-tqpv
-
-# PostgresObjectQueryParamValue — private field accessor
-# *PostgresQueryParamValue$PostgresObjectQueryParamValue#pgObject(*) id:balta-pqpv-pgobj
-
-# DBFunction$DBFunctionWithNamedParamsToo — case class field accessor
-# *DBFunction$DBFunctionWithNamedParamsToo#functionName(*) id:balta-func-named-funcname
-
-# ConnectionInfo — static apply forwarder on main class (delegates to ConnectionInfo$.apply)
-# *ConnectionInfo#apply(*)                                 id:balta-conninfo-apply
-
-# QueryResult — missed Iterator mixin forwarder
-# *QueryResult#sliding(*)                                  id:balta-qr-iter-sliding
-
-# QueryResultRow$ — timeTzExtractor: private extractor used only when column type is timetz
-# Exercised through integration tests with the actual DB; not unit-testable.
-# *QueryResultRow$#timeTzExtractor$1(*)                    id:balta-row-timetz-ext
-
-# DBTable — boundary methods (fieldValue/count need DB connection for SQL execution)
-# *DBTable#fieldValue(*)                                   id:balta-dbtable-fieldvalue
-# *DBTable#count(*)                                        id:balta-dbtable-count
-
-# DBFunction — execute(String, verify) partially covered; uncovered branch is empty-orderBy path
-# *DBFunction#execute(Ljava/lang/String;*)*                id:balta-func-execute-orderby
diff --git a/project/plugins.sbt b/project/plugins.sbt
index 426feed..5d98cda 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,3 +1,3 @@
 lazy val sbtCiReleaseVersion = "1.11.2"
 
-addSbtPlugin("io.github.moranaapps" % "jacoco-method-filter-sbt" % "2.1.0")
+addSbtPlugin("io.github.moranaapps" % "jacoco-method-filter-sbt" % "2.1.1")

From 0cca7e7b907cab17983779a8ae9317719f61df0f Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 21 Apr 2026 12:54:40 +0200
Subject: [PATCH 08/13] Fixed review notes.

---
 .github/copilot-instructions.md               |   2 +-
 .../RecordingPreparedStatement.scala          |   0
 .../classes/QueryResultRowUnitTests.scala     |   2 -
 .../balta/classes/inner/ParamsUnitTests.scala |   4 +-
 .../SnakeCaseNamingUnitTests.scala            |   2 +-
 jmf-rules.txt                                 | 168 +++++++++---------
 6 files changed, 87 insertions(+), 91 deletions(-)
 rename balta/src/test/scala/za/co/absa/db/balta/{testing => }/RecordingPreparedStatement.scala (100%)

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index c511ca4..429fe61 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -78,7 +78,7 @@ Tooling
 Coverage filtering (JMF)
 - A method qualifies when its body is a single call with no own logic (see Testing section for the full decision rule and qualifying patterns).
 - Must not add JMF rules for methods with branching logic, error handling, or non-trivial transformations.
-- Rules file: `jmf-rules.txt` (version `[jmf:1.0.0]`); one rule per line, `#` comments and blank lines ignored.
+- Rules file: `jmf-rules.txt`; one rule per line, `#` comments and blank lines ignored.
 - Rule syntax: `<FQCN_glob>#<method_glob>(<descriptor_glob>) [FLAGS] [PREDICATES]`
   - FQCN_glob: dot-form class pattern (`*`, `*.model.*`, `com.example.*`; `$` for inner/companion classes).
   - method_glob: glob on method name (`copy`, `get*`, `$anonfun$*`, `*_$eq`).
diff --git a/balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala b/balta/src/test/scala/za/co/absa/db/balta/RecordingPreparedStatement.scala
similarity index 100%
rename from balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
rename to balta/src/test/scala/za/co/absa/db/balta/RecordingPreparedStatement.scala
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
index aeccfb1..81b9a07 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
@@ -24,11 +24,9 @@ import za.co.absa.db.mag.naming.implementations.AsIsNaming
 
 import java.sql.{ResultSetMetaData, Types}
 
-/** Case classes for toProductType tests — must be top-level for Scala reflection. */
 case class SimpleRecord(name: String, age: Int)
 case class OptionalRecord(label: String, value: Option[Int])
 
-/** Case class with auxiliary constructor — tests the multi-constructor branch in getConstructor. */
 case class MultiCtorRecord(x: Int, y: String) {
   def this(x: Int) = this(x, "default")
 }
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
index 2f05a72..9660332 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/inner/ParamsUnitTests.scala
@@ -49,7 +49,7 @@ class ParamsUnitTests extends AnyFunSuiteLike {
   }
 
   test("NamedParams instance addNull appends NULL parameter") {
-    val params = Params.add("id", 42).addNull("missing")
+    val params = Params.add("id", 42).add("missing", QueryParamType.NULL)
     assert(params.size == 2)
     assert(params("missing").sqlEntry == "NULL")
     assert(params("missing").equalityOperator == "IS")
@@ -95,7 +95,7 @@ class ParamsUnitTests extends AnyFunSuiteLike {
   }
 
   test("OrderedParams instance addNull appends NULL parameter") {
-    val params = Params.add(1).addNull[QueryParamType.NULL.type]()
+    val params = Params.add(1).add(QueryParamType.NULL)
     assert(params.size == 2)
     assert(params.values.last.sqlEntry == "NULL")
     assert(params.values.last.equalityOperator == "IS")
diff --git a/balta/src/test/scala/za/co/absa/db/mag/naming/implementations/SnakeCaseNamingUnitTests.scala b/balta/src/test/scala/za/co/absa/db/mag/naming/implementations/SnakeCaseNamingUnitTests.scala
index 939021a..5fdd575 100644
--- a/balta/src/test/scala/za/co/absa/db/mag/naming/implementations/SnakeCaseNamingUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/mag/naming/implementations/SnakeCaseNamingUnitTests.scala
@@ -60,7 +60,7 @@ class SnakeCaseNamingUnitTests extends AnyWordSpec with Matchers {
     "strip trailing $ from companion object class names" in {
       val nm = new SnakeCaseNaming(LowerCase)
       val result = nm.fromClassNamePerConvention(SnakeCaseNaming)
-      result should include("snake")
+      result should be("snake_case_naming")
     }
   }
 }
diff --git a/jmf-rules.txt b/jmf-rules.txt
index a8adfec..76a3fec 100644
--- a/jmf-rules.txt
+++ b/jmf-rules.txt
@@ -16,7 +16,7 @@
 # 4) Use --verify mode to confirm rules match before committing.
 #
 # ─────────────────────────────────────────────────────────────────────────────
-# GLOBALS RULES
+# GLOBAL RULES
 # ─────────────────────────────────────────────────────────────────────────────
 # Global rules match ALL packages. Verify they do not suppress real logic.
 # See docs/rules-reference.md#global-rule-safety-warning for details.
@@ -82,7 +82,7 @@
 # trivial constant, a boundary call not unit-testable, or an already-tested computation.
 # Rescue any lazy vals with real logic via + include rules.
 # DISABLED — enable with + include rules to rescue lazy vals whose initializer has real logic
-*#*$lzycompute(*)                                      id:scala-lzycompute
+# *#*$lzycompute(*)                                      id:scala-lzycompute
 
 # Lambda serialization helper — compiler-generated private static method
 # Emitted by scalac/javac to support SerializedLambda deserialization.
@@ -126,10 +126,10 @@
 #
 # RESCUE: Domain factory/accessor methods that collide with broad *#apply(*) rule
 # These are real domain methods with business logic, not case-class helpers.
-+*Params#apply(*)                                        id:keep-params-apply
++*Params#apply(*)                                       id:keep-params-apply
 +*QueryResultRow#apply(*)                               id:keep-queryresult-accessors
 +*QueryResultRow$#apply(*)                              id:keep-queryresult-factory
-+*DBConnection$#apply(*)                                id:keep-dbconn-apply
++*DBConnection$#apply(Lscala/Function0;)*               id:keep-dbconn-apply
 +*DBFunction$#apply(*)                                  id:keep-dbfunction-apply
 +*MapBasedNaming$#apply(*)                              id:keep-naming-transform
 
@@ -137,88 +137,86 @@
 # PROJECT RULES
 # ─────────────────────────────────────────────────────────────────────────────
 
-*DBFunction#perform(*)                                   id:balta-func-perform
-*DBFunction#getResult(*)                                 id:balta-func-getresult
-*DBFunction#execute(Ljava/lang/String;*)*                id:balta-func-execute-orderby
+*DBFunction#perform(*)                                  id:balta-func-perform
+*DBFunction#getResult(*)                                id:balta-func-getresult
+*DBFunction#execute(Ljava/lang/String;*)*               id:balta-func-execute-orderby
 
 *DBConnection$#apply(Ljava/lang/String;*)               id:balta-dbconn-apply-str
-*DBConnection#connection(*)                              id:balta-dbconn-val
-*DBConnection#<init>(*)                                  id:balta-dbconn-init
-*DBConnection#dbConnectionToJdbcConnection(*)            id:balta-dbconn-impl-fwd
-
-*QueryResult#mk*(*)                                      id:balta-qr-iter-mk
-*QueryResult#addString(*)                                id:balta-qr-iter-addstr
-*QueryResult#copy*(*)                                    id:balta-qr-iter-copy
-*QueryResult#reduce*(*)                                  id:balta-qr-iter-reduce
-*QueryResult#fold*(*)                                    id:balta-qr-iter-fold
-*QueryResult#scan*(*)                                    id:balta-qr-iter-scan
-*QueryResult#zip*(*)                                     id:balta-qr-iter-zip
-*QueryResult#take*(*)                                    id:balta-qr-iter-take
-*QueryResult#drop*(*)                                    id:balta-qr-iter-drop
-*QueryResult#filter*(*)                                  id:balta-qr-iter-filter
-*QueryResult#collect*(*)                                 id:balta-qr-iter-collect
-*QueryResult#slice*(*)                                   id:balta-qr-iter-slice
-*QueryResult#index*(*)                                   id:balta-qr-iter-index
-*QueryResult#min*(*)                                     id:balta-qr-iter-min
-*QueryResult#max*(*)                                     id:balta-qr-iter-max
-*QueryResult#pad*(*)                                     id:balta-qr-iter-pad
-*QueryResult#for*(*)                                     id:balta-qr-iter-for
-*QueryResult#is*(*)                                      id:balta-qr-iter-is
-*QueryResult#size*(*)                                    id:balta-qr-iter-size
-*QueryResult#non*(*)                                     id:balta-qr-iter-non
-*QueryResult#map(*)                                      id:balta-qr-iter-map
-*QueryResult#flatMap(*)                                  id:balta-qr-iter-flatmap
-*QueryResult#find(*)                                     id:balta-qr-iter-find
-*QueryResult#contains(*)                                 id:balta-qr-iter-contains
-*QueryResult#count(*)                                    id:balta-qr-iter-count
-*QueryResult#corresponds(*)                              id:balta-qr-iter-corr
-*QueryResult#withFilter(*)                               id:balta-qr-iter-withfilter
-*QueryResult#partition(*)                                id:balta-qr-iter-partition
-*QueryResult#span(*)                                     id:balta-qr-iter-span
-*QueryResult#patch(*)                                    id:balta-qr-iter-patch
-*QueryResult#buffered(*)                                 id:balta-qr-iter-buffered
-*QueryResult#grouped(*)                                  id:balta-qr-iter-grouped
-*QueryResult#duplicate(*)                                id:balta-qr-iter-duplicate
-*QueryResult#sameElements(*)                             id:balta-qr-iter-same
-*QueryResult#$plus$plus(*)                               id:balta-qr-iter-plusplus
-*QueryResult#$div$colon(*)                               id:balta-qr-iter-divcolon
-*QueryResult#$colon$bslash(*)                            id:balta-qr-iter-colonbslash
-*QueryResult#aggregate(*)                                id:balta-qr-iter-aggregate
-*QueryResult#sum(*)                                      id:balta-qr-iter-sum
-*QueryResult#product(*)                                  id:balta-qr-iter-product
-*QueryResult#exists(*)                                   id:balta-qr-iter-exists
-*QueryResult#length(*)                                   id:balta-qr-iter-length
-*QueryResult#reversed(*)                                 id:balta-qr-iter-reversed
-*QueryResult#hasDefiniteSize(*)                          id:balta-qr-iter-defsize
-*QueryResult#toArray(*)                                  id:balta-qr-iter-toarray
-*QueryResult#toMap(*)                                    id:balta-qr-iter-tomap
-*QueryResult#toTraversable(*)                            id:balta-qr-iter-totraversable
-*QueryResult#toIterator(*)                               id:balta-qr-iter-toiterator
-*QueryResult#toStream(*)                                 id:balta-qr-iter-tostream
-*QueryResult#toIterable(*)                               id:balta-qr-iter-toiterable
-*QueryResult#toSeq(*)                                    id:balta-qr-iter-toseq
-*QueryResult#toIndexedSeq(*)                             id:balta-qr-iter-toindexedseq
-*QueryResult#toBuffer(*)                                 id:balta-qr-iter-tobuffer
-*QueryResult#toSet(*)                                    id:balta-qr-iter-toset
-*QueryResult#toVector(*)                                 id:balta-qr-iter-tovector
-*QueryResult#sliding(*)                                  id:balta-qr-iter-sliding
-
-*QueryResultRowImplicits$ProductTypeConvertor#row(*)        id:balta-valclass-ptc-row
-*QueryResultRowImplicits$ProductTypeConvertor#toProductType(*) id:balta-valclass-ptc-tpt
-
-*QueryResultRow#createExtractors(*)                        id:balta-row-extractors-fwd
-*QueryResultRow#fieldNamesFromMetadata(*)                  id:balta-row-fieldnames-fwd
-*QueryResultRow#getChar(*)*                                 id:balta-colname-get-char
-*QueryResultRow#getObject(*)*                               id:balta-colname-get-char
-*QueryResultRow#getAs(Ljava/lang/String;Lscala/Function1;)* id:balta-colname-getas-transformer
-
-*QueryResultRowImplicits$ProductTypeConvertor#<init>(*)    id:balta-qrri-ctor
-*QueryResultRowImplicits$ProductTypeConvertor#getConstructor(*)      id:balta-valclass-ptc-gc
-*QueryResultRowImplicits$ProductTypeConvertor#getConstructorMirror(*) id:balta-valclass-ptc-gcm
-*QueryResultRowImplicits$ProductTypeConvertor#readParamsFromRow(*)    id:balta-valclass-ptc-rpr
-*QueryResultRowImplicits$ProductTypeConvertor#getParamValue(*)        id:balta-valclass-ptc-gpv
-
-*DBTable#fieldValue(*)                                   id:balta-dbtable-fieldvalue
-*DBTable#count(Lza/co/absa/db/balta/classes/inner/Params$NamedParams;Ljava/sql/Connection;)* id:balta-dbtable-count-named
+*DBConnection#connection(*)                             id:balta-dbconn-val
+*DBConnection#<init>(*)                                 id:balta-dbconn-init
+*DBConnection#dbConnectionToJdbcConnection(*)           id:balta-dbconn-impl-fwd
+
+*QueryResult#mk*(*)                                     id:balta-qr-iter-mk
+*QueryResult#addString(*)                               id:balta-qr-iter-addstr
+*QueryResult#copy*(*)                                   id:balta-qr-iter-copy
+*QueryResult#reduce*(*)                                 id:balta-qr-iter-reduce
+*QueryResult#fold*(*)                                   id:balta-qr-iter-fold
+*QueryResult#scan*(*)                                   id:balta-qr-iter-scan
+*QueryResult#zip*(*)                                    id:balta-qr-iter-zip
+*QueryResult#take*(*)                                   id:balta-qr-iter-take
+*QueryResult#drop*(*)                                   id:balta-qr-iter-drop
+*QueryResult#filter*(*)                                 id:balta-qr-iter-filter
+*QueryResult#collect*(*)                                id:balta-qr-iter-collect
+*QueryResult#slice*(*)                                  id:balta-qr-iter-slice
+*QueryResult#index*(*)                                  id:balta-qr-iter-index
+*QueryResult#min*(*)                                    id:balta-qr-iter-min
+*QueryResult#max*(*)                                    id:balta-qr-iter-max
+*QueryResult#pad*(*)                                    id:balta-qr-iter-pad
+*QueryResult#for*(*)                                    id:balta-qr-iter-for
+*QueryResult#is*(*)                                     id:balta-qr-iter-is
+*QueryResult#size*(*)                                   id:balta-qr-iter-size
+*QueryResult#non*(*)                                    id:balta-qr-iter-non
+*QueryResult#map(*)                                     id:balta-qr-iter-map
+*QueryResult#flatMap(*)                                 id:balta-qr-iter-flatmap
+*QueryResult#find(*)                                    id:balta-qr-iter-find
+*QueryResult#contains(*)                                id:balta-qr-iter-contains
+*QueryResult#count(*)                                   id:balta-qr-iter-count
+*QueryResult#corresponds(*)                             id:balta-qr-iter-corr
+*QueryResult#withFilter(*)                              id:balta-qr-iter-withfilter
+*QueryResult#partition(*)                               id:balta-qr-iter-partition
+*QueryResult#span(*)                                    id:balta-qr-iter-span
+*QueryResult#patch(*)                                   id:balta-qr-iter-patch
+*QueryResult#buffered(*)                                id:balta-qr-iter-buffered
+*QueryResult#grouped(*)                                 id:balta-qr-iter-grouped
+*QueryResult#duplicate(*)                               id:balta-qr-iter-duplicate
+*QueryResult#sameElements(*)                            id:balta-qr-iter-same
+*QueryResult#$plus$plus(*)                              id:balta-qr-iter-plusplus
+*QueryResult#$div$colon(*)                              id:balta-qr-iter-divcolon
+*QueryResult#$colon$bslash(*)                           id:balta-qr-iter-colonbslash
+*QueryResult#aggregate(*)                               id:balta-qr-iter-aggregate
+*QueryResult#sum(*)                                     id:balta-qr-iter-sum
+*QueryResult#product(*)                                 id:balta-qr-iter-product
+*QueryResult#exists(*)                                  id:balta-qr-iter-exists
+*QueryResult#length(*)                                  id:balta-qr-iter-length
+*QueryResult#reversed(*)                                id:balta-qr-iter-reversed
+*QueryResult#hasDefiniteSize(*)                         id:balta-qr-iter-defsize
+*QueryResult#toArray(*)                                 id:balta-qr-iter-toarray
+*QueryResult#toMap(*)                                   id:balta-qr-iter-tomap
+*QueryResult#toTraversable(*)                           id:balta-qr-iter-totraversable
+*QueryResult#toIterator(*)                              id:balta-qr-iter-toiterator
+*QueryResult#toStream(*)                                id:balta-qr-iter-tostream
+*QueryResult#toIterable(*)                              id:balta-qr-iter-toiterable
+*QueryResult#toSeq(*)                                   id:balta-qr-iter-toseq
+*QueryResult#toIndexedSeq(*)                            id:balta-qr-iter-toindexedseq
+*QueryResult#toBuffer(*)                                id:balta-qr-iter-tobuffer
+*QueryResult#toSet(*)                                   id:balta-qr-iter-toset
+*QueryResult#toVector(*)                                id:balta-qr-iter-tovector
+*QueryResult#sliding(*)                                 id:balta-qr-iter-sliding
+
+*QueryResultRowImplicits$ProductTypeConvertor#row(*)    id:balta-valclass-ptc-row
+*QueryResultRowImplicits$ProductTypeConvertor#toProductType(*)  id:balta-valclass-ptc-tpt
+
+*QueryResultRow#getChar(Ljava/lang/String;)*            id:balta-colname-get-char
+*QueryResultRow#getObject(Ljava/lang/String;)*          id:balta-colname-get-object
+*QueryResultRow#getAs(Ljava/lang/String;Lscala/Function1;)*  id:balta-colname-getas-transformer
+
+*QueryResultRowImplicits$ProductTypeConvertor#<init>(*)  id:balta-qrri-ctor
+*QueryResultRowImplicits$ProductTypeConvertor#getConstructor(*)  id:balta-valclass-ptc-gc
+*QueryResultRowImplicits$ProductTypeConvertor#getConstructorMirror(*)  id:balta-valclass-ptc-gcm
+*QueryResultRowImplicits$ProductTypeConvertor#readParamsFromRow(*)  id:balta-valclass-ptc-rpr
+*QueryResultRowImplicits$ProductTypeConvertor#getParamValue(*)  id:balta-valclass-ptc-gpv
+
+*DBTable#fieldValue(*)                                  id:balta-dbtable-fieldvalue
+*DBTable#count(Lza/co/absa/db/balta/classes/inner/Params$NamedParams;Ljava/sql/Connection;)*  id:balta-dbtable-count-named
 *DBTable#count(Ljava/lang/String;Ljava/sql/Connection;)*  id:balta-dbtable-count-str
 

From f2fbc3cebbd350b74c13bf32c92885729591036e Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 21 Apr 2026 12:58:59 +0200
Subject: [PATCH 09/13] Refactor unit tests to use new
 RecordingPreparedStatement location; remove old implementation

---
 .../db/balta/{ => testing}/RecordingPreparedStatement.scala     | 2 +-
 .../co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala  | 2 +-
 .../co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
 rename balta/src/test/scala/za/co/absa/db/balta/{ => testing}/RecordingPreparedStatement.scala (99%)

diff --git a/balta/src/test/scala/za/co/absa/db/balta/RecordingPreparedStatement.scala b/balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
similarity index 99%
rename from balta/src/test/scala/za/co/absa/db/balta/RecordingPreparedStatement.scala
rename to balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
index a43eaa6..a92936e 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/RecordingPreparedStatement.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package za.co.absa.db.balta
+package za.co.absa.db.balta.testing
 
 import java.io.{InputStream, Reader}
 import java.net.URL
diff --git a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
index aad283e..aa4557b 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
@@ -20,7 +20,7 @@ import java.time.{Instant, LocalDate, LocalTime, OffsetDateTime, ZoneOffset}
 import java.util.UUID
 
 import org.scalatest.funsuite.AnyFunSuiteLike
-import za.co.absa.db.balta.RecordingPreparedStatement
+import za.co.absa.db.balta.testing.RecordingPreparedStatement
 
 class QueryParamTypeUnitTests extends AnyFunSuiteLike {
 
diff --git a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala
index d0c94e6..89e1df3 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala
@@ -17,7 +17,7 @@
 package za.co.absa.db.balta.typeclasses
 
 import org.scalatest.funsuite.AnyFunSuiteLike
-import za.co.absa.db.balta.RecordingPreparedStatement
+import za.co.absa.db.balta.testing.RecordingPreparedStatement
 import za.co.absa.db.balta.typeclasses.QueryParamValue._
 
 class QueryParamValueUnitTests extends AnyFunSuiteLike {

From f213797a63ff482dedd2a32dc6541c4529fefbcb Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 21 Apr 2026 13:09:46 +0200
Subject: [PATCH 10/13] Fixed review comments.

---
 .../classes/QueryResultRowUnitTests.scala     | 35 +++++++++++++------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
index 81b9a07..2052aa9 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
@@ -16,14 +16,17 @@
 
 package za.co.absa.db.balta.classes
 
+import java.sql.{ResultSetMetaData, Types}
+import java.time.{OffsetDateTime, OffsetTime}
+
 import org.scalatest.funsuite.AnyFunSuiteLike
+
+import za.co.absa.db.balta.MockResultSets
 import za.co.absa.db.balta.classes.QueryResultRow.FieldNames
 import za.co.absa.db.balta.implicits.QueryResultRowImplicits.ProductTypeConvertor
 import za.co.absa.db.mag.naming.LettersCase.AsIs
 import za.co.absa.db.mag.naming.implementations.AsIsNaming
 
-import java.sql.{ResultSetMetaData, Types}
-
 case class SimpleRecord(name: String, age: Int)
 case class OptionalRecord(label: String, value: Option[Int])
 
@@ -135,27 +138,37 @@ class QueryResultRowUnitTests extends AnyFunSuiteLike {
   }
 
   test("createExtractors dispatches timestamptz to OffsetDateTime extractor") {
-    val metaData = new StubMetaData(
-      List(("ts", Types.TIMESTAMP, "timestamptz"))
-    )
+    val expected = OffsetDateTime.parse("2024-01-15T10:30:00+02:00")
+    val metaData = new StubMetaData(List(("ts", Types.TIMESTAMP, "timestamptz")))
+    val rs = new MockResultSets.MockResultSet(1) {
+      override def getObject[T](columnIndex: Int, `type`: Class[T]): T = expected.asInstanceOf[T]
+    }
     val extractors = QueryResultRow.createExtractors(metaData)
     assert(extractors.size == 1)
+    assert(extractors.head(rs).contains(expected))
   }
 
   test("createExtractors dispatches timetz to OffsetTime extractor") {
-    val metaData = new StubMetaData(
-      List(("t", Types.TIME, "timetz"))
-    )
+    val expected = OffsetTime.parse("10:30:00+02:00")
+    val metaData = new StubMetaData(List(("t", Types.TIME, "timetz")))
+    val rs = new MockResultSets.MockResultSet(1) {
+      override def getObject[T](columnIndex: Int, `type`: Class[T]): T = expected.asInstanceOf[T]
+    }
     val extractors = QueryResultRow.createExtractors(metaData)
     assert(extractors.size == 1)
+    assert(extractors.head(rs).contains(expected))
   }
 
   test("createExtractors dispatches ARRAY type") {
-    val metaData = new StubMetaData(
-      List(("arr", Types.ARRAY, "_int4"))
-    )
+    val arr: Array[Object] = Array(java.lang.Integer.valueOf(1))
+    val sqlArr = new StubSqlArray(arr)
+    val metaData = new StubMetaData(List(("arr", Types.ARRAY, "_int4")))
+    val rs = new MockResultSets.MockResultSet(1) {
+      override def getArray(columnIndex: Int): java.sql.Array = sqlArr
+    }
     val extractors = QueryResultRow.createExtractors(metaData)
     assert(extractors.size == 1)
+    assert(extractors.head(rs).contains(sqlArr))
   }
 
   test("getArray returns Vector from sql.Array column") {

From 7aea462cc59fe5eb9cc01cfd687a29eb38ea8efb Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Tue, 21 Apr 2026 13:32:49 +0200
Subject: [PATCH 11/13] Fix apply method to use 0-based index; add unit tests
 for apply method behavior

---
 .github/copilot-instructions.md               |  6 ++---
 .../db/balta/classes/QueryResultRow.scala     |  2 +-
 .../classes/QueryResultRowUnitTests.scala     | 22 +++++++++++++++++++
 jmf-rules.txt                                 |  2 +-
 4 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 429fe61..c10fd04 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -64,11 +64,11 @@ Testing
   - Body is a single call with no own logic: forwards to another overload, calls its non-deprecated replacement, returns a field, or wraps a constructor with no transformation.
   - Litmus: "Does this method have any logic of its own?" — No → JMF.
 - Global rule collision check (CRITICAL):
-  - When adding any new method, check if it matches a pattern in the `# GLOBALS RULES` section of `jmf-rules.txt` (line ~22+).
+  - When adding any new method, check if it matches a pattern in the `# GLOBAL RULES` section of `jmf-rules.txt` (line ~22+).
   - If method name matches a global rule AND the method has domain logic: immediately create an INCLUDE rescue rule (`+FQCN#method(*)`) in the `# INCLUDE RULES` section of `jmf-rules.txt`.
-  - High-risk method names: refer to `jmf-rules.txt` GLOBALS RULES section for complete list; most common collisions: `apply()`, `toString()`, `equals()`, `copy()`, `name()`, `groups()`, `optionalAttributes()`.
+  - High-risk method names: refer to `jmf-rules.txt` GLOBAL RULES section for complete list; most common collisions: `apply()`, `toString()`, `equals()`, `copy()`, `name()`, `groups()`, `optionalAttributes()`.
   - Rationale: Broad global rules designed for compiler-generated boilerplate can silently hide coverage for domain methods. INCLUDE rules rescue specific methods from broad exclusions.
-  - Example: If adding `def apply(id: String): Record`, add `+*Record$#apply(*)  id:keep-record-factory` to rescue from the `*$*#apply(*)` global rule in GLOBALS RULES section.
+  - Example: If adding `def apply(id: String): Record`, add `+*Record$#apply(*)  id:keep-record-factory` to rescue from the `*$*#apply(*)` global rule in GLOBAL RULES section.
 - Review rule — JMF drift check: when modifying a method that appears in `jmf-rules.txt`, verify its body still qualifies; if own logic has been added, remove the JMF rule and write a unit test instead.
 
 Tooling
diff --git a/balta/src/main/scala/za/co/absa/db/balta/classes/QueryResultRow.scala b/balta/src/main/scala/za/co/absa/db/balta/classes/QueryResultRow.scala
index dc6633f..8dcb127 100644
--- a/balta/src/main/scala/za/co/absa/db/balta/classes/QueryResultRow.scala
+++ b/balta/src/main/scala/za/co/absa/db/balta/classes/QueryResultRow.scala
@@ -48,7 +48,7 @@ class QueryResultRow private[classes](val rowNumber: Int,
    * @param column  - the number of the column, 1 based
    * @return        - the value stored in the column, type `Any` is for warningless comparison with any type
    */
-  def apply(column: Int): Option[Any] = getObject(column - 1)
+  def apply(column: Int): Option[Any] = getObject(column)
   /**
    * Extracts a value from the row by column name.
    * @param columnLabel - the name of the column
diff --git a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
index 2052aa9..ad31dcc 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/classes/QueryResultRowUnitTests.scala
@@ -64,6 +64,28 @@ class QueryResultRowUnitTests extends AnyFunSuiteLike {
     assert(row.columnNumber("age") == 2)
   }
 
+  test("apply(Int) returns correct value by 1-based column index") {
+    val row = mkRow()
+    assert(row(1).contains("hello"))
+    assert(row(2).contains(java.lang.Integer.valueOf(42)))
+  }
+
+  test("apply(Int) returns None for null column") {
+    val row = mkRow()
+    assert(row(3).isEmpty)
+  }
+
+  test("apply(String) returns correct value by column label") {
+    val row = mkRow()
+    assert(row("name").contains("hello"))
+    assert(row("age").contains(java.lang.Integer.valueOf(42)))
+  }
+
+  test("apply(String) returns None for null column") {
+    val row = mkRow()
+    assert(row("nullable").isEmpty)
+  }
+
   test("columnNumber is case-insensitive") {
     val row = mkRow()
     assert(row.columnNumber("NAME") == 1)
diff --git a/jmf-rules.txt b/jmf-rules.txt
index 76a3fec..248e8cb 100644
--- a/jmf-rules.txt
+++ b/jmf-rules.txt
@@ -1,7 +1,7 @@
 # jacoco-method-filter — Rules Template (Scala / sbt)
 # [jmf:2.1.0]
 #
-# Syntax reference, pitfalls, examples, and workflows: docs/rules-reference.md
+# Syntax reference, pitfalls, examples, and workflows: https://github.com/MoranaApps/jacoco-method-filter/blob/main/docs/rules-reference.md
 #
 # ─────────────────────────────────────────────────────────────────────────────
 # HOW TO USE

From e4b3f5dad52b93822298b0aaba594643de59f36a Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Wed, 22 Apr 2026 12:10:18 +0200
Subject: [PATCH 12/13] Refactor import paths for RecordingPreparedStatement;
 move to the correct package location

---
 .../testing/{ => classes}/RecordingPreparedStatement.scala      | 2 +-
 .../co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala  | 2 +-
 .../co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
 rename balta/src/test/scala/za/co/absa/db/balta/testing/{ => classes}/RecordingPreparedStatement.scala (99%)

diff --git a/balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala b/balta/src/test/scala/za/co/absa/db/balta/testing/classes/RecordingPreparedStatement.scala
similarity index 99%
rename from balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
rename to balta/src/test/scala/za/co/absa/db/balta/testing/classes/RecordingPreparedStatement.scala
index a92936e..03a6da0 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/testing/RecordingPreparedStatement.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/testing/classes/RecordingPreparedStatement.scala
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package za.co.absa.db.balta.testing
+package za.co.absa.db.balta.testing.classes
 
 import java.io.{InputStream, Reader}
 import java.net.URL
diff --git a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
index aa4557b..2642dad 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamTypeUnitTests.scala
@@ -20,7 +20,7 @@ import java.time.{Instant, LocalDate, LocalTime, OffsetDateTime, ZoneOffset}
 import java.util.UUID
 
 import org.scalatest.funsuite.AnyFunSuiteLike
-import za.co.absa.db.balta.testing.RecordingPreparedStatement
+import za.co.absa.db.balta.testing.classes.RecordingPreparedStatement
 
 class QueryParamTypeUnitTests extends AnyFunSuiteLike {
 
diff --git a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala
index 89e1df3..48bb3bf 100644
--- a/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala
+++ b/balta/src/test/scala/za/co/absa/db/balta/typeclasses/QueryParamValueUnitTests.scala
@@ -17,7 +17,7 @@
 package za.co.absa.db.balta.typeclasses
 
 import org.scalatest.funsuite.AnyFunSuiteLike
-import za.co.absa.db.balta.testing.RecordingPreparedStatement
+import za.co.absa.db.balta.testing.classes.RecordingPreparedStatement
 import za.co.absa.db.balta.typeclasses.QueryParamValue._
 
 class QueryParamValueUnitTests extends AnyFunSuiteLike {

From 1330c03cb10ce2b7bfbd43b04c75644d6cda94b4 Mon Sep 17 00:00:00 2001
From: miroslavpojer <miroslav.pojer@absa.africa>
Date: Thu, 23 Apr 2026 09:30:01 +0200
Subject: [PATCH 13/13] Improved doc.

---
 .../scala/za/co/absa/db/balta/classes/QueryResultRow.scala    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/balta/src/main/scala/za/co/absa/db/balta/classes/QueryResultRow.scala b/balta/src/main/scala/za/co/absa/db/balta/classes/QueryResultRow.scala
index 8dcb127..3dbaa47 100644
--- a/balta/src/main/scala/za/co/absa/db/balta/classes/QueryResultRow.scala
+++ b/balta/src/main/scala/za/co/absa/db/balta/classes/QueryResultRow.scala
@@ -45,7 +45,9 @@ class QueryResultRow private[classes](val rowNumber: Int,
 
   /**
    * Extracts a value from the row by column number.
-   * @param column  - the number of the column, 1 based
+   * @param column  - the 1-based column number (JDBC convention); note: prior to this fix the parameter was
+   *                  incorrectly treated as 0-based (direct vector index), causing column 1 to silently return
+   *                  the value of the second column
    * @return        - the value stored in the column, type `Any` is for warningless comparison with any type
    */
   def apply(column: Int): Option[Any] = getObject(column)