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

api_foundry_query_engine/dao/sql_query_handler.py

@@ -0,0 +1,386 @@
+import re
+from typing import Optional, List, Dict
+from datetime import datetime, date
+
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.api_model import SchemaObject, SchemaObjectProperty
+from api_foundry_query_engine.utils.logger import logger
+
+log = logger(__name__)
+
+SQL_RESERVED_WORDS = {
+    "select",
+    "from",
+    "where",
+    "insert",
+    "update",
+    "delete",
+    "join",
+    "on",
+    "order",
+    "group",
+    "having",
+    "union",
+    "distinct",
+    "into",
+    "as",
+    "and",
+    "or",
+    "not",
+    "in",
+    "is",
+    "null",
+    "like",
+    "between",
+    "by",
+    "case",
+    "when",
+    "then",
+    "else",
+    "end",
+    "exists",
+    "all",
+    "any",
+    "some",
+    "limit",
+    "offset",
+    "fetch",
+    "for",
+    "create",
+    "alter",
+    "drop",
+    "table",
+    "index",
+    "view",
+    "trigger",
+    "procedure",
+    "function",
+    "database",
+    "schema",
+    "grant",
+    "revoke",
+    "primary",
+    "key",
+    "foreign",
+    "references",
+    "check",
+    "unique",
+    "default",
+    "with",
+    "values",
+    "set",
+    "transaction",
+    "commit",
+    "rollback",
+    "savepoint",
+    "lock",
+    "tablespace",
+    "sequence",
+    "if",
+    "else",
+    "elsif",
+    "loop",
+    "begin",
+    "declare",
+    "end",
+    "open",
+    "fetch",
+    "close",
+    "cursor",
+    "next",
+}
+
+RELATIONAL_TYPES = {
+    "lt": "<",
+    "le": "<=",
+    "eq": "=",
+    "ge": ">=",
+    "gt": ">",
+    "in": "in",
+    "not-in": "not-in",
+    "between": "between",
+    "not-between": "not-between",
+}
+
+
+class SQLQueryHandler:
+    operation: Operation
+    engine: str
+
+    def __init__(self, operation: Operation, engine: str):
+        self.operation = operation
+        self.__select_list_columns = None
+        self.engine = engine
+
+    @property
+    def sql(self) -> str:
+        raise NotImplementedError("Subclasses must implement this method")
+
+    @property
+    def placeholders(self) -> Dict[str, SchemaObjectProperty]:
+        raise NotImplementedError("Subclasses must implement this method")
+
+    @property
+    def select_list_columns(self) -> List[str]:
+        if not self.__select_list_columns:
+            self.__select_list_columns = list(self.selection_results.keys())
+        return self.__select_list_columns
+
+    def marshal_record(self, record: dict) -> dict:
+        result = {}
+        for name, value in record.items():
+            property = self.selection_results[name]
+            result[property.api_name] = property.convert_to_api_value(value)
+        return result
+
+    def placeholder(self, property: SchemaObjectProperty, param: str = "") -> str:
+        if len(param) == 0:
+            param = property.api_name
+
+        if self.engine == "oracle":
+            if property.column_type == "date":
+                return f"TO_DATE(:{param}, 'YYYY-MM-DD')"
+            elif property.column_type == "datetime":
+                return f"TO_TIMESTAMP(:{param}, 'YYYY-MM-DD\"T\"HH24:MI:SS.FF')"
+            elif property.column_type == "time":
+                return f"TO_TIME(:{param}, 'HH24:MI:SS.FF')"
+            return f":{param}"
+        return f"%({param})s"
+
+    def generate_sql_condition(
+        self, property: SchemaObjectProperty, value, prefix: Optional[str] = None
+    ) -> str:
+        operand = "="
+
+        if isinstance(value, str):
+            parts = value.split("::", 1)
+            operand = RELATIONAL_TYPES.get(parts[0], "=") if len(parts) > 1 else "="
+            value_str = parts[-1]
+        elif isinstance(value, (datetime, date)):
+            value_str = value.isoformat()
+        else:
+            value_str = str(value)
+
+        column = f"{prefix}.{property.column_name}" if prefix else property.column_name
+        placeholder_name = (
+            f"{prefix}_{property.api_name}" if prefix else property.api_name
+        )
+
+        if operand in ["between", "not-between"]:
+            value_set = value_str.split(",")
+            sql = f"{column} {'NOT ' if operand == 'not-between' else ''}BETWEEN {self.placeholder(property, f'{placeholder_name}_1')} AND {self.placeholder(property, f'{prefix}_{property.api_name}_2')}"  # noqa E501
+        elif operand in ["in", "not-in"]:
+            value_set = value_str.split(",")
+            assignments = [
+                self.placeholder(property, f"{placeholder_name}_{index}")
+                for index, _ in enumerate(value_set)
+            ]
+            sql = f"{column} {'NOT ' if operand == 'not-in' else ''}IN ({', '.join(assignments)})"  # noqa E501
+        else:
+            sql = f"{column} {operand} {self.placeholder(property, placeholder_name)}"
+        return sql
+
+    def generate_placeholders(
+        self, property: SchemaObjectProperty, value, prefix: Optional[str] = None
+    ) -> dict:
+        operand = "="
+
+        if isinstance(value, str):
+            parts = value.split("::", 1)
+            operand = RELATIONAL_TYPES.get(parts[0], "=") if len(parts) > 1 else "="
+            value_str = parts[-1]
+        elif isinstance(value, (datetime, date)):
+            value_str = value.isoformat()
+        else:
+            value_str = str(value)
+
+        placeholder_name = (
+            f"{prefix}_{property.api_name}" if prefix else property.api_name
+        )
+        placeholders = {}
+
+        if operand in ["between", "not-between"]:
+            value_set = value_str.split(",")
+            placeholders = {
+                f"{placeholder_name}_1": property.convert_to_db_value(value_set[0]),
+                f"{placeholder_name}_2": property.convert_to_db_value(value_set[1]),
+            }
+        elif operand in ["in", "not-in"]:
+            value_set = value_str.split(",")
+            for index, item in enumerate(value_set):
+                item_name = f"{placeholder_name}_{index}"
+                placeholders[item_name] = property.convert_to_db_value(item)
+        else:
+            placeholders = {placeholder_name: property.convert_to_db_value(value_str)}
+
+        return placeholders
+
+    def search_value_assignment(
+        self, property: SchemaObjectProperty, value, prefix: Optional[str] = None
+    ) -> tuple[str, dict]:
+        sql_condition = self.generate_sql_condition(property, value, prefix)
+        placeholders = self.generate_placeholders(property, value, prefix)
+        return sql_condition, placeholders
+
+    @property
+    def selection_results(self) -> Dict:
+        if not hasattr(self, "_selection_results"):
+            self._selection_results = self.selection_result_map()
+        return self._selection_results
+
+    def selection_result_map(self) -> Dict:
+        raise NotImplementedError()
+
+
+class SQLSchemaQueryHandler(SQLQueryHandler):
+    schema_object: SchemaObject
+
+    def __init__(
+        self, operation: Operation, schema_object: SchemaObject, engine: str
+    ) -> None:
+        super().__init__(operation, engine)
+        self.schema_object = schema_object
+        self.single_table = self.__single_table()
+        self.__select_list = None
+        self.__selection_result_map = None
+        self.search_placeholders = dict()
+        self.store_placeholders = dict()
+        self.active_prefixes = set()
+
+    @property
+    def sql(self) -> str:
+        raise NotImplementedError("Subclasses should implement this method")
+
+    @property
+    def placeholders(self) -> dict:
+        return {**self.search_placeholders, **self.store_placeholders}
+
+    @property
+    def prefix_map(self) -> Dict[str, str]:
+        if not hasattr(self, "_prefix_map"):
+            self._prefix_map = {}
+            for entity in [
+                self.schema_object.api_name,
+                *self.schema_object.relations.keys(),
+            ]:
+                entity_lower = entity.lower()
+                for i in range(1, len(entity_lower) + 1):
+                    substring = entity_lower[:i]
+                    if (
+                        substring not in self._prefix_map.values()
+                        and substring not in SQL_RESERVED_WORDS
+                    ):
+                        self._prefix_map[entity] = substring
+                        break
+        return self._prefix_map
+
+    def __single_table(self) -> bool:
+        if len(self.prefix_map) == 1 or self.operation.action == "create":
+            return True
+        if ":" in self.operation.metadata_params.get("properties", ""):
+            return False
+        for param in self.operation.query_params.keys():
+            if "." in param:
+                return False
+        return True
+
+    @property
+    def select_list(self) -> str:
+        if not self.__select_list:
+            self.__select_list = ", ".join(self.select_list_columns)
+        return self.__select_list
+
+    @property
+    def table_expression(self) -> str:
+        return self.schema_object.table_name
+
+    @property
+    def search_condition(self) -> str:
+        self.search_placeholders = {}
+        conditions = []
+        for name, value in self.operation.query_params.items():
+            if "." in name:
+                raise ApplicationException(
+                    400, "Selection on relations is not supported"
+                )
+            property = self.schema_object.properties.get(name)
+            if not property:
+                raise ApplicationException(
+                    500, f"Search condition column not found {name}"
+                )
+            if (
+                self.operation.action != "read"
+                and isinstance(value, str)
+                and re.match(
+                    r"^(lt|le|eq|ne|gt|ge|in|not-in|between|not-between)::(.+)$", value
+                )
+                and self.schema_object.concurrency_property
+            ):
+                raise ApplicationException(
+                    400,
+                    "Concurrency settings prohibit multi-record updates "
+                    + self.schema_object.api_name
+                    + ", property: "
+                    + property.api_name,
+                )
+
+            assignment, holders = self.search_value_assignment(property, value)
+            conditions.append(assignment)
+            self.search_placeholders.update(holders)
+        return f" WHERE {' AND '.join(conditions)}" if conditions else ""
+
+    def selection_result_map(self) -> dict:
+        if not self.__selection_result_map:
+            filters = self.operation.metadata_params.get("_properties", ".*").split()
+            self.__selection_result_map = self.filter_and_prefix_keys(
+                filters, self.schema_object.properties
+            )
+        return self.__selection_result_map
+
+    def filter_and_prefix_keys(
+        self, regex_list: List[str], properties: dict, prefix: Optional[str] = None
+    ) -> dict:
+        """
+        Accepts a prefix string, list of regular expressions, and a dictionary.
+        Returns a new dictionary containing items whose keys match any of the
+        regular expressions, with the prefix string prepended to the key
+        values of the dictionary.
+
+        Parameters:
+        - prefix (str): The prefix string to prepend to the key values.
+        - regex_list (list of str): The list of regular expression patterns
+                to match keys.
+        - properties (dict): The input properties.
+
+        Returns:
+        - dict: A new dictionary containing filtered items with modified key values.
+        """
+        filtered_dict = {}
+        compiled_regexes = [re.compile(regex) for regex in regex_list]
+        for key, value in properties.items():
+            for pattern in compiled_regexes:
+                if pattern.match(key):
+                    filtered_dict[f"{prefix}.{key}" if prefix else key] = value
+                    self.active_prefixes.add(prefix)
+                    break
+        return filtered_dict
+
+    def concurrency_generator(self, property: SchemaObjectProperty) -> str:
+        if property.api_type == "date-time":
+            return "CURRENT_TIMESTAMP"
+        elif property.api_type == "integer":
+            return f"{property.column_name} + 1"
+        elif property.api_type in ["string", "uuid"]:
+            if self.engine == "oracle":
+                return "SYS_GUID()"
+            if self.engine == "mysql":
+                return "UUID()"
+            return "gen_random_uuid()"
+        raise ApplicationException(
+            500,
+            (
+                "Concurrency control property is unrecognized type"
+                + f"name: {property.api_name}, type: {property.api_type}"
+            ),
+        )

