apexdevkit 1.17.9__tar.gz → 1.17.10__tar.gz

{apexdevkit-1.17.9 → apexdevkit-1.17.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apexdevkit
-Version: 1.17.9
+Version: 1.17.10
 Summary: Apex Development Tools for python.
 Author: Apex Dev
 Author-email: dev@apex.ge

{apexdevkit-1.17.9 → apexdevkit-1.17.10}/apexdevkit/repository/mssql.py

@@ -8,6 +8,7 @@ from pymssql.exceptions import DatabaseError
 from apexdevkit.error import DoesNotExistError, ExistsError
 from apexdevkit.formatter import Formatter
 from apexdevkit.repository import Database, DatabaseCommand, RepositoryBase
+from apexdevkit.repository.sql import NotNone, SqlFieldManager, _SqlField
 
 ItemT = TypeVar("ItemT")
 
@@ -143,7 +144,7 @@ class MsSqlTableBuilder(Generic[ItemT]):
     schema: str | None = None
     table: str | None = None
     formatter: Formatter[dict[str, Any], ItemT] | None = None
-    fields: list[MsSqlField] | None = None
+    fields: list[_SqlField] | None = None
 
     def with_username(self, value: str) -> MsSqlTableBuilder[ItemT]:
         return MsSqlTableBuilder[ItemT](
@@ -183,18 +184,29 @@ class MsSqlTableBuilder(Generic[ItemT]):
             self.fields,
         )
 
-    def with_fields(self, value: Iterable[MsSqlField]) -> MsSqlTableBuilder[ItemT]:
-        field_list = list(value)
-        if len([field for field in field_list if field.is_id]) != 1:
-            raise ValueError("Pass only one identifier field.")
-        if len([field for field in field_list if field.is_parent]) > 1:
-            raise ValueError("Pass only one parent field.")
+    def with_fields(self, value: Iterable[_SqlField]) -> MsSqlTableBuilder[ItemT]:
+        key_list = list(value)
+        if len([key for key in key_list if key.is_id]) != 1:
+            raise ValueError("Pass only one identifier key.")
+        if len([key for key in key_list if key.is_parent]) > 1:
+            raise ValueError("Pass only one parent key.")
+        if (
+            len(
+                [
+                    key
+                    for key in key_list
+                    if not key.is_filter and isinstance(key.fixed_value, NotNone)
+                ]
+            )
+            > 0
+        ):
+            raise ValueError("Only filter fields can be 'not null'.")
         return MsSqlTableBuilder[ItemT](
             self.username,
             self.schema,
             self.table,
             self.formatter,
-            field_list,
+            key_list,
         )
 
     def build(self) -> SqlTable[ItemT]:
@@ -205,7 +217,7 @@ class MsSqlTableBuilder(Generic[ItemT]):
             self.schema,
             self.table,
             self.formatter,
-            self.fields,
+            SqlFieldManager.Builder().with_fields(self.fields).for_mssql().build(),
             self.username,
         )
 
@@ -215,7 +227,7 @@ class DefaultSqlTable(SqlTable[ItemT]):
     schema: str
     table: str
     formatter: Formatter[dict[str, Any], ItemT]
-    fields: list[MsSqlField]
+    fields: SqlFieldManager
     username: str | None = None
 
     def count_all(self) -> DatabaseCommand:
@@ -223,9 +235,9 @@ class DefaultSqlTable(SqlTable[ItemT]):
             {self._user_check}
             SELECT count(*) AS n_items
             FROM [{self.schema}].[{self.table}]
-            {self._where_statement(include_id=False)}
+            {self.fields.where_statement(include_id=False)}
             REVERT
-        """).with_data(self._data_with_fixed({}))
+        """).with_data(self.fields.with_fixed({}))
 
     def insert(self, item: ItemT) -> DatabaseCommand:
         columns = ", ".join(
@@ -246,7 +258,7 @@ class DefaultSqlTable(SqlTable[ItemT]):
                 {placeholders}
             )
             REVERT
