tinybird-toolset 2.5.4__tar.gz → 2.6.0__tar.gz

{tinybird_toolset-2.5.4/src/tinybird_toolset.egg-info → tinybird_toolset-2.6.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: tinybird-toolset
-Version: 2.5.4
+Version: 2.6.0
 Home-page: https://gitlab.com/tinybird/clickhouse-toolset
 Author: Tinybird.co
 Author-email: support@tinybird.co
-Requires-Python: >=3.10, <3.15
+Requires-Python: >=3.13, <3.15
 License-File: LICENSE
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/README.md

@@ -70,9 +70,9 @@ You'll also need `objcopy` or `llvm-objcopy` in your path. The latter is more pr
 in the bin path of your homebrew llvm installation, so you'll have to do something like: `export PATH="/opt/homebrew/opt/llvm@19/bin:$PATH"`
 
 ```bash
-make build-3.11    # Build for Python 3.11
-make test-3.11     # Build and test
-OMIT_PATCHES=1 make build-3.11  # Skip patches on rebuild
+make build-3.13    # Build for Python 3.13
+make test-3.13     # Build and test
+OMIT_PATCHES=1 make build-3.13  # Skip patches on rebuild
 ```
 
 ### Key Profiling Targets
@@ -113,8 +113,8 @@ make build      # Build for all Python versions
 make test       # Run tests for all Python versions
 
 # Or for a specific Python version
-make build-3.11 # Build only for Python 3.11
-make test-3.11  # Test only for Python 3.11
+make build-3.13 # Build only for Python 3.13
+make test-3.13  # Test only for Python 3.13
 ```
 
 The Docker image includes:
@@ -139,7 +139,7 @@ sudo bash -c "$(wget -O - https://apt.llvm.org/llvm.sh)"
 
 sudo add-apt-repository ppa:deadsnakes/ppa
 sudo apt update
-sudo apt install python3.10-dev python3.11-dev python3.12-dev python3.13-dev python3.14-dev
+sudo apt install python3.13-dev python3.14-dev
 
 pip3 install virtualenv
 ```
@@ -199,7 +199,7 @@ source ~/.zshrc
 
 * Follow the normal build. When validating a new machine or toolchain, prefer building a single Python version first:
 ```bash
-make build-3.11
+make build-3.13
 ```
 Then run the full build only after that succeeds:
 ```bash
@@ -283,7 +283,7 @@ export TWINE_PASSWORD=pypi-...  # PyPI API token
 ```
 
 The script will:
-- Build wheels for Python 3.10-3.14
+- Build wheels for Python 3.13-3.14
 - Delocate them (bundle dynamic libraries, set minimum macOS version to 11.0)
 - Run tests for each Python version
 - Upload to PyPI

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/conf.py

@@ -417,7 +417,7 @@ class CustomBuildWithFromCH(build_ext):
 
         compiler = getattr(self.compiler, "compiler_so")
         if sys.platform == 'darwin':
-            # Fix for problem in Apple Silicon Mac with Python 3.11
+            # Fix for problem in Apple Silicon Mac with Python 3.x
             # both -arch arm64 and -arch x86_64 are included and this collides with
             # other -march option from cflags() (generated by Ninja)
             if 'x86_64' in compiler and 'arm64' in compiler:

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, Extension
 
 NAME = 'tinybird-toolset'
-VERSION = '2.5.4'
+VERSION = '2.6.0'
 
 # Shared metadata for both the full (extension) build and the metadata-only
 # fallback below, so the two setup() calls can't drift apart.
@@ -13,7 +13,7 @@ common_kwargs = dict(
     author_email="support@tinybird.co",
     packages=["chtoolset"],
     package_dir={"": "src"},
-    python_requires=">=3.10, <3.15",
+    python_requires=">=3.13, <3.15",
     install_requires=[],
 )
 

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/src/chtoolset/query.py

@@ -21,6 +21,8 @@ from chtoolset._query import replace_tables, \
     get_columns_from_create_query, \
     normalize_table_column, \
     validate_ttl, \
+    validate_partition_key, \
+    check_ttl_partition_compatibility, \
     parse_create_materialized_view_target_table as _parse_create_materialized_view_target_table
 
 from typing import Optional, TypedDict

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0/src/tinybird_toolset.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: tinybird-toolset
-Version: 2.5.4
+Version: 2.6.0
 Home-page: https://gitlab.com/tinybird/clickhouse-toolset
 Author: Tinybird.co
 Author-email: support@tinybird.co
-Requires-Python: >=3.10, <3.15
+Requires-Python: >=3.13, <3.15
 License-File: LICENSE
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/src/tinybird_toolset.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/tinybird_toolset.egg-info/dependency_links.txt
 src/tinybird_toolset.egg-info/requires.txt
 src/tinybird_toolset.egg-info/top_level.txt
 tests/test_check_compatible_types.py
+tests/test_check_ttl_partition_compatibility.py
 tests/test_check_write_query.py
 tests/test_chquery.py
 tests/test_convert_to_row_binary.py
@@ -25,4 +26,5 @@ tests/test_replace_tables.py
 tests/test_replace_tables_backward_compat.py
 tests/test_rewrite_aggregation_states.py
 tests/test_tables.py
+tests/test_validate_partition_key.py
 tests/test_validate_ttl.py

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/tests/test_check_compatible_types.py

@@ -357,6 +357,21 @@ class TestCast(unittest.TestCase):
             self.assertTrue(chquery.check_compatible_types('AggregateFunction(sum, Int16)', 'AggregateFunction(sum, Int8)'))
         self.assertEqual(str(error.exception), """Different #0 argument: Int16 vs Int8""")
 
+    def test_works_with_aggregate_functions_over_json(self):
+        # Regression test for PLTF-842: resolving an AggregateFunction/
+        # SimpleAggregateFunction over a JSON value type used to segfault.
+        # DataTypeObject::doGetDefaultSerialization() unconditionally
+        # dereferences Context::getGlobalContextInstance() to read the
+        # allow_simdjson setting, which is null since chtoolset never runs
+        # a real clickhouse-server. See CheckCompatibleTypes.cpp.
+        self.assertTrue(chquery.check_compatible_types(
+            'AggregateFunction(argMax, JSON, DateTime)',
+            'AggregateFunction(argMax, JSON, DateTime)'))
+
+        self.assertTrue(chquery.check_compatible_types(
+            'SimpleAggregateFunction(any, JSON)',
+            'SimpleAggregateFunction(any, JSON)'))
+
     def test_rejects_if_agg_parameters_are_incompatible(self):
         with self.assertRaises(ValueError) as error:
             self.assertTrue(chquery.check_compatible_types('AggregateFunction(topK, String)', 'AggregateFunction(topK(100), String)'))
@@ -365,3 +380,44 @@ class TestCast(unittest.TestCase):
         with self.assertRaises(ValueError) as error:
             self.assertTrue(chquery.check_compatible_types('AggregateFunction(topK(99), String)', 'AggregateFunction(topK(100), String)'))
         self.assertEqual(str(error.exception), """Different #0 parameter: 99 vs 100""")
+
+    # Nested/composed types that must resolve without crashing. Covers PLTF-842
+    # (JSON nested inside Array/Map/Tuple/Nested/AggregateFunction combinators,
+    # which all previously segfaulted resolving JSON's default serialization
+    # without a global ClickHouse Context) plus general composed-type coverage.
+    NESTED_AND_COMPOSED_TYPES = [
+        'Array(JSON)',
+        'Map(String, JSON)',
+        'Tuple(JSON, String)',
+        'Tuple(a JSON, b String)',
+        'Nullable(JSON)',
+        'Nested(a JSON, b String)',
+        'AggregateFunction(argMax, Array(JSON), DateTime)',
+        'AggregateFunction(argMax, Map(String, JSON), DateTime)',
+        'AggregateFunction(argMax, Tuple(JSON, String), DateTime)',
+        'SimpleAggregateFunction(any, Array(JSON))',
+        'Array(AggregateFunction(argMax, JSON, DateTime))',
+        'Array(LowCardinality(String))',
+        'Map(String, LowCardinality(String))',
+        'Array(Nullable(Int64))',
+        'Map(String, Nullable(Int64))',
+        'Map(String, AggregateFunction(sum, Int64))',
+        'Nested(a UInt64, b String)',
+        'Tuple(x Float64, y Float64)',
+        'Array(Tuple(UInt8, String))',
+        'Array(Array(String))',
+        'Map(String, Array(String))',
+        'Map(String, Map(String, Int64))',
+        'Variant(String, Int64)',
+        'Dynamic',
+        'LowCardinality(Nullable(String))',
+    ]
+
+    def test_nested_and_composed_types_self_compatible(self):
+        for type_str in self.NESTED_AND_COMPOSED_TYPES:
+            with self.subTest(type_str):
+                self.assertTrue(chquery.check_compatible_types(type_str, type_str))
+
+    def test_low_cardinality_of_json_is_rejected(self):
+        with self.assertRaisesRegex(ValueError, 'DataTypeLowCardinality is supported only for'):
+            chquery.check_compatible_types('LowCardinality(JSON)', 'LowCardinality(JSON)')

tinybird_toolset-2.6.0/tests/test_check_ttl_partition_compatibility.py

@@ -0,0 +1,175 @@
+import unittest
+from chtoolset import query as chquery
+
+
+class TestCheckTTLPartitionCompatibility(unittest.TestCase):
+    def test_checked_and_compatible(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 1 MONTH",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertTrue(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_checked_and_compatible_uses_interval_count(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 90 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertTrue(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_checked_and_incompatible(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertTrue(result["checked"])
+        self.assertIsNotNone(result["error"])
+        self.assertIn("shorter than the partition key period", result["error"])
+
+    def test_mixed_where_clause_ttl_is_not_checked(self):
+        # A WHERE clause makes the whole statement ineligible for ttl_only_drop_parts,
+        # including when it also contains an unconditional TTL.
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "status", "type": "String"},
+            ],
+            ttl="ts + INTERVAL 1 MONTH, ts + INTERVAL 1 DAY WHERE status = 'expired'",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_when_a_ttl_clause_is_unrecognized(self):
+        # An unrecognized unconditional TTL remains unchecked; the WHERE clause also makes the
+        # whole statement ineligible for the optimization.
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "other_col", "type": "DateTime"},
+                {"name": "flag", "type": "UInt8"},
+            ],
+            ttl="toDateTime(other_col) + INTERVAL 1 DAY, ts + INTERVAL 1 MONTH WHERE flag = 1",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+        # validate_ttl, by contrast, silently accepts it - confirming the gap this function closes.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "other_col", "type": "DateTime"},
+                    {"name": "flag", "type": "UInt8"},
+                ],
+                ttl="toDateTime(other_col) + INTERVAL 1 DAY, ts + INTERVAL 1 MONTH WHERE flag = 1",
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_not_checked_when_only_where_ttl_exists(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "flag", "type": "UInt8"},
+            ],
+            ttl="ts + INTERVAL 1 DAY WHERE flag = 1",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_when_ttl_column_differs_from_partition_column(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "updated_at", "type": "DateTime"},
+            ],
+            ttl="updated_at + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_for_composite_partition_key(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "k", "type": "String"},
+            ],
+            ttl="ts + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts), k",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_for_unrecognized_partition_function(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="intDiv(toUInt32(ts), 86400)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_when_no_partition_key(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_when_no_ttl(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_on_malformed_ttl(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="this is not a valid ttl !!!",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/tests/test_get_columns_from_create_query.py

@@ -670,6 +670,107 @@ class TestGetColumnsFromCreateQuery(unittest.TestCase):
             'is_primary_key': False,
         })
 
