remdb 0.3.1

//! SQL Aggregate Functions
//!
//! This module contains aggregate function implementations like COUNT, SUM, AVG, MIN, MAX, etc.

use crate::types::DataType;
use crate::types::TypedValue;
use crate::Value;

/// 执行COUNT函数
pub fn execute_count(_args: &[TypedValue]) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    // COUNT函数返回记录数，这里简单返回1，实际聚合时会累加
    Ok(TypedValue {
        value_type: DataType::UInt64,
        value: Value { u64: 1 },
    })
}

/// 执行SUM函数
pub fn execute_sum(args: &[TypedValue]) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.is_empty() {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    let arg = &args[0];

    // 根据参数类型返回对应的值
    unsafe {
        match arg.value_type {
            DataType::UInt8 => Ok(TypedValue {
                value_type: DataType::UInt64,
                value: Value {
                    u64: arg.value.u8 as u64,
                },
            }),
            DataType::UInt16 => Ok(TypedValue {
                value_type: DataType::UInt64,
                value: Value {
                    u64: arg.value.u16 as u64,
                },
            }),
            DataType::UInt32 => Ok(TypedValue {
                value_type: DataType::UInt64,
                value: Value {
                    u64: arg.value.u32 as u64,
                },
            }),
            DataType::UInt64 => Ok(arg.clone()),
            DataType::Int8 => Ok(TypedValue {
                value_type: DataType::Int64,
                value: Value {
                    i64: arg.value.i8 as i64,
                },
            }),
            DataType::Int16 => Ok(TypedValue {
                value_type: DataType::Int64,
                value: Value {
                    i64: arg.value.i16 as i64,
                },
            }),
            DataType::Int32 => Ok(TypedValue {
                value_type: DataType::Int64,
                value: Value {
                    i64: arg.value.i32 as i64,
                },
            }),
            DataType::Int64 => Ok(arg.clone()),
            DataType::Float32 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.float32 as f64,
                },
            }),
            DataType::Float64 => Ok(arg.clone()),
            _ => Err(crate::sql::QueryExecutionError::TypeMismatch),
        }
    }
}

/// 执行AVG函数
pub fn execute_avg(args: &[TypedValue]) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.is_empty() {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    let arg = &args[0];

    // 转换为浮点数类型
    unsafe {
        match arg.value_type {
            DataType::UInt8 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.u8 as f64,
                },
            }),
            DataType::UInt16 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.u16 as f64,
                },
            }),
            DataType::UInt32 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.u32 as f64,
                },
            }),
            DataType::UInt64 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.u64 as f64,
                },
            }),
            DataType::Int8 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.i8 as f64,
                },
            }),
            DataType::Int16 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.i16 as f64,
                },
            }),
            DataType::Int32 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.i32 as f64,
                },
            }),
            DataType::Int64 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.i64 as f64,
                },
            }),
            DataType::Float32 => Ok(TypedValue {
                value_type: DataType::Float64,
                value: Value {
                    float64: arg.value.float32 as f64,
                },
            }),
            DataType::Float64 => Ok(arg.clone()),
            _ => Err(crate::sql::QueryExecutionError::TypeMismatch),
        }
    }
}

/// 执行MIN函数
pub fn execute_min(args: &[TypedValue]) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.is_empty() {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    // MIN函数在聚合时会比较值，这里直接返回参数值
    Ok(args[0].clone())
}

/// 执行MAX函数
pub fn execute_max(args: &[TypedValue]) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.is_empty() {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    // MAX函数在聚合时会比较值，这里直接返回参数值
    Ok(args[0].clone())
}

/// 执行STDDEV函数
pub fn execute_stddev(args: &[TypedValue]) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.is_empty() {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    // STDDEV函数在聚合时计算标准差，这里直接返回参数值
    Ok(args[0].clone())
}

/// 执行VAR函数
pub fn execute_var(args: &[TypedValue]) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.is_empty() {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    // VAR函数在聚合时计算方差，这里直接返回参数值
    Ok(args[0].clone())
}

/// 执行STDDEV_SAMP函数
pub fn execute_stddev_samp(
    args: &[TypedValue],
) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.is_empty() {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    // STDDEV_SAMP函数在聚合时计算样本标准差，这里直接返回参数值
    Ok(args[0].clone())
}

/// 执行VAR_SAMP函数
pub fn execute_var_samp(
    args: &[TypedValue],
) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.is_empty() {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    // VAR_SAMP函数在聚合时计算样本方差，这里直接返回参数值
    Ok(args[0].clone())
}

/// 执行MOVING_AVERAGE函数
pub fn execute_moving_average(
    args: &[TypedValue],
) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.len() < 2 {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    // MOVING_AVERAGE函数：MOVING_AVERAGE(value, window_size)
    // 目前返回输入值，后续需要实现完整的滑动窗口逻辑
    Ok(args[0].clone())
}

/// 执行MOVING_SUM函数
pub fn execute_moving_sum(
    args: &[TypedValue],
) -> Result<TypedValue, crate::sql::QueryExecutionError> {
    if args.len() < 2 {
        return Err(crate::sql::QueryExecutionError::TypeMismatch);
    }

    // MOVING_SUM函数：MOVING_SUM(value, window_size)
    // 目前返回输入值，后续需要实现完整的滑动窗口逻辑
    Ok(args[0].clone())
}