snowpark-checkpoints-collectors 0.2.0rc1__py3-none-any.whl → 0.3.0__py3-none-any.whl

snowflake/snowpark_checkpoints_collector/__init__.py

@@ -0,0 +1,30 @@
+# 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.
+
+import logging
+
+
+# Add a NullHandler to prevent logging messages from being output to
+# sys.stderr if no logging configuration is provided.
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+# ruff: noqa: E402
+
+__all__ = ["collect_dataframe_checkpoint", "CheckpointMode"]
+
+from snowflake.snowpark_checkpoints_collector.collection_common import CheckpointMode
+from snowflake.snowpark_checkpoints_collector.summary_stats_collector import (
+    collect_dataframe_checkpoint,
+)

snowflake/snowpark_checkpoints_collector/__version__.py

@@ -0,0 +1,16 @@
+# 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.
+
+__version__ = "0.3.0"

snowflake/snowpark_checkpoints_collector/collection_common.py

@@ -0,0 +1,160 @@
+# 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.
+
+import locale
+
+from enum import IntEnum
+
+
+class CheckpointMode(IntEnum):
+
+    """Enum class representing the collection mode."""
+
+    SCHEMA = 1
+    """Collect automatic schema inference"""
+    DATAFRAME = 2
+    """Export DataFrame as Parquet file to Snowflake"""
+
+
+# CONSTANTS
+ARRAY_COLUMN_TYPE = "array"
+BINARY_COLUMN_TYPE = "binary"
+BOOLEAN_COLUMN_TYPE = "boolean"
+BYTE_COLUMN_TYPE = "byte"
+DATE_COLUMN_TYPE = "date"
+DAYTIMEINTERVAL_COLUMN_TYPE = "daytimeinterval"
+DECIMAL_COLUMN_TYPE = "decimal"
+DOUBLE_COLUMN_TYPE = "double"
+FLOAT_COLUMN_TYPE = "float"
+INTEGER_COLUMN_TYPE = "integer"
+LONG_COLUMN_TYPE = "long"
+MAP_COLUMN_TYPE = "map"
+NULL_COLUMN_TYPE = "void"
+SHORT_COLUMN_TYPE = "short"
+STRING_COLUMN_TYPE = "string"
+STRUCT_COLUMN_TYPE = "struct"
+TIMESTAMP_COLUMN_TYPE = "timestamp"
+TIMESTAMP_NTZ_COLUMN_TYPE = "timestamp_ntz"
+
+PANDAS_BOOLEAN_DTYPE = "bool"
+PANDAS_DATETIME_DTYPE = "datetime64[ns]"
+PANDAS_FLOAT_DTYPE = "float64"
+PANDAS_INTEGER_DTYPE = "int64"
+PANDAS_OBJECT_DTYPE = "object"
+PANDAS_TIMEDELTA_DTYPE = "timedelta64[ns]"
+
+NUMERIC_TYPE_COLLECTION = [
+    BYTE_COLUMN_TYPE,
+    DOUBLE_COLUMN_TYPE,
+    FLOAT_COLUMN_TYPE,
+    INTEGER_COLUMN_TYPE,
+    LONG_COLUMN_TYPE,
+    SHORT_COLUMN_TYPE,
+]
+
+INTEGER_TYPE_COLLECTION = [
+    BYTE_COLUMN_TYPE,
+    INTEGER_COLUMN_TYPE,
+    LONG_COLUMN_TYPE,
+    SHORT_COLUMN_TYPE,
+]
+
+PANDAS_OBJECT_TYPE_COLLECTION = [
+    STRING_COLUMN_TYPE,
+    ARRAY_COLUMN_TYPE,
+    MAP_COLUMN_TYPE,
+    NULL_COLUMN_TYPE,
+    STRUCT_COLUMN_TYPE,
+]
+
+BETWEEN_CHECK_ERROR_MESSAGE_FORMAT = "Value must be between {} and {}"
+
+# SCHEMA CONTRACT KEYS CONSTANTS
+COLUMN_ALLOW_NULL_KEY = "allow_null"
+COLUMN_COUNT_KEY = "rows_count"
+COLUMN_DECIMAL_PRECISION_KEY = "decimal_precision"
+COLUMN_FALSE_COUNT_KEY = "false_count"
+COLUMN_FORMAT_KEY = "format"
+COLUMN_IS_NULLABLE_KEY = "nullable"
+COLUMN_IS_UNIQUE_SIZE_KEY = "is_unique_size"
+COLUMN_KEY_TYPE_KEY = "key_type"
+COLUMN_MARGIN_ERROR_KEY = "margin_error"
+COLUMN_MAX_KEY = "max"
+COLUMN_MAX_LENGTH_KEY = "max_length"
+COLUMN_MAX_SIZE_KEY = "max_size"
+COLUMN_MEAN_KEY = "mean"
+COLUMN_MEAN_SIZE_KEY = "mean_size"
+COLUMN_METADATA_KEY = "metadata"
+COLUMN_MIN_KEY = "min"
+COLUMN_MIN_LENGTH_KEY = "min_length"
+COLUMN_MIN_SIZE_KEY = "min_size"
+COLUMN_NAME_KEY = "name"
+COLUMN_NULL_COUNT_KEY = "null_count"
+COLUMN_NULL_VALUE_PROPORTION_KEY = "null_value_proportion"
+COLUMN_ROWS_NOT_NULL_COUNT_KEY = "rows_not_null_count"
+COLUMN_ROWS_NULL_COUNT_KEY = "rows_null_count"
+COLUMN_SIZE_KEY = "size"
+COLUMN_TRUE_COUNT_KEY = "true_count"
+COLUMN_TYPE_KEY = "type"
+COLUMN_VALUE_KEY = "value"
+COLUMN_VALUE_TYPE_KEY = "value_type"
+COLUMNS_KEY = "columns"
+
+DATAFRAME_CUSTOM_DATA_KEY = "custom_data"
+DATAFRAME_PANDERA_SCHEMA_KEY = "pandera_schema"
+
+PANDERA_COLUMN_TYPE_KEY = "dtype"
+
+CONTAINS_NULL_KEY = "containsNull"
+ELEMENT_TYPE_KEY = "elementType"
+FIELD_METADATA_KEY = "metadata"
+FIELDS_KEY = "fields"
+KEY_TYPE_KEY = "keyType"
+NAME_KEY = "name"
+VALUE_CONTAINS_NULL_KEY = "valueContainsNull"
+VALUE_TYPE_KEY = "valueType"
+
+# DIRECTORY AND FILE NAME CONSTANTS
+SNOWPARK_CHECKPOINTS_OUTPUT_DIRECTORY_NAME = "snowpark-checkpoints-output"
+CHECKPOINT_JSON_OUTPUT_FILE_NAME_FORMAT = "{}.json"
+CHECKPOINT_PARQUET_OUTPUT_FILE_NAME_FORMAT = "{}.parquet"
+COLLECTION_RESULT_FILE_NAME = "checkpoint_collection_results.json"
+
+# MISC KEYS
+DECIMAL_TOKEN_KEY = "decimal_point"
+DOT_PARQUET_EXTENSION = ".parquet"
+DOT_IPYNB_EXTENSION = ".ipynb"
+UNKNOWN_SOURCE_FILE = "unknown"
+UNKNOWN_LINE_OF_CODE = -1
+BACKSLASH_TOKEN = "\\"
+SLASH_TOKEN = "/"
+PYSPARK_NONE_SIZE_VALUE = -1
+PANDAS_LONG_TYPE = "Int64"
+
+# ENVIRONMENT VARIABLES
+SNOWFLAKE_CHECKPOINT_CONTRACT_FILE_PATH_ENV_VAR = (
+    "SNOWFLAKE_CHECKPOINT_CONTRACT_FILE_PATH"
+)
+
+
+def get_decimal_token() -> str:
+    """Return the decimal token based on the local environment.
+
+    Returns:
+        str: The decimal token.
+
+    """
+    decimal_token = locale.localeconv()[DECIMAL_TOKEN_KEY]
+    return decimal_token