+    def test_aggregate_function_over_json_type(self):
+        """Regression test for PLTF-842: resolving an AggregateFunction over a
+        JSON value type used to segfault inside columnInfoFromColumnDeclaration
+        (functions/NormalizeColumnsFromDict.cpp), which calls DataTypeFactory
+        without a global ClickHouse Context. JSON's default serialization reads
+        that context unconditionally to check the allow_simdjson setting."""
+        sql = """
+        CREATE TABLE test (
+            id UInt64,
+            payload AggregateFunction(argMax, JSON, DateTime)
+        ) ENGINE = AggregatingMergeTree() ORDER BY id
+        """
+        cols = chquery.get_columns_from_create_query(sql)
+        self.assertEqual(len(cols), 2)
+
+        self.assertColumnEquals(cols[1], {
+            'name': 'payload',
+            'type': 'AggregateFunction(argMax, JSON, DateTime)',
+            'nullable': False,
+            'default_specifier': '',
+            'default_expression': None,
+            'codec': None,
+            'comment': None,
+            'ttl': None,
+            'is_primary_key': False,
+        })
+
+    # Nested/composed type -> expected (normalized_type, nullable). Covers PLTF-842
+    # (JSON nested inside Array/Map/Tuple/Nested/AggregateFunction combinators, which
+    # all previously segfaulted resolving JSON's default serialization without a
+    # global ClickHouse Context) plus general composed-type coverage so any similar
+    # gap for other types would show up here too.
+    NESTED_AND_COMPOSED_TYPES = [
+        ('Array(JSON)', ('Array(JSON)', False)),
+        ('Map(String, JSON)', ('Map(String, JSON)', False)),
+        ('Tuple(JSON, String)', ('Tuple(JSON, String)', False)),
+        ('Tuple(a JSON, b String)', ('Tuple(a JSON, b String)', False)),
+        ('Nullable(JSON)', ('Nullable(JSON)', True)),
+        ('Nested(a JSON, b String)', ('Nested(a JSON, b String)', False)),
+        ('AggregateFunction(argMax, JSON, DateTime)', ('AggregateFunction(argMax, JSON, DateTime)', False)),
+        ('AggregateFunction(argMax, Array(JSON), DateTime)', ('AggregateFunction(argMax, Array(JSON), DateTime)', False)),
+        ('AggregateFunction(argMax, Map(String, JSON), DateTime)', ('AggregateFunction(argMax, Map(String, JSON), DateTime)', False)),
+        ('AggregateFunction(argMax, Tuple(JSON, String), DateTime)', ('AggregateFunction(argMax, Tuple(JSON, String), DateTime)', False)),
+        ('SimpleAggregateFunction(any, JSON)', ('SimpleAggregateFunction(any, JSON)', False)),
+        ('SimpleAggregateFunction(any, Array(JSON))', ('SimpleAggregateFunction(any, Array(JSON))', False)),
+        ('Array(AggregateFunction(argMax, JSON, DateTime))', ('Array(AggregateFunction(argMax, JSON, DateTime))', False)),
+        ('Array(LowCardinality(String))', ('Array(LowCardinality(String))', False)),
+        ('Map(String, LowCardinality(String))', ('Map(String, LowCardinality(String))', False)),
+        ('Array(Nullable(Int64))', ('Array(Nullable(Int64))', False)),
+        ('Map(String, Nullable(Int64))', ('Map(String, Nullable(Int64))', False)),
+        ('Map(String, AggregateFunction(sum, Int64))', ('Map(String, AggregateFunction(sum, Int64))', False)),
+        ('Nested(a UInt64, b String)', ('Nested(a UInt64, b String)', False)),
+        ('Tuple(x Float64, y Float64)', ('Tuple(x Float64, y Float64)', False)),
+        ('Array(Tuple(UInt8, String))', ('Array(Tuple(UInt8, String))', False)),
+        ('Array(Array(String))', ('Array(Array(String))', False)),
+        ('Map(String, Array(String))', ('Map(String, Array(String))', False)),
+        ('Map(String, Map(String, Int64))', ('Map(String, Map(String, Int64))', False)),
+        ('Variant(String, Int64)', ('Variant(String, Int64)', False)),
+        ('Dynamic', ('Dynamic', False)),
+        ('LowCardinality(Nullable(String))', ('LowCardinality(Nullable(String))', True)),
+    ]
+
+    def test_nested_and_composed_types(self):
+        """Regression test for PLTF-842 plus general coverage: resolving nested
+        and composed types (Array/Map/Tuple/Nested/AggregateFunction combinators,
+        including JSON nested inside them) must not crash columnInfoFromColumnDeclaration
+        (functions/NormalizeColumnsFromDict.cpp)."""
+        for type_str, (expected_type, expected_nullable) in self.NESTED_AND_COMPOSED_TYPES:
+            with self.subTest(type_str):
+                sql = f"""
+                CREATE TABLE test (
+                    id UInt64,
+                    col {type_str}
+                ) ENGINE = AggregatingMergeTree() ORDER BY id
+                """
+                cols = chquery.get_columns_from_create_query(sql)
+                self.assertEqual(len(cols), 2)
+                self.assertColumnEquals(cols[1], {
+                    'name': 'col',
+                    'type': expected_type,
+                    'nullable': expected_nullable,
+                    'default_specifier': '',
+                    'default_expression': None,
+                    'codec': None,
+                    'comment': None,
+                    'ttl': None,
+                    'is_primary_key': False,
+                })
+
+    def test_low_cardinality_of_json_is_rejected(self):
+        """LowCardinality only supports numbers, strings, Date or DateTime; JSON
+        must be rejected with a clear error rather than crashing."""
+        sql = """
+        CREATE TABLE test (
+            id UInt64,
+            col LowCardinality(JSON)
+        ) ENGINE = AggregatingMergeTree() ORDER BY id
+        """
+        with self.assertRaisesRegex(ValueError, 'DataTypeLowCardinality is supported only for'):
+            chquery.get_columns_from_create_query(sql)
+
     def test_invalid_query(self):
         """Test that invalid queries raise appropriate errors"""
         with self.assertRaises(ValueError):

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/tests/test_normalize_table_column.py

