sql_fusion 1.1.0__tar.gz → 1.2.0__tar.gz

{sql_fusion-1.1.0 → sql_fusion-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sql_fusion
-Version: 1.1.0
+Version: 1.2.0
 Summary: Python query builder with a focus on composability and reusability.
 Author: Mastermind-U
 Author-email: Mastermind-U <rex49513@gmail.com>
@@ -77,6 +77,7 @@ In short, the goal is to keep the ergonomics of a lightweight builder while stil
 - automatic table aliases
 - composable conditions with `AND`, `OR`, and `NOT`
 - joins, subqueries, and CTEs
+- set operations with `UNION`, `INTERSECT`, and `EXCEPT`
 - ordering and grouping with `GROUP BY`, `ROLLUP`, `CUBE`, and `GROUPING SETS`
 - aggregate and custom SQL functions through `func`
 - backend-specific SQL rewrites through compile expressions
@@ -113,10 +114,13 @@ from sql_fusion import (
     Column,
     Table,
     delete,
+    except_,
     func,
     insert,
+    intersect,
     select,
-    text,
+    union,
+    text_op,
     update,
 )
 ```

{sql_fusion-1.1.0 → sql_fusion-1.2.0}/README.md

@@ -63,6 +63,7 @@ In short, the goal is to keep the ergonomics of a lightweight builder while stil
 - automatic table aliases
 - composable conditions with `AND`, `OR`, and `NOT`
 - joins, subqueries, and CTEs
+- set operations with `UNION`, `INTERSECT`, and `EXCEPT`
 - ordering and grouping with `GROUP BY`, `ROLLUP`, `CUBE`, and `GROUPING SETS`
 - aggregate and custom SQL functions through `func`
 - backend-specific SQL rewrites through compile expressions
@@ -99,10 +100,13 @@ from sql_fusion import (
     Column,
     Table,
     delete,
+    except_,
     func,
     insert,
+    intersect,
     select,
-    text,
+    union,
+    text_op,
     update,
 )
 ```

{sql_fusion-1.1.0 → sql_fusion-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sql_fusion"
-version = "1.1.0"
+version = "1.2.0"
 description = "Python query builder with a focus on composability and reusability."
 readme = "README.md"
 authors = [{ name = "Mastermind-U", email = "rex49513@gmail.com" }]

{sql_fusion-1.1.0 → sql_fusion-1.2.0}/src/sql_fusion/__init__.py

@@ -2,6 +2,7 @@ from .composite_table import Alias, Column, Table, func, text_op
 from .query.delete import delete
 from .query.insert import insert
 from .query.select import select
+from .query.sets import except_, intersect, union
 from .query.update import update
 
 __all__ = [
@@ -9,9 +10,12 @@ __all__ = [
     "Column",
     "Table",
     "delete",
+    "except_",
     "func",
     "insert",
+    "intersect",
     "select",
     "text_op",
+    "union",
     "update",
 ]

{sql_fusion-1.1.0 → sql_fusion-1.2.0}/src/sql_fusion/composite_table.py

@@ -511,7 +511,8 @@ class Condition:
             )
             sql, op_params = operator.to_sql_ref(subquery_sql)
             return apply_negation(
-                sql, col_params + subquery_params + op_params
+                sql,
+                col_params + subquery_params + op_params,
             )
 
         sql, op_params = operator.to_sql(self.value)

sql_fusion-1.2.0/src/sql_fusion/query/__init__.py

@@ -0,0 +1,15 @@
+from .delete import delete
+from .insert import insert
+from .select import select
+from .sets import except_, intersect, union
+from .update import update
+
+__all__ = [
+    "delete",
+    "except_",
+    "insert",
+    "intersect",
+    "select",
+    "union",
+    "update",
+]

sql_fusion-1.2.0/src/sql_fusion/query/sets.py

@@ -0,0 +1,107 @@
+from typing import Any
+
+from sql_fusion.composite_table import AbstractQuery, AliasRegistry
+
+
+class _set_operation(AbstractQuery):
+    def __init__(
+        self,
+        query1: AbstractQuery,
+        query2: AbstractQuery,
+    ) -> None:
+        super().__init__(table=None, columns=())
+        self._query1 = query1
+        self._query2 = query2
+
+    def _operator_sql(self) -> str:
+        raise NotImplementedError()
+
+    def _render_query(
+        self,
+        query: AbstractQuery,
+        alias_registry: AliasRegistry,
+    ) -> tuple[str, tuple[Any, ...]]:
+        return query.build_query(alias_registry)
+
+    def build_query(
+        self,
+        alias_registry: AliasRegistry | None = None,
+    ) -> tuple[str, tuple[Any, ...]]:
+        registry = alias_registry or self._alias_registry
+        params: list[Any] = []
+
+        with_sql, with_params = self._build_with_clause(registry)
+        params.extend(with_params)
+
+        left_sql, left_params = self._render_query(self._query1, registry)
+        right_sql, right_params = self._render_query(self._query2, registry)
+
+        query_parts: list[str] = []
+        if with_sql:
+            query_parts.append(with_sql)
+        query_parts.append(
+            f"{left_sql} {self._operator_sql()} {right_sql}",
+        )
+
+        params.extend(left_params)
+        params.extend(right_params)
+
+        return self._apply_compile_expressions(
+            " ".join(query_parts),
+            tuple(params),
+        )
+
+
+class union(_set_operation):
+    def __init__(
+        self,
+        query1: AbstractQuery,
+        query2: AbstractQuery,
+        all: bool = False,  # noqa: A002
+        by_name: bool = False,
+    ) -> None:
+        super().__init__(query1, query2)
+        self._all = all
+        self._by_name = by_name
+
+    def _operator_sql(self) -> str:
+        operator = "UNION"
+        if self._all:
+            operator += " ALL"
+        if self._by_name:
+            operator += " BY NAME"
+        return operator
+
+
+class intersect(_set_operation):
+    def __init__(
+        self,
+        query1: AbstractQuery,
+        query2: AbstractQuery,
+        all_: bool = False,
+    ) -> None:
+        super().__init__(query1, query2)
+        self._all = all_
+
+    def _operator_sql(self) -> str:
+        operator = "INTERSECT"
+        if self._all:
+            operator += " ALL"
+        return operator
+
+
+class except_(_set_operation):
+    def __init__(
+        self,
+        query1: AbstractQuery,
+        query2: AbstractQuery,
+        all_: bool = False,
+    ) -> None:
+        super().__init__(query1, query2)
+        self._all = all_
+
+    def _operator_sql(self) -> str:
+        operator = "EXCEPT"
+        if self._all:
+            operator += " ALL"
+        return operator