david8 0.dev5__tar.gz → 0.2.0b1__tar.gz

{david8-0.dev5 → david8-0.2.0b1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: david8
-Version: 0.dev5
-Summary: Lightweight Python SQL query builder with support for multiple dialects: ClickHouse and PostgreSQL
+Version: 0.2.0b1
+Summary: Lightweight Python SQL query builder with support for multiple dialects: ClickHouse, PostgreSQL, DuckDB, MySQL and SQLite
 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
@@ -10,7 +10,7 @@ Project-URL: Issues, https://github.com/d-ganchar/david8/issues
 Project-URL: CI, https://github.com/d-ganchar/david8/actions
 Project-URL: Documentation, https://github.com/d-ganchar/david8/wiki
 Project-URL: Source, https://github.com/d-ganchar/david8
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Database
@@ -37,6 +37,6 @@ predictable and ergonomic workflow
 
 - Zero dependencies
 - Zero global objects
-- Built-in base support for ClickHouse, PostgreSQL, DuckDB, and MySQL
+- Built-in base support for ClickHouse, PostgreSQL, DuckDB, MySQL and SQLite
 
 See [Wiki](https://github.com/d-ganchar/david8/wiki)

{david8-0.dev5 → david8-0.2.0b1}/README.md

@@ -12,6 +12,6 @@ predictable and ergonomic workflow
 
 - Zero dependencies
 - Zero global objects
-- Built-in base support for ClickHouse, PostgreSQL, DuckDB, and MySQL
+- Built-in base support for ClickHouse, PostgreSQL, DuckDB, MySQL and SQLite
 
 See [Wiki](https://github.com/d-ganchar/david8/wiki)

david8-0.2.0b1/david8/cast_types.py

@@ -0,0 +1,16 @@
+text = 'TEXT'
+integer = 'INTEGER'
+smallint = 'SMALLINT'
+bigint = 'BIGINT'
+date_ = 'DATE'
+time_ = 'TIME'
+timestamp_ = 'TIMESTAMP'
+boolean = 'BOOLEAN'
+
+
+def varchar(char_length: int) -> str:
+    return f'VARCHAR({char_length})'
+
+
+def char(char_length: int) -> str:
+    return f'CHAR({char_length})'

david8-0.2.0b1/david8/core/arg_convertors.py

@@ -0,0 +1,8 @@
+from ..protocols.dialect import DialectProtocol
+from ..protocols.sql import ExprProtocol
+
+
+def to_col_or_expr(value: str | ExprProtocol, dialect: DialectProtocol) -> str:
+    if isinstance(value, str):
+        return dialect.quote_ident(value)
+    return value.get_sql(dialect)

{david8-0.dev5 → david8-0.2.0b1}/david8/core/base_aliased.py

@@ -35,6 +35,15 @@ class Value(BaseAliased, ValueProtocol):
         return f'{self._value}'
 
 
+class SqlType(BaseAliased):
+    def __init__(self, name: str) -> None:
+        super().__init__()
+        self._name = name
+
+    def _get_sql(self, dialect: DialectProtocol) -> str:
+        return f'{self._name}'
+
+
 class Parameter(BaseAliased, ParameterProtocol):
     def __init__(self, value: str | int | float, fixed_name: bool = False) -> None:
         super().__init__()

{david8-0.dev5 → david8-0.2.0b1}/david8/core/base_dml.py

@@ -67,18 +67,18 @@ class BaseSelect(SelectProtocol):
         self.limit_value = value
         return self
 
-    def _columns_to_sql(self) -> str:
+    def _columns_to_sql(self, dialect: DialectProtocol) -> str:
         return ', '.join(
-            self.dialect.quote_ident(column)
-            if isinstance(column, str) else column.get_sql(self.dialect)
+            dialect.quote_ident(column)
+            if isinstance(column, str) else column.get_sql(dialect)
             for column in self.select_columns
         )
 
-    def _where_to_sql(self) -> str:
+    def _where_to_sql(self, dialect: DialectProtocol) -> str:
         if not self.where_conditions:
             return ''
 
-        return f" WHERE {' AND '.join(predicate.get_sql(self.dialect) for predicate in self.where_conditions)}"
+        return f" WHERE {' AND '.join(predicate.get_sql(dialect) for predicate in self.where_conditions)}"
 
     def _order_by_to_sql(self) -> str:
         if not self.order_by_expressions:
@@ -91,60 +91,60 @@ class BaseSelect(SelectProtocol):
 
         return f" ORDER BY {', '.join(order_items)}"
 
-    def _with_queries_to_sql(self) -> str:
+    def _with_queries_to_sql(self, dialect: DialectProtocol) -> str:
         if not self.with_queries:
             return ''
 
         with_items = ', '.join(
-            f'{self.dialect.quote_ident(alias)} AS ({query.get_sql(self.dialect)})'
+            f'{dialect.quote_ident(alias)} AS ({query.get_sql(dialect)})'
             for alias, query in self.with_queries
         )
 
         return f'WITH {with_items} '
 
-    def _from_to_sql(self) -> str:
+    def _from_to_sql(self, dialect: DialectProtocol) -> str:
         if self.from_query_expr:
-            source = f'({self.from_query_expr.get_sql(self.dialect)})'
+            source = f'({self.from_query_expr.get_sql(dialect)})'
         elif self.from_table_value:
-            source = self.dialect.quote_ident(self.from_table_value)
+            source = dialect.quote_ident(self.from_table_value)
             if self.from_db_value:
-                source = f'{self.dialect.quote_ident(self.from_db_value)}.{source}'
+                source = f'{dialect.quote_ident(self.from_db_value)}.{source}'
         else:
             return ''
 
-        source = f'{source} AS {self.dialect.quote_ident(self.source_alias)}' if self.source_alias else source
+        source = f'{source} AS {dialect.quote_ident(self.source_alias)}' if self.source_alias else source
         return f' FROM {source}'
 
-    def _union_to_sql(self) -> str:
+    def _union_to_sql(self, dialect: DialectProtocol) -> str:
         if not self.unions:
             return ''
 
         return ' ' + ' '.join(
-            f"UNION{' ALL' if union_type else ''} {query.get_sql(self.dialect)}"
+            f"UNION{' ALL' if union_type else ''} {query.get_sql(dialect)}"
             for union_type, query in self.unions
         )
 
-    def _group_by_to_sql(self) -> str:
+    def _group_by_to_sql(self, dialect: DialectProtocol) -> str:
         if not self.group_by_expressions:
             return ''
 
         return ' GROUP BY ' + ', '.join(
-            f"{self.dialect.quote_ident(f) if isinstance(f, str) else str(f)}"
+            f"{dialect.quote_ident(f) if isinstance(f, str) else str(f)}"
             for f in self.group_by_expressions
         )
 
-    def _having_to_sql(self) -> str:
+    def _having_to_sql(self, dialect: DialectProtocol) -> str:
         if not self.having_expressions:
             return ''
 
-        return f" HAVING {' AND '.join(p.get_sql(self.dialect) for p in self.having_expressions)}"
+        return f" HAVING {' AND '.join(p.get_sql(dialect) for p in self.having_expressions)}"
 
-    def _joins_to_sql(self) -> str:
+    def _joins_to_sql(self, dialect: DialectProtocol) -> str:
         if not self.joins:
             return ''
 
         return ' ' + ' '.join(
-            join.get_sql(self.dialect)
+            join.get_sql(dialect)
             for join in self.joins
         )
 
@@ -169,21 +169,25 @@ class BaseSelect(SelectProtocol):
         """
         if dialect is None:
             self.dialect.get_paramstyle().reset_parameters()
-
-        with_query = self._with_queries_to_sql()
-        select = self._columns_to_sql()
-        from_ref = self._from_to_sql()
-        joins = self._joins_to_sql()
-        where = self._where_to_sql()
-        group_by = self._group_by_to_sql()
-        having = self._having_to_sql()
-        union = self._union_to_sql()
+            dialect = self.dialect
+            log_query = True
+        else:
+            log_query = False
+
+        with_query = self._with_queries_to_sql(dialect)
+        select = self._columns_to_sql(dialect)
+        from_ref = self._from_to_sql(dialect)
+        joins = self._joins_to_sql(dialect)
+        where = self._where_to_sql(dialect)
+        group_by = self._group_by_to_sql(dialect)
+        having = self._having_to_sql(dialect)
+        union = self._union_to_sql(dialect)
         order_by = self._order_by_to_sql()
 
         limit = f' LIMIT {self.limit_value}' if self.limit_value else ''
         sql = f'{with_query}SELECT {select}{from_ref}{joins}{where}{group_by}{order_by}{having}{limit}{union}'
-        if dialect is None:
-            log.info('%s %s', sql, self.get_parameters())
+        if log_query:
+            log.info('%s\n%s', sql, self.get_parameters())
 
         return sql
 

{david8-0.dev5 → david8-0.2.0b1}/david8/core/fn_generator.py

@@ -1,5 +1,6 @@
 import dataclasses
 
+from david8.core.arg_convertors import to_col_or_expr
 from david8.core.base_aliased import BaseAliased
 from david8.protocols.dialect import DialectProtocol
 from david8.protocols.sql import ExprProtocol, FunctionProtocol
@@ -9,6 +10,17 @@ from david8.protocols.sql import ExprProtocol, FunctionProtocol
 class Function(BaseAliased, FunctionProtocol):
     name: str
 
+    def _get_sql(self, dialect: DialectProtocol) -> str:
+        return f"{self.name}()"
+
+
+@dataclasses.dataclass(slots=True, kw_only=True)
+class ZeroArgsCallableFactory:
+    name: str = ''
+
+    def __call__(self) -> FunctionProtocol:
+        return Function(self.name)
+
 
 @dataclasses.dataclass(slots=True, kw_only=True)
 class FnCallableFactory:
@@ -65,3 +77,45 @@ class _OneArgDistinctFn(Function):
 class OneArgDistinctCallableFactory(FnCallableFactory):
     def __call__(self, column: str, distinct: bool = False) -> FunctionProtocol:
         return _OneArgDistinctFn(self.name, column, distinct)
+
+
+@dataclasses.dataclass(slots=True)
+class _StrArgFn(Function):
+    """
+    upper(col_name)
+    lower(col_name)
+    etc
+    """
+    value: str | ExprProtocol = ''
+
+    def _get_sql(self, dialect: DialectProtocol) -> str:
+        if isinstance(self.value, str):
+            value = dialect.quote_ident(self.value)
+        else:
+            value = self.value.get_sql(dialect)
+        return f"{self.name}({value})"
+
+
+@dataclasses.dataclass(slots=True)
+class StrArgCallableFactory(FnCallableFactory):
+    value: str = ''
+
+    def __call__(self, value: str | ExprProtocol) -> FunctionProtocol:
+        return _StrArgFn(self.name, value)
+
+
+@dataclasses.dataclass(slots=True)
+class _CastFn(Function):
+    value: str | ExprProtocol
+    cast_type: str
+
+    def _get_sql(self, dialect: DialectProtocol) -> str:
+        value = to_col_or_expr(self.value, dialect)
+        return f"{self.name}({value} AS {self.cast_type})"
+
+
+@dataclasses.dataclass(slots=True)
+class CastCallableFactory(FnCallableFactory):
+    name = 'CAST'
+    def __call__(self, value: str | ExprProtocol, cast_type: str) -> FunctionProtocol:
+        return _CastFn('CAST', value, cast_type)

{david8-0.dev5 → david8-0.2.0b1}/david8/core/sql_92_join.py

@@ -21,7 +21,7 @@ class Sql92Join(Sql92JoinProtocol):
 
     def get_sql(self, dialect: DialectProtocol) -> str:
         if self.from_query:
-            source = self.from_query.get_sql(dialect)
+            source = f'({self.from_query.get_sql(dialect)})'
         else:
             table, db = self.from_table
             source = dialect.quote_ident(table)

{david8-0.dev5 → david8-0.2.0b1}/david8/expressions.py

@@ -1,7 +1,8 @@
 from david8.core.base_aliased import Column as _Column
 from david8.core.base_aliased import Parameter as _Parameter
+from david8.core.base_aliased import SqlType as _SqlType
 from david8.core.base_aliased import Value as _Value
-from david8.protocols.sql import ValueProtocol
+from david8.protocols.sql import AliasedProtocol, ValueProtocol
 
 
 def val(value: str | int | float) -> ValueProtocol:
@@ -12,3 +13,12 @@ def col(name: str) -> _Column:
 
 def param(value: str | int | float, fixed_name: bool = False) -> _Parameter:
     return _Parameter(value, fixed_name)
+
+def true() -> AliasedProtocol:
+    return _SqlType('TRUE')
+
+def false() -> AliasedProtocol:
+    return _SqlType('FALSE')
+
+def null() -> AliasedProtocol:
+    return _SqlType('NULL')

david8-0.2.0b1/david8/functions.py

@@ -0,0 +1,35 @@
+from david8.core.fn_generator import (
+    CastCallableFactory as _CastCallableFactory,
+)
+from david8.core.fn_generator import (
+    OneArgDistinctCallableFactory as _AggDistinctCallableFactory,
+)
+from david8.core.fn_generator import (
+    SeparatedStrArgsCallableFactory as _SeparatedStrArgsCallableFactory,
+)
+from david8.core.fn_generator import (
+    StrArgCallableFactory as _StrArgCallableFactory,
+)
+from david8.core.fn_generator import (
+    ZeroArgsCallableFactory as _ZeroArgsCallableFactory,
+)
+
+# length('col_name') | length(val('MyVAR')) | length(param('myParam')) | length(concat('col1', 'col2'))
+lower = _StrArgCallableFactory(name='lower')
+upper = _StrArgCallableFactory(name='upper')
+length = _StrArgCallableFactory(name='length')
+trim = _StrArgCallableFactory(name='trim')
+
+# count('name', True) => count(DISTINCT name), min_('age', True) => min(DISTINCT age) = 33
+count = _AggDistinctCallableFactory(name='count')
+avg = _AggDistinctCallableFactory(name='avg')
+sum_ = _AggDistinctCallableFactory(name='sum')
+max_ = _AggDistinctCallableFactory(name='max')
+min_ = _AggDistinctCallableFactory(name='min')
+
+concat = _SeparatedStrArgsCallableFactory(name='concat', separator=', ')
+
+now_ = _ZeroArgsCallableFactory(name='now')
+uuid_ = _ZeroArgsCallableFactory(name='uuid')
+
+cast = _CastCallableFactory()

david8-0.2.0b1/david8/logical_operators.py

@@ -0,0 +1,43 @@
+import dataclasses
+from typing import Union
+
+from .core.arg_convertors import to_col_or_expr
+from .protocols.dialect import DialectProtocol
+from .protocols.sql import ExprProtocol, LogicalOperatorProtocol
+
+
+@dataclasses.dataclass(slots=True)
+class _ArgsLogicalOperator(LogicalOperatorProtocol):
+    _name: str
+    _conditions: Union[ExprProtocol, 'LogicalOperatorProtocol', ...]
+
+    def get_sql(self, dialect: DialectProtocol) -> str:
+        conditions = f' {self._name} '.join(c.get_sql(dialect) for c in self._conditions)
+        return f'({conditions})'
+
+
+@dataclasses.dataclass(slots=True)
+class _NotLogicalOperator(LogicalOperatorProtocol):
+    _value: str | ExprProtocol
+
+    def get_sql(self, dialect: DialectProtocol) -> str:
+        return f'NOT {to_col_or_expr(self._value, dialect)}'
+
+
+def or_(*args: ExprProtocol | LogicalOperatorProtocol) -> LogicalOperatorProtocol:
+    return _ArgsLogicalOperator(_name='OR', _conditions=args)
+
+
+def and_(*args: ExprProtocol | LogicalOperatorProtocol) -> LogicalOperatorProtocol:
+    return _ArgsLogicalOperator(_name='AND', _conditions=args)
+
+
+def xor(*args: ExprProtocol | LogicalOperatorProtocol) -> LogicalOperatorProtocol:
+    return _ArgsLogicalOperator(_name='XOR', _conditions=args)
+
+
+def not_(value: str | ExprProtocol) -> LogicalOperatorProtocol:
+    """
+    .where(not_('column_name')) => WHERE NOT column_name
+    """
+    return _NotLogicalOperator(_value=value)

{david8-0.dev5 → david8-0.2.0b1}/david8/predicates.py

@@ -1,8 +1,21 @@
+from .core.arg_convertors import to_col_or_expr
 from .core.base_aliased import BaseAliased as _BaseAliased
 from .protocols.dialect import DialectProtocol
 from .protocols.sql import ExprProtocol, PredicateProtocol
 
 
+class _IsPredicate(PredicateProtocol, _BaseAliased):
+    def __init__(self, left: str | ExprProtocol, right: str | ExprProtocol):
+        super().__init__()
+        self._left = left
+        self._right = right
+
+    def _get_sql(self, dialect: DialectProtocol) -> str:
+        left = to_col_or_expr(self._left, dialect)
+        right = to_col_or_expr(self._right, dialect)
+        return f'{left} IS {right}'
+
+
 class _LeftColRightParamPredicate(PredicateProtocol, _BaseAliased):
     def __init__(
         self,
@@ -104,6 +117,11 @@ def between(
 ) -> PredicateProtocol:
     return _BetweenPredicate(column, start, end)
 
+# .where(is_('is_active', false)) => WHERE is_active IS FALSE
+# .where(is_('is_active', not_(false))) => WHERE is_active IS NOT FALSE
+def is_(left: str | ExprProtocol, right: str | ExprProtocol) -> PredicateProtocol:
+    return _IsPredicate(left, right)
+
 # columns predicates. example: WHERE col_name = col_name2, col_name != col_name2 ...
 def eq_c(left_column: str, right_column: str) -> PredicateProtocol:
     return _LeftColRightColPredicate(left_column, right_column, '=')

{david8-0.dev5 → david8-0.2.0b1}/david8.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: david8
-Version: 0.dev5
-Summary: Lightweight Python SQL query builder with support for multiple dialects: ClickHouse and PostgreSQL
+Version: 0.2.0b1
+Summary: Lightweight Python SQL query builder with support for multiple dialects: ClickHouse, PostgreSQL, DuckDB, MySQL and SQLite
 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
@@ -10,7 +10,7 @@ Project-URL: Issues, https://github.com/d-ganchar/david8/issues
 Project-URL: CI, https://github.com/d-ganchar/david8/actions
 Project-URL: Documentation, https://github.com/d-ganchar/david8/wiki
 Project-URL: Source, https://github.com/d-ganchar/david8
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Database
@@ -37,6 +37,6 @@ predictable and ergonomic workflow
 
 - Zero dependencies
 - Zero global objects
-- Built-in base support for ClickHouse, PostgreSQL, DuckDB, and MySQL
+- Built-in base support for ClickHouse, PostgreSQL, DuckDB, MySQL and SQLite
 
 See [Wiki](https://github.com/d-ganchar/david8/wiki)

{david8-0.dev5 → david8-0.2.0b1}/david8.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 david8/__init__.py
+david8/cast_types.py
 david8/expressions.py
 david8/functions.py
 david8/joins.py
@@ -13,6 +14,7 @@ david8.egg-info/SOURCES.txt
 david8.egg-info/dependency_links.txt
 david8.egg-info/top_level.txt
 david8/core/__init__.py
+david8/core/arg_convertors.py
 david8/core/base_aliased.py
 david8/core/base_dialect.py
 david8/core/base_dml.py

{david8-0.dev5 → david8-0.2.0b1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "david8"
-version = "0.dev.5"
-description = "Lightweight Python SQL query builder with support for multiple dialects: ClickHouse and PostgreSQL"
+version = "0.2.0b1"
+description = "Lightweight Python SQL query builder with support for multiple dialects: ClickHouse, PostgreSQL, DuckDB, MySQL and SQLite"
 authors = [{name = "Danila Ganchar", email = "danila.ganchar@gmail.com"}]
 maintainers = [{name = "Danila Ganchar", email = "danila.ganchar@gmail.com"}]
 license-files = ["LICENSE"]
@@ -12,7 +12,7 @@ dependencies = [
 ]
 
 classifiers = [
-    "Development Status :: 2 - Pre-Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "Topic :: Software Development :: Libraries",
     "Topic :: Database",

{david8-0.dev5 → david8-0.2.0b1}/tests/test_expressions.py

@@ -1,7 +1,7 @@
 from parameterized import parameterized
 
 from david8 import get_default_qb
-from david8.expressions import col, param, val
+from david8.expressions import col, false, null, param, true, val
 from david8.param_styles import (
     FormatParamStyle,
     NamedParamStyle,
@@ -10,7 +10,7 @@ from david8.param_styles import (
     QMarkParamStyle,
 )
 from david8.protocols.dialect import ParamStyleProtocol
-from david8.protocols.sql import QueryProtocol
+from david8.protocols.sql import AliasedProtocol, QueryProtocol
 from tests.base_test import BaseTest
 
 
@@ -129,3 +129,20 @@ class TestExpressions(BaseTest):
         self.assertEqual(query.get_parameters(), exp_dict_params)
         self.assertEqual(query.get_list_parameters(), exp_list_params)
         self.assertEqual(query.get_tuple_parameters(), tuple(exp_list_params))
+
+    @parameterized.expand([
+        (
+            true(),
+            'SELECT TRUE',
+        ),
+        (
+            false(),
+            'SELECT FALSE',
+        ),
+        (
+            null(),
+            'SELECT NULL',
+        ),
+    ])
+    def test_sql_type(self, expr: AliasedProtocol, exp_sql: str):
+        self.assertEqual(self.qb.select(expr).get_sql(), exp_sql)

david8-0.2.0b1/tests/test_functions.py

@@ -0,0 +1,259 @@
+from parameterized import parameterized
+
+from david8 import QueryBuilderProtocol
+from david8.cast_types import bigint, char, date_, integer, smallint, text, time_, timestamp_, varchar
+from david8.expressions import param, val
+from david8.functions import avg, cast, concat, count, length, lower, max_, min_, now_, sum_, trim, upper, uuid_
+from david8.logical_operators import and_, or_, xor
+from david8.predicates import eq_e
+from david8.protocols.dml import FunctionProtocol
+from tests.base_test import BaseTest
+
+
+class TestFunctions(BaseTest):
+
+    @parameterized.expand([
+        (
+            BaseTest.qb,
+            "SELECT concat(col_name1, 'val1', %(p1)s, '1', '1.5', concat(col_name2, "
+            "'val2', %(p2)s, '2', '2.5')), concat(col3, %(p3)s, col_name3) AS alias FROM test",
+        ),
+        (
+            BaseTest.qb_w,
+            'SELECT concat("col_name1", \'val1\', %(p1)s, \'1\', \'1.5\', '
+            'concat("col_name2", \'val2\', %(p2)s, \'2\', \'2.5\')), concat("col3", '
+            '%(p3)s, "col_name3") AS "alias" FROM "test"'
+        )
+    ])
+    def test_concat(self, qb: QueryBuilderProtocol, exp_sql: str):
+        query = (
+            qb
+            .select(
+                concat(
+                    'col_name1',
+                    val('val1'),
+                    param('param1'),
+                    1,
+                    1.5,
+                    concat(
+                        'col_name2',
+                        val('val2'),
+                        param('param2'),
+                        2,
+                        2.5,
+                    ),
+                ),
+                concat('col3', param('param3'), 'col_name3').as_('alias')
+            )
+            .from_table('test')
+        )
+
+        self.assertEqual(query.get_sql(), exp_sql)
+        self.assertEqual({'p1': 'param1', 'p2': 'param2', 'p3': 'param3'}, query.get_parameters())
+
+
+class TestAggFunctions(BaseTest):
+
+    def test_agg_functions(self):
+        query = (
+            self.qb
+            .select('*')
+            .from_table('test')
+            .having(eq_e(count('*'), val(1)))
+        )
+
+        for expr in [
+            eq_e(count('name'), val(2)),
+            eq_e(max_('price'), val(1000)),
+            eq_e(min_('age'), val(27)),
+            eq_e(sum_('money'), val(100)),
+            eq_e(avg('success'), val(99)),
+            eq_e(count('name', True), val(3)),
+            eq_e(max_('price', True), val(2000)),
+            eq_e(min_('age', True), val(33)),
+            eq_e(sum_('money', True), val(200)),
+            eq_e(avg('success', True), val(299)),
+        ]:
+            query.having(expr)
+
+        sql = query.get_sql()
+        self.assertEqual(
+            sql,
+            'SELECT * FROM test HAVING count(*) = 1 AND count(name) = 2 AND max(price) = 1000 AND min(age) = 27 AND '
+            'sum(money) = 100 AND avg(success) = 99 AND count(DISTINCT name) = 3 AND max(DISTINCT price) = 2000 AND '
+            'min(DISTINCT age) = 33 AND sum(DISTINCT money) = 200 AND avg(DISTINCT success) = 299'
+        )
+
+    def test_agg_logical_operators(self):
+        query = (
+            self.qb
+            .select('*')
+            .from_table('test')
+            .having(
+                or_(
+                    eq_e(count('name'), val(2)),
+                    eq_e(max_('price'), val(1000)),
+                    and_(
+                        eq_e(min_('age'), val(27)),
+                        eq_e(sum_('money'), val(100)),
+                    ),
+                    xor(
+                        eq_e(avg('success'), val(99)),
+                        eq_e(avg('happiness'), val(101)),
+                    )
+                )
+            )
+        )
+
+        self.assertEqual(
+            query.get_sql(),
+            'SELECT * FROM test HAVING (count(name) = 2 OR max(price) = 1000 OR (min(age) = 27 '
+            'AND sum(money) = 100) OR (avg(success) = 99 XOR avg(happiness) = 101))'
+        )
+
+    @parameterized.expand([
+        # length
+        (
+            length(concat('col1', 'col2')),
+            'SELECT length(concat(col1, col2))',
+            'SELECT length(concat("col1", "col2"))',
+            {},
+        ),
+        (
+            length('col_name'),
+            'SELECT length(col_name)',
+            'SELECT length("col_name")',
+            {},
+        ),
+        (
+            length(val('MyVAR')),
+            "SELECT length('MyVAR')",
+            "SELECT length('MyVAR')",
+            {},
+        ),
+        (
+            length(param('myParam')),
+            'SELECT length(%(p1)s)',
+            'SELECT length(%(p1)s)',
+            {'p1': 'myParam'},
+        ),
+        # upper
+        (
+            upper('col_name'),
+            'SELECT upper(col_name)',
+            'SELECT upper("col_name")',
+            {},
+        ),
+        (
+            upper(val('MyVAR')),
+            "SELECT upper('MyVAR')",
+            "SELECT upper('MyVAR')",
+            {},
+        ),
+        (
+            upper(param('myParam')),
+            'SELECT upper(%(p1)s)',
+            'SELECT upper(%(p1)s)',
+            {'p1': 'myParam'},
+        ),
+        # lower
+        (
+            lower('col_name'),
+            'SELECT lower(col_name)',
+            'SELECT lower("col_name")',
+            {},
+        ),
+        (
+            lower(val('MyVAR')),
+            "SELECT lower('MyVAR')",
+            "SELECT lower('MyVAR')",
+            {},
+        ),
+        (
+            lower(param('myParam')),
+            'SELECT lower(%(p1)s)',
+            'SELECT lower(%(p1)s)',
+            {'p1': 'myParam'},
+        ),
+        # trim
+        (
+            trim('col_name'),
+            'SELECT trim(col_name)',
+            'SELECT trim("col_name")',
+            {},
+        ),
+        (
+            trim(val('MyVAR')),
+            "SELECT trim('MyVAR')",
+            "SELECT trim('MyVAR')",
+            {},
+        ),
+        (
+            trim(param('myParam')),
+            'SELECT trim(%(p1)s)',
+            'SELECT trim(%(p1)s)',
+            {'p1': 'myParam'},
+        ),
+    ])
+    def test_str_arg_fn(self, fn: FunctionProtocol, sql_exp: str, sql_expr2: str, exp_param: dict):
+        query = self.qb.select(fn)
+        self.assertEqual(query.get_sql(), sql_exp)
+        self.assertEqual(query.get_parameters(), exp_param)
+
+        query = self.qb_w.select(fn)
+        self.assertEqual(query.get_sql(), sql_expr2)
+        self.assertEqual(query.get_parameters(), exp_param)
+
+    @parameterized.expand([
+        (
+            now_(),
+            'SELECT now()',
+        ),
+        (
+            uuid_(),
+            'SELECT uuid()',
+        ),
+    ])
+    def test_zero_arg_fn(self, fn: FunctionProtocol, sql_exp: str):
+        self.assertEqual(self.qb.select(fn).get_sql(), sql_exp)
+
+    @parameterized.expand([
+        (
+            cast('col_name', integer),
+            'SELECT CAST(col_name AS INTEGER)',
+        ),
+        (
+            cast('col_name', bigint),
+            'SELECT CAST(col_name AS BIGINT)',
+        ),
+        (
+            cast('col_name', text),
+            'SELECT CAST(col_name AS TEXT)',
+        ),
+        (
+            cast('col_name', char(9)),
+            'SELECT CAST(col_name AS CHAR(9))',
+        ),
+        (
+            cast('col_name', varchar(9)),
+            'SELECT CAST(col_name AS VARCHAR(9))',
+        ),
+        (
+            cast(val('1'), smallint).as_('small_int_val'),
+            "SELECT CAST('1' AS SMALLINT) AS small_int_val",
+        ),
+        (
+            cast(val('2025-11-27 15:54:34.173122+00'), timestamp_),
+            "SELECT CAST('2025-11-27 15:54:34.173122+00' AS TIMESTAMP)",
+        ),
+        (
+            cast(val('2025-11-27 15:54:34.173122+00'), date_),
+            "SELECT CAST('2025-11-27 15:54:34.173122+00' AS DATE)",
+        ),
+        (
+            cast(val('2025-11-27 15:54:34.173122+00'), time_),
+            "SELECT CAST('2025-11-27 15:54:34.173122+00' AS TIME)",
+        ),
+    ])
+    def test_cast(self, fn: FunctionProtocol, sql_exp: str):
+        self.assertEqual(self.qb.select(fn).get_sql(), sql_exp)

{david8-0.dev5 → david8-0.2.0b1}/tests/test_join.py

@@ -118,3 +118,60 @@ class TestJoin(BaseTest):
     ])
     def test_simple_join_using(self, query: QueryProtocol, exp_sql: str):
         self.assertEqual(query.get_sql(), exp_sql)
+
+    @parameterized.expand([
+        # using
+        (
+            BaseTest
+            .qb
+            .select('*')
+            .from_table('orders')
+            .join(
+                left()
+                .query(BaseTest.qb.select('*').from_table('users'))
+                .using('order_id', 'user_id')
+            ),
+            'SELECT * FROM orders LEFT JOIN (SELECT * FROM users) USING (order_id, user_id)'
+        ),
+        (
+            BaseTest
+            .qb_w
+            .select('*')
+            .from_table('orders')
+            .join(
+                left()
+                .query(BaseTest.qb.select('*').from_table('users'))
+                .using('order_id', 'user_id')
+            ),
+            'SELECT "*" FROM "orders" LEFT JOIN (SELECT "*" FROM "users") USING ("order_id", "user_id")'
+        ),
+        # on
+        (
+            BaseTest
+            .qb
+            .select('*')
+            .from_table('users', 'u')
+            .join(
+                left()
+                .query(BaseTest.qb.select('*').from_table('users'))
+                .on(eq_c('o.user_id', 'u.id'))
+                .as_('o')
+            ),
+            'SELECT * FROM users AS u LEFT JOIN (SELECT * FROM users) AS o ON (o.user_id = u.id)'
+        ),
+        (
+            BaseTest
+            .qb_w
+            .select('*')
+            .from_table('users', 'u')
+            .join(
+                left()
+                .query(BaseTest.qb.select('*').from_table('users'))
+                .on(eq_c('o.user_id', 'u.id'))
+                .as_('o')
+            ),
+            'SELECT "*" FROM "users" AS "u" LEFT JOIN (SELECT "*" FROM "users") AS "o" ON ("o"."user_id" = "u"."id")'
+        ),
+    ])
+    def test_join_from_query(self, query: QueryProtocol, exp_sql: str):
+        self.assertEqual(query.get_sql(), exp_sql)

{david8-0.dev5 → david8-0.2.0b1}/tests/test_logical_operators.py

@@ -1,5 +1,9 @@
-from david8.logical_operators import and_, or_, xor
+from parameterized import parameterized
+
+from david8.expressions import false, true
+from david8.logical_operators import and_, not_, or_, xor
 from david8.predicates import eq
+from david8.protocols.sql import LogicalOperatorProtocol
 from tests.base_test import BaseTest
 
 
@@ -81,3 +85,32 @@ class TestLogicalOperators(BaseTest):
         )
 
         self.assertEqual(query.get_parameters(), {'p1': 1, 'p2': 2, 'p3': 3, 'p4': 4, 'p5': 5})
+
+    @parameterized.expand([
+        (
+            not_('column_name'),
+            'SELECT NOT column_name',
+            'SELECT NOT "column_name"',
+            {}
+        ),
+        (
+            not_(true()),
+            'SELECT NOT TRUE',
+            'SELECT NOT TRUE',
+            {}
+        ),
+        (
+            not_(false()),
+            'SELECT NOT FALSE',
+            'SELECT NOT FALSE',
+            {}
+        ),
+    ])
+    def test_not(self, logical: LogicalOperatorProtocol, exp_sql: str, exp_sql2: str, exp_params: dict) -> None:
+        query = BaseTest.qb.select(logical)
+        self.assertEqual(query.get_sql(), exp_sql)
+        self.assertEqual(query.get_parameters(), exp_params)
+
+        query = BaseTest.qb_w.select(logical)
+        self.assertEqual(query.get_sql(), exp_sql2)
+        self.assertEqual(query.get_parameters(), exp_params)

{david8-0.dev5 → david8-0.2.0b1}/tests/test_predicates.py

@@ -1,6 +1,7 @@
 from parameterized import parameterized
 
-from david8.expressions import param, val
+from david8.expressions import false, null, param, true, val
+from david8.logical_operators import not_
 from david8.predicates import (
     between,
     eq,
@@ -12,6 +13,7 @@ from david8.predicates import (
     gt,
     gt_c,
     gt_e,
+    is_,
     le,
     le_c,
     le_e,
@@ -30,14 +32,14 @@ class TestPredicates(BaseTest):
     @parameterized.expand([
         # between
         (
-                between('age', 14, 18).as_('is_valid'),
+            between('age', 14, 18).as_('is_valid'),
             'SELECT age BETWEEN %(p1)s AND %(p2)s AS is_valid',
-                {'p1': 14, 'p2': 18}
+            {'p1': 14, 'p2': 18}
         ),
         (
-                between('created_day', val('2025-01-01'), val('2026-01-01')),
+            between('created_day', val('2025-01-01'), val('2026-01-01')),
             "SELECT created_day BETWEEN '2025-01-01' AND '2026-01-01'",
-                {}
+            {}
         ),
         # eq
         (
@@ -199,6 +201,47 @@ class TestPredicates(BaseTest):
             'SELECT 1 != %(p1)s',
             {'p1': 1}
         ),
+        # is
+        (
+            is_('is_active', true()),
+            'SELECT is_active IS TRUE',
+            {},
+        ),
+        (
+            is_('is_active', not_(true())),
+            'SELECT is_active IS NOT TRUE',
+            {},
+        ),
+        (
+            is_('is_active', false()),
+            'SELECT is_active IS FALSE',
+            {},
+        ),
+        (
+            is_('is_active', not_(false())),
+            'SELECT is_active IS NOT FALSE',
+            {},
+        ),
+        (
+            is_('is_active', null()),
+            'SELECT is_active IS NULL',
+            {},
+        ),
+        (
+            is_('is_active', not_(null())),
+            'SELECT is_active IS NOT NULL',
+            {},
+        ),
+        (
+            is_('last_update_dt', 'last_login_dt'),
+            'SELECT last_update_dt IS last_login_dt',
+            {}
+        ),
+        (
+            is_('last_update_dt', param(1)),
+            'SELECT last_update_dt IS %(p1)s',
+            {'p1': 1}
+        ),
     ])
     def test_predicate(self, predicate: PredicateProtocol, exp_sql: str, exp_params: dict) -> None:
         query = BaseTest.qb.select(predicate)

david8-0.dev5/david8/functions.py

@@ -1,9 +0,0 @@
-from david8.core.fn_generator import OneArgDistinctCallableFactory as _AggDistinctCallableFactory
-from david8.core.fn_generator import SeparatedStrArgsCallableFactory as _SeparatedStrArgsCallableFactory
-
-count = _AggDistinctCallableFactory(name='count')
-avg = _AggDistinctCallableFactory(name='avg')
-sum_ = _AggDistinctCallableFactory(name='sum')
-max_ = _AggDistinctCallableFactory(name='max')
-min_ = _AggDistinctCallableFactory(name='min')
-concat = _SeparatedStrArgsCallableFactory(name='concat', separator=', ')

david8-0.dev5/david8/logical_operators.py

@@ -1,27 +0,0 @@
-import dataclasses
-from typing import Union
-
-from .protocols.dialect import DialectProtocol
-from .protocols.sql import ExprProtocol, LogicalOperatorProtocol
-
-
-@dataclasses.dataclass(slots=True)
-class _LogicalOperator(LogicalOperatorProtocol):
-    _name: str
-    _conditions: Union[ExprProtocol, 'LogicalOperatorProtocol', ...]
-
-    def get_sql(self, dialect: DialectProtocol) -> str:
-        conditions = f' {self._name} '.join(c.get_sql(dialect) for c in self._conditions)
-        return f'({conditions})'
-
-
-def or_(*args: ExprProtocol | LogicalOperatorProtocol):
-    return _LogicalOperator(_name='OR', _conditions=args)
-
-
-def and_(*args: ExprProtocol | LogicalOperatorProtocol):
-    return _LogicalOperator(_name='AND', _conditions=args)
-
-
-def xor(*args: ExprProtocol | LogicalOperatorProtocol):
-    return _LogicalOperator(_name='XOR', _conditions=args)

david8-0.dev5/tests/test_functions.py

@@ -1,110 +0,0 @@
-from parameterized import parameterized
-
-from david8 import QueryBuilderProtocol
-from david8.expressions import param, val
-from david8.functions import avg, concat, count, max_, min_, sum_
-from david8.logical_operators import and_, or_, xor
-from david8.predicates import eq_e
-from tests.base_test import BaseTest
-
-
-class TestFunctions(BaseTest):
-
-    @parameterized.expand([
-        (
-            BaseTest.qb,
-            "SELECT concat(col_name1, 'val1', %(p1)s, '1', '1.5', concat(col_name2, "
-            "'val2', %(p2)s, '2', '2.5')), concat(col3, %(p3)s, col_name3) AS alias FROM test",
-        ),
-        (
-            BaseTest.qb_w,
-            'SELECT concat("col_name1", \'val1\', %(p1)s, \'1\', \'1.5\', '
-            'concat("col_name2", \'val2\', %(p2)s, \'2\', \'2.5\')), concat("col3", '
-            '%(p3)s, "col_name3") AS "alias" FROM "test"'
-        )
-    ])
-    def test_concat(self, qb: QueryBuilderProtocol, exp_sql: str):
-        query = (
-            qb
-            .select(
-                concat(
-                    'col_name1',
-                    val('val1'),
-                    param('param1'),
-                    1,
-                    1.5,
-                    concat(
-                        'col_name2',
-                        val('val2'),
-                        param('param2'),
-                        2,
-                        2.5,
-                    ),
-                ),
-                concat('col3', param('param3'), 'col_name3').as_('alias')
-            )
-            .from_table('test')
-        )
-
-        self.assertEqual(query.get_sql(), exp_sql)
-        self.assertEqual({'p1': 'param1', 'p2': 'param2', 'p3': 'param3'}, query.get_parameters())
-
-
-class TestAggFunctions(BaseTest):
-
-    def test_agg_functions(self):
-        query = (
-            self.qb
-            .select('*')
-            .from_table('test')
-            .having(eq_e(count('*'), val(1)))
-        )
-
-        for expr in [
-            eq_e(count('name'), val(2)),
-            eq_e(max_('price'), val(1000)),
-            eq_e(min_('age'), val(27)),
-            eq_e(sum_('money'), val(100)),
-            eq_e(avg('success'), val(99)),
-            eq_e(count('name', True), val(3)),
-            eq_e(max_('price', True), val(2000)),
-            eq_e(min_('age', True), val(33)),
-            eq_e(sum_('money', True), val(200)),
-            eq_e(avg('success', True), val(299)),
-        ]:
-            query.having(expr)
-
-        sql = query.get_sql()
-        self.assertEqual(
-            sql,
-            'SELECT * FROM test HAVING count(*) = 1 AND count(name) = 2 AND max(price) = 1000 AND min(age) = 27 AND '
-            'sum(money) = 100 AND avg(success) = 99 AND count(DISTINCT name) = 3 AND max(DISTINCT price) = 2000 AND '
-            'min(DISTINCT age) = 33 AND sum(DISTINCT money) = 200 AND avg(DISTINCT success) = 299'
-        )
-
-    def test_agg_logical_operators(self):
-        query = (
-            self.qb
-            .select('*')
-            .from_table('test')
-            .having(
-                or_(
-                    eq_e(count('name'), val(2)),
-                    eq_e(max_('price'), val(1000)),
-                    and_(
-                        eq_e(min_('age'), val(27)),
-                        eq_e(sum_('money'), val(100)),
-                    ),
-                    xor(
-                        eq_e(avg('success'), val(99)),
-                        eq_e(avg('happiness'), val(101)),
-                    )
-                )
-            )
-        )
-
-        self.assertEqual(
-            query.get_sql(),
-            'SELECT * FROM test HAVING (count(name) = 2 OR max(price) = 1000 OR (min(age) = 27 '
-            'AND sum(money) = 100) OR (avg(success) = 99 XOR avg(happiness) = 101))'
-        )