snowpark-checkpoints-collectors 0.1.0rc2__py3-none-any.whl → 0.1.1__py3-none-any.whl

snowflake/snowpark_checkpoints_collector/column_collection/model/__init__.py

@@ -0,0 +1,75 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__all__ = [
+    "ArrayColumnCollector",
+    "BinaryColumnCollector",
+    "BooleanColumnCollector",
+    "DateColumnCollector",
+    "DayTimeIntervalColumnCollector",
+    "DecimalColumnCollector",
+    "EmptyColumnCollector",
+    "MapColumnCollector",
+    "NumericColumnCollector",
+    "NullColumnCollector",
+    "StringColumnCollector",
+    "StructColumnCollector",
+    "TimestampColumnCollector",
+    "TimestampNTZColumnCollector",
+]
+
+from snowflake.snowpark_checkpoints_collector.column_collection.model.array_column_collector import (
+    ArrayColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.binary_column_collector import (
+    BinaryColumnCollector,
+)
+
+from snowflake.snowpark_checkpoints_collector.column_collection.model.boolean_column_collector import (
+    BooleanColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.date_column_collector import (
+    DateColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.day_time_interval_column_collector import (
+    DayTimeIntervalColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.decimal_column_collector import (
+    DecimalColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.empty_column_collector import (
+    EmptyColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.map_column_collector import (
+    MapColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.null_column_collector import (
+    NullColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.numeric_column_collector import (
+    NumericColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.string_column_collector import (
+    StringColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.struct_column_collector import (
+    StructColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.timestamp_column_collector import (
+    TimestampColumnCollector,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.timestamp_ntz_column_collector import (
+    TimestampNTZColumnCollector,
+)

snowflake/snowpark_checkpoints_collector/column_collection/model/array_column_collector.py

@@ -0,0 +1,113 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from statistics import mean
+
+from pyspark.sql import DataFrame as SparkDataFrame
+from pyspark.sql.functions import array as spark_array
+from pyspark.sql.functions import coalesce as spark_coalesce
+from pyspark.sql.functions import col as spark_col
+from pyspark.sql.functions import explode as spark_explode
+from pyspark.sql.functions import size as spark_size
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    COLUMN_ALLOW_NULL_KEY,
+    COLUMN_IS_UNIQUE_SIZE_KEY,
+    COLUMN_MAX_SIZE_KEY,
+    COLUMN_MEAN_SIZE_KEY,
+    COLUMN_MIN_SIZE_KEY,
+    COLUMN_NULL_VALUE_PROPORTION_KEY,
+    COLUMN_SIZE_KEY,
+    COLUMN_VALUE_KEY,
+    COLUMN_VALUE_TYPE_KEY,
+    CONTAINS_NULL_KEY,
+    ELEMENT_TYPE_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class ArrayColumnCollector(ColumnCollectorBase):
+
+    """Class for collect an array type column.
+
+    Attributes:
+        name (str): the name of the column.
+        type (str): the type of the column.
+        struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+        column_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+    """
+
+    def __init__(
+        self, clm_name: str, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init ArrayColumnCollector.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            clm_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        """
+        super().__init__(clm_name, struct_field, clm_df)
+        self._array_size_collection = self._compute_array_size_collection()
+
+    def get_custom_data(self) -> dict[str, any]:
+        data_type_dict = self.struct_field.dataType.jsonValue()
+        array_type = data_type_dict[ELEMENT_TYPE_KEY]
+        allow_null = data_type_dict[CONTAINS_NULL_KEY]
+        null_value_proportion = (
+            self._compute_null_value_proportion() if allow_null else 0.0
+        )
+        array_max_size = max(self._array_size_collection)
+        array_min_size = min(self._array_size_collection)
+        array_mean_size = mean(self._array_size_collection)
+        all_array_have_same_size = array_max_size == array_min_size
+
+        custom_data_dict = {
+            COLUMN_VALUE_TYPE_KEY: array_type,
+            COLUMN_ALLOW_NULL_KEY: allow_null,
+            COLUMN_NULL_VALUE_PROPORTION_KEY: null_value_proportion,
+            COLUMN_MAX_SIZE_KEY: array_max_size,
+            COLUMN_MIN_SIZE_KEY: array_min_size,
+            COLUMN_MEAN_SIZE_KEY: array_mean_size,
+            COLUMN_IS_UNIQUE_SIZE_KEY: all_array_have_same_size,
+        }
+
+        return custom_data_dict
+
+    def _compute_array_size_collection(self) -> list[int]:
+        select_result = self.column_df.select(
+            spark_size(spark_coalesce(spark_col(self.name), spark_array([]))).alias(
+                COLUMN_SIZE_KEY
+            )
+        ).collect()
+
+        size_collection = [row[COLUMN_SIZE_KEY] for row in select_result]
+
+        return size_collection
+
+    def _compute_null_value_proportion(self) -> float:
+        select_result = self.column_df.select(
+            spark_explode(spark_col(self.name)).alias(COLUMN_VALUE_KEY)
+        )
+
+        null_counter = select_result.where(spark_col(COLUMN_VALUE_KEY).isNull()).count()
+
+        total_values = sum(self._array_size_collection)
+        null_value_proportion = (null_counter / total_values) * 100
+        return null_value_proportion

snowflake/snowpark_checkpoints_collector/column_collection/model/binary_column_collector.py

@@ -0,0 +1,87 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from statistics import mean
+
+from pyspark.sql import DataFrame as SparkDataFrame
+from pyspark.sql.functions import coalesce as spark_coalesce
+from pyspark.sql.functions import col as spark_col
+from pyspark.sql.functions import length as spark_length
+from pyspark.sql.functions import lit as spark_lit
+from pyspark.sql.functions import to_binary as spark_to_binary
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    COLUMN_IS_UNIQUE_SIZE_KEY,
+    COLUMN_MAX_SIZE_KEY,
+    COLUMN_MEAN_SIZE_KEY,
+    COLUMN_MIN_SIZE_KEY,
+    COLUMN_SIZE_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class BinaryColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a binary type column.
+
+    Attributes:
+        name (str): the name of the column.
+        type (str): the type of the column.
+        struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+        column_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+    """
+
+    def __init__(
+        self, clm_name: str, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init BinaryColumnCollector.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            clm_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        """
+        super().__init__(clm_name, struct_field, clm_df)
+        self._binary_size_collection = self._compute_binary_size_collection()
+
+    def get_custom_data(self) -> dict[str, any]:
+        max_size_value = max(self._binary_size_collection)
+        min_size_value = min(self._binary_size_collection)
+        mean_size_value = mean(self._binary_size_collection)
+        all_elements_have_same_size = max_size_value == min_size_value
+
+        custom_data_dict = {
+            COLUMN_MAX_SIZE_KEY: max_size_value,
+            COLUMN_MIN_SIZE_KEY: min_size_value,
+            COLUMN_MEAN_SIZE_KEY: mean_size_value,
+            COLUMN_IS_UNIQUE_SIZE_KEY: all_elements_have_same_size,
+        }
+
+        return custom_data_dict
+
+    def _compute_binary_size_collection(self) -> list[int]:
+        select_result = self.column_df.select(
+            spark_length(
+                spark_coalesce(spark_col(self.name), spark_to_binary(spark_lit(b"")))
+            ).alias(COLUMN_SIZE_KEY)
+        ).collect()
+
+        size_collection = [row[COLUMN_SIZE_KEY] for row in select_result]
+
+        return size_collection

snowflake/snowpark_checkpoints_collector/column_collection/model/boolean_column_collector.py

@@ -0,0 +1,71 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pyspark.sql import DataFrame as SparkDataFrame
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    COLUMN_FALSE_COUNT_KEY,
+    COLUMN_TRUE_COUNT_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+TRUE_KEY = "True"
+FALSE_KEY = "False"
+NONE_KEY = "None"
+
+
+class BooleanColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a boolean type column.
+
+    Attributes:
+        name (str): the name of the column.
+        type (str): the type of the column.
+        struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+        column_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+    """
+
+    def __init__(
+        self, clm_name: str, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init BooleanColumnCollector.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            clm_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        """
+        super().__init__(clm_name, struct_field, clm_df)
+
+    def get_custom_data(self) -> dict[str, any]:
+        count_dict = self._get_count_dict()
+
+        custom_data_dict = {
+            COLUMN_TRUE_COUNT_KEY: count_dict.get(TRUE_KEY, 0),
+            COLUMN_FALSE_COUNT_KEY: count_dict.get(FALSE_KEY, 0),
+        }
+
+        return custom_data_dict
+
+    def _get_count_dict(self) -> dict[str, int]:
+        select_result = self.column_df.groupby(self.name).count().collect()
+        count_dict = {str(row[0]): row[1] for row in select_result}
+        return count_dict

snowflake/snowpark_checkpoints_collector/column_collection/model/column_collector_base.py

@@ -0,0 +1,95 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+
+from pyspark.sql import DataFrame as SparkDataFrame
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    COLUMN_COUNT_KEY,
+    COLUMN_IS_NULLABLE_KEY,
+    COLUMN_NAME_KEY,
+    COLUMN_ROWS_NOT_NULL_COUNT_KEY,
+    COLUMN_ROWS_NULL_COUNT_KEY,
+    COLUMN_TYPE_KEY,
+)
+
+
+class ColumnCollectorBase(ABC):
+
+    """Base class for column collector based on type.
+
+    Attributes:
+        name (str): the name of the column.
+        type (str): the type of the column.
+        struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+        column_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+    """
+
+    def __init__(
+        self, clm_name: str, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init ColumnCollectorBase.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            clm_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        """
+        self.name = clm_name
+        self.type = struct_field.dataType.typeName()
+        self.struct_field = struct_field
+        self.column_df = clm_df
+
+    @abstractmethod
+    def get_custom_data(self) -> dict[str, any]:
+        """Get the custom data of the column.
+
+        Returns:
+            dict[str, any]: The data collected.
+
+        """
+        pass
+
+    def _get_common_data(self) -> dict[str, any]:
+        column_size = self.column_df.count()
+        rows_not_null_count = self.column_df.dropna().count()
+        rows_null_count = column_size - rows_not_null_count
+
+        common_data_dict = {
+            COLUMN_NAME_KEY: self.name,
+            COLUMN_TYPE_KEY: self.type,
+            COLUMN_IS_NULLABLE_KEY: self.struct_field.nullable,
+            COLUMN_COUNT_KEY: column_size,
+            COLUMN_ROWS_NOT_NULL_COUNT_KEY: rows_not_null_count,
+            COLUMN_ROWS_NULL_COUNT_KEY: rows_null_count,
+        }
+
+        return common_data_dict
+
+    def get_data(self) -> dict[str, any]:
+        """Get the data collected of the column.
+
+        Returns:
+            dict[str, any]: The data collected.
+
+        """
+        common_data = self._get_common_data()
+        custom_data = self.get_custom_data()
+        column_data = dict(common_data | custom_data)
+        return column_data

snowflake/snowpark_checkpoints_collector/column_collection/model/date_column_collector.py

@@ -0,0 +1,74 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from pyspark.sql import DataFrame as SparkDataFrame
+from pyspark.sql.functions import col as spark_col
+from pyspark.sql.functions import max as spark_max
+from pyspark.sql.functions import min as spark_min
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    COLUMN_FORMAT_KEY,
+    COLUMN_MAX_KEY,
+    COLUMN_MIN_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+FORMAT = "%Y-%m-%d"
+
+
+class DateColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a date type column.
+
+    Attributes:
+        name (str): the name of the column.
+        type (str): the type of the column.
+        struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+        column_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+    """
+
+    def __init__(
+        self, clm_name: str, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init DateColumnCollector.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            clm_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        """
+        super().__init__(clm_name, struct_field, clm_df)
+
+    def get_custom_data(self) -> dict[str, any]:
+        select_result = self.column_df.select(
+            spark_min(spark_col(self.name)).alias(COLUMN_MIN_KEY),
+            spark_max(spark_col(self.name)).alias(COLUMN_MAX_KEY),
+        ).collect()[0]
+
+        min_value = str(select_result[COLUMN_MIN_KEY])
+        max_value = str(select_result[COLUMN_MAX_KEY])
+
+        custom_data_dict = {
+            COLUMN_MIN_KEY: min_value,
+            COLUMN_MAX_KEY: max_value,
+            COLUMN_FORMAT_KEY: FORMAT,
+        }
+
+        return custom_data_dict

snowflake/snowpark_checkpoints_collector/column_collection/model/day_time_interval_column_collector.py

@@ -0,0 +1,67 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pyspark.sql import DataFrame as SparkDataFrame
+from pyspark.sql.functions import col as spark_col
+from pyspark.sql.functions import max as spark_max
+from pyspark.sql.functions import min as spark_min
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    COLUMN_MAX_KEY,
+    COLUMN_MIN_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class DayTimeIntervalColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a date time interval type column.
+
+    Attributes:
+        name (str): the name of the column.
+        type (str): the type of the column.
+        struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+        column_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+    """
+
+    def __init__(
+        self, clm_name: str, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init DayTimeIntervalColumnCollector.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            clm_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        """
+        super().__init__(clm_name, struct_field, clm_df)
+
+    def get_custom_data(self) -> dict[str, any]:
+        select_result = self.column_df.select(
+            spark_min(spark_col(self.name)).alias(COLUMN_MIN_KEY),
+            spark_max(spark_col(self.name)).alias(COLUMN_MAX_KEY),
+        ).collect()[0]
+
+        min_value = str(select_result[COLUMN_MIN_KEY])
+        max_value = str(select_result[COLUMN_MAX_KEY])
+
+        custom_data_dict = {COLUMN_MIN_KEY: min_value, COLUMN_MAX_KEY: max_value}
+
+        return custom_data_dict

snowflake/snowpark_checkpoints_collector/column_collection/model/decimal_column_collector.py

@@ -0,0 +1,92 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pyspark.sql import DataFrame as SparkDataFrame
+from pyspark.sql.functions import col as spark_col
+from pyspark.sql.functions import max as spark_max
+from pyspark.sql.functions import mean as spark_mean
+from pyspark.sql.functions import min as spark_min
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    COLUMN_DECIMAL_PRECISION_KEY,
+    COLUMN_MAX_KEY,
+    COLUMN_MEAN_KEY,
+    COLUMN_MIN_KEY,
+    get_decimal_token,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class DecimalColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a decimal type column.
+
+    Attributes:
+        name (str): the name of the column.
+        type (str): the type of the column.
+        struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+        column_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+    """
+
+    def __init__(
+        self, clm_name: str, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init DecimalColumnCollector.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            clm_df (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        """
+        super().__init__(clm_name, struct_field, clm_df)
+
+    def get_custom_data(self) -> dict[str, any]:
+        select_result = self.column_df.select(
+            spark_min(spark_col(self.name)).alias(COLUMN_MIN_KEY),
+            spark_max(spark_col(self.name)).alias(COLUMN_MAX_KEY),
+            spark_mean(spark_col(self.name)).alias(COLUMN_MEAN_KEY),
+        ).collect()[0]
+
+        min_value = str(select_result[COLUMN_MIN_KEY])
+        max_value = str(select_result[COLUMN_MAX_KEY])
+        mean_value = str(select_result[COLUMN_MEAN_KEY])
+        decimal_precision = self._compute_decimal_precision()
+
+        custom_data_dict = {
+            COLUMN_MIN_KEY: min_value,
+            COLUMN_MAX_KEY: max_value,
+            COLUMN_MEAN_KEY: mean_value,
+            COLUMN_DECIMAL_PRECISION_KEY: decimal_precision,
+        }
+
+        return custom_data_dict
+
+    def _compute_decimal_precision(self) -> int:
+        decimal_part_index = 1
+        decimal_token = get_decimal_token()
+        value = self.column_df.dropna().collect()[0][0]
+        value_str = str(value)
+        value_split_by_token = value_str.split(decimal_token)
+        if len(value_split_by_token) == 1:
+            return 0
+
+        decimal_part = value_split_by_token[decimal_part_index]
+        decimal_digits_counted = len(decimal_part)
+        return decimal_digits_counted