ormlambda 3.35.2__py3-none-any.whl → 4.0.0__py3-none-any.whl

ormlambda/sql/column/column_proxy.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, overload
+
+
+from ormlambda.sql.column_table_proxy import ColumnTableProxy
+from .column import Column
+from ormlambda import ConditionType, JoinType
+from ormlambda.sql.elements import ClauseElement
+from ormlambda import util
+
+if TYPE_CHECKING:
+    from ormlambda.sql.types import ColumnType, ComparerType
+    from ormlambda.sql.elements import Dialect
+    from ormlambda.sql.context import FKChain
+    from ormlambda.sql.comparer import Comparer
+    from ormlambda.sql.clauses import JoinSelector
+
+
+class ColumnProxy[TProp](ColumnTableProxy, Column[TProp], ClauseElement):
+    __visit_name__ = "column_proxy"
+    _column: Column
+    _path: FKChain
+    alias: Optional[str]
+
+    @overload
+    def __init__(self, column: Column[TProp], path: FKChain): ...
+    @overload
+    def __init__(self, column: Column[TProp], path: FKChain, alias: str): ...
+
+    def __init__(self, column, path, alias=None):
+        self._column = column
+        self.alias = alias
+        super().__init__(path)
+
+    def __str__(self) -> str:
+        return self.get_full_chain()
+
+    def __repr__(self) -> str:
+        table = self._column.table
+        table = table.__table_name__ if table else None
+
+        col = f"{table}.{self._column.column_name}"
+        path = self._path.get_path_key()
+
+        return f"{ColumnProxy.__name__}({col if table else self._column.column_name}) {f'Path={path}' if path else ""}"
+
+    def __getattr__(self, name: str):
+        # it does not work when comparing methods
+        return getattr(self._column, name)
+
+    @util.preload_module("ormlambda.sql.comparer")
+    def __comparer_creator(self, other: ColumnType, compare: ComparerType) -> Comparer:
+        Comparer = util.preloaded.sql_comparer.Comparer
+
+        return Comparer(self, other, compare)
+
+    def __eq__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.EQUAL.value)
+
+    def __ne__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.NOT_EQUAL.value)
+
+    def __lt__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.LESS_THAN.value)
+
+    def __le__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.LESS_THAN_OR_EQUAL.value)
+
+    def __gt__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.GREATER_THAN.value)
+
+    def __ge__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.GREATER_THAN_OR_EQUAL.value)
+
+    def get_full_chain(self, chr: str = "."):
+        alias: list[str] = [self._path.base.__table_name__]
+
+        n = self.number_table_in_chain()
+
+        for i in range(n):
+            fk = self._path.steps[i]
+
+            value = fk.clause_name
+            alias.append(value)
+
+        # Column name
+        alias.append(self._column.column_name)
+        return chr.join(alias)
+
+    def get_table_chain(self) -> str:
+        return self._path.get_alias()
+
+    def number_table_in_chain(self) -> int:
+        return len(self._path.steps)
+
+    @util.preload_module("ormlambda.sql.clauses")
+    def get_relations(self, by: JoinType, dialect: Dialect) -> tuple[JoinSelector]:
+        JoinSelector = util.preloaded.sql_clauses.JoinSelector
+
+        result: list[JoinSelector] = []
+        alias = self._path.base.__table_name__
+
+        for i in range(self.number_table_in_chain()):
+            tbl = self._path.steps[i]
+            relation = tbl.resolved_function()
+
+            relation.left_condition.alias = alias
+            relation.left_condition.path = self._path[:i]
+
+            alias += f"_{tbl.clause_name}"
+
+            relation.right_condition.alias = alias
+            relation.right_condition.path = self._path[: i + 1]
+
+            js = JoinSelector(relation, by, alias, dialect=dialect)
+            result.append(js)
+        return result