snowflake/snowpark_checkpoints_collector/collection_result/model/__init__.py

@@ -0,0 +1,24 @@
+# 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__ = ["CollectionPointResult", "CollectionResult", "CollectionPointResultManager"]
+
+from snowflake.snowpark_checkpoints_collector.collection_result.model.collection_point_result import (
+    CollectionPointResult,
+    CollectionResult,
+)
+from snowflake.snowpark_checkpoints_collector.collection_result.model.collection_point_result_manager import (
+    CollectionPointResultManager,
+)

snowflake/snowpark_checkpoints_collector/collection_result/model/collection_point_result.py

@@ -0,0 +1,91 @@
+# 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 datetime import datetime
+from enum import Enum
+
+from snowflake.snowpark_checkpoints_collector.utils import file_utils
+
+
+TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+TIMESTAMP_KEY = "timestamp"
+FILE_KEY = "file"
+RESULT_KEY = "result"
+LINE_OF_CODE_KEY = "line_of_code"
+CHECKPOINT_NAME_KEY = "checkpoint_name"
+
+
+class CollectionResult(Enum):
+    FAIL = "FAIL"
+    PASS = "PASS"
+
+
+class CollectionPointResult:
+
+    """Class for checkpoint collection results.
+
+    Attributes:
+        _timestamp (timestamp): the timestamp when collection started.
+        _file_path (str): the full path where checkpoint is.
+        _line_of_code (int): the line of code where the checkpoint is.
+        _checkpoint_name (str): the checkpoint name.
+        _result (CollectionResult): the result status of the checkpoint collection point.
+
+    """
+
+    def __init__(
+        self,
+        file_path: str,
+        line_of_code: int,
+        checkpoint_name: str,
+    ) -> None:
+        """Init CollectionPointResult.
+
+        Args:
+            file_path (str): the full path where checkpoint is.
+            line_of_code (int): the line of code where the checkpoint is.
+            checkpoint_name (str): the checkpoint name.
+
+        """
+        self._timestamp = datetime.now()
+        self._file_path = file_path
+        self._line_of_code = line_of_code
+        self._checkpoint_name = checkpoint_name
+        self._result = None
+
+    @property
+    def result(self):
+        """Get the result status of the checkpoint collection point."""
+        return self._result
+
+    @result.setter
+    def result(self, value):
+        """Set the result status of the checkpoint collection point."""
+        self._result = value
+
+    def get_collection_result_data(self) -> dict[str, any]:
+        """Get the results of the checkpoint collection point."""
+        timestamp_with_format = self._timestamp.strftime(TIMESTAMP_FORMAT)
+        relative_path = file_utils.get_relative_file_path(self._file_path)
+
+        collection_point_result = {
+            TIMESTAMP_KEY: timestamp_with_format,
+            FILE_KEY: relative_path,
+            LINE_OF_CODE_KEY: self._line_of_code,
+            CHECKPOINT_NAME_KEY: self._checkpoint_name,
+            RESULT_KEY: self.result.value,
+        }
+
+        return collection_point_result

