pdql 0.1.0__tar.gz

pdql-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# Environments
+.venv/
+venv/
+ENV/
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Build and distribution
+dist/
+build/
+*.egg-info/
+
+# OS files
+.DS_Store

pdql-0.1.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marcin Zawalski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pdql-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: pdql
+Version: 0.1.0
+Summary: A library to transpile Pandas syntax to SQL strings.
+Project-URL: Homepage, https://github.com/marcinz606/pdql
+Project-URL: Issues, https://github.com/marcinz606/pdql/issues
+Author-email: Marcin Zawalski <zawalskimarcin@gmail.com>
+License: MIT
+License-File: LICENSE.md
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Provides-Extra: dev
+Requires-Dist: flake8; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pdql
+
+Lightweight Python library that allows you to write SQL queries using familiar Pandas syntax. It functions as a "lazy compiler," building a syntax tree from your operations and transpiling them into standard SQL strings without executing them or requiring a database connection.
+
+## Installation
+
+Clone the repository and set up the environment using the provided Makefile:
+
+```bash
+git clone <repo-url>
+cd pdql
+make setup
+```
+
+## Usage
+
+### Persistent Dialect & Filtering
+
+```python
+from pdql.dataframe import SQLDataFrame
+from pdql.dialects import BigQueryDialect
+
+# Initialize with a specific dialect
+df = SQLDataFrame("my_table", dialect=BigQueryDialect())
+
+# Filters use dialect-specific quoting (backticks for BigQuery)
+query = df[df["age"] > 21]
+
+print(query.to_sql())
+# SELECT * FROM `my_table` WHERE (`my_table`.`age` > 21)
+```
+
+### Common Table Expressions (CTEs)
+
+```python
+from pdql.dataframe import SQLDataFrame
+
+# Define a subquery
+sub = SQLDataFrame("raw_data")[["id", "val"]]
+sub = sub[sub["val"] > 10]
+
+# Use it as a source and define the CTE
+df = SQLDataFrame("filtered").with_cte("filtered", sub)
+
+print(df.to_sql())
+# WITH "filtered" AS (SELECT "id", "val" FROM "raw_data" WHERE ("raw_data"."val" > 10)) SELECT * FROM "filtered"
+```
+
+### Subqueries & Aliasing
+
+```python
+inner = SQLDataFrame("orders").groupby("user_id").agg({"amount": "sum"}).alias("totals")
+outer = SQLDataFrame(inner)
+query = outer[outer["amount_sum"] > 1000]
+
+print(query.to_sql())
+# SELECT * FROM (SELECT "user_id", SUM("amount") AS "amount_sum" FROM "orders" GROUP BY "user_id") AS "totals" WHERE ("totals"."amount_sum" > 1000)
+```
+
+### Ordering & Limits
+
+```python
+from pdql.expressions import SQLFunction
+
+# Order by columns or expressions/functions
+query = df.sort_values(["created_at", SQLFunction("rand")], ascending=[False, True]).head(10)
+
+print(query.to_sql())
+# SELECT * FROM "my_table" ORDER BY "my_table"."created_at" DESC, RAND() ASC LIMIT 10
+```
+
+### DML Operations
+
+```python
+df = SQLDataFrame("users")
+
+# Generate INSERT
+insert_sql = df.insert({"name": "Alice", "status": "active"})
+
+# Generate DELETE based on current filters
+delete_sql = df[df["status"] == "inactive"].delete()
+```
+
+## Development
+
+Use the `Makefile` for standard tasks:
+
+- **Run Tests:** `make test`
+- **Format Code:** `make format`
+- **Linting:** `make lint`
+- **Build Package:** `make build`
+
+## License
+
+[MIT](LICENSE.md)

pdql-0.1.0/README.md