-        """).with_data(self._data_with_fixed(self.formatter.dump(item)))
+        """).with_data(self.fields.with_fixed(self.formatter.dump(item)))
 
     def select(self, item_id: str) -> DatabaseCommand:
         columns = ", ".join(["[" + field.name + "]" for field in self.fields])
@@ -256,9 +268,9 @@ class DefaultSqlTable(SqlTable[ItemT]):
             SELECT
                 {columns} 
             FROM [{self.schema}].[{self.table}]
-            {self._where_statement(include_id=True)}
+            {self.fields.where_statement(include_id=True)}
             REVERT
-        """).with_data(self._data_with_fixed({self._id: item_id}))
+        """).with_data(self.fields.with_fixed({self.fields.id: item_id}))
 
     def select_all(self) -> DatabaseCommand:
         columns = ", ".join(["[" + field.name + "]" for field in self.fields])
@@ -268,10 +280,10 @@ class DefaultSqlTable(SqlTable[ItemT]):
             SELECT
                 {columns}
             FROM [{self.schema}].[{self.table}]
-            {self._where_statement(include_id=False)}
-            {self._order}
+            {self.fields.where_statement(include_id=False)}
+            {self.fields.order}
             REVERT
-        """).with_data(self._data_with_fixed({}))
+        """).with_data(self.fields.with_fixed({}))
 
     def update(self, item: ItemT) -> DatabaseCommand:
         updates = ", ".join(
@@ -287,27 +299,27 @@ class DefaultSqlTable(SqlTable[ItemT]):
             UPDATE [{self.schema}].[{self.table}]
             SET
                 {updates}
-            {self._where_statement(include_id=True)}
+            {self.fields.where_statement(include_id=True)}
             REVERT
-        """).with_data(self._data_with_fixed(self.formatter.dump(item)))
+        """).with_data(self.fields.with_fixed(self.formatter.dump(item)))
 
     def delete(self, item_id: str) -> DatabaseCommand:
         return DatabaseCommand(f"""
             {self._user_check}
             DELETE
             FROM [{self.schema}].[{self.table}]
-            {self._where_statement(include_id=True)}
+            {self.fields.where_statement(include_id=True)}
             REVERT
-        """).with_data(self._data_with_fixed({self._id: item_id}))
+        """).with_data(self.fields.with_fixed({self.fields.id: item_id}))
 
     def delete_all(self) -> DatabaseCommand:
         return DatabaseCommand(f"""
             {self._user_check}
             DELETE
             FROM [{self.schema}].[{self.table}]
-            {self._where_statement(include_id=False)}
+            {self.fields.where_statement(include_id=False)}
             REVERT
-        """).with_data(self._data_with_fixed({}))
+        """).with_data(self.fields.with_fixed({}))
 
     def load(self, data: dict[str, Any]) -> ItemT:
         return self.formatter.load(data)
@@ -315,56 +327,12 @@ class DefaultSqlTable(SqlTable[ItemT]):
     def exists(self, duplicate: ItemT) -> ExistsError:
         raw = self.formatter.dump(duplicate)
         return ExistsError(duplicate).with_duplicate(
-            lambda i: f"{self._id}<{raw[self._id]}>"
+            lambda i: f"{self.fields.id}<{raw[self.fields.id]}>"
         )
 
-    def _where_statement(self, include_id: bool = False) -> str:
-        result = next((field for field in self.fields if field.is_parent), None)
-        if result is None:
-            return f"WHERE [{self._id}] = %({self._id})s" if include_id else ""
-        else:
-            statement = "WHERE [" + result.name + "] = %(" + result.name + ")s"
-            if include_id:
-                statement += f" AND [{self._id}] = %({self._id})s"
-            return statement
-
-    def _data_with_fixed(self, data: dict[str, Any]) -> dict[str, Any]:
-        for field in self.fields:
-            if field.is_parent or field.is_fixed:
-                data[field.name] = field.fixed_value
-        return data
-
-    @property
-    def _id(self) -> str:
-        result = next((field for field in self.fields if field.is_id), None)
-        if result is None:
-            raise ValueError("Id field is required.")
-        return result.name
-
     @property
     def _user_check(self) -> str:
         if self.username is not None:
             return f"EXECUTE AS USER = '{self.username}'"
         else:
             return ""
