ormlambda 3.34.0__py3-none-any.whl → 3.34.5__py3-none-any.whl

ormlambda/dialects/mysql/types.py

@@ -32,7 +32,7 @@ class _NumericType(_NumericCommonType, sqltypes.Numeric): ...
 class _FloatType(_NumericCommonType, sqltypes.Float):
     def __init__(self, precision=None, scale=None, asdecimal=True, **kw):
         if isinstance(self, (REAL, DOUBLE)) and ((precision is None and scale is not None) or (precision is not None and scale is None)):
-            raise AttributeError("You must specify both precision and scale or omit " "both altogether.")
+            raise AttributeError("You must specify both precision and scale or omit both altogether.")
         super().__init__(precision=precision, asdecimal=asdecimal, **kw)
         self.scale = scale
 
@@ -42,6 +42,9 @@ class _IntegerType(_NumericCommonType, sqltypes.Integer):
         self.display_width = display_width
         super().__init__(**kw)
 
+    def __repr__(self):
+        return f"{type(self).__name__}({self.display_width})"
+
 
 class _StringType(sqltypes.String):
     """Base for MySQL string types."""

ormlambda/engine/base.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
-from pathlib import Path
-from typing import TYPE_CHECKING, BinaryIO, Literal, Optional, TextIO
+from typing import TYPE_CHECKING, Literal
 from ormlambda.engine import url
-from ormlambda.sql.ddl import CreateSchema, DropSchema, CreateBackup
+from ormlambda.sql.ddl import CreateSchema, DropSchema
+
 
 if TYPE_CHECKING:
     from ormlambda.dialects import Dialect
@@ -20,7 +20,7 @@ class Engine:
         if if_exists == "replace":
             self.drop_schema(schema_name, if_exists)
 
-        sql = CreateSchema(schema=schema_name, if_not_exists=if_exists == "append").compile(self.dialect).string
+        sql = CreateSchema(schema=schema_name, if_not_exists=if_exists== 'append').compile(self.dialect).string
         try:
             self.repository.execute(sql)
         except Exception:
@@ -56,22 +56,3 @@ class Engine:
     def set_database(self, name: str) -> None:
         self.repository.database = name
         return None
-
-    def create_backup(
-        self,
-        output: Optional[str | BinaryIO | TextIO] = None,
-        compress: bool = False,
-        backup_dir: str = "backups",
-        **kw,
-    ) -> Optional[str | BinaryIO | Path]:
-        return (
-            CreateBackup(self.url)
-            .compile(
-                self.dialect,
-                output=output,
-                compress=compress,
-                backup_dir=backup_dir,
-                **kw,
-            )
-            .string
-        )

ormlambda/repository/interfaces/IRepositoryBase.py

@@ -9,8 +9,12 @@ from typing import (
     Sequence,
     Type,
     Iterable,
+    TYPE_CHECKING,
 )
 