@@ -0,0 +1,95 @@
+# pdql
+
+Lightweight Python library that allows you to write SQL queries using familiar Pandas syntax. It functions as a "lazy compiler," building a syntax tree from your operations and transpiling them into standard SQL strings without executing them or requiring a database connection.
+
+## Installation
+
+Clone the repository and set up the environment using the provided Makefile:
+
+```bash
+git clone <repo-url>
+cd pdql
+make setup
+```
+
+## Usage
+
+### Persistent Dialect & Filtering
+
+```python
+from pdql.dataframe import SQLDataFrame
+from pdql.dialects import BigQueryDialect
+
+# Initialize with a specific dialect
+df = SQLDataFrame("my_table", dialect=BigQueryDialect())
+
+# Filters use dialect-specific quoting (backticks for BigQuery)
+query = df[df["age"] > 21]
+
+print(query.to_sql())
+# SELECT * FROM `my_table` WHERE (`my_table`.`age` > 21)
+```
+
+### Common Table Expressions (CTEs)
+
+```python
+from pdql.dataframe import SQLDataFrame
+
+# Define a subquery
+sub = SQLDataFrame("raw_data")[["id", "val"]]
+sub = sub[sub["val"] > 10]
+
+# Use it as a source and define the CTE
+df = SQLDataFrame("filtered").with_cte("filtered", sub)
+
+print(df.to_sql())
+# WITH "filtered" AS (SELECT "id", "val" FROM "raw_data" WHERE ("raw_data"."val" > 10)) SELECT * FROM "filtered"
+```
+
+### Subqueries & Aliasing
+
+```python
+inner = SQLDataFrame("orders").groupby("user_id").agg({"amount": "sum"}).alias("totals")
+outer = SQLDataFrame(inner)
+query = outer[outer["amount_sum"] > 1000]
+
+print(query.to_sql())
+# SELECT * FROM (SELECT "user_id", SUM("amount") AS "amount_sum" FROM "orders" GROUP BY "user_id") AS "totals" WHERE ("totals"."amount_sum" > 1000)
+```
+
+### Ordering & Limits
+
+```python
+from pdql.expressions import SQLFunction
+
+# Order by columns or expressions/functions
+query = df.sort_values(["created_at", SQLFunction("rand")], ascending=[False, True]).head(10)
+
+print(query.to_sql())
+# SELECT * FROM "my_table" ORDER BY "my_table"."created_at" DESC, RAND() ASC LIMIT 10
+```
+
+### DML Operations
+
+```python
+df = SQLDataFrame("users")
+
+# Generate INSERT
+insert_sql = df.insert({"name": "Alice", "status": "active"})
+
+# Generate DELETE based on current filters
+delete_sql = df[df["status"] == "inactive"].delete()
+```
+
+## Development
+
+Use the `Makefile` for standard tasks:
+
+- **Run Tests:** `make test`
+- **Format Code:** `make format`
+- **Linting:** `make lint`
+- **Build Package:** `make build`
+
+## License
+
+[MIT](LICENSE.md)

pdql-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pdql"
+version = "0.1.0"
+description = "A library to transpile Pandas syntax to SQL strings."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Marcin Zawalski", email = "zawalskimarcin@gmail.com"},
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "flake8",
+    "mypy",
+    "ruff",
+]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/pdql"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pdql"]
+
+[project.urls]
+Homepage = "https://github.com/marcinz606/pdql"
+Issues = "https://github.com/marcinz606/pdql/issues"

pdql-0.1.0/src/pdql/dataframe.py

