ddsql 0.0.1__tar.gz

ddsql-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Artem Davydov
+
+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.

ddsql-0.0.1/PKG-INFO

@@ -0,0 +1,252 @@
+Metadata-Version: 2.4
+Name: ddsql
+Version: 0.0.1
+Summary: SQL Query Library
+License: MIT
+License-File: LICENSE
+Keywords: python,ddsql
+Author: davyddd
+Requires-Python: >=3.9,<3.15
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: ddutils (<0.2.0)
+Requires-Dist: jinja2 (>=3.0.0,<4.0.0)
+Project-URL: Repository, https://github.com/davyddd/ddsql
+Description-Content-Type: text/markdown
+
+# DDSQL
+
+[![pypi](https://img.shields.io/pypi/v/ddsql.svg)](https://pypi.python.org/pypi/ddsql)
+[![downloads](https://static.pepy.tech/badge/ddsql/month)](https://pepy.tech/project/ddsql)
+[![versions](https://img.shields.io/pypi/pyversions/ddsql.svg)](https://github.com/davyddd/ddsql)
+[![codecov](https://codecov.io/gh/davyddd/ddsql/branch/main/graph/badge.svg)](https://app.codecov.io/github/davyddd/ddsql)
+[![license](https://img.shields.io/github/license/davyddd/ddsql.svg)](https://github.com/davyddd/ddsql/blob/main/LICENSE)
+
+**DDSQL** is a Python library for building SQL queries with Jinja2 template rendering and database adapter support.
+Query results are automatically deserialized into typed models.
+
+## Installation
+
+Install the library using pip:
+```bash
+pip install ddsql
+```
+
+## Serializer
+
+The serializer converts Python types to their SQL representations. 
+You can use one of the built-in serializers (`PostgresSerializer`, `ClickhouseSerializer`) 
+or create your own by inheriting from `BaseSerializer`.
+
+**Serialization Table**
+
+| Python Type          | Base                     | PostgreSQL                          | ClickHouse                                        |
+|----------------------|--------------------------|-------------------------------------|---------------------------------------------------|
+| `None`               | `NULL`                   | `NULL`                              | `NULL`                                            |
+| `bool`               | `true`/`false`           | `true`/`false`                      | `true`/`false`                                    |
+| `int`                | `123`                    | `123`                               | `123`                                             |
+| `float`/`Decimal`    | `45.67`                  | `45.67`                             | `45.67`                                           |
+| `str`                | `'value'`                | `'value'`                           | `'value'`                                         |
+| `UUID`               | `'550e8400-...'`         | `'550e8400-...'::uuid`              | `toUUID('550e8400-...')`                          |
+| `datetime`           | `'2025-01-01T12:00:00'`  | `'2025-01-01T12:00:00'::timestamp`  | `parseDateTimeBestEffort('2025-01-01T12:00:00')`  |
+| `date`               | `'2025-01-01'`           | `'2025-01-01'::date`                | `toDate('2025-01-01')`                            |
+| `list`/`tuple`/`set` | `(item1, item2, ...)`    | `(item1, item2, ...)`               | `(item1, item2, ...)`                             |
+
+If you need to serialize a type not listed in the table, override the `serialize_other_object` method in your serializer:
+
+```python
+from ddsql.serializers import BaseSerializer
+
+
+class CustomSerializer(BaseSerializer):
+    def serialize_other_object(self, value):
+        if isinstance(value, CustomType):
+            return ...
+        ...
+```
+
+To serialize values in SQL templates, wrap parameters with `serialize_value`:
+
+```sql
+SELECT * 
+FROM users
+WHERE 
+    name = {{ serialize_value(name) }}
+    AND created_at > {{ serialize_value(created_at) }}
+```
+
+To add custom functions to templates, override the `template_functions` property:
+
+```python
+from ddsql.serializers import BaseSerializer
+
+
+class CustomSerializer(BaseSerializer):
+    @property
+    def template_functions(self):
+        return {
+            **super().template_functions,
+            'some_function': ...,
+        }
+```
+
+## Adapter
+
+`Adapter` encapsulates database interactions. To create an adapter, inherit from the `Adapter` base class 
+and define two required elements:
+- **serializer** – an instance of a serializer for converting Python types to SQL representations;
+- **_execute** method – the database-specific query execution logic.
+
+```python
+from ddsql.adapter import Adapter
+from ddsql.serializers import PostgresSerializer
+
+
+class PostgresAdapter(Adapter):
+    serializer = PostgresSerializer()
+
+    async def _execute(self) -> Sequence[Dict[str, Any]]:
+        query = await self.get_query()  # get the rendered SQL query
+        async with Atomic() as postgres_session:
+            result = await postgres_session.execute(text(query))
+            return [dict(zip(result.keys(), row)) for row in result.fetchall()]
+```
+
+## SQLBase
+
+`SQLBase` is configured once per project and defines which adapters are available for query execution. 
+It serves as the central point that connects queries with database adapters.
+
+Create a subclass with one or more adapters:
+
+```python
+from ddsql.sqlbase import SQLBase
+from ddsql.adapter import AdapterDescriptor
+
+
+class SQL(SQLBase):
+    postgres: PostgresAdapter = AdapterDescriptor(PostgresAdapter)
+    clickhouse: ClickhouseAdapter = AdapterDescriptor(ClickhouseAdapter)
+```
+
+Execution example:
+
+```python
+from ddsql.query import Query
+
+
+query = Query(...)
+result = await SQL(query=query).with_params(email='test@test.test', is_deleted=False).postgres.execute()
+```
+
+## Query
+
+`Query` knows where to get the template from and how to render a SQL query. 
+It also handles result deserialization via the `build_result` method, 
+which wraps raw database rows into the specified model (called internally by `Adapter.execute`).
+
+Required parameters:
+- **model** – a declarative class (e.g., dataclass) describing the output result structure;
+- **text** or **path** – the SQL template source.
+
+### Inline Template (text)
+
+```python
+from ddsql.query import Query
+
+
+query = Query(
+    model=User,
+    text='SELECT user_id, name FROM users WHERE user_id = {{ serialize_value(user_id) }}'
+)
+```
+
+### File Template (path)
+
+For file-based templates, set the `SQL_TEMPLATES_DIR` environment variable to the directory containing your SQL files:
+
+```bash
+export SQL_TEMPLATES_DIR=/app/src/templates/sql/
+```
+
+Then use a relative path:
+
+```python
+from ddsql.query import Query
+
+
+# Loads template from /app/src/templates/sql/users/get_by_id.sql
+query = Query(
+    model=User, 
+    path='users/get_by_id.sql'
+)
+```
+
+### Result
+
+The result of query execution is a `Result` object that wraps the data into the specified model:
+- `get()` – returns the first row as a model instance, or `None` if empty;
+- `get_list()` – returns all rows as a tuple of model instances;
+- `rows` – attribute for accessing raw data.
+
+## Complete Example
+
+```python
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+from ddsql.query import Query
+from ddsql.sqlbase import SQLBase
+from ddsql.adapter import Adapter, AdapterDescriptor
+from ddsql.serializers import PostgresSerializer
+
+
+class PostgresAdapter(Adapter):
+    serializer = PostgresSerializer()
+
+    async def _execute(self):
+        ...
+
+
+class SQL(SQLBase):
+    postgres: PostgresAdapter = AdapterDescriptor(PostgresAdapter)
+
+
+@dataclass
+class User:
+    user_id: int
+    name: str
+    email: Optional[str]
+    created_at: datetime
+    is_deleted: bool
+
+
+query = Query(
+    model=User,
+    text='''
+        SELECT *
+        FROM users
+        WHERE 
+            created_at > {{ serialize_value(created_after) }}
+        LIMIT {{ limit }}
+    '''
+)
+
+
+async def get_users():
+    result = await (
+        SQL(query=query)
+        .with_params(created_after=datetime(2025, 1, 1))
+        .with_params(limit=10)
+        .postgres
+        .execute()
+    )
+    return result.get_list()
+```

ddsql-0.0.1/README.md

@@ -0,0 +1,230 @@
+# DDSQL
+
+[![pypi](https://img.shields.io/pypi/v/ddsql.svg)](https://pypi.python.org/pypi/ddsql)
+[![downloads](https://static.pepy.tech/badge/ddsql/month)](https://pepy.tech/project/ddsql)
+[![versions](https://img.shields.io/pypi/pyversions/ddsql.svg)](https://github.com/davyddd/ddsql)
+[![codecov](https://codecov.io/gh/davyddd/ddsql/branch/main/graph/badge.svg)](https://app.codecov.io/github/davyddd/ddsql)
+[![license](https://img.shields.io/github/license/davyddd/ddsql.svg)](https://github.com/davyddd/ddsql/blob/main/LICENSE)
+
+**DDSQL** is a Python library for building SQL queries with Jinja2 template rendering and database adapter support.
+Query results are automatically deserialized into typed models.
+
+## Installation
+
+Install the library using pip:
+```bash
+pip install ddsql
+```
+
+## Serializer
+
+The serializer converts Python types to their SQL representations. 
+You can use one of the built-in serializers (`PostgresSerializer`, `ClickhouseSerializer`) 
+or create your own by inheriting from `BaseSerializer`.
+
+**Serialization Table**
+
+| Python Type          | Base                     | PostgreSQL                          | ClickHouse                                        |
+|----------------------|--------------------------|-------------------------------------|---------------------------------------------------|
+| `None`               | `NULL`                   | `NULL`                              | `NULL`                                            |
+| `bool`               | `true`/`false`           | `true`/`false`                      | `true`/`false`                                    |
+| `int`                | `123`                    | `123`                               | `123`                                             |
+| `float`/`Decimal`    | `45.67`                  | `45.67`                             | `45.67`                                           |
+| `str`                | `'value'`                | `'value'`                           | `'value'`                                         |
+| `UUID`               | `'550e8400-...'`         | `'550e8400-...'::uuid`              | `toUUID('550e8400-...')`                          |
+| `datetime`           | `'2025-01-01T12:00:00'`  | `'2025-01-01T12:00:00'::timestamp`  | `parseDateTimeBestEffort('2025-01-01T12:00:00')`  |
+| `date`               | `'2025-01-01'`           | `'2025-01-01'::date`                | `toDate('2025-01-01')`                            |
+| `list`/`tuple`/`set` | `(item1, item2, ...)`    | `(item1, item2, ...)`               | `(item1, item2, ...)`                             |
+
+If you need to serialize a type not listed in the table, override the `serialize_other_object` method in your serializer:
+
+```python
+from ddsql.serializers import BaseSerializer
+
+
+class CustomSerializer(BaseSerializer):
+    def serialize_other_object(self, value):
+        if isinstance(value, CustomType):
+            return ...
+        ...
+```
+
+To serialize values in SQL templates, wrap parameters with `serialize_value`:
+
+```sql
+SELECT * 
+FROM users
+WHERE 
+    name = {{ serialize_value(name) }}
+    AND created_at > {{ serialize_value(created_at) }}
+```
+
+To add custom functions to templates, override the `template_functions` property:
+
+```python
+from ddsql.serializers import BaseSerializer
+
+
+class CustomSerializer(BaseSerializer):
+    @property
+    def template_functions(self):
+        return {
+            **super().template_functions,
+            'some_function': ...,
+        }
+```
+
+## Adapter
+
+`Adapter` encapsulates database interactions. To create an adapter, inherit from the `Adapter` base class 
+and define two required elements:
+- **serializer** – an instance of a serializer for converting Python types to SQL representations;
+- **_execute** method – the database-specific query execution logic.
+
+```python
+from ddsql.adapter import Adapter
+from ddsql.serializers import PostgresSerializer
+
+
+class PostgresAdapter(Adapter):
+    serializer = PostgresSerializer()
+
+    async def _execute(self) -> Sequence[Dict[str, Any]]:
+        query = await self.get_query()  # get the rendered SQL query
+        async with Atomic() as postgres_session:
+            result = await postgres_session.execute(text(query))
+            return [dict(zip(result.keys(), row)) for row in result.fetchall()]
+```
+
+## SQLBase
+
+`SQLBase` is configured once per project and defines which adapters are available for query execution. 
+It serves as the central point that connects queries with database adapters.
+
+Create a subclass with one or more adapters:
+
+```python
+from ddsql.sqlbase import SQLBase
+from ddsql.adapter import AdapterDescriptor
+
+
+class SQL(SQLBase):
+    postgres: PostgresAdapter = AdapterDescriptor(PostgresAdapter)
+    clickhouse: ClickhouseAdapter = AdapterDescriptor(ClickhouseAdapter)
+```
+
+Execution example:
+
+```python
+from ddsql.query import Query
+
+
+query = Query(...)
+result = await SQL(query=query).with_params(email='test@test.test', is_deleted=False).postgres.execute()
+```
+
+## Query
+
+`Query` knows where to get the template from and how to render a SQL query. 
+It also handles result deserialization via the `build_result` method, 
+which wraps raw database rows into the specified model (called internally by `Adapter.execute`).
+
+Required parameters:
+- **model** – a declarative class (e.g., dataclass) describing the output result structure;
+- **text** or **path** – the SQL template source.
+
+### Inline Template (text)
+
+```python
+from ddsql.query import Query
+
+
+query = Query(
+    model=User,
+    text='SELECT user_id, name FROM users WHERE user_id = {{ serialize_value(user_id) }}'
+)
+```
+
+### File Template (path)
+
+For file-based templates, set the `SQL_TEMPLATES_DIR` environment variable to the directory containing your SQL files:
+
+```bash
+export SQL_TEMPLATES_DIR=/app/src/templates/sql/
+```
+
+Then use a relative path:
+
+```python
+from ddsql.query import Query
+
+
+# Loads template from /app/src/templates/sql/users/get_by_id.sql
+query = Query(
+    model=User, 
+    path='users/get_by_id.sql'
+)
+```
+
+### Result
+
+The result of query execution is a `Result` object that wraps the data into the specified model:
+- `get()` – returns the first row as a model instance, or `None` if empty;
+- `get_list()` – returns all rows as a tuple of model instances;
+- `rows` – attribute for accessing raw data.
+
+## Complete Example
+
+```python
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+from ddsql.query import Query
+from ddsql.sqlbase import SQLBase
+from ddsql.adapter import Adapter, AdapterDescriptor
+from ddsql.serializers import PostgresSerializer
+
+
+class PostgresAdapter(Adapter):
+    serializer = PostgresSerializer()
+
+    async def _execute(self):
+        ...
+
+
+class SQL(SQLBase):
+    postgres: PostgresAdapter = AdapterDescriptor(PostgresAdapter)
+
+
+@dataclass
+class User:
+    user_id: int
+    name: str
+    email: Optional[str]
+    created_at: datetime
+    is_deleted: bool
+
+
+query = Query(
+    model=User,
+    text='''
+        SELECT *
+        FROM users
+        WHERE 
+            created_at > {{ serialize_value(created_after) }}
+        LIMIT {{ limit }}
+    '''
+)
+
+
+async def get_users():
+    result = await (
+        SQL(query=query)
+        .with_params(created_after=datetime(2025, 1, 1))
+        .with_params(limit=10)
+        .postgres
+        .execute()
+    )
+    return result.get_list()
+```

ddsql-0.0.1/ddsql/__init__.py

@@ -0,0 +1,3 @@
+from . import adapter, query, serializers, sqlbase
+
+__all__ = ('adapter', 'query', 'sqlbase', 'serializers')

ddsql-0.0.1/ddsql/adapter.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Sequence, Type, TypeVar
+
+from ddutils.annotation_helpers import is_subclass
+
+from ddsql.serializers import BaseSerializer
+
+if TYPE_CHECKING:
+    from ddsql.query import Result
+    from ddsql.sqlbase import SQLBase
+
+
+class Adapter(ABC):
+    serializer: BaseSerializer
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        serializer = getattr(cls, 'serializer', None)
+        serializer_class = getattr(serializer, '__class__', None)
+        if not is_subclass(serializer_class, BaseSerializer):
+            raise NotImplementedError(
+                'Subclass of Adapter must define a valid serializer attribute that is a subclass of Serializer'
+            )
+
+    def __init__(self, sql: SQLBase) -> None:
+        self.sql = sql
+
+    async def get_query(self) -> str:
+        return await self.sql.query.render_template(
+            params=self.sql.params, template_functions=self.serializer.template_functions
+        )
+
+    async def execute(self) -> Result:
+        return self.sql.query.build_result(await self._execute())
+
+    @abstractmethod
+    async def _execute(self) -> Sequence[Dict[str, Any]]:  # noqa: UP006
+        ...
+
+
+AdapterT = TypeVar('AdapterT', bound=Adapter)
+
+
+class AdapterDescriptor(Generic[AdapterT]):
+    adapter_class: Type[AdapterT]  # noqa: UP006
+
+    def __init__(self, adapter_class: Type[AdapterT]):  # noqa: UP006
+        self.adapter_class = adapter_class
+
+    def __get__(self, sql: SQLBase, sql_class: Optional[Type[SQLBase]] = None) -> AdapterT:  # noqa: UP006, UP007
+        return self.adapter_class(sql)
+
+
+__all__ = ('Adapter', 'AdapterDescriptor')

ddsql-0.0.1/ddsql/query.py

@@ -0,0 +1,81 @@
+import os
+from pathlib import Path
+from typing import Any, Dict, Generic, Optional, Sequence, Tuple, Type, TypeVar
+
+from jinja2 import Environment, FileSystemLoader, Template
+
+SQL_TEMPLATES_DIR = os.getenv('SQL_TEMPLATES_DIR')
+
+
+DataT = TypeVar('DataT')
+
+
+class Result(Generic[DataT]):
+    rows: Sequence[dict[str, Any]]
+    model: Type[DataT]
+
+    def __init__(self, rows: Sequence[dict[str, Any]], model: Type[DataT]):
+        self.rows = rows
+        self.model = model
+
+    def get(self) -> Optional[DataT]:
+        if not self.rows:
+            return None
+        return self.model(**self.rows[0])
+
+    def get_list(self) -> Tuple[DataT, ...]:
+        return tuple(self.model(**row) for row in self.rows)
+
+
+class Query(Generic[DataT]):
+    model: Type[DataT]
+    template: Template
+
+    def __init__(self, model: Type[DataT], text: Optional[str] = None, path: Optional[str] = None):
+        self.model = model
+
+        self.template = self.get_template(text, path)
+
+    @staticmethod
+    def get_template(text: Optional[str] = None, path: Optional[str] = None) -> Template:
+        if text:
+            file_system_loader = FileSystemLoader(Path('.'))
+            method = 'from_string'
+            query = text
+        elif path:
+            if SQL_TEMPLATES_DIR is None:
+                raise ValueError(
+                    'SQL Templates dir is not defined. Make sure the SQL_TEMPLATES_DIR environment variable is set correctly.'
+                )
+            file_system_loader = FileSystemLoader(Path(SQL_TEMPLATES_DIR))
+            method = 'get_template'
+            query = path
+        else:
+            raise ValueError('One of `text` or `path` must be specified')
+
+        environment = Environment(
+            loader=file_system_loader, trim_blocks=True, lstrip_blocks=True, keep_trailing_newline=True, enable_async=True
+        )
+
+        return getattr(environment, method)(query)
+
+    def update_globals(self, envs: Optional[Dict[str, Any]] = None):
+        if envs:
+            self.template.environment.globals.update(envs)
+
+    @staticmethod
+    def format_sql(sql: str) -> str:
+        strings = sql.split('\n')
+        return '\n'.join([string.strip() for string in strings])
+
+    async def render_template(self, params: Dict[str, Any], template_functions: Optional[Dict[str, Any]] = None) -> str:
+        self.update_globals(template_functions)
+
+        rendered_template = await self.template.render_async(**params)
+        return self.format_sql(rendered_template)
+
+    def build_result(self, rows: Sequence[dict[str, Any]]) -> Result[DataT]:
+        return Result(rows=rows, model=self.model)
+
+
+__all__ = ('Result', 'Query')

ddsql-0.0.1/ddsql/serializers/__init__.py

@@ -0,0 +1,5 @@
+from .base import BaseSerializer
+from .clickhouse import ClickhouseSerializer
+from .postgres import PostgresSerializer
+
+__all__ = ('BaseSerializer', 'ClickhouseSerializer', 'PostgresSerializer')

ddsql-0.0.1/ddsql/serializers/base.py

@@ -0,0 +1,71 @@
+from collections.abc import Callable, Collection, Mapping
+from datetime import date, datetime
+from decimal import Decimal
+from typing import Any, Dict, Union
+from uuid import UUID
+
+
+class BaseSerializer:
+    @property
+    def template_functions(self) -> Dict[str, Callable[[Any], str]]:
+        return {'serialize_value': self.serialize_value}
+
+    def serialize_value(self, value: Any) -> str:
+        if value is None:
+            return self.serialize_none(value)
+        elif isinstance(value, bool):
+            return self.serialize_bool(value)
+        elif isinstance(value, (int, float, Decimal)):
+            return self.serialize_number(value)
+        elif isinstance(value, str):
+            return self.serialize_string(value)
+        elif isinstance(value, UUID):
+            return self.serialize_uuid(value)
+        elif isinstance(value, datetime):
+            return self.serialize_datetime(value)
+        elif isinstance(value, date):
+            # the check for date must come after datetime,
+            # because a datetime instance can also be identified as a date
+            return self.serialize_date(value)
+        elif isinstance(value, Collection) and not isinstance(value, Mapping):
+            return self.serialize_collection(value)
+        else:
+            return self.serialize_other_object(value)
+
+    @staticmethod
+    def serialize_none(value) -> str:  # noqa: ARG004
+        return 'NULL'
+
+    @staticmethod
+    def serialize_bool(value: bool) -> str:
+        return f'{value}'.lower()
+
+    @staticmethod
+    def serialize_number(value: Union[int, float, Decimal]) -> str:
+        return f'{value}'
+
+    @staticmethod
+    def serialize_string(value: str) -> str:
+        return f"'{value}'"
+
+    @staticmethod
+    def serialize_uuid(value: UUID) -> str:
+        return f"'{value}'"
+
+    @staticmethod
+    def serialize_datetime(value: datetime) -> str:
+        return f"'{value.isoformat()}'"
+
+    @staticmethod
+    def serialize_date(value: date) -> str:
+        return f"'{value.isoformat()}'"
+
+    def serialize_collection(self, value: Collection) -> str:
+        items = ', '.join(self.serialize_value(item) for item in value)
+        return f'({items})'
+
+    def serialize_other_object(self, value: Any) -> str:
+        raise NotImplementedError()
+
+
+__all__ = ('BaseSerializer',)

ddsql-0.0.1/ddsql/serializers/clickhouse.py

@@ -0,0 +1,21 @@
+from datetime import date, datetime
+from uuid import UUID
+
+from ddsql.serializers import BaseSerializer
+
+
+class ClickhouseSerializer(BaseSerializer):
+    @staticmethod
+    def serialize_uuid(value: UUID) -> str:
+        return f"toUUID('{value}')"
+
+    @staticmethod
+    def serialize_datetime(value: datetime) -> str:
+        return f"parseDateTimeBestEffort('{value.isoformat()}')"
+
+    @staticmethod
+    def serialize_date(value: date) -> str:
+        return f"toDate('{value.isoformat()}')"
+
+
+__all__ = ('ClickhouseSerializer',)

ddsql-0.0.1/ddsql/serializers/postgres.py

@@ -0,0 +1,21 @@
+from datetime import date, datetime
+from uuid import UUID
+
+from ddsql.serializers import BaseSerializer
+
+
+class PostgresSerializer(BaseSerializer):
+    @staticmethod
+    def serialize_uuid(value: UUID) -> str:
+        return f"'{value}'::uuid"
+
+    @staticmethod
+    def serialize_datetime(value: datetime) -> str:
+        return f"'{value.isoformat()}'::timestamp"
+
+    @staticmethod
+    def serialize_date(value: date) -> str:
+        return f"'{value.isoformat()}'::date"
+
+
+__all__ = ('PostgresSerializer',)

ddsql-0.0.1/ddsql/sqlbase.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING, Any, Dict
+
+from ddutils.annotation_helpers import is_subclass
+from ddutils.class_helpers import classproperty
+
+from ddsql.adapter import Adapter
+
+if TYPE_CHECKING:
+    from ddsql.query import Query
+
+
+class SQLBase(ABC):
+    """
+    Abstract base class for SQL query execution with adapter-based database connections.
+
+    This class provides a foundation for executing SQL queries against different database backends
+    using adapters. It handles query preparation, parameter management, and adapter selection.
+
+    Subclasses must define at least one adapter as a class attribute.
+
+    Attributes:
+        query: The SQL query to execute, either as a Query object or raw SQL string
+        params: Dictionary of parameters to be used in the query
+    """
+
+    query: Query
+    params: Dict[str, Any]
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        if not cls.has_adapters:
+            raise NotImplementedError('Subclasses must define at least one adapter')
+
+    @classproperty
+    def has_adapters(cls) -> bool:
+        for field in cls.__annotations__:
+            adapter = getattr(cls, field, None)
+            adapter_class = getattr(adapter, '__class__', None)
+            if adapter_class and is_subclass(adapter_class, Adapter):
+                return True
+
+        return False
+
+    def __init__(self, query: Query) -> None:
+        self.query = query
+        self.params = {}
+
+    def with_params(self, **params: Any) -> SQLBase:
+        self.params = {**self.params, **params}
+        return self
+
+
+__all__ = ('SQLBase',)

ddsql-0.0.1/pyproject.toml

@@ -0,0 +1,33 @@
+[tool.poetry]
+name = "ddsql"
+description = "SQL Query Library"
+version = "0.0.1"
+authors = ["davyddd"]
+license = "MIT"
+repository = "https://github.com/davyddd/ddsql"
+readme = "README.md"
+keywords = ["python", "ddsql"]
+packages = [{include = "ddsql"}]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<3.15"
+ddutils = "<0.2.0"
+jinja2 = ">=3.0.0,<4.0.0"
+
+[tool.poetry.group.dev.dependencies]
+ipdb = "0.13.9"
+ipython = "8.12.3"
+
+[tool.poetry.group.test.dependencies]
+pytest = "8.1.1"
+pytest-cov = "5.0.0"
+parameterized = "0.9.0"
+typing-extensions = "^4.12.2"
+
+[tool.poetry.group.linter.dependencies]
+mypy = "1.18.2"
+ruff = "0.14.4"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"