gaman-core 0.3.22

use super::{ParseError, parse_sql_raw as parse_sql};
use crate::states::{Constraint, Schema, Volatility};

// Helpers for SQL parser tests.

fn table<'a>(schema: &'a Schema, name: &str) -> &'a crate::states::Table {
    schema
        .tables
        .get(name)
        .unwrap_or_else(|| panic!("table '{name}' not found"))
}

fn col<'a>(schema: &'a Schema, tbl: &str, col: &str) -> &'a crate::states::Column {
    let t = table(schema, tbl);
    t.columns
        .iter()
        .find(|c| c.name == col)
        .unwrap_or_else(|| panic!("column '{col}' not found on table '{tbl}'"))
}

/// Verifies a minimal CREATE TABLE with a bigserial PK and a text column parses correctly.
#[test]
fn test_simple_table() {
    let sql = "CREATE TABLE users (id bigserial PRIMARY KEY, name text NOT NULL);";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();

    assert!(schema.tables.contains_key("users"));
    let id = col(&schema, "users", "id");
    assert!(id.primary_key);
    assert!(!id.nullable);

    let name = col(&schema, "users", "name");
    assert_eq!(name.col_type, "text");
    assert!(!name.nullable);
}

/// Confirms NULL and NOT NULL column modifiers set `nullable` correctly.
#[test]
fn test_column_nullability() {
    let sql = "CREATE TABLE t (
        a integer NOT NULL,
        b integer NULL,
        c integer
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(!col(&schema, "t", "a").nullable);
    assert!(col(&schema, "t", "b").nullable);
    // Postgres default: nullable when neither NULL nor NOT NULL is specified
    assert!(col(&schema, "t", "c").nullable);
}

/// Checks that a column DEFAULT expression is captured verbatim.
#[test]
fn test_column_default() {
    let sql = "CREATE TABLE t (created_at timestamptz NOT NULL DEFAULT now());";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let c = col(&schema, "t", "created_at");
    assert_eq!(c.default.as_deref(), Some("now()"));
}

/// Ensures a table-level PRIMARY KEY constraint marks the right column.
#[test]
fn test_table_level_primary_key() {
    let sql = "CREATE TABLE orders (
        id bigint,
        PRIMARY KEY (id)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let table = table(&schema, "orders");
    let pk = table.primary_key.as_ref().expect("primary key");
    assert_eq!(pk.name, "orders_pkey");
    assert_eq!(pk.columns, ["id"]);
    assert!(col(&schema, "orders", "id").primary_key);
}

#[test]
fn test_named_composite_primary_key_preserves_order() {
    let sql = "CREATE TABLE order_lines (
        order_id bigint,
        tenant_id bigint,
        CONSTRAINT order_lines_identity PRIMARY KEY (tenant_id, order_id)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let table = table(&schema, "order_lines");
    let pk = table.primary_key.as_ref().expect("primary key");
    assert_eq!(pk.name, "order_lines_identity");
    assert_eq!(pk.columns, ["tenant_id", "order_id"]);
    assert_eq!(table.primary_key_column_names(), ["tenant_id", "order_id"]);
    assert!(col(&schema, "order_lines", "tenant_id").primary_key);
    assert!(col(&schema, "order_lines", "order_id").primary_key);
}

/// Parses an inline column-level FOREIGN KEY reference.
#[test]
fn test_column_level_foreign_key() {
    let sql = "CREATE TABLE posts (
        id bigserial PRIMARY KEY,
        user_id bigint NOT NULL REFERENCES users(id)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "posts");
    assert_eq!(t.foreign_keys.len(), 1);
    let fk = &t.foreign_keys[0];
    assert_eq!(fk.columns, ["user_id"]);
    assert_eq!(fk.to_table, "users");
    assert_eq!(fk.to_columns, ["id"]);
    assert_eq!(fk.name, "posts_user_id_fkey");
}

/// Parses a table-level FOREIGN KEY with an explicit constraint name.
#[test]
fn test_table_level_foreign_key_named() {
    let sql = "CREATE TABLE posts (
        id bigserial PRIMARY KEY,
        user_id bigint NOT NULL,
        CONSTRAINT fk_posts_user FOREIGN KEY (user_id) REFERENCES users(id)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "posts");
    assert_eq!(t.foreign_keys.len(), 1);
    assert_eq!(t.foreign_keys[0].name, "fk_posts_user");
}

#[test]
fn test_named_composite_foreign_key_preserves_order() {
    let sql = "CREATE TABLE orders (
        tenant_id bigint,
        user_id bigint,
        CONSTRAINT orders_user_fkey FOREIGN KEY (tenant_id, user_id) REFERENCES users(tenant_id, id)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let fk = &table(&schema, "orders").foreign_keys[0];

    assert_eq!(fk.name, "orders_user_fkey");
    assert_eq!(fk.columns, ["tenant_id", "user_id"]);
    assert_eq!(fk.to_table, "users");
    assert_eq!(fk.to_columns, ["tenant_id", "id"]);
}