@@ -0,0 +1,394 @@
+import uuid
+from typing import List, Optional, Union, Any, Dict, Tuple
+from dataclasses import dataclass
+from pdql.expressions import SQLColumn, SQLExpression, SQLNode, SQLFunction
+from pdql.dialects import Dialect, GenericDialect
+
+
+@dataclass
+class Join:
+    table: Union[str, "SQLDataFrame"]
+    join_type: str
+    condition: SQLExpression
+    alias: Optional[str] = None
+
+
+class SQLDataFrame:
+    """Immutable container representing a SQL query."""
+
+    def __init__(
+        self,
+        source: Union[str, "SQLDataFrame"],
+        select_cols: Optional[List[Union[str, SQLNode]]] = None,
+        where_conditions: Optional[List[SQLExpression]] = None,
+        joins: Optional[List[Join]] = None,
+        group_by_cols: Optional[List[Union[str, SQLNode]]] = None,
+        order_by: Optional[List[Tuple[SQLNode, bool]]] = None,
+        limit_count: Optional[int] = None,
+        alias_name: Optional[str] = None,
+        dialect: Optional[Dialect] = None,
+        ctes: Optional[Dict[str, "SQLDataFrame"]] = None,
+    ):
+        self.source = source
+        self.select_cols = select_cols or ["*"]
+        self.where_conditions = where_conditions or []
+        self.joins = joins or []
+        self.group_by_cols = group_by_cols or []
+        self.order_by = order_by or []
+        self.limit_count = limit_count
+        self.alias_name = alias_name
+        self.dialect = dialect
+        self.ctes = ctes or {}
+
+    @property
+    def identifier(self) -> str:
+        """Identifier used for table qualification."""
+        if self.alias_name:
+            return self.alias_name
+        if isinstance(self.source, str):
+            return self.source
+        return self.source.identifier
+
+    def is_simple(self) -> bool:
+        """True if the dataframe is a simple table reference."""
+        return (
+            self.select_cols == ["*"]
+            and not self.where_conditions
+            and not self.joins
+            and not self.group_by_cols
+            and not self.order_by
+            and self.limit_count is None
+            and isinstance(self.source, str)
+        )
+
+    def alias(self, name: str) -> "SQLDataFrame":
+        """Assign an alias for subquery usage."""
+        return SQLDataFrame(
+            source=self.source,
+            select_cols=self.select_cols,
+            where_conditions=self.where_conditions,
+            joins=self.joins,
+            group_by_cols=self.group_by_cols,
+            order_by=self.order_by,
+            limit_count=self.limit_count,
+            alias_name=name,
+            dialect=self.dialect,
+            ctes=self.ctes,
+        )
+
+    def with_cte(self, name: str, dataframe: "SQLDataFrame") -> "SQLDataFrame":
+        """Add a Common Table Expression to the query."""
+        new_ctes = dict(self.ctes)
+        new_ctes[name] = dataframe
+        return SQLDataFrame(
+            source=self.source,
+            select_cols=self.select_cols,
+            where_conditions=self.where_conditions,
+            joins=self.joins,
+            group_by_cols=self.group_by_cols,
+            order_by=self.order_by,
+            limit_count=self.limit_count,
+            alias_name=self.alias_name,
+            dialect=self.dialect,
+            ctes=new_ctes,
+        )
+
+    def __getitem__(self, item: Any) -> Union[SQLColumn, "SQLDataFrame"]:
+        if isinstance(item, str):
+            owner = self.identifier if not self.joins else None
+            return SQLColumn(item, owner=owner)
+
+        if isinstance(item, list):
+            return SQLDataFrame(
+                source=self.source,
+                select_cols=item,
+                where_conditions=self.where_conditions,
+                joins=self.joins,
+                group_by_cols=self.group_by_cols,
+                order_by=self.order_by,
+                limit_count=self.limit_count,
+                alias_name=self.alias_name,
+                dialect=self.dialect,
+                ctes=self.ctes,
+            )
+
+        if isinstance(item, SQLExpression):
+            new_conditions = self.where_conditions + [item]
+            return SQLDataFrame(
+                source=self.source,
+                select_cols=self.select_cols,
+                where_conditions=new_conditions,
+                joins=self.joins,
+                group_by_cols=self.group_by_cols,
+                order_by=self.order_by,
+                limit_count=self.limit_count,
+                alias_name=self.alias_name,
+                dialect=self.dialect,
+                ctes=self.ctes,
+            )
+
+        raise TypeError(f"Invalid argument type for __getitem__: {type(item)}")
+
+    def merge(
+        self,
+        right: "SQLDataFrame",
+        how: str = "inner",
+        on: Optional[str] = None,
+        left_on: Optional[str] = None,
+        right_on: Optional[str] = None,
+    ) -> "SQLDataFrame":
+        """Merge with another SQLDataFrame."""
+        if on:
+            left_col = self[on]
+            right_col = right[on]
+            condition = left_col == right_col
+        elif left_on and right_on:
+            left_col = self[left_on]
+            right_col = right[right_on]
+            condition = left_col == right_col
+        else:
+            raise ValueError("Must specify 'on' or 'left_on' and 'right_on'")
+
+        join_map = {
+            "inner": "JOIN",
+            "left": "LEFT JOIN",
+            "right": "RIGHT JOIN",
+            "outer": "FULL OUTER JOIN",
+        }
+        join_type = join_map.get(how, "JOIN")
+
+        new_join = Join(
+            table=right,
+            join_type=join_type,
+            condition=condition,
+            alias=right.alias_name,
+        )
+
+        return SQLDataFrame(
+            source=self.source,
+            select_cols=self.select_cols,
+            where_conditions=self.where_conditions,
+            joins=self.joins + [new_join],
+            group_by_cols=self.group_by_cols,
+            order_by=self.order_by,
+            limit_count=self.limit_count,
+            alias_name=self.alias_name,
+            dialect=self.dialect,
+            ctes=self.ctes,
+        )
+
+    def groupby(
+        self, by: Union[str, List[str], SQLNode, List[SQLNode]]
+    ) -> "SQLDataFrame":
+        if not isinstance(by, list):
+            by = [by]
+
+        return SQLDataFrame(
+            source=self.source,
+            select_cols=self.select_cols,
+            where_conditions=self.where_conditions,
+            joins=self.joins,
+            group_by_cols=by,
+            order_by=self.order_by,
+            limit_count=self.limit_count,
+            alias_name=self.alias_name,
+            dialect=self.dialect,
+            ctes=self.ctes,
+        )
+
+    def agg(self, func_map: Dict[str, str]) -> "SQLDataFrame":
+        new_selects = []
+        for grp in self.group_by_cols:
+            if isinstance(grp, str):
+                new_selects.append(self[grp])
+            else:
+                new_selects.append(grp)
+
+        for col_name, func_name in func_map.items():
+            col = self[col_name]
+            alias = f"{col_name}_{func_name}"
+            func_node = SQLFunction(func_name, col, alias=alias)
+            new_selects.append(func_node)
+
+        return SQLDataFrame(
+            source=self.source,
+            select_cols=new_selects,
+            where_conditions=self.where_conditions,
+            joins=self.joins,
+            group_by_cols=self.group_by_cols,
+            order_by=self.order_by,
+            limit_count=self.limit_count,
+            alias_name=self.alias_name,
+            dialect=self.dialect,
+            ctes=self.ctes,
+        )
+
+    def sort_values(
+        self,
+        by: Union[str, SQLNode, List[Union[str, SQLNode]]],
+        ascending: Union[bool, List[bool]] = True,
+    ) -> "SQLDataFrame":
+        if not isinstance(by, list):
+            by = [by]
+        if not isinstance(ascending, list):
+            ascending = [ascending] * len(by)
+
+        new_order_by = list(self.order_by)
+        for item, asc in zip(by, ascending):
+            if isinstance(item, str):
+                node = self[item]
+            else:
+                node = item
+            new_order_by.append((node, asc))
+
+        return SQLDataFrame(
+            source=self.source,
+            select_cols=self.select_cols,
+            where_conditions=self.where_conditions,
+            joins=self.joins,
+            group_by_cols=self.group_by_cols,
+            order_by=new_order_by,
+            limit_count=self.limit_count,
+            alias_name=self.alias_name,
+            dialect=self.dialect,
+            ctes=self.ctes,
+        )
+
+    def head(self, n: int = 5) -> "SQLDataFrame":
+        return SQLDataFrame(
+            source=self.source,
+            select_cols=self.select_cols,
+            where_conditions=self.where_conditions,
+            joins=self.joins,
+            group_by_cols=self.group_by_cols,
+            order_by=self.order_by,
+            limit_count=n,
+            alias_name=self.alias_name,
+            dialect=self.dialect,
+            ctes=self.ctes,
+        )
+
+    def insert(self, data: Union[Dict[str, Any], List[Dict[str, Any]]]) -> str:
+        if not isinstance(self.source, str):
+            raise ValueError("Can only insert into a table (string source)")
+
+        if isinstance(data, dict):
+            data = [data]
+
+        if not data:
+            raise ValueError("No data provided for insert")
+
+        dialect = self.dialect or GenericDialect()
+        columns = list(data[0].keys())
+        quoted_table = dialect.quote_identifier(self.source)
+        quoted_cols = ", ".join(dialect.quote_identifier(c) for c in columns)
+
+        all_values = []
+        for record in data:
+            vals = ", ".join(dialect.format_value(record[c]) for c in columns)
+            all_values.append(f"({vals})")
+
+        values_str = ", ".join(all_values)
+        return f"INSERT INTO {quoted_table} ({quoted_cols}) VALUES {values_str}"
+
+    def delete(self) -> str:
+        if not isinstance(self.source, str):
+            raise ValueError("Can only delete from a table (string source)")
+
+        dialect = self.dialect or GenericDialect()
+        quoted_table = dialect.quote_identifier(self.source)
+        sql = f"DELETE FROM {quoted_table}"
+
+        if self.where_conditions:
+            conditions = [cond.to_sql(dialect) for cond in self.where_conditions]
+            where_clause = " AND ".join(conditions)
+            sql += f" WHERE {where_clause}"
+
+        return sql
+
+    def to_sql(self, dialect: Optional[Dialect] = None) -> str:
+        """Generate SQL query string."""
+        if dialect is None:
+            dialect = self.dialect or GenericDialect()
+
+        if self.select_cols == ["*"]:
+            select_clause = "*"
+        else:
+            quoted_cols = []
+            for col in self.select_cols:
+                if isinstance(col, SQLNode):
+                    quoted_cols.append(col.to_sql(dialect))
+                else:
+                    quoted_cols.append(dialect.quote_identifier(col))
+            select_clause = ", ".join(quoted_cols)
+
+        if isinstance(self.source, str):
+            from_clause = dialect.quote_identifier(self.source)
+        elif self.source.is_simple() and not self.alias_name:
+            from_clause = dialect.quote_identifier(self.source.source)  # type: ignore
+        else:
+            subquery_sql = self.source.to_sql(dialect)
+            alias = dialect.quote_identifier(self.alias_name or self.identifier)
+            from_clause = f"({subquery_sql}) AS {alias}"
+
+        join_clauses = []
+        for join in self.joins:
+            if isinstance(join.table, str):
+                table_sql = dialect.quote_identifier(join.table)
+            elif join.table.is_simple() and not join.alias:
+                table_sql = dialect.quote_identifier(join.table.source)  # type: ignore
+            else:
+                inner_sql = join.table.to_sql(dialect)
+                alias = dialect.quote_identifier(join.alias or join.table.identifier)
+                table_sql = f"({inner_sql}) AS {alias}"
+
+            condition = join.condition.to_sql(dialect)
+            join_clauses.append(f"{join.join_type} {table_sql} ON {condition}")
+
+        full_from = f"{from_clause}"
+        if join_clauses:
+            full_from += " " + " ".join(join_clauses)
+
+        sql = f"SELECT {select_clause} FROM {full_from}"
+
+        if self.where_conditions:
+            conditions = [cond.to_sql(dialect) for cond in self.where_conditions]
+            where_clause = " AND ".join(conditions)
+            sql += f" WHERE {where_clause}"
+
+        if self.group_by_cols:
+            group_items = []
+            for g in self.group_by_cols:
+                if isinstance(g, SQLNode):
+                    group_items.append(g.to_sql(dialect))
+                else:
+                    owner = self.alias_name or (
+                        self.source
+                        if isinstance(self.source, str)
+                        else self.source.identifier
+                    )
+                    quoted_owner = dialect.quote_identifier(owner)
+                    quoted_col = dialect.quote_identifier(g)
+                    group_items.append(f"{quoted_owner}.{quoted_col}")
+            group_clause = ", ".join(group_items)
+            sql += f" GROUP BY {group_clause}"
+
+        if self.order_by:
+            order_items = []
+            for node, asc in self.order_by:
+                direction = "ASC" if asc else "DESC"
+                order_items.append(f"{node.to_sql(dialect)} {direction}")
+            sql += f" ORDER BY {', '.join(order_items)}"
+
+        if self.limit_count is not None:
+            sql += f" LIMIT {self.limit_count}"
+
+        if self.ctes:
+            cte_parts = []
+            for name, cte_df in self.ctes.items():
+                cte_parts.append(
+                    f"{dialect.quote_identifier(name)} AS ({cte_df.to_sql(dialect)})"
+                )
+            sql = f"WITH {', '.join(cte_parts)} {sql}"
+
+        return sql