ormlambda/sql/column_table_proxy.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+import abc
+
+from ormlambda.sql.context import FKChain
+
+
+class ColumnTableProxy(abc.ABC):
+    _path: FKChain
+
+    def __init__(self, path: FKChain):
+        self._path = path
+
+    @property
+    def path(self) -> FKChain:
+        return self._path
+
+    @path.setter
+    def path(self, value: FKChain) -> None:
+        self._path = value
+        return None
+
+    @abc.abstractmethod
+    def get_table_chain(self): ...

ormlambda/sql/comparer.py

@@ -2,17 +2,16 @@ from __future__ import annotations
 import abc
 import re
 import typing as tp
-from ormlambda.common.interfaces.IQueryCommand import IQuery
 
 
-from ormlambda.sql.types import ConditionType, ComparerTypes
-from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.types import ConditionType
+from ormlambda.sql.types import ComparerTypes
+
+from ormlambda.sql.clause_info import IAggregate
 from ormlambda import ConditionType as ConditionEnum
-from ormlambda.sql.elements import Element
+from ormlambda.sql.elements import ClauseElement
 
-if tp.TYPE_CHECKING:
-    from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-    from ormlambda.dialects import Dialect
+from ormlambda import ColumnProxy
 
 
 class ICleaner(abc.ABC):
@@ -46,7 +45,7 @@ class CleanValue:
         return temp_name
 
 
-class Comparer(Element, IQuery):
+class Comparer(ClauseElement, IAggregate):
     __visit_name__ = "comparer"
 
     def __init__(
@@ -54,64 +53,23 @@ class Comparer(Element, IQuery):
         left_condition: ConditionType,
         right_condition: ConditionType,
         compare: ComparerTypes,
-        context: ClauseContextType = None,
         flags: tp.Optional[tp.Iterable[re.RegexFlag]] = None,
-        dialect: tp.Optional[Dialect] = None,
     ) -> None:
-        self._context: ClauseContextType = context
         self._compare: ComparerTypes = compare
-        self._left_condition: Comparer | ClauseInfo = left_condition
-        self._right_condition: Comparer | ClauseInfo = right_condition
+        self.left_condition: ConditionType = left_condition
+        self.right_condition: ConditionType = right_condition
         self._flags = flags
-        self._dialect = dialect
-
-    def set_context(self, context: ClauseContextType) -> None:
-        self._context = context
-        return None
 
-    def set_dialect(self, dialect: Dialect) -> None:
-        self._dialect = dialect
-        return None
+    @property
+    def dtype(self) -> tp.Any: ...
 
     def __repr__(self) -> str:
-        return f"{Comparer.__name__}: {self.query}"
-
-    def _create_clause_info(self, cond: ConditionType, dialect: Dialect, **kw) -> Comparer | ClauseInfo:
-        from ormlambda import Column
-
-        if isinstance(cond, Comparer):
-            return cond
-        table = None if not isinstance(cond, Column) else cond.table
-
-        # it a value that's not depend of any Table
-        return ClauseInfo(
-            table,
-            cond,
-            alias_clause=None,
-            context=self._context,
-            dialect=dialect,
-            **kw,
-        )
-
-    def left_condition(self, dialect: Dialect) -> Comparer | ClauseInfo:
-        return self._create_clause_info(self._left_condition, dialect=dialect)
-
-    def right_condition(self, dialect: Dialect) -> Comparer | ClauseInfo:
-        return self._create_clause_info(self._right_condition, dialect=dialect)
+        return f"{Comparer.__name__}: {self.left_condition} {self._compare} {self.right_condition}"
 
     @property
     def compare(self) -> ComparerTypes:
         return self._compare
 
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        lcond = self.left_condition(dialect).query(dialect, **kwargs)
-        rcond = self.right_condition(dialect).query(dialect, **kwargs)
-
-        if self._flags:
-            rcond = CleanValue(rcond, self._flags).clean()
-
-        return f"{lcond} {self._compare} {rcond}"
-
     def __and__(self, other: Comparer, **kwargs) -> Comparer:
         # Customize the behavior of '&'
         return Comparer(self, other, "AND", **kwargs)
@@ -121,13 +79,13 @@ class Comparer(Element, IQuery):
         return Comparer(self, other, "OR", **kwargs)
 
     @classmethod