#[test]
fn test_unnamed_composite_foreign_key_uses_deterministic_name() {
    let sql = "CREATE TABLE orders (
        tenant_id bigint,
        user_id bigint,
        FOREIGN KEY (tenant_id, user_id) REFERENCES users(tenant_id, id)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let fk = &table(&schema, "orders").foreign_keys[0];

    assert_eq!(fk.name, "orders_tenant_id_user_id_fkey");
    assert_eq!(fk.columns, ["tenant_id", "user_id"]);
    assert_eq!(fk.to_columns, ["tenant_id", "id"]);
}

#[test]
fn test_composite_foreign_key_preserves_schema_qualified_target() {
    let sql = "CREATE TABLE orders (
        tenant_id bigint,
        user_id bigint,
        FOREIGN KEY (tenant_id, user_id) REFERENCES auth.users(tenant_id, id)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let fk = &table(&schema, "orders").foreign_keys[0];

    assert_eq!(fk.to_table, "auth.users");
    assert_eq!(fk.to_columns, ["tenant_id", "id"]);
}

/// Parses a table-level UNIQUE constraint and maps it to `Constraint::Unique`.
#[test]
fn test_table_level_unique_constraint() {
    let sql = "CREATE TABLE users (
        id bigserial PRIMARY KEY,
        email text NOT NULL,
        CONSTRAINT users_email_unique UNIQUE (email)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "users");
    let unique = t
        .constraints
        .iter()
        .find(|c| c.name() == "users_email_unique")
        .expect("unique constraint not found");
    assert!(matches!(unique, Constraint::Unique { columns, .. } if columns == &["email"]));
}

/// Parses a table-level CHECK constraint and maps it to `Constraint::Check`.
#[test]
fn test_table_level_check_constraint() {
    let sql = "CREATE TABLE products (
        id bigserial PRIMARY KEY,
        price numeric NOT NULL,
        CONSTRAINT products_price_positive CHECK (price > 0)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "products");
    let chk = t
        .constraints
        .iter()
        .find(|c| c.name() == "products_price_positive")
        .expect("check constraint not found");
    assert!(matches!(chk, Constraint::Check { expression, .. } if expression.contains("price")));
}

/// Parses a column-level CHECK constraint and auto-generates a name.
#[test]
fn test_column_level_check_constraint() {
    let sql = "CREATE TABLE products (
        price numeric CHECK (price > 0)
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "products");
    assert_eq!(t.constraints.len(), 1);
    assert_eq!(t.constraints[0].name(), "products_price_check");
}

/// Verifies mixed nullability across multiple columns.
#[test]
fn test_mixed_nullability() {
    let sql = "CREATE TABLE t (
        a text NOT NULL,
        b text NULL,
        c text NOT NULL,
        d text
    );";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(!col(&schema, "t", "a").nullable);
    assert!(col(&schema, "t", "b").nullable);
    assert!(!col(&schema, "t", "c").nullable);
    // Postgres default: nullable when neither NULL nor NOT NULL is specified
    assert!(col(&schema, "t", "d").nullable);
}

/// A plain CREATE INDEX is attached to the target table.
#[test]
fn test_create_index() {
    let sql = "
        CREATE TABLE articles (id bigserial PRIMARY KEY, title text);
        CREATE INDEX articles_title_idx ON articles (title);
    ";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "articles");
    assert_eq!(t.indexes.len(), 1);
    assert_eq!(t.indexes[0].name, "articles_title_idx");
    assert!(!t.indexes[0].unique);
    assert_eq!(t.indexes[0].columns, ["title"]);
}

/// CREATE UNIQUE INDEX sets `unique = true` on the resulting `Index`.
#[test]
fn test_create_unique_index() {
    let sql = "
        CREATE TABLE users (id bigserial PRIMARY KEY, email text);
        CREATE UNIQUE INDEX users_email_idx ON users (email);
    ";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "users");
    assert!(t.indexes[0].unique);
}

/// A partial index with a WHERE clause captures the predicate expression.
#[test]
fn test_partial_index_with_predicate() {
    let sql = "
        CREATE TABLE events (id bigserial PRIMARY KEY, active boolean);
        CREATE INDEX events_active_idx ON events (id) WHERE active = true;
    ";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "events");
    let idx = &t.indexes[0];
    assert!(
        idx.predicate.is_some(),
        "expected a predicate on the partial index"
    );
    assert!(idx.predicate.as_deref().unwrap().contains("active"));
}

