reddb-io-server 1.1.2

//! Function catalog — static table of built-in scalar / aggregate
//! function signatures used by the Fase 3 expression typer to
//! resolve `Expr::FunctionCall` nodes to a concrete return type.
//!
//! Mirrors PostgreSQL's `pg_proc` catalog with a deliberately
//! narrow row shape: a single (name, arg_types, return_type, kind)
//! entry per overload. Multiple entries may share the same name —
//! the resolver picks the one whose argument types match (after
//! implicit coercion) using the `func_select_candidate` heuristic
//! described in the roadmap (parte 4 of the plan file).
//!
//! The table is `const &[FunctionEntry]` so it lives in the
//! read-only segment and lookups stay cache-friendly. Linear
//! scan is fine for the ~30 entries the catalog covers today.
//! Future weeks can switch to a `HashMap<&'static str, &[…]>`
//! grouped by name when the table grows past ~500 entries.
//!
//! ## Coverage today
//!
//! Aggregates: COUNT, SUM, AVG, MIN, MAX (the five SQL-standard
//! ones). Each has multiple overloads for the numeric category.
//!
//! Scalars covered:
//!
//! - String: UPPER, LOWER, LENGTH, COALESCE
//! - Math:   ABS, ROUND, FLOOR, CEIL
//! - Time:   NOW, CURRENT_TIMESTAMP, CURRENT_DATE, TIME_BUCKET
//! - Geo:    GEO_DISTANCE, GEO_BEARING, HAVERSINE
//! - Misc:   VERIFY_PASSWORD
//!
//! Variadic functions (COALESCE, GREATEST, LEAST, CONCAT) are
//! marked with `variadic: true` and the resolver treats their
//! `arg_types` slice as a description of the *uniform* element
//! type — the catalog can't enumerate every arity, so the typer
//! checks each call-site argument against `arg_types[0]` instead.
//!
//! ## What's NOT in this catalog
//!
//! - User-defined functions (CREATE FUNCTION) — separate runtime
//!   table, queried after the static catalog yields no match.
//! - Polymorphic signatures (anyelement, anyarray) — Fase 3 W4.
//! - Operator functions backing `+`, `-`, `*` — those go in
//!   `pg_operator` equivalent which we haven't built yet.

use super::types::DataType;

/// Function classification — affects resolver behavior and
/// downstream planner cost estimation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FunctionKind {
    /// Pure scalar function: same input → same output, no side
    /// effects, no row-context dependency. The planner is free
    /// to constant-fold or push-down through joins.
    Scalar,
    /// Aggregate function: consumes a Vec of input values, produces
    /// a single output. Only valid in projection lists / HAVING /
    /// window frames.
    Aggregate,
    /// Window function: like aggregate but evaluates over an
    /// ORDER BY frame. Stays in projection lists only.
    Window,
    /// Side-effecting / time-dependent function: NOW(), RANDOM().
    /// The planner cannot cache results across rows.
    Volatile,
}

/// One signature in the static function catalog.
#[derive(Debug, Clone, Copy)]
pub struct FunctionEntry {
    pub name: &'static str,
    pub arg_types: &'static [DataType],
    pub return_type: DataType,
    pub kind: FunctionKind,
    /// When true, the catalog's `arg_types` describes the element
    /// type of a variadic argument list. Resolver matches each
    /// call-site argument against `arg_types[0]` and ignores
    /// arity entirely.
    pub variadic: bool,
}

const fn entry(
    name: &'static str,
    arg_types: &'static [DataType],
    return_type: DataType,
    kind: FunctionKind,
    variadic: bool,
) -> FunctionEntry {
    FunctionEntry {
        name,
        arg_types,
        return_type,
        kind,
        variadic,
    }
}

// ── Argument-list constants used by multiple entries ──
// These are static slices so the FunctionEntry::arg_types pointer
// stays the same across overloads sharing identical signatures.
// The compiler interns the slice symbols so there's no duplicate
// storage even if multiple entries reference the same array.