-
-    @property
-    def _order(self) -> str:
-        ordering = [field.name for field in self.fields if field.is_ordered]
-        if len(ordering) > 0:
-            return "ORDER BY " + ", ".join(ordering)
-        else:
-            return ""
-
-
-@dataclass(frozen=True)
-class MsSqlField:
-    name: str
-    is_id: bool = False
-    is_ordered: bool = False
-    include_in_insert: bool = True
-
-    is_parent: bool = False
-
-    is_fixed: bool = False
-    fixed_value: Any | None = None

apexdevkit-1.17.10/apexdevkit/repository/sql.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Iterator
+
+
+@dataclass(frozen=True)
+class NotNone:
+    pass
+
+
+@dataclass(frozen=True)
+class _SqlField:
+    name: str
+    is_id: bool = False
+    is_ordered: bool = False
+    is_composite: bool = False
+    include_in_insert: bool = True
+
+    is_parent: bool = False
+    parent_value: Any | None = None
+
+    is_filter: bool = False
+    filter_value: Any | None | NotNone = None
+
+    is_fixed: bool = False
+    fixed_value: Any | None = None
+
+
+@dataclass
+class SqlFieldBuilder:
+    _name: str = field(init=False)
+    _is_id: bool = False
+    _is_ordered: bool = False
+    _is_composite: bool = False
+    _include_in_insert: bool = True
+
+    _is_parent: bool = False
+    _parent_value: Any | None = None
+
+    _is_filter: bool = False
+    _filter_value: Any | None | NotNone = None
+
+    _is_fixed: bool = False
+    _fixed_value: Any | None = None
+
+    def with_name(self, value: str) -> SqlFieldBuilder:
+        self._name = value
+
+        return self
+
+    def as_id(self) -> SqlFieldBuilder:
+        self._is_id = True
+
+        return self
+
+    def as_composite(self) -> SqlFieldBuilder:
+        self._is_composite = True
+
+        return self
+
+    def in_ordering(self) -> SqlFieldBuilder:
+        self._is_ordered = True
+
+        return self
+
+    def derive_on_insert(self) -> SqlFieldBuilder:
+        self._include_in_insert = False
+
+        return self
+
+    def as_parent(self, value: Any | None) -> SqlFieldBuilder:
+        self._is_parent = True
+        self._parent_value = value
+
+        return self
+
+    def as_filter(self, value: Any | None | NotNone) -> SqlFieldBuilder:
+        self._is_filter = True
+        self._filter_value = value
+
+        return self
+
+    def as_fixed(self, value: Any | None) -> SqlFieldBuilder:
+        self._is_fixed = True
+        self._fixed_value = value
+
+        return self
+
+    def build(self) -> _SqlField:
+        return _SqlField(
+            self._name,
+            self._is_id,
+            self._is_ordered,
+            self._is_composite,
+            self._include_in_insert,
+            self._is_parent,
+            self._parent_value,
+            self._is_filter,
+            self._filter_value,
+            self._is_fixed,
+            self._fixed_value,
+        )
+
+
+@dataclass
+class SqlFieldManager:
+    fields: list[_SqlField]
+    key_formatter: str
+    value_formatter: str
+
+    @property
+    def id(self) -> str:
+        result = next((key for key in self.fields if key.is_id), None)
+        if result is None:
+            raise ValueError("Id field is required.")
+        return result.name
+
+    @property
+    def composite(self) -> list[str]:
+        names = [key.name for key in self.fields if key.is_composite]
+        return [self.id] if len(names) == 0 else names
+
+    @property
+    def order(self) -> str:
+        ordering = [key.name for key in self.fields if key.is_ordered]
+        if len(ordering) > 0:
+            return "ORDER BY " + ", ".join(ordering)
+        else:
+            return ""
+
+    def __iter__(self) -> Iterator[_SqlField]:
+        yield from self.fields
+
+    def where_statement(self, include_id: bool = False) -> str:
+        statements = [
+            statement
+            for statement in [
+                self._parent_filter(),
+                self._id_filter(include_id),
+                self._general_filters(),
+            ]
+            if statement != ""
+        ]
+        if len(statements) > 0:
+            return "WHERE " + " AND ".join(statements)
+        else:
+            return ""
+
+    def with_fixed(self, data: dict[str, Any]) -> dict[str, Any]:
+        for key in self.fields:
+            if key.is_parent:
+                data[key.name] = key.parent_value
+            if key.is_fixed:
+                data[key.name] = key.fixed_value
+        return data
+
+    def _parent_filter(self) -> str:
+        result = next((key for key in self.fields if key.is_parent), None)
+        if result is not None:
+            if result.parent_value is None:
+                return self.key_formatter.replace("x", result.name) + " IS NULL"
+            else:
+                return (
+                    self.key_formatter.replace("x", result.name)
+                    + " = "
+                    + self.value_formatter.replace("x", result.name)
+                )
+        else:
+            return ""
+
+    def _id_filter(self, include_id: bool = False) -> str:
+        return (
+            self.key_formatter.replace("x", self.id)
+            + " = "
+            + self.value_formatter.replace("x", self.id)
+            if include_id
+            else ""
+        )
+
+    def _general_filters(self) -> str:
+        statements: list[str] = []
+        for key in self.fields:
+            if key.is_filter:
+                if key.filter_value is None:
+                    statements.append(
+                        self.key_formatter.replace("x", key.name) + " IS NULL"
+                    )
+                elif isinstance(key.filter_value, NotNone):
+                    statements.append(
+                        self.key_formatter.replace("x", key.name) + " IS NOT NULL"
+                    )
+                else:
+                    statements.append(
+                        self.key_formatter.replace("x", key.name)
+                        + " = "
+                        + self.value_formatter.replace("x", key.name)
+                    )
+
+        return " AND ".join(statements)
+
+    @dataclass
+    class Builder:
+        fields: list[_SqlField] = field(init=False)
+        key_formatter: str = field(init=False)
+        value_formatter: str = field(init=False)
+
+        def with_fields(self, fields: list[_SqlField]) -> SqlFieldManager.Builder:
+            self.fields = fields
+
+            return self
+
+        def for_sqlite(self) -> SqlFieldManager.Builder:
+            self.key_formatter = "x"
+            self.value_formatter = ":x"
+
+            return self
+
+        def for_mssql(self) -> SqlFieldManager.Builder:
+            self.key_formatter = "[x]"
+            self.value_formatter = "%(x)s"
+
+            return self
+
+        def build(self) -> SqlFieldManager:
+            return SqlFieldManager(
+                self.fields, self.key_formatter, self.value_formatter
+            )

