api-foundry-query-engine 0.0.1__py3-none-any.whl

api_foundry_query_engine/dao/operation_dao.py

@@ -0,0 +1,141 @@
+from typing import Union
+
+from api_foundry_query_engine.dao.sql_custom_query_handler import SQLCustomQueryHandler
+from api_foundry_query_engine.dao.sql_delete_query_handler import SQLDeleteSchemaQueryHandler
+from api_foundry_query_engine.dao.sql_insert_query_handler import SQLInsertSchemaQueryHandler
+from api_foundry_query_engine.dao.sql_select_query_handler import SQLSelectSchemaQueryHandler
+from api_foundry_query_engine.dao.sql_subselect_query_handler import SQLSubselectSchemaQueryHandler
+from api_foundry_query_engine.dao.sql_update_query_handler import SQLUpdateSchemaQueryHandler
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.dao.dao import DAO
+from api_foundry_query_engine.connectors.connection import Cursor
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.api_model import get_schema_object, get_path_operation
+from api_foundry_query_engine.dao.sql_query_handler import SQLQueryHandler
+
+
+class OperationDAO(DAO):
+    """
+    A class to handle database operations based on the provided
+    Operation object.
+
+    Attributes:
+        operation (Operation): The operation to perform.
+    """
+
+    def __init__(self, operation: Operation, engine: str) -> None:
+        """
+        Initialize the OperationDAO with the provided Operation object.
+
+        Args:
+            operation (Operation): The operation to perform.
+        """
+        super().__init__()
+        self.operation = operation
+        self.engine = engine
+
+    @property
+    def query_handler(self) -> SQLQueryHandler:
+        if not hasattr(self, "_query_handler"):
+            path_operation = get_path_operation(
+                self.operation.entity, self.operation.action
+            )
+            if path_operation:
+                self._query_handler = SQLCustomQueryHandler(
+                    self.operation, path_operation, self.engine
+                )
+                return self._query_handler
+
+            schema_object = get_schema_object(self.operation.entity)
+            if self.operation.action == "read":
+                self._query_handler = SQLSelectSchemaQueryHandler(
+                    self.operation, schema_object, self.engine
+                )
+            elif self.operation.action == "create":
+                self._query_handler = SQLInsertSchemaQueryHandler(
+                    self.operation, schema_object, self.engine
+                )
+            elif self.operation.action == "update":
+                self._query_handler = SQLUpdateSchemaQueryHandler(
+                    self.operation, schema_object, self.engine
+                )
+            elif self.operation.action == "delete":
+                self._query_handler = SQLDeleteSchemaQueryHandler(
+                    self.operation, schema_object, self.engine
+                )
+            else:
+                raise ApplicationException(
+                    400, f"Invalid operation action: {self.operation.action}"
+                )
+        return self._query_handler
+
+    def execute(self, cursor: Cursor) -> Union[list[dict], dict]:
+        """
+        Execute the database operation based on the provided cursor.
+
+        Args:
+            cursor (Cursor): The database cursor.
+
+        Returns:
+            list[dict]: A list of dictionaries containing the results
+            of the operation.
+        """
+
+        result = self.__fetch_record_set(self.query_handler, cursor)
+
+        if self.operation.action == "read":
+            if self.operation.metadata_params.get("count", False):
+                return result[0]
+            self.__fetch_many(result, cursor)
+        elif self.operation.action in ["update", "delete"] and len(result) == 0:
+            raise ApplicationException(400, "No records were modified")
+
+        return result
+
+    def __fetch_many(self, parent_set: list[dict], cursor: Cursor):
+        if "properties" not in self.operation.metadata_params:
+            return
+
+        schema_object = get_schema_object(self.operation.entity)
+        for name, relation in schema_object.relations.items():
+            if relation.type == "object":
+                continue
+
+            child_set = self.__fetch_record_set(
+                SQLSubselectSchemaQueryHandler(
+                    self.operation, relation, self.query_handler  # type: ignore
+                ),
+                cursor,
+            )
+            if len(child_set) == 0:
+                continue
+
+            for parent in parent_set:
+                parent[name] = []
+
+            parents = {}
+            for parent in parent_set:
+                parents[parent[relation.parent_property]] = parent
+
+            for child in child_set:
+                parent_id = child[relation.child_property]
+                parent = parents.get(parent_id)
+                if parent:
+                    parent[name].append(child)
+
+    def __fetch_record_set(
+        self, query_handler: SQLQueryHandler, cursor: Cursor
+    ) -> list[dict]:
+        sql = query_handler.sql
+        if not sql:
+            return []
+
+        record_set = cursor.execute(
+            sql, query_handler.placeholders, query_handler.selection_results
+        )
+        result = []
+        for record in record_set:
+            object = query_handler.marshal_record(record)
+            result.append(object)
+
+        return result

