hints.rs

use tracing::trace;

use crate::hint_engine::LeafNode;
use crate::hint_engine::{
    GucParam, InternalNode, JoinAlgorithm, JoinNode, ParallelHint,
    ParallelMode, ScanMethod, engine::HintEngineConfig,
};

use std::fmt;

/// Enum for different classes of Postgres hints
///
/// See [Postgres Documentation](https://pg-hint-plan.readthedocs.io/en/latest/hint_list.html) for more details
///
/// Used to configure engine
///
#[derive(Hash, Eq, PartialEq, Debug, Clone)]

/// Supported hint groups for pg_hint_plan. See [pg_hint_plan](https://pg-hint-plan.readthedocs.io/en/latest/hint_list.html) for more details.
///
/// For supported variants of each group, see the `PgHint` enum.
///
/// # Variants
///
/// - JoinOrder: Specifies the join order of tables in a query. Output: Leading(t1 t2 t3)
/// - JoinOrderInnerOuter: Similar to JoinOrder, but preserves inner/outer table for each join. Output: Leading(((t1 t2) t3))
/// - JoinMethod: Specifies the join algorithm to use for joins. Output: HashJoin(t1 t2) also represents negative join methods like NoHashJoin(t1 t2)
/// - ScanMethod: Specifies the scan method to use for tables. Output: SeqScan(t1), IndexScan(t1 idx1), etc. Also represents negative scan methods like NoSeqScan(t1)
/// - RowNumberCorrection: Specifies the estimated number of rows for a table or join. Output: Rows(t1 t2 #1000)
/// - JoinMemoize: Specifies the join behavior (e.g., memoization) for joins. Output: Memoize(t1 t2)
pub enum PGHintType {
    JoinOrder,
    JoinOrderInnerOuter,
    JoinMethod,
    ScanMethod,
    RowNumberCorrection,
    JoinMemoize,
    GucParameter,
    Parallel,
}

/// Represents postgres hints
///
///
/// Represents a list of postgres hints.
///
/// The each hint references the join tree and only generates the hint text when formatted to string.
///
/// The native to_string method outputs the hints in the format required by pg_hint_plan.
/// # Fields
/// * `hints`: A vector of postgres hints
/// * `data`: The join tree that the hints are based on
/// * `config`: The configuration for the hint engine (which groups of hints to use, etc)
/// # Methods
/// * `new`: Creates a new empty hint list with the given configuration
/// * `add_hint`: Adds a hint to the hint list
/// * `size`: Returns the number of hints in the hint list
/// * `to_hint_table_string`: Returns the hints as a single string, concatenated by spaces (for use in a hint table)
/// * `from_join_tree`: Creates a hint list from a join tree and configuration
/// * `from_join_node`: Recursively adds hints from a join node (used by from_join_tree)
/// * `with_sql`: Returns the SQL representation of the hint list, prepended to the given SQL query
/// * `fmt::Display`: Formats the hint list as a string in the format required by pg_hint_plan
///
#[derive(Clone, Debug)]
pub struct PgHintList<'a> {
    hints: Vec<PgHint<'a>>,
    data: JoinNode,
    config: HintEngineConfig,
}

impl<'a> PgHintList<'a> {
    pub fn new(config: HintEngineConfig) -> Self {
        PgHintList {
            hints: Vec::new(),
            data: JoinNode::Leaf(LeafNode::new("".to_string())),
            config,
        }
    }

    pub fn get_data(&self) -> &JoinNode {
        &self.data
    }

    //// Get the length of the hint list
    //// Returns:
    //// - length of the hint list
    pub fn size(&self) -> usize {
        self.hints.len()
    }

    /// output hints concatenated by space, used for hint table
    ///  Returns:
    ///  - string of hints concatenated by space
    #[cfg(feature = "hint-table")]
    pub fn to_hint_table_string(&self) -> String {
        self.hints
            .iter()
            .map(|h| h.to_string())
            .collect::<Vec<_>>()
            .join(" ")
    }

    /// Add a hint to the hint list
    ///
    /// Should be used to add global hints that do not refer to join tree nodes. e.g., GUC Parameter hints
    pub fn add_hint(&mut self, hint: PgHint<'a>) {
        self.hints.push(hint);
    }