@@ -390,6 +390,81 @@ class TestNormalizeTableColumn(unittest.TestCase):
 
         self.assertEqual(column["type"], "Float64")
 
+    def test_aggregate_function_over_json_type(self):
+        # Regression test for PLTF-842: normalizeColumnInfo() calls
+        # columnInfoFromColumnDeclaration() (functions/NormalizeColumnsFromDict.cpp),
+        # which used to segfault resolving an AggregateFunction over a JSON value
+        # type via DataTypeFactory without a global ClickHouse Context.
+        column = chquery.normalize_table_column(
+            column={
+                "name": "payload",
+                "normalized_name": "payload",
+                "type": "AggregateFunction(argMax, JSON, DateTime)",
+                "nullable": False,
+            },
+        )
+
+        self.assertEqual(column["type"], "AggregateFunction(argMax, JSON, DateTime)")
+        self.assertFalse(column["nullable"])
+
+    # Nested/composed type -> expected (normalized_type, nullable). Covers PLTF-842
+    # (JSON nested inside Array/Map/Tuple/Nested/AggregateFunction combinators)
+    # plus general composed-type coverage for normalizeColumnInfo()
+    # (functions/NormalizeColumnsFromDict.cpp).
+    NESTED_AND_COMPOSED_TYPES = [
+        ('Array(JSON)', ('Array(JSON)', False)),
+        ('Map(String, JSON)', ('Map(String, JSON)', False)),
+        ('Tuple(JSON, String)', ('Tuple(JSON, String)', False)),
+        ('Tuple(a JSON, b String)', ('Tuple(a JSON, b String)', False)),
+        ('Nullable(JSON)', ('Nullable(JSON)', True)),
+        ('Nested(a JSON, b String)', ('Nested(a JSON, b String)', False)),
+        ('AggregateFunction(argMax, Array(JSON), DateTime)', ('AggregateFunction(argMax, Array(JSON), DateTime)', False)),
+        ('AggregateFunction(argMax, Map(String, JSON), DateTime)', ('AggregateFunction(argMax, Map(String, JSON), DateTime)', False)),
+        ('AggregateFunction(argMax, Tuple(JSON, String), DateTime)', ('AggregateFunction(argMax, Tuple(JSON, String), DateTime)', False)),
+        ('SimpleAggregateFunction(any, JSON)', ('SimpleAggregateFunction(any, JSON)', False)),
+        ('SimpleAggregateFunction(any, Array(JSON))', ('SimpleAggregateFunction(any, Array(JSON))', False)),
+        ('Array(AggregateFunction(argMax, JSON, DateTime))', ('Array(AggregateFunction(argMax, JSON, DateTime))', False)),
+        ('Array(LowCardinality(String))', ('Array(LowCardinality(String))', False)),
+        ('Map(String, LowCardinality(String))', ('Map(String, LowCardinality(String))', False)),
+        ('Array(Nullable(Int64))', ('Array(Nullable(Int64))', False)),
+        ('Map(String, Nullable(Int64))', ('Map(String, Nullable(Int64))', False)),
+        ('Map(String, AggregateFunction(sum, Int64))', ('Map(String, AggregateFunction(sum, Int64))', False)),
+        ('Nested(a UInt64, b String)', ('Nested(a UInt64, b String)', False)),
+        ('Tuple(x Float64, y Float64)', ('Tuple(x Float64, y Float64)', False)),
+        ('Array(Tuple(UInt8, String))', ('Array(Tuple(UInt8, String))', False)),
+        ('Array(Array(String))', ('Array(Array(String))', False)),
+        ('Map(String, Array(String))', ('Map(String, Array(String))', False)),
+        ('Map(String, Map(String, Int64))', ('Map(String, Map(String, Int64))', False)),
+        ('Variant(String, Int64)', ('Variant(String, Int64)', False)),
+        ('Dynamic', ('Dynamic', False)),
+        ('LowCardinality(Nullable(String))', ('LowCardinality(Nullable(String))', True)),
+    ]
+
+    def test_nested_and_composed_types(self):
+        for type_str, (expected_type, expected_nullable) in self.NESTED_AND_COMPOSED_TYPES:
+            with self.subTest(type_str):
+                column = chquery.normalize_table_column(
+                    column={
+                        "name": "col",
+                        "normalized_name": "col",
+                        "type": type_str,
+                        "nullable": False,
+                    },
+                )
+                self.assertEqual(column["type"], expected_type)
+                self.assertEqual(column["nullable"], expected_nullable)
+
+    def test_low_cardinality_of_json_is_rejected(self):
+        with self.assertRaisesRegex(ValueError, 'DataTypeLowCardinality is supported only for'):
+            chquery.normalize_table_column(
+                column={
+                    "name": "col",
+                    "normalized_name": "col",
+                    "type": "LowCardinality(JSON)",
+                    "nullable": False,
+                },
+            )
+
     def test_default_now_for_created_at(self):
         column = chquery.normalize_table_column(
             column={

tinybird_toolset-2.6.0/tests/test_validate_partition_key.py

@@ -0,0 +1,150 @@
+import unittest
+from chtoolset import query as chquery
+
+
+class TestValidatePartitionKey(unittest.TestCase):
+    def test_valid_empty_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="",
+            )
+        )
+
+    def test_valid_hourly_partition_key(self):
+        # Hour is the floor - allowed.
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="toStartOfHour(ts)",
+            )
+        )
+
+    def test_valid_daily_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="toDate(ts)",
+            )
+        )
+
+    def test_valid_monthly_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_invalid_minute_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfMinute(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_second_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfSecond(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_five_minute_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfFiveMinutes(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_ten_minute_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfTenMinutes(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_fifteen_minute_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfFifteenMinutes(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_five_minute_singular_alias_partition_key(self):
+        # toStartOfFiveMinute (singular) is a registered alias for toStartOfFiveMinutes.
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfFiveMinute(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_millisecond_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime64(3)"}],
+            partition_key="toStartOfMillisecond(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_microsecond_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime64(6)"}],
+            partition_key="toStartOfMicrosecond(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_nanosecond_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime64(9)"}],
+            partition_key="toStartOfNanosecond(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_yyyymmddhhmmss_partition_key(self):
+        # Packs the full date+time down to the second - no coarsening at all.
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toYYYYMMDDhhmmss(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_valid_skipped_for_composite_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "k", "type": "String"},
+                ],
+                partition_key="toStartOfMinute(ts), k",
+            )
+        )
+
+    def test_valid_skipped_for_unrecognized_function(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="intDiv(toUInt32(ts), 60)",
+            )
+        )
+
+    def test_valid_skipped_for_bare_column(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "k", "type": "String"}],
+                partition_key="k",
+            )
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