api_foundry_query_engine/dao/sql_custom_query_handler.py

@@ -0,0 +1,66 @@
+from typing import List, Dict
+import re
+
+from api_foundry_query_engine.dao.sql_query_handler import SQLQueryHandler
+from api_foundry_query_engine.utils.api_model import SchemaObjectProperty, PathOperation
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.utils.logger import logger
+
+log = logger(__name__)
+
+
+class SQLCustomQueryHandler(SQLQueryHandler):
+    def __init__(
+        self, operation: Operation, path_operation: PathOperation, engine: str
+    ) -> None:
+        super().__init__(operation, engine)
+        self.path_operation = path_operation
+
+    @property
+    def sql(self) -> str:
+        if not hasattr(self, "_sql"):
+            self._compile()
+        return self._sql
+
+    @property
+    def placeholders(self) -> Dict[str, SchemaObjectProperty]:
+        if not hasattr(self, "_placeholders"):
+            self._compile()
+        return self._placeholders
+
+    @property
+    def select_list_columns(self) -> List[SchemaObjectProperty]:
+        raise NotImplementedError()
+
+    def selection_result_map(self) -> Dict:
+        log.info(f"outputs: {self.path_operation.outputs}")
+        return self.path_operation.outputs
+
+    def _compile(self):
+        placeholder_pattern = re.compile(r":(\w+)")
+        self._placeholders = dict()
+        result_sql = placeholder_pattern.sub(
+            self._get_placeholder_text, self.path_operation.sql
+        )
+        self._sql = re.sub(r"\s+", " ", result_sql).strip()
+
+    def _get_placeholder_text(self, match) -> str:
+        placeholder_name = match.group(1)
+        property = self.path_operation.inputs.get(placeholder_name)
+        if not property:
+            raise ApplicationException(
+                500,
+                f"Input parameter not defined for the placeholder: {placeholder_name}",
+            )
+
+        value = (
+            self.operation.query_params[placeholder_name]
+            if placeholder_name in self.operation.query_params
+            else property.default
+        )
+        log.info(f"placeholder_name: {placeholder_name}")
+        log.info(f"value: {value}, default: {property.default}")
+        log.info(f"placeholders: {self.generate_placeholders(property, value)}")
+        self._placeholders.update(self.generate_placeholders(property, value))
+        return self.placeholder(property, placeholder_name)

api_foundry_query_engine/dao/sql_delete_query_handler.py

@@ -0,0 +1,36 @@
+from api_foundry_query_engine.dao.sql_query_handler import SQLSchemaQueryHandler
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.utils.api_model import SchemaObject
+
+
+class SQLDeleteSchemaQueryHandler(SQLSchemaQueryHandler):
+    def __init__(
+        self, operation: Operation, schema_object: SchemaObject, engine: str
+    ) -> None:
+        super().__init__(operation, schema_object, engine)
+
+    @property
+    def sql(self) -> str:
+        concurrency_property = self.schema_object.concurrency_property
+        if concurrency_property:
+            if not self.operation.query_params.get(concurrency_property.api_name):
+                raise ApplicationException(
+                    400,
+                    "Missing required concurrency management property.  "
+                    + f"schema_object: {self.schema_object.api_name}, "
+                    + f"property: {concurrency_property.api_name}",
+                )
+            if self.operation.store_params.get(concurrency_property.api_name):
+                raise ApplicationException(
+                    400,
+                    "For updating concurrency managed schema objects the current "
+                    + "version may not be supplied as a storage parameter.  "
+                    + f"schema_object: {self.schema_object.api_name}, "
+                    + f"property: {concurrency_property.api_name}",
+                )
+
+        return (
+            f"DELETE FROM {self.table_expression}{self.search_condition} "
+            + f"RETURNING {self.select_list}"
+        )

