aegis_query/

parser.rs

//! Aegis Parser - SQL Parser
//!
//! Wraps sqlparser-rs to parse SQL statements and convert them to the
//! internal Aegis AST representation. Handles dialect differences and
//! provides friendly error messages.
//!
//! Key Features:
//! - Full ANSI SQL support via sqlparser-rs
//! - Conversion to typed Aegis AST
//! - Detailed parse error reporting
//! - Support for multiple SQL dialects
//!
//! @version 0.1.0
//! @author AutomataNexus Development Team

use crate::ast::*;
use aegis_common::{AegisError, DataType, Result};
use sqlparser::ast as sp;
use sqlparser::dialect::GenericDialect;
use sqlparser::parser::Parser as SqlParser;

// =============================================================================
// Parser
// =============================================================================

/// SQL parser wrapping sqlparser-rs.
pub struct Parser {
    dialect: GenericDialect,
}

impl Parser {
    pub fn new() -> Self {
        Self {
            dialect: GenericDialect {},
        }
    }

    /// Parse a SQL string into statements.
    pub fn parse(&self, sql: &str) -> Result<Vec<Statement>> {
        let ast = SqlParser::parse_sql(&self.dialect, sql)
            .map_err(|e| AegisError::Parse(e.to_string()))?;

        ast.into_iter()
            .map(|stmt| self.convert_statement(stmt))
            .collect()
    }

    /// Parse a single statement.
    pub fn parse_single(&self, sql: &str) -> Result<Statement> {
        let statements = self.parse(sql)?;
        if statements.len() != 1 {
            return Err(AegisError::Parse(format!(
                "Expected 1 statement, got {}",
                statements.len()
            )));
        }
        // Safe to use expect here: we verified statements.len() == 1 above
        Ok(statements
            .into_iter()
            .next()
            .expect("statements verified to have exactly 1 element"))
    }

    fn convert_statement(&self, stmt: sp::Statement) -> Result<Statement> {
        match stmt {
            sp::Statement::Query(query) => self.convert_query_to_statement(*query),
            sp::Statement::Insert(insert) => {
                let insert_stmt = self.convert_insert(insert)?;
                Ok(Statement::Insert(insert_stmt))
            }
            sp::Statement::Update {
                table,
                assignments,
                from: _,
                selection,
                returning: _,
                ..
            } => {
                let update_stmt = self.convert_update(table, assignments, selection)?;
                Ok(Statement::Update(update_stmt))
            }
            sp::Statement::Delete(delete) => {
                let delete_stmt = self.convert_delete(delete)?;
                Ok(Statement::Delete(delete_stmt))
            }
            sp::Statement::CreateTable(create) => {
                let create_stmt = self.convert_create_table(create)?;
                Ok(Statement::CreateTable(create_stmt))
            }
            sp::Statement::Drop {
                object_type,
                if_exists,
                names,
                ..
            } => self.convert_drop(object_type, if_exists, names),
            sp::Statement::CreateIndex(create) => {
                let create_stmt = self.convert_create_index(create)?;
                Ok(Statement::CreateIndex(create_stmt))
            }
            sp::Statement::AlterTable {
                name, operations, ..
            } => {
                let alter_stmt = self.convert_alter_table(name, operations)?;
                Ok(Statement::AlterTable(alter_stmt))
            }
            sp::Statement::StartTransaction { .. } => Ok(Statement::Begin),
            sp::Statement::Commit { .. } => Ok(Statement::Commit),
            sp::Statement::Rollback { .. } => Ok(Statement::Rollback),
            _ => Err(AegisError::Parse(format!(
                "Unsupported statement type: {:?}",
                stmt
            ))),
        }
    }

