Add type conversion for PostgreSQL driver to Parquet type matching

## Problem
Panic: "cannot create parquet value of type INT32 from go value of type int64"

The PostgreSQL driver (lib/pq) returns int64 for ALL integer types (int2, int4, int8)
to avoid overflow issues. However, Parquet expects exact type matches:
- INT32 for PostgreSQL int2/int4
- INT64 for PostgreSQL int8

## Solution
Added `convertPostgreSQLValue()` function that converts driver types to appropriate
Go types based on the PostgreSQL column type from the schema:

### Type Conversions
- **int2, int4**: int64 → int32 (safe, PostgreSQL int4 max is 2^31-1)
- **int8**: Keep as int64
- **float4**: float64 → float32
- **float8, numeric, decimal**: Keep as float64
- **timestamp, date**: Keep as time.Time
- **bool**: Keep as bool
- **bytea**: Keep as []byte
- **strings**: Keep as-is

### Integration
The conversion is called when building rowData in the streaming extraction:
```go
rowData[col.GetName()] = convertPostgreSQLValue(scanValues[i], col.GetType())
```

## Benefits
✅ **Type Precision**: Correct integer sizes (int32 vs int64)
✅ **Parquet Compatibility**: Types match schema expectations
✅ **No Panics**: Proper type conversions prevent runtime errors
✅ **Safe**: Conversions are within PostgreSQL type bounds

## Testing
- All tests pass
- Linters pass (with nolint for safe int64→int32 conversion)
- Build succeeds

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: kevinelliott

cmd/archiver.go

@@ -1852,6 +1852,49 @@ func (a *Archiver) extractRowsWithDateFilter(partition PartitionInfo, startTime,
 	return result, nil
 }
 
+// convertPostgreSQLValue converts PostgreSQL driver values to appropriate Go types
+// The pq driver returns int64 for all integer types, but formatters (especially Parquet)
+// need specific types based on the actual PostgreSQL column type
+func convertPostgreSQLValue(value interface{}, pgType string) interface{} {
+	if value == nil {
+		return nil
+	}
+
+	switch pgType {
+	case "int2", "int4":
+		// PostgreSQL driver returns int64, but we need int32 for Parquet INT32
+		// Safe conversion: PostgreSQL int2 is -32768 to 32767, int4 is -2147483648 to 2147483647
+		if v, ok := value.(int64); ok {
+			return int32(v) //nolint:gosec // G115: Safe conversion, PostgreSQL int4 fits in int32
+		}
+	case "int8":
+		// Keep as int64
+		return value
+	case "float4":
+		// PostgreSQL driver returns float64, convert to float32
+		if v, ok := value.(float64); ok {
+			return float32(v)
+		}
+	case "float8", "numeric", "decimal":
+		// Keep as float64
+		return value
+	case "bool":
+		// Keep as bool
+		return value
+	case "timestamp", "timestamptz", "date":
+		// Keep as time.Time
+		return value
+	case "bytea":
+		// Keep as []byte
+		return value
+	default:
+		// For strings and other types, keep as-is
+		return value
+	}
+
+	return value
+}
+
 // extractPartitionDataStreaming extracts partition data using streaming architecture
 // This streams data in chunks to a temp file, avoiding loading everything into memory
 //
@@ -2008,10 +2051,11 @@ func (a *Archiver) extractPartitionDataStreaming(partition PartitionInfo, progra
 			return
 		}
 
-		// Convert to map[string]interface{}
+		// Convert to map[string]interface{} with type conversion
 		rowData := make(map[string]interface{}, len(columns))
 		for i, col := range columns {
-			rowData[col.GetName()] = scanValues[i]
+			// Convert PostgreSQL driver types to appropriate Go types for formatters
+			rowData[col.GetName()] = convertPostgreSQLValue(scanValues[i], col.GetType())
 		}
 
 		chunk = append(chunk, rowData)