const ARGS_INT: &[DataType] = &[DataType::Integer];
const ARGS_FLOAT: &[DataType] = &[DataType::Float];
const ARGS_BIGINT: &[DataType] = &[DataType::BigInt];
const ARGS_TEXT: &[DataType] = &[DataType::Text];
const ARGS_TWO_TEXT: &[DataType] = &[DataType::Text, DataType::Text];
const ARGS_TEXT_INT: &[DataType] = &[DataType::Text, DataType::Integer];
const ARGS_TEXT_TWO_INT: &[DataType] = &[DataType::Text, DataType::Integer, DataType::Integer];
const ARGS_NONE: &[DataType] = &[];
const ARGS_TWO_FLOATS: &[DataType] = &[DataType::Float, DataType::Float];
const ARGS_GEO_PAIR: &[DataType] = &[DataType::GeoPoint, DataType::GeoPoint];
const ARGS_FOUR_FLOATS: &[DataType] = &[
    DataType::Float,
    DataType::Float,
    DataType::Float,
    DataType::Float,
];
const ARGS_TIME_BUCKET: &[DataType] = &[DataType::Text, DataType::Timestamp];
const ARGS_VERIFY_PWD: &[DataType] = &[DataType::Password, DataType::Text];
const ARGS_MONEY: &[DataType] = &[DataType::Money];
const ARGS_ONE_TEXT: &[DataType] = &[DataType::Text];
const ARGS_TWO_TEXT_ANY: &[DataType] = &[DataType::Text, DataType::Text];

// JSON function signatures (Phase 1.4 PG parity).
//
// RedDB accepts both Text and Json inputs interchangeably — the evaluator
// parses text on the fly. We list the Text overload in the catalog so
// existing text-column calls resolve without a cast; an explicit Json
// overload is included for schemas that actually use the Json type.
const ARGS_JSON_TEXT: &[DataType] = &[DataType::Text];
const ARGS_JSON_JSON: &[DataType] = &[DataType::Json];
const ARGS_JSON_EXTRACT_TEXT: &[DataType] = &[DataType::Text, DataType::Text];
const ARGS_JSON_EXTRACT_JSON: &[DataType] = &[DataType::Json, DataType::Text];
// JSON_SET takes (json, path, value). Value type is Unknown — the evaluator
// coerces any scalar at runtime (int, float, bool, text, or another json).
const ARGS_JSON_SET_TEXT: &[DataType] = &[DataType::Text, DataType::Text, DataType::Unknown];
const ARGS_JSON_SET_JSON: &[DataType] = &[DataType::Json, DataType::Text, DataType::Unknown];