    /// Convert a query that may be a set operation into a Statement.
    /// Returns Statement::SetOperation for UNION/INTERSECT/EXCEPT,
    /// or Statement::Select for plain SELECTs.
    fn convert_query_to_statement(&self, query: sp::Query) -> Result<Statement> {
        if matches!(query.body.as_ref(), sp::SetExpr::SetOperation { .. }) {
            // Destructure the set operation
            match *query.body {
                sp::SetExpr::SetOperation {
                    op,
                    set_quantifier,
                    left,
                    right,
                } => {
                    let op_type = match (op, set_quantifier) {
                        (sp::SetOperator::Union, sp::SetQuantifier::All) => {
                            SetOperationType::UnionAll
                        }
                        (sp::SetOperator::Union, _) => SetOperationType::Union,
                        (sp::SetOperator::Intersect, _) => SetOperationType::Intersect,
                        (sp::SetOperator::Except, _) => SetOperationType::Except,
                    };
                    let make_query = |body: Box<sp::SetExpr>| sp::Query {
                        body,
                        order_by: None,
                        limit: None,
                        offset: None,
                        fetch: None,
                        with: None,
                        limit_by: vec![],
                        for_clause: None,
                        settings: None,
                        format_clause: None,
                        locks: vec![],
                    };
                    let left_stmt = self.convert_query_to_statement(make_query(left))?;
                    let right_stmt = self.convert_query_to_statement(make_query(right))?;
                    Ok(Statement::SetOperation(SetOperationStatement {
                        op: op_type,
                        left: Box::new(left_stmt),
                        right: Box::new(right_stmt),
                    }))
                }
                _ => unreachable!(),
            }
        } else {
            let select = self.convert_query(query)?;
            Ok(Statement::Select(select))
        }
    }

    fn convert_query(&self, query: sp::Query) -> Result<SelectStatement> {
        let body = match *query.body {
            sp::SetExpr::Select(select) => select,
            _ => return Err(AegisError::Parse("Unsupported query type".to_string())),
        };

        let columns = body
            .projection
            .into_iter()
            .map(|item| self.convert_select_item(item))
            .collect::<Result<Vec<_>>>()?;

        let from = if !body.from.is_empty() {
            Some(self.convert_from(&body.from)?)
        } else {
            None
        };

        let where_clause = body
            .selection
            .map(|expr| self.convert_expr(expr))
            .transpose()?;

        let group_by = match body.group_by {
            sp::GroupByExpr::Expressions(exprs, _) => exprs
                .into_iter()
                .map(|e| self.convert_expr(e))
                .collect::<Result<Vec<_>>>()?,
            sp::GroupByExpr::All(_) => Vec::new(),
        };

        let having = body.having.map(|e| self.convert_expr(e)).transpose()?;

        let order_by = query
            .order_by
            .map(|ob| {
                ob.exprs
                    .into_iter()
                    .map(|item| self.convert_order_by_item(item))
                    .collect::<Result<Vec<_>>>()
            })
            .transpose()?
            .unwrap_or_default();

        let limit = query.limit.map(|e| self.extract_limit(e)).transpose()?;

        let offset = query
            .offset
            .map(|o| self.extract_limit(o.value))
            .transpose()?;

        Ok(SelectStatement {
            distinct: body.distinct.is_some(),
            columns,
            from,
            where_clause,
            group_by,
            having,
            order_by,
            limit,
            offset,
        })
    }

    fn convert_select_item(&self, item: sp::SelectItem) -> Result<SelectColumn> {
        match item {
            sp::SelectItem::UnnamedExpr(expr) => Ok(SelectColumn::Expression {
                expr: self.convert_expr(expr)?,
                alias: None,
            }),
            sp::SelectItem::ExprWithAlias { expr, alias } => Ok(SelectColumn::Expression {
                expr: self.convert_expr(expr)?,
                alias: Some(alias.value),
            }),
            sp::SelectItem::Wildcard(_) => Ok(SelectColumn::AllColumns),
            sp::SelectItem::QualifiedWildcard(name, _) => {
                Ok(SelectColumn::TableAllColumns(name.to_string()))
            }
        }
    }

    fn convert_from(&self, from: &[sp::TableWithJoins]) -> Result<FromClause> {
        let first = from
            .first()
            .ok_or_else(|| AegisError::Parse("Empty FROM".to_string()))?;

        let source = self.convert_table_factor(&first.relation)?;

        let mut joins = Vec::new();
        for join in &first.joins {
            joins.push(self.convert_join(join)?);
        }

        Ok(FromClause { source, joins })
    }