    /// Insert the hints into the pg_hint_plan hint table
    ///
    /// If hints for this query_id already exist, they will be overwritten.
    ///
    /// Arguments:
    /// * `client`: The Postgres client to use for the insertion
    /// * `query_id`: The query ID to associate the hints with
    /// Returns:
    /// * `Result<(), postgres::Error>`: Ok if successful, Err if there was an error
    #[cfg(feature = "hint-table")]
    pub fn insert_into_hint_table(
        &self,
        client: &mut postgres::Client,
        query_id: i64,
    ) -> Result<(), postgres::Error> {
        let hint_string = self.to_hint_table_string();
        trace!("Inserting hints for query_id {}: {}", query_id, hint_string);
        client.execute(
            "INSERT INTO hint_plan.hints (query_id, application_name, hints) VALUES ($1, '', $2)
             ON CONFLICT (query_id, application_name) DO UPDATE SET hints = EXCLUDED.hints",
            &[&query_id, &hint_string],
        )?;
        Ok(())
    }

    /// Create a PgHintList from a join tree and configuration
    ///
    /// TODO (bobby): Should this be part of engine?
    ///
    /// Arguments:
    /// * `root_node`: The root of the join tree, containing all children. Must be an InternalNode      
    /// * `config`: The configuration for the hint engine (which groups of hints to use
    ///
    /// Returns:
    /// * `Result<PgHintList, String>`: The generated hint list or an error message
    //// Note: This replaces the previous add_hint and concat_hint_list methods
    ///
    pub fn from_join_tree(
        root_node: &'a JoinNode,
        config: HintEngineConfig,
    ) -> Result<PgHintList<'a>, String> {
        let mut hint_list = PgHintList::new(config);
        hint_list.data = root_node.clone();
        hint_list.hints = Vec::new();

        // Add query level hints (Leading)
        if let JoinNode::Internal(internal) = root_node {
            if hint_list.config.is_hint_enabled(&PGHintType::JoinOrder) {
                hint_list.hints.push(PgHint::JoinOrder {
                    join_order: &internal,
                });
            } else if hint_list
                .config
                .is_hint_enabled(&PGHintType::JoinOrderInnerOuter)
            {
                hint_list.hints.push(PgHint::JoinOrderInnerOuter {
                    join_order: &internal,
                });
            }
        }
        // Begin recursion to add the rest of the hints
        hint_list.from_join_node(&root_node)?;

