以下是根据您提供的内容整理的完整示例demo：

基础数据处理完整示例

use polar_core::data::{DataFrame, Series};

fn main() {
    // 创建两个Series
    let names = Series::new("names", vec!["Alice", "Bob", "Charlie"]);
    let scores = Series::new("scores", vec![85, 92, 78]);
    
    // 创建DataFrame并添加Series
    let mut df = DataFrame::new();
    df.add_column(names);
    df.add_column(scores);
    
    // 打印整个DataFrame
    println!("完整数据:");
    println!("{:?}", df);
    
    // 获取特定列
    if let Some(scores) = df.get_column("scores") {
        println!("分数列: {:?}", scores);
    }
}

扩展功能完整示例

use polar_core::extension::{Extension, ExtensionRegistry};
use polar_core::data::{DataFrame, Series};

// 自定义扩展：分数标准化
struct NormalizeExtension;

impl Extension for NormalizeExtension {
    fn name(&self) -> &str {
        "normalize"
    }
    
    fn process(&self, data: &mut DataFrame) {
        if let Some(scores) = data.get_column("scores") {
            // 计算最大值
            let max = scores.iter()
                .map(|v| v.as_i32().unwrap())
                .max()
                .unwrap_or(1) as f32;
            
            // 创建标准化后的分数列
            let normalized: Vec<f32> = scores.iter()
                .map(|v| v.as_i32().unwrap() as f32 / max)
                .collect();
            
            data.add_column(Series::new("normalized", normalized));
        }
    }
}

fn main() {
    // 创建扩展注册表并注册扩展
    let mut registry = ExtensionRegistry::new();
    registry.register(Box::new(NormalizeExtension));
    
    // 准备数据
    let mut df = DataFrame::new();
    df.add_column(Series::new("scores", vec![50, 80, 100]));
    
    // 应用扩展
    registry.process("normalize", &mut df);
    
    // 打印结果
    println!("标准化后的分数:");
    println!("{:?}", df.get_column("normalized"));
}

线程安全完整示例

use polar_core::data::DataFrame;
use std::sync::Arc;
use std::thread;

fn main() {
    // 创建共享DataFrame
    let df = Arc::new({
        let mut df = DataFrame::new();
        df.add_column(Series::new("data", vec![1, 2, 3, 4, 5]));
        df
    });
    
    // 创建4个线程处理数据
    let handles: Vec<_> = (0..4).map(|i| {
        let df = Arc::clone(&df);
        thread::spawn(move || {
            // 模拟数据处理
            println!("线程 {} 开始处理", i);
            if let Some(col) = df.get_column("data") {
                let sum: i32 = col.iter().map(|v| v.as_i32().unwrap()).sum();
                println!("线程 {} 计算结果: {}", i, sum);
            }
        })
    }).collect();
    
    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }
}

性能优化完整示例

use polar_core::data::{DataFrame, Series};
use polar_core::ops::{filter, transform};

fn main() {
    // 1. 预分配DataFrame
    let mut df = DataFrame::with_capacity(1000);
    
    // 2. 批量添加数据
    let values: Vec<i32> = (0..1000).collect();
    df.add_column(Series::new("values", values));
    
    // 3. 使用零拷贝转换
    transform(&mut df, |data| {
        // 对每个元素乘以2
        if let Some(col) = data.get_column_mut("values") {
            for v in col.iter_mut() {
                *v = v.as_i32().unwrap() * 2;
            }
        }
    });
    
    // 4. 批量过滤数据
    let filtered = filter(&df, "values", |val: &i32| *val > 1500);
    
    println!("过滤后的数据量: {}", filtered.len());
}

自定义扩展完整示例

use polar_core::extension::{Extension, ExtensionRegistry};
use polar_core::data::{DataFrame, Series};

// 自定义统计扩展
struct StatsExtension;

impl Extension for StatsExtension {
    fn name(&self) -> &str {
        "stats"
    }
    
    fn process(&self, data: &mut DataFrame) {
        if let Some(col) = data.get_column("values") {
            let values: Vec<i32> = col.iter()
                .map(|v| v.as_i32().unwrap())
                .collect();
            
            let sum: i32 = values.iter().sum();
            let avg = sum as f32 / values.len() as f32;
            let min = *values.iter().min().unwrap();
            let max = *values.iter().max().unwrap();
            
            // 添加统计结果
            data.add_column(Series::new("sum", vec![sum]));
            data.add_column(Series::new("avg", vec![avg]));
            data.add_column(Series::new("min", vec![min]));
            data.add_column(Series::new("max", vec![max]));
        }
    }
}

fn main() {
    // 初始化扩展系统
    let mut registry = ExtensionRegistry::new();
    registry.register(Box::new(StatsExtension));
    
    // 准备测试数据
    let mut df = DataFrame::new();
    df.add_column(Series::new("values", vec![10, 20, 30, 40, 50]));
    
    // 应用统计扩展
    registry.process("stats", &mut df);
    
    // 打印统计结果
    println!("总和: {:?}", df.get_column("sum"));
    println!("平均值: {:?}", df.get_column("avg"));
    println!("最小值: {:?}", df.get_column("min"));
    println!("最大值: {:?}", df.get_column("max"));
}