Repository: great-expectations/great_expectations
Pull request #11222 (2025-06-04 07:35:36)

[FEATURE] Add SuiteParameterDict to all Expectation Kwargs
Adds SuiteParameterDict to the type definition of all expectation arguments. By doing that, all kwargs of an expectation are parametrizable. See discussion: https://app.slack.com/client/T7NEH00BA/CUTCNHN82

- [ ] Description of PR changes above includes a link to [an existing GitHub issue](https://github.com/great-expectations/great_expectations/issues)
- [ ] PR title is prefixed with one of: [BUGFIX], [FEATURE], [DOCS], [MAINTENANCE], [CONTRIB], [MINORBUMP]
- [ ] Code is linted - run `invoke lint` (uses `ruff format` + `ruff check`)
- [ ] Appropriate tests and docs have been updated

For more information about contributing, visit our [community resources](https://docs.greatexpectations.io/docs/core/introduction/community_resources#contribute-code-or-documentation).

After you submit your PR, keep the page open and **monitor the statuses of the various checks made by our continuous integration process at the bottom of the page. Please fix any issues that come up** and [reach out on Slack](https://greatexpectations.io/slack) if you need help. Thanks for contributing!


joshua-stauffer: The minimum test coverage would just ensure that the expectation validates as expected and GX doesn't blow up when a suite parameter is provided. Here's a quick example PR i threw together that tests both success and failure results, but just testing success the success path is probably sufficient: https://github.com/great-expectations/great_expectations/pull/11225
Pascal06S: Thanks @joshua-stauffer i updated the tests! I also fixed a bug in the prescriptive renderer for the already parametrizable params "mostly" and "quantiles"
joshua-stauffer: ok, great, we're getting closer. Since this PR updates the public Expectation API, we need to regen their schemas. Looks like that's the main cause of test failures. To fix, run `invoke schemas --sync` and commit the result.
Pascal06S: I hope the tests are successful now. They did not fail on my local python 3.10 env. After installing python 3.9 they failed and i think i fixed it now

Patch:
diff --git a/docs/docusaurus/docs/reference/learn/data_quality_use_cases/integrity_resources/integrity_workflow.py b/docs/docusaurus/docs/reference/learn/data_quality_use_cases/integrity_resources/integrity_workflow.py
index be5a2969a..fac758cec 100644
--- a/docs/docusaurus/docs/reference/learn/data_quality_use_cases/integrity_resources/integrity_workflow.py
+++ b/docs/docusaurus/docs/reference/learn/data_quality_use_cases/integrity_resources/integrity_workflow.py
@@ -54,7 +54,7 @@ class ExpectTransfersToArriveWithin45Seconds(gxe.UnexpectedRowsExpectation):
 
     description = "Transfers arrive within 45 seconds"
 
-    unexpected_rows_query = """
+    unexpected_rows_query: str = """
         select *
         from {batch}
         where extract(epoch from (age(received_ts, sent_ts))) > 45
@@ -104,7 +104,7 @@ class ExpectTransferAmountsToMatch(gxe.UnexpectedRowsExpectation):
         "Transfer amounts in integrity_transfers and integrity_transfer_balance match."
     )
 
-    unexpected_rows_query = """
+    unexpected_rows_query: str = """
         select *
         from {batch} t
         join integrity_transfer_balance b using (transfer_balance_id)
diff --git a/great_expectations/expectations/core/expect_column_kl_divergence_to_be_less_than.py b/great_expectations/expectations/core/expect_column_kl_divergence_to_be_less_than.py
index 0bb570b3b..72301249f 100644
--- a/great_expectations/expectations/core/expect_column_kl_divergence_to_be_less_than.py
+++ b/great_expectations/expectations/core/expect_column_kl_divergence_to_be_less_than.py
@@ -9,6 +9,9 @@ import pandas as pd
 from scipy import stats
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.execution_engine.util import (
     is_valid_categorical_partition_object,
@@ -319,15 +322,21 @@ class ExpectColumnKLDivergenceToBeLessThan(ColumnAggregateExpectation):
                 }}
     """  # noqa: E501 # FIXME CoP
 
-    partition_object: Union[dict, None] = pydantic.Field(description=PARTITION_OBJECT_DESCRIPTION)
-    threshold: Union[float, None] = pydantic.Field(description=THRESHOLD_DESCRIPTION)
-    internal_weight_holdout: Union[float, None] = pydantic.Field(
+    partition_object: Union[dict, SuiteParameterDict, None] = pydantic.Field(
+        description=PARTITION_OBJECT_DESCRIPTION
+    )
+    threshold: Union[float, SuiteParameterDict, None] = pydantic.Field(
+        description=THRESHOLD_DESCRIPTION
+    )
+    internal_weight_holdout: Union[float, SuiteParameterDict, None] = pydantic.Field(
         default=0, ge=0, le=1, description=INTERNAL_WEIGHT_HOLDOUT_DESCRIPTION
     )
-    tail_weight_holdout: Union[float, None] = pydantic.Field(
+    tail_weight_holdout: Union[float, SuiteParameterDict, None] = pydantic.Field(
         default=0, ge=0, le=1, description=TAIL_WEIGHT_HOLDOUT_DESCRIPTION
     )
-    bucketize_data: bool = pydantic.Field(default=True, description=BUCKETIZE_DATA_DESCRIPTION)
+    bucketize_data: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=True, description=BUCKETIZE_DATA_DESCRIPTION
+    )
     min_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MIN_VALUE_DESCRIPTION
     )
diff --git a/great_expectations/expectations/core/expect_column_max_to_be_between.py b/great_expectations/expectations/core/expect_column_max_to_be_between.py
index ed60fcd76..3dc67bb1f 100644
--- a/great_expectations/expectations/core/expect_column_max_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_max_to_be_between.py
@@ -4,6 +4,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     render_suite_parameter_string,
@@ -194,8 +197,12 @@ class ExpectColumnMaxToBeBetween(ColumnAggregateExpectation):
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
 
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
         "maturity": "production",
diff --git a/great_expectations/expectations/core/expect_column_mean_to_be_between.py b/great_expectations/expectations/core/expect_column_mean_to_be_between.py
index 85317bd55..b9b8c3901 100644
--- a/great_expectations/expectations/core/expect_column_mean_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_mean_to_be_between.py
@@ -4,6 +4,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     ColumnAggregateExpectation,
@@ -185,8 +188,12 @@ class ExpectColumnMeanToBeBetween(ColumnAggregateExpectation):
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
 
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
         "maturity": "production",
diff --git a/great_expectations/expectations/core/expect_column_median_to_be_between.py b/great_expectations/expectations/core/expect_column_median_to_be_between.py
index a26e89fed..bf5d2d7da 100644
--- a/great_expectations/expectations/core/expect_column_median_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_median_to_be_between.py
@@ -4,6 +4,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     ColumnAggregateExpectation,
@@ -181,8 +184,12 @@ class ExpectColumnMedianToBeBetween(ColumnAggregateExpectation):
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
 
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
         "maturity": "production",
diff --git a/great_expectations/expectations/core/expect_column_min_to_be_between.py b/great_expectations/expectations/core/expect_column_min_to_be_between.py
index af778e6fb..0f9b18b21 100644
--- a/great_expectations/expectations/core/expect_column_min_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_min_to_be_between.py
@@ -4,6 +4,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     ColumnAggregateExpectation,
@@ -188,8 +191,12 @@ class ExpectColumnMinToBeBetween(ColumnAggregateExpectation):
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
 
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
         "maturity": "production",
diff --git a/great_expectations/expectations/core/expect_column_most_common_value_to_be_in_set.py b/great_expectations/expectations/core/expect_column_most_common_value_to_be_in_set.py
index b03a9091b..60576be0c 100644
--- a/great_expectations/expectations/core/expect_column_most_common_value_to_be_in_set.py
+++ b/great_expectations/expectations/core/expect_column_most_common_value_to_be_in_set.py
@@ -3,6 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     COLUMN_DESCRIPTION,
     ColumnAggregateExpectation,
@@ -177,7 +180,7 @@ class ExpectColumnMostCommonValueToBeInSet(ColumnAggregateExpectation):
     """  # noqa: E501 # FIXME CoP
 
     value_set: ValueSetField
-    ties_okay: Union[bool, None] = pydantic.Field(
+    ties_okay: Union[bool, SuiteParameterDict, None] = pydantic.Field(
         default=None,
         description=TIES_OKAY_DESCRIPTION,
     )
diff --git a/great_expectations/expectations/core/expect_column_pair_values_a_to_be_greater_than_b.py b/great_expectations/expectations/core/expect_column_pair_values_a_to_be_greater_than_b.py
index 763e2d42c..3979875c9 100644
--- a/great_expectations/expectations/core/expect_column_pair_values_a_to_be_greater_than_b.py
+++ b/great_expectations/expectations/core/expect_column_pair_values_a_to_be_greater_than_b.py
@@ -3,6 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Literal, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     ColumnPairMapExpectation,
     render_suite_parameter_string,
@@ -180,12 +183,15 @@ class ExpectColumnPairValuesAToBeGreaterThanB(ColumnPairMapExpectation):
                 }}
     """  # noqa: E501 # FIXME CoP
 
-    or_equal: Union[bool, None] = pydantic.Field(default=None, description=OR_EQUAL_DESCRIPTION)
-    ignore_row_if: Literal["both_values_are_missing", "either_value_is_missing", "neither"] = (
-        pydantic.Field(
-            default="both_values_are_missing",
-            description=IGNORE_ROW_IF_DESCRIPTION,
-        )
+    or_equal: Union[bool, SuiteParameterDict, None] = pydantic.Field(
+        default=None, description=OR_EQUAL_DESCRIPTION
+    )
+    ignore_row_if: Union[
+        Literal["both_values_are_missing", "either_value_is_missing", "neither"],
+        SuiteParameterDict,
+    ] = pydantic.Field(
+        default="both_values_are_missing",
+        description=IGNORE_ROW_IF_DESCRIPTION,
     )
 
     # This dictionary contains metadata for display in the public gallery
diff --git a/great_expectations/expectations/core/expect_column_pair_values_to_be_equal.py b/great_expectations/expectations/core/expect_column_pair_values_to_be_equal.py
index e534b428f..08d1e457d 100644
--- a/great_expectations/expectations/core/expect_column_pair_values_to_be_equal.py
+++ b/great_expectations/expectations/core/expect_column_pair_values_to_be_equal.py
@@ -3,6 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Literal, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     ColumnPairMapExpectation,
     render_suite_parameter_string,
@@ -177,9 +180,10 @@ class ExpectColumnPairValuesToBeEqual(ColumnPairMapExpectation):
                 }}
     """  # noqa: E501 # FIXME CoP
 
-    ignore_row_if: Literal["both_values_are_missing", "either_value_is_missing", "neither"] = (
-        pydantic.Field(default="both_values_are_missing", description=IGNORE_ROW_IF_DESCRIPTION)
-    )
+    ignore_row_if: Union[
+        Literal["both_values_are_missing", "either_value_is_missing", "neither"],
+        SuiteParameterDict,
+    ] = pydantic.Field(default="both_values_are_missing", description=IGNORE_ROW_IF_DESCRIPTION)
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
diff --git a/great_expectations/expectations/core/expect_column_pair_values_to_be_in_set.py b/great_expectations/expectations/core/expect_column_pair_values_to_be_in_set.py
index 2e98d61be..71b12bbc9 100644
--- a/great_expectations/expectations/core/expect_column_pair_values_to_be_in_set.py
+++ b/great_expectations/expectations/core/expect_column_pair_values_to_be_in_set.py
@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import Any, ClassVar, Dict, List, Literal, Tuple, Type, Union
 
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     ColumnPairMapExpectation,
 )