        Ok(hint_list)
    }

    /// Helper function to traverse join tree and add appriopriate hints based on configuration
    fn from_join_node(&mut self, node: &'a JoinNode) -> Result<(), String> {
        match node {
            JoinNode::Leaf(leaf) => {
                if self.config.is_hint_enabled(&PGHintType::ScanMethod) {
                    match &leaf.scan_method {
                        ScanMethod::SeqScan => {
                            self.hints.push(PgHint::SeqScan { table: leaf })
                        }
                        ScanMethod::Index(index_name) => {
                            self.hints.push(PgHint::IndexScan {
                                table: leaf,
                                index: index_name.clone().into(),
                            })
                        }
                        ScanMethod::IndexOnly(index_name) => {
                            self.hints.push(PgHint::IndexOnlyScan {
                                table: leaf,
                                index: index_name.clone().into(),
                            })
                        }
                        ScanMethod::BitmapScan => {
                            self.hints.push(PgHint::BitmapScan { table: leaf })
                        }
                        ScanMethod::TidScan => {
                            self.hints.push(PgHint::TidScan { table: leaf })
                        }
                        ScanMethod::NoSeqScan => {
                            self.hints.push(PgHint::NoSeqScan { table: leaf })
                        }
                        ScanMethod::NoTidScan => {
                            self.hints.push(PgHint::NoTidScan { table: leaf })
                        }
                        ScanMethod::NoIndexScan => {
                            self.hints.push(PgHint::NoIndexScan { table: leaf })
                        }
                        ScanMethod::NoIndexOnlyScan => self
                            .hints
                            .push(PgHint::NoIndexOnlyScan { table: leaf }),
                        ScanMethod::NoBitmapScan => self
                            .hints
                            .push(PgHint::NoBitmapScan { table: leaf }),
                        ScanMethod::IndexRegex(pattern) => {
                            self.hints.push(PgHint::IndexScanRegexp {
                                table: leaf,
                                pattern: pattern.clone(),
                            })
                        }
                        ScanMethod::IndexOnlyRegex(pattern) => {
                            self.hints.push(PgHint::IndexOnlyScanRegexp {
                                table: leaf,
                                pattern: pattern.clone(),
                            })
                        }
                        ScanMethod::BitmapRegex(pattern) => {
                            self.hints.push(PgHint::BitmapScanRegexp {
                                table: leaf,
                                pattern: pattern.clone(),
                            })
                        }
                        ScanMethod::Unknown => {}
                    }
                }

                if self.config.is_hint_enabled(&PGHintType::Parallel) {
                    if let Some(parallel_hint) = &leaf.parallel_hint {
                        self.hints.push(PgHint::Parallel {
                            table: leaf,
                            hint: parallel_hint.clone(),
                        });
                    }
                }
            }
            JoinNode::Internal(internal) => {
                if self.config.is_hint_enabled(&PGHintType::JoinMethod) {
                    match internal.join_algorithm {
                        JoinAlgorithm::HashJoin => self
                            .hints
                            .push(PgHint::HashJoin { node: &internal }),
                        JoinAlgorithm::MergeJoin => self
                            .hints
                            .push(PgHint::MergeJoin { node: &internal }),
                        JoinAlgorithm::NestedLoopJoin => self
                            .hints
                            .push(PgHint::NestLoop { node: &internal }),
                        JoinAlgorithm::NoHashJoin => self
                            .hints
                            .push(PgHint::NoHashJoin { node: &internal }),
                        JoinAlgorithm::NoMergeJoin => self
                            .hints
                            .push(PgHint::NoMergeJoin { node: &internal }),
                        JoinAlgorithm::NoNestedLoopJoin => self
                            .hints
                            .push(PgHint::NoNestLoop { node: &internal }),
                        JoinAlgorithm::Unknown => {}
                    }
                }

                let tables: Vec<String> = internal
                    .print_tables(false)
                    .unwrap_or_default()
                    .trim()
                    .split_whitespace()
                    .map(|s| s.to_string())
                    .collect();

                if self.config.is_hint_enabled(&PGHintType::JoinMemoize) {
                    if let Some(memoize) = internal.memoize {
                        if memoize {
                            self.hints
                                .push(PgHint::Memoize { node: &internal });
                        } else {
                            self.hints
                                .push(PgHint::NoMemoize { node: &internal });
                        }
                    }
                }
                if self
                    .config
                    .is_hint_enabled(&PGHintType::RowNumberCorrection)
                {
                    if let Some(card) = internal.join_card {
                        self.hints.push(PgHint::CardCorrection {
                            tables: tables.clone(),
                            card: card as i64,
                        });
                    }
                }

                self.from_join_node(&internal.inner)?;
                self.from_join_node(&internal.outer)?;
            }
        }

        Ok(())
    }

    /// Returns the SQL representation of the hint list, prepended to the given SQL query
    ///
    /// Arguments:
    ///    sql: The SQL query to prepend the hints to
    /// Returns:
    ///    A string containing the hints followed by the SQL query
    ///    If there are no hints, returns the original SQL query
    pub fn with_sql(&self, sql: &str) -> String {
        if self.hints.is_empty() {
            return sql.to_string();
        }
        format!("{}\n{}", self.to_string(), sql)
    }
}

impl fmt::Display for PgHintList<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.hints.is_empty() {
            return write!(f, "");
        }
        write!(
            f,
            "/*+ {} */",
            self.hints
                .iter()
                .map(|h| h.to_string())
                .collect::<Vec<_>>()
                .join("\n")
        )
    }
}