    fn convert_table_factor(&self, factor: &sp::TableFactor) -> Result<TableReference> {
        match factor {
            sp::TableFactor::Table { name, alias, .. } => Ok(TableReference::Table {
                name: name.to_string(),
                alias: alias.as_ref().map(|a| a.name.value.clone()),
            }),
            sp::TableFactor::Derived {
                subquery, alias, ..
            } => {
                let alias_name = alias
                    .as_ref()
                    .map(|a| a.name.value.clone())
                    .ok_or_else(|| AegisError::Parse("Subquery requires alias".to_string()))?;
                Ok(TableReference::Subquery {
                    query: Box::new(self.convert_query(*subquery.clone())?),
                    alias: alias_name,
                })
            }
            _ => Err(AegisError::Parse("Unsupported table factor".to_string())),
        }
    }

    fn convert_join(&self, join: &sp::Join) -> Result<JoinClause> {
        let join_type = match &join.join_operator {
            sp::JoinOperator::Inner(_) => JoinType::Inner,
            sp::JoinOperator::LeftOuter(_) => JoinType::Left,
            sp::JoinOperator::RightOuter(_) => JoinType::Right,
            sp::JoinOperator::FullOuter(_) => JoinType::Full,
            sp::JoinOperator::CrossJoin => JoinType::Cross,
            _ => return Err(AegisError::Parse("Unsupported join type".to_string())),
        };

        let condition = match &join.join_operator {
            sp::JoinOperator::Inner(c)
            | sp::JoinOperator::LeftOuter(c)
            | sp::JoinOperator::RightOuter(c)
            | sp::JoinOperator::FullOuter(c) => match c {
                sp::JoinConstraint::On(expr) => Some(self.convert_expr(expr.clone())?),
                sp::JoinConstraint::None => None,
                _ => return Err(AegisError::Parse("Unsupported join constraint".to_string())),
            },
            sp::JoinOperator::CrossJoin => None,
            _ => None,
        };

        Ok(JoinClause {
            join_type,
            table: self.convert_table_factor(&join.relation)?,
            condition,
        })
    }

    fn convert_order_by_item(&self, item: sp::OrderByExpr) -> Result<OrderByItem> {
        Ok(OrderByItem {
            expression: self.convert_expr(item.expr)?,
            ascending: item.asc.unwrap_or(true),
            nulls_first: item.nulls_first,
        })
    }

    fn convert_expr(&self, expr: sp::Expr) -> Result<Expression> {
        match expr {
            sp::Expr::Identifier(ident) => Ok(Expression::Column(ColumnRef {
                table: None,
                column: ident.value,
            })),
            sp::Expr::CompoundIdentifier(idents) => {
                if idents.len() == 2 {
                    Ok(Expression::Column(ColumnRef {
                        table: Some(idents[0].value.clone()),
                        column: idents[1].value.clone(),
                    }))
                } else {
                    Ok(Expression::Column(ColumnRef {
                        table: None,
                        column: idents.last().map(|i| i.value.clone()).unwrap_or_default(),
                    }))
                }
            }
            sp::Expr::Value(value) => self.convert_value(value),
            sp::Expr::BinaryOp { left, op, right } => Ok(Expression::BinaryOp {
                left: Box::new(self.convert_expr(*left)?),
                op: self.convert_binary_op(op)?,
                right: Box::new(self.convert_expr(*right)?),
            }),
            sp::Expr::UnaryOp { op, expr } => Ok(Expression::UnaryOp {
                op: self.convert_unary_op(op)?,
                expr: Box::new(self.convert_expr(*expr)?),
            }),
            sp::Expr::Function(func) => {
                let args = match func.args {
                    sp::FunctionArguments::List(list) => list
                        .args
                        .into_iter()
                        .filter_map(|arg| match arg {
                            sp::FunctionArg::Unnamed(sp::FunctionArgExpr::Expr(e)) => {
                                Some(self.convert_expr(e))
                            }
                            _ => None,
                        })
                        .collect::<Result<Vec<_>>>()?,
                    _ => Vec::new(),
                };

                Ok(Expression::Function {
                    name: func.name.to_string(),
                    args,
                    distinct: false,
                })
            }
            sp::Expr::Nested(expr) => self.convert_expr(*expr),
            sp::Expr::IsNull(expr) => Ok(Expression::IsNull {
                expr: Box::new(self.convert_expr(*expr)?),
                negated: false,
            }),
            sp::Expr::IsNotNull(expr) => Ok(Expression::IsNull {
                expr: Box::new(self.convert_expr(*expr)?),
                negated: true,
            }),
            sp::Expr::InList {
                expr,
                list,
                negated,
            } => Ok(Expression::InList {
                expr: Box::new(self.convert_expr(*expr)?),
                list: list
                    .into_iter()
                    .map(|e| self.convert_expr(e))
                    .collect::<Result<Vec<_>>>()?,
                negated,
            }),
            sp::Expr::Between {
                expr,
                low,
                high,
                negated,
            } => Ok(Expression::Between {
                expr: Box::new(self.convert_expr(*expr)?),
                low: Box::new(self.convert_expr(*low)?),
                high: Box::new(self.convert_expr(*high)?),
                negated,
            }),
            sp::Expr::Like {
                expr,
                pattern,
                negated,
                ..
            } => Ok(Expression::Like {
                expr: Box::new(self.convert_expr(*expr)?),
                pattern: Box::new(self.convert_expr(*pattern)?),
                negated,
            }),
            _ => Err(AegisError::Parse(format!(
                "Unsupported expression: {:?}",
                expr
            ))),
        }
    }

