Fix DICTIONARY array handling in CSV, ORC, Paimon, Iceberg writers

Arrow dict8<int8, utf8> arrays (used for low-cardinality TPC-H columns
since Phase 3.3) were not handled in non-Lance writers:

- csv_writer: fell back to array->ToString() producing corrupt column
  representation per cell; fix does index→value lookup via GetString()
- orc_writer: arrow_type_to_orc_type_name() threw "Unsupported type" on
  DICTIONARY; copy_array_to_orc_column() also threw; fix maps DICTIONARY
  to ORC "string" and expands indices via GetView() into dict buffer
- paimon_writer: arrow_type_to_paimon_type() threw on DICTIONARY; fix
  maps to "string" (data path via parquet::arrow::WriteTable is fine)
- iceberg_writer: arrow_type_to_iceberg_type() threw on DICTIONARY; fix
  maps to "string" (data path via parquet::arrow::WriteTable is fine)

Parquet and Lance handle DICTIONARY natively through Arrow — no changes
needed. ORC fix tested via code review only (requires -DTPCH_ENABLE_ORC).
CSV fix verified: l_returnflag/linestatus/shipinstruct/shipmode output
correct string values ("N", "O", "DELIVER IN PERSON", "TRUCK").

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: tsafin

src/writers/csv_writer.cpp

@@ -269,6 +269,13 @@ void CSVWriter::write_batch(
           auto float_array =
               std::dynamic_pointer_cast<arrow::FloatArray>(array);
           row_buffer << float_array->Value(row);
+        } else if (field_type->id() == arrow::Type::DICTIONARY) {
+          auto dict_array =
+              std::dynamic_pointer_cast<arrow::DictionaryArray>(array);
+          auto dict_values =
+              std::dynamic_pointer_cast<arrow::StringArray>(dict_array->dictionary());
+          auto idx = dict_array->GetValueIndex(row);
+          row_buffer << escape_csv_value(dict_values->GetString(idx));
         } else {
           // Fallback: convert to string using Arrow's ToString
           row_buffer << array->ToString();

src/writers/iceberg_writer.cpp

@@ -58,6 +58,8 @@ std::string IcebergWriter::arrow_type_to_iceberg_type(
             return "decimal(" + std::to_string(decimal_type->precision()) + ","
                    + std::to_string(decimal_type->scale()) + ")";
         }
+        case arrow::Type::DICTIONARY:
+            return "string";  // dict8<int8, utf8> written as Parquet dict page, exposed as string
         default:
             throw std::runtime_error(
                 std::string("Unsupported Arrow type for Iceberg: ") + arrow_type->ToString()

src/writers/orc_writer.cpp

@@ -32,6 +32,8 @@ std::string arrow_type_to_orc_type_name(const std::shared_ptr<arrow::DataType>&
         return "double";
     } else if (type->id() == arrow::Type::STRING) {
         return "string";
+    } else if (type->id() == arrow::Type::DICTIONARY) {
+        return "string";  // dict8<int8, utf8> expanded to string on write
     } else {
         throw std::runtime_error("Unsupported Arrow type for ORC conversion");
     }
@@ -139,6 +141,26 @@ void copy_array_to_orc_column(
                 string_col->length[i] = static_cast<int64_t>(str.length());
             }
         }
+    } else if (array->type()->id() == arrow::Type::DICTIONARY) {
+        // Expand dict8<int8, utf8> to ORC string column via index lookup.
+        // string_view points into the dictionary buffer which outlives this function.
+        auto dict_array = std::static_pointer_cast<arrow::DictionaryArray>(array);
+        auto dict_values = std::static_pointer_cast<arrow::StringArray>(dict_array->dictionary());
+        auto* string_col = dynamic_cast<orc::StringVectorBatch*>(col_batch);
+        if (!string_col) {
+            throw std::runtime_error("Failed to cast ORC column to StringVectorBatch");
+        }
+        for (size_t i = 0; i < size; ++i) {
+            if (dict_array->IsNull(static_cast<int64_t>(i))) {
+                string_col->notNull[i] = 0;
+            } else {
+                string_col->notNull[i] = 1;
+                auto idx = dict_array->GetValueIndex(static_cast<int64_t>(i));
+                auto sv = dict_values->GetView(idx);
+                string_col->data[i] = const_cast<char*>(sv.data());
+                string_col->length[i] = static_cast<int64_t>(sv.length());
+            }
+        }
     } else {
         throw std::runtime_error("Unsupported Arrow type for ORC column copy");
     }

src/writers/paimon_writer.cpp

@@ -74,6 +74,8 @@ std::string PaimonWriter::arrow_type_to_paimon_type(
             return "decimal";
         case arrow::Type::BOOL:
             return "boolean";
+        case arrow::Type::DICTIONARY:
+            return "string";  // dict8<int8, utf8> written as Parquet dict page, exposed as string
         default:
             throw std::runtime_error(
                 std::string("Unsupported Arrow type for Paimon: ") + arrow_type->ToString()