/// CREATE INDEX that references a table not in the SQL returns an error.
#[test]
fn test_index_unknown_table_is_error() {
    let sql = "CREATE INDEX missing_idx ON ghost (id);";
    let err = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap_err();
    assert!(
        matches!(err, ParseError::UnknownTable { .. }),
        "expected UnknownTable error, got: {err}"
    );
}

/// A CREATE VIEW is stored in `schema.views` with its SELECT definition.
#[test]
fn test_create_view() {
    let sql = "CREATE VIEW active_users AS SELECT id, name FROM users WHERE active = true;";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(schema.views.contains_key("active_users"));
    let v = &schema.views["active_users"];
    assert_eq!(v.name, "active_users");
    assert!(v.definition.contains("active"));
}

/// CREATE EXTENSION is stored with name and optional version.
#[test]
fn test_create_extension() {
    let sql = "CREATE EXTENSION IF NOT EXISTS \"uuid-ossp\";";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(schema.extensions.contains_key("uuid-ossp"));
}

/// A CREATE TYPE AS ENUM is parsed into `schema.enums` with its label values.
#[test]
fn test_create_enum() {
    let sql = "CREATE TYPE mood AS ENUM ('happy', 'sad', 'neutral');";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(schema.enums.contains_key("mood"));
    let e = &schema.enums["mood"];
    assert_eq!(e.values, ["happy", "sad", "neutral"]);
}

/// A basic PL/pgSQL function is parsed into `schema.functions`.
#[test]
fn test_create_function() {
    let sql = r#"
        CREATE FUNCTION add_numbers(a integer, b integer) RETURNS integer
        LANGUAGE sql
        AS $$ SELECT a + b; $$;
    "#;
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(schema.functions.contains_key("add_numbers"));
    let f = &schema.functions["add_numbers"];
    assert_eq!(f.language, "sql");
    assert!(f.arguments.contains("integer"));
    assert_eq!(f.returns, "integer");
}

/// IMMUTABLE / STABLE / VOLATILE function attributes are mapped to `Volatility`.
#[test]
fn test_function_volatility() {
    let sql = r#"
        CREATE FUNCTION pure_fn() RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT 1; $$;
    "#;
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let f = &schema.functions["pure_fn"];
    assert_eq!(f.volatility, Volatility::Immutable);
}

/// SECURITY DEFINER is captured on the `FunctionDef`.
#[test]
fn test_function_security_definer() {
    let sql = r#"
        CREATE FUNCTION privileged() RETURNS void LANGUAGE sql SECURITY DEFINER AS $$ SELECT 1; $$;
    "#;
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let f = &schema.functions["privileged"];
    assert!(f.security_definer);
}

/// `public.tablename` resolves to schema = None (treated as default schema).
#[test]
fn test_public_schema_is_none() {
    let sql = "CREATE TABLE public.users (id bigserial PRIMARY KEY);";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    // Key should be just "users"
    assert!(schema.tables.contains_key("users"), "expected key 'users'");
    assert_eq!(schema.tables["users"].schema, None);
}

/// `myschema.tablename` resolves to schema = Some("myschema").
#[test]
fn test_custom_schema_is_preserved() {
    let sql = "CREATE TABLE analytics.events (id bigserial PRIMARY KEY);";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(schema.tables.contains_key("analytics.events"));
    assert_eq!(
        schema.tables["analytics.events"].schema,
        Some("analytics".to_string())
    );
}

/// Multiple CREATE statements in one SQL string are all loaded into the schema.
#[test]
fn test_multi_statement_sql() {
    let sql = "
        CREATE TABLE users (id bigserial PRIMARY KEY, name text NOT NULL);
        CREATE TABLE posts (id bigserial PRIMARY KEY, user_id bigint NOT NULL);
        CREATE INDEX posts_user_idx ON posts (user_id);
    ";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(schema.tables.contains_key("users"));
    assert!(schema.tables.contains_key("posts"));
    assert_eq!(table(&schema, "posts").indexes.len(), 1);
}

/// An unsupported statement (INSERT) produces `ParseError::UnsupportedStatement`.
#[test]
fn test_unsupported_statement_is_error() {
    let sql = "INSERT INTO users (name) VALUES ('alice');";
    let err = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap_err();
    assert!(
        matches!(err, ParseError::UnsupportedStatement { .. }),
        "expected Unsupported error, got: {err}"
    );
}

/// Parse errors in later segments report original source line and column context.
#[test]
fn test_parse_error_remaps_second_statement_location() {
    let sql = "\
CREATE TABLE ok (id integer);
CREATE TABLE broken (id integer,);
";
    let err = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap_err();
    let ParseError::Parse {
        line,
        segment_ordinal,
        segment_start_line,
        ..
    } = err
    else {
        panic!("expected Parse error");
    };

    assert_eq!(segment_ordinal, Some(2));
    assert_eq!(segment_start_line, Some(1));
    assert_eq!(line, Some(2));
}