{apexdevkit-1.17.9 → apexdevkit-1.17.10}/apexdevkit/repository/sqlite.py

@@ -8,6 +8,7 @@ from apexdevkit.error import DoesNotExistError, ExistsError
 from apexdevkit.formatter import Formatter
 from apexdevkit.repository import Database, DatabaseCommand, RepositoryBase
 from apexdevkit.repository.interface import ItemT
+from apexdevkit.repository.sql import NotNone, SqlFieldManager, _SqlField
 
 
 @dataclass(frozen=True)
@@ -102,7 +103,7 @@ class UnknownError(Exception):
 class SqliteTableBuilder(Generic[ItemT]):
     table_name: str | None = None
     formatter: Formatter[dict[str, Any], ItemT] | None = None
-    fields: list[SqliteField] | None = None
+    fields: list[_SqlField] | None = None
 
     def with_name(self, value: str) -> SqliteTableBuilder[ItemT]:
         return SqliteTableBuilder[ItemT](value, self.formatter, self.fields)
@@ -112,16 +113,27 @@ class SqliteTableBuilder(Generic[ItemT]):
     ) -> SqliteTableBuilder[ItemT]:
         return SqliteTableBuilder[ItemT](self.table_name, value, self.fields)
 
-    def with_fields(self, value: Iterable[SqliteField]) -> SqliteTableBuilder[ItemT]:
-        field_list = list(value)
-        if len([field for field in field_list if field.is_id]) != 1:
-            raise ValueError("Pass only one identifier field.")
-        if len([field for field in field_list if field.is_parent]) > 1:
-            raise ValueError("Pass only one parent field.")
+    def with_fields(self, value: Iterable[_SqlField]) -> SqliteTableBuilder[ItemT]:
+        key_list = list(value)
+        if len([key for key in key_list if key.is_id]) != 1:
+            raise ValueError("Pass only one identifier key.")
+        if len([key for key in key_list if key.is_parent]) > 1:
+            raise ValueError("Pass only one parent key.")
+        if (
+            len(
+                [
+                    key
+                    for key in key_list
+                    if not key.is_filter and isinstance(key.fixed_value, NotNone)
+                ]
+            )
+            > 0
+        ):
+            raise ValueError("Only filter fields can be 'not null'.")
         return SqliteTableBuilder[ItemT](
             self.table_name,
             self.formatter,
-            field_list,
+            key_list,
         )
 
     def build(self) -> SqlTable[ItemT]:
