david8 0.dev5__tar.gz → 0.1.0b1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: david8
-Version: 0.dev5
+Version: 0.1.0b1
 Summary: Lightweight Python SQL query builder with support for multiple dialects: ClickHouse and PostgreSQL
 Author-email: Danila Ganchar <danila.ganchar@gmail.com>
 Maintainer-email: Danila Ganchar <danila.ganchar@gmail.com>
@@ -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.1.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.1.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.1.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.1.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.1.0b1}/david8/core/fn_generator.py

@@ -65,3 +65,28 @@ 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)

{david8-0.dev5 → david8-0.1.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.1.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.1.0b1/david8/functions.py

@@ -0,0 +1,24 @@
+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,
+)
+
+# 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=', ')

david8-0.1.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.1.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.1.0b1}/david8.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: david8
-Version: 0.dev5
+Version: 0.1.0b1
 Summary: Lightweight Python SQL query builder with support for multiple dialects: ClickHouse and PostgreSQL
 Author-email: Danila Ganchar <danila.ganchar@gmail.com>
 Maintainer-email: Danila Ganchar <danila.ganchar@gmail.com>
@@ -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.1.0b1}/david8.egg-info/SOURCES.txt

@@ -13,6 +13,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.1.0b1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "david8"
-version = "0.dev.5"
+version = "0.1.0b1"
 description = "Lightweight Python SQL query builder with support for multiple dialects: ClickHouse and PostgreSQL"
 authors = [{name = "Danila Ganchar", email = "danila.ganchar@gmail.com"}]
 maintainers = [{name = "Danila Ganchar", email = "danila.ganchar@gmail.com"}]
@@ -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.1.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.dev5 → david8-0.1.0b1}/tests/test_functions.py

@@ -2,9 +2,10 @@ 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.functions import avg, concat, count, length, lower, max_, min_, sum_, trim, upper
 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
 
 
@@ -108,3 +109,96 @@ class TestAggFunctions(BaseTest):
             '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)

{david8-0.dev5 → david8-0.1.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.1.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.1.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)