@@ -163,10 +166,11 @@ class ExpectColumnPairValuesToBeInSet(ColumnPairMapExpectation):
                 }}
     """  # noqa: E501 # FIXME CoP
 
-    value_pairs_set: List[Tuple[Any, Any]]
-    ignore_row_if: Literal["both_values_are_missing", "either_value_is_missing", "neither"] = (
-        "both_values_are_missing"
-    )
+    value_pairs_set: Union[List[Tuple[Any, Any]], SuiteParameterDict]
+    ignore_row_if: Union[
+        Literal["both_values_are_missing", "either_value_is_missing", "neither"],
+        SuiteParameterDict,
+    ] = "both_values_are_missing"
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
diff --git a/great_expectations/expectations/core/expect_column_proportion_of_unique_values_to_be_between.py b/great_expectations/expectations/core/expect_column_proportion_of_unique_values_to_be_between.py
index 4a87910bc..71ed27a2f 100644
--- a/great_expectations/expectations/core/expect_column_proportion_of_unique_values_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_proportion_of_unique_values_to_be_between.py
@@ -1,8 +1,11 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     COLUMN_DESCRIPTION,
@@ -192,8 +195,12 @@ class ExpectColumnProportionOfUniqueValuesToBeBetween(ColumnAggregateExpectation
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata = {
diff --git a/great_expectations/expectations/core/expect_column_quantile_values_to_be_between.py b/great_expectations/expectations/core/expect_column_quantile_values_to_be_between.py
index e9cff949c..f4d4afe52 100644
--- a/great_expectations/expectations/core/expect_column_quantile_values_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_quantile_values_to_be_between.py
@@ -6,6 +6,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Type, Uni
 import numpy as np
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.exceptions import InvalidExpectationConfigurationError
 from great_expectations.expectations.expectation import (
     COLUMN_DESCRIPTION,
@@ -246,8 +249,10 @@ class ExpectColumnQuantileValuesToBeBetween(ColumnAggregateExpectation):
                 }}
     """  # noqa: E501 # FIXME CoP
 
-    quantile_ranges: QuantileRange = pydantic.Field(description=QUANTILE_RANGES_DESCRIPTION)
-    allow_relative_error: Union[bool, str] = pydantic.Field(
+    quantile_ranges: Union[QuantileRange, SuiteParameterDict] = pydantic.Field(
+        description=QUANTILE_RANGES_DESCRIPTION
+    )
+    allow_relative_error: Union[bool, str, SuiteParameterDict] = pydantic.Field(
         default=False,
         description=ALLOW_RELATIVE_ERROR_DESCRIPTION,
     )
@@ -310,17 +315,22 @@ class ExpectColumnQuantileValuesToBeBetween(ColumnAggregateExpectation):
             )
 
     @pydantic.validator("quantile_ranges")
-    def validate_quantile_ranges(cls, quantile_ranges: QuantileRange) -> Optional[QuantileRange]:
-        try:
-            assert all(
-                True if None in x else x == sorted([val for val in x if val is not None])
-                for x in quantile_ranges.value_ranges
-            ), "quantile_ranges must consist of ordered pairs"
-        except AssertionError as e:
-            raise InvalidExpectationConfigurationError(str(e))
-
-        if len(quantile_ranges.quantiles) != len(quantile_ranges.value_ranges):
-            raise ValueError("quantile_values and quantiles must have the same number of elements")  # noqa: TRY003 # FIXME CoP
+    def validate_quantile_ranges(
+        cls, quantile_ranges: QuantileRange | SuiteParameterDict
+    ) -> Optional[QuantileRange | SuiteParameterDict]:
+        if isinstance(quantile_ranges, QuantileRange):
+            try:
+                assert all(
+                    True if None in x else x == sorted([val for val in x if val is not None])
+                    for x in quantile_ranges.value_ranges
+                ), "quantile_ranges must consist of ordered pairs"
+            except AssertionError as e:
+                raise InvalidExpectationConfigurationError(str(e))
+
+            if len(quantile_ranges.quantiles) != len(quantile_ranges.value_ranges):
+                raise ValueError(  # noqa: TRY003
+                    "quantile_values and quantiles must have the same number of elements"
+                )  # FIXME CoP
 
         return quantile_ranges
 
@@ -476,8 +486,8 @@ class ExpectColumnQuantileValuesToBeBetween(ColumnAggregateExpectation):
             "string_template": {"template": template_str, "params": params},
         }
 
-        quantiles = params["quantile_ranges"]["quantiles"]
-        value_ranges = params["quantile_ranges"]["value_ranges"]
+        quantiles = params["quantile_ranges"].get("quantiles", [])
+        value_ranges = params["quantile_ranges"].get("value_ranges", [])
 
         table_header_row = ["Quantile", "Min Value", "Max Value"]
         table_rows = []
diff --git a/great_expectations/expectations/core/expect_column_stdev_to_be_between.py b/great_expectations/expectations/core/expect_column_stdev_to_be_between.py
index 5a8cbbb89..c7f7a009f 100644
--- a/great_expectations/expectations/core/expect_column_stdev_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_stdev_to_be_between.py
@@ -3,6 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     COLUMN_DESCRIPTION,
@@ -183,8 +186,12 @@ class ExpectColumnStdevToBeBetween(ColumnAggregateExpectation):
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
diff --git a/great_expectations/expectations/core/expect_column_sum_to_be_between.py b/great_expectations/expectations/core/expect_column_sum_to_be_between.py
index 3ced4fc88..ee9353d2e 100644
--- a/great_expectations/expectations/core/expect_column_sum_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_sum_to_be_between.py
@@ -4,6 +4,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     COLUMN_DESCRIPTION,
@@ -173,8 +176,12 @@ class ExpectColumnSumToBeBetween(ColumnAggregateExpectation):
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
diff --git a/great_expectations/expectations/core/expect_column_unique_value_count_to_be_between.py b/great_expectations/expectations/core/expect_column_unique_value_count_to_be_between.py
index 80e3b88ce..da80791d4 100644
--- a/great_expectations/expectations/core/expect_column_unique_value_count_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_unique_value_count_to_be_between.py
@@ -1,8 +1,11 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     COLUMN_DESCRIPTION,
@@ -183,11 +186,11 @@ class ExpectColumnUniqueValueCountToBeBetween(ColumnAggregateExpectation):
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
         default=False,
         description=STRICT_MIN_DESCRIPTION,
     )
-    strict_max: bool = pydantic.Field(
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
         default=False,
         description=STRICT_MAX_DESCRIPTION,
     )
diff --git a/great_expectations/expectations/core/expect_column_value_lengths_to_be_between.py b/great_expectations/expectations/core/expect_column_value_lengths_to_be_between.py
index 8669774fb..2e5745c5e 100644
--- a/great_expectations/expectations/core/expect_column_value_lengths_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_value_lengths_to_be_between.py
@@ -221,8 +221,12 @@ class ExpectColumnValueLengthsToBeBetween(ColumnMapExpectation):
     max_value: Union[int, SuiteParameterDict, datetime, None] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
@@ -355,7 +359,7 @@ class ExpectColumnValueLengthsToBeBetween(ColumnMapExpectation):
     @classmethod
     @renderer(renderer_type=LegacyRendererType.PRESCRIPTIVE)
     @render_suite_parameter_string