-    def join_comparers(cls, comparers: list[Comparer], restrictive: bool = True, context: ClauseContextType = None, *, dialect) -> str:
+    def join_comparers(cls, comparers: list[Comparer], restrictive: bool = True, *, dialect, **kwargs) -> str:
         if not isinstance(comparers, tp.Iterable):
             raise ValueError(f"Excepted '{Comparer.__name__}' iterable not {type(comparers).__name__}")
+
         if len(comparers) == 1:
             comparer = comparers[0]
-            comparer._context = context
-            return comparer.query(dialect)
+            return comparer.compile(dialect, alias_clause=None, **kwargs).string
 
         join_method = cls.__or__ if not restrictive else cls.__and__
 
@@ -135,12 +93,23 @@ class Comparer(Element, IQuery):
         for i in range(len(comparers) - 1):
             if ini_comparer is None:
                 ini_comparer = comparers[i]
-                ini_comparer._context = context
             right_comparer = comparers[i + 1]
-            right_comparer._context = context
-            new_comparer = join_method(ini_comparer, right_comparer, context=context, dialect=dialect)
+            new_comparer = join_method(ini_comparer, right_comparer)
             ini_comparer = new_comparer
-        return new_comparer.query(dialect)
+
+        res = new_comparer.compile(dialect, alias_clause=None, **kwargs)
+        return res.string
+
+    def used_columns(self) -> tp.Iterable[ColumnProxy]:
+        res = []
+
+        if isinstance(self.left_condition, ColumnProxy):
+            res.append(self.left_condition)
+
+        if isinstance(self.right_condition, ColumnProxy):
+            res.append(self.right_condition)
+
+        return res
 
 
 class Regex(Comparer):
@@ -148,14 +117,12 @@ class Regex(Comparer):
         self,
         left_condition: ConditionType,
         right_condition: ConditionType,
-        context: ClauseContextType = None,
         flags: tp.Optional[tp.Iterable[re.RegexFlag]] = None,
     ):
         super().__init__(
             left_condition=left_condition,
             right_condition=right_condition,
             compare=ConditionEnum.REGEXP.value,
-            context=context,
             flags=flags,  # Pass as a named parameter instead
         )
 
@@ -165,6 +132,5 @@ class Like(Comparer):
         self,
         left_condition: ConditionType,
         right_condition: ConditionType,
-        context: ClauseContextType = None,
     ):
-        super().__init__(left_condition, right_condition, ConditionEnum.LIKE.value, context)
+        super().__init__(left_condition, right_condition, ConditionEnum.LIKE.value)

ormlambda/sql/compiler.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
-import abc
-from typing import Any, ClassVar, Optional, TYPE_CHECKING
+import datetime
+import io
+import logging
+import os
+from pathlib import Path
+import subprocess
+import sys
+from typing import Any, BinaryIO, ClassVar, Optional, TYPE_CHECKING, TextIO, Union
 
 from ormlambda.sql.ddl import CreateColumn
-from ormlambda.sql.foreign_key import ForeignKey
 from ormlambda.sql.sqltypes import resolve_primitive_types
 
 from .visitors import Visitor
-from ormlambda import util
 from ormlambda.sql.type_api import TypeEngine
 
 if TYPE_CHECKING:
@@ -15,7 +19,13 @@ if TYPE_CHECKING:
     from .visitors import Element
     from .elements import ClauseElement
     from ormlambda.dialects import Dialect
-    from ormlambda.sql.ddl import CreateTable, CreateSchema, DropSchema
+    from ormlambda.sql.ddl import (
+        CreateTable,
+        CreateSchema,
+        DropSchema,
+        DropTable,
+        CreateBackup,
+    )
     from .sqltypes import (
         INTEGER,
         SMALLINTEGER,
@@ -43,23 +53,10 @@ if TYPE_CHECKING:
         POINT,
     )
 
