alopex-sql 0.8.8

//! Planner error types for the Alopex SQL dialect.
//!
//! This module defines error types for the planning phase, including:
//! - Catalog errors (ALOPEX-C*): Table/column/index lookup failures
//! - Type errors (ALOPEX-T*): Type mismatches, constraint violations
//! - Feature errors (ALOPEX-F*): Unsupported features

use crate::ast::Span;
use thiserror::Error;

/// Planner errors for the Alopex SQL dialect.
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum PlannerError {
    /// Invalid PRAGMA name or value.
    #[error("invalid PRAGMA '{name}': {reason}")]
    InvalidPragma { name: String, reason: String },
    // === Catalog Errors (ALOPEX-C*) ===
    /// ALOPEX-C001: Table not found.
    #[error("error[ALOPEX-C001]: table '{name}' not found at line {line}, column {column}")]
    TableNotFound {
        name: String,
        line: u64,
        column: u64,
    },

    /// ALOPEX-C002: Table already exists.
    #[error("error[ALOPEX-C002]: table '{name}' already exists")]
    TableAlreadyExists { name: String },

    /// ALOPEX-C003: Column not found.
    #[error(
        "error[ALOPEX-C003]: column '{column}' not found in table '{table}' at line {line}, column {col}"
    )]
    ColumnNotFound {
        column: String,
        table: String,
        line: u64,
        col: u64,
    },

    /// ALOPEX-C004: Ambiguous column reference.
    #[error(
        "error[ALOPEX-C004]: ambiguous column '{column}' found in tables: {tables:?} at line {line}, column {col}"
    )]
    AmbiguousColumn {
        column: String,
        tables: Vec<String>,
        line: u64,
        col: u64,
    },

    /// ALOPEX-C005: Index already exists.
    #[error("error[ALOPEX-C005]: index '{name}' already exists")]
    IndexAlreadyExists { name: String },

    /// ALOPEX-C006: Index not found.
    #[error("error[ALOPEX-C006]: index '{name}' not found")]
    IndexNotFound { name: String },

    /// ALOPEX-C007: FROM-clause table function not in the closed registry.
    #[error(
        "error[ALOPEX-C007]: table function '{name}' does not exist at line {line}, column {column}"
    )]
    UnknownTableFunction {
        name: String,
        line: u64,
        column: u64,
    },

    // === Type Errors (ALOPEX-T*) ===
    /// ALOPEX-T001: Type mismatch.
    #[error(
        "error[ALOPEX-T001]: type mismatch at line {line}, column {column}: expected {expected}, found {found}"
    )]
    TypeMismatch {
        expected: String,
        found: String,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T002: Invalid operator for type.
    #[error(
        "error[ALOPEX-T002]: invalid operator '{op}' for type '{type_name}' at line {line}, column {column}"
    )]
    InvalidOperator {
        op: String,
        type_name: String,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T003: NULL constraint violation.
    #[error(
        "error[ALOPEX-T003]: null constraint violation for column '{column}' at line {line}, column {col}"
    )]
    NullConstraintViolation { column: String, line: u64, col: u64 },

    /// ALOPEX-T004: Vector dimension mismatch.
    #[error(
        "error[ALOPEX-T004]: vector dimension mismatch at line {line}, column {column}: expected {expected}, found {found}"
    )]
    VectorDimensionMismatch {
        expected: u32,
        found: u32,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T005: Invalid metric.
    #[error(
        "error[ALOPEX-T005]: invalid metric '{value}' at line {line}, column {column}. Valid options: cosine, l2, inner"
    )]
    InvalidMetric {
        value: String,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T006: Column count does not match value count.
    #[error(
        "error[ALOPEX-T006]: column count ({columns}) does not match value count ({values}) at line {line}, column {column}"
    )]
    ColumnValueCountMismatch {
        columns: usize,
        values: usize,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T007: Invalid expression for the current context.
    #[error("error[ALOPEX-T007]: invalid expression: {message}")]
    InvalidExpression { message: String },

    /// ALOPEX-T008: Set-operation inputs expose different numbers of columns.
    #[error(
        "error[ALOPEX-T008]: set operation column count mismatch: left {left}, right {right} at line {line}, column {column}"
    )]
    SetOperationColumnCountMismatch {
        left: usize,
        right: usize,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T009: A CTE column-name list does not match its query width.
    #[error(
        "error[ALOPEX-T009]: common table expression '{cte}' declares {declared} column names but its query returns {actual} columns at line {line}, column {column}"
    )]
    CteColumnCountMismatch {
        cte: String,
        declared: usize,
        actual: usize,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T010: A CTE column-name list contains the same name twice.
    #[error(
        "error[ALOPEX-T010]: common table expression '{cte}' declares column '{name}' more than once at line {line}, column {column}"
    )]
    DuplicateCteColumn {
        cte: String,
        name: String,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T011: VALUES rows expose different numbers of columns.
    #[error(
        "error[ALOPEX-T011]: VALUES row {row} has {actual} columns but row 1 has {expected} at line {line}, column {column}"
    )]
    ValuesColumnCountMismatch {
        row: usize,
        expected: usize,
        actual: usize,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T012: A relation alias column list does not match the relation
    /// width. Covers derived tables, base tables, and table functions
    /// (issue #151).
    #[error(
        "error[ALOPEX-T012]: relation alias '{alias}' declares {declared} column names but the relation has {actual} columns at line {line}, column {column}"
    )]
    TableAliasColumnCountMismatch {
        alias: String,
        declared: usize,
        actual: usize,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T013: Row operands expose different numbers of fields.
    #[error(
        "error[ALOPEX-T013]: row value has {actual} fields but its comparison operand has {expected} at line {line}, column {column}"
    )]
    RowArityMismatch {
        expected: usize,
        actual: usize,
        line: u64,
        column: u64,
    },

    /// ALOPEX-T014: DISTINCT ON keys do not form the initial ORDER BY prefix.
    /// Message and semantics follow PostgreSQL error 42P10 (D2 in
    /// docs/sql-distinct-on.md).
    #[error(
        "error[ALOPEX-T014]: SELECT DISTINCT ON expressions must match initial ORDER BY expressions at line {line}, column {column}"
    )]
    DistinctOnOrderByMismatch { line: u64, column: u64 },

    /// ALOPEX-T015: RIGHT or FULL JOIN with a LATERAL right side (issue #151).
    /// PostgreSQL rejects the same shape: the correlated side cannot be the
    /// null-supplying side of the join.
    #[error(
        "error[ALOPEX-T015]: {join_type} JOIN cannot have a LATERAL right side at line {line}, column {column}"
    )]
    LateralJoinTypeUnsupported {
        join_type: String,
        line: u64,
        column: u64,
    },

    // === Feature Errors (ALOPEX-F*) ===
    /// ALOPEX-F001: Unsupported feature.
    #[error(
        "error[ALOPEX-F001]: feature '{feature}' is not supported in this version. Expected in {version}"
    )]
    UnsupportedFeature {
        feature: String,
        version: String,
        line: u64,
        column: u64,
    },
}