/// The static function catalog. Append-only; removing a row is a
/// breaking change that may invalidate cached plans referencing
/// the function. Each block is grouped by category for readability.
pub const FUNCTION_CATALOG: &[FunctionEntry] = &[
    // ─────────────────────────────────────────────────────────────
    // Aggregate functions
    // ─────────────────────────────────────────────────────────────
    //
    // COUNT(*) and COUNT(col) are both modelled as `Integer →
    // Integer` here; the parser distinguishes the star form via
    // a separate Projection variant so the catalog doesn't need
    // a magic asterisk overload.
    entry(
        "COUNT",
        ARGS_INT,
        DataType::Integer,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "COUNT",
        ARGS_TEXT,
        DataType::Integer,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "COUNT",
        ARGS_FLOAT,
        DataType::Integer,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "SUM",
        ARGS_INT,
        DataType::Integer,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "SUM",
        ARGS_BIGINT,
        DataType::BigInt,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "SUM",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "AVG",
        ARGS_INT,
        DataType::Float,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "AVG",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "MIN",
        ARGS_INT,
        DataType::Integer,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "MIN",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "MIN",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "MAX",
        ARGS_INT,
        DataType::Integer,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "MAX",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "MAX",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "STDDEV",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "VARIANCE",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "GROUP_CONCAT",
        ARGS_TWO_TEXT,
        DataType::Text,
        FunctionKind::Aggregate,
        false,
    ),
    entry(
        "STRING_AGG",
        ARGS_TWO_TEXT,
        DataType::Text,
        FunctionKind::Aggregate,
        false,
    ),
    // ─────────────────────────────────────────────────────────────
    // Scalar — string
    // ─────────────────────────────────────────────────────────────
    entry(
        "UPPER",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "LOWER",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "LENGTH",
        ARGS_TEXT,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "CHAR_LENGTH",
        ARGS_TEXT,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "CHARACTER_LENGTH",
        ARGS_TEXT,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "OCTET_LENGTH",
        ARGS_TEXT,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "BIT_LENGTH",
        ARGS_TEXT,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "SUBSTRING",
        ARGS_TWO_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "SUBSTRING",
        ARGS_TEXT_INT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "SUBSTRING",
        ARGS_TEXT_TWO_INT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "SUBSTR",
        ARGS_TEXT_INT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "SUBSTR",
        ARGS_TEXT_TWO_INT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "POSITION",
        ARGS_TWO_TEXT,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "TRIM",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "TRIM",
        ARGS_TWO_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "LTRIM",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "LTRIM",
        ARGS_TWO_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "RTRIM",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "RTRIM",
        ARGS_TWO_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "BTRIM",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "BTRIM",
        ARGS_TWO_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "CONCAT",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        true,
    ),
    entry(
        "CONCAT_WS",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        true,
    ),
    entry(
        "REVERSE",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "LEFT",
        ARGS_TEXT_INT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "RIGHT",
        ARGS_TEXT_INT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "QUOTE_LITERAL",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    // COALESCE is variadic over a uniform element type. The
    // resolver matches each call-site arg against arg_types[0]
    // (any concrete type), and the return type is propagated
    // from the first non-null argument's type at typing time.
    entry(
        "COALESCE",
        ARGS_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        true,
    ),
    // ─────────────────────────────────────────────────────────────
    // Scalar — math
    // ─────────────────────────────────────────────────────────────
    entry(
        "ABS",
        ARGS_INT,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "ABS",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "ROUND",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "FLOOR",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "CEIL",
        ARGS_FLOAT,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    // ─────────────────────────────────────────────────────────────
    // Scalar — time
    // ─────────────────────────────────────────────────────────────
    //
    // NOW / CURRENT_TIMESTAMP / CURRENT_DATE are no-arg volatile
    // scalars that read the wall clock at evaluation time. The
    // planner must not constant-fold them across rows.
    entry(
        "NOW",
        ARGS_NONE,
        DataType::TimestampMs,
        FunctionKind::Volatile,
        false,
    ),
    entry(
        "CURRENT_TIMESTAMP",
        ARGS_NONE,
        DataType::TimestampMs,
        FunctionKind::Volatile,
        false,
    ),
    entry(
        "CURRENT_DATE",
        ARGS_NONE,
        DataType::Date,
        FunctionKind::Volatile,
        false,
    ),
    // Phase 2.5.3 multi-tenancy + PG session identity scalars. Marked
    // Volatile so the planner cannot constant-fold them across rows
    // — the thread-local value is hot-swappable per statement.
    entry(
        "CURRENT_TENANT",
        ARGS_NONE,
        DataType::Text,
        FunctionKind::Volatile,
        false,
    ),
    entry(
        "CURRENT_USER",
        ARGS_NONE,
        DataType::Text,
        FunctionKind::Volatile,
        false,
    ),
    entry(
        "SESSION_USER",
        ARGS_NONE,
        DataType::Text,
        FunctionKind::Volatile,
        false,
    ),
    entry(
        "CURRENT_ROLE",
        ARGS_NONE,
        DataType::Text,
        FunctionKind::Volatile,
        false,
    ),
    entry(
        "TIME_BUCKET",
        ARGS_TIME_BUCKET,
        DataType::TimestampMs,
        FunctionKind::Scalar,
        false,
    ),
    // ─────────────────────────────────────────────────────────────
    // Scalar — geo
    // ─────────────────────────────────────────────────────────────
    entry(
        "GEO_DISTANCE",
        ARGS_GEO_PAIR,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "GEO_DISTANCE",
        ARGS_FOUR_FLOATS,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "GEO_BEARING",
        ARGS_FOUR_FLOATS,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "HAVERSINE",
        ARGS_FOUR_FLOATS,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "VINCENTY",
        ARGS_FOUR_FLOATS,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    // ─────────────────────────────────────────────────────────────
    // Scalar — security
    // ─────────────────────────────────────────────────────────────
    //
    // VERIFY_PASSWORD takes a hashed Password column + a candidate
    // plaintext Text and returns Boolean. Marked Volatile because
    // the underlying argon2id verify is intentionally slow and the
    // planner should not cache results.
    entry(
        "VERIFY_PASSWORD",
        ARGS_VERIFY_PWD,
        DataType::Boolean,
        FunctionKind::Volatile,
        false,
    ),
    entry(
        "MONEY",
        ARGS_ONE_TEXT,
        DataType::Money,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "MONEY",
        ARGS_TWO_TEXT_ANY,
        DataType::Money,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "MONEY_ASSET",
        ARGS_MONEY,
        DataType::AssetCode,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "MONEY_MINOR",
        ARGS_MONEY,
        DataType::BigInt,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "MONEY_SCALE",
        ARGS_MONEY,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    // Two-floats variant used by some places (legacy dual-arg form).
    entry(
        "POWER",
        ARGS_TWO_FLOATS,
        DataType::Float,
        FunctionKind::Scalar,
        false,
    ),
    // ─────────────────────────────────────────────────────────────
    // Scalar — JSON (Phase 1.4 PG parity)
    // ─────────────────────────────────────────────────────────────
    //
    // JSON_EXTRACT(json_or_text, path) → Text
    //   Returns the value at `path` serialised as JSON text. Scalar strings
    //   come back with surrounding quotes; scalar numbers/booleans come back
    //   as bare tokens. Returns NULL when the path does not resolve.
    entry(
        "JSON_EXTRACT",
        ARGS_JSON_EXTRACT_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "JSON_EXTRACT",
        ARGS_JSON_EXTRACT_JSON,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    // JSON_EXTRACT_TEXT(json_or_text, path) → Text
    //   Same as JSON_EXTRACT but strings come back unquoted (PG `->>` style).
    entry(
        "JSON_EXTRACT_TEXT",
        ARGS_JSON_EXTRACT_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "JSON_EXTRACT_TEXT",
        ARGS_JSON_EXTRACT_JSON,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    // JSON_SET(json_or_text, path, value) → Json
    //   Immutable update — returns a new JSON blob with `value` written at `path`.
    //   Creates missing parent objects/arrays on the path.
    entry(
        "JSON_SET",
        ARGS_JSON_SET_TEXT,
        DataType::Json,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "JSON_SET",
        ARGS_JSON_SET_JSON,
        DataType::Json,
        FunctionKind::Scalar,
        false,
    ),
    // JSON_ARRAY_LENGTH(json) → Integer
    entry(
        "JSON_ARRAY_LENGTH",
        ARGS_JSON_TEXT,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "JSON_ARRAY_LENGTH",
        ARGS_JSON_JSON,
        DataType::Integer,
        FunctionKind::Scalar,
        false,
    ),
    // JSON_TYPEOF(json) → Text ("null" | "boolean" | "number" | "string" | "array" | "object")
    entry(
        "JSON_TYPEOF",
        ARGS_JSON_TEXT,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    entry(
        "JSON_TYPEOF",
        ARGS_JSON_JSON,
        DataType::Text,
        FunctionKind::Scalar,
        false,
    ),
    // JSON_VALID(text) → Boolean — returns true if the argument parses.
    entry(
        "JSON_VALID",
        ARGS_TEXT,
        DataType::Boolean,
        FunctionKind::Scalar,
        false,
    ),
    // JSON_ARRAY(any*) → Json — variadic array constructor.
    // Resolver uses arg_types[0] as the template; Unknown means "any scalar".
    entry(
        "JSON_ARRAY",
        &[DataType::Unknown],
        DataType::Json,
        FunctionKind::Scalar,
        true,
    ),
    // JSON_OBJECT(key, value, ...) → Json — variadic k/v pair object constructor.
    entry(
        "JSON_OBJECT",
        &[DataType::Unknown],
        DataType::Json,
        FunctionKind::Scalar,
        true,
    ),
];

/// Look up a function by name, returning the slice of overloads
/// (possibly empty). The resolver walks this slice and picks the
/// best match using its own coercion logic.
pub fn lookup(name: &str) -> Vec<&'static FunctionEntry> {
    FUNCTION_CATALOG
        .iter()
        .filter(|e| e.name.eq_ignore_ascii_case(name))
        .collect()
}

/// Resolve a function call to the best-matching overload. Returns
/// `None` when no overload matches the call-site argument types
/// (after implicit coercion).
///
/// **As of issue #82, this function delegates to
/// `coercion_spine::resolve_function`**. The spine owns the
/// coercion-aware overload-picking rule that used to live inline
/// here; the catalog itself is now a pure registry of `pg_proc`-style
/// rows. Callers that need the per-argument implicit-cast list
/// (which the runtime evaluator must apply before dispatch) should
/// call `coercion_spine::resolve_function` directly — this wrapper
/// only returns the entry to preserve the existing call-site
/// signature.
pub fn resolve(name: &str, arg_types: &[DataType]) -> Option<&'static FunctionEntry> {
    super::coercion_spine::resolve_function(name, arg_types).map(|(entry, _)| entry)
}