ormlambda 0.1.0__py3-none-any.whl

ormlambda/common/interfaces/IStatements.py

@@ -0,0 +1,227 @@
+from typing import Any, Callable, Iterable, Optional, Literal, Type, overload
+from enum import Enum
+from abc import abstractmethod, ABC
+
+from .IRepositoryBase import IRepositoryBase
+from ..enums import JoinType
+from ...utils import Table
+
+OrderType = Literal["ASC", "DESC"]
+
+
+class IStatements[T: Table](ABC):
+    @abstractmethod
+    def create_table(self) -> None: ...
+
+    @abstractmethod
+    def table_exists(self) -> bool: ...
+
+    # region insert
+    @overload
+    def insert(self, values: T) -> None:
+        """
+        PARAMS
+        ------
+        - values: Recieves a single object that must match the model's type
+        """
+        ...
+
+    @overload
+    def insert(self, values: list[T]) -> None:
+        """
+        PARAMS
+        ------
+        - values: Recieves a list of the same objects as the model
+        """
+        ...
+
+    @abstractmethod
+    def insert(self, values: T | list[T]) -> None: ...
+
+    # region upsert
+    @overload
+    def upsert(self, values: T) -> None:
+        """
+        PARAMS
+        ------
+        - values: Recieves a single object that must match the model's type
+        """
+        ...
+
+    @overload
+    def upsert(self, values: list[T]) -> None:
+        """
+        PARAMS
+        ------
+        - values: Recieves a list of the same objects as the model
+        """
+        ...
+
+    @abstractmethod
+    def upsert(self, values: list[T]) -> None:
+        """
+        Try to insert new values in the table, if they exist, update them
+        """
+        ...
+
+    @abstractmethod
+    def update(self, dicc: dict[str | property, Any]) -> None: ...
+
+    # endregion
+
+    # region limit
+    @abstractmethod
+    def limit(self, number: int) -> "IStatements[T]": ...
+
+    # endregion
+
+    # region offset
+    @abstractmethod
+    def offset(self, number: int) -> "IStatements[T]": ...
+
+    # endregion
+
+    # region delete
+    @overload
+    def delete(self) -> None: ...
+
+    @overload
+    def delete(self, instance: T) -> None: ...
+
+    @overload
+    def delete(self, instance: list[T]) -> None: ...
+    @abstractmethod
+    def delete(self, instance: Optional[T | list[T]] = None) -> None: ...
+
+    # endregion
+
+    # region join
+    @abstractmethod
+    def join(self, table_left: Table, table_right: Table, *, by: str) -> "IStatements[T]": ...
+
+    # endregion
+
+    # region where
+    @overload
+    def where(self, lambda_: Callable[[T], bool]) -> "IStatements[T]":
+        """
+        This method creates where clause by passing the lambda's condition
+
+        EXAMPLE
+        -
+        mb = BaseModel()
+        mb.where(lambda a: 10 <= a.city_id <= 100)
+        """
+        ...
+
+    @overload
+    def where(self, lambda_: Callable[[T], Iterable]) -> "IStatements[T]":
+        """
+        This method creates where clause by passing the Iterable in lambda function
+        EXAMPLE
+        -
+        mb = BaseModel()
+        mb.where(lambda a: (a.city, ConditionType.REGEXP, r"^B"))
+        """
+        ...
+
+    @overload
+    def where(self, lambda_: Callable[[T], bool], **kwargs) -> "IStatements[T]":
+        """
+        PARAM
+        -
+
+        -kwargs: Use this when you need to replace variables inside a lambda method. When working with lambda methods, all variables will be replaced by their own variable names. To avoid this, we need to pass key-value parameters  to specify which variables we want to replace with their values.
+
+        EXAMPLE
+        -
+        mb = BaseModel()
+
+        external_data = "
+        mb.where(lambda a: a.city_id > external_data)
+        """
+        ...
+
+    @abstractmethod
+    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> "IStatements[T]": ...
+
+    # endregion
+
+    # region order
+    @overload
+    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> "IStatements[T]": ...
+    @overload
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements[T]": ...
+    @abstractmethod
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements[T]": ...
+
+    # endregion
+
+    # region select
+    @overload
+    def select(self) -> tuple[T, ...]: ...
+    @overload
+    def select[T1](self, selector: Callable[[T], T1], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...]]: ...
+    @overload
+    def select[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...]]: ...
+    @overload
+    def select[T1, T2](self, selector: Callable[[T], tuple[T1, T2]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...]]: ...
+    @overload
+    def select[T1, T2, T3](self, selector: Callable[[T], tuple[T1, T2, T3]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...]]: ...
+    @overload
+    def select[T1, T2, T3, T4](self, selector: Callable[[T], tuple[T1, T2, T3, T4]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...]]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...]]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...]]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6, T7](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...]]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6, T7, T8](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...]]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9](
+        self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]], *, by: Optional[Enum] = JoinType.INNER_JOIN
+    ) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...], tuple[T9, ...]]: ...
+    @overload
+    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](
+        self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], *, by: Optional[Enum] = JoinType.INNER_JOIN
+    ) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...], tuple[T9, ...], tuple[T10, ...]]: ...
+    @overload
+    def select[Ts](self, selector: Optional[Callable[[T], Ts]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[Ts, ...]: ...
+    @overload
+    def select[Ts](self, selector: Optional[Callable[[T], tuple[Ts]]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[Ts, ...]: ...
+    @overload
+    def select[*Ts](self, selector: Optional[Callable[[T], tuple[*Ts]]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[*Ts]]: ...
+    @overload
+    def select[TFlavour](self, selector: Optional[Callable[[T], tuple]] = None, *, flavour: Type[TFlavour], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[TFlavour]: ...
+    @abstractmethod
+    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = None, by: JoinType = JoinType.INNER_JOIN): ...
+
+    # endregion
+
+    # region select_one
+    @overload
+    def select_one(self) -> T: ...
+    @overload
+    def select_one(self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[tuple]) -> tuple: ...
+    @overload
+    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> T1: ...
+    @overload
+    def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[*Ts]: ...
+    @overload
+    def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[tuple]) -> tuple[*Ts]: ...
+    @overload
+    def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...
+    @abstractmethod
+    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = None, by: Optional[Enum] = JoinType.INNER_JOIN): ...
+
+    # endregion
+
+    @abstractmethod
+    def build(self) -> str: ...
+
+
+class IStatements_two_generic[T: Table, TRepo](IStatements[T]):
+    @property
+    @abstractmethod
+    def repository(self) -> IRepositoryBase[TRepo]: ...

ormlambda/common/interfaces/__init__.py

@@ -0,0 +1,4 @@
+from .IQueryCommand import IQuery  # noqa: F401
+from .INonQueryCommand import INonQueryCommand  # noqa: F401
+from .IRepositoryBase import IRepositoryBase  # noqa: F401
+from .IStatements import IStatements,IStatements_two_generic  # noqa: F401

ormlambda/components/delete/IDelete.py

@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+
+class IDelete[T](ABC):
+    @abstractmethod
+    def delete(self, instances: T | list[T]) -> None: ...

ormlambda/components/delete/__init__.py

@@ -0,0 +1,2 @@
+from .abstract_delete import DeleteQueryBase  # noqa: F401
+from .IDelete import IDelete  # noqa: F401

ormlambda/components/delete/abstract_delete.py

@@ -0,0 +1,14 @@
+from abc import abstractmethod
+
+from .IDelete import IDelete
+from ...utils import Table
+from ...common.interfaces import IRepositoryBase
+from ...common.abstract_classes import NonQueryBase
+
+
+class DeleteQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IDelete[T]):
+    def __init__(self, model: T, repository: TRepo) -> None:
+        super().__init__(model, repository)
+
+    @abstractmethod
+    def delete(self, instances: T | list[T]) -> None: ...

ormlambda/components/insert/IInsert.py

@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+
+class IInsert[T](ABC):
+    @abstractmethod
+    def insert(self, instances: T | list[T])->None: ...

ormlambda/components/insert/__init__.py

@@ -0,0 +1,2 @@
+from .IInsert import IInsert  # noqa: F401
+from .abstract_insert import InsertQueryBase  # noqa: F401

ormlambda/components/insert/abstract_insert.py

@@ -0,0 +1,21 @@
+from abc import abstractmethod
+from ...utils import Table
+
+from .IInsert import IInsert
+from ...common.interfaces import IRepositoryBase
+from ...common.abstract_classes import NonQueryBase
+
+
+class InsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, IRepositoryBase], IInsert[T]):
+    def __init__(self, model: T, repository: TRepo) -> None:
+        super().__init__(model, repository)
+
+    @abstractmethod
+    def insert(self, instances: T | list[T]) -> None: ...
+
+    @property
+    @abstractmethod
+    def CLAUSE(self) -> str: ...
+
+    @abstractmethod
+    def execute(self) -> None: ...