-    from ormlambda.sql.clauses import (
-        Insert,
-        Delete,
-        Upsert,
-        Update,
-        Limit,
-        Offset,
-        Count,
-        Where,
-        Having,
-        Order,
-        Concat,
-        Max,
-        Min,
-        Sum,
-        Groupby,
-    )
+type customString = Union[str | Path]
+
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+log = logging.getLogger(__name__)
 
 
 class Compiled:
@@ -141,40 +138,9 @@ class TypeCompiler(Visitor):
         return type_._compiler_dispatch(self, **kw)
 
 
-class SQLCompiler(Compiled, abc.ABC):
+class SQLCompiler(Compiled):
     is_sql = True
 
-    @abc.abstractmethod
-    def visit_insert(self, insert: Insert, **kw) -> Insert: ...
-    @abc.abstractmethod
-    def visit_delete(self, delete: Delete, **kw) -> Delete: ...
-    @abc.abstractmethod
-    def visit_upsert(self, upsert: Upsert, **kw) -> Upsert: ...
-    @abc.abstractmethod
-    def visit_update(self, update: Update, **kw) -> Update: ...
-    @abc.abstractmethod
-    def visit_limit(self, limit: Limit, **kw) -> Limit: ...
-    @abc.abstractmethod
-    def visit_offset(self, offset: Offset, **kw) -> Offset: ...
-    @abc.abstractmethod
-    def visit_count(self, count: Count, **kw) -> Count: ...
-    @abc.abstractmethod
-    def visit_where(self, where: Where, **kw) -> Where: ...
-    @abc.abstractmethod
-    def visit_having(self, having: Having, **kw) -> Having: ...
-    @abc.abstractmethod
-    def visit_order(self, order: Order, **kw) -> Order: ...
-    @abc.abstractmethod
-    def visit_concat(self, concat: Concat, **kw) -> Concat: ...
-    @abc.abstractmethod
-    def visit_max(self, max: Max, **kw) -> Max: ...
-    @abc.abstractmethod
-    def visit_min(self, min: Min, **kw) -> Min: ...
-    @abc.abstractmethod
-    def visit_sum(self, sum: Sum, **kw) -> Sum: ...
-    @abc.abstractmethod
-    def visit_group_by(self, groupby: Groupby, **kw) -> Groupby: ...
-
 
 class DDLCompiler(Compiled):
     is_ddl = True