    fn convert_value(&self, value: sp::Value) -> Result<Expression> {
        let literal = match value {
            sp::Value::Null => Literal::Null,
            sp::Value::Boolean(b) => Literal::Boolean(b),
            sp::Value::Number(n, _) => {
                if n.contains('.') {
                    Literal::Float(
                        n.parse()
                            .map_err(|_| AegisError::Parse("Invalid float".to_string()))?,
                    )
                } else {
                    Literal::Integer(
                        n.parse()
                            .map_err(|_| AegisError::Parse("Invalid integer".to_string()))?,
                    )
                }
            }
            sp::Value::SingleQuotedString(s) | sp::Value::DoubleQuotedString(s) => {
                Literal::String(s)
            }
            sp::Value::Placeholder(s) if s.starts_with('$') => {
                let idx: usize = s[1..]
                    .parse()
                    .map_err(|_| AegisError::Parse(format!("Invalid placeholder: {}", s)))?;
                return Ok(Expression::Placeholder(idx));
            }
            _ => return Err(AegisError::Parse("Unsupported literal value".to_string())),
        };
        Ok(Expression::Literal(literal))
    }

    fn convert_binary_op(&self, op: sp::BinaryOperator) -> Result<BinaryOperator> {
        match op {
            sp::BinaryOperator::Plus => Ok(BinaryOperator::Add),
            sp::BinaryOperator::Minus => Ok(BinaryOperator::Subtract),
            sp::BinaryOperator::Multiply => Ok(BinaryOperator::Multiply),
            sp::BinaryOperator::Divide => Ok(BinaryOperator::Divide),
            sp::BinaryOperator::Modulo => Ok(BinaryOperator::Modulo),
            sp::BinaryOperator::Eq => Ok(BinaryOperator::Equal),
            sp::BinaryOperator::NotEq => Ok(BinaryOperator::NotEqual),
            sp::BinaryOperator::Lt => Ok(BinaryOperator::LessThan),
            sp::BinaryOperator::LtEq => Ok(BinaryOperator::LessThanOrEqual),
            sp::BinaryOperator::Gt => Ok(BinaryOperator::GreaterThan),
            sp::BinaryOperator::GtEq => Ok(BinaryOperator::GreaterThanOrEqual),
            sp::BinaryOperator::And => Ok(BinaryOperator::And),
            sp::BinaryOperator::Or => Ok(BinaryOperator::Or),
            sp::BinaryOperator::StringConcat => Ok(BinaryOperator::Concat),
            _ => Err(AegisError::Parse(format!("Unsupported operator: {:?}", op))),
        }
    }

    fn convert_unary_op(&self, op: sp::UnaryOperator) -> Result<UnaryOperator> {
        match op {
            sp::UnaryOperator::Not => Ok(UnaryOperator::Not),
            sp::UnaryOperator::Minus => Ok(UnaryOperator::Negative),
            sp::UnaryOperator::Plus => Ok(UnaryOperator::Positive),
            _ => Err(AegisError::Parse(format!(
                "Unsupported unary operator: {:?}",
                op
            ))),
        }
    }