// Can add more hints here, just be sure to implement fmt::Display for them
#[derive(Clone, Debug)]
pub enum PgHint<'a> {
    SeqScan {
        table: &'a LeafNode,
    },
    IndexScan {
        table: &'a LeafNode,
        index: Option<String>,
    },
    NoSeqScan {
        table: &'a LeafNode,
    },
    NoTidScan {
        table: &'a LeafNode,
    },
    NoIndexScan {
        table: &'a LeafNode,
    },
    NoIndexOnlyScan {
        table: &'a LeafNode,
    },
    NoBitmapScan {
        table: &'a LeafNode,
    },
    BitmapScan {
        table: &'a LeafNode,
    },
    TidScan {
        table: &'a LeafNode,
    },
    JoinOrder {
        join_order: &'a InternalNode,
    },
    JoinOrderInnerOuter {
        // Variant to preserve inner/outer table for each join
        join_order: &'a InternalNode,
    },
    HashJoin {
        node: &'a InternalNode,
    },
    MergeJoin {
        node: &'a InternalNode,
    },
    IndexOnlyScan {
        table: &'a LeafNode,
        index: Option<String>,
    },
    NestLoop {
        node: &'a InternalNode,
    },
    CardCorrection {
        tables: Vec<String>,
        card: i64,
    },
    NoNestLoop {
        node: &'a InternalNode,
    },
    NoHashJoin {
        node: &'a InternalNode,
    },
    NoMergeJoin {
        node: &'a InternalNode,
    },
    Parallel {
        table: &'a LeafNode,
        hint: ParallelHint,
    },
    NoParallel {
        table: &'a LeafNode,
    },
    Memoize {
        node: &'a InternalNode,
    },
    NoMemoize {
        node: &'a InternalNode,
    },
    Set {
        param: GucParam,
    },
    IndexScanRegexp {
        table: &'a LeafNode,
        pattern: String,
    },
    IndexOnlyScanRegexp {
        table: &'a LeafNode,
        pattern: String,
    },
    BitmapScanRegexp {
        table: &'a LeafNode,
        pattern: String,
    },
}

impl fmt::Display for PgHint<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PgHint::SeqScan { table } => {
                f.write_str(&format!("SeqScan({})", table.get_effective_name()))
            }
            PgHint::IndexScan { table, index } => {
                if let Some(index) = index {
                    f.write_str(&format!(
                        "IndexScan({} {})",
                        table.get_effective_name(),
                        index
                    ))
                } else {
                    f.write_str(&format!(
                        "IndexScan({})",
                        table.get_effective_name()
                    ))
                }
            }
            PgHint::NoSeqScan { table } => f.write_str(&format!(
                "NoSeqScan({})",
                table.get_effective_name()
            )),
            PgHint::NoTidScan { table } => f.write_str(&format!(
                "NoTidScan({})",
                table.get_effective_name()
            )),
            PgHint::NoBitmapScan { table } => f.write_str(&format!(
                "NoBitmapScan({})",
                table.get_effective_name()
            )),
            PgHint::NoIndexScan { table } => f.write_str(&format!(
                "NoIndexScan({})",
                table.get_effective_name()
            )),
            PgHint::NoIndexOnlyScan { table } => f.write_str(&format!(
                "NoIndexOnlyScan({})",
                table.get_effective_name()
            )),
            PgHint::JoinOrder { join_order } => f.write_str(&format!(
                "Leading({})",
                (**join_order)
                    .print_tables(false)
                    .unwrap_or_default()
                    .trim()
            )),
            PgHint::JoinOrderInnerOuter { join_order } => {
                f.write_str(&format!(
                    "Leading({})",
                    (**join_order)
                        .print_tables(true)
                        .unwrap_or_default()
                        .trim()
                ))
            }
            PgHint::HashJoin { node } => f.write_str(&format!(
                "HashJoin({})",
                node.print_tables(false).unwrap_or_default().trim()
            )),
            PgHint::MergeJoin { node } => f.write_str(&format!(
                "MergeJoin({})",
                node.print_tables(false).unwrap_or_default().trim()
            )),
            PgHint::NestLoop { node } => f.write_str(&format!(
                "NestLoop({})",
                node.print_tables(false).unwrap_or_default().trim()
            )),
            PgHint::IndexOnlyScan { table, index } => {
                if let Some(index) = index {
                    f.write_str(&format!(
                        "IndexOnlyScan({} {})",
                        table.get_effective_name(),
                        index
                    ))
                } else {
                    f.write_str(&format!(
                        "IndexOnlyScan({})",
                        table.get_effective_name()
                    ))
                }
            }
            PgHint::BitmapScan { table } => f.write_str(&format!(
                "BitmapScan({})",
                table.get_effective_name()
            )),
            PgHint::TidScan { table } => {
                f.write_str(&format!("TidScan({})", table.get_effective_name()))
            }
            PgHint::CardCorrection { tables, card } => {
                f.write_str(&format!("Rows({} #{})", tables.join(" "), card))
            }
            PgHint::NoNestLoop { node } => f.write_str(&format!(
                "NoNestLoop({})",
                node.print_tables(false).unwrap_or_default().trim()
            )),
            PgHint::NoHashJoin { node } => f.write_str(&format!(
                "NoHashJoin({})",
                node.print_tables(false).unwrap_or_default().trim()
            )),
            PgHint::NoMergeJoin { node } => f.write_str(&format!(
                "NoMergeJoin({})",
                node.print_tables(false).unwrap_or_default().trim()
            )),
            PgHint::Parallel { table, hint } => {
                let mode_str = match &hint.mode {
                    Some(ParallelMode::Soft) => " soft",
                    Some(ParallelMode::Hard) => " hard",
                    None => "",
                };
                f.write_str(&format!(
                    "Parallel({} {}{})",
                    table.get_effective_name(),
                    hint.workers,
                    mode_str
                ))
            }
            PgHint::NoParallel { table } => f.write_str(&format!(
                "NoParallel({})",
                table.get_effective_name()
            )),
            PgHint::Memoize { node } => f.write_str(&format!(
                "Memoize({})",
                node.print_tables(false).unwrap_or_default().trim()
            )),
            PgHint::NoMemoize { node } => f.write_str(&format!(
                "NoMemoize({})",
                node.print_tables(false).unwrap_or_default().trim()
            )),
            PgHint::Set { param } => f.write_str(&format!(
                "Set({} {})",
                param.parameter, param.value
            )),
            PgHint::IndexScanRegexp { table, pattern } => {
                f.write_str(&format!(
                    "IndexScanRegexp({} {})",
                    table.get_effective_name(),
                    pattern
                ))
            }
            PgHint::IndexOnlyScanRegexp { table, pattern } => {
                f.write_str(&format!(
                    "IndexOnlyScanRegexp({} {})",
                    table.get_effective_name(),
                    pattern
                ))
            }
            PgHint::BitmapScanRegexp { table, pattern } => {
                f.write_str(&format!(
                    "BitmapScanRegexp({} {})",
                    table.get_effective_name(),
                    pattern
                ))
            }
        }
    }
}