@@ -214,8 +180,6 @@ class DDLCompiler(Compiled):
         """
         schema_name = create.schema
 
-        util.avoid_sql_injection(schema_name)
-
         if_not_exists_clause = "IF NOT EXISTS " if create.if_not_exists else ""
         return f"CREATE SCHEMA {if_not_exists_clause}{schema_name};"
 
@@ -239,16 +203,23 @@ class DDLCompiler(Compiled):
             except Exception:
                 raise
 
-        foreign_keys = ForeignKey.create_query(tablecls, self.dialect)
+        foreign_keys = create.element.foreign_keys()
+
+        foreign_keys_string = []
+        for fk in foreign_keys.values():
+            foreign_keys_string.append(fk.compile(self.dialect, orig_table=tablecls).string)
         table_options = " ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci"
 
         sql = f"CREATE TABLE {tablecls.__table_name__} (\n\t"
         sql += ",\n\t".join(column_sql)
         sql += "\n\t" if not foreign_keys else ",\n\t"
-        sql += ",\n\t".join(foreign_keys)
+        sql += ",\n\t".join(foreign_keys_string)
         sql += f"\n){table_options};"
         return sql
 
+    def visit_drop_table(self, drop: DropTable, **kw) -> str:
+        return "DROP TABLE " + drop.element.__table_name__
+
     def visit_create_column(self, create: CreateColumn, first_pk=False, **kw):  # noqa: F821
         column = create.element
         return self.get_column_specification(column)
@@ -273,6 +244,225 @@ class DDLCompiler(Compiled):
             return None
         return None
 
+    # TODOH []: refactor in order to improve clarity
+    def visit_create_backup(
+        self,
+        backup: CreateBackup,
+        output: Optional[Union[Path | str, BinaryIO, TextIO]] = None,
+        compress: bool = False,
+        backup_dir: customString = ".",
+        **kw,
+    ) -> Optional[str | BinaryIO | Path]:
+        """
+        Create MySQL backup with flexible output options
+
+        Args:
+            backup: An object containing database connection details (host, user, password, database, port).
+            output: Output destination:
+                - None: Auto-generate file path
+                - str: Custom file path (treated as a path-like object)
+                - Stream object: Write to stream (io.StringIO, io.BytesIO, sys.stdout, etc.)
+            compress: Whether to compress the output using gzip.
+            backup_dir: Directory for auto-generated files if 'output' is None.
+
+        Returns:
+            - File path (str) if output to file.
+            - Backup data as bytes (if output to binary stream) or string (if output to text stream).
+            - None if an error occurs.
+        """
+
+        host = backup.url.host
+        user = backup.url.username
+        password = backup.url.password
+        database = backup.url.database
+        port = backup.url.port
+
+        if not database:
+            log.error("Error: Database name is required for backup.")
+            return None
+
+        # Build mysqldump command
+        command = [
+            "mysqldump",
+            f"--host={host}",
+            f"--port={port}",
+            f"--user={user}",
+            f"--password={password}",
+            "--single-transaction",
+            "--routines",
+            "--triggers",
+            "--events",
+            "--lock-tables=false",  # Often used to avoid locking during backup
+            "--add-drop-table",
+            "--extended-insert",
+            database,
+        ]
+
+        def export_to_stream_internal() -> Optional[io.BytesIO]:
+            nonlocal command, compress, database
+            # If streaming, execute mysqldump and capture stdout
+            log.info(f"Backing up database '{database}' to BytesIO...")
+
+            try:
+                if compress:
+                    # Start mysqldump process
+                    mysqldump_process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+                    # Start gzip process, taking input from mysqldump
+                    gzip_process = subprocess.Popen(["gzip", "-c"], stdin=mysqldump_process.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+                    # Close mysqldump stdout in parent process - gzip will handle it
+                    mysqldump_process.stdout.close()
+
+                    # Wait for gzip to complete (which will also wait for mysqldump)
+                    gzip_stdout, gzip_stderr = gzip_process.communicate()
+
+                    # Wait for mysqldump to finish and get its stderr
+                    mysqldump_stderr = mysqldump_process.communicate()[1]
+
+                    if mysqldump_process.returncode != 0:
+                        log.error(f"mysqldump error: {mysqldump_stderr.decode().strip()}")
+                        return None
+                    if gzip_process.returncode != 0:
+                        log.error(f"gzip error: {gzip_stderr.decode().strip()}")
+                        return None
+
+                    log.info("Backup successful and compressed to BytesIO.")
+                    return io.BytesIO(gzip_stdout)
+                else:
+                    # Directly capture mysqldump output
+                    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                    stdout, stderr = process.communicate()
+
+                    if process.returncode != 0:
+                        log.error(f"mysqldump error: {stderr.decode().strip()}")
+                        return None
+
+                    log.info("Backup successful to BytesIO.")
+                    return io.BytesIO(stdout)
+
+            except FileNotFoundError as e:
+                log.error(f"Error: '{e.filename}' command not found. Please ensure mysqldump (and gzip if compressing) is installed and in your system's PATH.")
+                return None
+            except Exception as e:
+                log.error(f"An unexpected error occurred during streaming backup: {e}")
+                return None
+
+        def export_to_file_internal(file_path: customString) -> Optional[Path]:
+            nonlocal command, compress, database
+
+            if isinstance(file_path, str):
+                file_path = Path(file_path)
+
+            if not file_path.exists():
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                file_path.touch()
+
+            try:
+                if compress:
+                    # Pipe mysqldump output through gzip to file
+                    with open(file_path, "wb") as output_file:
+                        # Start mysqldump process
+                        mysqldump_process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+                        # Start gzip process, taking input from mysqldump and writing to file
+                        gzip_process = subprocess.Popen(["gzip", "-c"], stdin=mysqldump_process.stdout, stdout=output_file, stderr=subprocess.PIPE)
+
+                        # Close mysqldump stdout in parent process - gzip will handle it
+                        mysqldump_process.stdout.close()
+
+                        # Wait for gzip to complete (which will also wait for mysqldump)
+                        gzip_stdout, gzip_stderr = gzip_process.communicate()
+
+                        # Wait for mysqldump to finish and get its stderr
+                        mysqldump_stderr = mysqldump_process.communicate()[1]
+
+                        if mysqldump_process.returncode != 0:
+                            log.error(f"mysqldump error: {mysqldump_stderr.decode().strip()}")
+                            return None
+                        if gzip_process.returncode != 0:
+                            log.error(f"gzip error: {gzip_stderr.decode().strip()}")
+                            return None
+                else:
+                    # Directly redirect mysqldump output to file
+                    with open(file_path, "wb") as output_file:
+                        process = subprocess.Popen(command, stdout=output_file, stderr=subprocess.PIPE)
+                        stdout, stderr = process.communicate()
+
+                        if process.returncode != 0:
+                            log.error(f"mysqldump error: {stderr.decode().strip()}")
+                            return None
+
+                log.info(f"Backup completed successfully: {file_path}")
+                return file_path
+
+            except FileNotFoundError as e:
+                log.error(f"Error: '{e.filename}' command not found. Please ensure mysqldump (and gzip if compressing) is installed and in your system's PATH.")
+                return None
+            except Exception as e:
+                log.error(f"An unexpected error occurred during file backup: {e}")
+                return None
+
+        try:
+            if output is None:
+                # Auto-generate file path
+
+                backup_dir = Path(backup_dir)
+                backup_dir.mkdir(exist_ok=True)
+
+                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                file_extension = "sql.gz" if compress else "sql"
+                output_filename = f"{database}_backup_{timestamp}.{file_extension}"
+                output_filepath = os.path.join(backup_dir, output_filename)
+                return export_to_file_internal(output_filepath)
+
+            elif isinstance(output, (io.BytesIO, io.StringIO)):
+                # Output to a stream object
+                stream_result = export_to_stream_internal()
+                if stream_result:
+                    # Write the content from the internal BytesIO to the provided output stream
+                    if isinstance(output, io.BytesIO):
+                        output.write(stream_result.getvalue())
+                        return stream_result.getvalue()  # Return bytes if it was a BytesIO internally
+                    elif isinstance(output, io.StringIO):
+                        # Attempt to decode bytes to string if target is StringIO
+                        try:
+                            decoded_content = stream_result.getvalue().decode("utf-8")
+                            output.write(decoded_content)
+                            return decoded_content
+                        except UnicodeDecodeError:
+                            log.error("Error: Cannot decode byte stream to UTF-8 for StringIO output. Consider setting compress=False or ensuring database encoding is compatible.")
+                            return None
+                return None
+
+            elif isinstance(output, str | Path):
+                # Output to a custom file path
+                return export_to_file_internal(output)
+
+            elif isinstance(output, (BinaryIO, TextIO)):  # Handles sys.stdout, open file objects
+                stream_result = export_to_stream_internal()
+                if stream_result:
+                    if "b" in getattr(output, "mode", "") or isinstance(output, BinaryIO):  # Check if it's a binary stream
+                        output.write(stream_result.getvalue())
+                        return stream_result.getvalue()
+                    else:  # Assume text stream
+                        try:
+                            decoded_content = stream_result.getvalue().decode("utf-8")
+                            output.write(decoded_content)
+                            return decoded_content
+                        except UnicodeDecodeError:
+                            log.error("Error: Cannot decode byte stream to UTF-8 for text stream output. Consider setting compress=False or ensuring database encoding is compatible.")
+                            return None
+                return None
+
+            else:
+                log.error(f"Unsupported output type: {type(output)}")
+                return None
+
+        except Exception as e:
+            log.error(f"An unexpected error occurred: {e}")
+            return None
+
 
 class GenericTypeCompiler(TypeCompiler):
     """Generic type compiler