    fn convert_insert(&self, insert: sp::Insert) -> Result<InsertStatement> {
        let table = insert.table_name.to_string();

        let columns = if insert.columns.is_empty() {
            None
        } else {
            Some(insert.columns.into_iter().map(|c| c.value).collect())
        };

        let source = match insert.source {
            Some(query) => match *query.body {
                sp::SetExpr::Values(values) => {
                    let rows = values
                        .rows
                        .into_iter()
                        .map(|row| {
                            row.into_iter()
                                .map(|e| self.convert_expr(e))
                                .collect::<Result<Vec<_>>>()
                        })
                        .collect::<Result<Vec<_>>>()?;
                    InsertSource::Values(rows)
                }
                _ => InsertSource::Query(Box::new(self.convert_query(*query)?)),
            },
            None => return Err(AegisError::Parse("INSERT missing values".to_string())),
        };

        Ok(InsertStatement {
            table,
            columns,
            source,
        })
    }

    fn convert_update(
        &self,
        table: sp::TableWithJoins,
        assignments: Vec<sp::Assignment>,
        selection: Option<sp::Expr>,
    ) -> Result<UpdateStatement> {
        let table_name = match &table.relation {
            sp::TableFactor::Table { name, .. } => name.to_string(),
            _ => return Err(AegisError::Parse("UPDATE requires table name".to_string())),
        };

        let assigns = assignments
            .into_iter()
            .map(|a| {
                let column = match a.target {
                    sp::AssignmentTarget::ColumnName(names) => names
                        .0
                        .into_iter()
                        .map(|i| i.value)
                        .collect::<Vec<_>>()
                        .join("."),
                    sp::AssignmentTarget::Tuple(cols) => cols
                        .into_iter()
                        .map(|c| c.to_string())
                        .collect::<Vec<_>>()
                        .join(", "),
                };
                Ok(Assignment {
                    column,
                    value: self.convert_expr(a.value)?,
                })
            })
            .collect::<Result<Vec<_>>>()?;

        let where_clause = selection.map(|e| self.convert_expr(e)).transpose()?;

        Ok(UpdateStatement {
            table: table_name,
            assignments: assigns,
            where_clause,
        })
    }

    fn convert_delete(&self, delete: sp::Delete) -> Result<DeleteStatement> {
        let table = match delete.from {
            sp::FromTable::WithFromKeyword(tables) => tables
                .first()
                .map(|t| match &t.relation {
                    sp::TableFactor::Table { name, .. } => name.to_string(),
                    _ => String::new(),
                })
                .ok_or_else(|| AegisError::Parse("DELETE missing table".to_string()))?,
            sp::FromTable::WithoutKeyword(tables) => tables
                .first()
                .map(|t| match &t.relation {
                    sp::TableFactor::Table { name, .. } => name.to_string(),
                    _ => String::new(),
                })
                .ok_or_else(|| AegisError::Parse("DELETE missing table".to_string()))?,
        };

        let where_clause = delete.selection.map(|e| self.convert_expr(e)).transpose()?;

        Ok(DeleteStatement {
            table,
            where_clause,
        })
    }

    fn convert_create_table(&self, create: sp::CreateTable) -> Result<CreateTableStatement> {
        let columns = create
            .columns
            .into_iter()
            .map(|col| {
                Ok(ColumnDefinition {
                    name: col.name.value,
                    data_type: self.convert_data_type(&col.data_type)?,
                    nullable: !col
                        .options
                        .iter()
                        .any(|o| matches!(o.option, sp::ColumnOption::NotNull)),
                    default: col
                        .options
                        .iter()
                        .find_map(|o| match &o.option {
                            sp::ColumnOption::Default(e) => Some(self.convert_expr(e.clone())),
                            _ => None,
                        })
                        .transpose()?,
                    constraints: Vec::new(),
                })
            })
            .collect::<Result<Vec<_>>>()?;

        Ok(CreateTableStatement {
            name: create.name.to_string(),
            columns,
            constraints: Vec::new(),
            if_not_exists: create.if_not_exists,
        })
    }