-    def _prescriptive_renderer(  # noqa: C901 #  too complex
+    def _prescriptive_renderer(  # noqa: PLR0912, C901 #  too complex
         cls,
         configuration: Optional[ExpectationConfiguration] = None,
         result: Optional[ExpectationValidationResult] = None,
@@ -394,9 +398,10 @@ class ExpectColumnValueLengthsToBeBetween(ColumnMapExpectation):
         else:
             at_least_str, at_most_str = handle_strict_min_max(params)
 
-            if params["mostly"] is not None and params["mostly"] < 1.0:
-                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
+            if params["mostly"] is not None:
+                if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                    params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                    # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
                 if params["min_value"] is not None and params["max_value"] is not None:
                     template_str = f"values must be {at_least_str} $min_value and {at_most_str} $max_value characters long, at least $mostly_pct % of the time."  # noqa: E501 # FIXME CoP
 
diff --git a/great_expectations/expectations/core/expect_column_value_lengths_to_equal.py b/great_expectations/expectations/core/expect_column_value_lengths_to_equal.py
index d7425b414..998d67ed8 100644
--- a/great_expectations/expectations/core/expect_column_value_lengths_to_equal.py
+++ b/great_expectations/expectations/core/expect_column_value_lengths_to_equal.py
@@ -285,9 +285,10 @@ class ExpectColumnValueLengthsToEqual(ColumnMapExpectation):
             template_str = "values may have any length."
         else:
             template_str = "values must be $value characters long"
-            if params["mostly"] is not None and params["mostly"] < 1.0:
-                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
+            if params["mostly"] is not None:
+                if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                    params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                    # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
                 template_str += ", at least $mostly_pct % of the time."
             else:
                 template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_between.py b/great_expectations/expectations/core/expect_column_values_to_be_between.py
index 9dccd47d6..e4648d099 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_between.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_between.py
@@ -5,6 +5,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.pydantic import root_validator
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.core.types import Comparable  # noqa: TC001 # FIXME CoP
 from great_expectations.expectations.expectation import (
     ColumnMapExpectation,
@@ -198,8 +201,12 @@ class ExpectColumnValuesToBeBetween(ColumnMapExpectation):
     max_value: Optional[Comparable] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=MAX_VALUE_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=MAX_VALUE_DESCRIPTION
+    )
 
     @root_validator
     def check_min_val_or_max_val(cls, values: dict) -> dict:
@@ -342,7 +349,7 @@ class ExpectColumnValuesToBeBetween(ColumnMapExpectation):
     @override
     @renderer(renderer_type=LegacyRendererType.PRESCRIPTIVE)
     @render_suite_parameter_string
-    def _prescriptive_renderer(
+    def _prescriptive_renderer(  # noqa: C901
         cls,
         configuration: Optional[ExpectationConfiguration] = None,
         result: Optional[ExpectationValidationResult] = None,
@@ -373,9 +380,10 @@ class ExpectColumnValuesToBeBetween(ColumnMapExpectation):
             at_least_str, at_most_str = handle_strict_min_max(params)
 
             mostly_str = ""
-            if params["mostly"] is not None and params["mostly"] < 1.0:
-                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
+            if params["mostly"] is not None:
+                if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                    params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                    # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
                 mostly_str = ", at least $mostly_pct % of the time"
 
             if params["min_value"] is not None and params["max_value"] is not None:
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_dateutil_parseable.py b/great_expectations/expectations/core/expect_column_values_to_be_dateutil_parseable.py
index 578db3cc1..f107bb39b 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_dateutil_parseable.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_dateutil_parseable.py
@@ -125,9 +125,10 @@ class ExpectColumnValuesToBeDateutilParseable(ColumnMapExpectation):
 
         template_str = "values must be parseable by dateutil"
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_decreasing.py b/great_expectations/expectations/core/expect_column_values_to_be_decreasing.py
index 6856d1af1..6876cb771 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_decreasing.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_decreasing.py
@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional, Union
 
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     ColumnMapExpectation,
     render_suite_parameter_string,
@@ -70,7 +73,7 @@ class ExpectColumnValuesToBeDecreasing(ColumnMapExpectation):
         [ExpectColumnValuesToBeIncreasing](https://greatexpectations.io/expectations/expect_column_values_to_be_increasing)
     """  # noqa: E501 # FIXME CoP
 
-    strictly: Union[bool, None] = None
+    strictly: Union[bool, SuiteParameterDict, None] = None
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata = {
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_in_set.py b/great_expectations/expectations/core/expect_column_values_to_be_in_set.py
index 8994be147..cb698ebe6 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_in_set.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_in_set.py
@@ -327,9 +327,10 @@ class ExpectColumnValuesToBeInSet(ColumnMapExpectation):
 
         template_str = f"values must belong to this set: {values_string}"
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_in_type_list.py b/great_expectations/expectations/core/expect_column_values_to_be_in_type_list.py
index 30f1c677e..db1edc075 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_in_type_list.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_in_type_list.py
@@ -314,7 +314,7 @@ class ExpectColumnValuesToBeInTypeList(ColumnMapExpectation):
     @override
     @renderer(renderer_type=LegacyRendererType.PRESCRIPTIVE)
     @render_suite_parameter_string
-    def _prescriptive_renderer(
+    def _prescriptive_renderer(  # noqa: C901, PLR0912
         cls,
         configuration: Optional[ExpectationConfiguration] = None,
         result: Optional[ExpectationValidationResult] = None,
@@ -334,9 +334,10 @@ class ExpectColumnValuesToBeInTypeList(ColumnMapExpectation):
                 params[f"v__{i!s}"] = v
             values_string = " ".join([f"$v__{i!s}" for i, v in enumerate(params["type_list"])])
 
-            if params["mostly"] is not None and params["mostly"] < 1.0:
-                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
+            if params["mostly"] is not None:
+                if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                    params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                    # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
                 if include_column_name:
                     template_str = (
                         "$column value types must belong to this set: "
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_increasing.py b/great_expectations/expectations/core/expect_column_values_to_be_increasing.py
index c86817ea9..347786982 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_increasing.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_increasing.py
@@ -3,6 +3,9 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Optional, Union
 
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     ColumnMapExpectation,
     render_suite_parameter_string,
@@ -73,7 +76,7 @@ class ExpectColumnValuesToBeIncreasing(ColumnMapExpectation):
         [ExpectColumnValuesToBeDecreasing](https://greatexpectations.io/expectations/expect_column_values_to_be_decreasing)
     """  # noqa: E501 # FIXME CoP
 
-    strictly: Union[bool, None] = None
+    strictly: Union[bool, SuiteParameterDict, None] = None
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata = {
@@ -153,9 +156,10 @@ class ExpectColumnValuesToBeIncreasing(ColumnMapExpectation):
         else:
             template_str = "values must be greater than or equal to previous values"
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_json_parseable.py b/great_expectations/expectations/core/expect_column_values_to_be_json_parseable.py
index 2768e5e4b..fc4fa78da 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_json_parseable.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_json_parseable.py
@@ -133,9 +133,10 @@ class ExpectColumnValuesToBeJsonParseable(ColumnMapExpectation):
 
         template_str = "values must be parseable as JSON"
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_null.py b/great_expectations/expectations/core/expect_column_values_to_be_null.py
index 290c8360f..461db9bd8 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_null.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_null.py
@@ -269,9 +269,10 @@ class ExpectColumnValuesToBeNull(ColumnMapExpectation):
             ["column", "mostly", "row_condition", "condition_parser"],
         )
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str = "values must be null, at least $mostly_pct % of the time."
         else:
             template_str = "values must be null."
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_of_type.py b/great_expectations/expectations/core/expect_column_values_to_be_of_type.py
index fe4fd3d3c..4e3647d13 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_of_type.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_of_type.py
@@ -18,6 +18,9 @@ from great_expectations.compatibility.bigquery import (
 )
 from great_expectations.compatibility.sqlalchemy import sqlalchemy as sa
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.execution_engine.sqlalchemy_dialect import (
     GXSqlDialect,  # noqa: TC001, RUF100 # FIXME CoP
 )
@@ -223,7 +226,7 @@ class ExpectColumnValuesToBeOfType(ColumnMapExpectation):
                 }}
     """  # noqa: E501 # FIXME CoP
 
-    type_: str = pydantic.Field(description=TYPE__DESCRIPTION)
+    type_: Union[str, SuiteParameterDict] = pydantic.Field(description=TYPE__DESCRIPTION)
 
     library_metadata: ClassVar[Dict[str, Union[str, list, bool]]] = {
         "maturity": "production",
@@ -334,9 +337,10 @@ class ExpectColumnValuesToBeOfType(ColumnMapExpectation):
             ["column", "type_", "mostly", "row_condition", "condition_parser"],
         )
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str = "values must be of type $type_, at least $mostly_pct % of the time."
         else:
             template_str = "values must be of type $type_."
diff --git a/great_expectations/expectations/core/expect_column_values_to_be_unique.py b/great_expectations/expectations/core/expect_column_values_to_be_unique.py
index 75eb5c36c..be517883b 100644
--- a/great_expectations/expectations/core/expect_column_values_to_be_unique.py
+++ b/great_expectations/expectations/core/expect_column_values_to_be_unique.py
@@ -269,9 +269,10 @@ class ExpectColumnValuesToBeUnique(ColumnMapExpectation):
         else:
             template_str = "values must be unique"
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_match_json_schema.py b/great_expectations/expectations/core/expect_column_values_to_match_json_schema.py
index 77265bf48..035b3a287 100644
--- a/great_expectations/expectations/core/expect_column_values_to_match_json_schema.py
+++ b/great_expectations/expectations/core/expect_column_values_to_match_json_schema.py
@@ -1,8 +1,11 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Union
 
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     ColumnMapExpectation,
     render_suite_parameter_string,
@@ -72,7 +75,7 @@ class ExpectColumnValuesToMatchJsonSchema(ColumnMapExpectation):
         [The JSON-schema docs](https://json-schema.org)
     """  # noqa: E501 # FIXME CoP
 
-    json_schema: dict
+    json_schema: Union[dict, SuiteParameterDict]
 
     # This dictionary contains metadata for display in the public gallery
     library_metadata = {
@@ -158,9 +161,10 @@ class ExpectColumnValuesToMatchJsonSchema(ColumnMapExpectation):
             params["formatted_json"] = (
                 f"<pre>{json.dumps(params.get('json_schema'), indent=4)}</pre>"
             )
-            if params["mostly"] is not None and params["mostly"] < 1.0:
-                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
+            if params["mostly"] is not None:
+                if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                    params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                    # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
                 template_str = "values must match the following JSON Schema, at least $mostly_pct % of the time: $formatted_json"  # noqa: E501 # FIXME CoP
             else:
                 template_str = "values must match the following JSON Schema: $formatted_json"
diff --git a/great_expectations/expectations/core/expect_column_values_to_match_like_pattern_list.py b/great_expectations/expectations/core/expect_column_values_to_match_like_pattern_list.py
index d32d9a5b4..cbf0ef37a 100644
--- a/great_expectations/expectations/core/expect_column_values_to_match_like_pattern_list.py
+++ b/great_expectations/expectations/core/expect_column_values_to_match_like_pattern_list.py
@@ -189,7 +189,7 @@ class ExpectColumnValuesToMatchLikePatternList(ColumnMapExpectation):
     like_pattern_list: Union[List[str], SuiteParameterDict] = pydantic.Field(
         description=LIKE_PATTERN_DESCRIPTION
     )
-    match_on: Literal["any", "all"] = pydantic.Field(
+    match_on: Union[Literal["any", "all"], SuiteParameterDict] = pydantic.Field(
         default="any", description=MATCH_ON_DESCRIPTION
     )
 
@@ -335,8 +335,10 @@ class ExpectColumnValuesToMatchLikePatternList(ColumnMapExpectation):
 
         template_str = "Values must match the following like patterns: " + values_string
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_match_regex.py b/great_expectations/expectations/core/expect_column_values_to_match_regex.py
index cfb57ae65..74dfad3d2 100644
--- a/great_expectations/expectations/core/expect_column_values_to_match_regex.py
+++ b/great_expectations/expectations/core/expect_column_values_to_match_regex.py
@@ -315,9 +315,10 @@ class ExpectColumnValuesToMatchRegex(ColumnMapExpectation):
             template_str = "values must match a regular expression but none was specified."
         else:
             template_str = "values must match this regular expression: $regex"
-            if params["mostly"] is not None and params["mostly"] < 1.0:
-                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
+            if params["mostly"] is not None:
+                if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                    params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                    # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
                 template_str += ", at least $mostly_pct % of the time."
             else:
                 template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_match_regex_list.py b/great_expectations/expectations/core/expect_column_values_to_match_regex_list.py
index 06f793620..482fd3731 100644
--- a/great_expectations/expectations/core/expect_column_values_to_match_regex_list.py
+++ b/great_expectations/expectations/core/expect_column_values_to_match_regex_list.py
@@ -194,7 +194,7 @@ class ExpectColumnValuesToMatchRegexList(ColumnMapExpectation):
     regex_list: Union[List[str], SuiteParameterDict] = pydantic.Field(
         description=REGEX_LIST_DESCRIPTION
     )
-    match_on: Literal["any", "all"] = pydantic.Field(
+    match_on: Union[Literal["any", "all"], SuiteParameterDict] = pydantic.Field(
         default="any", description=MATCH_ON_DESCRIPTION
     )
 
@@ -351,9 +351,10 @@ class ExpectColumnValuesToMatchRegexList(ColumnMapExpectation):
                 "values must match any of the following regular expressions: " + values_string
             )
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_match_strftime_format.py b/great_expectations/expectations/core/expect_column_values_to_match_strftime_format.py
index 1c0c6b724..51f08f4c6 100644
--- a/great_expectations/expectations/core/expect_column_values_to_match_strftime_format.py
+++ b/great_expectations/expectations/core/expect_column_values_to_match_strftime_format.py
@@ -167,9 +167,10 @@ class ExpectColumnValuesToMatchStrftimeFormat(ColumnMapExpectation):
             template_str = "values must match a strftime format but none was specified."
         else:
             template_str = "values must match the following strftime format: $strftime_format"
-            if params["mostly"] is not None and params["mostly"] < 1.0:
-                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
+            if params["mostly"] is not None:
+                if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                    params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                    # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
                 template_str += ", at least $mostly_pct % of the time."
             else:
                 template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_not_be_in_set.py b/great_expectations/expectations/core/expect_column_values_to_not_be_in_set.py
index 5332e3c7a..2b11d8f0f 100644
--- a/great_expectations/expectations/core/expect_column_values_to_not_be_in_set.py
+++ b/great_expectations/expectations/core/expect_column_values_to_not_be_in_set.py
@@ -313,9 +313,10 @@ class ExpectColumnValuesToNotBeInSet(ColumnMapExpectation):
 
         template_str = f"values must not belong to this set: {values_string}"
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_not_be_null.py b/great_expectations/expectations/core/expect_column_values_to_not_be_null.py
index ee2e3ef6a..7f189ae37 100644
--- a/great_expectations/expectations/core/expect_column_values_to_not_be_null.py
+++ b/great_expectations/expectations/core/expect_column_values_to_not_be_null.py
@@ -270,9 +270,10 @@ class ExpectColumnValuesToNotBeNull(ColumnMapExpectation):
             ["column", "mostly", "row_condition", "condition_parser"],
         )
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             if include_column_name:
                 template_str = (
                     "$column values must not be null, at least $mostly_pct % of the time."
diff --git a/great_expectations/expectations/core/expect_column_values_to_not_match_like_pattern_list.py b/great_expectations/expectations/core/expect_column_values_to_not_match_like_pattern_list.py
index e55965496..aa5e5b648 100644
--- a/great_expectations/expectations/core/expect_column_values_to_not_match_like_pattern_list.py
+++ b/great_expectations/expectations/core/expect_column_values_to_not_match_like_pattern_list.py
@@ -323,8 +323,10 @@ class ExpectColumnValuesToNotMatchLikePatternList(ColumnMapExpectation):
 
         template_str = "Values must not match the following like patterns: " + values_string
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_column_values_to_not_match_regex.py b/great_expectations/expectations/core/expect_column_values_to_not_match_regex.py
index 9c54ac4d3..c3ac219c3 100644
--- a/great_expectations/expectations/core/expect_column_values_to_not_match_regex.py
+++ b/great_expectations/expectations/core/expect_column_values_to_not_match_regex.py
@@ -305,9 +305,10 @@ class ExpectColumnValuesToNotMatchRegex(ColumnMapExpectation):
         if not params.get("regex"):
             template_str = "values must not match a regular expression but none was specified."
         else:  # noqa: PLR5501 # FIXME CoP
-            if params["mostly"] is not None and params["mostly"] < 1.0:
-                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
+            if params["mostly"] is not None:
+                if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                    params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                    # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
                 if include_column_name:
                     template_str = "$column values must not match this regular expression: $regex, at least $mostly_pct % of the time."  # noqa: E501 # FIXME CoP
                 else:
diff --git a/great_expectations/expectations/core/expect_column_values_to_not_match_regex_list.py b/great_expectations/expectations/core/expect_column_values_to_not_match_regex_list.py
index 4889ca4ad..1377799fa 100644
--- a/great_expectations/expectations/core/expect_column_values_to_not_match_regex_list.py
+++ b/great_expectations/expectations/core/expect_column_values_to_not_match_regex_list.py
@@ -323,9 +323,10 @@ class ExpectColumnValuesToNotMatchRegexList(ColumnMapExpectation):
             "values must not match any of the following regular expressions: " + values_string
         )
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
-            # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str += ", at least $mostly_pct % of the time."
         else:
             template_str += "."
diff --git a/great_expectations/expectations/core/expect_compound_columns_to_be_unique.py b/great_expectations/expectations/core/expect_compound_columns_to_be_unique.py
index 25b540d94..8d55195de 100644
--- a/great_expectations/expectations/core/expect_compound_columns_to_be_unique.py
+++ b/great_expectations/expectations/core/expect_compound_columns_to_be_unique.py
@@ -292,8 +292,10 @@ class ExpectCompoundColumnsToBeUnique(MulticolumnMapExpectation):
             ],
         )
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str = "Values for given compound columns must be unique together, at least $mostly_pct % of the time: "  # noqa: E501 # FIXME CoP
         else:
             template_str = "Values for given compound columns must be unique together: "
diff --git a/great_expectations/expectations/core/expect_multicolumn_sum_to_equal.py b/great_expectations/expectations/core/expect_multicolumn_sum_to_equal.py
index dd4af59f6..6bcf8349f 100644
--- a/great_expectations/expectations/core/expect_multicolumn_sum_to_equal.py
+++ b/great_expectations/expectations/core/expect_multicolumn_sum_to_equal.py
@@ -4,6 +4,9 @@ import logging
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     MulticolumnMapExpectation,
 )
@@ -183,12 +186,13 @@ class ExpectMulticolumnSumToEqual(MulticolumnMapExpectation):
                 }}
     """  # noqa: E501 # FIXME CoP
 
-    sum_total: float = pydantic.Field(description=SUM_TOTAL_DESCRIPTION)
-    ignore_row_if: Literal["all_values_are_missing", "any_value_is_missing", "never"] = (
-        pydantic.Field(
-            default="all_values_are_missing",
-            description=IGNORE_ROW_IF_DESCRIPTION,
-        )
+    sum_total: Union[float, SuiteParameterDict] = pydantic.Field(description=SUM_TOTAL_DESCRIPTION)
+    ignore_row_if: Union[
+        Literal["all_values_are_missing", "any_value_is_missing", "never"],
+        SuiteParameterDict,
+    ] = pydantic.Field(
+        default="all_values_are_missing",
+        description=IGNORE_ROW_IF_DESCRIPTION,
     )
 
     # This dictionary contains metadata for display in the public gallery
diff --git a/great_expectations/expectations/core/expect_multicolumn_values_to_be_unique.py b/great_expectations/expectations/core/expect_multicolumn_values_to_be_unique.py
index b5faa1819..f3f6dcebb 100644
--- a/great_expectations/expectations/core/expect_multicolumn_values_to_be_unique.py
+++ b/great_expectations/expectations/core/expect_multicolumn_values_to_be_unique.py
@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional, Union
 
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     ColumnMapExpectation,
     render_suite_parameter_string,
@@ -70,7 +73,7 @@ class ExpectMulticolumnValuesToBeUnique(ColumnMapExpectation):
     """  # noqa: E501 # FIXME CoP
 
     column_list: Union[tuple, list]