/// Leading metadata comments remain part of the segment while parse errors still map to source.
#[test]
fn test_parse_error_remaps_location_with_leading_comments() {
    let sql = "\
-- metadata for next statement
CREATE TABLE broken (id integer,);
";
    let err = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap_err();
    let ParseError::Parse {
        line,
        segment_ordinal,
        segment_start_line,
        ..
    } = err
    else {
        panic!("expected Parse error");
    };

    assert_eq!(segment_ordinal, Some(1));
    assert_eq!(segment_start_line, Some(1));
    assert_eq!(line, Some(2));
}

/// Parse errors in an unterminated final statement still report original source location.
#[test]
fn test_parse_error_remaps_final_statement_without_semicolon() {
    let sql = "\
CREATE TABLE ok (id integer);
CREATE TABLE broken (
  id integer,
  name text,
)
";
    let err = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap_err();
    let ParseError::Parse {
        line,
        segment_ordinal,
        segment_start_line,
        ..
    } = err
    else {
        panic!("expected Parse error");
    };

    assert_eq!(segment_ordinal, Some(2));
    assert_eq!(segment_start_line, Some(1));
    assert_eq!(line, Some(5));
}

/// Duplicate table names produce `ParseError::DuplicateTable`.
#[test]
fn test_duplicate_table_is_error() {
    let sql = "
        CREATE TABLE users (id bigserial PRIMARY KEY);
        CREATE TABLE users (email text);
    ";
    let err = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap_err();
    assert!(
        matches!(err, ParseError::DuplicateTable(ref name) if name == "users"),
        "expected DuplicateTable error, got: {err}"
    );
}

/// Auto-generated index name is derived from table and columns when no name is provided.
#[test]
fn test_index_auto_name() {
    let sql = "
        CREATE TABLE orders (id bigserial PRIMARY KEY, status text);
        CREATE INDEX ON orders (status);
    ";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "orders");
    assert_eq!(t.indexes.len(), 1);
    assert_eq!(t.indexes[0].name, "orders_status_idx");
}

/// A column-level UNIQUE constraint generates an auto-name from table + column.
#[test]
fn test_column_level_unique_auto_name() {
    let sql = "CREATE TABLE users (id bigserial PRIMARY KEY, email text UNIQUE);";
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let t = table(&schema, "users");
    assert_eq!(t.constraints.len(), 1);
    assert_eq!(t.constraints[0].name(), "users_email_key");
}

/// Function argument modes (IN, OUT, INOUT) are included in the argument string.
#[test]
fn test_function_argument_modes() {
    let sql = r#"
        CREATE FUNCTION compute(IN a integer, OUT b integer)
        RETURNS integer LANGUAGE sql AS $$ SELECT a; $$;
    "#;
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    let f = &schema.functions["compute"];
    assert!(f.arguments.contains("IN"), "expected IN mode in arguments");
    assert!(
        f.arguments.contains("OUT"),
        "expected OUT mode in arguments"
    );
}

/// PostgreSQL parsing segments a function body with internal semicolons before lowering.
#[test]
fn test_postgres_segmented_function_trigger_body() {
    let sql = r#"
        CREATE TABLE users (id integer PRIMARY KEY);
        CREATE FUNCTION audit_users() RETURNS trigger LANGUAGE plpgsql AS $$
        BEGIN
          INSERT INTO audit_log VALUES (NEW.id);
          RETURN NEW;
        END;
        $$;
        CREATE TRIGGER users_ai AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION audit_users();
    "#;
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(schema.functions.contains_key("audit_users"));
    assert_eq!(table(&schema, "users").triggers.len(), 1);
}

/// SQLite parsing segments trigger bodies with internal semicolons before lowering.
#[test]
fn test_sqlite_segmented_trigger_body() {
    let sql = r#"
        CREATE TABLE users (id integer, touched integer);
        CREATE TRIGGER users_ai AFTER INSERT ON users
        BEGIN
          UPDATE users SET touched = 1 WHERE id = NEW.id;
          UPDATE users SET touched = touched + 1 WHERE id = NEW.id;
        END;
    "#;
    let schema = super::parse_sql(sql, crate::dialects::Dialect::Sqlite).unwrap();
    assert_eq!(table(&schema, "users").triggers.len(), 1);
}

/// Parsing accepts a final DDL statement without a trailing semicolon after segmentation.
#[test]
fn test_segmented_final_statement_without_semicolon() {
    let sql = r#"
        CREATE TABLE users (id integer PRIMARY KEY);
        CREATE TABLE posts (id integer PRIMARY KEY)
    "#;
    let schema = parse_sql(sql, crate::dialects::Dialect::Postgres).unwrap();
    assert!(schema.tables.contains_key("users"));
    assert!(schema.tables.contains_key("posts"));
}