// TODO: Add tests for new functionality
#[cfg(test)]
mod test_hints {
    use super::*;

    #[allow(unused_imports)]
    use crate::hint_engine::{
        JoinAlgorithm, LeafNode, PlanNodeMetadata, engine::HintEngineConfig,
        hints::PGHintType, visitor::PlanVisitor,
    };

    #[test]
    fn test_hint_display() {
        let hint = PgHint::SeqScan {
            table: &LeafNode {
                table_name: "title_basics".to_string(),
                table_alias: None,
                scan_method: ScanMethod::SeqScan,
                parallel_hint: None,
            },
        };
        assert_eq!(hint.to_string(), "SeqScan(title_basics)");

        // TODO(bobby): Add scan method hints

        let scan_tree = JoinNode::Internal(InternalNode {
            inner: Box::new(JoinNode::Leaf(
                LeafNode::new("title_basics".to_string())
                    .with_scan_method(ScanMethod::SeqScan),
            )),
            outer: Box::new(JoinNode::Leaf(
                LeafNode::new("title_ratings".to_string()).with_scan_method(
                    ScanMethod::Index("idx_title_ratings_tconst".to_string()),
                ),
            )),
            join_algorithm: JoinAlgorithm::HashJoin,
            join_card: None,
            memoize: None,
        });

        let scan_only_config = HintEngineConfig::new()
            .with_hint_type(PGHintType::ScanMethod)
            .build();

        let hint_list =
            PgHintList::from_join_tree(&scan_tree, scan_only_config).unwrap();
        // assert_eq!(hint_list.size(), 2);

        let expected_hints = "/*+ SeqScan(title_basics)\nIndexScan(title_ratings idx_title_ratings_tconst) */";

        assert_eq!(hint_list.to_string(), expected_hints);

        // let hint = PgHint::IndexScan {
        //     table: "title_basics".to_string(),
        //     index: Some("idx_title_basics_tconst".to_string()),
        // };
        // assert_eq!(
        //     hint.to_string(),
        //     "IndexScan(title_basics idx_title_basics_tconst)"
        // );

        // let hint = PgHint::NoSeqScan {
        //     table: "title_basics".to_string(),
        // };
        // assert_eq!(hint.to_string(), "NoSeqScan(title_basics)");

        // let hint = PgHint::NoIndexScan {
        //     table: "title_basics".to_string(),
        // };
        // assert_eq!(hint.to_string(), "NoIndexScan(title_basics)");

        // let hint = PgHint::NoIndexOnlyScan {
        //     table: "title_basics".to_string(),
        // };
        // assert_eq!(hint.to_string(), "NoIndexOnlyScan(title_basics)");

        // let hint = PgHint::JoinOrder {
        //     join_order: "title_basics, title_ratings".to_string(),
        // };
        // assert_eq!(hint.to_string(), "Leading(title_basics, title_ratings)");

        let tree = JoinNode::Internal(InternalNode {
            inner: Box::new(JoinNode::Leaf(LeafNode::new(
                "title_basics".to_string(),
            ))),
            outer: Box::new(JoinNode::Leaf(LeafNode::new(
                "title_ratings".to_string(),
            ))),
            join_algorithm: JoinAlgorithm::HashJoin,
            join_card: None,
            memoize: None,
        });

        let join_method_only_config = HintEngineConfig::new()
            .with_hint_type(PGHintType::JoinMethod)
            .build();

        let hint_list =
            PgHintList::from_join_tree(&tree, join_method_only_config).unwrap();

        assert_eq!(hint_list.size(), 1);
        assert_eq!(
            hint_list.to_string(),
            "/*+ HashJoin(title_basics title_ratings) */"
        );

        let join_order_and_method_config = HintEngineConfig::new()
            .with_hint_type(PGHintType::JoinOrder)
            .with_hint_type(PGHintType::JoinMethod)
            .build();

        let hint_list =
            PgHintList::from_join_tree(&tree, join_order_and_method_config)
                .unwrap();
        assert_eq!(hint_list.size(), 2);
        assert_eq!(
            hint_list.to_string(),
            "/*+ Leading(title_basics title_ratings)\nHashJoin(title_basics title_ratings) */"
        );

        let three_join_tree = JoinNode::Internal(InternalNode {
            inner: Box::new(tree.clone()),
            outer: Box::new(JoinNode::Leaf(LeafNode::new(
                "title_principals".to_string(),
            ))),
            join_algorithm: JoinAlgorithm::HashJoin,
            join_card: None,
            memoize: None,
        }); // ((A B) C)

        // Test with inner/outer preservation
        let join_order_inner_outer_config = HintEngineConfig::new()
            .with_hint_type(PGHintType::JoinOrderInnerOuter)
            .build();

        let hint_list = PgHintList::from_join_tree(
            &three_join_tree,
            join_order_inner_outer_config,
        )
        .unwrap();

        // TODO(bobby) clean up white space, but doesn't affect functionality
        assert_eq!(hint_list.size(), 1);
        assert_eq!(
            hint_list.to_string().replace(" ", ""),
            "/*+ Leading(((title_basics title_ratings) title_principals)) */"
                .replace(" ", "")
        );

        // Test table display with alias for join and scan method hints
        let alias_tree = JoinNode::Internal(InternalNode {
            inner: Box::new(JoinNode::Leaf(
                LeafNode::new("title_basics".to_string())
                    .with_alias("tb".to_string())
                    .with_scan_method(ScanMethod::SeqScan),
            )),
            outer: Box::new(JoinNode::Leaf(
                LeafNode::new("title_ratings".to_string())
                    .with_alias("tr".to_string())
                    .with_scan_method(ScanMethod::Index(
                        "idx_title_ratings_tconst".to_string(),
                    )),
            )),
            join_algorithm: JoinAlgorithm::HashJoin,
            join_card: None,
            memoize: None,
        });

        println!("Alias Tree: {:?}", alias_tree);

        let scan_config = HintEngineConfig::new()
            .with_hint_type(PGHintType::ScanMethod)
            .build();

        let hint_list =
            PgHintList::from_join_tree(&alias_tree, scan_config).unwrap();
        assert_eq!(hint_list.size(), 2);

        println!("Hint List: {:?}", hint_list);

        let expected_hints =
            "/*+ SeqScan(tb)\nIndexScan(tr idx_title_ratings_tconst) */";

        assert_eq!(
            hint_list.to_string().replace(" ", ""),
            expected_hints.replace(" ", "")
        );

        let join_config = HintEngineConfig::new()
            .with_hint_type(PGHintType::JoinMethod)
            .build();

        let hint_list =
            PgHintList::from_join_tree(&alias_tree, join_config).unwrap();
        assert_eq!(hint_list.size(), 1);
        assert_eq!(
            hint_list.to_string().replace(" ", ""),
            "/*+ HashJoin(tb tr) */".replace(" ", "")
        );
        //         "title_ratings".to_string(),
        //     ],
        // };
        // assert_eq!(hint.to_string(), "MergeJoin(title_basics, title_ratings)");

        // let hint = PgHint::IndexOnlyScan {
        //     table: "title_basics".to_string(),
        // };
        // assert_eq!(hint.to_string(), "IndexOnlyScan(title_basics)");

        // let hint = PgHint::ValueScan {
        //     table: "title_basics".to_string(),
        // };
        // assert_eq!(hint.to_string(), "ValueScan(title_basics)");

        // let hint = PgHint::SubqueryScan {
        //     table: "title_basics".to_string(),
        // };
        // assert_eq!(hint.to_string(), "SubqueryScan(title_basics)");
    }