@@ -131,7 +143,7 @@ class SqliteTableBuilder(Generic[ItemT]):
         return _DefaultSqlTable(
             self.table_name,
             self.formatter,
-            self.fields,
+            SqlFieldManager.Builder().with_fields(self.fields).for_sqlite().build(),
         )
 
 
@@ -139,14 +151,14 @@ class SqliteTableBuilder(Generic[ItemT]):
 class _DefaultSqlTable(SqlTable[ItemT]):
     table_name: str
     formatter: Formatter[dict[str, Any], ItemT]
-    fields: list[SqliteField]
+    fields: SqlFieldManager
 
     def count_all(self) -> DatabaseCommand:
         return DatabaseCommand(f"""
             SELECT count(*) as n_items
             FROM {self.table_name.upper()}
-            {self._where_statement(include_id=False)};
-        """).with_data(self._data_with_fixed({}))
+            {self.fields.where_statement(include_id=False)};
+        """).with_data(self.fields.with_fixed({}))
 
     def insert(self, item: ItemT) -> DatabaseCommand:
         insert_columns = ", ".join(
@@ -164,7 +176,7 @@ class _DefaultSqlTable(SqlTable[ItemT]):
                 {placeholders}
             )
             RETURNING {return_columns};
-        """).with_data(self._data_with_fixed(self.formatter.dump(item)))
+        """).with_data(self.fields.with_fixed(self.formatter.dump(item)))
 
     def select(self, item_id: str) -> DatabaseCommand:
         columns = ", ".join([field.name for field in self.fields])
@@ -173,21 +185,23 @@ class _DefaultSqlTable(SqlTable[ItemT]):
             SELECT
                 {columns} 
             FROM {self.table_name.upper()}
-            {self._where_statement(include_id=True)};
-        """).with_data(self._data_with_fixed({self._id: item_id}))
+            {self.fields.where_statement(include_id=True)};
+        """).with_data(self.fields.with_fixed({self.fields.id: item_id}))
 
     def select_duplicate(self, item: ItemT) -> DatabaseCommand:
         raw = self.formatter.dump(item)
         columns = ", ".join([field.name for field in self.fields])
 
-        duplicates = " AND ".join([f"{field} = :{field}" for field in self._composite])
+        duplicates = " AND ".join(
+            [f"{field} = :{field}" for field in self.fields.composite]
+        )
 
         return DatabaseCommand(f"""
             SELECT
                 {columns} 
             FROM {self.table_name.upper()}
             WHERE {duplicates};