api_foundry_query_engine/dao/sql_insert_query_handler.py

@@ -0,0 +1,102 @@
+from typing import Optional
+from api_foundry_query_engine.dao.sql_query_handler import SQLSchemaQueryHandler
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.utils.api_model import SchemaObject, SchemaObjectProperty
+
+
+class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
+    key_property: Optional[SchemaObjectProperty]
+
+    def __init__(
+        self, operation: Operation, schema_object: SchemaObject, engine: str
+    ) -> None:
+        super().__init__(operation, schema_object, engine)
+        self.key_property = schema_object.primary_key
+        if self.key_property:
+            if self.key_property.key_type == "auto":
+                if operation.store_params.get(self.key_property.column_name):
+                    raise ApplicationException(
+                        400,
+                        "Primary key values cannot be inserted when key type"
+                        + f" is auto. schema_object: {schema_object.api_name}",
+                    )
+            elif self.key_property.key_type == "required":
+                if not operation.store_params.get(self.key_property.column_name):
+                    raise ApplicationException(
+                        400,
+                        "Primary key values must be provided when key type is"
+                        + f" required. schema_object: {schema_object.api_name}",
+                    )
+        self.concurrency_property = schema_object.concurrency_property
+        if self.concurrency_property and operation.store_params.get(
+            self.concurrency_property.api_name
+        ):
+            raise ApplicationException(
+                400,
+                "Versioned properties can not be supplied a store parameters. "
+                + f"schema_object: {schema_object.api_name}, "
+                + f"property: {self.concurrency_property.api_name}",
+            )
+
+    @property
+    def sql(self) -> str:
+        self.concurrency_property = self.schema_object.concurrency_property
+        if not self.concurrency_property:
+            return (
+                f"INSERT INTO {self.table_expression}{self.insert_values} "
+                + f"RETURNING {self.select_list}"
+            )
+
+        if self.operation.store_params.get(self.concurrency_property.api_name):
+            raise ApplicationException(
+                400,
+                "When inserting schema objects with a version property "
+                + "the a version must not be supplied as a storage parameter."
+                + f"  schema_object: {self.schema_object.api_name}, "
+                + f"property: {self.concurrency_property.api_name}",
+            )
+        return (
+            f"INSERT INTO {self.table_expression}{self.insert_values}"
+            + f" RETURNING {self.select_list}"
+        )
+
+    @property
+    def insert_values(self) -> str:
+        self.store_placeholders = {}
+        placeholders = []
+        columns = []
+
+        for name, value in self.operation.store_params.items():
+            parts = name.split(".")
+
+            try:
+                if len(parts) > 1:
+                    raise ApplicationException(
+                        400,
+                        "Properties can not be set on associated objects " + name,
+                    )
+
+                property = self.schema_object.properties[parts[0]]
+            except KeyError:
+                raise ApplicationException(400, f"Invalid property: {name}")
+
+            columns.append(property.column_name)
+            placeholders.append(self.placeholder(property, property.api_name))
+            self.store_placeholders[property.api_name] = property.convert_to_db_value(value)
+
+        if self.key_property:
+            if self.key_property.key_type == "sequence":
+                columns.append(self.key_property.column_name)
+                placeholders.append(f"nextval('{self.key_property.sequence_name}')")
+
+        if self.concurrency_property:
+            columns.append(self.concurrency_property.column_name)
+            if self.concurrency_property.column_type == "integer":
+                placeholders.append("1")
+            else:
+                placeholders.append(
+                    self.concurrency_generator(self.concurrency_property)
+                )
+
+        return f" ( {', '.join(columns)} ) VALUES ( {', '.join(placeholders)})"