-    ignore_row_if: str = "all_values_are_missing"
+    ignore_row_if: Union[str, SuiteParameterDict] = "all_values_are_missing"
 
     library_metadata = {
         "maturity": "production",
diff --git a/great_expectations/expectations/core/expect_query_results_to_match_comparison.py b/great_expectations/expectations/core/expect_query_results_to_match_comparison.py
index 2385a194c..0b9b9b0f9 100644
--- a/great_expectations/expectations/core/expect_query_results_to_match_comparison.py
+++ b/great_expectations/expectations/core/expect_query_results_to_match_comparison.py
@@ -8,6 +8,9 @@ from great_expectations import exceptions
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.typing_extensions import override
 from great_expectations.core.result_format import ResultFormat
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     BatchExpectation,
     parse_value_to_observed_type,
@@ -117,11 +120,13 @@ class ExpectQueryResultsToMatchComparison(BatchExpectation):
         {DATA_QUALITY_ISSUES[0]}
     """
 
-    base_query: str = pydantic.Field(description=BASE_QUERY_DESCRIPTION)
-    comparison_data_source_name: str = pydantic.Field(
+    base_query: Union[str, SuiteParameterDict] = pydantic.Field(description=BASE_QUERY_DESCRIPTION)
+    comparison_data_source_name: Union[str, SuiteParameterDict] = pydantic.Field(
         description=COMPARISON_DATA_SOURCE_NAME_DESCRIPTION
     )
-    comparison_query: str = pydantic.Field(description=COMPARISON_QUERY_DESCRIPTION)
+    comparison_query: Union[str, SuiteParameterDict] = pydantic.Field(
+        description=COMPARISON_QUERY_DESCRIPTION
+    )
     mostly: MostlyField = 1
 
     metric_dependencies: ClassVar[Tuple[str, ...]] = (
diff --git a/great_expectations/expectations/core/expect_select_column_values_to_be_unique_within_record.py b/great_expectations/expectations/core/expect_select_column_values_to_be_unique_within_record.py
index 223d0199c..3248a3988 100644
--- a/great_expectations/expectations/core/expect_select_column_values_to_be_unique_within_record.py
+++ b/great_expectations/expectations/core/expect_select_column_values_to_be_unique_within_record.py
@@ -3,6 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Sequence, Type, Union
 
 from great_expectations.compatibility import pydantic
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     MulticolumnMapExpectation,
     render_suite_parameter_string,
@@ -180,7 +183,7 @@ class ExpectSelectColumnValuesToBeUniqueWithinRecord(MulticolumnMapExpectation):
     """  # noqa: E501 # FIXME CoP
 
     column_list: Sequence[str] = pydantic.Field(description=COLUMN_LIST_DESCRIPTION)
-    ignore_row_if: str = pydantic.Field(
+    ignore_row_if: Union[str, SuiteParameterDict] = pydantic.Field(
         default="all_values_are_missing", description=IGNORE_ROW_IF_DESCRIPTION
     )
 
@@ -303,8 +306,10 @@ class ExpectSelectColumnValuesToBeUniqueWithinRecord(MulticolumnMapExpectation):
             ],
         )
 
-        if params["mostly"] is not None and params["mostly"] < 1.0:
-            params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+        if params["mostly"] is not None:
+            if isinstance(params["mostly"], (int, float)) and params["mostly"] < 1.0:
+                params["mostly_pct"] = num_to_str(params["mostly"] * 100, no_scientific=True)
+                # params["mostly_pct"] = "{:.14f}".format(params["mostly"]*100).rstrip("0").rstrip(".")  # noqa: E501 # FIXME CoP
             template_str = (
                 "Values must be unique across columns, at least $mostly_pct % of the time: "
             )
diff --git a/great_expectations/expectations/core/expect_table_columns_to_match_set.py b/great_expectations/expectations/core/expect_table_columns_to_match_set.py
index 59a0c9392..a2ab0024c 100644
--- a/great_expectations/expectations/core/expect_table_columns_to_match_set.py
+++ b/great_expectations/expectations/core/expect_table_columns_to_match_set.py
@@ -179,7 +179,7 @@ class ExpectTableColumnsToMatchSet(BatchExpectation):
     column_set: Union[list, set, SuiteParameterDict, None] = pydantic.Field(
         description=COLUMN_SET_DESCRIPTION
     )
-    exact_match: Union[bool, None] = pydantic.Field(
+    exact_match: Union[bool, SuiteParameterDict, None] = pydantic.Field(
         default=True, description=EXACT_MATCH_DESCRIPTION
     )
 
diff --git a/great_expectations/expectations/core/expect_table_row_count_to_be_between.py b/great_expectations/expectations/core/expect_table_row_count_to_be_between.py
index 7d7f1eada..d98e167d5 100644
--- a/great_expectations/expectations/core/expect_table_row_count_to_be_between.py
+++ b/great_expectations/expectations/core/expect_table_row_count_to_be_between.py
@@ -176,8 +176,12 @@ class ExpectTableRowCountToBeBetween(BatchExpectation):
     max_value: Union[int, SuiteParameterDict, datetime, None] = pydantic.Field(
         default=None, description=MAX_VALUE_DESCRIPTION
     )
-    strict_min: bool = pydantic.Field(default=False, description=STRICT_MAX_DESCRIPTION)
-    strict_max: bool = pydantic.Field(default=False, description=STRICT_MIN_DESCRIPTION)
+    strict_min: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MAX_DESCRIPTION
+    )
+    strict_max: Union[bool, SuiteParameterDict] = pydantic.Field(
+        default=False, description=STRICT_MIN_DESCRIPTION
+    )
     row_condition: Union[str, None] = None
     condition_parser: Union[ConditionParser, None] = None
 
diff --git a/great_expectations/expectations/core/expect_table_row_count_to_equal_other_table.py b/great_expectations/expectations/core/expect_table_row_count_to_equal_other_table.py
index fccf788a2..2850026c1 100644
--- a/great_expectations/expectations/core/expect_table_row_count_to_equal_other_table.py
+++ b/great_expectations/expectations/core/expect_table_row_count_to_equal_other_table.py
@@ -5,6 +5,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Type, Union
 
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # noqa: TC001 # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     BatchExpectation,
     render_suite_parameter_string,
