sql_fusion 1.0.0__py3-none-any.whl

sql_fusion/operators.py

@@ -0,0 +1,119 @@
+from typing import Any, Callable
+
+OPERATORS: dict[str, type[AbstractOperator]] = {}
+
+
+class AbstractOperator:
+    sql_symbol: str = ""
+
+    def __init__(self, col_ref: str) -> None:
+        self._col_ref: str = col_ref
+
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        raise NotImplementedError()
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        raise NotImplementedError()
+
+
+def register_operator(
+    symbol: str,
+) -> Callable[[type[AbstractOperator]], type[AbstractOperator]]:
+    def decorator(cls: type[AbstractOperator]) -> type[AbstractOperator]:
+        OPERATORS[symbol] = cls
+        cls.sql_symbol = symbol
+        return cls
+
+    return decorator
+
+
+@register_operator("=")
+class EqualOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} = ?", (value,)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} = {value_ref}", tuple()
+
+
+@register_operator("!=")
+class NotEqualOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} != ?", (value,)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} != {value_ref}", tuple()
+
+
+@register_operator("<")
+class LessThanOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} < ?", (value,)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} < {value_ref}", tuple()
+
+
+@register_operator(">")
+class GreaterThanOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} > ?", (value,)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} > {value_ref}", tuple()
+
+
+@register_operator("<=")
+class LessThanOrEqualOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} <= ?", (value,)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} <= {value_ref}", tuple()
+
+
+@register_operator(">=")
+class GreaterThanOrEqualOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} >= ?", (value,)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} >= {value_ref}", tuple()
+
+
+@register_operator("LIKE")
+class LikeOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} LIKE ?", (value,)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} LIKE {value_ref}", tuple()
+
+
+@register_operator("ILIKE")
+class IlikeOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} ILIKE ?", (value,)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} ILIKE {value_ref}", tuple()
+
+
+@register_operator("IN")
+class InOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        placeholders: str = ", ".join("?" * len(value))
+        return f"{self._col_ref} IN ({placeholders})", tuple(value)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} IN ({value_ref})", tuple()
+
+
+@register_operator("NOT IN")
+class NotInOperator(AbstractOperator):
+    def to_sql(self, value: Any) -> tuple[str, tuple[Any, ...]]:
+        placeholders: str = ", ".join("?" * len(value))
+        return f"{self._col_ref} NOT IN ({placeholders})", tuple(value)
+
+    def to_sql_ref(self, value_ref: str) -> tuple[str, tuple[Any, ...]]:
+        return f"{self._col_ref} NOT IN ({value_ref})", tuple()

sql_fusion/query/delete.py

@@ -0,0 +1,84 @@
+from copy import copy
+from typing import Any, Self
+
+from sql_fusion.composite_table import (
+    AbstractQuery,
+    AliasRegistry,
+    Column,
+    FunctionCall,
+    Table,
+)
+
+
+class delete(AbstractQuery):
+    def __init__(self, table: Table | None = None) -> None:
+        super().__init__(table=table, columns=())
+        self._returning_columns: tuple[Column | FunctionCall, ...] = ()
+        self._returning_all: bool = False
+
+    def returning(self, *columns: Column | FunctionCall) -> Self:
+        if not columns:
+            self._returning_all = True
+            self._returning_columns = ()
+            return self
+
+        if not self._returning_all:
+            self._returning_columns += columns
+
+        return self
+
+    def build_query(
+        self,
+        alias_registry: AliasRegistry | None = None,
+    ) -> tuple[str, tuple[Any, ...]]:
+        registry = alias_registry or self._alias_registry
+        table = self._get_table()
+        alias = registry.get_alias_for_table(table)
+        with_sql, with_params = self._build_with_clause(registry)
+        from_clause = self._build_clause(
+            "FROM",
+            "FROM",
+            f'"{table.get_name()}" AS "{alias.name}"',
+        )
+        query = self._build_clause("DELETE", "DELETE", from_clause)
+        params: list[Any] = list(with_params)
+
+        if self._where_condition:
+            where_sql, where_params = self._where_condition.to_sql(registry)
+            query += f" {self._build_clause('WHERE', 'WHERE', where_sql)}"
+            params.extend(where_params)
+
+        if self._returning_all:
+            query += f" {self._build_clause('RETURNING', 'RETURNING', '*')}"
+            return self._apply_compile_expressions(
+                f"{with_sql} {query}" if with_sql else query,
+                tuple(params),
+            )
+
+        if self._returning_columns:
+            returning_parts: list[str] = []
+
+            for col in self._returning_columns:
+                if isinstance(col, FunctionCall):
+                    func_sql, func_params = col.to_sql(registry)
+                    returning_parts.append(func_sql)
+                    params.extend(func_params)
+                else:
+                    alias = registry.get_alias_for_table(col.table)
+                    returning_parts.append(f'"{alias.name}"."{col.name}"')
+
+            query += " " + self._build_clause(
+                "RETURNING",
+                "RETURNING",
+                ", ".join(returning_parts),
+            )
+
+        return self._apply_compile_expressions(
+            f"{with_sql} {query}" if with_sql else query,
+            tuple(params),
+        )
+
+    def from_(self, table: Table | AbstractQuery) -> Self:
+        qs = copy(self)
+        qs._table = table if isinstance(table, Table) else Table(table)
+        return qs

sql_fusion/query/insert.py

@@ -0,0 +1,72 @@
+from typing import Any, Self
+
+from sql_fusion.composite_table import AbstractQuery, AliasRegistry, Table
+
+
+class insert(AbstractQuery):
+    def __init__(
+        self,
+        table: Table,
+        *,
+        or_replace: bool = False,
+        or_ignore: bool = False,
+    ) -> None:
+        super().__init__(table=table, columns=())
+        self._values: dict[str, Any] = {}
+        self._or_replace: bool = or_replace
+        self._or_ignore: bool = or_ignore
+
+    def values(self, **values: Any) -> Self:
+        if not values:
+            raise ValueError("No values provided for insert")
+        self._values.update(values)
+        return self
+
+    def build_query(
+        self,
+        alias_registry: AliasRegistry | None = None,
+    ) -> tuple[str, tuple[Any, ...]]:
+        if not self._values:
+            raise ValueError("No values provided for insert")
+        registry = alias_registry or self._alias_registry
+        table = self._get_table()
+        with_sql, with_params = self._build_with_clause(registry)
+
+        columns = list(self._values.keys())
+        col_names = ", ".join(f'"{col}"' for col in columns)
+        placeholders = ", ".join("?" * len(columns))
+        params = tuple(self._values[col] for col in columns)
+
+        insert_stmnt = "INSERT"
+
+        if self._or_replace and self._or_ignore:
+            raise ValueError("Cannot use both or_replace and or_ignore")
+        if self._or_replace:
+            insert_stmnt += " OR REPLACE"
+        elif self._or_ignore:
+            insert_stmnt += " OR IGNORE"
+
+        into_clause = self._build_clause(
+            "INTO",
+            "INTO",
+            f'"{table.get_name()}" ({col_names})',
+        )
+        values_clause = self._build_clause(
+            "VALUES",
+            "VALUES",
+            f"({placeholders})",
+        )
+        query = self._build_clause(
+            "INSERT",
+            insert_stmnt,
+            f"{into_clause} {values_clause}",
+        )
+
+        query_parts = [query]
+        if with_sql:
+            query_parts.insert(0, with_sql)
+
+        return self._apply_compile_expressions(
+            " ".join(query_parts),
+            tuple(with_params) + params,
+        )