flowmaticdb 2.2.0__tar.gz → 2.2.2__tar.gz

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowmaticdb
-Version: 2.2.0
+Version: 2.2.2
 Summary: A Python database abstraction layer supporting PostgreSQL, SQLite, and MySQL.
 Author: Flowmatic, UniForceMusic
 License: MIT
@@ -29,6 +29,10 @@ Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Requires-Dist: ruff>=0.1; extra == "dev"
+Provides-Extra: all
+Requires-Dist: asyncpg>=0.29; extra == "all"
+Requires-Dist: mysql-connector-python>=9.0; extra == "all"
+Requires-Dist: psycopg[binary]>=3.1; extra == "all"
 
 # Transparency
 This package is a port of [PHP Sentience Database](https://github.com/Sentience-Framework/database)
@@ -433,21 +437,26 @@ from flowmaticdb import raw, identifier
 
 query = db.select("users").columns(["users.id", "posts.title"])
 
-# INNER JOIN with ON conditions
-join = query.inner_join("posts", "p")  # Returns Join object
-join.on(["users", "id"], ["p", "user_id"])    # ON users.id = p.user_id
-join.or_on(["p", "status"], ["'published'"])   # OR p.status = 'published'
+# INNER JOIN with ON conditions — the callback receives the Join,
+# every join method returns the query so you can keep chaining
+query.inner_join_table(
+    "posts",
+    lambda join: join
+        .on(["users", "id"], ["p", "user_id"])       # ON users.id = p.user_id
+        .or_on(["p", "status"], ["'published'"]),    # OR p.status = 'published'
+    "p",
+)
 
 # LEFT JOIN
-query.left_join("comments", "c").on(["p", "id"], ["c", "post_id"])
+query.left_join_table("comments", lambda join: join.on(["p", "id"], ["c", "post_id"]), "c")
 
-# CROSS JOIN
+# CROSS JOIN (never takes ON conditions)
 query.cross_join("sessions")
 
 # LATERAL joins
-query.left_join_lateral(sub_query, "sq")
-query.inner_join_lateral(sub_query, "sq")
-query.cross_join_lateral(sub_query, "sq")
+query.left_join_lateral_sub_query(sub_query, "sq")
+query.inner_join_lateral_sub_query(sub_query, "sq")
+query.cross_join_lateral_sub_query(sub_query, "sq")
 
 # Raw join SQL (e.g. for aggregates)
 query.join(raw("LEFT JOIN (SELECT user_id, count(*) AS cnt FROM orders GROUP BY user_id) AS o ON o.user_id = users.id"))
@@ -458,9 +467,12 @@ query.join(raw("LEFT JOIN (SELECT user_id, count(*) AS cnt FROM orders GROUP BY
 `Join` objects support all the same condition methods as WHERE:
 
 ```python
-join = query.inner_join("orders")
-join.where_equals(["orders", "user_id"], ["users", "id"])
-join.where_greater_than("orders.total", 100)
+query.inner_join(
+    "orders",
+    lambda join: join
+        .where_equals(["orders", "user_id"], ["users", "id"])
+        .where_greater_than("orders.total", 100),
+)
 ```
 
 ---

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/README.md

@@ -401,21 +401,26 @@ from flowmaticdb import raw, identifier
 
 query = db.select("users").columns(["users.id", "posts.title"])
 
-# INNER JOIN with ON conditions
-join = query.inner_join("posts", "p")  # Returns Join object
-join.on(["users", "id"], ["p", "user_id"])    # ON users.id = p.user_id
-join.or_on(["p", "status"], ["'published'"])   # OR p.status = 'published'
+# INNER JOIN with ON conditions — the callback receives the Join,
+# every join method returns the query so you can keep chaining
+query.inner_join_table(
+    "posts",
+    lambda join: join
+        .on(["users", "id"], ["p", "user_id"])       # ON users.id = p.user_id
+        .or_on(["p", "status"], ["'published'"]),    # OR p.status = 'published'
+    "p",
+)
 
 # LEFT JOIN
-query.left_join("comments", "c").on(["p", "id"], ["c", "post_id"])
+query.left_join_table("comments", lambda join: join.on(["p", "id"], ["c", "post_id"]), "c")
 
-# CROSS JOIN
+# CROSS JOIN (never takes ON conditions)
 query.cross_join("sessions")
 
 # LATERAL joins
-query.left_join_lateral(sub_query, "sq")
-query.inner_join_lateral(sub_query, "sq")
-query.cross_join_lateral(sub_query, "sq")
+query.left_join_lateral_sub_query(sub_query, "sq")
+query.inner_join_lateral_sub_query(sub_query, "sq")
+query.cross_join_lateral_sub_query(sub_query, "sq")
 
 # Raw join SQL (e.g. for aggregates)
 query.join(raw("LEFT JOIN (SELECT user_id, count(*) AS cnt FROM orders GROUP BY user_id) AS o ON o.user_id = users.id"))
@@ -426,9 +431,12 @@ query.join(raw("LEFT JOIN (SELECT user_id, count(*) AS cnt FROM orders GROUP BY
 `Join` objects support all the same condition methods as WHERE:
 
 ```python
-join = query.inner_join("orders")
-join.where_equals(["orders", "user_id"], ["users", "id"])
-join.where_greater_than("orders.total", 100)
+query.inner_join(
+    "orders",
+    lambda join: join
+        .where_equals(["orders", "user_id"], ["users", "id"])
+        .where_greater_than("orders.total", 100),
+)
 ```
 
 ---

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flowmaticdb"
-version = "2.2.0"
+version = "2.2.2"
 description = "A Python database abstraction layer supporting PostgreSQL, SQLite, and MySQL."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -50,6 +50,11 @@ dev = [
     "mypy>=1.0",
     "ruff>=0.1",
 ]
+all = [
+    "asyncpg>=0.29",
+    "mysql-connector-python>=9.0",
+    "psycopg[binary]>=3.1",
+]
 
 [tool.setuptools.packages.find]
 where = ["src"]

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/src/flowmaticdb/adapters/_postgres.py

@@ -9,7 +9,7 @@ from datetime import date, datetime
 from datetime import time as time_of_day
 from typing import TYPE_CHECKING, Any, TypeVar
 
-from flowmaticdb._exceptions import AdapterError
+from flowmaticdb import AdapterError
 from flowmaticdb._query_with_params import REGEX_PATTERN
 from flowmaticdb.adapters._base import AdapterABC
 from flowmaticdb.result import AsyncpgResult, PsycopgResult, ResultABC

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/src/flowmaticdb/dialects/_postgres.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import dataclasses
 import re
 from collections.abc import Mapping
+from datetime import UTC, datetime
 from typing import Any, ClassVar
 
 from flowmaticdb.dialects._sql_dialect import SQLDialect
@@ -12,6 +13,10 @@ from flowmaticdb.query.enums import ConditionEnum, TypeEnum
 
 _TZ_OFFSET_RE = re.compile(r"([+-]\d{2})$")
 
+# TIMESTAMP WITHOUT TIME ZONE columns and pre-timestamptz data still come back
+# without an offset; those are read as UTC.
+_NAIVE_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S.%f"
+
 
 class PostgresqlDialect(SQLDialect):
     escape_chars: ClassVar[Mapping[str, str]] = {
@@ -33,7 +38,7 @@ class PostgresqlDialect(SQLDialect):
         self.on_conflict = True
         self.returning = True
         self.lateral = True
-        self.datetime_format = "%Y-%m-%d %H:%M:%S.%f"
+        self.datetime_format = "%Y-%m-%d %H:%M:%S.%f%z"
         self._version_gate()
 
     def _version_gate(self) -> None:
@@ -118,9 +123,25 @@ class PostgresqlDialect(SQLDialect):
     def cast_bool(self, value: bool) -> bool | int:
         return value
 
+    def cast_datetime(self, value: Any) -> str:
+        # %z renders nothing for a naive datetime, which would defeat the point
+        # of a timestamptz column -- read those as UTC, matching how naive
+        # strings are parsed back.
+        if isinstance(value, datetime) and value.tzinfo is None:
+            value = value.replace(tzinfo=UTC)
+        return super().cast_datetime(value)
+
     def parse_datetime(self, value: Any) -> Any:
         if isinstance(value, str):
             value = _TZ_OFFSET_RE.sub(r"\1:00", value)
+            try:
+                return datetime.strptime(value, self.datetime_format)
+            except ValueError:
+                pass
+            try:
+                return datetime.strptime(value, _NAIVE_DATETIME_FORMAT).replace(tzinfo=UTC)
+            except ValueError:
+                pass
         return super().parse_datetime(value)
 
     def type(self, type_enum: TypeEnum, bits: int | None = None) -> str:
@@ -128,5 +149,5 @@ class PostgresqlDialect(SQLDialect):
         if type_enum == TypeEnum.FLOAT:
             return "DOUBLE PRECISION" if size > 32 else "REAL"
         if type_enum == TypeEnum.DATETIME:
-            return "TIMESTAMP"
+            return "TIMESTAMPTZ"
         return super().type(type_enum, bits)

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/src/flowmaticdb/query/_join.py

@@ -8,7 +8,7 @@ from flowmaticdb.query._condition import Condition
 from flowmaticdb.query._condition_group import ConditionGroupABC
 from flowmaticdb.query._condition_mixin import ConditionMixin
 from flowmaticdb.query.enums import ChainEnum, JoinEnum
-from flowmaticdb.query.expressions import SqlABC
+from flowmaticdb.query.expressions import SqlABC, Identifier
 
 if TYPE_CHECKING:
     from flowmaticdb.query._select import SelectQuery
@@ -264,9 +264,9 @@ class Join(ConditionMixin):
         return self
 
     def on(self, left: list[str], right: list[str]) -> Self:
-        self._equals(self.conditions, left, right, cast=True)
+        self._equals(self.conditions, left, Identifier(right))
         return self
 
     def or_on(self, left: list[str], right: list[str]) -> Self:
-        self._equals(self.conditions, left, right, cast=True, chain=ChainEnum.OR)
+        self._equals(self.conditions, left, Identifier(right), chain=ChainEnum.OR)
         return self

flowmaticdb-2.2.2/src/flowmaticdb/query/_joins_mixin.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Self
+
+from flowmaticdb.query._join import Join
+from flowmaticdb.query.enums import JoinEnum
+from flowmaticdb.query.expressions import Alias, SqlABC, SubQuery
+
+if TYPE_CHECKING:
+    from flowmaticdb.query._select import SelectQuery
+
+
+class JoinsMixin:
+    joins: list[Any]
+
+    def left_join(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self._add_join(JoinEnum.LEFT_JOIN, table, on)
+
+    def left_join_table(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None, alias: str | None = None) -> Self:
+        return self.left_join(Alias(table, alias) if alias else table, on)
+
+    def left_join_sub_query(self, query: SelectQuery, alias: str, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self.left_join(SubQuery(query, alias), on)
+
+    def left_join_lateral(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self._add_join(JoinEnum.LEFT_JOIN_LATERAL, table, on)
+
+    def left_join_lateral_table(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None, alias: str | None = None) -> Self:
+        return self.left_join_lateral(Alias(table, alias) if alias else table, on)
+
+    def left_join_lateral_sub_query(self, query: SelectQuery, alias: str, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self.left_join_lateral(SubQuery(query, alias), on)
+
+    def inner_join(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self._add_join(JoinEnum.INNER_JOIN, table, on)
+
+    def inner_join_table(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None, alias: str | None = None) -> Self:
+        return self.inner_join(Alias(table, alias) if alias else table, on)
+
+    def inner_join_sub_query(self, query: SelectQuery, alias: str, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self.inner_join(SubQuery(query, alias), on)
+
+    def inner_join_lateral(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self._add_join(JoinEnum.INNER_JOIN_LATERAL, table, on)
+
+    def inner_join_lateral_table(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None, alias: str | None = None) -> Self:
+        return self.inner_join_lateral(Alias(table, alias) if alias else table, on)
+
+    def inner_join_lateral_sub_query(self, query: SelectQuery, alias: str, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self.inner_join_lateral(SubQuery(query, alias), on)
+
+    def cross_join(self, table: str | list[str] | SqlABC) -> Self:
+        return self._add_join(JoinEnum.CROSS_JOIN, table, None)
+
+    def cross_join_table(self, table: str | list[str] | SqlABC, alias: str | None = None) -> Self:
+        return self.cross_join(Alias(table, alias) if alias else table)
+
+    def cross_join_sub_query(self, query: SelectQuery, alias: str) -> Self:
+        return self.cross_join(SubQuery(query, alias))
+
+    def cross_join_lateral(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self._add_join(JoinEnum.CROSS_JOIN_LATERAL, table, on)
+
+    def cross_join_lateral_table(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None, alias: str | None = None) -> Self:
+        return self.cross_join_lateral(Alias(table, alias) if alias else table, on)
+
+    def cross_join_lateral_sub_query(self, query: SelectQuery, alias: str, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self.cross_join_lateral(SubQuery(query, alias), on)
+
+    def outer_apply(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self._add_join(JoinEnum.LEFT_JOIN_LATERAL, table, on)
+
+    def outer_apply_table(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None, alias: str | None = None) -> Self:
+        return self.outer_apply(Alias(table, alias) if alias else table, on)
+
+    def outer_apply_sub_query(self, query: SelectQuery, alias: str, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self.outer_apply(SubQuery(query, alias), on)
+
+    def cross_apply(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self._add_join(JoinEnum.INNER_JOIN_LATERAL, table, on)
+
+    def cross_apply_table(self, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None = None, alias: str | None = None) -> Self:
+        return self.cross_apply(Alias(table, alias) if alias else table, on)
+
+    def cross_apply_sub_query(self, query: SelectQuery, alias: str, on: Callable[[Join], Join | None] | None = None) -> Self:
+        return self.cross_apply(SubQuery(query, alias), on)
+
+    def join(self, sql: Any) -> Self:
+        self.joins.append(sql)
+        return self
+
+    def _add_join(self, join_type: JoinEnum, table: str | list[str] | SqlABC, on: Callable[[Join], Join | None] | None) -> Self:
+        join: Any = Join(join=join_type, table=table)
+
+        if on:
+            returned = on(join)
+            if returned is not None:
+                join = returned
+
+        if not isinstance(join, Join):
+            return self
+
+        self.joins.append(join)
+
+        return self

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/src/flowmaticdb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowmaticdb
-Version: 2.2.0
+Version: 2.2.2
 Summary: A Python database abstraction layer supporting PostgreSQL, SQLite, and MySQL.
 Author: Flowmatic, UniForceMusic
 License: MIT
@@ -29,6 +29,10 @@ Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Requires-Dist: ruff>=0.1; extra == "dev"
+Provides-Extra: all
+Requires-Dist: asyncpg>=0.29; extra == "all"
+Requires-Dist: mysql-connector-python>=9.0; extra == "all"
+Requires-Dist: psycopg[binary]>=3.1; extra == "all"
 
 # Transparency
 This package is a port of [PHP Sentience Database](https://github.com/Sentience-Framework/database)
@@ -433,21 +437,26 @@ from flowmaticdb import raw, identifier
 
 query = db.select("users").columns(["users.id", "posts.title"])
 
-# INNER JOIN with ON conditions
-join = query.inner_join("posts", "p")  # Returns Join object
-join.on(["users", "id"], ["p", "user_id"])    # ON users.id = p.user_id
-join.or_on(["p", "status"], ["'published'"])   # OR p.status = 'published'
+# INNER JOIN with ON conditions — the callback receives the Join,
+# every join method returns the query so you can keep chaining
+query.inner_join_table(
+    "posts",
+    lambda join: join
+        .on(["users", "id"], ["p", "user_id"])       # ON users.id = p.user_id
+        .or_on(["p", "status"], ["'published'"]),    # OR p.status = 'published'
+    "p",
+)
 
 # LEFT JOIN
-query.left_join("comments", "c").on(["p", "id"], ["c", "post_id"])
+query.left_join_table("comments", lambda join: join.on(["p", "id"], ["c", "post_id"]), "c")
 
-# CROSS JOIN
+# CROSS JOIN (never takes ON conditions)
 query.cross_join("sessions")
 
 # LATERAL joins
-query.left_join_lateral(sub_query, "sq")
-query.inner_join_lateral(sub_query, "sq")
-query.cross_join_lateral(sub_query, "sq")
+query.left_join_lateral_sub_query(sub_query, "sq")
+query.inner_join_lateral_sub_query(sub_query, "sq")
+query.cross_join_lateral_sub_query(sub_query, "sq")
 
 # Raw join SQL (e.g. for aggregates)
 query.join(raw("LEFT JOIN (SELECT user_id, count(*) AS cnt FROM orders GROUP BY user_id) AS o ON o.user_id = users.id"))
@@ -458,9 +467,12 @@ query.join(raw("LEFT JOIN (SELECT user_id, count(*) AS cnt FROM orders GROUP BY
 `Join` objects support all the same condition methods as WHERE:
 
 ```python
-join = query.inner_join("orders")
-join.where_equals(["orders", "user_id"], ["users", "id"])
-join.where_greater_than("orders.total", 100)
+query.inner_join(
+    "orders",
+    lambda join: join
+        .where_equals(["orders", "user_id"], ["users", "id"])
+        .where_greater_than("orders.total", 100),
+)
 ```
 
 ---

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/src/flowmaticdb.egg-info/requires.txt

@@ -1,4 +1,9 @@
 
+[all]
+asyncpg>=0.29
+mysql-connector-python>=9.0
+psycopg[binary]>=3.1
+
 [asyncpg]
 asyncpg>=0.29
 

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/tests/test_conditions_port.py

@@ -148,42 +148,45 @@ def test_join_or_where_not_empty_chains_with_or_not_and() -> None:
 
 def test_select_has_full_join_api(sql_dialect: SQLDialect, mock_db) -> None:
     q = SelectQuery(sql_dialect, "users", database=mock_db)
-    assert isinstance(q.inner_join_table("posts"), Join)
-    assert isinstance(q.cross_join_table("posts"), Join)
-    assert isinstance(q.left_join_lateral("posts"), Join)
-    assert isinstance(q.inner_join_lateral("posts"), Join)
-    assert isinstance(q.cross_join_lateral("posts"), Join)
-    assert isinstance(q.outer_apply("posts"), Join)
-    assert isinstance(q.cross_apply("posts"), Join)
+    assert q.inner_join_table("posts") is q
+    assert q.cross_join_table("posts") is q
+    assert q.left_join_lateral("posts") is q
+    assert q.inner_join_lateral("posts") is q
+    assert q.cross_join_lateral("posts") is q
+    assert q.outer_apply("posts") is q
+    assert q.cross_apply("posts") is q
+    assert len(q.joins) == 7
+    assert all(isinstance(j, Join) for j in q.joins)
 
 
 def test_outer_apply_maps_to_left_join_lateral(sql_dialect: SQLDialect, mock_db) -> None:
     q = SelectQuery(sql_dialect, "users", database=mock_db)
-    j = q.outer_apply("posts")
-    assert j.join == JoinEnum.LEFT_JOIN_LATERAL
+    q.outer_apply("posts")
+    assert q.joins[0].join == JoinEnum.LEFT_JOIN_LATERAL
 
 
 def test_cross_apply_maps_to_inner_join_lateral(sql_dialect: SQLDialect, mock_db) -> None:
     q = SelectQuery(sql_dialect, "users", database=mock_db)
-    j = q.cross_apply("posts")
-    assert j.join == JoinEnum.INNER_JOIN_LATERAL
+    q.cross_apply("posts")
+    assert q.joins[0].join == JoinEnum.INNER_JOIN_LATERAL
 
 
 def test_left_join_lateral_takes_raw_table_not_subquery_only(sql_dialect: SQLDialect, mock_db) -> None:
     q = SelectQuery(sql_dialect, "users", database=mock_db)
-    j = q.left_join_lateral("posts", "p")
-    assert j.join == JoinEnum.LEFT_JOIN_LATERAL
+    q.left_join_lateral_table("posts", alias="p")
+    assert q.joins[0].join == JoinEnum.LEFT_JOIN_LATERAL
 
 
 def test_left_join_lateral_sub_query_still_available(sql_dialect: SQLDialect, mock_db) -> None:
     inner = SelectQuery(sql_dialect, "posts", database=mock_db)
     q = SelectQuery(sql_dialect, "users", database=mock_db)
-    j = q.left_join_lateral_sub_query(inner, "p")
-    assert j.join == JoinEnum.LEFT_JOIN_LATERAL
+    q.left_join_lateral_sub_query(inner, "p")
+    assert q.joins[0].join == JoinEnum.LEFT_JOIN_LATERAL
 
 
 def test_inner_join_sub_query_and_cross_join_sub_query_exist(sql_dialect: SQLDialect, mock_db) -> None:
     inner = SelectQuery(sql_dialect, "posts", database=mock_db)
     q = SelectQuery(sql_dialect, "users", database=mock_db)
-    assert isinstance(q.inner_join_sub_query(inner, "p"), Join)
-    assert isinstance(q.cross_join_sub_query(inner, "p"), Join)
+    assert q.inner_join_sub_query(inner, "p") is q
+    assert q.cross_join_sub_query(inner, "p") is q
+    assert [j.join for j in q.joins] == [JoinEnum.INNER_JOIN, JoinEnum.CROSS_JOIN]

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/tests/test_dialect_postgres.py

@@ -118,7 +118,7 @@ def test_pg_type_mapping(pg_dialect: PostgresqlDialect) -> None:
     assert pg_dialect.type(TypeEnum.INT) == "INTEGER"
     assert pg_dialect.type(TypeEnum.FLOAT) == "REAL"
     assert pg_dialect.type(TypeEnum.FLOAT, 64) == "DOUBLE PRECISION"
-    assert pg_dialect.type(TypeEnum.DATETIME) == "TIMESTAMP"
+    assert pg_dialect.type(TypeEnum.DATETIME) == "TIMESTAMPTZ"
 
 
 def test_pg_like_case_sensitive_by_default(pg_dialect: PostgresqlDialect) -> None:

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/tests/test_integration_mysql.py

@@ -395,8 +395,7 @@ def test_mysql_joins(
 
     q: SelectQuery = SelectQuery(dialect, "users", database=db)
     q.columns(["name", "title"])
-    j = q.inner_join("posts")
-    j.on(["users", "id"], ["posts", "user_id"])
+    q.inner_join("posts", lambda join: join.on(["users", "id"], ["posts", "user_id"]))
     q.order_by_asc("title")
 
     qwp: QueryWithParams = q.to_query_with_params()
@@ -418,8 +417,7 @@ def test_mysql_joins(
 
     q2: SelectQuery = SelectQuery(dialect, "users", database=db)
     q2.columns(["name", "title"])
-    lj = q2.left_join("posts")
-    lj.on(["users", "id"], ["posts", "user_id"])
+    q2.left_join("posts", lambda join: join.on(["users", "id"], ["posts", "user_id"]))
     q2.order_by_asc("name")
 
     qwp2: QueryWithParams = q2.to_query_with_params()
@@ -445,8 +443,8 @@ def test_mysql_joins(
 
     q4: SelectQuery = SelectQuery(dialect, "users", database=db)
     q4.columns(["name", "title"])
-    cj = q4.cross_join("posts")
-    assert cj.conditions == []
+    q4.cross_join("posts")
+    assert q4.joins[0].conditions == []
 
     qwp4: QueryWithParams = q4.to_query_with_params()
     result4: ResultABC = adapter.query_with_params(dialect, qwp4)
@@ -987,8 +985,7 @@ def test_mysql_giant_select(
         ]
     )
 
-    inner = q.inner_join("posts")
-    inner.on(["users", "id"], ["posts", "user_id"])
+    q.inner_join("posts", lambda join: join.on(["users", "id"], ["posts", "user_id"]))
 
     q.where_greater_than(["users", "age"], 18)
     q.where_in(["users", "id"], [1, 2, 3])

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/tests/test_integration_postgres.py

@@ -271,14 +271,14 @@ def test_postgres_joins(pg_adapter: PsycopgAdapter, pg_dialect: PostgresqlDialec
 
     q = SelectQuery(dialect, "j_users", database=db)
     q.columns([identifier(["j_users", "name"]), identifier(["j_posts", "title"])])
-    q.inner_join("j_posts").on(["j_users", "id"], ["j_posts", "user_id"])
+    q.inner_join("j_posts", lambda join: join.on(["j_users", "id"], ["j_posts", "user_id"]))
     rows: list[dict[str, Any]] = adapter.query_with_params(dialect, q.to_query_with_params()).fetch_dicts()
     assert len(rows) == 2
     assert all(r["name"] == "Alice" for r in rows)
 
     q = SelectQuery(dialect, "j_users", database=db)
     q.columns([identifier(["j_users", "name"]), identifier(["j_posts", "title"])])
-    q.left_join("j_posts").on(["j_users", "id"], ["j_posts", "user_id"])
+    q.left_join("j_posts", lambda join: join.on(["j_users", "id"], ["j_posts", "user_id"]))
     rows = adapter.query_with_params(dialect, q.to_query_with_params()).fetch_dicts()
     names: dict[str, Any] = {r["name"]: r["title"] for r in rows}
     assert names["Bob"] is None
@@ -663,7 +663,7 @@ def test_postgres_giant_select(pg_adapter: PsycopgAdapter, pg_dialect: Postgresq
 
     q = SelectQuery(dialect, Alias("g_users", "u"), database=db)
     q.columns([identifier(["u", "name"]), expression('count("p"."id") AS post_count')])
-    q.inner_join("g_posts", "p").on(["u", "id"], ["p", "user_id"])
+    q.inner_join_table("g_posts", lambda join: join.on(["u", "id"], ["p", "user_id"]), "p")
     q.where_greater_than_or_equals("age", 25)
     q.where_in("name", ["Alice", "Bob"])
     q.where_between("age", 20, 40)

flowmaticdb-2.2.2/tests/test_joins.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Any
+
+from flowmaticdb.dialects import SQLDialect
+from flowmaticdb.query import Join, SelectQuery
+from flowmaticdb.query.enums import ChainEnum, JoinEnum
+from flowmaticdb.query.expressions import Alias
+
+
+def test_join_creation() -> None:
+    j = Join(join=JoinEnum.LEFT_JOIN, table="posts")
+    assert j.join == JoinEnum.LEFT_JOIN
+    assert j.table == "posts"
+    assert j.conditions == []
+
+
+def test_join_on_condition() -> None:
+    j = Join(join=JoinEnum.INNER_JOIN, table="posts")
+    j.on("users.id", "posts.user_id")
+    assert len(j.conditions) == 1
+    assert j.conditions[0].chain == ChainEnum.AND
+
+
+def test_join_or_on_condition() -> None:
+    j = Join(join=JoinEnum.LEFT_JOIN, table="posts")
+    j.or_on("a", "b")
+    assert j.conditions[0].chain == ChainEnum.OR
+
+
+def test_multiple_join_conditions() -> None:
+    j = Join(join=JoinEnum.LEFT_JOIN, table="posts")
+    j.on("users.id", "posts.user_id")
+    j.on("users.deleted", 0)
+    assert len(j.conditions) == 2
+
+
+def test_all_join_types() -> None:
+    for join_type in JoinEnum:
+        j = Join(join=join_type, table="t")
+        assert j.join == join_type
+
+
+def test_join_returns_query_for_chaining(sql_dialect: SQLDialect, mock_db) -> None:
+    q = SelectQuery(sql_dialect, "users", database=mock_db)
+    returned = q.inner_join("posts").left_join("comments").where_equals("active", 1)
+    assert returned is q
+    assert [j.join for j in q.joins] == [JoinEnum.INNER_JOIN, JoinEnum.LEFT_JOIN]
+
+
+def test_join_callback_receives_join(sql_dialect: SQLDialect, mock_db) -> None:
+    q = SelectQuery(sql_dialect, "users", database=mock_db)
+    q.inner_join("posts", lambda join: join.on(["users", "id"], ["posts", "user_id"]))
+    assert len(q.joins) == 1
+    assert len(q.joins[0].conditions) == 1
+
+
+def test_join_callback_returning_none_keeps_join(sql_dialect: SQLDialect, mock_db) -> None:
+    def on(join: Join) -> None:
+        join.on(["users", "id"], ["posts", "user_id"])
+
+    q = SelectQuery(sql_dialect, "users", database=mock_db)
+    q.inner_join("posts", on)
+    assert len(q.joins) == 1
+    assert len(q.joins[0].conditions) == 1
+
+
+def test_join_callback_returning_non_join_cancels_join(sql_dialect: SQLDialect, mock_db) -> None:
+    def on(join: Join) -> Any:
+        return False
+
+    q = SelectQuery(sql_dialect, "users", database=mock_db)
+    q.inner_join("posts", on)
+    assert q.joins == []
+
+
+def test_join_table_alias_wraps_table(sql_dialect: SQLDialect, mock_db) -> None:
+    q = SelectQuery(sql_dialect, "users", database=mock_db)
+    q.left_join_table("posts", None, "p")
+    assert isinstance(q.joins[0].table, Alias)

{flowmaticdb-2.2.0 → flowmaticdb-2.2.2}/tests/test_select_query.py

@@ -107,7 +107,6 @@ def test_select_where_group(sql_dialect: SQLDialect, mock_db) -> None:
 
 def test_select_join(sql_dialect: SQLDialect, mock_db) -> None:
     q: SelectQuery = SelectQuery(sql_dialect, "users", database=mock_db)
-    j = q.left_join("posts")
-    j.on("users.id", "posts.user_id")
+    q.left_join("posts", lambda join: join.on("users.id", "posts.user_id"))
     qwp: QueryWithParams = q.to_query_with_params()
     assert "LEFT JOIN" in qwp.query