feat: enable casting from decimal to bigint (#1101)

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

This will help enable a very nice example. Casting from decimal to
bigint is helpful for some aggregations.

# What changes are included in this PR?

Enabling casting from decimal to int.

# Are these changes tested?
Yes.

Author: stuarttimwhite

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

@@ -225,6 +225,7 @@ pub fn try_cast_types(from: ColumnType, to: ColumnType) -> ColumnOperationResult
             to.precision_value().unwrap() >= from.precision_value().unwrap()
                 && to.scale() == from.scale()
         }
+        (ColumnType::Decimal75(precision, 0), ColumnType::BigInt) if precision.value() < 19 => true,
         _ => false,
     }
     .then_some(())
@@ -1175,6 +1176,20 @@ mod test {
         }
     }
 
+    #[test]
+    fn we_can_cast_decimal_to_bigint_with_zero_scale() {
+        try_cast_types(
+            ColumnType::Decimal75(Precision::new(18).unwrap(), 0),
+            ColumnType::BigInt,
+        )
+        .unwrap();
+        try_cast_types(
+            ColumnType::Decimal75(Precision::new(19).unwrap(), 0),
+            ColumnType::BigInt,
+        )
+        .unwrap_err();
+    }
+
     #[test]
     fn we_can_cast_decimal_to_decimal_with_same_scale() {
         try_cast_types(

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

@@ -605,6 +605,9 @@ pub fn cast_column<'a, S: Scalar>(
             );
             Column::Decimal75(to_precision, to_scale, vals)
         }
+        (Column::Decimal75(precision, 0, vals), ColumnType::BigInt) if precision.value() < 19 => {
+            cast_scalar_slice_to_int_column(alloc, vals, to_type)
+        }
         _ => panic!("Casting not supported between {from_type} and {to_type}"),
     }
 }
@@ -1306,4 +1309,60 @@ mod tests {
             Column::<TestScalar>::Decimal75(prec, scale, &scalar_slice)
         );
     }
+
+    #[test]
+    fn we_can_scale_cast_decimal_with_zero_scale_to_bigint() {
+        let alloc = Bump::new();
+        let decimal_slice = [TestScalar::ONE, TestScalar::TEN];
+        let decimal_column =
+            Column::<TestScalar>::Decimal75(Precision::new(11).unwrap(), 0, &decimal_slice);
+        assert_eq!(
+            cast_column(
+                &alloc,
+                decimal_column,
+                ColumnType::Decimal75(Precision::new(11).unwrap(), 0),
+                ColumnType::BigInt
+            ),
+            Column::BigInt(&[1, 10])
+        );
+    }
+
+    #[should_panic(
+        expected = "Unable to cast between types DECIMAL75(PRECISION: 19, SCALE: 0) and BIGINT"
+    )]
+    #[test]
+    fn we_cannot_scale_cast_decimal_with_zero_scale_to_bigint_if_precision_is_too_high() {
+        let alloc = Bump::new();
+        let decimal_slice = [TestScalar::ONE, TestScalar::TEN, TestScalar::from(i64::MAX)];
+        let decimal_column =
+            Column::<TestScalar>::Decimal75(Precision::new(19).unwrap(), 0, &decimal_slice);
+        cast_column(
+            &alloc,
+            decimal_column,
+            ColumnType::Decimal75(Precision::new(19).unwrap(), 0),
+            ColumnType::BigInt,
+        );
+    }
+
+    #[test]
+    fn we_can_scale_cast_decimal_with_zero_scale_to_bigint_if_precision_is_18() {
+        let alloc = Bump::new();
+        let supported_bigint = i64::MIN / 10;
+        let decimal_slice = [
+            TestScalar::ONE,
+            TestScalar::TEN,
+            TestScalar::from(supported_bigint),
+        ];
+        let decimal_column =
+            Column::<TestScalar>::Decimal75(Precision::new(18).unwrap(), 0, &decimal_slice);
+        assert_eq!(
+            cast_column(
+                &alloc,
+                decimal_column,
+                ColumnType::Decimal75(Precision::new(18).unwrap(), 0),
+                ColumnType::BigInt
+            ),
+            Column::BigInt(&[1, 10, supported_bigint])
+        );
+    }
 }