ormlambda/components/select/ISelect.py

@@ -0,0 +1,14 @@
+from abc import abstractmethod
+
+from ...common.interfaces import IQuery
+from .table_column import TableColumn
+
+
+class ISelect(IQuery):
+    @property
+    @abstractmethod
+    def select_list(self) -> list[TableColumn]: ...
+
+    @property
+    @abstractmethod
+    def tables_heritage(self) -> list[TableColumn]: ...

ormlambda/components/select/__init__.py

@@ -0,0 +1,2 @@
+from .ISelect import ISelect  # noqa: F401
+from .table_column import TableColumn  # noqa: F401

ormlambda/components/select/table_column.py

@@ -0,0 +1,39 @@
+from typing import Any, Iterator
+from ...utils import Table
+
+
+class TableColumn:
+    def __init__(self, table: Table, col: str) -> None:
+        self._table: Table = table
+        self._column: str = col
+
+    def __repr__(self) -> str:
+        return f"{TableColumn.__name__}: T={self._table.__table_name__} col={self._column}"
+
+    @property
+    def real_column(self) -> str:
+        return self._column
+
+    @property
+    def column(self) -> str:
+        return f"{self._table.__table_name__}.{self._column} as `{self.alias}`"
+
+    @property
+    def alias(self) -> str:
+        return f"{self._table.__table_name__}_{self._column}"
+
+    def get_all_alias(self) -> list[str]:
+        return [class_.alias for class_ in self.all_columns(self._table)]
+
+    @classmethod
+    def all_columns(cls, table: Table) -> Iterator["TableColumn"]:
+        for col in table.__annotations__:
+            yield cls(table, col)
+
+    def __hash__(self) -> int:
+        return hash((self._table, self._column))
+
+    def __eq__(self, __value: Any) -> bool:
+        if isinstance(__value, TableColumn):
+            return self._table.__table_name__ == __value._table.__table_name__ and self._column == __value._column
+        return False

