TypeDAL 4.3.6__tar.gz → 4.4.1__tar.gz

typedal-4.4.1/.crush/.gitignore

@@ -0,0 +1 @@
+*

typedal-4.4.1/.crush/logs/crush.log

@@ -0,0 +1,25 @@
+{"time":"2026-01-26T17:01:48.91963488+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/config.(*catwalkSync).Get.func1","file":"github.com/charmbracelet/crush/internal/config/catwalk.go","line":55},"msg":"Fetching providers from Catwalk"}
+{"time":"2026-01-26T17:01:49.11634171+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/config.(*catwalkSync).Get.func1","file":"github.com/charmbracelet/crush/internal/config/catwalk.go","line":63},"msg":"Catwalk providers not modified"}
+{"time":"2026-01-26T17:01:49.116589785+01:00","level":"WARN","source":{"function":"github.com/charmbracelet/crush/internal/config.(*Config).configureProviders","file":"github.com/charmbracelet/crush/internal/config/load.go","line":259},"msg":"Skipping provider due to missing API key","provider":"anthropic"}
+{"time":"2026-01-26T17:01:49.128053484+01:00","level":"INFO","msg":"OK   20250424200609_initial.sql (1.26ms)"}
+{"time":"2026-01-26T17:01:49.128338994+01:00","level":"INFO","msg":"OK   20250515105448_add_summary_message_id.sql (263.8µs)"}
+{"time":"2026-01-26T17:01:49.128678839+01:00","level":"INFO","msg":"OK   20250624000000_add_created_at_indexes.sql (325.2µs)"}
+{"time":"2026-01-26T17:01:49.128984204+01:00","level":"INFO","msg":"OK   20250627000000_add_provider_to_messages.sql (291.73µs)"}
+{"time":"2026-01-26T17:01:49.12929983+01:00","level":"INFO","msg":"OK   20250810000000_add_is_summary_message.sql (265.62µs)"}
+{"time":"2026-01-26T17:01:49.129580779+01:00","level":"INFO","msg":"OK   20250812000000_add_todos_to_sessions.sql (268.09µs)"}
+{"time":"2026-01-26T17:01:49.129585964+01:00","level":"INFO","msg":"goose: successfully migrated database to version: 20250812000000"}
+{"time":"2026-01-26T17:01:49.129633405+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/app.(*App).initLSPClients","file":"github.com/charmbracelet/crush/internal/app/lsp.go","line":21},"msg":"LSP clients initialization started in background"}
+{"time":"2026-01-26T17:01:49.129745943+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/app.New.func1","file":"github.com/charmbracelet/crush/internal/app/app.go","line":110},"msg":"Initializing MCP clients"}
+{"time":"2026-01-26T17:01:49.73470854+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/app.(*App).createAndStartLSPClient","file":"github.com/charmbracelet/crush/internal/app/lsp.go","line":76},"msg":"LSP client initialized","name":"python"}
+{"time":"2026-01-26T17:02:52.962674187+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/agent.(*sessionAgent).generateTitle","file":"github.com/charmbracelet/crush/internal/agent/agent.go","line":788},"msg":"generated title with small model"}
+{"time":"2026-01-26T17:02:57.3247847+01:00","level":"WARN","source":{"function":"github.com/charmbracelet/crush/internal/agent/tools.init.func1","file":"github.com/charmbracelet/crush/internal/agent/tools/rg.go","line":18},"msg":"Ripgrep (rg) not found in $PATH. Some grep features might be limited or slower."}
+{"time":"2026-01-26T17:11:33.432259554+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/app.(*App).Shutdown.func1","file":"github.com/charmbracelet/crush/internal/app/app.go","line":507},"msg":"Shutdown took 6.286852ms"}
+{"time":"2026-01-26T17:11:33.982816329+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/config.(*catwalkSync).Get.func1","file":"github.com/charmbracelet/crush/internal/config/catwalk.go","line":55},"msg":"Fetching providers from Catwalk"}
+{"time":"2026-01-26T17:11:34.178260248+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/config.(*catwalkSync).Get.func1","file":"github.com/charmbracelet/crush/internal/config/catwalk.go","line":63},"msg":"Catwalk providers not modified"}
+{"time":"2026-01-26T17:11:34.178494988+01:00","level":"WARN","source":{"function":"github.com/charmbracelet/crush/internal/config.(*Config).configureProviders","file":"github.com/charmbracelet/crush/internal/config/load.go","line":259},"msg":"Skipping provider due to missing API key","provider":"anthropic"}
+{"time":"2026-01-26T17:11:34.18216688+01:00","level":"INFO","msg":"goose: no migrations to run. current version: 20250812000000"}
+{"time":"2026-01-26T17:11:34.182194111+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/app.(*App).initLSPClients","file":"github.com/charmbracelet/crush/internal/app/lsp.go","line":21},"msg":"LSP clients initialization started in background"}
+{"time":"2026-01-26T17:11:34.182335616+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/app.New.func1","file":"github.com/charmbracelet/crush/internal/app/app.go","line":110},"msg":"Initializing MCP clients"}
+{"time":"2026-01-26T17:11:34.786142525+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/app.(*App).createAndStartLSPClient","file":"github.com/charmbracelet/crush/internal/app/lsp.go","line":76},"msg":"LSP client initialized","name":"python"}
+{"time":"2026-01-26T17:11:43.042930337+01:00","level":"INFO","source":{"function":"github.com/charmbracelet/crush/internal/agent.(*sessionAgent).generateTitle","file":"github.com/charmbracelet/crush/internal/agent/agent.go","line":788},"msg":"generated title with small model"}
+{"time":"2026-01-26T17:11:44.911909276+01:00","level":"WARN","source":{"function":"github.com/charmbracelet/crush/internal/agent/tools.init.func1","file":"github.com/charmbracelet/crush/internal/agent/tools/rg.go","line":18},"msg":"Ripgrep (rg) not found in $PATH. Some grep features might be limited or slower."}