    // #[test]
    // fn test_hint_list_display() {
    //     let config = HintEngineConfig::new()
    //         .with_hint_type(PGHintType::ScanMethod)
    //         .build();

    //     let mut hint_list = PgHintList::new(config);
    //     hint_list.add_hint(PgHint::SeqScan {
    //         table: "title_basics".to_string(),
    //     });
    //     hint_list.add_hint(PgHint::IndexScan {
    //         table: "title_basics".to_string(),
    //         index: Some("idx_title_basics_tconst".to_string()),
    //     });
    //     assert_eq!(
    //         hint_list.to_string(),
    //         "/*+ SeqScan(title_basics) IndexScan(title_basics idx_title_basics_tconst) */"
    //     );
    // }

    #[test]
    fn user_specified_negative_hints() {
        // Create a simple join tree: t1 join t2
        let tree = JoinNode::Internal(InternalNode {
            inner: Box::new(JoinNode::Leaf(
                LeafNode::new("t1".into())
                    .with_scan_method(ScanMethod::NoSeqScan),
            )),
            outer: Box::new(JoinNode::Leaf(
                LeafNode::new("t2".into())
                    .with_scan_method(ScanMethod::NoIndexScan),
            )),
            join_algorithm: JoinAlgorithm::NoNestedLoopJoin,
            join_card: None,
            memoize: None,
        });

        let cfg = HintEngineConfig::new()
            .with_hint_type(PGHintType::ScanMethod)
            .with_hint_type(PGHintType::JoinMethod)
            .build();

        let hints = PgHintList::from_join_tree(&tree, cfg).unwrap().to_string();
        eprintln!("{}", hints);

        assert!(hints.contains("NoSeqScan(t1)"));
        assert!(hints.contains("NoIndexScan(t2)"));
        assert!(hints.contains("NoNestLoop(t1 t2)"));
    }