ormlambda/components/update/IUpdate.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class IUpdate(ABC):
+    @abstractmethod
+    def update(self, dicc: dict[str|property, Any]) -> None: ...

ormlambda/components/update/__init__.py

@@ -0,0 +1,2 @@
+from .abstract_update import UpdateQueryBase  # noqa: F401
+from .IUpdate import IUpdate  # noqa: F401

ormlambda/components/update/abstract_update.py

@@ -0,0 +1,25 @@
+from abc import abstractmethod
+from typing import Any, Optional
+
+from .IUpdate import IUpdate
+from ..where import AbstractWhere
+from ...common.interfaces import IRepositoryBase
+from ...common.abstract_classes import NonQueryBase
+from ...utils import Table
+
+
+class UpdateQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IUpdate):
+    def __init__(self, model: T, repository: TRepo, where: AbstractWhere = list[AbstractWhere]) -> None:
+        super().__init__(model, repository)
+        self._where: Optional[AbstractWhere] = where
+
+    @abstractmethod
+    def update(self, dicc: dict[str | property, Any]) -> None:
+        return super().update(dicc)
+
+    @property
+    @abstractmethod
+    def CLAUSE(self) -> str: ...
+
+    @abstractmethod
+    def execute(self) -> None: ...

ormlambda/components/upsert/IUpsert.py

@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+
+class IUpsert[T](ABC):
+    @abstractmethod
+    def upsert(self, instances: T | list[T]) -> None: ...

ormlambda/components/upsert/__init__.py

@@ -0,0 +1,2 @@
+from .abstract_upsert import UpsertQueryBase  # noqa: F401
+from .IUpsert import IUpsert  # noqa: F401

ormlambda/components/upsert/abstract_upsert.py

@@ -0,0 +1,21 @@
+from abc import abstractmethod
+from .IUpsert import IUpsert
+from ...common.interfaces import IRepositoryBase
+from ...common.abstract_classes import NonQueryBase
+
+from ...utils import Table
+
+
+class UpsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IUpsert[T]):
+    def __init__(self, model: T, repository: TRepo) -> None:
+        super().__init__(model, repository)
+
+    @abstractmethod
+    def upsert(self, instances: T | list[T]) -> None: ...
+
+    @property
+    @abstractmethod
+    def CLAUSE(self) -> str: ...
+
+    @abstractmethod
+    def execute(self) -> None: ...