impl PlannerError {
    /// Create a TableNotFound error from a span.
    pub fn table_not_found(name: impl Into<String>, span: Span) -> Self {
        Self::TableNotFound {
            name: name.into(),
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a TableAlreadyExists error.
    pub fn table_already_exists(name: impl Into<String>) -> Self {
        Self::TableAlreadyExists { name: name.into() }
    }

    /// Create an UnknownTableFunction error from a span.
    pub fn unknown_table_function(name: impl Into<String>, span: Span) -> Self {
        Self::UnknownTableFunction {
            name: name.into(),
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a LateralJoinTypeUnsupported error from a span.
    pub fn lateral_join_type_unsupported(join_type: impl Into<String>, span: Span) -> Self {
        Self::LateralJoinTypeUnsupported {
            join_type: join_type.into(),
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a ColumnNotFound error from a span.
    pub fn column_not_found(
        column: impl Into<String>,
        table: impl Into<String>,
        span: Span,
    ) -> Self {
        Self::ColumnNotFound {
            column: column.into(),
            table: table.into(),
            line: span.start.line,
            col: span.start.column,
        }
    }

    /// Create an AmbiguousColumn error from a span.
    pub fn ambiguous_column(column: impl Into<String>, tables: Vec<String>, span: Span) -> Self {
        Self::AmbiguousColumn {
            column: column.into(),
            tables,
            line: span.start.line,
            col: span.start.column,
        }
    }

    /// Create an IndexAlreadyExists error.
    pub fn index_already_exists(name: impl Into<String>) -> Self {
        Self::IndexAlreadyExists { name: name.into() }
    }

    /// Create an IndexNotFound error.
    pub fn index_not_found(name: impl Into<String>) -> Self {
        Self::IndexNotFound { name: name.into() }
    }

    /// Create a TypeMismatch error from a span.
    pub fn type_mismatch(
        expected: impl Into<String>,
        found: impl Into<String>,
        span: Span,
    ) -> Self {
        Self::TypeMismatch {
            expected: expected.into(),
            found: found.into(),
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create an InvalidExpression error.
    pub fn invalid_expression(message: impl Into<String>) -> Self {
        Self::InvalidExpression {
            message: message.into(),
        }
    }

    /// Create a set-operation column-count error from a span.
    pub fn set_operation_column_count_mismatch(left: usize, right: usize, span: Span) -> Self {
        Self::SetOperationColumnCountMismatch {
            left,
            right,
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a CTE column-count error from a span.
    pub fn cte_column_count_mismatch(
        cte: impl Into<String>,
        declared: usize,
        actual: usize,
        span: Span,
    ) -> Self {
        Self::CteColumnCountMismatch {
            cte: cte.into(),
            declared,
            actual,
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a duplicate CTE column-name error from a span.
    pub fn duplicate_cte_column(
        cte: impl Into<String>,
        column_name: impl Into<String>,
        span: Span,
    ) -> Self {
        Self::DuplicateCteColumn {
            cte: cte.into(),
            name: column_name.into(),
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a VALUES row-width error from a span.
    pub fn values_column_count_mismatch(
        row: usize,
        expected: usize,
        actual: usize,
        span: Span,
    ) -> Self {
        Self::ValuesColumnCountMismatch {
            row,
            expected,
            actual,
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a derived-table alias-width error from a span.
    pub fn table_alias_column_count_mismatch(
        alias: impl Into<String>,
        declared: usize,
        actual: usize,
        span: Span,
    ) -> Self {
        Self::TableAliasColumnCountMismatch {
            alias: alias.into(),
            declared,
            actual,
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create an InvalidOperator error from a span.
    pub fn invalid_operator(
        op: impl Into<String>,
        type_name: impl Into<String>,
        span: Span,
    ) -> Self {
        Self::InvalidOperator {
            op: op.into(),
            type_name: type_name.into(),
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a NullConstraintViolation error from a span.
    pub fn null_constraint_violation(column: impl Into<String>, span: Span) -> Self {
        Self::NullConstraintViolation {
            column: column.into(),
            line: span.start.line,
            col: span.start.column,
        }
    }

    /// Create a VectorDimensionMismatch error from a span.
    pub fn vector_dimension_mismatch(expected: u32, found: u32, span: Span) -> Self {
        Self::VectorDimensionMismatch {
            expected,
            found,
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create an InvalidMetric error from a span.
    pub fn invalid_metric(value: impl Into<String>, span: Span) -> Self {
        Self::InvalidMetric {
            value: value.into(),
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a ColumnValueCountMismatch error from a span.
    pub fn column_value_count_mismatch(columns: usize, values: usize, span: Span) -> Self {
        Self::ColumnValueCountMismatch {
            columns,
            values,
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create a DistinctOnOrderByMismatch error from a span.
    pub fn distinct_on_order_by_mismatch(span: Span) -> Self {
        Self::DistinctOnOrderByMismatch {
            line: span.start.line,
            column: span.start.column,
        }
    }

    /// Create an UnsupportedFeature error from a span.
    pub fn unsupported_feature(
        feature: impl Into<String>,
        version: impl Into<String>,
        span: Span,
    ) -> Self {
        Self::UnsupportedFeature {
            feature: feature.into(),
            version: version.into(),
            line: span.start.line,
            column: span.start.column,
        }
    }
}