feat: import PRs from old repo (#2)

crates/proofs/src/sql/ast/and_expr.rs

@@ -1,8 +1,8 @@
-use super::BoolExpr;
+use super::ProvableExpr;
 use crate::{
     base::{
         commitment::Commitment,
-        database::{ColumnRef, CommitmentAccessor, DataAccessor},
+        database::{ColumnRef, ColumnType, CommitmentAccessor, DataAccessor},
         proof::ProofError,
     },
     sql::proof::{CountBuilder, ProofBuilder, SumcheckSubpolynomialType, VerificationBuilder},
@@ -15,13 +15,13 @@ use std::collections::HashSet;
 
 /// Provable logical AND expression
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub struct AndExpr<C: Commitment, B: BoolExpr<C>> {
+pub struct AndExpr<C: Commitment, B: ProvableExpr<C, bool>> {
     lhs: Box<B>,
     rhs: Box<B>,
     _phantom: PhantomData<C>,
 }
 
-impl<C: Commitment, B: BoolExpr<C>> AndExpr<C, B> {
+impl<C: Commitment, B: ProvableExpr<C, bool>> AndExpr<C, B> {
     /// Create logical AND expression
     pub fn new(lhs: Box<B>, rhs: Box<B>) -> Self {
         Self {
@@ -32,7 +32,7 @@ impl<C: Commitment, B: BoolExpr<C>> AndExpr<C, B> {
     }
 }
 
-impl<C: Commitment, B: BoolExpr<C>> BoolExpr<C> for AndExpr<C, B> {
+impl<C: Commitment, B: ProvableExpr<C, bool>> ProvableExpr<C, bool> for AndExpr<C, B> {
     fn count(&self, builder: &mut CountBuilder) -> Result<(), ProofError> {
         self.lhs.count(builder)?;
         self.rhs.count(builder)?;
@@ -42,6 +42,10 @@ impl<C: Commitment, B: BoolExpr<C>> BoolExpr<C> for AndExpr<C, B> {
         Ok(())
     }
 
+    fn data_type(&self) -> ColumnType {
+        ColumnType::Boolean
+    }
+
     fn result_evaluate<'a>(
         &self,
         table_length: usize,

crates/proofs/src/sql/ast/and_expr_test.rs

@@ -1,4 +1,4 @@
-use super::{test_utility::*, BoolExpr, FilterExpr};
+use super::{test_utility::*, FilterExpr, ProvableExpr};
 use crate::{
     base::{
         commitment::InnerProductProof,
@@ -12,7 +12,7 @@ use crate::{
     sql::{
         ast::{
             test_utility::{and, equal},
-            BoolExprPlan,
+            ProvableExprPlan,
         },
         proof::{exercise_verification, VerifiableQueryResult},
     },
@@ -143,7 +143,7 @@ fn we_can_compute_the_correct_output_of_an_and_expr_using_result_evaluate() {
     let mut accessor = OwnedTableTestAccessor::<InnerProductProof>::new_empty_with_setup(());
     let t = "sxt.t".parse().unwrap();
     accessor.add_table(t, data, 0);
-    let and_expr: BoolExprPlan<RistrettoPoint> =
+    let and_expr: ProvableExprPlan<RistrettoPoint> =
         and(equal(t, "b", 1, &accessor), equal(t, "d", "t", &accessor));
     let alloc = Bump::new();
     let res = and_expr.result_evaluate(4, &alloc, &accessor);

crates/proofs/src/sql/ast/const_bool_expr.rs

@@ -1,13 +1,11 @@
+use super::ProvableExpr;
 use crate::{
     base::{
         commitment::Commitment,
-        database::{ColumnRef, CommitmentAccessor, DataAccessor},
+        database::{ColumnRef, ColumnType, CommitmentAccessor, DataAccessor},
         proof::ProofError,
     },
-    sql::{
-        ast::BoolExpr,
-        proof::{CountBuilder, ProofBuilder, VerificationBuilder},
-    },
+    sql::proof::{CountBuilder, ProofBuilder, VerificationBuilder},
 };
 use bumpalo::Bump;
 use num_traits::Zero;
@@ -37,11 +35,15 @@ impl ConstBoolExpr {
     }
 }
 
-impl<C: Commitment> BoolExpr<C> for ConstBoolExpr {
+impl<C: Commitment> ProvableExpr<C, bool> for ConstBoolExpr {
     fn count(&self, _builder: &mut CountBuilder) -> Result<(), ProofError> {
         Ok(())
     }
 
+    fn data_type(&self) -> ColumnType {
+        ColumnType::Boolean
+    }
+
     fn result_evaluate<'a>(
         &self,
         table_length: usize,

crates/proofs/src/sql/ast/const_bool_expr_test.rs

@@ -1,4 +1,4 @@
-use super::{BoolExpr, BoolExprPlan};
+use super::{ProvableExpr, ProvableExprPlan};
 use crate::{
     base::database::{
         make_random_test_accessor_data, ColumnType, RandomTestAccessorDescriptor,
@@ -77,7 +77,7 @@ fn we_can_select_from_tables_with_an_always_false_where_clause() {
 #[test]
 fn we_can_compute_the_correct_output_of_a_const_bool_expr_using_result_evaluate() {
     let accessor = UnimplementedTestAccessor::new_empty();
-    let const_bool_expr: BoolExprPlan<RistrettoPoint> = const_v(true);
+    let const_bool_expr: ProvableExprPlan<RistrettoPoint> = const_v(true);
     let alloc = Bump::new();
     let res = const_bool_expr.result_evaluate(4, &alloc, &accessor);
     let expected_res = &[true, true, true, true];

crates/proofs/src/sql/ast/dense_filter_expr.rs

@@ -1,7 +1,8 @@
 use super::{
-    bool_expr_plan::BoolExprPlan,
     dense_filter_util::{fold_columns, fold_vals},
-    filter_columns, BoolExpr, ColumnExpr, TableExpr,
+    filter_columns,
+    provable_expr_plan::ProvableExprPlan,
+    ColumnExpr, ProvableExpr, TableExpr,
 };
 use crate::{
     base::{
@@ -34,13 +35,17 @@ use std::{collections::HashSet, marker::PhantomData};
 pub struct OstensibleDenseFilterExpr<C: Commitment, H: ProverHonestyMarker> {
     pub(super) results: Vec<ColumnExpr>,
     pub(super) table: TableExpr,
-    pub(super) where_clause: BoolExprPlan<C>,
+    pub(super) where_clause: ProvableExprPlan<C>,
     phantom: PhantomData<H>,
 }
 
 impl<C: Commitment, H: ProverHonestyMarker> OstensibleDenseFilterExpr<C, H> {
     /// Creates a new dense_filter expression.
-    pub fn new(results: Vec<ColumnExpr>, table: TableExpr, where_clause: BoolExprPlan<C>) -> Self {
+    pub fn new(
+        results: Vec<ColumnExpr>,
+        table: TableExpr,
+        where_clause: ProvableExprPlan<C>,
+    ) -> Self {
         Self {
             results,
             table,

crates/proofs/src/sql/ast/dense_filter_expr_test.rs

@@ -2,7 +2,7 @@ use crate::{
     base::math::decimal::Precision,
     sql::ast::{
         test_utility::{and, not, or},
-        BoolExprPlan,
+        ProvableExprPlan,
     },
 };
 use crate::{
@@ -53,7 +53,7 @@ fn we_can_correctly_fetch_the_query_result_schema() {
             )),
         ],
         TableExpr { table_ref },
-        BoolExprPlan::new_equals(
+        ProvableExprPlan::new_equals(
             ColumnRef::new(
                 table_ref,
                 Identifier::try_new("c").unwrap(),
@@ -98,15 +98,15 @@ fn we_can_correctly_fetch_all_the_referenced_columns() {
         TableExpr { table_ref },
         not::<RistrettoPoint>(and(
             or(
-                BoolExprPlan::new_equals(
+                ProvableExprPlan::new_equals(
                     ColumnRef::new(
                         table_ref,
                         Identifier::try_new("f").unwrap(),
                         ColumnType::BigInt,
                     ),
                     Curve25519Scalar::from(45_u64),
                 ),
-                BoolExprPlan::new_equals(
+                ProvableExprPlan::new_equals(
                     ColumnRef::new(
                         table_ref,
                         Identifier::try_new("c").unwrap(),
@@ -115,7 +115,7 @@ fn we_can_correctly_fetch_all_the_referenced_columns() {
                     -Curve25519Scalar::from(2_u64),
                 ),
             ),
-            BoolExprPlan::new_equals(
+            ProvableExprPlan::new_equals(
                 ColumnRef::new(
                     table_ref,
                     Identifier::try_new("b").unwrap(),
@@ -189,7 +189,7 @@ fn we_can_get_an_empty_result_from_a_basic_dense_filter_on_an_empty_table_using_
     let t = "sxt.t".parse().unwrap();
     let mut accessor = OwnedTableTestAccessor::<InnerProductProof>::new_empty_with_setup(());
     accessor.add_table(t, data, 0);
-    let where_clause: BoolExprPlan<RistrettoPoint> = equal(t, "a", 999, &accessor);
+    let where_clause: ProvableExprPlan<RistrettoPoint> = equal(t, "a", 999, &accessor);
     let expr = dense_filter(
         cols_expr(t, &["b", "c", "d", "e"], &accessor),
         tab(t),
@@ -234,7 +234,7 @@ fn we_can_get_an_empty_result_from_a_basic_dense_filter_using_result_evaluate()
     let t = "sxt.t".parse().unwrap();
     let mut accessor = OwnedTableTestAccessor::<InnerProductProof>::new_empty_with_setup(());
     accessor.add_table(t, data, 0);
-    let where_clause: BoolExprPlan<RistrettoPoint> = equal(t, "a", 999, &accessor);
+    let where_clause: ProvableExprPlan<RistrettoPoint> = equal(t, "a", 999, &accessor);
     let expr = dense_filter(
         cols_expr(t, &["b", "c", "d", "e"], &accessor),
         tab(t),
@@ -279,7 +279,7 @@ fn we_can_get_no_columns_from_a_basic_dense_filter_with_no_selected_columns_usin
     let t = "sxt.t".parse().unwrap();
     let mut accessor = OwnedTableTestAccessor::<InnerProductProof>::new_empty_with_setup(());
     accessor.add_table(t, data, 0);
-    let where_clause: BoolExprPlan<RistrettoPoint> = equal(t, "a", 5, &accessor);
+    let where_clause: ProvableExprPlan<RistrettoPoint> = equal(t, "a", 5, &accessor);
     let expr = dense_filter(cols_expr(t, &[], &accessor), tab(t), where_clause);
     let alloc = Bump::new();
     let mut builder = ResultBuilder::new(5);
@@ -305,7 +305,7 @@ fn we_can_get_the_correct_result_from_a_basic_dense_filter_using_result_evaluate
     let t = "sxt.t".parse().unwrap();
     let mut accessor = OwnedTableTestAccessor::<InnerProductProof>::new_empty_with_setup(());
     accessor.add_table(t, data, 0);
-    let where_clause: BoolExprPlan<RistrettoPoint> = equal(t, "a", 5, &accessor);
+    let where_clause: ProvableExprPlan<RistrettoPoint> = equal(t, "a", 5, &accessor);
     let expr = dense_filter(
         cols_expr(t, &["b", "c", "d", "e"], &accessor),
         tab(t),

crates/proofs/src/sql/ast/dense_filter_expr_test_dishonest_prover.rs

@@ -1,4 +1,6 @@
-use super::{dense_filter_expr::prove_filter, filter_columns, BoolExpr, OstensibleDenseFilterExpr};
+use super::{
+    dense_filter_expr::prove_filter, filter_columns, OstensibleDenseFilterExpr, ProvableExpr,
+};
 use crate::{
     base::{
         database::{Column, DataAccessor, OwnedTableTestAccessor, TestAccessor},