feat: add div-mod constraints

Author: stuarttimwhite

crates/proof-of-sql/Cargo.toml

@@ -67,6 +67,7 @@ zerocopy = { workspace = true }
 arrow-csv = { workspace = true }
 criterion = { workspace = true, features = ["html_reports"] }
 merlin = { workspace = true }
+mockall = "0.13.1"
 opentelemetry = { workspace = true }
 opentelemetry-jaeger = { workspace = true }
 rand = { workspace = true, default-features = false, features = ["std"] }

crates/proof-of-sql/src/base/database/column.rs

@@ -426,9 +426,7 @@ impl ColumnType {
     /// Returns `None` if the type is not a signed integer.
     /// `sqrt_negative_min(NumericalType) = floor(sqrt(-NumericalType::MIN))`
     #[must_use]
-    #[cfg_attr(not(test), expect(dead_code))]
-    #[expect(clippy::trivially_copy_pass_by_ref)]
-    fn sqrt_negative_min(&self) -> Option<u64> {
+    pub(crate) fn sqrt_negative_min(self) -> Option<u64> {
         match self {
             ColumnType::TinyInt => Some(11),
             ColumnType::SmallInt => Some(181),
@@ -440,7 +438,7 @@ impl ColumnType {
     }
 
     /// Returns the number of bits in the integer type if it is an integer type. Otherwise, return None.
-    fn to_integer_bits(self) -> Option<usize> {
+    pub(crate) fn to_integer_bits(self) -> Option<usize> {
         match self {
             ColumnType::Uint8 | ColumnType::TinyInt => Some(8),
             ColumnType::SmallInt => Some(16),

crates/proof-of-sql/src/base/database/column_type_operation.rs

@@ -115,8 +115,7 @@ pub fn try_multiply_column_types(
 /// Determine the output type of a divide/modulo operation if it is possible
 /// to divide and modulo the two input types. If the types are not compatible, return
 /// an error.
-#[cfg_attr(not(test), expect(dead_code))]
-fn try_divide_modulo_column_types(
+pub fn try_divide_modulo_column_types(
     lhs: ColumnType,
     rhs: ColumnType,
 ) -> ColumnOperationResult<(ColumnType, ColumnType)> {

crates/proof-of-sql/src/base/database/mod.rs

@@ -14,7 +14,8 @@ mod slice_decimal_operation;
 
 mod column_type_operation;
 pub use column_type_operation::{
-    try_add_subtract_column_types, try_divide_column_types, try_multiply_column_types,
+    try_add_subtract_column_types, try_divide_column_types, try_divide_modulo_column_types,
+    try_multiply_column_types,
 };
 
 mod column_arithmetic_operation;

crates/proof-of-sql/src/sql/proof_exprs/mod.rs

@@ -53,10 +53,9 @@ pub(crate) use comparison_util::scale_and_subtract;
 
 mod numerical_util;
 pub(crate) use numerical_util::{
-    add_subtract_columns, multiply_columns, scale_and_add_subtract_eval,
+    add_subtract_columns, columns_to_scalar_slice, divide_columns, modulo_columns,
+    multiply_columns, scale_and_add_subtract_eval,
 };
-#[cfg(test)]
-pub(crate) use numerical_util::{divide_columns, modulo_columns};
 
 mod equals_expr;
 pub(crate) use equals_expr::EqualsExpr;

crates/proof-of-sql/src/sql/proof_exprs/numerical_util.rs

@@ -134,6 +134,15 @@ pub(crate) fn multiply_columns<'a, S: Scalar>(
     })
 }
 
+/// Convert column to scalar slice.
+#[expect(clippy::missing_panics_doc)]
+pub(crate) fn columns_to_scalar_slice<'a, S: Scalar>(
+    column: &Column<'a, S>,
+    alloc: &'a Bump,
+) -> &'a [S] {
+    alloc.alloc_slice_fill_with(column.len(), |i| column.scalar_at(i).unwrap())
+}
+
 #[expect(dead_code)]
 /// Multiply two [`ColumnarValues`] together.
 /// # Panics
@@ -270,7 +279,6 @@ fn modulo_integer_columns<
 /// # Panics
 /// Panics if: `lhs` and `rhs` are not of the same length or column type division is unsupported.
 #[expect(clippy::too_many_lines)]
-#[cfg_attr(not(test), expect(dead_code))]
 pub(crate) fn divide_columns<'a, S: Scalar>(
     lhs: &Column<'a, S>,
     rhs: &Column<'a, S>,
@@ -394,7 +402,6 @@ pub(crate) fn divide_columns<'a, S: Scalar>(
 /// Take the modulo of one column against another.
 /// # Panics
 /// Panics if: `lhs` and `rhs` are not of the same length.
-#[cfg_attr(not(test), expect(dead_code))]
 pub(crate) fn modulo_columns<'a, S: Scalar>(
     lhs: &Column<'a, S>,
     rhs: &Column<'a, S>,