ormlambda/components/where/__init__.py

@@ -0,0 +1 @@
+from .abstract_where import AbstractWhere  # noqa: F401

ormlambda/components/where/abstract_where.py

@@ -0,0 +1,11 @@
+from abc import abstractmethod
+from ...utils import Table
+
+from ...common.interfaces import IQuery
+
+
+class AbstractWhere(IQuery):
+    WHERE: str = "WHERE"
+
+    @abstractmethod
+    def get_involved_tables(self) -> tuple[tuple[Table, Table]]: ...

ormlambda/databases/my_sql/__init__.py

@@ -0,0 +1,2 @@
+from .repository import MySQLRepository, Error  # noqa: F401
+from .statements import MySQLStatements  # noqa: F401

ormlambda/databases/my_sql/clauses/__init__.py

@@ -0,0 +1,13 @@
+from .create_database import CreateDatabase, TypeExists  # noqa: F401
+from .delete import DeleteQuery  # noqa: F401
+from .drop_database import DropDatabase  # noqa: F401
+from .drop_table import DropTable  # noqa: F401
+from .insert import InsertQuery  # noqa: F401
+from .joins import JoinSelector, JoinType  # noqa: F401
+from .limit import LimitQuery  # noqa: F401
+from .offset import OffsetQuery  # noqa: F401
+from .order import OrderQuery  # noqa: F401
+from .select import SelectQuery  # noqa: F401
+from .update import UpdateQuery  # noqa: F401
+from .upsert import UpsertQuery  # noqa: F401
+from .where_condition import WhereCondition  # noqa: F401

ormlambda/databases/my_sql/clauses/create_database.py

@@ -0,0 +1,29 @@
+from typing import Literal, override
+from mysql.connector import Error, errorcode
+from mysql.connector import MySQLConnection
+
+from ....common.interfaces import IRepositoryBase
+
+TypeExists = Literal["fail", "replace", "append"]
+
+
+class CreateDatabase:
+    def __init__(self, repository: IRepositoryBase[MySQLConnection]) -> None:
+        self._repository: IRepositoryBase[MySQLConnection] = repository
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "CREATE DATABASE"
+
+    @override
+    def execute(self, name: str, if_exists: TypeExists = "fail") -> None:
+        with self._repository.connection.cursor() as cursor:
+            try:
+                cursor.execute(f"{self.CLAUSE} {name} DEFAULT CHARACTER SET 'utf8'")
+            except Error as err:
+                if err.errno == errorcode.ER_DB_CREATE_EXISTS and if_exists != "fail":
+                    cursor.execute(f"USE {name};")
+                else:
+                    raise err
+        return None

ormlambda/databases/my_sql/clauses/delete.py

@@ -0,0 +1,54 @@
+from typing import Any, override, Iterable
+
+from ....utils import Table, Column
+from ....common.interfaces import IRepositoryBase
+from ....components.delete import DeleteQueryBase
+from mysql.connector import MySQLConnection
+
+
+class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase[MySQLConnection]]):
+    def __init__(self, model: T, repository: IRepositoryBase[MySQLConnection]) -> None:
+        super().__init__(model, repository)
+
+    @property
+    def CLAUSE(self) -> str:
+        return "DELETE"
+
+    @override
+    def delete(self, instances: T | list[T]) -> None:
+        col: str = ""
+        if isinstance(instances, Table):
+            pk: Column = instances.get_pk()
+            if pk.column_value is None:
+                raise Exception(f"You cannot use 'DELETE' query without set primary key in '{instances.__table_name__}'")
+            col = pk.column_name
+            value = str(pk.column_value)
+
+        elif isinstance(instances, Iterable):
+            value: list[Any] = []
+            for ins in instances:
+                pk = ins.get_pk()
+                col = pk.column_name
+                value.append(pk.column_value)
+
+        query: str = f"{self.CLAUSE} FROM {self._model.__table_name__} WHERE {col}"
+        if isinstance(value, str):
+            query += "= %s"
+            self._query = query
+            self._values = [value]
+            return None
+
+        elif isinstance(value, Iterable):
+            params = ", ".join(["%s"] * len(value))
+            query += f" IN ({params})"
+            self._query = query
+            self._values = value
+            return None
+        else:
+            raise Exception(f"'{type(value)}' no esperado")
+
+    @override
+    def execute(self) -> None:
+        if not self._query:
+            raise ValueError
+        return self._repository.execute_with_values(self._query, self._values)

