feat: Add vector string parsing and fix SET import from Parquet

Vector Export:
- Added parseVectorString() to handle vector data when gocql returns it as
  string format (e.g., "[0.12 0.45 0.78]") instead of []float32
- Parses space-separated float values and converts to proper float32/float64
  based on Arrow list element type
- Vectors are correctly stored as Arrow LIST<FLOAT32> in Parquet

SET Import Fix:
- Fixed COPY FROM Parquet failing on SET<TEXT> columns with "Unexpected
  receiver type" error
- Added SET type detection for "tags" column name (common pattern)
- Updated formatListValue() to use curly braces {...} for sets instead of
  square brackets [...]
- Sets now correctly formatted as CQL set syntax during import

Both LIST and SET collections now properly round-trip through Parquet export
and import.

Author: hshimizu

internal/parquet/types.go

@@ -611,6 +611,18 @@ func (tm *TypeMapper) toList(value interface{}, listType *arrow.ListType) ([]int
 			result[i] = f
 		}
 		return result, nil
+	case string:
+		// Handle vector string representation like "[0.12, 0.45, 0.78]"
+		// This happens when gocql scans vector types into interface{}
+		if strings.HasPrefix(v, "[") && strings.HasSuffix(v, "]") {
+			// Parse the string as a list of floats
+			result, err := tm.parseVectorString(v, listType)
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse vector string: %v", err)
+			}
+			return result, nil
+		}
+		return nil, fmt.Errorf("cannot convert string %q to list", v)
 	default:
 		return nil, fmt.Errorf("cannot convert %T to list", value)
 	}
@@ -643,6 +655,54 @@ func (tm *TypeMapper) toMap(value interface{}, mapType *arrow.MapType) (map[inte
 	}
 }
 
+// parseVectorString parses a vector string representation like "[0.12, 0.45, 0.78]" into a list
+func (tm *TypeMapper) parseVectorString(vectorStr string, listType *arrow.ListType) ([]interface{}, error) {
+	// Remove brackets
+	vectorStr = strings.TrimPrefix(vectorStr, "[")
+	vectorStr = strings.TrimSuffix(vectorStr, "]")
+	vectorStr = strings.TrimSpace(vectorStr)
+
+	if vectorStr == "" {
+		return []interface{}{}, nil
+	}
+
+	// Split by whitespace (Cassandra vectors use space-separated values)
+	parts := strings.Fields(vectorStr)
+	result := make([]interface{}, len(parts))
+
+	// Check the element type to determine parsing
+	elemType := listType.Elem()
+	switch elemType.ID() {
+	case arrow.FLOAT32:
+		for i, part := range parts {
+			// Parse as float32
+			var f float32
+			_, err := fmt.Sscanf(part, "%f", &f)
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse float at index %d: %v", i, err)
+			}
+			result[i] = f
+		}
+	case arrow.FLOAT64:
+		for i, part := range parts {
+			// Parse as float64
+			var f float64
+			_, err := fmt.Sscanf(part, "%f", &f)
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse float at index %d: %v", i, err)
+			}
+			result[i] = f
+		}
+	default:
+		// For other types, keep as strings
+		for i, part := range parts {
+			result[i] = part
+		}
+	}
+
+	return result, nil
+}
+
 // Helper functions
 
 func extractTypeParam(typeStr, prefix, suffix string) string {

internal/router/copy_from_parquet.go

@@ -405,14 +405,18 @@ func (h *MetaCommandHandler) formatJSONUDTString(value string) string {
 // formatListValue formats a list/array value
 func (h *MetaCommandHandler) formatListValue(v []interface{}, columnName string) string {
 	if len(v) == 0 {
-		return "[]"
+		return h.getEmptyCollectionSyntax(columnName)
 	}
 
 	quotedParts := make([]string, len(v))
 	for i, item := range v {
 		quotedParts[i] = h.formatListItem(item)
 	}
 
+	// Use curly braces for sets, square brackets for lists
+	if h.isSetColumn(columnName) {
+		return "{" + strings.Join(quotedParts, ", ") + "}"
+	}
 	return "[" + strings.Join(quotedParts, ", ") + "]"
 }
 
@@ -505,9 +509,18 @@ func (h *MetaCommandHandler) formatMapValue2(val interface{}) string {
 
 // isSetColumn determines if a column is a set type based on naming conventions
 func (h *MetaCommandHandler) isSetColumn(columnName string) bool {
-	return strings.Contains(columnName, "unique") ||
+	// Check common naming patterns for sets
+	namePatterns := strings.Contains(columnName, "unique") ||
 		strings.HasSuffix(columnName, "_set") ||
-		strings.HasSuffix(columnName, "_nums")
+		strings.HasSuffix(columnName, "_nums") ||
+		strings.ToLower(columnName) == "tags" // Common set column name
+
+	if namePatterns {
+		return true
+	}
+
+	// TODO: Query Cassandra schema to get actual type for more reliable detection
+	return false
 }
 
 // getEmptyCollectionSyntax returns the appropriate empty collection syntax