+if TYPE_CHECKING:
+    from ormlambda.statements.types import TypeExists
+
 
 type _DBAPICursorDescription = Sequence[
     tuple[
@@ -138,6 +142,9 @@ class IRepositoryBase(ABC):
     @abstractmethod
     def execute(self, query: str) -> None: ...
 
+    @abstractmethod
+    def drop_table(self, name: str) -> None: ...
+
     @abstractmethod
     def table_exists(self, name: str) -> bool: ...
 

ormlambda/sql/clause_info/clause_info.py

@@ -9,6 +9,7 @@ from ormlambda.sql.types import (
     TableType,
     ColumnType,
     AliasType,
+    TypeEngine,
 )
 from .interface import IClauseInfo
 from ormlambda.sql import ForeignKey
@@ -166,6 +167,18 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             return self._column
         return type(self._column)
 
+    @property
+    def dbtype(self)->tp.Optional[TypeEngine]:
+        if self._dtype is not None:
+            return self._dtype
+
+        if isinstance(self._column, Column):
+            return self._column.dbtype
+
+        if isinstance(self._column, type):
+            return self._column
+        return type(self._column)
+
     def query(self, dialect: Dialect, **kwargs) -> str:
         return self._create_query(dialect, **kwargs)
 

ormlambda/sql/column/column.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 import abc
-from typing import Annotated, Any, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args
+from typing import Annotated, Any, ClassVar, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args
 from ormlambda.sql.types import TableType, ComparerType, ColumnType
 from ormlambda import ConditionType
+from ormlambda.sql.type_api import TypeEngine
 
 if TYPE_CHECKING:
     import re
     from ormlambda import Table
     from ormlambda.sql.comparer import Comparer, Regex, Like
-    from ormlambda.sql.type_api import TypeEngine
 
 
 from ormlambda.types import (
@@ -24,10 +24,13 @@ from ormlambda.types import (
 
 
 class Column[TProp]:
-    PRIVATE_CHAR: str = "_"
+    PRIVATE_CHAR: ClassVar[str] = "_"
+
+    _dbtype: Optional[TypeEngine]
 
     __slots__ = (
-        "dtype",
+        "_dtype",
+        "_dbtype",
         "column_name",
         "table",
         "is_primary_key",
@@ -111,7 +114,8 @@ class Column[TProp]:
 
     def __set__(self, obj, value):
         if self._check and value is not None:
-            if not isinstance(value, self.dtype):
+            type_ = self.dtype if not isinstance(self.dtype, TypeEngine) else self.dtype.python_type
+            if not isinstance(value, type_):
                 raise ValueError(f"The '{self.column_name}' Column from '{self.table.__table_name__}' table expected '{str(self.dtype)}' type. You passed '{type(value).__name__}' type")
         setattr(obj, self.__private_name, value)
 
@@ -132,8 +136,6 @@ class Column[TProp]:
     def _fill_from_annotations[T: Table](self, obj: Type[T], name: str) -> None:
         """Read the metada when using Annotated typing class, and set the attributes accordingly"""
 
-        from ormlambda.sql.type_api import TypeEngine
-
         annotations = get_type_hints(obj, include_extras=True)
         if name in annotations:
             annotation = annotations[name]
@@ -163,6 +165,23 @@ class Column[TProp]:
                         self.is_not_null = True
         return None
 
+    @property
+    def dtype(self) -> Type[TProp]:
+        return self._dtype
+
+    @dtype.setter
+    def dtype(self, value: Type[TProp] | TypeEngine) -> None:
+        if isinstance(value, TypeEngine):
+            self._dtype = value.python_type
+            self._dbtype = value
+        else:
+            self._dtype = value
+            self._dbtype = None
+
+    @property
+    def dbtype(self) -> TypeEngine[TProp]:
+        return self._dbtype if self._dbtype else self.dtype
+
     @abc.abstractmethod
     def __comparer_creator(self, other: ColumnType, compare: ComparerType) -> Comparer:
         from ormlambda.sql.comparer import Comparer

ormlambda/sql/compiler.py

@@ -1,13 +1,6 @@
 from __future__ import annotations
 import abc
-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 typing import Any, ClassVar, Optional, TYPE_CHECKING
 
 from ormlambda.sql.ddl import CreateColumn
 from ormlambda.sql.foreign_key import ForeignKey
@@ -22,13 +15,7 @@ if TYPE_CHECKING:
     from .visitors import Element
     from .elements import ClauseElement
     from ormlambda.dialects import Dialect
-    from ormlambda.sql.ddl import (
-        CreateTable,
-        CreateSchema,
-        DropSchema,
-        DropTable,
-        CreateBackup,
-    )
+    from ormlambda.sql.ddl import CreateTable, CreateSchema, DropSchema
     from .sqltypes import (
         INTEGER,
         SMALLINTEGER,
@@ -75,12 +62,6 @@ if TYPE_CHECKING:
     )
 
 
-type customString = Union[str | Path]
-
-logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-log = logging.getLogger(__name__)
-
-
 class Compiled:
     """Represent a compiled SQL or DDL expression.
 
@@ -268,9 +249,6 @@ class DDLCompiler(Compiled):
         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)
@@ -295,225 +273,6 @@ 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

ormlambda/sql/ddl.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING
 from .elements import ClauseElement
 
 if TYPE_CHECKING:
-    from ormlambda import URL
     from ormlambda.dialects.interface.dialect import Dialect
     from ormlambda import Column
     from ormlambda import Table
@@ -23,22 +22,16 @@ class BaseDDLElement(ClauseElement):
         return dialect.ddl_compiler(dialect, self, **kw)
 
 
-class CreateDropTable:
-    def __init__(self, element: Table):
-        self.element = element
-        self.columns = [CreateColumn(c) for c in element.get_columns()]
-
-
-class CreateTable(CreateDropTable, BaseDDLElement):
+class CreateTable(BaseDDLElement):
     """
     Class representing a CREATE TABLE statement.
     """
 
     __visit_name__ = "create_table"
 
-
-class DropTable(CreateDropTable, BaseDDLElement):
-    __visit_name__ = "drop_table"
+    def __init__(self, element: Table):
+        self.element = element
+        self.columns = [CreateColumn(c) for c in element.get_columns()]
 
 
 class CreateColumn[T](BaseDDLElement):
@@ -73,10 +66,3 @@ class SchemaExists(BaseDDLElement):
 
     def __init__(self, schema: str):
         self.schema = schema
-
-
-class CreateBackup(BaseDDLElement):
-    __visit_name__ = "create_backup"
-
-    def __init__(self, url: URL):
-        self.url = url

ormlambda/sql/foreign_key.py

@@ -36,14 +36,6 @@ class ForeignKeyContext(set["ForeignKey"]):
 class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
     __visit_name__ = "foreign_key"
 
-    __slots__ = (
-        "_tright",
-        "_relationship",
-        "_comparer",
-        "_clause_name",
-        "_keep_alive",
-    )
-
     stored_calls: ClassVar[ForeignKeyContext] = ForeignKeyContext()
 
     @overload
@@ -157,13 +149,3 @@ class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
         comparer.set_context(context)
         comparer._dialect = dialect
         return comparer
-
-    def __hash__(self):
-        return hash((
-            self._tleft,
-            self._tright,
-            self._clause_name,
-        ))
-
-    def __eq__(self, other: ForeignKey):
-        return hash(other) == hash(self)

ormlambda/sql/sqltypes.py

@@ -10,6 +10,7 @@ import ormlambda.util as util
 from uuid import UUID as _python_UUID
 from shapely import Point as _python_Point
 
+
 class _NoArg(enum.Enum):
     NO_ARG = 0
 
@@ -391,7 +392,7 @@ class Enum(String, TypeEngine[EnumType]):
             enum_args = get_args(pt)
             bad_args = [arg for arg in enum_args if not isinstance(arg, str)]
             if bad_args:
-                raise ValueError(f"Can't create string-based Enum datatype from non-string " f"values: {', '.join(repr(x) for x in bad_args)}.  Please " f"provide an explicit Enum datatype for this Python type")
+                raise ValueError(f"Can't create string-based Enum datatype from non-string values: {', '.join(repr(x) for x in bad_args)}.  Please provide an explicit Enum datatype for this Python type")
             native_enum = False
             return enum_args, native_enum
 
@@ -407,7 +408,7 @@ class Enum(String, TypeEngine[EnumType]):
         elif util.is_pep695(python_type):
             value = python_type.__value__
             if not util.is_literal(value):
-                raise ValueError(f"Can't associate TypeAliasType '{python_type}' to an " "Enum since it's not a direct alias of a Literal. Only " "aliases in this form `type my_alias = Literal['a', " "'b']` are supported when generating Enums.")
+                raise ValueError(f"Can't associate TypeAliasType '{python_type}' to an Enum since it's not a direct alias of a Literal. Only aliases in this form `type my_alias = Literal['a', 'b']` are supported when generating Enums.")
             enum_args, native_enum = process_literal(value)
 
         elif isinstance(python_type, type) and issubclass(python_type, enum.Enum):
@@ -439,13 +440,15 @@ class Enum(String, TypeEngine[EnumType]):
 
         self._valid_lookup.update([(value, self._valid_lookup[self._object_lookup[value]]) for value in values])
 
+
 class Point(TypeEngine[_python_Point]):
-    __visit_name__ = 'point'
+    __visit_name__ = "point"
 
     @property
-    def python_type(self)->Type[_python_Point]:
+    def python_type(self) -> Type[_python_Point]:
         return _python_Point
-    
+
+
 class JSON(TypeEngine[Any]):
     """JSON data type."""
 
@@ -597,6 +600,7 @@ class VARBINARY(Varbinary):
 class ENUM(Enum):
     __visit_name__ = "ENUM"
 
+
 class POINT(Point):
     __visit_name__ = "POINT"
 
@@ -623,13 +627,15 @@ _type_dicc: dict[Any, TypeEngine[Any]] = {
     float: Float(),
     NoneType: NULLTYPE,
     dt.datetime: Datetime(timezone=False),
+    dt.date: DATE(),
     bytes: _BINARY,
     bytearray: _BINARY,
     bool: Boolean(),
     enum.Enum: _ENUM,
     Literal: _ENUM,
     _python_UUID: UUID(),
-    _python_Point: POINT()
+    _python_Point: POINT(),
+    decimal.Decimal: DECIMAL(),
 }
 # enderegion
 

ormlambda/sql/table/table.py

@@ -5,9 +5,10 @@ import json
 from ormlambda.sql import Column
 from ormlambda.sql import ForeignKey
 from ormlambda.util.module_tree.dfs_traversal import DFSTraversal
-from ormlambda.sql.ddl import CreateTable, DropTable
+from ormlambda.sql.ddl import CreateTable
 
 if TYPE_CHECKING:
+    from ormlambda.statements import BaseStatement
     from ormlambda.dialects import Dialect
 
 from .table_constructor import __init_constructor__
@@ -114,14 +115,17 @@ class Table(metaclass=TableMeta):
             if name == key:
                 return value
 
+    @classmethod
+    def create_table_query(cls, statement: BaseStatement) -> str:
+        """It's classmethod because of it does not matter the columns values to create the table"""
+        from ormlambda.sql.schema_generator import SchemaGeneratorFactory
+
+        return SchemaGeneratorFactory.get_generator(statement._dialect).create_table(cls)
+
     @classmethod
     def create_table(cls, dialect: Dialect) -> str:
         return CreateTable(cls).compile(dialect).string
 
-    @classmethod
-    def drop_table(cls, dialect:Dialect)->str:
-        return DropTable(cls).compile(dialect).string
-    
     @classmethod
     def find_dependent_tables(cls) -> tuple["Table", ...]:
         """Work in progress"""

ormlambda/sql/type_api.py

@@ -33,3 +33,6 @@ class TypeEngine[T: Any](Element, abc.ABC):
         if _coerced_type is NULLTYPE:
             return self
         return _coerced_type
+
+    def __repr__(self):
+        return f"{TypeEngine.__name__}: {super().__repr__()}"

ormlambda/sql/visitors.py

@@ -72,3 +72,6 @@ class Element:
                 # return visitor.visit_unsupported_compilation(self, err, **kw)  # type: ignore  # noqa: E501
 
         cls._compiler_dispatch = _compiler_dispatch
+
+    def __repr__(self):
+        return f"{Element.__name__}: {self.__visit_name__}"

ormlambda/statements/interfaces/IStatements.py

@@ -37,9 +37,6 @@ class IStatements[T: Table](Element):
     @abstractmethod
     def create_table(self, if_exists: TypeExists = "fail") -> None: ...
 
-    @abstractmethod
-    def drop_table(self) -> None: ...
-
     # #TODOL [ ]: We must to implement this mehtod
     # @abstractmethod
     # def drop_table(self)->None: ...