    fn convert_drop(
        &self,
        object_type: sp::ObjectType,
        if_exists: bool,
        names: Vec<sp::ObjectName>,
    ) -> Result<Statement> {
        let name = names
            .first()
            .map(|n| n.to_string())
            .ok_or_else(|| AegisError::Parse("DROP missing name".to_string()))?;

        match object_type {
            sp::ObjectType::Table => {
                Ok(Statement::DropTable(DropTableStatement { name, if_exists }))
            }
            sp::ObjectType::Index => {
                Ok(Statement::DropIndex(DropIndexStatement { name, if_exists }))
            }
            _ => Err(AegisError::Parse(format!(
                "Unsupported DROP object type: {:?}",
                object_type
            ))),
        }
    }

    fn convert_create_index(&self, create: sp::CreateIndex) -> Result<CreateIndexStatement> {
        let name = create
            .name
            .map(|n| n.to_string())
            .ok_or_else(|| AegisError::Parse("CREATE INDEX missing name".to_string()))?;

        let table = create.table_name.to_string();

        let columns = create
            .columns
            .into_iter()
            .map(|c| c.expr.to_string())
            .collect();

        Ok(CreateIndexStatement {
            name,
            table,
            columns,
            unique: create.unique,
            if_not_exists: create.if_not_exists,
        })
    }

    fn convert_alter_table(
        &self,
        name: sp::ObjectName,
        operations: Vec<sp::AlterTableOperation>,
    ) -> Result<AlterTableStatement> {
        let ops = operations
            .into_iter()
            .map(|op| self.convert_alter_operation(op))
            .collect::<Result<Vec<_>>>()?;

        Ok(AlterTableStatement {
            name: name.to_string(),
            operations: ops,
        })
    }

    fn convert_alter_operation(&self, op: sp::AlterTableOperation) -> Result<AlterTableOperation> {
        match op {
            sp::AlterTableOperation::AddColumn { column_def, .. } => {
                let col = ColumnDefinition {
                    name: column_def.name.value.clone(),
                    data_type: self.convert_data_type(&column_def.data_type)?,
                    nullable: !column_def
                        .options
                        .iter()
                        .any(|o| matches!(o.option, sp::ColumnOption::NotNull)),
                    default: column_def
                        .options
                        .iter()
                        .find_map(|o| match &o.option {
                            sp::ColumnOption::Default(e) => Some(self.convert_expr(e.clone())),
                            _ => None,
                        })
                        .transpose()?,
                    constraints: Vec::new(),
                };
                Ok(AlterTableOperation::AddColumn(col))
            }
            sp::AlterTableOperation::DropColumn {
                column_name,
                if_exists,
                ..
            } => Ok(AlterTableOperation::DropColumn {
                name: column_name.value,
                if_exists,
            }),
            sp::AlterTableOperation::RenameColumn {
                old_column_name,
                new_column_name,
            } => Ok(AlterTableOperation::RenameColumn {
                old_name: old_column_name.value,
                new_name: new_column_name.value,
            }),
            sp::AlterTableOperation::RenameTable { table_name } => {
                Ok(AlterTableOperation::RenameTable {
                    new_name: table_name.to_string(),
                })
            }
            sp::AlterTableOperation::AlterColumn { column_name, op } => match op {
                sp::AlterColumnOperation::SetDataType { data_type, .. } => {
                    Ok(AlterTableOperation::AlterColumn {
                        name: column_name.value,
                        data_type: Some(self.convert_data_type(&data_type)?),
                        set_not_null: None,
                        set_default: None,
                    })
                }
                sp::AlterColumnOperation::SetNotNull => Ok(AlterTableOperation::AlterColumn {
                    name: column_name.value,
                    data_type: None,
                    set_not_null: Some(true),
                    set_default: None,
                }),
                sp::AlterColumnOperation::DropNotNull => Ok(AlterTableOperation::AlterColumn {
                    name: column_name.value,
                    data_type: None,
                    set_not_null: Some(false),
                    set_default: None,
                }),
                sp::AlterColumnOperation::SetDefault { value } => {
                    Ok(AlterTableOperation::AlterColumn {
                        name: column_name.value,
                        data_type: None,
                        set_not_null: None,
                        set_default: Some(Some(self.convert_expr(value)?)),
                    })
                }
                sp::AlterColumnOperation::DropDefault => Ok(AlterTableOperation::AlterColumn {
                    name: column_name.value,
                    data_type: None,
                    set_not_null: None,
                    set_default: Some(None),
                }),
                _ => Err(AegisError::Parse(format!(
                    "Unsupported ALTER COLUMN operation: {:?}",
                    op
                ))),
            },
            sp::AlterTableOperation::DropConstraint { name, .. } => {
                Ok(AlterTableOperation::DropConstraint { name: name.value })
            }
            _ => Err(AegisError::Parse(format!(
                "Unsupported ALTER TABLE operation: {:?}",
                op
            ))),
        }
    }