api_foundry_query_engine/dao/sql_select_query_handler.py

@@ -0,0 +1,305 @@
+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
+)
+from api_foundry.utils.logger import logger
+
+log = logger(__name__)
+
+
+class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
+    def __init__(
+        self, operation: Operation, schema_object: SchemaObject, engine: str
+    ) -> None:
+        super().__init__(operation, schema_object, engine)
+
+    @property
+    def sql(self) -> str:
+        # order is important here table_expression must be last
+        search_condition = self.search_condition
+        order_by_expression = self.order_by_expression
+        select_list = self.select_list
+        table_expression = self.table_expression
+
+        return (
+            f"SELECT {select_list}"
+            + f" FROM {table_expression}"
+            + search_condition
+            + order_by_expression
+            + self.limit_expression
+            + self.offset_expression
+        )
+
+    @property
+    def select_list(self) -> str:
+        if self.operation.metadata_params.get("count", False):
+            return "count(*)"
+        return super().select_list
+
+    @property
+    def search_condition(self) -> str:
+        self.search_placeholders = {}
+        conditions = []
+
+        for name, value in self.operation.query_params.items():
+            parts = name.split(".")
+
+            try:
+                if len(parts) > 1:
+                    if parts[0] not in self.schema_object.relations:
+                        raise ApplicationException(
+                            400,
+                            "Invalid selection property "
+                            + self.schema_object.api_name
+                            + " does not have a property "
+                            + parts[0],
+                        )
+                    relation = self.schema_object.relations[parts[0]]
+                    if parts[1] not in relation.child_schema_object.properties:
+                        raise ApplicationException(
+                            400,
+                            "Property not found, "
+                            + relation.child_schema_object.api_name
+                            + " does not have property "
+                            + parts[1],
+                        )
+                    property = relation.child_schema_object.properties[parts[1]]
+                    prefix = self.prefix_map[parts[0]]
+                else:
+                    property = self.schema_object.properties[parts[0]]
+                    prefix = self.prefix_map[self.schema_object.api_name]
+            except KeyError:
+                raise ApplicationException(
+                    500,
+                    (
+                        "Invalid query parameter, property not found. "
+                        + "schema object: "
+                        + self.schema_object.api_name
+                        + ", property: "
+                        + name
+                    ),
+                )
+
+            assignment, holders = self.search_value_assignment(property, value, prefix)
+            self.active_prefixes.add(prefix)
+            conditions.append(assignment)
+            self.search_placeholders.update(holders)
+
+        return f" WHERE {' AND '.join(conditions)}" if len(conditions) > 0 else ""
+
+    @property
+    def table_expression(self) -> str:
+        joins = []
+        parent_prefix = self.prefix_map[self.schema_object.api_name]
+        for name, relation in self.schema_object.relations.items():
+            child_prefix = self.prefix_map[relation.api_name]
+            if child_prefix in self.active_prefixes:
+                joins.append(
+                    "INNER JOIN "
+                    + relation.child_schema_object.table_name
+                    + " AS "
+                    + child_prefix
+                    + " ON "
+                    + parent_prefix
+                    + "."
+                    + relation.parent_property
+                    + " = "
+                    + child_prefix
+                    + "."
+                    + relation.child_property
+                )
+
+        return (
+            self.schema_object.table_name
+            + " AS "
+            + self.prefix_map[self.schema_object.api_name]
+            + (f" {' '.join(joins)}" if len(joins) > 0 else "")
+        )
+
+    def selection_result_map(self) -> dict:
+        if "count" in self.operation.metadata_params:
+            self._selection_results = {
+                "count": SchemaObjectProperty( {
+                    "api_name": "count",
+                    "api_type": "integer",
+                    "column_name": "count(*)",
+                    "column_type": "integer"
+                } )
+            }
+            return self._selection_results
+
+        filter_str = self.operation.metadata_params.get("properties", ".*")
+        self._selection_results = {}
+
+        for relation, reg_exs in self.get_regex_map(filter_str).items():
+            # Extract the schema object for the current entity
+            relation_property = self.schema_object.relations.get(relation)
+
+            if relation_property:
+                if relation_property.type == "array":
+                    continue
+
+                # Use a default value if relation_property is None
+                schema_object = relation_property.child_schema_object
+            else:
+                schema_object = self.schema_object
+
+            if relation not in self.prefix_map:
+                raise ApplicationException(
+                    400,
+                    "Bad object association: "
+                    + schema_object.api_name
+                    + " does not have a "
+                    + relation
+                    + " property",
+                )
+            # Filter and prefix keys for the current entity
+            # and regular expressions
+            filtered_keys = self.filter_and_prefix_keys(
+                reg_exs, schema_object.properties, self.prefix_map[relation]
+            )
+
+            # Extend the result map with the filtered keys
+            self._selection_results.update(filtered_keys)
+
+        return self._selection_results
+
+    def get_regex_map(self, filter_str: str) -> dict[str, list]:
+        result = {}
+
+        for filter in filter_str.split():
+            parts = filter.split(":")
+            entity = parts[0] if len(parts) > 1 else self.schema_object.api_name
+            expression = parts[-1]
+
+            # Check if entity already exists in result, if not, initialize
+            # it with an empty list
+            if entity not in result:
+                result[entity] = []
+
+            # Append the expression to the list of expressions for the entity
+            result[entity].append(expression)
+
+        return result
+
+    def marshal_record(self, record) -> dict:
+        object_set = {}
+        for name, value in record.items():
+            property = self.selection_results[name]
+            parts = name.split(".")
+            component = parts[0] if len(parts) > 1 else self.prefix_map[self.schema_object.api_name]
+            object = object_set.get(component, {})
+            if not object:
+                object_set[component] = object
+            object[property.api_name] = property.convert_to_api_value(value)
+
+        result = object_set[self.prefix_map[self.schema_object.api_name]]
+        for name, prefix in self.prefix_map.items():
+            if name != self.schema_object.api_name and prefix in object_set:
+                result[name] = object_set[prefix]
+
+        return result
+
+    @property
+    def order_by_expression(self) -> str:
+        fields_str = self.operation.metadata_params.get("sort", None)
+        if not fields_str:
+            return ""
+
+        # determine the columns requested
+        fields = fields_str.replace(",", " ").split()
+
+        order_set = []
+        use_prefixes = False
+        for field in fields:
+            # handle order
+            field_parts = field.split(":")
+            field_name = field_parts[0]
+
+            order = "asc" if len(field_parts) == 1 else field_parts[1]
+            if order != "desc" and order != "asc":
+                raise ApplicationException(400, f"unrecognized sorting order: {field}")
+
+            # handle entity prefix
+            field_parts = field_name.split(".")
+            if len(field_parts) == 1:
+                prefix = self.prefix_map[self.schema_object.api_name]
+                property = self.schema_object.properties.get(field_parts[0])
+                if not property:
+                    raise ApplicationException(
+                        400,
+                        f"Invalid order by property, schema object: {self.schema_object.api_name} does not have a property: {field_parts[0]}",  # noqa E501
+                    )
+                column = property.column_name
+            else:
+                # Extract the schema object for the current entity
+                relation_property = self.schema_object.relations.get(field_parts[0])
+                if not relation_property:
+                    raise ApplicationException(
+                        400,
+                        f"Invalid order by property, schema object: {self.schema_object.api_name} does not have a property: {field_parts[0]}",  # noqa E501
+                    )
+
+                if relation_property:
+                    if relation_property.type == "array":
+                        raise ApplicationException(
+                            400,
+                            f"Invalid order by array property is not supported, schema object: {self.schema_object.api_name} property: {field_parts[0]}",  # noqa E501
+                        )
+
+                    # Use a default value if relation_property is None
+                    schema_object = relation_property.child_schema_object
+                else:
+                    schema_object = self.schema_object
+
+                prefix = self.prefix_map[field_parts[0]]
+                property = schema_object.properties.get(field_parts[1])
+                if not property:
+                    raise ApplicationException(
+                        400,
+                        f"Invalid order by property, schema object: {schema_object.api_name} does not have a property: {field_parts[1]}",  # noqa E501
+                    )
+                column = property.column_name
+                self.active_prefixes.add(prefix)
+                use_prefixes = True
+
+            order_set.append((prefix, column, order))
+
+        if len(order_set) == 0:
+            return ""
+        order_parts = []
+        for prefix, column, order in order_set:
+            if use_prefixes:
+                order_parts.append(f"{prefix}.{column} {order}")
+            else:
+                order_parts.append(f"{column} {order}")
+        return " ORDER BY " + ", ".join(order_parts)
+
+    @property
+    def limit_expression(self) -> str:
+        limit_str = self.operation.metadata_params.get("limit", None)
+        if not limit_str:
+            return ""
+
+        if isinstance(limit_str, str) and not limit_str.isdigit():
+            raise ApplicationException(
+                400, f"Limit is not an valid integer {limit_str}"
+            )
+
+        return f" LIMIT {limit_str}"
+
+    @property
+    def offset_expression(self) -> str:
+        offset_str = self.operation.metadata_params.get("offset", None)
+        if not offset_str:
+            return ""
+
+        if isinstance(offset_str, str) and not offset_str.isdigit():
+            raise ApplicationException(
+                400, f"Offset is not an valid integer {offset_str}"
+            )
+
+        return f" offset {offset_str}"