snowflake/snowpark_checkpoints_collector/collection_result/model/collection_point_result_manager.py

@@ -0,0 +1,76 @@
+# 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.
+
+import json
+import logging
+
+from typing import Optional
+
+from snowflake.snowpark_checkpoints_collector.collection_result.model import (
+    CollectionPointResult,
+)
+from snowflake.snowpark_checkpoints_collector.io_utils.io_file_manager import (
+    get_io_file_manager,
+)
+from snowflake.snowpark_checkpoints_collector.singleton import Singleton
+from snowflake.snowpark_checkpoints_collector.utils import file_utils
+
+
+RESULTS_KEY = "results"
+LOGGER = logging.getLogger(__name__)
+
+
+class CollectionPointResultManager(metaclass=Singleton):
+
+    """Class for manage the checkpoint collection results. It is a singleton.
+
+    Attributes:
+        result_collection (list[any]): the collection of the checkpoint results.
+        output_file_path (str): the full path of the output file.
+
+    """
+
+    def __init__(self, output_path: Optional[str] = None) -> None:
+        """Init CollectionPointResultManager."""
+        self.result_collection: list[any] = []
+        self.output_file_path = file_utils.get_output_file_path(output_path)
+
+    def add_result(self, result: CollectionPointResult) -> None:
+        """Add the CollectionPointResult result to the collection.
+
+        Args:
+            result (CollectionPointResult): the CollectionPointResult to add.
+
+        """
+        result_json = result.get_collection_result_data()
+        LOGGER.debug("Adding a new collection result: %s", result_json)
+        self.result_collection.append(result_json)
+        self._save_result()
+
+    def to_json(self) -> str:
+        """Convert to json the checkpoint results collected.
+
+        Returns:
+            str: the results as json string.
+
+        """
+        dict_object = {RESULTS_KEY: self.result_collection}
+        result_collection_json = json.dumps(dict_object)
+        return result_collection_json
+
+    def _save_result(self) -> None:
+        result_collection_json = self.to_json()
+        LOGGER.info("Saving collection results to '%s'", self.output_file_path)
+        get_io_file_manager().write(self.output_file_path, result_collection_json)