    fn convert_data_type(&self, dt: &sp::DataType) -> Result<DataType> {
        match dt {
            sp::DataType::Boolean => Ok(DataType::Boolean),
            sp::DataType::TinyInt(_) => Ok(DataType::TinyInt),
            sp::DataType::SmallInt(_) => Ok(DataType::SmallInt),
            sp::DataType::Int(_) | sp::DataType::Integer(_) => Ok(DataType::Integer),
            sp::DataType::BigInt(_) => Ok(DataType::BigInt),
            sp::DataType::Real => Ok(DataType::Float),
            sp::DataType::Float(_) | sp::DataType::Double | sp::DataType::DoublePrecision => {
                Ok(DataType::Double)
            }
            sp::DataType::Decimal(info) | sp::DataType::Numeric(info) => {
                let (precision, scale) = match info {
                    sp::ExactNumberInfo::PrecisionAndScale(p, s) => (*p as u8, *s as u8),
                    sp::ExactNumberInfo::Precision(p) => (*p as u8, 0),
                    sp::ExactNumberInfo::None => (18, 0),
                };
                Ok(DataType::Decimal { precision, scale })
            }
            sp::DataType::Char(len) => {
                let size = len
                    .as_ref()
                    .and_then(|l| match l {
                        sp::CharacterLength::IntegerLength { length, .. } => Some(*length as u16),
                        sp::CharacterLength::Max => None,
                    })
                    .unwrap_or(1);
                Ok(DataType::Char(size))
            }
            sp::DataType::Varchar(len) => {
                let size = len
                    .as_ref()
                    .and_then(|l| match l {
                        sp::CharacterLength::IntegerLength { length, .. } => Some(*length as u16),
                        sp::CharacterLength::Max => None,
                    })
                    .unwrap_or(255);
                Ok(DataType::Varchar(size))
            }
            sp::DataType::Text => Ok(DataType::Text),
            sp::DataType::Blob(_) => Ok(DataType::Blob),
            sp::DataType::Date => Ok(DataType::Date),
            sp::DataType::Time(..) => Ok(DataType::Time),
            sp::DataType::Timestamp(..) => Ok(DataType::Timestamp),
            sp::DataType::JSON => Ok(DataType::Json),
            sp::DataType::Uuid => Ok(DataType::Uuid),
            _ => Err(AegisError::Parse(format!(
                "Unsupported data type: {:?}",
                dt
            ))),
        }
    }

    fn extract_limit(&self, expr: sp::Expr) -> Result<u64> {
        match expr {
            sp::Expr::Value(sp::Value::Number(n, _)) => n
                .parse()
                .map_err(|_| AegisError::Parse("Invalid LIMIT value".to_string())),
            _ => Err(AegisError::Parse("LIMIT must be a number".to_string())),
        }
    }
}

impl Default for Parser {
    fn default() -> Self {
        Self::new()
    }
}