    #[test]
    fn test_parallel_hints() {
        use crate::hint_engine::{
            InternalNode, JoinAlgorithm, JoinNode, LeafNode, ParallelHint,
            engine::HintEngineConfig,
        };

        // Create a simple join tree: t1 join t2
        let tree = JoinNode::Internal(InternalNode {
            inner: Box::new(JoinNode::Leaf(
                LeafNode::new("t1".into()).with_parallel_hint(ParallelHint {
                    workers: 8,
                    mode: None,
                }),
            )),
            outer: Box::new(JoinNode::Leaf(
                LeafNode::new("t2".into()).with_parallel_hint(ParallelHint {
                    workers: 0,
                    mode: Some(crate::hint_engine::ParallelMode::Hard),
                }),
            )),
            join_algorithm: JoinAlgorithm::HashJoin,
            join_card: None,
            memoize: None,
        });

        let cfg = HintEngineConfig::new()
            .with_hint_type(PGHintType::Parallel)
            .build();

        let hints = PgHintList::from_join_tree(&tree, cfg).unwrap().to_string();

        eprintln!("Generated Hints:\n{}", hints);

        assert!(hints.contains("Parallel(t1 8)"));
        assert!(hints.contains("Parallel(t2 0 hard)"));
    }

    #[test]
    fn user_specified_memoize_hints() {
        use crate::hint_engine::{
            InternalNode, JoinAlgorithm, JoinNode, LeafNode,
            engine::HintEngineConfig,
        };

        // Create a simple join tree: t1 join t2
        let tree = JoinNode::Internal(InternalNode {
            inner: Box::new(JoinNode::Leaf(LeafNode::new("t1".into()))),
            outer: Box::new(JoinNode::Leaf(LeafNode::new("t2".into()))),
            join_algorithm: JoinAlgorithm::HashJoin,
            join_card: None,
            memoize: Some(true),
        });

        let cfg = HintEngineConfig::new()
            .with_hint_type(PGHintType::JoinMemoize)
            .build();

        let hints = PgHintList::from_join_tree(&tree, cfg).unwrap().to_string();

        assert!(hints.contains("Memoize(t1 t2)"));
    }