snowflake/snowpark_checkpoints_collector/column_collection/__init__.py

@@ -0,0 +1,22 @@
+# 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__ = [
+    "ColumnCollectorManager",
+]
+
+from snowflake.snowpark_checkpoints_collector.column_collection.column_collector_manager import (
+    ColumnCollectorManager,
+)

snowflake/snowpark_checkpoints_collector/column_collection/column_collector_manager.py

@@ -0,0 +1,276 @@
+# 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.
+
+import logging
+
+from pyspark.sql import DataFrame as SparkDataFrame
+from pyspark.sql.types import StructField
+
+from snowflake.snowpark_checkpoints_collector.collection_common import (
+    ARRAY_COLUMN_TYPE,
+    BINARY_COLUMN_TYPE,
+    BOOLEAN_COLUMN_TYPE,
+    BYTE_COLUMN_TYPE,
+    DATE_COLUMN_TYPE,
+    DAYTIMEINTERVAL_COLUMN_TYPE,
+    DECIMAL_COLUMN_TYPE,
+    DOUBLE_COLUMN_TYPE,
+    FLOAT_COLUMN_TYPE,
+    INTEGER_COLUMN_TYPE,
+    LONG_COLUMN_TYPE,
+    MAP_COLUMN_TYPE,
+    NULL_COLUMN_TYPE,
+    SHORT_COLUMN_TYPE,
+    STRING_COLUMN_TYPE,
+    STRUCT_COLUMN_TYPE,
+    TIMESTAMP_COLUMN_TYPE,
+    TIMESTAMP_NTZ_COLUMN_TYPE,
+)
+from snowflake.snowpark_checkpoints_collector.column_collection.model import (
+    ArrayColumnCollector,
+    BinaryColumnCollector,
+    BooleanColumnCollector,
+    DateColumnCollector,
+    DayTimeIntervalColumnCollector,
+    DecimalColumnCollector,
+    EmptyColumnCollector,
+    MapColumnCollector,
+    NullColumnCollector,
+    NumericColumnCollector,
+    StringColumnCollector,
+    StructColumnCollector,
+    TimestampColumnCollector,
+    TimestampNTZColumnCollector,
+)
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+def collector_register(cls):
+    """Decorate a class with the collection type mechanism.
+
+    Args:
+        cls: The class to decorate.
+
+    Returns:
+        The class to decorate.
+
+    """
+    LOGGER.debug("Starting to register collectors from class %s", cls.__name__)
+    cls._collectors = {}
+    for method_name in dir(cls):
+        method = getattr(cls, method_name)
+        if hasattr(method, "_column_type"):
+            col_type_collection = method._column_type
+            for col_type in col_type_collection:
+                cls._collectors[col_type] = method_name
+                LOGGER.debug(
+                    "Registered collector '%s' for column type '%s'",
+                    method_name,
+                    col_type,
+                )
+    return cls
+
+
+def column_register(*args):
+    """Decorate a method to register it in the collection mechanism based on column type.
+
+    Args:
+        args: the column type to register.
+
+    Returns:
+        The wrapper.
+
+    """
+
+    def wrapper(func):
+        has_arguments = len(args) > 0
+        if has_arguments:
+            func._column_type = args
+        return func
+
+    return wrapper
+
+
+@collector_register
+class ColumnCollectorManager:
+
+    """Manage class for column collector based on type."""
+
+    def collect_column(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        """Collect the data of the column based on the column type.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            values (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        Returns:
+            dict[str, any]: The data collected.
+
+        """
+        clm_type = struct_field.dataType.typeName()
+        if clm_type not in self._collectors:
+            LOGGER.debug(
+                "No collectors found for column '%s' of type '%s'. Skipping collection for this column.",
+                clm_name,
+                clm_type,
+            )
+            return {}
+
+        func_name = self._collectors[clm_type]
+        func = getattr(self, func_name)
+        LOGGER.debug(
+            "Collecting custom data for column '%s' of type '%s' using collector method '%s'",
+            clm_name,
+            clm_type,
+            func_name,
+        )
+        data = func(clm_name, struct_field, values)
+        return data
+
+    @column_register(ARRAY_COLUMN_TYPE)
+    def _collect_array_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = ArrayColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(BINARY_COLUMN_TYPE)
+    def _collect_binary_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = BinaryColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(BOOLEAN_COLUMN_TYPE)
+    def _collect_boolean_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = BooleanColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(DATE_COLUMN_TYPE)
+    def _collect_date_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = DateColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(DAYTIMEINTERVAL_COLUMN_TYPE)
+    def _collect_day_time_interval_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = DayTimeIntervalColumnCollector(
+            clm_name, struct_field, values
+        )
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(DECIMAL_COLUMN_TYPE)
+    def _collect_decimal_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = DecimalColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(MAP_COLUMN_TYPE)
+    def _collect_map_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = MapColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(NULL_COLUMN_TYPE)
+    def _collect_null_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = NullColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(
+        BYTE_COLUMN_TYPE,
+        SHORT_COLUMN_TYPE,
+        INTEGER_COLUMN_TYPE,
+        LONG_COLUMN_TYPE,
+        FLOAT_COLUMN_TYPE,
+        DOUBLE_COLUMN_TYPE,
+    )
+    def _collect_numeric_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = NumericColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(STRING_COLUMN_TYPE)
+    def _collect_string_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = StringColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(STRUCT_COLUMN_TYPE)
+    def _collect_struct_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = StructColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(TIMESTAMP_COLUMN_TYPE)
+    def _collect_timestamp_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = TimestampColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    @column_register(TIMESTAMP_NTZ_COLUMN_TYPE)
+    def _collect_timestampntz_type_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        column_collector = TimestampNTZColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data
+
+    def collect_empty_custom_data(
+        self, clm_name: str, struct_field: StructField, values: SparkDataFrame
+    ) -> dict[str, any]:
+        """Collect the data of a empty column.
+
+        Args:
+            clm_name (str): the name of the column.
+            struct_field (pyspark.sql.types.StructField): the struct field of the column type.
+            values (pyspark.sql.DataFrame): the column values as PySpark DataFrame.
+
+        Returns:
+            dict[str, any]: The data collected.
+
+        """
+        column_collector = EmptyColumnCollector(clm_name, struct_field, values)
+        collected_data = column_collector.get_data()
+        return collected_data