-        """).with_data({key: raw[key] for key in raw if key in self._composite})
+        """).with_data({key: raw[key] for key in raw if key in self.fields.composite})
 
     def select_all(self) -> DatabaseCommand:
         columns = ", ".join([field.name for field in self.fields])
@@ -196,8 +210,9 @@ class _DefaultSqlTable(SqlTable[ItemT]):
             SELECT
                 {columns}
             FROM {self.table_name.capitalize()}
-            {self._where_statement(include_id=False)};
-        """).with_data(self._data_with_fixed({}))
+            {self.fields.where_statement(include_id=False)}
+            {self.fields.order}
+        """).with_data(self.fields.with_fixed({}))
 
     def update(self, item: ItemT) -> DatabaseCommand:
         updates = ", ".join(
@@ -212,22 +227,22 @@ class _DefaultSqlTable(SqlTable[ItemT]):
             UPDATE {self.table_name.upper()}
             SET
                 {updates}
-            {self._where_statement(include_id=True)};
-        """).with_data(self._data_with_fixed(self.formatter.dump(item)))
+            {self.fields.where_statement(include_id=True)};
+        """).with_data(self.fields.with_fixed(self.formatter.dump(item)))
 
     def delete(self, item_id: str) -> DatabaseCommand:
         return DatabaseCommand(f"""
             DELETE
             FROM {self.table_name.upper()}
-            {self._where_statement(include_id=True)};
-        """).with_data(self._data_with_fixed({self._id: item_id}))
+            {self.fields.where_statement(include_id=True)};
+        """).with_data(self.fields.with_fixed({self.fields.id: item_id}))
 
     def delete_all(self) -> DatabaseCommand:
         return DatabaseCommand(f"""
             DELETE
             FROM {self.table_name.upper()}
-            {self._where_statement(include_id=False)};
-        """).with_data(self._data_with_fixed({}))
+            {self.fields.where_statement(include_id=False)};
+        """).with_data(self.fields.with_fixed({}))
 
     def load(self, data: dict[str, Any]) -> ItemT:
         return self.formatter.load(data)
@@ -236,47 +251,6 @@ class _DefaultSqlTable(SqlTable[ItemT]):
         raw = self.formatter.dump(item)
         return ExistsError(item).with_duplicate(
             lambda i: ",".join(
-                [f"{key}<{raw[key]}>" for key in raw if key in self._composite]
+                [f"{key}<{raw[key]}>" for key in raw if key in self.fields.composite]
             )
         )
-
-    def _where_statement(self, include_id: bool = False) -> str:
-        result = next((field for field in self.fields if field.is_parent), None)
-        if result is None:
-            return f"WHERE {self._id} = :{self._id}" if include_id else ""
-        else:
-            statement = "WHERE " + result.name + " = :" + result.name
-            if include_id:
-                statement += f" AND {self._id} = :{self._id}"
-            return statement
-
-    def _data_with_fixed(self, data: dict[str, Any]) -> dict[str, Any]:
-        for field in self.fields:
-            if field.is_parent or field.is_fixed:
-                data[field.name] = field.fixed_value
-        return data
-
-    @property
-    def _id(self) -> str:
-        result = next((field for field in self.fields if field.is_id), None)
-        if result is None:
-            raise ValueError("Id field is required.")
-        return result.name
-
-    @property
-    def _composite(self) -> list[str]:
-        names = [field.name for field in self.fields if field.is_composite]
-        return [self._id] if len(names) == 0 else names
-
-
-@dataclass(frozen=True)
-class SqliteField:
-    name: str
-    is_id: bool = False
-    is_composite: bool = False
-    include_in_insert: bool = True
-
-    is_parent: bool = False
-
-    is_fixed: bool = False
-    fixed_value: Any | None = None

{apexdevkit-1.17.9 → apexdevkit-1.17.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "apexdevkit"
-version = "1.17.9"
+version = "1.17.10"
 description = "Apex Development Tools for python."
 authors = ["Apex Dev <dev@apex.ge>"]
 readme = "README.md"