Implement comprehensive multi-format DataFrame Spring integration with Spring Data patterns

[Copilot]

This PR extends the DataFrame Spring integration from CSV-only to comprehensive multi-format support, following Spring Data patterns for unified data source management.

Multi-Format Data Source Support

The implementation now supports all major DataFrame formats through dedicated annotations:

CSV Data Sources

@CsvDataSource(file = "sales.csv", delimiter = ',', header = true)
lateinit var salesData: DataFrame<*>

@CsvDataSource(file = "products.tsv", delimiter = '\t')
lateinit var productData: DataFrame<*>

JSON Data Sources

@JsonDataSource(file = "users.json")
lateinit var userData: DataFrame<*>

@JsonDataSource(
    file = "complex.json",
    typeClashTactic = JSON.TypeClashTactic.ANY_COLUMNS,
    keyValuePaths = ["user.preferences", "config.settings"]
)
lateinit var complexData: DataFrame<*>

Arrow/Parquet Data Sources

@ArrowDataSource(file = "analytics.parquet")
lateinit var analyticsData: DataFrame<*>

@ArrowDataSource(file = "timeseries.arrow", format = ArrowFormat.IPC)
lateinit var timeseriesData: DataFrame<*>

JDBC Data Sources

@JdbcDataSource(
    connectionBean = "dataSource",
    tableName = "customers"
)
lateinit var customerData: DataFrame<*>

@JdbcDataSource(
    url = "jdbc:h2:mem:testdb",
    username = "sa", 
    password = "",
    query = "SELECT * FROM orders WHERE status = 'COMPLETED'"
)
lateinit var orders: DataFrame<*>

Spring Data-Inspired Architecture

The design follows established Spring Data patterns:

• Declarative Annotations: Similar to @Query in Spring Data JPA
• Strategy Pattern: Format-specific processors handle different data sources
• Bean Integration: Leverages existing Spring infrastructure for connections
• Property Placeholders: Support for externalized configuration via ${...}
• Type Safety: Compile-time validation of format-specific parameters

Advanced Parameter Management

Each annotation provides type-safe parameters specific to its format:

• CSV: Custom delimiters, header configuration
• JSON: Type clash tactics, key-value path processing, number unification
• Arrow: Format detection, nullability options
• JDBC: Connection beans, custom queries, result limits

Real-World Usage

@Component
class AnalyticsService {
    
    @CsvDataSource(file = "exports/customers.csv")
    lateinit var customers: DataFrame<*>
    
    @JsonDataSource(file = "logs/events.json")
    lateinit var events: DataFrame<*>
    
    @ArrowDataSource(file = "ml/features.parquet")
    lateinit var features: DataFrame<*>
    
    @JdbcDataSource(
        connectionBean = "metricsDataSource",
        query = "SELECT * FROM metrics WHERE timestamp >= NOW() - INTERVAL '1 hour'"
    )
    lateinit var realtimeMetrics: DataFrame<*>
    
    fun generateReport() {
        // All data sources automatically loaded and ready to use
    }
}

Backward Compatibility

The original @DataSource annotation remains supported but is deprecated in favor of the more explicit @CsvDataSource.

Benefits

1. Unified Data Access: Consistent annotation-based approach across all formats
2. Reduced Boilerplate: No manual DataFrame construction required
3. Spring Integration: Leverages existing Spring beans and configuration
4. Developer Experience: Follows familiar Spring Data patterns
5. Type Safety: Format-specific parameters with compile-time validation

The implementation transforms DataFrame Spring integration from a CSV-specific utility into a comprehensive data access layer that rivals Spring Data in functionality while maintaining the power and flexibility of the DataFrame API.

Fixes #1321.

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

[zaleslaw]

@copilot extend this module to support of the different file formats (CSV, JSON, Parquet, Arrow) and try to find optimal solution if we have a lot of parameters for each file type, explore Spring Data approach to work with different data sources, also we also support JDBC, could it be also covered?

[Copilot]

@copilot extend this module to support of the different file formats (CSV, JSON, Parquet, Arrow) and try to find optimal solution if we have a lot of parameters for each file type, explore Spring Data...

I've implemented comprehensive multi-format support for the DataFrame Spring integration, extending it far beyond the original CSV-only implementation. The new design follows Spring Data patterns and includes:

🎯 Multi-Format Support:

• @CsvDataSource - CSV/TSV files with custom delimiters
• @JsonDataSource - JSON files with type clash handling
• @ArrowDataSource - Arrow/Parquet/Feather files with format auto-detection
• @JdbcDataSource - Database tables/queries with connection pooling

🏗️ Spring Data-Inspired Architecture:

• Declarative annotations similar to Spring Data repositories
• Strategy pattern for handling different data source types
• Bean reference support for database connections
• Property placeholder resolution for externalized config
• Comprehensive error handling with meaningful messages

⚙️ Advanced Parameter Management:

• Type-safe parameters specific to each format
• Flexible configuration supporting complex scenarios
• Sensible defaults minimizing boilerplate
• Support for Spring's ${...} property placeholders

📊 JDBC Integration:
Uses existing dataframe-jdbc module capabilities:

@JdbcDataSource(
    connectionBean = "dataSource", 
    query = "SELECT * FROM orders WHERE status = 'COMPLETED'",
    limit = 1000
)
lateinit var orders: DataFrame<*>

The implementation provides exactly what you requested - a unified approach handling multiple formats with optimal parameter management, closely following Spring Data patterns while maintaining the power and flexibility of the DataFrame API.

Commit: 66b692e