@@ -160,7 +163,9 @@ class ExpectTableRowCountToEqualOtherTable(BatchExpectation):
                 }}
     """  # noqa: E501 # FIXME CoP
 
-    other_table_name: str = pydantic.Field(description=OTHER_TABLE_NAME_DESCRIPTION)
+    other_table_name: Union[str, SuiteParameterDict] = pydantic.Field(
+        description=OTHER_TABLE_NAME_DESCRIPTION
+    )
     row_condition: Union[str, None] = None
     condition_parser: Union[ConditionParser, None] = None
 
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnKLDivergenceToBeLessThan.json b/great_expectations/expectations/core/schemas/ExpectColumnKLDivergenceToBeLessThan.json
index ccb95c23e..918c5e5a4 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnKLDivergenceToBeLessThan.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnKLDivergenceToBeLessThan.json
@@ -94,29 +94,57 @@
         "threshold": {
             "title": "Threshold",
             "description": "The maximum KL divergence to for which to return success=True. If KL divergence is largerthan the provided threshold, the test will return success=False.",
-            "type": "number"
+            "anyOf": [
+                {
+                    "type": "number"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "internal_weight_holdout": {
             "title": "Internal Weight Holdout",
             "description": "The amount of weight to split uniformly among zero-weighted partition bins. internal_weight_holdout provides a mechanisms to make the test less strict by assigning positive weights to values observed in the data for which the partition explicitly expected zero weight.",
             "default": 0,
-            "minimum": 0,
-            "maximum": 1,
-            "type": "number"
+            "anyOf": [
+                {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "tail_weight_holdout": {
             "title": "Tail Weight Holdout",
             "description": "The amount of weight to add to the tails of the histogram.Tail weight holdout is split evenly between (-Infinity, min(partition_object['bins'])) and (max(partition_object['bins']), +Infinity). tail_weight_holdout provides a mechanism to make the test less strict by assigning positive weights to values observed in the data that are not present in the partition. With no tail_weight_holdout, any value observed outside the provided partition_object will cause KL divergence to rise to +Infinity. Defaults to 0.",
             "default": 0,
-            "minimum": 0,
-            "maximum": 1,
-            "type": "number"
+            "anyOf": [
+                {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "bucketize_data": {
             "title": "Bucketize Data",
             "description": "If True, then continuous data will be bucketized before evaluation. Setting this parameter to false allows evaluation of KL divergence with a None partition object for profiling against discrete data.",
             "default": true,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "min_value": {
             "title": "Min Value",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnMaxToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnMaxToBeBetween.json
index 38d8eca3b..730e41340 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnMaxToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnMaxToBeBetween.json
@@ -128,15 +128,29 @@
         },
         "strict_min": {
             "title": "Strict Min",
-            "description": "If True, the upper bound of the column maximum acceptable rangemust be strictly smaller than max_value, default=False",
+            "description": "If True, the lower bound of the column maximum acceptable rangemust be strictly larger than min_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
-            "description": "If True, the lower bound of the column maximum acceptable rangemust be strictly larger than min_value, default=False",
+            "description": "If True, the upper bound of the column maximum acceptable rangemust be strictly smaller than max_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnMeanToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnMeanToBeBetween.json
index 951e4a122..e11f633a0 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnMeanToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnMeanToBeBetween.json
@@ -128,15 +128,29 @@
         },
         "strict_min": {
             "title": "Strict Min",
-            "description": "If True, the column mean must be strictly smaller than max_value, default=False",
+            "description": "If True, the column mean must be strictly larger than min_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
-            "description": "If True, the column mean must be strictly larger than min_value, default=False",
+            "description": "If True, the column mean must be strictly smaller than max_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnMedianToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnMedianToBeBetween.json
index b1bedd306..a8ddb9aab 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnMedianToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnMedianToBeBetween.json
@@ -128,15 +128,29 @@
         },
         "strict_min": {
             "title": "Strict Min",
-            "description": "If True, the column median must be strictly smaller than max_value, default=False",
+            "description": "If True, the column median must be strictly larger than min_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
-            "description": "If True, the column median must be strictly larger than min_value, default=False",
+            "description": "If True, the column median must be strictly smaller than max_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnMinToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnMinToBeBetween.json
index 34261ca20..8bbdf2f4c 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnMinToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnMinToBeBetween.json
@@ -128,15 +128,29 @@
         },
         "strict_min": {
             "title": "Strict Min",
-            "description": "If True, the maximal column minimum must be strictly smaller than max_value, default=False",
+            "description": "If True, the minimal column minimum must be strictly larger than min_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
-            "description": "If True, the minimal column minimum must be strictly larger than min_value, default=False",
+            "description": "If True, the maximal column minimum must be strictly smaller than max_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnMostCommonValueToBeInSet.json b/great_expectations/expectations/core/schemas/ExpectColumnMostCommonValueToBeInSet.json
index 90d7bfa40..5f81bd35f 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnMostCommonValueToBeInSet.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnMostCommonValueToBeInSet.json
@@ -160,7 +160,14 @@
         "ties_okay": {
             "title": "Ties Okay",
             "description": "If True, then the expectation will still succeed if values outside the designated set are as common (but not more common) than designated values.",
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnPairValuesAToBeGreaterThanB.json b/great_expectations/expectations/core/schemas/ExpectColumnPairValuesAToBeGreaterThanB.json
index 869d4babc..30e5afa33 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnPairValuesAToBeGreaterThanB.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnPairValuesAToBeGreaterThanB.json
@@ -111,18 +111,32 @@
         "or_equal": {
             "title": "Or Equal",
             "description": "If True, then values can be equal, not strictly greater.",
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "ignore_row_if": {
             "title": "Ignore Row If",
             "description": "If specified, sets the condition on which a given row is to be ignored.",
             "default": "both_values_are_missing",
-            "enum": [
-                "both_values_are_missing",
-                "either_value_is_missing",
-                "neither"
-            ],
-            "type": "string"
+            "anyOf": [
+                {
+                    "enum": [
+                        "both_values_are_missing",
+                        "either_value_is_missing",
+                        "neither"
+                    ],
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnPairValuesToBeEqual.json b/great_expectations/expectations/core/schemas/ExpectColumnPairValuesToBeEqual.json
index 6ca8d940f..c4f1eb81a 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnPairValuesToBeEqual.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnPairValuesToBeEqual.json
@@ -112,12 +112,19 @@
             "title": "Ignore Row If",
             "description": "If specified, sets the condition on which a given row is to be ignored.",
             "default": "both_values_are_missing",
-            "enum": [
-                "both_values_are_missing",
-                "either_value_is_missing",
-                "neither"
-            ],
-            "type": "string"
+            "anyOf": [
+                {
+                    "enum": [
+                        "both_values_are_missing",
+                        "either_value_is_missing",
+                        "neither"
+                    ],
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnPairValuesToBeInSet.json b/great_expectations/expectations/core/schemas/ExpectColumnPairValuesToBeInSet.json
index 4f17da852..0b8104b38 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnPairValuesToBeInSet.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnPairValuesToBeInSet.json
@@ -110,26 +110,40 @@
         },
         "value_pairs_set": {
             "title": "Value Pairs Set",
-            "type": "array",
-            "items": {
-                "type": "array",
-                "minItems": 2,
-                "maxItems": 2,
-                "items": [
-                    {},
-                    {}
-                ]
-            }
+            "anyOf": [
+                {
+                    "type": "array",
+                    "items": {
+                        "type": "array",
+                        "minItems": 2,
+                        "maxItems": 2,
+                        "items": [
+                            {},
+                            {}
+                        ]
+                    }
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "ignore_row_if": {
             "title": "Ignore Row If",
             "default": "both_values_are_missing",
-            "enum": [
-                "both_values_are_missing",
-                "either_value_is_missing",
-                "neither"
-            ],
-            "type": "string"
+            "anyOf": [
+                {
+                    "enum": [
+                        "both_values_are_missing",
+                        "either_value_is_missing",
+                        "neither"
+                    ],
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnProportionOfUniqueValuesToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnProportionOfUniqueValuesToBeBetween.json
index f713f7eed..7505aa9e9 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnProportionOfUniqueValuesToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnProportionOfUniqueValuesToBeBetween.json
@@ -130,13 +130,27 @@
             "title": "Strict Min",
             "description": "If True, the minimum proportion of unique values must be strictly larger than min_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
             "description": "If True, the maximum proportion of unique values must be strictly smaller than max_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "library_metadata": {
             "title": "Library Metadata",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnQuantileValuesToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnQuantileValuesToBeBetween.json
index 1bef09b09..df16ee689 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnQuantileValuesToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnQuantileValuesToBeBetween.json
@@ -89,9 +89,12 @@
         "quantile_ranges": {
             "title": "Quantile Ranges",
             "description": "Key 'quantiles' is an increasingly ordered list of desired quantile values (floats). Key 'value_ranges' is a list of 2-value lists that specify a lower and upper bound (inclusive) for the corresponding quantile (with [min, max] ordering).",
-            "allOf": [
+            "anyOf": [
                 {
                     "$ref": "#/definitions/QuantileRange"
+                },
+                {
+                    "type": "object"
                 }
             ]
         },
@@ -105,6 +108,9 @@
                 },
                 {
                     "type": "string"
+                },
+                {
+                    "type": "object"
                 }
             ]
         },
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnStdevToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnStdevToBeBetween.json
index 4ba367976..942cd4194 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnStdevToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnStdevToBeBetween.json
@@ -130,13 +130,27 @@
             "title": "Strict Min",
             "description": "If True, the column standard deviation must be strictly larger than min_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
             "description": "If True, the column standard deviation must be strictly smaller than max_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnSumToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnSumToBeBetween.json
index cbc7b28de..8396dd9c4 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnSumToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnSumToBeBetween.json
@@ -130,13 +130,27 @@
             "title": "Strict Min",
             "description": "If True, the minimal sum must be strictly larger than min_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
             "description": "If True, the maximal sum must be strictly smaller than max_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnUniqueValueCountToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnUniqueValueCountToBeBetween.json
index dd282fbad..196c72504 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnUniqueValueCountToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnUniqueValueCountToBeBetween.json
@@ -130,13 +130,27 @@
             "title": "Strict Min",
             "description": "If True, the column must have strictly more unique value count than min_value to pass.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
             "description": "If True, the column must have strictly fewer unique value count than max_value to pass.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "library_metadata": {
             "title": "Library Metadata",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnValueLengthsToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnValueLengthsToBeBetween.json
index 3c5219eed..4d237641a 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnValueLengthsToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnValueLengthsToBeBetween.json
@@ -138,13 +138,27 @@
             "title": "Strict Min",
             "description": "If True, values must be strictly larger than min_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
             "description": "If True, values must be strictly smaller than max_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnValuesToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectColumnValuesToBeBetween.json
index 52ccefe9c..f01634e60 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnValuesToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnValuesToBeBetween.json
@@ -146,13 +146,27 @@
             "title": "Strict Min",
             "description": "If True, values must be strictly larger than min_value.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
             "description": "The maximum value for a column entry.",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnValuesToBeOfType.json b/great_expectations/expectations/core/schemas/ExpectColumnValuesToBeOfType.json
index 86256cd94..94251823b 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnValuesToBeOfType.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnValuesToBeOfType.json
@@ -105,7 +105,14 @@
         "type_": {
             "title": "Type ",
             "description": "\n    A string representing the data type that each column should have as entries.     Valid types are defined by the current backend implementation and are dynamically loaded.\n    ",
-            "type": "string"
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnValuesToMatchLikePatternList.json b/great_expectations/expectations/core/schemas/ExpectColumnValuesToMatchLikePatternList.json
index 89f00b662..b196c693a 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnValuesToMatchLikePatternList.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnValuesToMatchLikePatternList.json
@@ -121,11 +121,18 @@
             "title": "Match On",
             "description": "'any' or 'all'. Use 'any' if the value should match at least one like pattern in the list. Use 'all' if it should match each like pattern in the list.",
             "default": "any",
-            "enum": [
-                "any",
-                "all"
-            ],
-            "type": "string"
+            "anyOf": [
+                {
+                    "enum": [
+                        "any",
+                        "all"
+                    ],
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectColumnValuesToMatchRegexList.json b/great_expectations/expectations/core/schemas/ExpectColumnValuesToMatchRegexList.json
index 232de719d..814410f9d 100644
--- a/great_expectations/expectations/core/schemas/ExpectColumnValuesToMatchRegexList.json
+++ b/great_expectations/expectations/core/schemas/ExpectColumnValuesToMatchRegexList.json
@@ -121,11 +121,18 @@
             "title": "Match On",
             "description": "'any' or 'all'. Use 'any' if the value should match at least one regular expression in the list. Use 'all' if it should match each regular expression in the list.",
             "default": "any",
-            "enum": [
-                "any",
-                "all"
-            ],
-            "type": "string"
+            "anyOf": [
+                {
+                    "enum": [
+                        "any",
+                        "all"
+                    ],
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectMulticolumnSumToEqual.json b/great_expectations/expectations/core/schemas/ExpectMulticolumnSumToEqual.json
index 9121ca3e6..91925f0d2 100644
--- a/great_expectations/expectations/core/schemas/ExpectMulticolumnSumToEqual.json
+++ b/great_expectations/expectations/core/schemas/ExpectMulticolumnSumToEqual.json
@@ -108,17 +108,31 @@
             "title": "Ignore Row If",
             "description": "If specified, sets the condition on which a given row is to be ignored.",
             "default": "all_values_are_missing",
-            "enum": [
-                "all_values_are_missing",
-                "any_value_is_missing",
-                "never"
-            ],
-            "type": "string"
+            "anyOf": [
+                {
+                    "enum": [
+                        "all_values_are_missing",
+                        "any_value_is_missing",
+                        "never"
+                    ],
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "sum_total": {
             "title": "Sum Total",
             "description": "Expected sum of columns",
-            "type": "number"
+            "anyOf": [
+                {
+                    "type": "number"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectQueryResultsToMatchComparison.json b/great_expectations/expectations/core/schemas/ExpectQueryResultsToMatchComparison.json
index d9751f463..add65d80f 100644
--- a/great_expectations/expectations/core/schemas/ExpectQueryResultsToMatchComparison.json
+++ b/great_expectations/expectations/core/schemas/ExpectQueryResultsToMatchComparison.json
@@ -69,17 +69,38 @@
         "base_query": {
             "title": "Base Query",
             "description": "A SQL query to be executed for this Data Asset.",
-            "type": "string"
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "comparison_data_source_name": {
             "title": "Comparison Data Source Name",
             "description": "The name of the comparison Data Source to compare this Asset against.",
-            "type": "string"
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "comparison_query": {
             "title": "Comparison Query",
             "description": "A SQL query to be executed for the comparison Data Source.",
-            "type": "string"
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "mostly": {
             "title": "Mostly",
diff --git a/great_expectations/expectations/core/schemas/ExpectSelectColumnValuesToBeUniqueWithinRecord.json b/great_expectations/expectations/core/schemas/ExpectSelectColumnValuesToBeUniqueWithinRecord.json
index f7b9c4783..86ecd8e59 100644
--- a/great_expectations/expectations/core/schemas/ExpectSelectColumnValuesToBeUniqueWithinRecord.json
+++ b/great_expectations/expectations/core/schemas/ExpectSelectColumnValuesToBeUniqueWithinRecord.json
@@ -108,7 +108,14 @@
             "title": "Ignore Row If",
             "description": "If specified, sets the condition on which a given row is to be ignored.",
             "default": "all_values_are_missing",
-            "type": "string"
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectTableColumnsToMatchSet.json b/great_expectations/expectations/core/schemas/ExpectTableColumnsToMatchSet.json
index 7f43ec670..045552030 100644
--- a/great_expectations/expectations/core/schemas/ExpectTableColumnsToMatchSet.json
+++ b/great_expectations/expectations/core/schemas/ExpectTableColumnsToMatchSet.json
@@ -88,7 +88,14 @@
             "title": "Exact Match",
             "description": "If True, the list of columns must exactly match the observed columns. If False, observed columns must include column_set but additional columns will pass.",
             "default": true,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/schemas/ExpectTableRowCountToBeBetween.json b/great_expectations/expectations/core/schemas/ExpectTableRowCountToBeBetween.json
index def3dae68..829db4d2f 100644
--- a/great_expectations/expectations/core/schemas/ExpectTableRowCountToBeBetween.json
+++ b/great_expectations/expectations/core/schemas/ExpectTableRowCountToBeBetween.json
@@ -102,13 +102,27 @@
             "title": "Strict Min",
             "description": "If True, the row count must be strictly smaller than max_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "strict_max": {
             "title": "Strict Max",
             "description": "If True, the row count must be strictly larger than min_value, default=False",
             "default": false,
-            "type": "boolean"
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "row_condition": {
             "title": "Row Condition",
diff --git a/great_expectations/expectations/core/schemas/ExpectTableRowCountToEqualOtherTable.json b/great_expectations/expectations/core/schemas/ExpectTableRowCountToEqualOtherTable.json
index a98571399..52e0032ad 100644
--- a/great_expectations/expectations/core/schemas/ExpectTableRowCountToEqualOtherTable.json
+++ b/great_expectations/expectations/core/schemas/ExpectTableRowCountToEqualOtherTable.json
@@ -69,7 +69,14 @@
         "other_table_name": {
             "title": "Other Table Name",
             "description": "The name of the other table. Other table must be located within the same database.",
-            "type": "string"
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "row_condition": {
             "title": "Row Condition",
diff --git a/great_expectations/expectations/core/schemas/UnexpectedRowsExpectation.json b/great_expectations/expectations/core/schemas/UnexpectedRowsExpectation.json
index 957006792..96bc4a5e9 100644
--- a/great_expectations/expectations/core/schemas/UnexpectedRowsExpectation.json
+++ b/great_expectations/expectations/core/schemas/UnexpectedRowsExpectation.json
@@ -69,7 +69,14 @@
         "unexpected_rows_query": {
             "title": "Unexpected Rows Query",
             "description": "A SQL or Spark-SQL query to be executed for validation.",
-            "type": "string"
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
         },
         "metadata": {
             "type": "object",
diff --git a/great_expectations/expectations/core/unexpected_rows_expectation.py b/great_expectations/expectations/core/unexpected_rows_expectation.py
index 4101877c6..685423ada 100644
--- a/great_expectations/expectations/core/unexpected_rows_expectation.py
+++ b/great_expectations/expectations/core/unexpected_rows_expectation.py
@@ -6,6 +6,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Tuple, Type, Un
 
 from great_expectations.compatibility import pydantic
 from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.suite_parameters import (
+    SuiteParameterDict,  # FIXME CoP
+)
 from great_expectations.expectations.expectation import (
     BatchExpectation,
     render_suite_parameter_string,
@@ -87,7 +90,9 @@ class UnexpectedRowsExpectation(BatchExpectation):
         {DATA_QUALITY_ISSUES[0]}
     """
 
