Allow select function to read source column values

[nafg]

Problem

In the TableSpec.select { row => Seq(...) } DSL, transformation functions like mapString and mapOptString cannot access other columns in the current row. The RawRow parameter exists in TransformedColumn's function signature (RawRow => Option[String] => Option[String]) but is discarded by mapString and mapOptString:

def mapString(f: String => String): TransformedColumn =
  TransformedColumn(name, Lens.Direct, _ => opt => opt.map(f))  // _ discards RawRow

def mapOptString(f: Option[String] => Option[String]): TransformedColumn =
  TransformedColumn(name, Lens.Direct, _ => f)  // _ discards RawRow

This means transformations can only see the current column's value, not values from other columns in the same row.

Use Cases

• Conditionally anonymize a column based on another column's value
• Compose values from multiple columns
• Apply different transformations based on row context

Proposed Solution

Add new methods on SourceColumn that expose the RawRow to the transformation function, e.g.:

def mapWithRow(f: RawRow => String => String): TransformedColumn =
  TransformedColumn(name, Lens.Direct, rawRow => opt => opt.map(f(rawRow)))

def mapOptWithRow(f: RawRow => Option[String] => Option[String]): TransformedColumn =
  TransformedColumn(name, Lens.Direct, rawRow => f(rawRow))

Files

• simple-anonymizer/src/scala/simpleanonymizer/OutputColumn.scala
• simple-anonymizer/src/scala/simpleanonymizer/RawRow.scala
• simple-anonymizer/src/scala/simpleanonymizer/TableSpec.scala

[nafg]

Implementation notes

The low-level capability already exists today: TransformedColumn's function signature is RawRow => Option[String] => Option[String], so the transformation function already receives the full RawRow and can access any other column's value. What's missing is a clean DSL surface for it.

Approaches considered

1. Add mapStringWithRow / mapOptStringWithRow on SourceColumn — straightforward but doesn't change the underlying architecture.

2. Make Row wrap RawRow — Instead of Row being a stateless Dynamic class (used only for selectDynamic to produce SourceColumn), it could wrap the actual RawRow. Then row.column_name could give you both the DSL methods (.mapString, etc.) and direct access to the value. This would also address Replace select DSL with stateless alternative #5 (replacing the stateless Dynamic-based DSL).

3. Eagerly evaluate transformations — If Row wraps RawRow, transformations like .mapString(f) could eagerly apply f and return the result, rather than storing a deferred function. However, the current design runs the select function once at setup time to build Seq[OutputColumn], then applies the stored functions per-row during copy. Switching to eager evaluation would require select to be called per-row, which is a bigger change.

Relationship to #5

This is closely related to the question of replacing the Dynamic-based Row class (#5). The right solution here depends on the DSL direction chosen there. If Row becomes a wrapper around RawRow, cross-column access comes naturally. If we keep the current stateless approach, we'd add explicit mapStringWithRow-style methods instead.