refactor: receive parsed statement in planner rather than raw sql (#753)

Please be sure to look over the pull request guidelines here:
https://github.com/spaceandtimelabs/sxt-proof-of-sql/blob/main/CONTRIBUTING.md#submit-pr.

# Please go through the following checklist
- [ ] The PR title and commit messages adhere to guidelines here:
https://github.com/spaceandtimelabs/sxt-proof-of-sql/blob/main/CONTRIBUTING.md.
In particular `!` is used if and only if at least one breaking change
has been introduced.
- [ ] I have run the ci check script with `source
scripts/run_ci_checks.sh`.
- [ ] I have run the clean commit check script with `source
scripts/check_commits.sh`, and the commit history is certified to follow
clean commit guidelines as described here:
https://github.com/spaceandtimelabs/sxt-proof-of-sql/blob/main/COMMIT_GUIDELINES.md
- [ ] The latest changes from `main` have been incorporated to this PR
by simple rebase if possible, if not, then conflicts are resolved
appropriately.

# Rationale for this change

In order to avoid parsing twice, we want the planner to use a parsed
statement, rather than raw sql, to produce the `DynProofPlan`.

# What changes are included in this PR?

Modifying `conversion` functions to use `Statement`s rather than raw
sql.

# Are these changes tested?
Yes

Author: stuarttimwhite

crates/proof-of-sql-planner/src/conversion.rs

@@ -16,11 +16,7 @@ use proof_of_sql::{
     base::database::{ParseError, TableRef},
     sql::proof_plans::DynProofPlan,
 };
-use sqlparser::{
-    ast::{visit_relations, Statement},
-    dialect::GenericDialect,
-    parser::Parser,
-};
+use sqlparser::ast::{visit_relations, Statement};
 use std::ops::ControlFlow;
 
 /// Get [`Optimizer`]
@@ -51,7 +47,7 @@ pub fn optimizer() -> Optimizer {
 /// 4. Optimize the `LogicalPlan` using `Optimizer`
 /// 5. Convert the optimized `LogicalPlan` into a Proof of SQL plan
 fn sql_to_posql_plans<S, T, F>(
-    sql: &str,
+    statements: &[Statement],
     context_provider: &S,
     schemas: &IndexMap<TableReference, DFSchema>,
     config: &ConfigOptions,
@@ -62,9 +58,8 @@ where
     F: Fn(&LogicalPlan, &IndexMap<TableReference, DFSchema>) -> PlannerResult<T>,
 {
     // 1. Parse the SQL query into AST using sqlparser
-    let dialect = GenericDialect {};
-    let asts = Parser::parse_sql(&dialect, sql)?;
-    asts.iter()
+    statements
+        .iter()
         .map(|ast| -> PlannerResult<T> {
             // 2. Convert the AST into a `LogicalPlan` using `SqlToRel`
             let raw_logical_plan =
@@ -88,13 +83,13 @@ where
 ///
 /// See `sql_to_posql_plans` for more details
 pub fn sql_to_proof_plans<S: ContextProvider>(
-    sql: &str,
+    statements: &[Statement],
     context_provider: &S,
     schemas: &IndexMap<TableReference, DFSchema>,
     config: &ConfigOptions,
 ) -> PlannerResult<Vec<DynProofPlan>> {
     sql_to_posql_plans(
-        sql,
+        statements,
         context_provider,
         schemas,
         config,
@@ -106,13 +101,13 @@ pub fn sql_to_proof_plans<S: ContextProvider>(
 ///
 /// See `sql_to_posql_plans` for more details
 pub fn sql_to_proof_plans_with_postprocessing<S: ContextProvider>(
-    sql: &str,
+    statements: &[Statement],
     context_provider: &S,
     schemas: &IndexMap<TableReference, DFSchema>,
     config: &ConfigOptions,
 ) -> PlannerResult<Vec<ProofPlanWithPostprocessing>> {
     sql_to_posql_plans(
-        sql,
+        statements,
         context_provider,
         schemas,
         config,

crates/proof-of-sql-planner/tests/e2e_tests.rs

@@ -21,6 +21,7 @@ use proof_of_sql_planner::{
     column_fields_to_schema, postprocessing::PostprocessingStep, sql_to_proof_plans,
     sql_to_proof_plans_with_postprocessing, PlannerResult, PoSqlContextProvider,
 };
+use sqlparser::{dialect::GenericDialect, parser::Parser};
 
 /// Get a new `TableTestAccessor` with the provided tables
 fn new_test_accessor<'a, CP: CommitmentEvaluationProof>(
@@ -69,7 +70,8 @@ fn posql_end_to_end_test<'a, CP: CommitmentEvaluationProof>(
     let schemas = get_schemas::<CP>(&tables).unwrap();
     let context_provider = PoSqlContextProvider::new(tables);
     let config = ConfigOptions::default();
-    let plans = sql_to_proof_plans(sql, &context_provider, &schemas, &config).unwrap();
+    let statements = Parser::parse_sql(&GenericDialect {}, sql).unwrap();
+    let plans = sql_to_proof_plans(&statements, &context_provider, &schemas, &config).unwrap();
     // Prove and verify the plans
     for (plan, expected) in plans.iter().zip(expected_results.iter()) {
         let res = VerifiableQueryResult::<CP>::new(plan, &accessor, &prover_setup, params).unwrap();
@@ -96,8 +98,10 @@ fn posql_end_to_end_test_with_postprocessing<'a, CP: CommitmentEvaluationProof>(
     let schemas = get_schemas::<CP>(&tables).unwrap();
     let context_provider = PoSqlContextProvider::new(tables);
     let config = ConfigOptions::default();
+    let statements = Parser::parse_sql(&GenericDialect {}, sql).unwrap();
     let plan_with_postprocessings =
-        sql_to_proof_plans_with_postprocessing(sql, &context_provider, &schemas, &config).unwrap();
+        sql_to_proof_plans_with_postprocessing(&statements, &context_provider, &schemas, &config)
+            .unwrap();
     for (plan_with_postprocessing, expected) in plan_with_postprocessings
         .iter()
         .zip(expected_results.iter())