Function test_large_query_no_panic

crates/core/src/sql/execute.rs:1421–1470

()

    /// Exercise the limit [`recursion::MAX_RECURSION_EXPR`]
    #[test]
    fn test_large_query_no_panic() -> ResultTest<()> {
        let db = TestDB::durable()?;

        let _table_id = db
            .create_table_for_test_multi_column(
                "test",
                &[("x", AlgebraicType::I32), ("y", AlgebraicType::I32)],
                col_list![0, 1],
            )
            .unwrap();

        let build_query = |total| {
            let mut sql = "select * from test where ".to_string();
            for x in 1..total {
                let fragment = format!("x = {x} or ");
                sql.push_str(&fragment.repeat((total - 1) as usize));
            }
            sql.push_str("(y = 0)");
            sql
        };
        let run = |db: &Arc<RelationalDB>, sep: char, sql_text: &str| {
            run_for_testing(db, sql_text).map_err(|e| e.to_string().split(sep).next().unwrap_or_default().to_string())
        };
        let sql = build_query(1_000);
        assert_eq!(
            run(&db, ':', &sql),
            Err("SQL query exceeds maximum allowed length".to_string())
        );

        let sql = build_query(41); // This causes stack overflow without the limit
        assert_eq!(run(&db, ',', &sql), Err("Recursion limit exceeded".to_string()));

        let sql = build_query(40); // The max we can with the current limit
        assert!(run(&db, ',', &sql).is_ok(), "Expected query to run without panic");

        // Check no overflow with lot of joins
        let mut sql = "SELECT test.* FROM test ".to_string();
        // We could push up to 700 joins without overflow as long we don't have any conditions,
        // but here execution become too slow.
        // TODO: Move this test to the `Plan`
        for i in 0..200 {
            sql.push_str(&format!("JOIN test AS m{i} ON test.x = m{i}.y "));
        }

        assert!(
            run(&db, ',', &sql).is_ok(),
            "Query with many joins and conditions should not overflow"
        );
        Ok(())
    }

    #[test]
    fn test_impossible_bounds_no_panic() -> ResultTest<()> {