{typedal-4.3.6 → typedal-4.4.1}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 <!--next-version-placeholder-->
 
+## v4.4.1 (2026-01-26)
+
+### Fix
+
+* Test and support memoize with empty table and .execute() ([`76ea39b`](https://github.com/trialandsuccess/TypeDAL/commit/76ea39bf4f8beb2ad303e66b69ad01780359ad14))
+
+### Documentation
+
+* Add chapter 9 about `memoize` ([`e23a8c8`](https://github.com/trialandsuccess/TypeDAL/commit/e23a8c80ee60a5adb2d32c6d05fb398d5d703116))
+
+## v4.4.0 (2026-01-20)
+
+### Feature
+
+* Add groupby and having methods to QueryBuilder ([`8bce7ec`](https://github.com/trialandsuccess/TypeDAL/commit/8bce7ec137db79ab1631f4504ae891b5bd42c1d8))
+
 ## v4.3.6 (2026-01-19)
 
 ### Fix

{typedal-4.3.6 → typedal-4.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.3.6
+Version: 4.4.1
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues

{typedal-4.3.6 → typedal-4.4.1}/docs/3_building_queries.md

@@ -22,6 +22,8 @@ A Query Builder can be initialized by calling one of these methods on a TypedTab
 - where
 - select
 - join
+- groupby
+- having
 - cache
 
 e.g. `Person.where(...)` -> `QueryBuilder[Person]`
@@ -155,6 +157,35 @@ Person.join('articles', method='inner')  # will only yield persons that have rel
 
 For more details about relationships and joins, see [4. Relationships](./4_relationships.md).
 
+### groupby & having
+
+Group query results by one or more fields, typically used with aggregate functions like `count()`, `sum()`, `avg()`, etc.
+Use `having` to filter the grouped results based on aggregate conditions.
+
+```python
+# Basic grouping: count articles per author
+Article.select(Article.author, Article.id.count().with_alias("article_count"))
+    .groupby(Article.author)
+    .collect()
+
+# Group by multiple fields
+Sale.select(Sale.product, Sale.region, Sale.amount.sum().with_alias("total"))
+    .groupby(Sale.product, Sale.region)
+    .collect()
+
+# Filter groups with having: only authors with more than 5 articles
+Article.select(Article.author, Article.id.count().with_alias("article_count"))
+    .groupby(Article.author)
+    .having(Article.id.count() > 5)
+    .collect()
+
+# Can be chained in any order
+School.groupby(School.id)
+    .having(Team.id.count() > 0)
+    .select(School.id, Team.id.count())
+    .collect()
+```
+
 ### cache
 
 ```python
@@ -186,6 +217,8 @@ In order to enable this functionality, TypeDAL adds a `before update` and `befor
 which manages the dependencies. You can disable this behavior by passing `cache_dependency=False` to `db.define`.
 Be aware doing this might break some caching functionality!
 
+**Note:** For caching function results (instead of just query results), see [9. Function Memoization](./9_memoization.md).
+
 ### Collecting
 
 The Query Builder has a few operations that don't return a new builder instance:

{typedal-4.3.6 → typedal-4.4.1}/docs/8_mixins.md

@@ -121,3 +121,7 @@ recent_articles = (
 
 By using these mixins, you can enhance the functionality of your models in a modular and reusable manner, saving you
 time and effort in your development process.
+
+---
+
+Looking to cache expensive function results? Head to [9. Function Memoization](./9_memoization.md) to learn about `db.memoize()`.

typedal-4.4.1/docs/9_memoization.md

@@ -0,0 +1,150 @@
+# 9. Function Memoization
+
+TypeDAL provides database-aware function memoization via `db.memoize()`. This allows you to cache the result of expensive functions and automatically invalidate the cache when the underlying database rows change.
+
+## Overview
+
+While `.cache()` on query builders (see [3. Building Queries](./3_building_queries.md#cache)) caches query results, `db.memoize()` caches entire function results while tracking all database operations that happen inside the function.
+
+This is designed for cases where the database query itself is fast, but the application logic that follows is expensive.
+
+## Basic Usage
+
+Wrap any function call with `db.memoize()` to cache its result:
+
+```python
+def process_articles(articles: TypedRows[Article]) -> dict:
+    result = {}
+    # dummy example, normally you'd use .join() of course
+    for article in articles:
+        comments = Comment.where(article=article).collect()
+        result[article.id] = comments  
+    return result
+
+articles = Article.where(published=True).collect()
+
+result, status = db.memoize(process_articles, articles)
+assert status == "fresh"
+
+result, status = db.memoize(process_articles, articles)
+assert status == "cached"
+
+Comment.first().update_record(text="Updated")
+
+result, status = db.memoize(process_articles, articles)
+assert status == "fresh"  # cache invalidated!
+```
+
+The return value is a tuple of `(result, status)`:
+- `result`: The actual return value of the function
+- `status`: Either `"fresh"` (newly computed) or `"cached"` (retrieved from cache)
+
+## Automatic Dependency Tracking
+
+TypeDAL automatically tracks all database rows loaded during function execution. This includes:
+
+- Direct queries (`Table.where(...).collect()`)
+- Joins (`Table.join().collect()`)
+- Nested queries inside loops
+
+When any tracked row is updated, inserted, or deleted, the cached result is invalidated:
+
+```python
+def something_slow():
+    return list(User.join())
+
+result, status = db.memoize(something_slow)
+assert status == "fresh"
+
+User.first().update_record(name="Changed")
+
+result, status = db.memoize(something_slow)
+assert status == "fresh"  # cache was invalidated
+```
+
+## TTL (Time To Live)
+
+Control cache lifetime using the `ttl` parameter. It accepts seconds (int), a `timedelta`, or an absolute `datetime`:
+
+```python
+from datetime import datetime, timedelta
+
+# Expire after 1 hour (3600 seconds)
+db.memoize(func, data, ttl=3600)
+
+# Expire after 1 hour (timedelta)
+db.memoize(func, data, ttl=timedelta(hours=1))
+
+# Expire at specific datetime
+db.memoize(func, data, ttl=datetime(2026, 1, 7))
+```
+
+## Cache Maintenance
+
+The `typedal.caching` module provides utilities for cache management:
+
+```python
+from typedal.caching import clear_cache, remove_cache_for_table, clear_expired
+
+# Remove all cache entries
+clear_cache()
+
+# Invalidate all cache entries related to a specific table
+remove_cache_for_table(User)
+
+# Clean up expired entries only
+clear_expired()
+```
+
+You can also use the CLI:
+
+```bash
+# Clean up expired entries
+typedal cache.clear
+
+# Show cache statistics
+typedal cache.stats
+```
+
+## Debugging & Profiling
+
+TypeDAL provides `before_collect`/`before_execute` and `after_collect`/`after_execute` hooks on the database instance for debugging and profiling queries:
+
+```python
+def print_query(qb: QueryBuilder):
+    print("going to run", qb.to_sql())
+
+def print_duration(_qb: QueryBuilder, rows, _raw):
+    print("took", rows.metadata["select_duration"])
+
+db.before_collect.append(print_query)
+db.after_collect.append(print_duration)
+
+TestQueryTable.all()  # will trigger both hooks
+```
+
+These hooks are used internally for dependency tracking but are exposed for debugging and observability.
+
+## How It Works
+
+When you call `db.memoize(func, *args, **kwargs)`:
+
+1. TypeDAL computes a cache key based on the function and its arguments
+2. If a valid cached result exists, it's returned with `status="cached"`
+3. Otherwise, the function is executed while tracking all database operations
+4. The result is cached along with the IDs of all rows accessed
+5. When any tracked row changes, the cache entry is invalidated
+
+The cache is stored in the `typedal_cache` (and `typedal_cache_dependency`) table (same as query-level caching).
+
+## Disabling Dependency Tracking
+
+If you need to disable cache invalidation hooks for a specific table:
+
+```python
+@db.define(cache_dependency=False)
+class SpecialTable(TypedTable):
+    ...
+```
+
+**Warning:** Disabling this may break caching functionality for queries involving this table.

{typedal-4.3.6 → typedal-4.4.1}/docs/index.md

@@ -8,3 +8,4 @@
 6. [Migrations](./6_migrations.md)
 7. [Advanced Configuration](./7_configuration.md)
 8. [Mixins](./8_mixins.md)
+9. [Function Memoization](./9_memoization.md)

{typedal-4.3.6 → typedal-4.4.1}/src/typedal/__about__.py

@@ -5,4 +5,4 @@ This file contains the Version info for this package.
 # SPDX-FileCopyrightText: 2023-present Robin van der Noord <robinvandernoord@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "4.3.6"
+__version__ = "4.4.1"

{typedal-4.3.6 → typedal-4.4.1}/src/typedal/caching.py

@@ -12,6 +12,7 @@ import dill  # nosec
 from pydal.objects import Field, Rows, Set
 
 from .fields import TypedField
+from .helpers import throw
 from .rows import TypedRows
 from .tables import TypedTable
 from .types import CacheStatus, Query
@@ -177,8 +178,12 @@ def clear_cache() -> None:
 
     Immediately commits
     """
+    db: TypeDAL = _TypedalCache._db or throw(
+        RuntimeError("@define or db.define is not called on typedal caching classes yet!")
+    )
+
     _TypedalCache.truncate("RESTART IDENTITY CASCADE")
-    _TypedalCache._db.commit()
+    db.commit()
 
 
 def clear_expired() -> int:
@@ -572,16 +577,45 @@ def memoize(
         return cached, "cached"
     # Cache miss - compute result
 
-    def track_collect(_qb: "QueryBuilder[t.Any]", _: TypedRows[t.Any], raw: Rows) -> None:
+    def track_execute(qb: "QueryBuilder[t.Any]", raw: Rows):
         # find dependant table+id combinations, includes relationships:
         deps.update(_determine_dependencies_auto(raw))
 
+        # tables: qb.model;
+        # something with qb.relationships
+        # something with qb.select_args
+
+        related_tables = (
+            {
+                # original table
+                str(qb.model)
+            }
+            | {
+                # other tables in select()
+                _get_table_name(arg)
+                for arg in qb.select_args
+            }
+            | {
+                # other tables in relationships
+                str(r.table)
+                for r in qb.relationships.values()
+            }
+        )
+
+        # mark dependency for every relevant table in this query without id:
+        deps.update({(table, 0) for table in related_tables})
+
+    def track_collect(qb: "QueryBuilder[t.Any]", _: TypedRows[t.Any], raw: Rows) -> None:
+        return track_execute(qb, raw)
+
     # hooks every .collect() to track extra dependencies
     db._after_collect.append(track_collect)
+    db._after_execute.append(track_execute)
     try:
         result = func(*args, **kwargs)
     finally:
         db._after_collect.remove(track_collect)
+        db._after_execute.remove(track_execute)
 
     # Save to cache
     if isinstance(ttl, dt.datetime):

{typedal-4.3.6 → typedal-4.4.1}/src/typedal/core.py

@@ -4,6 +4,7 @@ Core functionality of TypeDAL.
 
 from __future__ import annotations
 
+import datetime as dt
 import sys
 import typing as t
 import warnings
@@ -147,10 +148,12 @@ class TypeDAL(pydal.DAL):
     _config: TypeDALConfig
     _builder: TableDefinitionBuilder
 
-    # similar to the insert/update/delete hooks at table-level but for .collect:
+    # similar to the insert/update/delete hooks at table-level but for .collect/.execute:
     # note: return values are ignored!
     _before_collect: list[t.Callable[["QueryBuilder[t.Any]"], None]]
     _after_collect: list[t.Callable[["QueryBuilder[t.Any]", "TypedRows[t.Any]", "Rows"], None]]
+    _before_execute: list[t.Callable[["QueryBuilder[t.Any]"], None]]
+    _after_execute: list[t.Callable[["QueryBuilder[t.Any]", "Rows"], None]]
 
     def __init__(
         self,
@@ -207,6 +210,8 @@ class TypeDAL(pydal.DAL):
 
         self._before_collect = []
         self._after_collect = []
+        self._before_execute = []
+        self._after_execute = []
 
         if config.folder:
             Path(config.folder).mkdir(exist_ok=True)

{typedal-4.3.6 → typedal-4.4.1}/src/typedal/query_builder.py

@@ -70,8 +70,7 @@ class QueryBuilder(t.Generic[T_MetaInstance]):
         """
         self.model = model
         table = self._ensure_table_defined()
-
-        default_query = table.id > 0
+        default_query: Query = table.id > 0
         self.query = add_query or default_query
         self.select_args = select_args or []
         self.select_kwargs = select_kwargs or {}
@@ -111,7 +110,7 @@ class QueryBuilder(t.Generic[T_MetaInstance]):
         Querybuilder is truthy if it has t.Any conditions.
         """
         table = self._ensure_table_defined()
-        default_query = table.id > 0
+        default_query: Query = table.id > 0
         return any(
             [
                 self.query != default_query,
@@ -183,6 +182,31 @@ class QueryBuilder(t.Generic[T_MetaInstance]):
         """
         return self.select(orderby=fields)
 
+    def groupby(self, *fields: t.Any) -> "QueryBuilder[T_MetaInstance]":
+        """
+        Group the query results by specified fields.
+
+        Args:
+            fields: Field(s) to group by (e.g., Table.column)
+
+        Returns:
+            QueryBuilder: A new QueryBuilder instance with grouping applied.
+        """
+        groupby_value = fields[0] if len(fields) == 1 else fields
+        return self.select(groupby=groupby_value)
+
+    def having(self, condition: t.Any) -> "QueryBuilder[T_MetaInstance]":
+        """
+        Filter grouped query results based on aggregate conditions.
+
+        Args:
+            condition: Query condition for filtering groups (e.g., Team.id.count() > 0)
+
+        Returns:
+            QueryBuilder: A new QueryBuilder instance with having condition applied.
+        """
+        return self.select(having=condition)
+
     def where(
         self,
         *queries_or_lambdas: Query | t.Callable[[t.Type[T_MetaInstance]], Query] | dict[str, t.Any],
@@ -524,11 +548,19 @@ class QueryBuilder(t.Generic[T_MetaInstance]):
         Raw version of .collect which only executes the SQL, without performing t.Any magic afterwards.
         """
         db = self._get_db()
-        metadata = self.metadata.copy()
+        metadata: Metadata = self.metadata.copy()
 
         query, select_args, select_kwargs = self._before_query(metadata, add_id=add_id)
 
-        return db(query).select(*select_args, **select_kwargs)
+        for fn_before in db._before_execute:
+            fn_before(self)
+
+        rows = db(query).select(*select_args, **select_kwargs)
+
+        for fn_after in db._after_execute:
+            fn_after(self, rows)
+
+        return rows
 
     def collect(
         self,
@@ -552,7 +584,7 @@ class QueryBuilder(t.Generic[T_MetaInstance]):
         for fn_before in db._before_collect:
             fn_before(self)
 
-        metadata = self.metadata.copy()
+        metadata: Metadata = self.metadata.copy()
 
         if metadata.get("cache", {}).get("enabled") and (result := self._collect_cached(metadata)):
             return result

{typedal-4.3.6 → typedal-4.4.1}/src/typedal/tables.py

@@ -326,6 +326,18 @@ class TableMeta(type):
         """
         return QueryBuilder(self).orderby(*fields)
 
+    def groupby(self: t.Type[T_MetaInstance], *fields: t.Any) -> "QueryBuilder[T_MetaInstance]":
+        """
+        See QueryBuilder.groupby!
+        """
+        return QueryBuilder(self).groupby(*fields)
+
+    def having(self: t.Type[T_MetaInstance], condition: t.Any) -> "QueryBuilder[T_MetaInstance]":
+        """
+        See QueryBuilder.having!
+        """
+        return QueryBuilder(self).having(condition)
+
     def cache(self: t.Type[T_MetaInstance], *deps: t.Any, **kwargs: t.Any) -> "QueryBuilder[T_MetaInstance]":
         """
         See QueryBuilder.cache!

{typedal-4.3.6 → typedal-4.4.1}/src/typedal/types.py

@@ -220,6 +220,8 @@ class SelectKwargs(t.TypedDict, total=False):
     join: t.Optional[list[Expression]]
     left: t.Optional[list[Expression]]
     orderby: "OrderBy | t.Iterable[OrderBy] | None"
+    groupby: "GroupBy | t.Iterable[GroupBy] | None"
+    having: "Having | None"
     limitby: t.Optional[tuple[int, int]]
     distinct: bool | Field | Expression
     orderby_on_limitby: bool
@@ -323,5 +325,7 @@ CacheModel = t.Callable[[str, CacheFn, int], Rows]
 CacheTuple = tuple[CacheModel, int]
 
 OrderBy: t.TypeAlias = str | Expression
+GroupBy: t.TypeAlias = Field | Expression
+Having: t.TypeAlias = Query | Expression
 
 T_annotation = t.Type[t.Any] | types.UnionType

{typedal-4.3.6 → typedal-4.4.1}/tests/test_query_builder.py

@@ -45,25 +45,6 @@ def test_query_type():
     assert isinstance(TestQueryTable.number != 3, Query)
 
 
-"""
-SELECT "test_query_table"."id"
-     , "test_query_table"."number"
-     , "relations_8106139955393"."id"
-     , "relations_8106139955393"."name"
-     , "relations_8106139955393"."value"
-     , "relations_8106139955393"."querytable"
-    FROM "test_query_table"
-             LEFT JOIN "test_relationship" AS "relations_8106139955393"
-                       ON ("relations_8106139955393"."querytable" = "test_query_table"."id")
-    WHERE ("test_query_table"."id" IN (SELECT "test_query_table"."id"
-                                           FROM "test_query_table"
-                                           WHERE ("test_query_table"."id" > 0)
-                                           ORDER BY "test_query_table"."id"
-                                           LIMIT 3 OFFSET 0))
-    ORDER BY "test_query_table"."number" DESC;
-"""
-
-
 def _setup_data():
     TestQueryTable.truncate()
     first = TestQueryTable.insert(number=0)
@@ -546,7 +527,7 @@ def test_minimal_functionality_on_pydal_style_tables():
     assert len(qb2) == 1
 
 
-def test_before_after_collect():
+def test_before_after_collect(capsys):
     _setup_data()
 
     def print_query(qb: QueryBuilder):
@@ -562,3 +543,165 @@ def test_before_after_collect():
     db._after_collect.append(print_duration)
 
     TestQueryTable.all()
+    captured = capsys.readouterr()
+    assert "going to run" in captured.out
+    assert "took" in captured.out
+
+    db._before_execute.append(lambda *_: print("BEFORE EXECUTE"))
+    db._after_execute.append(lambda *_: print("AFTER EXECUTE"))
+    TestQueryTable.select().execute()
+    captured = capsys.readouterr()
+    assert "BEFORE EXECUTE" in captured.out
+    assert "AFTER EXECUTE" in captured.out
+
+
+def test_groupby_basic():
+    """Test basic groupby with count aggregation."""
+    _setup_data()
+
+    result = (
+        TestRelationship.select(
+            TestRelationship.querytable.with_alias("query_table"),
+            TestRelationship.querytable.count().with_alias("count"),
+        )
+        .groupby(TestRelationship.querytable)
+        .execute()
+    )
+
+    assert len(result) == 2
+    for row in result:
+        assert row["count"] == 4
+
+
+def test_groupby_multiple_fields():
+    """Test grouping by multiple fields."""
+    _setup_data()
+
+    result = (
+        TestRelationship.select(
+            TestRelationship.querytable,
+            TestRelationship.value,
+            TestRelationship.id.count().with_alias("count"),
+        )
+        .groupby(TestRelationship.querytable, TestRelationship.value)
+        .execute()
+    )
+
+    # Should group by combination of querytable and value
+    assert len(result) > 0
+
+
+def test_groupby_with_having():
+    """Test groupby with having to filter groups."""
+    _setup_data()
+
+    result = (
+        TestRelationship.select(
+            TestRelationship.querytable.with_alias("query_table"),
+            TestRelationship.querytable.count().with_alias("count"),
+        )
+        .groupby(TestRelationship.querytable)
+        .having(TestRelationship.querytable.count() > 3)
+        .execute()
+    )
+
+    # Only groups with count > 3
+    assert len(result) == 2
+    for row in result:
+        assert row["count"] > 3
+
+
+def test_having_filters_aggregates():
+    """Test that having properly filters based on aggregate conditions."""
+    _setup_data()
+
+    # Get all groups
+    all_groups = (
+        TestRelationship.select(
+            TestRelationship.querytable,
+            TestRelationship.querytable.count().with_alias("count"),
+        )
+        .groupby(TestRelationship.querytable)
+        .execute()
+    )
+
+    # Filter with having
+    filtered = (
+        TestRelationship.select(
+            TestRelationship.querytable,
+            TestRelationship.querytable.count().with_alias("count"),
+        )
+        .groupby(TestRelationship.querytable)
+        .having(TestRelationship.querytable.count() > 10)
+        .execute()
+    )
+
+    # Should have fewer results (or zero if no groups have count > 10)
+    assert len(filtered) <= len(all_groups)
+
+
+def test_groupby_to_sql():
+    """Verify SQL generation includes GROUP BY."""
+    sql = (
+        TestRelationship.select(TestRelationship.querytable, TestRelationship.querytable.count())
+        .groupby(TestRelationship.querytable)
+        .to_sql()
+    )
+
+    assert "GROUP BY" in sql
+
+
+def test_having_to_sql():
+    """Verify SQL generation includes HAVING."""
+    sql = (
+        TestRelationship.select(TestRelationship.querytable, TestRelationship.querytable.count())
+        .groupby(TestRelationship.querytable)
+        .having(TestRelationship.querytable.count() > 0)
+        .to_sql()
+    )
+
+    assert "GROUP BY" in sql
+    assert "HAVING" in sql
+
+
+def test_groupby_chaining():
+    """Test that multiple groupby calls work (last one should win)."""
+    _setup_data()
+
+    # First groupby by querytable
+    builder1 = TestRelationship.select(
+        TestRelationship.querytable, TestRelationship.querytable.count().with_alias("count")
+    ).groupby(TestRelationship.querytable)
+
+    # Then groupby by value (should override)
+    builder2 = builder1.groupby(TestRelationship.value)
+
+    sql = builder2.to_sql()
+    # Should only have the second groupby
+    assert "GROUP BY" in sql
+
+
+def test_groupby_having_on_table_class():
+    """Test calling .groupby() and .having() directly on table class in different orders."""
+    _setup_data()
+
+    builder1 = (
+        TestRelationship.groupby(TestRelationship.querytable)
+        .having(TestRelationship.querytable.count() > 0)
+        .select(TestRelationship.querytable, TestRelationship.querytable.count())
+    )
+
+    sql1 = builder1.to_sql()
+
+    builder2 = (
+        TestRelationship.having(TestRelationship.querytable.count() > 0)
+        .groupby(TestRelationship.querytable)
+        .select(TestRelationship.querytable, TestRelationship.querytable.count())
+    )
+    sql2 = builder2.to_sql()
+
+    assert sql1 == sql2
+    assert "GROUP BY" in sql1
+    assert "HAVING" in sql1
+
+    assert builder1.execute() == builder2.execute()

{typedal-4.3.6 → typedal-4.4.1}/tests/test_relationships.py

@@ -774,6 +774,51 @@ def test_memoize_nested_dependencies2():
     assert status == "cached"
 
 
+def test_memoize_with_empty_table():
+    """
+    Test memoization when the table has no data yet.
+    Ensures cache invalidation works correctly when data is added later.
+    """
+    # (no setup data needed since we'll truncate anyway)
+
+    # Clean up - ensure table is empty
+    for table in db.tables:
+        db[table].truncate()
+
+    db.commit()
+
+    # Memoize a function with empty table
+    def get_all_users() -> list[str]:
+        users = User.join().select(User.name).execute()  # also tests execute instead of collect
+        return [user[User.name] for user in users]
+
+    # First call with empty table
+    result1, status1 = db.memoize(get_all_users)
+    assert status1 == "fresh"
+    assert result1 == []
+
+    # Second call - should be cached
+    result2, status2 = db.memoize(get_all_users)
+    assert status2 == "cached"
+    assert result2 == []
+
+    # Now insert data into the empty table
+    role = Role.insert(name="admin")
+    User.insert(name="First User", roles=[role], main_role=role, extra_roles=[])
+    db.commit()
+
+    # Third call - cache should be invalidated due to insert
+    result3, status3 = db.memoize(get_all_users)
+    assert status3 == "fresh", "Cache should be invalidated after insert into previously empty table"
+    assert len(result3) == 1
+    assert "First User" in result3
+
+    # Fourth call - should be cached again
+    result4, status4 = db.memoize(get_all_users)
+    assert status4 == "cached"
+    assert result3 == result4
+
+
 def test_illegal():
     with pytest.raises(ValueError), pytest.warns(UserWarning):