david8-duckdb 0.2.0b1__tar.gz

david8_duckdb-0.2.0b1/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: david8_duckdb
+Version: 0.2.0b1
+Summary: SQL query builder. david8 duckdb dielect
+Author-email: Danila Ganchar <danila.ganchar@gmail.com>
+Maintainer-email: Danila Ganchar <danila.ganchar@gmail.com>
+Project-URL: Homepage, https://github.com/d-ganchar/david8_duckdb
+Project-URL: Changelog, https://github.com/d-ganchar/david8_duckdb/releases
+Project-URL: Issues, https://github.com/d-ganchar/david8_duckdb/issues
+Project-URL: CI, https://github.com/d-ganchar/david8_duckdb/actions
+Project-URL: Documentation, https://github.com/d-ganchar/david8_duckdb/wiki
+Project-URL: Source, https://github.com/d-ganchar/david8_duckdb
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Database
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: david8<2.0.0b1,>=1.0.0b1
+
+# david8_duckdb
+
+`david8_duckdb` is [DuckDb](https://duckdb.org/) dialect for [david8](https://github.com/d-ganchar/david8)
+
+See [Wiki](https://github.com/d-ganchar/david8_duckdb/wiki)

david8_duckdb-0.2.0b1/README.md

@@ -0,0 +1,5 @@
+# david8_duckdb
+
+`david8_duckdb` is [DuckDb](https://duckdb.org/) dialect for [david8](https://github.com/d-ganchar/david8)
+
+See [Wiki](https://github.com/d-ganchar/david8_duckdb/wiki)

david8_duckdb-0.2.0b1/david8_duckdb/__init__.py

@@ -0,0 +1,10 @@
+from david8.core.base_dialect import BaseDialect as _BaseDialect
+from david8.param_styles import QMarkParamStyle
+
+from .core.query_builder import DuckDbQueryBuilder as _QueryBuilder
+from .protocols.query_builder import QueryBuilderProtocol
+
+
+def get_qb(is_quote_mode: bool = False) -> QueryBuilderProtocol:
+    dialect = _BaseDialect(QMarkParamStyle(), is_quote_mode)
+    return _QueryBuilder(dialect)

david8_duckdb-0.2.0b1/david8_duckdb/core/copy_to_query.py

@@ -0,0 +1,29 @@
+import dataclasses
+
+from david8.core.base_query import BaseQuery
+from david8.protocols.dialect import DialectProtocol
+
+from david8_duckdb.protocols.sql import SelectProtocol
+
+
+@dataclasses.dataclass(slots=True)
+class CopyToQuery(BaseQuery):
+    source: str | SelectProtocol
+    target: str
+    copy_options: dict = None
+
+    def _render_sql(self, dialect: DialectProtocol) -> str:
+        source = f'({self.source.get_sql(dialect)})' if isinstance(self.source, SelectProtocol) else self.source
+        return f"COPY {source} TO '{self.target}'"
+
+    def _render_sql_postfix(self, dialect: DialectProtocol) -> str:
+        if not self.copy_options:
+            return ''
+
+        option_items = []
+        for key, value in self.copy_options.items():
+            if value is not None:
+                fixed_value = str(value).lower() if isinstance(value, bool) else value
+                option_items.append(f'{key} {fixed_value}')
+
+        return f' ({", ".join(option_items)})'

david8_duckdb-0.2.0b1/david8_duckdb/core/query_builder.py

@@ -0,0 +1,15 @@
+from david8.core.base_query_builder import BaseQueryBuilder as _BaseQueryBuilder
+from david8.protocols.sql import AliasedProtocol, ExprProtocol, FunctionProtocol, QueryProtocol
+
+from ..protocols.query_builder import QueryBuilderProtocol
+from ..protocols.sql import SelectProtocol
+from .copy_to_query import CopyToQuery
+from .select_query import DuckDbSelect
+
+
+class DuckDbQueryBuilder(QueryBuilderProtocol, _BaseQueryBuilder):
+    def select(self, *args: str | AliasedProtocol | ExprProtocol | FunctionProtocol) -> SelectProtocol:
+        return DuckDbSelect(select_columns=args, dialect=self._dialect)
+
+    def copy_to(self, source: str | SelectProtocol, target: str, copy_options: dict = None) -> QueryProtocol:
+        return CopyToQuery(dialect=self._dialect, source=source, target=target, copy_options=copy_options)

david8_duckdb-0.2.0b1/david8_duckdb/core/select_query.py

@@ -0,0 +1,50 @@
+import dataclasses
+
+from david8.core.base_dql import BaseSelect as _BaseSelect
+from david8.protocols.dialect import DialectProtocol
+
+from ..protocols.sql import SelectProtocol
+
+
+@dataclasses.dataclass(slots=True)
+class DuckDbSelect(_BaseSelect, SelectProtocol):
+    from_files: tuple[str, tuple[str, ...]] = dataclasses.field(default_factory=tuple)
+
+    def from_csv(self, *file_names: str) -> 'SelectProtocol':
+        self.from_files = ('read_csv', file_names)
+        return self
+
+    def from_json(self, *file_names: str) -> 'SelectProtocol':
+        self.from_files = ('read_json', file_names)
+        return self
+
+    def from_json_objects(self, *file_names: str) -> 'SelectProtocol':
+        self.from_files = ('read_json_objects', file_names)
+        return self
+
+    def from_ndjson_objects(self, *file_names: str) -> 'SelectProtocol':
+        self.from_files = ('read_ndjson_objects', file_names)
+        return self
+
+    def from_json_objects_auto(self, *file_names: str) -> 'SelectProtocol':
+        self.from_files = ('read_json_objects_auto', file_names)
+        return self
+
+    def from_parquet(self, *file_names: str) -> 'SelectProtocol':
+        self.from_files = ('read_parquet', file_names)
+        return self
+
+    def from_xlsx(self, file_name: str) -> 'SelectProtocol':
+        self.from_files = ('read_xlsx', (file_name,))
+        return self
+
+    def _from_to_sql(self, dialect: DialectProtocol) -> str:
+        if not self.from_files:
+            return _BaseSelect._from_to_sql(self, dialect)
+
+        if len(self.from_files[1]) > 1:
+            files = str(list(self.from_files[1]))
+        else:
+            files = f"'{self.from_files[1][0]}'"
+
+        return f' FROM {self.from_files[0]}({files})'

david8_duckdb-0.2.0b1/david8_duckdb/protocols/query_builder.py

@@ -0,0 +1,19 @@
+from david8.protocols.query_builder import QueryBuilderProtocol as _QueryBuilderProtocol
+from david8.protocols.sql import AliasedProtocol, ExprProtocol, FunctionProtocol, QueryProtocol
+
+from ..protocols.sql import SelectProtocol
+
+
+class QueryBuilderProtocol(_QueryBuilderProtocol):
+    def select(self, *args: str | AliasedProtocol | ExprProtocol | FunctionProtocol) -> SelectProtocol:
+        pass
+
+    def copy_to(self, source: str | SelectProtocol, target: str, copy_options: dict = None) -> QueryProtocol:
+        """
+        :param source: query or table
+        :param target: file name
+        :param copy_options: https://duckdb.org/docs/stable/sql/statements/copy#copy--to-options
+
+        example:
+            qb.copy_to('events', 'events.parquet', {'FORMAT': 'parquet', 'DELIMITER': "','", 'APPEND': True})
+        """

david8_duckdb-0.2.0b1/david8_duckdb/protocols/sql.py

@@ -0,0 +1,38 @@
+from david8.protocols.sql import SelectProtocol as _SelectProtocol
+
+
+class SelectProtocol(_SelectProtocol):
+    def from_csv(self, *file_names: str) -> 'SelectProtocol':
+        """
+        https://duckdb.org/docs/stable/data/csv/reading_faulty_csv_files
+        """
+
+    def from_json(self, *file_names: str) -> 'SelectProtocol':
+        """
+        https://duckdb.org/docs/stable/data/json/loading_json#the-read_json-function
+        """
+
+    def from_json_objects(self, *file_names: str) -> 'SelectProtocol':
+        """
+        https://duckdb.org/docs/stable/data/json/loading_json#functions-for-reading-json-objects
+        """
+
+    def from_ndjson_objects(self, *file_names: str) -> 'SelectProtocol':
+        """
+        https://duckdb.org/docs/stable/data/json/loading_json#functions-for-reading-json-objects
+        """
+
+    def from_json_objects_auto(self, *file_names: str) -> 'SelectProtocol':
+        """
+        https://duckdb.org/docs/stable/data/json/loading_json#functions-for-reading-json-objects
+        """
+
+    def from_parquet(self, *file_names: str) -> 'SelectProtocol':
+        """
+        read_parquet(): https://duckdb.org/docs/stable/data/parquet/overview
+        """
+
+    def from_xlsx(self, file_name: str) -> 'SelectProtocol':
+        """
+        read_xlsx(): https://duckdb.org/docs/stable/core_extensions/excel
+        """

david8_duckdb-0.2.0b1/david8_duckdb.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: david8_duckdb
+Version: 0.2.0b1
+Summary: SQL query builder. david8 duckdb dielect
+Author-email: Danila Ganchar <danila.ganchar@gmail.com>
+Maintainer-email: Danila Ganchar <danila.ganchar@gmail.com>
+Project-URL: Homepage, https://github.com/d-ganchar/david8_duckdb
+Project-URL: Changelog, https://github.com/d-ganchar/david8_duckdb/releases
+Project-URL: Issues, https://github.com/d-ganchar/david8_duckdb/issues
+Project-URL: CI, https://github.com/d-ganchar/david8_duckdb/actions
+Project-URL: Documentation, https://github.com/d-ganchar/david8_duckdb/wiki
+Project-URL: Source, https://github.com/d-ganchar/david8_duckdb
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Database
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: david8<2.0.0b1,>=1.0.0b1
+
+# david8_duckdb
+
+`david8_duckdb` is [DuckDb](https://duckdb.org/) dialect for [david8](https://github.com/d-ganchar/david8)
+
+See [Wiki](https://github.com/d-ganchar/david8_duckdb/wiki)

david8_duckdb-0.2.0b1/david8_duckdb.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+david8_duckdb/__init__.py
+david8_duckdb.egg-info/PKG-INFO
+david8_duckdb.egg-info/SOURCES.txt
+david8_duckdb.egg-info/dependency_links.txt
+david8_duckdb.egg-info/requires.txt
+david8_duckdb.egg-info/top_level.txt
+david8_duckdb/core/__init__.py
+david8_duckdb/core/copy_to_query.py
+david8_duckdb/core/query_builder.py
+david8_duckdb/core/select_query.py
+david8_duckdb/protocols/__init__.py
+david8_duckdb/protocols/query_builder.py
+david8_duckdb/protocols/sql.py
+tests/test_copy_to.py
+tests/test_select.py

david8_duckdb-0.2.0b1/david8_duckdb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

david8_duckdb-0.2.0b1/david8_duckdb.egg-info/requires.txt

@@ -0,0 +1 @@
+david8<2.0.0b1,>=1.0.0b1

david8_duckdb-0.2.0b1/david8_duckdb.egg-info/top_level.txt

@@ -0,0 +1 @@
+david8_duckdb

david8_duckdb-0.2.0b1/pyproject.toml

@@ -0,0 +1,83 @@
+[project]
+name = "david8_duckdb"
+version = "0.2.0b1"
+description = "SQL query builder. david8 duckdb dielect"
+authors = [{name = "Danila Ganchar", email = "danila.ganchar@gmail.com"}]
+maintainers = [{name = "Danila Ganchar", email = "danila.ganchar@gmail.com"}]
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.11, < 3.14"
+dependencies = [
+    "david8>=1.0.0b1,<2.0.0b1"
+]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Database",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+
+[project.urls]
+Homepage = "https://github.com/d-ganchar/david8_duckdb"
+Changelog = "https://github.com/d-ganchar/david8_duckdb/releases"
+Issues = "https://github.com/d-ganchar/david8_duckdb/issues"
+CI = "https://github.com/d-ganchar/david8_duckdb/actions"
+Documentation = "https://github.com/d-ganchar/david8_duckdb/wiki"
+Source = "https://github.com/d-ganchar/david8_duckdb"
+
+
+[build-system]
+requires = ["setuptools>=77.0.0"]
+build-backend = "setuptools.build_meta"
+
+
+[tool.setuptools.packages]
+find = { include = ["david8_duckdb", "david8_duckdb.*"] }
+
+
+[dependency-groups]
+dev = [
+    "ruff",
+    "parameterized",
+    "pytest",
+    "pytest-cov>=7.0.0",
+]
+
+[lint.select]
+
+[lint.isort]
+known-third-party = ["pytest"]
+lines-after-imports = 2
+lines-between-types = 1
+
+
+[tool.ruff]
+line-length = 120
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    "**/.git",
+    "__pycache__",
+    "tests/fixtures/",
+    "benchmarks/"
+]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "N", "B", "W"]
+
+[tool.pytest.ini_options]
+testpaths = [
+    "tests",
+    "--color=yes",
+]
+
+addopts = [
+
+]

david8_duckdb-0.2.0b1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

david8_duckdb-0.2.0b1/tests/test_copy_to.py

@@ -0,0 +1,35 @@
+from david8.protocols.sql import QueryProtocol
+from parameterized import parameterized
+
+from tests.base_test import BaseTest
+
+
+class TestCopyTo(BaseTest):
+    @parameterized.expand([
+        (
+            BaseTest.qb.copy_to('events', 'events.csv'),
+            "COPY events TO 'events.csv'",
+        ),
+        (
+            BaseTest.qb.copy_to('events', 'events.csv', {'DELIMITER': "','", 'APPEND': True}),
+            "COPY events TO 'events.csv' (DELIMITER ',', APPEND true)",
+        ),
+        # query
+        (
+            BaseTest.qb.copy_to(
+                BaseTest.qb.select('name', 'value').from_table('events'),
+                'events.csv'
+            ),
+            "COPY (SELECT name, value FROM events) TO 'events.csv'"
+        ),
+        (
+            BaseTest.qb.copy_to(
+                BaseTest.qb.select('name', 'value').from_table('events'),
+                'events.csv',
+                {'DELIMITER': "','", 'APPEND': True},
+            ),
+            "COPY (SELECT name, value FROM events) TO 'events.csv' (DELIMITER ',', APPEND true)",
+        ),
+    ])
+    def test_copy_to(self, query: QueryProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)

david8_duckdb-0.2.0b1/tests/test_select.py

@@ -0,0 +1,93 @@
+from parameterized import parameterized
+
+from david8_duckdb.protocols.sql import SelectProtocol
+from tests.base_test import BaseTest
+
+
+class TestSelect(BaseTest):
+    @parameterized.expand([
+        (
+            BaseTest.qb.select('*').from_csv('faulty.csv'),
+            "SELECT * FROM read_csv('faulty.csv')",
+        ),
+        (
+            BaseTest.qb.select('*').from_csv('flights1.csv', 'flights2.csv'),
+            "SELECT * FROM read_csv(['flights1.csv', 'flights2.csv'])",
+        ),
+    ])
+    def test_from_csv(self, query: SelectProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)
+
+    @parameterized.expand([
+        (
+            BaseTest.qb.select('*').from_json('todos.json'),
+            "SELECT * FROM read_json('todos.json')",
+        ),
+        (
+            BaseTest.qb.select('*').from_json('todos1.json', 'todos2.json'),
+            "SELECT * FROM read_json(['todos1.json', 'todos2.json'])",
+        ),
+    ])
+    def test_from_json(self, query: SelectProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)
+
+    @parameterized.expand([
+        (
+            BaseTest.qb.select('*').from_json_objects('todos.json'),
+            "SELECT * FROM read_json_objects('todos.json')",
+        ),
+        (
+            BaseTest.qb.select('*').from_json_objects('todos1.json', 'todos2.json'),
+            "SELECT * FROM read_json_objects(['todos1.json', 'todos2.json'])",
+        ),
+    ])
+    def test_from_json_objects(self, query: SelectProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)
+
+    @parameterized.expand([
+        (
+            BaseTest.qb.select('*').from_ndjson_objects('todos.json'),
+            "SELECT * FROM read_ndjson_objects('todos.json')",
+        ),
+        (
+            BaseTest.qb.select('*').from_ndjson_objects('todos1.json', 'todos2.json'),
+            "SELECT * FROM read_ndjson_objects(['todos1.json', 'todos2.json'])",
+        ),
+    ])
+    def test_from_ndjson_objects(self, query: SelectProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)
+
+    @parameterized.expand([
+        (
+            BaseTest.qb.select('*').from_json_objects_auto('todos.json'),
+            "SELECT * FROM read_json_objects_auto('todos.json')",
+        ),
+        (
+            BaseTest.qb.select('*').from_json_objects_auto('todos1.json', 'todos2.json'),
+            "SELECT * FROM read_json_objects_auto(['todos1.json', 'todos2.json'])",
+        ),
+    ])
+    def test_from_json_objects_auto(self, query: SelectProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)
+
+    @parameterized.expand([
+        (
+            BaseTest.qb.select('*').from_parquet('file.parquet'),
+            "SELECT * FROM read_parquet('file.parquet')",
+        ),
+        (
+            BaseTest.qb.select('*').from_parquet('file1.parquet', 'file2.parquet'),
+            "SELECT * FROM read_parquet(['file1.parquet', 'file2.parquet'])",
+        ),
+    ])
+    def test_from_parquet(self, query: SelectProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)
+
+    @parameterized.expand([
+        (
+            BaseTest.qb.select('*').from_xlsx('test.xlsx'),
+            "SELECT * FROM read_xlsx('test.xlsx')",
+        ),
+    ])
+    def test_from_xlsx(self, query: SelectProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)