{tinybird_toolset-2.5.4 → tinybird_toolset-2.6.0}/tests/test_validate_ttl.py

@@ -389,6 +389,254 @@ class TestValidateTTL(unittest.TestCase):
                 primary_key="ts",
             )
 
+    # --- Partition key / TTL granularity ---
+    def test_invalid_ttl_finer_than_partition_month_vs_day(self):
+        err = chquery.validate_ttl(
+            ttl="ts + INTERVAL 7 DAY",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than the partition key period", err)
+
+    def test_invalid_ttl_finer_than_partition_month_vs_week(self):
+        err = chquery.validate_ttl(
+            ttl="ts + INTERVAL 1 WEEK",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than the partition key period", err)
+
+    def test_valid_ttl_interval_count_is_included_in_duration(self):
+        # 90 DAY is comparable to 3 MONTH for a monthly partition; the DAY unit alone
+        # must not cause a rejection.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 90 DAY",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_invalid_ttl_interval_does_not_cover_longest_partition_period(self):
+        err = chquery.validate_ttl(
+            ttl="ts + INTERVAL 30 DAY",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than the partition key period", err)
+
+    def test_valid_ttl_interval_covers_longest_partition_period(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 31 DAY",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_valid_ttl_coarser_than_partition_month_vs_day(self):
+        # TTL is monthly, partition is daily: whole day-partitions still expire together.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 3 MONTH",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toDate(ts)",
+            )
+        )
+
+    def test_valid_ttl_matches_partition_granularity(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 1 MONTH",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_valid_no_partition_key_skips_granularity_check(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 7 DAY",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+            )
+        )
+
+    def test_valid_granularity_check_skipped_for_different_column(self):
+        # TTL and partition key are on different columns; the relationship is unknown, so no check is applied.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 7 DAY",
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "inserted_at", "type": "DateTime"},
+                ],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(inserted_at)",
+            )
+        )
+
+    def test_valid_granularity_check_skipped_for_composite_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 7 DAY",
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "k", "type": "String"},
+                ],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts), k",
+            )
+        )
+
+    def test_valid_granularity_check_skipped_for_unrecognized_partition_function(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 7 DAY",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="intDiv(toUInt32(ts), 86400)",
+            )
+        )
+
+    def test_invalid_bare_column_ttl_with_partition_key(self):
+        # No INTERVAL at all: the TTL fires the instant the raw column value is reached,
+        # which is finer than any partition granularity.
+        err = chquery.validate_ttl(
+            ttl="ts",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than the partition key period", err)
+
+    def test_valid_mixed_where_clause_ttl_skips_part_drop_check(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 1 DAY, ts + INTERVAL 1 DAY WHERE status = 'expired'",
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "status", "type": "String"},
+                ],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_invalid_fixed_interval_can_be_shorter_than_calendar_truncation(self):
+        # A month can contain 31 days, so late rows in that month can be born expired.
+        err = chquery.validate_ttl(
+            ttl="toStartOfMonth(ts) + INTERVAL 30 DAY",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than its truncation period", err)
+
+    def test_valid_matching_calendar_interval_and_truncation(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="toStartOfMonth(ts) + INTERVAL 1 MONTH",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_valid_equivalent_calendar_interval_and_truncation(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="toStartOfQuarter(ts) + INTERVAL 3 MONTH",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toStartOfQuarter(ts)",
+            )
+        )
+
+    def test_valid_long_interval_with_truncated_base_finer_than_partition(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="toStartOfDay(ts) + INTERVAL 1 YEAR",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_invalid_interval_shorter_than_ttl_truncation(self):
+        err = chquery.validate_ttl(
+            ttl="toStartOfMonth(ts) + INTERVAL 5 MINUTE",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than its truncation period", err)
+        self.assertIn("expire as soon as they are inserted", err)
+
+    def test_invalid_interval_shorter_than_truncation_without_partition_key(self):
+        err = chquery.validate_ttl(
+            ttl="toStartOfHour(ts) + INTERVAL 5 MINUTE",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than its truncation period", err)
+
+    def test_valid_granularity_check_skipped_for_multi_minute_partition(self):
+        # toStartOfFiveMinutes isn't a recognized partition granularity (IntervalKind has no
+        # level between Minute and Hour), so the check is skipped rather than risk a false accept.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 1 MINUTE",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toStartOfFiveMinutes(ts)",
+            )
+        )
+
+    def test_valid_granularity_check_skipped_for_multi_minute_ttl_truncation(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="toStartOfFiveMinutes(ts) + INTERVAL 1 HOUR",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toStartOfTenMinutes(ts)",
+            )
+        )
 
     # --- Regression guard: sequential throwing calls must not crash ---
     def test_sequential_throwing_calls_do_not_crash(self):