-    unexpected_rows_query: str = pydantic.Field(description=UNEXPECTED_ROWS_QUERY_DESCRIPTION)
+    unexpected_rows_query: Union[str, SuiteParameterDict] = pydantic.Field(
+        description=UNEXPECTED_ROWS_QUERY_DESCRIPTION
+    )
 
     metric_dependencies: ClassVar[Tuple[str, ...]] = (
         "unexpected_rows_query.table",
@@ -101,7 +106,12 @@ class UnexpectedRowsExpectation(BatchExpectation):
     )
 
     @pydantic.validator("unexpected_rows_query")
-    def _validate_query(cls, query: str) -> str:
+    def _validate_query(
+        cls, query: Union[str, SuiteParameterDict]
+    ) -> Union[str, SuiteParameterDict]:
+        if isinstance(query, SuiteParameterDict):
+            return query
+
         parsed_fields = [f[1] for f in Formatter().parse(query)]
         if "batch" not in parsed_fields:
             batch_warning_message = (


Test patch:
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_kl_divergence_to_be_less_than.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_kl_divergence_to_be_less_than.py
index ef0e010ef..c79d0b29d 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_kl_divergence_to_be_less_than.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_kl_divergence_to_be_less_than.py
@@ -1,4 +1,5 @@
 import pandas as pd
+import pytest
 
 import great_expectations.expectations as gxe
 from great_expectations.core.result_format import ResultFormat
@@ -50,3 +51,129 @@ def test_failure(batch_for_datasource: Batch) -> None:
     )
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param({"weights": [0.5, 0.3, 0.2], "values": ["A", "B", "C"]}, True, id="success"),
+        pytest.param(
+            {
+                "weights": [0.3333333333333333, 0.3333333333333333, 0.3333333333333333],
+                "values": ["A", "B", "C"],
+            },
+            False,
+            id="failure",
+        ),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_partition_object_(
+    batch_for_datasource: Batch, suite_param_value: dict, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_kl_divergence_to_be_less_than"
+    expectation = gxe.ExpectColumnKLDivergenceToBeLessThan(
+        column=COL_NAME,
+        partition_object={"$PARAMETER": suite_param_key},
+        threshold=0.01,
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(0.01, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_threshold_(
+    batch_for_datasource: Batch, suite_param_value: float, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_kl_divergence_to_be_less_than"
+    expectation = gxe.ExpectColumnKLDivergenceToBeLessThan(
+        column=COL_NAME,
+        partition_object={"weights": [0.5, 0.3, 0.2], "values": ["A", "B", "C"]},
+        threshold={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(0, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_internal_weight_holdout_(
+    batch_for_datasource: Batch, suite_param_value: float, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_kl_divergence_to_be_less_than"
+    expectation = gxe.ExpectColumnKLDivergenceToBeLessThan(
+        column=COL_NAME,
+        partition_object={"weights": [0.5, 0.3, 0.2], "values": ["A", "B", "C"]},
+        threshold=0.01,
+        internal_weight_holdout={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(0.1, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_tail_weight_holdout_(
+    batch_for_datasource: Batch, suite_param_value: float, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_kl_divergence_to_be_less_than"
+    expectation = gxe.ExpectColumnKLDivergenceToBeLessThan(
+        column=COL_NAME,
+        partition_object={"weights": [0.5, 0.3, 0.2], "values": ["A", "B", "C"]},
+        threshold=0.01,
+        tail_weight_holdout={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_bucketize_data_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_kl_divergence_to_be_less_than"
+    expectation = gxe.ExpectColumnKLDivergenceToBeLessThan(
+        column=COL_NAME,
+        partition_object={"weights": [0.5, 0.3, 0.2], "values": ["A", "B", "C"]},
+        threshold=0.01,
+        bucketize_data={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_max_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_max_to_be_between.py
index 301661988..21cae4f61 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_max_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_max_to_be_between.py
@@ -152,7 +152,7 @@ def test_success_with_suite_param_min_value_(
     result = batch_for_datasource.validate(
         expectation, expectation_parameters={suite_param_key: suite_param_value}
     )
-    assert result.success is expected_result
+    assert result.success == expected_result
 
 
 @pytest.mark.parametrize(
@@ -178,4 +178,56 @@ def test_success_with_suite_param_max_value_(
     result = batch_for_datasource.validate(
         expectation, expectation_parameters={suite_param_key: suite_param_value}
     )
-    assert result.success is expected_result
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(
+    data_source_configs=JUST_PANDAS_DATA_SOURCES, data=ONES_AND_THREES
+)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_max_to_be_between"
+    expectation = gxe.ExpectColumnMaxToBeBetween(
+        column=COL_NAME,
+        min_value=0,
+        max_value=5,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(
+    data_source_configs=JUST_PANDAS_DATA_SOURCES, data=ONES_AND_THREES
+)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_max_to_be_between"
+    expectation = gxe.ExpectColumnMaxToBeBetween(
+        column=COL_NAME,
+        min_value=0,
+        max_value=5,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_mean_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_mean_to_be_between.py
index f90ee982c..b5c66abf9 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_mean_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_mean_to_be_between.py
@@ -101,3 +101,56 @@ def test_no_data(batch_for_datasource: Batch) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
     assert result.to_json_dict()["result"] == {"observed_value": None}
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(
+    data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA_WITH_NULLS
+)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_mean_to_be_between"
+    expectation = gxe.ExpectColumnMeanToBeBetween(
+        column=COL_NAME,
+        min_value=2,
+        max_value=3,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(
+    data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA_WITH_NULLS
+)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_mean_to_be_between"
+    expectation = gxe.ExpectColumnMeanToBeBetween(
+        column=COL_NAME,
+        min_value=2,
+        max_value=3,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_median_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_median_to_be_between.py
index dd0011cd1..60e733e27 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_median_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_median_to_be_between.py
@@ -106,3 +106,52 @@ def test_no_data(batch_for_datasource: Batch) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
     assert result.to_json_dict()["result"] == {"observed_value": None}
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=EVEN_COUNT)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_median_to_be_between"
+    expectation = gxe.ExpectColumnMedianToBeBetween(
+        column=COL_NAME,
+        min_value=10,
+        max_value=11,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=EVEN_COUNT)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_median_to_be_between"
+    expectation = gxe.ExpectColumnMedianToBeBetween(
+        column=COL_NAME,
+        min_value=10,
+        max_value=11,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_min_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_min_to_be_between.py
index 136a78bab..0c4792af5 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_min_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_min_to_be_between.py
@@ -127,3 +127,55 @@ def test_no_data(batch_for_datasource: Batch) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
     assert result.to_json_dict()["result"] == {"observed_value": None}
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(
+    data_source_configs=JUST_PANDAS_DATA_SOURCES, data=THREES_AND_FIVES
+)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_min_to_be_between"
+    expectation = gxe.ExpectColumnMinToBeBetween(
+        column=COL_NAME,
+        min_value=1,
+        max_value=4,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(
+    data_source_configs=JUST_PANDAS_DATA_SOURCES, data=THREES_AND_FIVES
+)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_min_to_be_between"
+    expectation = gxe.ExpectColumnMinToBeBetween(
+        column=COL_NAME,
+        min_value=1,
+        max_value=4,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_most_common_value_to_be_in_set.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_most_common_value_to_be_in_set.py
index 97f17a36f..6c4fda786 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_most_common_value_to_be_in_set.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_most_common_value_to_be_in_set.py
@@ -100,3 +100,26 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_ties_okay_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "expect_column_most_common_value_to_be_in_set"
+    expectation = gxe.ExpectColumnMostCommonValueToBeInSet(
+        column=COL_WITH_TIE,
+        value_set=[2, 4, 100],
+        ties_okay={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_a_to_be_greater_than_b.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_a_to_be_greater_than_b.py
index 9d09e46ae..634e1f5b9 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_a_to_be_greater_than_b.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_a_to_be_greater_than_b.py
@@ -190,3 +190,49 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_or_equal_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_pair_values_a_to_be_greater_than_b"
+    expectation = gxe.ExpectColumnPairValuesAToBeGreaterThanB(
+        column_A=NUMBERS_A,
+        column_B=NUMBERS_B,
+        or_equal={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param("both_values_are_missing", True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_ignore_row_if_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_pair_values_a_to_be_greater_than_b"
+    expectation = gxe.ExpectColumnPairValuesAToBeGreaterThanB(
+        column_A=NUMBERS_A,
+        column_B=NUMBERS_B,
+        ignore_row_if={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_to_be_equal.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_to_be_equal.py
index 57254a3ed..6f0be2701 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_to_be_equal.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_to_be_equal.py
@@ -197,3 +197,26 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param("both_values_are_missing", True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_ignore_row_if_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_pair_values_to_be_equal"
+    expectation = gxe.ExpectColumnPairValuesToBeEqual(
+        column_A=EQUAL_STRINGS_A,
+        column_B=EQUAL_STRINGS_B,
+        ignore_row_if={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_to_be_in_set.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_to_be_in_set.py
index d2763f799..2066b6cb0 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_to_be_in_set.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_pair_values_to_be_in_set.py
@@ -1,4 +1,5 @@
 import pandas as pd
+import pytest
 
 import great_expectations.expectations as gxe
 from great_expectations.core.result_format import ResultFormat
@@ -6,6 +7,7 @@ from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
 from tests.integration.data_sources_and_expectations.test_canonical_expectations import (
     ALL_DATA_SOURCES,
+    JUST_PANDAS_DATA_SOURCES,
 )
 
 DATA = pd.DataFrame({"foo": [1, 2, 4], "bar": [1, 1, 1]})
@@ -42,3 +44,54 @@ def test_success_complete_results(batch_for_datasource: Batch) -> None:
         "unexpected_percent_nonmissing": 33.33333333333333,
         "unexpected_percent_total": 33.33333333333333,
     }
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param([(2, 1), (1, 1)], True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_value_pairs_set_(
+    batch_for_datasource: Batch, suite_param_value: list[tuple], expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_pair_values_to_be_in_set"
+
+    expectation = gxe.ExpectColumnPairValuesToBeInSet(
+        column_A="foo",
+        column_B="bar",
+        value_pairs_set=[(2, 1), (1, 1)],
+        mostly=0.5,
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param("both_values_are_missing", True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_ignore_row_if_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_pair_values_to_be_in_set"
+
+    expectation = gxe.ExpectColumnPairValuesToBeInSet(
+        column_A="foo",
+        column_B="bar",
+        value_pairs_set=[(2, 1), (1, 1)],
+        mostly=0.5,
+        ignore_row_if={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_proportion_of_unique_values_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_proportion_of_unique_values_to_be_between.py
index 099e6b7f5..dbbedb627 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_proportion_of_unique_values_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_proportion_of_unique_values_to_be_between.py
@@ -182,3 +182,51 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(False, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_proportion_of_unique_values_to_be_between"
+    expectation = gxe.ExpectColumnProportionOfUniqueValuesToBeBetween(
+        column=SOME_UNIQUE_COL,
+        min_value=0.75,
+        max_value=0.75,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(False, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_proportion_of_unique_values_to_be_between"
+    expectation = gxe.ExpectColumnProportionOfUniqueValuesToBeBetween(
+        column=SOME_UNIQUE_COL,
+        min_value=0.75,
+        max_value=0.75,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_quantile_values_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_quantile_values_to_be_between.py
index da8c47f9d..ac38daf6b 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_quantile_values_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_quantile_values_to_be_between.py
@@ -1,4 +1,5 @@
 import pandas as pd
+import pytest
 
 import great_expectations.expectations as gxe
 from great_expectations.core.result_format import ResultFormat
@@ -72,3 +73,58 @@ def test_failure(batch_for_datasource: Batch) -> None:
     )
     result = batch_for_datasource.validate(expectation, result_format=ResultFormat.COMPLETE)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(
+            {
+                "quantiles": [0, 0.333, 0.667, 1],
+                "value_ranges": [[0, 1], [2, 3], [3, 4], [4, 5]],
+            },
+            True,
+            id="success",
+        ),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_quantile_ranges_(
+    batch_for_datasource: Batch, suite_param_value: dict, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_quantile_values_to_be_between"
+    expectation = gxe.ExpectColumnQuantileValuesToBeBetween(
+        column=COL_NAME,
+        quantile_ranges={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(False, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_allow_relative_error_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_quantile_values_to_be_between"
+    expectation = gxe.ExpectColumnQuantileValuesToBeBetween(
+        column=COL_NAME,
+        quantile_ranges=QuantileRange(
+            quantiles=[0, 0.333, 0.667, 1],
+            value_ranges=[[0, 1], [2, 3], [3, 4], [4, 5]],
+        ),
+        allow_relative_error={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_stdev_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_stdev_to_be_between.py
index d8f4ce372..d99657196 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_stdev_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_stdev_to_be_between.py
@@ -94,3 +94,51 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_stdev_to_be_between"
+    expectation = gxe.ExpectColumnStdevToBeBetween(
+        column=NUM_COL,
+        min_value=1,
+        max_value=1.5,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_stdev_to_be_between"
+    expectation = gxe.ExpectColumnStdevToBeBetween(
+        column=NUM_COL,
+        min_value=1,
+        max_value=1.5,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_sum_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_sum_to_be_between.py
index 5240d773b..367959dd1 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_sum_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_sum_to_be_between.py
@@ -73,3 +73,51 @@ def test_success(batch_for_datasource: Batch, expectation: gxe.ExpectColumnSumTo
 def test_failure(batch_for_datasource: Batch, expectation: gxe.ExpectColumnSumToBeBetween) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_sum_to_be_between"
+    expectation = gxe.ExpectColumnSumToBeBetween(
+        column=COL_NAME,
+        min_value=9000,
+        max_value=9002,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_sum_to_be_between"
+    expectation = gxe.ExpectColumnSumToBeBetween(
+        column=COL_NAME,
+        min_value=9000,
+        max_value=9002,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_unique_value_count_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_unique_value_count_to_be_between.py
index 07db7e33c..02a22040c 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_unique_value_count_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_unique_value_count_to_be_between.py
@@ -87,3 +87,51 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_unique_value_count_to_be_between"
+    expectation = gxe.ExpectColumnUniqueValueCountToBeBetween(
+        column=COL_NAME,
+        min_value=4,
+        max_value=6,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_unique_value_count_to_be_between"
+    expectation = gxe.ExpectColumnUniqueValueCountToBeBetween(
+        column=COL_NAME,
+        min_value=4,
+        max_value=6,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_value_lengths_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_value_lengths_to_be_between.py
index c34fb0fa7..8ba905304 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_value_lengths_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_value_lengths_to_be_between.py
@@ -76,3 +76,51 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_value_lengths_to_be_between"
+    expectation = gxe.ExpectColumnValueLengthsToBeBetween(
+        column=COL_NAME,
+        min_value=1,
+        max_value=4,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_value_lengths_to_be_between"
+    expectation = gxe.ExpectColumnValueLengthsToBeBetween(
+        column=COL_NAME,
+        min_value=1,
+        max_value=4,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_be_between.py
index 289e9a3e7..fdae0c812 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_be_between.py
@@ -258,3 +258,51 @@ class TestColumnValuesBetweenAgainstInvalidColumn:
         exception_info = list(results_with_errors[0].exception_info.values())
         assert len(exception_info) == 1
         assert self.EXPECTED_ERROR in exception_info[0]["exception_message"]
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_values_to_be_between"
+    expectation = gxe.ExpectColumnValuesToBeBetween(
+        column=NUMERIC_COLUMN,
+        min_value=0,
+        max_value=6,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_values_to_be_between"
+    expectation = gxe.ExpectColumnValuesToBeBetween(
+        column=NUMERIC_COLUMN,
+        min_value=0,
+        max_value=6,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_be_of_type.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_be_of_type.py
index 0e65646ff..f179443cf 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_be_of_type.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_be_of_type.py
@@ -2,6 +2,7 @@ import pandas as pd
 import pytest
 
 import great_expectations.expectations as gxe
+from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
 from tests.integration.data_sources_and_expectations.test_canonical_expectations import (
@@ -173,3 +174,25 @@ def test_case_insensitive_dialects(batch_for_datasource: Batch) -> None:
         expectation = gxe.ExpectColumnValuesToBeOfType(column=INTEGER_COLUMN, type_=type_str)
         result = batch_for_datasource.validate(expectation)
         assert result.success, f"Expected success for type '{type_str}' on dialect '{dialect_name}'"
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param("int", True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_type_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_values_to_be_of_type"
+    expectation = gxe.ExpectColumnValuesToBeOfType(
+        column=INTEGER_COLUMN,
+        type_={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_match_like_pattern_list.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_match_like_pattern_list.py
index 463bf2650..3e72260aa 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_match_like_pattern_list.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_match_like_pattern_list.py
@@ -238,3 +238,27 @@ def test_msql_fancy_syntax(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param("any", True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=SUPPORTED_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_match_on_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_values_to_match_like_pattern_list"
+
+    expectation = gxe.ExpectColumnValuesToMatchLikePatternList(
+        column=BASIC_PATTERNS,
+        like_pattern_list=["abc", "def", "ghi"],
+        match_on={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_match_regex_list.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_match_regex_list.py
index 383b1b830..e7e6e02e8 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_match_regex_list.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_column_values_to_match_regex_list.py
@@ -8,6 +8,9 @@ import great_expectations.expectations as gxe
 from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
+from tests.integration.data_sources_and_expectations.test_canonical_expectations import (
+    JUST_PANDAS_DATA_SOURCES,
+)
 from tests.integration.test_utils.data_source_config import (
     BigQueryDatasourceTestConfig,
     MySQLDatasourceTestConfig,
@@ -196,3 +199,27 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param("any", True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_match_on_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_column_values_to_match_regex_list"
+
+    expectation = gxe.ExpectColumnValuesToMatchRegexList(
+        column=BASIC_STRINGS,
+        regex_list=["a.+", "d.+", "g.+"],
+        match_on={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_multicolumn_sum_to_equal.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_multicolumn_sum_to_equal.py
index a84e1d0a6..f1af1dcb5 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_multicolumn_sum_to_equal.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_multicolumn_sum_to_equal.py
@@ -2,6 +2,7 @@ import pandas as pd
 import pytest
 
 import great_expectations.expectations as gxe
+from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
 from tests.integration.data_sources_and_expectations.test_canonical_expectations import (
@@ -66,3 +67,50 @@ def test_success(batch_for_datasource: Batch, expectation: gxe.ExpectMulticolumn
 def test_failure(batch_for_datasource: Batch, expectation: gxe.ExpectMulticolumnSumToEqual) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(7, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_sum_total_(
+    batch_for_datasource: Batch, suite_param_value: int, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_multicolumn_sum_to_equal"
+    expectation = gxe.ExpectMulticolumnSumToEqual(
+        column_list=[COL_A_BAD, COL_B, COL_C],
+        sum_total={"$PARAMETER": suite_param_key},
+        mostly=0.4,
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param("all_values_are_missing", True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_ignore_row_if_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_multicolumn_sum_to_equal"
+    expectation = gxe.ExpectMulticolumnSumToEqual(
+        column_list=[COL_A_BAD, COL_B, COL_C],
+        sum_total=7,
+        mostly=0.4,
+        ignore_row_if={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_query_results_to_match_comparison.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_query_results_to_match_comparison.py
index 46c9e3eab..8215c6e51 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_query_results_to_match_comparison.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_query_results_to_match_comparison.py
@@ -948,3 +948,51 @@ def _create_table_rendered_atomic_content(
         ),
         value_type="TableType",
     )
+
+
+@multi_source_batch_setup(
+    multi_source_test_configs=ALL_COMPARISON_TO_BASE_SOURCES,
+    base_data=BASE_DATA,
+    comparison_data=COMPARISON_DATA,
+)
+def test_success_with_suite_param_base_query_(
+    multi_source_batch: MultiSourceBatch,
+) -> None:
+    suite_param_key = "test_expect_query_results_to_match_comparison"
+
+    expectation = gxe.ExpectQueryResultsToMatchComparison(
+        base_query={"$PARAMETER": suite_param_key},
+        comparison_data_source_name=multi_source_batch.comparison_data_source_name,
+        comparison_query=f"SELECT a, b FROM {multi_source_batch.comparison_table_name} ORDER BY a, b",  # noqa: E501
+    )
+
+    result = multi_source_batch.base_batch.validate(
+        expectation,
+        expectation_parameters={suite_param_key: "SELECT a, b FROM {batch} ORDER BY a, b"},
+    )
+    assert result.success
+
+
+@multi_source_batch_setup(
+    multi_source_test_configs=ALL_COMPARISON_TO_BASE_SOURCES,
+    base_data=BASE_DATA,
+    comparison_data=COMPARISON_DATA,
+)
+def test_success_with_suite_param_comparison_query_(
+    multi_source_batch: MultiSourceBatch,
+) -> None:
+    suite_param_key = "test_expect_query_results_to_match_comparison"
+
+    expectation = gxe.ExpectQueryResultsToMatchComparison(
+        base_query="SELECT a, b FROM {batch} ORDER BY a, b",
+        comparison_data_source_name=multi_source_batch.comparison_data_source_name,
+        comparison_query={"$PARAMETER": suite_param_key},
+    )
+
+    result = multi_source_batch.base_batch.validate(
+        expectation,
+        expectation_parameters={
+            suite_param_key: f"SELECT a, b FROM {multi_source_batch.comparison_table_name} ORDER BY a, b"  # noqa: E501
+        },
+    )
+    assert result.success
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_select_column_values_to_be_unique_within_record.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_select_column_values_to_be_unique_within_record.py
index 478c41ae1..06a9dc215 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_select_column_values_to_be_unique_within_record.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_select_column_values_to_be_unique_within_record.py
@@ -2,6 +2,7 @@ import pandas as pd
 import pytest
 
 import great_expectations.expectations as gxe
+from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
 from tests.integration.data_sources_and_expectations.test_canonical_expectations import (
@@ -88,3 +89,26 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param("all_values_are_missing", True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_ignore_row_if_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_select_column_values_to_be_unique_within_record"
+    expectation = gxe.ExpectSelectColumnValuesToBeUniqueWithinRecord(
+        column_list=[INT_COL_A, INT_COL_B, INT_COL_C],
+        mostly=0.75,
+        ignore_row_if={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_table_columns_to_match_set.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_table_columns_to_match_set.py
index 6f98808e4..11cfa2030 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_table_columns_to_match_set.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_table_columns_to_match_set.py
@@ -2,6 +2,7 @@ import pandas as pd
 import pytest
 
 import great_expectations.expectations as gxe
+from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
 from tests.integration.data_sources_and_expectations.test_canonical_expectations import (
@@ -86,3 +87,25 @@ def test_failure(
 ) -> None:
     result = batch_for_datasource.validate(expectation)
     assert not result.success
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(False, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_exact_match_(
+    batch_for_datasource: Batch, suite_param_value: str, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_table_columns_to_match_set"
+    expectation = gxe.ExpectTableColumnsToMatchSet(
+        column_set=[COL_A, COL_B],
+        exact_match={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_table_row_count_to_be_between.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_table_row_count_to_be_between.py
index ab5c73a59..dc6cabba9 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_table_row_count_to_be_between.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_table_row_count_to_be_between.py
@@ -3,6 +3,7 @@ import pytest
 
 import great_expectations.expectations as gxe
 from great_expectations.compatibility import pydantic
+from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
 from tests.integration.data_sources_and_expectations.test_canonical_expectations import (
@@ -145,3 +146,49 @@ def test_invalid_runtime_parameters() -> None:
             min_value={"min_value": "param_min_value"},
             max_value={"max_value": "param_max_values"},
         )
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_min_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_table_row_count_to_be_between"
+    expectation = gxe.ExpectTableRowCountToBeBetween(
+        min_value=2,
+        max_value=4,
+        strict_min={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
+
+
+@pytest.mark.parametrize(
+    "suite_param_value,expected_result",
+    [
+        pytest.param(True, True, id="success"),
+    ],
+)
+@parameterize_batch_for_data_sources(data_source_configs=JUST_PANDAS_DATA_SOURCES, data=DATA)
+def test_success_with_suite_param_strict_max_(
+    batch_for_datasource: Batch, suite_param_value: bool, expected_result: bool
+) -> None:
+    suite_param_key = "test_expect_table_row_count_to_be_between"
+    expectation = gxe.ExpectTableRowCountToBeBetween(
+        min_value=2,
+        max_value=4,
+        strict_max={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: suite_param_value}
+    )
+    assert result.success == expected_result
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_table_row_count_to_equal_other_table.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_table_row_count_to_equal_other_table.py
index b65d8e785..a4286b553 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_table_row_count_to_equal_other_table.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_table_row_count_to_equal_other_table.py
@@ -3,6 +3,7 @@ from typing import Mapping, Sequence
 import pandas as pd
 
 import great_expectations.expectations as gxe
+from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
 from tests.integration.test_utils.data_source_config import (
@@ -69,3 +70,23 @@ def test_missing_table(batch_for_datasource: Batch):
     expectation = gxe.ExpectTableRowCountToEqualOtherTable(other_table_name="where_am_i")
     result = batch_for_datasource.validate(expectation)
     assert not result.success, "We should not find the other table, since we didn't load it."
+
+
+@parameterize_batch_for_data_sources(
+    data_source_configs=MULTI_ASSET_DATA_SOURCES,
+    data=pd.DataFrame({"a": [1, 2, 3, 4]}),
+    extra_data={"other_table": pd.DataFrame({"col_b": ["a", "b", "c", "d"]})},
+)
+def test_success_with_suite_param_other_table_name_(
+    batch_for_datasource: Batch, extra_table_names_for_datasource: Mapping[str, str]
+) -> None:
+    suite_param_key = "test_expect_table_row_count_to_equal_other_table"
+    other_table_name = extra_table_names_for_datasource["other_table"]
+    expectation = gxe.ExpectTableRowCountToEqualOtherTable(
+        other_table_name={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: other_table_name}
+    )
+    assert result.success
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_unexpected_rows_expectation.py b/tests/integration/data_sources_and_expectations/expectations/test_unexpected_rows_expectation.py
index 99af96f62..959e7fb7c 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_unexpected_rows_expectation.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_unexpected_rows_expectation.py
@@ -6,6 +6,7 @@ import pandas as pd
 import pytest
 
 import great_expectations.expectations as gxe
+from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
 from tests.integration.test_utils.data_source_config import (
@@ -368,3 +369,23 @@ def test_fail_result_format(batch_for_datasource: Batch) -> None:
             ],
         },
     }
+
+
+@parameterize_batch_for_data_sources(
+    data_source_configs=ALL_SUPPORTED_DATA_SOURCES,
+    data=TABLE_1,
+)
+@pytest.mark.parametrize("unexpected_rows_query", SUCCESS_QUERIES)
+def test_success_with_suite_param_other_table_name_(
+    batch_for_datasource: Batch, unexpected_rows_query
+) -> None:
+    suite_param_key = "test_unexpected_rows_expectation"
+    expectation = gxe.UnexpectedRowsExpectation(
+        description="Expect query with {batch} keyword to succeed",
+        unexpected_rows_query={"$PARAMETER": suite_param_key},
+        result_format=ResultFormat.SUMMARY,
+    )
+    result = batch_for_datasource.validate(
+        expectation, expectation_parameters={suite_param_key: unexpected_rows_query}
+    )
+    assert result.success