// =============================================================================
// Tests
// =============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_simple_select() {
        let parser = Parser::new();
        let stmt = parser.parse_single("SELECT id, name FROM users").unwrap();

        match stmt {
            Statement::Select(select) => {
                assert_eq!(select.columns.len(), 2);
                assert!(select.from.is_some());
            }
            _ => panic!("Expected SELECT statement"),
        }
    }

    #[test]
    fn test_parse_select_with_where() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("SELECT * FROM users WHERE age > 18")
            .unwrap();

        match stmt {
            Statement::Select(select) => {
                assert!(select.where_clause.is_some());
            }
            _ => panic!("Expected SELECT statement"),
        }
    }

    #[test]
    fn test_parse_select_with_join() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("SELECT u.name, o.total FROM users u JOIN orders o ON u.id = o.user_id")
            .unwrap();

        match stmt {
            Statement::Select(select) => {
                let from = select.from.unwrap();
                assert_eq!(from.joins.len(), 1);
                assert_eq!(from.joins[0].join_type, JoinType::Inner);
            }
            _ => panic!("Expected SELECT statement"),
        }
    }

    #[test]
    fn test_parse_insert() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("INSERT INTO users (name, age) VALUES ('Alice', 25)")
            .unwrap();

        match stmt {
            Statement::Insert(insert) => {
                assert_eq!(insert.table, "users");
                assert_eq!(
                    insert.columns,
                    Some(vec!["name".to_string(), "age".to_string()])
                );
            }
            _ => panic!("Expected INSERT statement"),
        }
    }

    #[test]
    fn test_parse_update() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("UPDATE users SET age = 26 WHERE name = 'Alice'")
            .unwrap();

        match stmt {
            Statement::Update(update) => {
                assert_eq!(update.table, "users");
                assert_eq!(update.assignments.len(), 1);
                assert!(update.where_clause.is_some());
            }
            _ => panic!("Expected UPDATE statement"),
        }
    }

    #[test]
    fn test_parse_delete() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("DELETE FROM users WHERE age < 18")
            .unwrap();

        match stmt {
            Statement::Delete(delete) => {
                assert_eq!(delete.table, "users");
                assert!(delete.where_clause.is_some());
            }
            _ => panic!("Expected DELETE statement"),
        }
    }

    #[test]
    fn test_parse_create_table() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single(
                "CREATE TABLE users (
                    id INTEGER NOT NULL,
                    name VARCHAR(255),
                    age INTEGER
                )",
            )
            .unwrap();

        match stmt {
            Statement::CreateTable(create) => {
                assert_eq!(create.name, "users");
                assert_eq!(create.columns.len(), 3);
                assert!(!create.columns[0].nullable);
                assert!(create.columns[1].nullable);
            }
            _ => panic!("Expected CREATE TABLE statement"),
        }
    }

    #[test]
    fn test_parse_transaction_statements() {
        let parser = Parser::new();

        assert!(matches!(
            parser.parse_single("BEGIN").unwrap(),
            Statement::Begin
        ));
        assert!(matches!(
            parser.parse_single("COMMIT").unwrap(),
            Statement::Commit
        ));
        assert!(matches!(
            parser.parse_single("ROLLBACK").unwrap(),
            Statement::Rollback
        ));
    }

    #[test]
    fn test_parse_union() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("SELECT id FROM users UNION SELECT id FROM orders")
            .unwrap();

        match stmt {
            Statement::SetOperation(set_op) => {
                assert_eq!(set_op.op, SetOperationType::Union);
                assert!(matches!(*set_op.left, Statement::Select(_)));
                assert!(matches!(*set_op.right, Statement::Select(_)));
            }
            _ => panic!("Expected SetOperation statement"),
        }
    }

    #[test]
    fn test_parse_union_all() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("SELECT id FROM users UNION ALL SELECT id FROM orders")
            .unwrap();

        match stmt {
            Statement::SetOperation(set_op) => {
                assert_eq!(set_op.op, SetOperationType::UnionAll);
            }
            _ => panic!("Expected SetOperation statement"),
        }
    }

    #[test]
    fn test_parse_intersect() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("SELECT id FROM users INTERSECT SELECT id FROM orders")
            .unwrap();

        match stmt {
            Statement::SetOperation(set_op) => {
                assert_eq!(set_op.op, SetOperationType::Intersect);
            }
            _ => panic!("Expected SetOperation statement"),
        }
    }

    #[test]
    fn test_parse_except() {
        let parser = Parser::new();
        let stmt = parser
            .parse_single("SELECT id FROM users EXCEPT SELECT id FROM orders")
            .unwrap();

        match stmt {
            Statement::SetOperation(set_op) => {
                assert_eq!(set_op.op, SetOperationType::Except);
            }
            _ => panic!("Expected SetOperation statement"),
        }
    }
}