ormlambda/databases/my_sql/clauses/drop_database.py

@@ -0,0 +1,19 @@
+from typing import override
+from mysql.connector import MySQLConnection
+
+
+from ....common.interfaces import IRepositoryBase
+
+
+class DropDatabase:
+    def __init__(self, repository: IRepositoryBase[MySQLConnection]) -> None:
+        self._repository: IRepositoryBase[MySQLConnection] = repository
+
+    @override
+    def execute(self, name: str) -> None:
+        return self._repository.execute(f"{self.CLAUSE} {name}")
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "DROP DATABASE IF EXISTS"

ormlambda/databases/my_sql/clauses/drop_table.py

@@ -0,0 +1,23 @@
+from typing import Literal, override
+
+from ....common.interfaces import IRepositoryBase
+
+from mysql.connector import MySQLConnection
+
+TypeExists = Literal["fail", "replace", "append"]
+
+
+class DropTable:
+    def __init__(self, repository: IRepositoryBase[MySQLConnection]) -> None:
+        self._repository: IRepositoryBase[MySQLConnection] = repository
+
+    @override
+    def execute(self, name: str = None) -> None:
+        query = rf"{self.CLAUSE} {name}"
+        self._repository.execute(query)
+        return None
+
+    @property
+    @override
+    def CLAUSE(self) -> str:
+        return "DROP TABLE"

ormlambda/databases/my_sql/clauses/insert.py

@@ -0,0 +1,70 @@
+from typing import Any, override, Iterable
+from mysql.connector import MySQLConnection
+
+from ....utils import Table, Column
+from ....components.insert import InsertQueryBase
+from ....common.interfaces import IRepositoryBase
+
+
+class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]):
+    def __init__(self, model: T, repository: IRepositoryBase[IRepositoryBase[MySQLConnection]]) -> None:
+        super().__init__(model, repository)
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "INSERT INTO"
+
+    @override
+    def execute(self) -> None:
+        if not self._query:
+            raise ValueError
+        return self._repository.executemany_with_values(self.query, self._values)
+
+    @override
+    def insert(self, instances: T | list[T]) -> None:
+        new_dict_list: list[dict[str, Any]] = []
+        self.__fill_dict_list(new_dict_list, instances)
+        cols_tuple = new_dict_list[0].keys()
+        join_cols = ", ".join(cols_tuple)
+        unknown_rows = f'({", ".join(["%s"]*len(cols_tuple))})'  # The number of "%s" must match the dict 'dicc_0' length
+
+        self._values = [tuple(x.values()) for x in new_dict_list]
+        self._query = f"{self.CLAUSE} {self._model.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
+        return None
+
+    @staticmethod
+    def __is_valid(column: Column) -> bool:
+        """
+        We want to delete the column from table when it's specified with an 'AUTO_INCREMENT' or 'AUTO GENERATED ALWAYS AS (__) STORED' statement.
+
+        if the column is auto-generated, it means the database creates the value for that column, so we must deleted it.
+        if the column is primary key and auto-increment, we should be able to create an object with specific pk value.
+
+        RETURN
+        -----
+
+        - True  -> Do not delete the column from dict query
+        - False -> Delete the column from dict query
+        """
+
+        is_pk_none_and_auto_increment: bool = all([column.column_value is None, column.is_primary_key, column.is_auto_increment])
+
+        if is_pk_none_and_auto_increment or column.is_auto_generated:
+            return False
+        return True
+
+    def __fill_dict_list(self, list_dict: list[dict], values: T | list[T]):
+        if issubclass(values.__class__, Table):
+            dicc: dict = {}
+            for col in values.__dict__.values():
+                if isinstance(col, Column) and self.__is_valid(col):
+                    dicc.update({col.column_name: col.column_value})
+            list_dict.append(dicc)
+            return list_dict
+
+        elif isinstance(values, Iterable):
+            for x in values:
+                self.__fill_dict_list(list_dict, x)
+        else:
+            raise Exception(f"Tipo de dato'{type(values)}' no esperado")