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

snowflake/snowpark_checkpoints_collector/column_collection/model/empty_column_collector.py

@@ -0,0 +1,88 @@
+# 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 (
+    ARRAY_COLUMN_TYPE,
+    COLUMN_ALLOW_NULL_KEY,
+    COLUMN_KEY_TYPE_KEY,
+    COLUMN_METADATA_KEY,
+    COLUMN_VALUE_TYPE_KEY,
+    CONTAINS_NULL_KEY,
+    ELEMENT_TYPE_KEY,
+    FIELD_METADATA_KEY,
+    FIELDS_KEY,
+    KEY_TYPE_KEY,
+    MAP_COLUMN_TYPE,
+    STRUCT_COLUMN_TYPE,
+    VALUE_CONTAINS_NULL_KEY,
+    VALUE_TYPE_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class EmptyColumnCollector(ColumnCollectorBase):
+
+    """Class for collect an empty 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 EmptyColumnCollector.
+
+        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]:
+        custom_data = {}
+        data_type_dict = self.struct_field.dataType.jsonValue()
+        if self.type == ARRAY_COLUMN_TYPE:
+            custom_data[COLUMN_VALUE_TYPE_KEY] = data_type_dict[ELEMENT_TYPE_KEY]
+            custom_data[COLUMN_ALLOW_NULL_KEY] = data_type_dict[CONTAINS_NULL_KEY]
+
+        elif self.type == MAP_COLUMN_TYPE:
+            custom_data[COLUMN_KEY_TYPE_KEY] = data_type_dict[KEY_TYPE_KEY]
+            custom_data[COLUMN_VALUE_TYPE_KEY] = data_type_dict[VALUE_TYPE_KEY]
+            custom_data[COLUMN_ALLOW_NULL_KEY] = data_type_dict[VALUE_CONTAINS_NULL_KEY]
+
+        elif self.type == STRUCT_COLUMN_TYPE:
+            field_metadata_collection = []
+            struct_field_json = self.struct_field.dataType.jsonValue()
+            for field in struct_field_json[FIELDS_KEY]:
+                del field[FIELD_METADATA_KEY]
+                field_metadata_collection.append(field)
+            custom_data[COLUMN_METADATA_KEY] = field_metadata_collection
+
+        else:
+            custom_data = {}
+
+        return custom_data

snowflake/snowpark_checkpoints_collector/column_collection/model/map_column_collector.py

@@ -0,0 +1,120 @@
+# 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 create_map as spark_create_map
+from pyspark.sql.functions import explode as spark_explode
+from pyspark.sql.functions import map_values as spark_map_values
+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_KEY_TYPE_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,
+    KEY_TYPE_KEY,
+    VALUE_CONTAINS_NULL_KEY,
+    VALUE_TYPE_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class MapColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a map 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 MapColumnCollector.
+
+        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._map_size_collection = self._compute_map_size_collection()
+
+    def get_custom_data(self) -> dict[str, any]:
+        data_type_dict = self.struct_field.dataType.jsonValue()
+        key_type = data_type_dict[KEY_TYPE_KEY]
+        value_type = data_type_dict[VALUE_TYPE_KEY]
+        allow_null = data_type_dict[VALUE_CONTAINS_NULL_KEY]
+        null_value_proportion = (
+            self._compute_null_value_proportion() if allow_null else 0.0
+        )
+        array_max_size = max(self._map_size_collection)
+        array_min_size = min(self._map_size_collection)
+        array_mean_size = mean(self._map_size_collection)
+        all_array_have_same_size = array_max_size == array_min_size
+
+        custom_data_dict = {
+            COLUMN_KEY_TYPE_KEY: key_type,
+            COLUMN_VALUE_TYPE_KEY: value_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_map_size_collection(self) -> list[int]:
+        select_result = self.column_df.select(
+            spark_size(
+                spark_coalesce(spark_col(self.name), spark_create_map([]))
+            ).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_map_values(spark_col(self.name))).alias(
+                COLUMN_VALUE_KEY
+            )
+        )
+
+        null_counter = select_result.where(spark_col(COLUMN_VALUE_KEY).isNull()).count()
+
+        total_values = sum(self._map_size_collection)
+        null_value_proportion = (null_counter / total_values) * 100
+        return null_value_proportion

snowflake/snowpark_checkpoints_collector/column_collection/model/null_column_collector.py

@@ -0,0 +1,49 @@
+# 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.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class NullColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a null 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 NullColumnCollector.
+
+        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]:
+        return {}

snowflake/snowpark_checkpoints_collector/column_collection/model/numeric_column_collector.py

@@ -0,0 +1,108 @@
+# 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.functions import stddev as spark_sdt
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    COLUMN_DECIMAL_PRECISION_KEY,
+    COLUMN_MARGIN_ERROR_KEY,
+    COLUMN_MAX_KEY,
+    COLUMN_MEAN_KEY,
+    COLUMN_MIN_KEY,
+    INTEGER_TYPE_COLLECTION,
+    get_decimal_token,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class NumericColumnCollector(ColumnCollectorBase):
+
+    """Class for collect an empty 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.
+        is_integer (boolean): a flag to indicate if values are integer or do not.
+
+    """
+
+    def __init__(
+        self, clm_name: str, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init NumericColumnCollector.
+
+        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.is_integer = self.type in INTEGER_TYPE_COLLECTION
+
+    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),
+            spark_sdt(spark_col(self.name)).alias(COLUMN_MARGIN_ERROR_KEY),
+        ).collect()[0]
+
+        min_value = select_result[COLUMN_MIN_KEY]
+        max_value = select_result[COLUMN_MAX_KEY]
+        mean_value = select_result[COLUMN_MEAN_KEY]
+        decimal_precision = self._compute_decimal_precision()
+        margin_error = select_result[COLUMN_MARGIN_ERROR_KEY]
+
+        custom_data_dict = {
+            COLUMN_MIN_KEY: min_value,
+            COLUMN_MAX_KEY: max_value,
+            COLUMN_MEAN_KEY: mean_value,
+            COLUMN_DECIMAL_PRECISION_KEY: decimal_precision,
+            COLUMN_MARGIN_ERROR_KEY: margin_error,
+        }
+
+        return custom_data_dict
+
+    def _compute_decimal_precision(self) -> int:
+        if self.is_integer:
+            return 0
+
+        decimal_part_index = 1
+        decimal_token = get_decimal_token()
+        max_decimal_digits_counted = 0
+
+        row_collection = self.column_df.dropna().collect()
+        for row in row_collection:
+            value = row[0]
+            value_str = str(value)
+            value_split_by_token = value_str.split(decimal_token)
+            decimal_part = value_split_by_token[decimal_part_index]
+            decimal_digits_counted = len(decimal_part)
+            max_decimal_digits_counted = max(
+                decimal_digits_counted, max_decimal_digits_counted
+            )
+
+        return max_decimal_digits_counted

snowflake/snowpark_checkpoints_collector/column_collection/model/string_column_collector.py

@@ -0,0 +1,70 @@
+# 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 length as spark_length
+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_LENGTH_KEY,
+    COLUMN_MIN_LENGTH_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class StringColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a string 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, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init StringColumnCollector.
+
+        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_length(spark_col(self.name))).alias(COLUMN_MIN_LENGTH_KEY),
+            spark_max(spark_length(spark_col(self.name))).alias(COLUMN_MAX_LENGTH_KEY),
+        ).collect()[0]
+
+        min_length = select_result[COLUMN_MIN_LENGTH_KEY]
+        max_length = select_result[COLUMN_MAX_LENGTH_KEY]
+
+        custom_data_dict = {
+            COLUMN_MIN_LENGTH_KEY: min_length,
+            COLUMN_MAX_LENGTH_KEY: max_length,
+        }
+
+        return custom_data_dict

snowflake/snowpark_checkpoints_collector/column_collection/model/struct_column_collector.py

@@ -0,0 +1,102 @@
+# 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_COUNT_KEY,
+    COLUMN_METADATA_KEY,
+    COLUMN_ROWS_NOT_NULL_COUNT_KEY,
+    COLUMN_ROWS_NULL_COUNT_KEY,
+    FIELD_METADATA_KEY,
+    FIELDS_KEY,
+    NAME_KEY,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model.column_collector_base import (
+    ColumnCollectorBase,
+)
+
+
+class StructColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a struct 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 StructColumnCollector.
+
+        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]:
+        metadata = self._compute_struct_metadata()
+
+        custom_data_dict = {
+            COLUMN_METADATA_KEY: metadata,
+        }
+
+        return custom_data_dict
+
+    def _compute_struct_metadata(self) -> list[dict[str, any]]:
+        field_metadata_collection = []
+        struct_field_json = self.struct_field.dataType.jsonValue()
+        for field in struct_field_json[FIELDS_KEY]:
+            del field[FIELD_METADATA_KEY]
+            clm_name = field[NAME_KEY]
+            rows_count_dict = self._compute_rows_count_by_column(clm_name)
+            struct_field_custom_data = dict(field | rows_count_dict)
+            field_metadata_collection.append(struct_field_custom_data)
+
+        return field_metadata_collection
+
+    def _compute_rows_count_by_column(self, clm_name: str) -> dict[str, int]:
+        rows_count = 0
+        rows_not_null_count = 0
+        rows_null_count = 0
+        row_collection = self.column_df.collect()
+        for row in row_collection:
+            inner_row = row[0]
+            rows_count += 1
+            if inner_row is None:
+                rows_null_count += 1
+                continue
+
+            row_clm_value = inner_row[clm_name]
+            if row_clm_value is None:
+                rows_null_count += 1
+            else:
+                rows_not_null_count += 1
+
+        rows_count_dict = {
+            COLUMN_COUNT_KEY: rows_count,
+            COLUMN_ROWS_NOT_NULL_COUNT_KEY: rows_not_null_count,
+            COLUMN_ROWS_NULL_COUNT_KEY: rows_null_count,
+        }
+
+        return rows_count_dict

snowflake/snowpark_checkpoints_collector/column_collection/model/timestamp_column_collector.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.
+
+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-%dT%H:%M:%S%z"
+
+
+class TimestampColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a timestamp 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, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init TimestampColumnCollector.
+
+        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/timestamp_ntz_column_collector.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.
+
+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-%dH:%M:%S"
+
+
+class TimestampNTZColumnCollector(ColumnCollectorBase):
+
+    """Class for collect a timestamp ntz 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, struct_field: StructField, clm_df: SparkDataFrame
+    ) -> None:
+        """Init TimestampNTZColumnCollector.
+
+        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