    #[test]
    fn user_specified_guc_param_hints() {
        use crate::hint_engine::{
            InternalNode, JoinAlgorithm, JoinNode, LeafNode,
            engine::HintEngineConfig,
        };

        let tree = JoinNode::Internal(InternalNode {
            inner: Box::new(JoinNode::Leaf(LeafNode::new("t1".into()))),
            outer: Box::new(JoinNode::Leaf(LeafNode::new("t2".into()))),
            join_algorithm: JoinAlgorithm::HashJoin,
            join_card: None,
            memoize: None,
        });

        let cfg = HintEngineConfig::new()
            .with_hint_type(PGHintType::GucParameter)
            .build();

        let mut hints = PgHintList::from_join_tree(&tree, cfg).unwrap();
        hints.add_hint(PgHint::Set {
            param: GucParam {
                parameter: "random_page_cost".to_string(),
                value: "1.0".to_string(),
            },
        });
        hints.add_hint(PgHint::Set {
            param: GucParam {
                parameter: "work_mem".to_string(),
                value: "'256MB'".to_string(),
            },
        });
        hints.add_hint(PgHint::Set {
            param: GucParam {
                parameter: "enable_hashjoin".to_string(),
                value: "off".to_string(),
            },
        });

        let hints = hints.to_string();

        assert!(hints.contains("Set(random_page_cost 1.0)"));
        assert!(hints.contains("Set(work_mem '256MB')"));
        assert!(hints.contains("Set(enable_hashjoin off)"));
    }

    // #[test]
    // fn user_specified_regex_index_hints() {
    //     use crate::hint_engine::{
    //         IndexPattern, InternalNode, JoinAlgorithm, JoinNode, LeafNode,
    //         engine::HintEngineConfig,
    //     };

    //     // Create a three-table join tree: t1 join t2 join t3
    //     let tree = JoinNode::Internal(InternalNode {
    //         inner: Box::new(JoinNode::Internal(InternalNode {
    //             inner: Box::new(JoinNode::Leaf(LeafNode::new("t1".into()))),
    //             outer: Box::new(JoinNode::Leaf(LeafNode::new("t2".into()))),
    //             join_algorithm: JoinAlgorithm::HashJoin,
    //             join_card: None,
    //         })),
    //         outer: Box::new(JoinNode::Leaf(LeafNode::new("t3".into()))),
    //         join_algorithm: JoinAlgorithm::HashJoin,
    //         join_card: None,
    //     });

    //     let cfg = HintEngineConfig::new()
    //         .with_hint_type(PGHintType::RegexScan)
    //         .with_index_scan_regexp_hint(
    //             "t1",
    //             IndexPattern::Regex("^idx_.*_id$".into()),
    //         )
    //         .with_index_only_scan_regexp_hint(
    //             "t2",
    //             IndexPattern::Literal("idx_t2_name".into()),
    //         )
    //         .with_bitmap_scan_regexp_hint(
    //             "t3",
    //             IndexPattern::Regex("idx_t3_.*".into()),
    //         )
    //         .build();

    //     let hints = PgHintList::from_join_tree(&tree, cfg).unwrap().to_string();

    //     assert!(hints.contains("IndexScanRegexp(t1 ^idx_.*_id$)"));
    //     assert!(hints.contains("IndexOnlyScan(t2 idx_t2_name)"));
    //     assert!(hints.contains("BitmapScanRegexp(t3 idx_t3_.*)"));
    // }
}