pdql-0.1.0/src/pdql/dialects.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Dialect(ABC):
+    """Abstract base class for SQL dialects."""
+
+    @abstractmethod
+    def quote_identifier(self, name: str) -> str:
+        pass
+
+    def format_value(self, value: Any) -> str:
+        if isinstance(value, str):
+            escaped = value.replace("'", "''")
+            return f"'{escaped}'"
+        if value is None:
+            return "NULL"
+        if isinstance(value, bool):
+            return "TRUE" if value else "FALSE"
+        return str(value)
+
+    def translate_function(self, name: str) -> str:
+        mapping = {
+            "mean": "AVG",
+            "sum": "SUM",
+            "count": "COUNT",
+            "min": "MIN",
+            "max": "MAX",
+        }
+        return mapping.get(name.lower(), name.upper())
+
+    def translate_op(self, op: str) -> str:
+        mapping = {
+            "eq": "=",
+            "ne": "!=",
+            "gt": ">",
+            "lt": "<",
+            "ge": ">=",
+            "le": "<=",
+            "add": "+",
+            "sub": "-",
+            "mul": "*",
+            "div": "/",
+            "and": "AND",
+            "or": "OR",
+        }
+        return mapping.get(op, op)
+
+
+class GenericDialect(Dialect):
+    def quote_identifier(self, name: str) -> str:
+        return f'"{name}"'
+
+
+class PostgresDialect(Dialect):
+    def quote_identifier(self, name: str) -> str:
+        return f'"{name}"'
+
+
+class BigQueryDialect(Dialect):
+    def quote_identifier(self, name: str) -> str:
+        return f"`{name}`"

pdql-0.1.0/src/pdql/expressions.py

@@ -0,0 +1,184 @@
+from typing import Any, Union, Optional, List
+from pdql.dialects import Dialect
+
+
+class SQLNode:
+    """Base class for SQL syntax tree nodes."""
+
+    def to_sql(self, dialect: Dialect) -> str:
+        raise NotImplementedError
+
+    def _op(self, op: str, other: Any) -> "SQLExpression":
+        return SQLExpression(self, op, other)
+
+    def __eq__(self, other: Any) -> "SQLExpression":  # type: ignore
+        return self._op("eq", other)
+
+    def __ne__(self, other: Any) -> "SQLExpression":  # type: ignore
+        return self._op("ne", other)
+
+    def __lt__(self, other: Any) -> "SQLExpression":
+        return self._op("lt", other)
+
+    def __le__(self, other: Any) -> "SQLExpression":
+        return self._op("le", other)
+
+    def __gt__(self, other: Any) -> "SQLExpression":
+        return self._op("gt", other)
+
+    def __ge__(self, other: Any) -> "SQLExpression":
+        return self._op("ge", other)
+
+    def __add__(self, other: Any) -> "SQLExpression":
+        return self._op("add", other)
+
+    def __sub__(self, other: Any) -> "SQLExpression":
+        return self._op("sub", other)
+
+    def __mul__(self, other: Any) -> "SQLExpression":
+        return self._op("mul", other)
+
+    def __truediv__(self, other: Any) -> "SQLExpression":
+        return self._op("div", other)
+
+    def __and__(self, other: Any) -> "SQLExpression":
+        return self._op("and", other)
+
+    def __or__(self, other: Any) -> "SQLExpression":
+        return self._op("or", other)
+
+
+class SQLExpression(SQLNode):
+    """Represents a binary operation in SQL."""
+
+    def __init__(self, left: Union[SQLNode, Any], op: str, right: Union[SQLNode, Any]):
+        self.left = left
+        self.op = op
+        self.right = right
+
+    def to_sql(self, dialect: Dialect) -> str:
+        left_sql = (
+            self.left.to_sql(dialect)
+            if isinstance(self.left, SQLNode)
+            else dialect.format_value(self.left)
+        )
+        right_sql = (
+            self.right.to_sql(dialect)
+            if isinstance(self.right, SQLNode)
+            else dialect.format_value(self.right)
+        )
+        operator = dialect.translate_op(self.op)
+        return f"({left_sql} {operator} {right_sql})"
+
+
+class SQLColumn(SQLNode):
+    """Represents a column in a SQL table."""
+
+    def __init__(self, name: str, owner: Optional[str] = None):
+        self.name = name
+        self.owner = owner
+
+    def to_sql(self, dialect: Dialect) -> str:
+        col = dialect.quote_identifier(self.name)
+        if self.owner:
+            owner = dialect.quote_identifier(self.owner)
+            return f"{owner}.{col}"
+        return col
+
+
+class SQLFunction(SQLNode):
+    """Represents a SQL function."""
+
+    def __init__(
+        self,
+        name: str,
+        args: Optional[Union[List[Any], Any]] = None,
+        alias: Optional[str] = None,
+    ):
+        self.name = name
+        if args is None:
+            self.args = []
+        elif isinstance(args, list):
+            self.args = args
+        else:
+            self.args = [args]
+        self.alias = alias
+
+    def to_sql(self, dialect: Dialect) -> str:
+        func_name = dialect.translate_function(self.name)
+        arg_sqls = []
+        for arg in self.args:
+            if isinstance(arg, SQLNode):
+                arg_sqls.append(arg.to_sql(dialect))
+            elif arg == "*":
+                arg_sqls.append("*")
+            else:
+                arg_sqls.append(dialect.format_value(arg))
+
+        args_str = ", ".join(arg_sqls)
+        sql = f"{func_name}({args_str})"
+
+        if self.alias:
+            return f"{sql} AS {dialect.quote_identifier(self.alias)}"
+        return sql
+
+    def over(self, partition_by=None, order_by=None) -> "SQLWindowFunction":
+        return SQLWindowFunction(self, partition_by=partition_by, order_by=order_by)
+
+
+class SQLWindowFunction(SQLNode):
+    """Represents a Window Function."""
+
+    def __init__(
+        self,
+        func: SQLFunction,
+        partition_by: Optional[Union[List[Any], Any]] = None,
+        order_by: Optional[Union[List[Any], Any]] = None,
+    ):
+        self.func = func
+
+        if partition_by is None:
+            self.partition_by = []
+        elif isinstance(partition_by, list):
+            self.partition_by = partition_by
+        else:
+            self.partition_by = [partition_by]
+
+        if order_by is None:
+            self.order_by = []
+        elif isinstance(order_by, list):
+            self.order_by = order_by
+        else:
+            self.order_by = [order_by]
+
+        self.alias = func.alias
+        self.func.alias = None
+
+    def to_sql(self, dialect: Dialect) -> str:
+        func_sql = self.func.to_sql(dialect)
+
+        parts = []
+        if self.partition_by:
+            p_sqls = []
+            for p in self.partition_by:
+                if isinstance(p, SQLNode):
+                    p_sqls.append(p.to_sql(dialect))
+                else:
+                    p_sqls.append(dialect.quote_identifier(str(p)))
+            parts.append(f"PARTITION BY {', '.join(p_sqls)}")
+
+        if self.order_by:
+            o_sqls = []
+            for o in self.order_by:
+                if isinstance(o, SQLNode):
+                    o_sqls.append(o.to_sql(dialect))
+                else:
+                    o_sqls.append(dialect.quote_identifier(str(o)))
+            parts.append(f"ORDER BY {', '.join(o_sqls)}")
+
+        over_clause = " ".join(parts)
+        sql = f"{func_sql} OVER ({over_clause})"
+
+        if self.alias:
+            return f"{sql} AS {dialect.quote_identifier(self.alias)}"
+        return sql