tinybird-toolset 2.2.0__tar.gz → 2.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinybird-toolset
-Version: 2.2.0
+Version: 2.2.2
 Home-page: https://gitlab.com/tinybird/clickhouse-toolset
 Author: Tinybird.co
 Author-email: support@tinybird.co

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

@@ -208,7 +208,7 @@ make build
 A couple of environment variables can be defined with a non-empty value to help retrying the compilation and debugging:
 
 * `OMIT_PATCHES` prevents the application of the ClickHouse patches: this is useful if you've already applied them to avoid having to restore the original source code, since some patches may not re-apply cleanly.
-* `DEBUG_SYMBOLS` triggers the generation of debug symbols for the python extension code (query.cpp and the C++ functions, but not for the ClickHouse code).
+* `DEBUG_SYMBOLS` controls the generation of debug symbols for the python extension code (query.cpp and the C++ functions, but not for the ClickHouse code). It is enabled by default for package builds; set `DEBUG_SYMBOLS=0` to disable it.
 
 ## Examples
 
@@ -226,18 +226,13 @@ Releasing a new version requires publishing wheels for three platforms: Linux x8
 
 ### 2. Linux release (automatic)
 
-Linux x86_64 and ARM64 wheels are published automatically by the CI pipeline when a version tag is pushed:
+Linux x86_64 and ARM64 wheels are published automatically when the MR is merged to `master`. The CI detects the `setup.py` change, and the `release` job will:
 
-```bash
-git tag v1.5.0
-git push origin v1.5.0
-```
-
-The CI `release` job will:
-- Validate that the tag version matches `setup.py` VERSION
+- Compare the version in `setup.py` with the latest version on PyPI (skips if already published)
 - Collect auditwheel-repaired wheels for both x86_64 and ARM64
 - Build the source distribution
 - Upload everything to PyPI
+- Create a git tag `vX.Y.Z` automatically
 
 The `PYPI_TOKEN` CI/CD variable must be configured in GitLab (Settings > CI/CD > Variables) with a valid PyPI API token.
 

{tinybird_toolset-2.2.0 → tinybird_toolset-2.2.2}/conf.py

@@ -21,7 +21,7 @@ COMPILER_CC = os.environ.get('CC', 'clang')
 COMPILER_CXX = os.environ.get('CXX', 'clang++')
 
 BUILD_FOR_VALGRIND = bool(os.environ.get('BUILD_FOR_VALGRIND', ''))
-DEBUG_SYMBOLS = bool(os.environ.get('DEBUG_SYMBOLS', ''))
+DEBUG_SYMBOLS = os.environ.get('DEBUG_SYMBOLS', '1').lower() not in ('', '0', 'false', 'no')
 OMIT_PATCHES = bool(os.environ.get('OMIT_PATCHES', ''))
 SIMDJSON_DEBUG = bool(os.environ.get('SIMDJSON_DEBUG', ''))
 

{tinybird_toolset-2.2.0 → tinybird_toolset-2.2.2}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, Extension
 
 NAME = 'tinybird-toolset'
-VERSION = '2.2.0'
+VERSION = '2.2.2'
 
 try:
     from conf import *

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinybird-toolset
-Version: 2.2.0
+Version: 2.2.2
 Home-page: https://gitlab.com/tinybird/clickhouse-toolset
 Author: Tinybird.co
 Author-email: support@tinybird.co

{tinybird_toolset-2.2.0 → tinybird_toolset-2.2.2}/tests/test_check_write_query.py

@@ -154,48 +154,6 @@ class TestCreateTable(unittest.TestCase):
         """
         self.assertEqual(query.format(query.check_valid_write_query(q)), query.format(q))
 
-    def test_create_table_with_default_column_with_joinget_is_ok(self):
-        q = """
-            CREATE TABLE visits2
-            (
-                `event_time` DateTime,
-                `query` String,
-                `three` String DEFAULT joinGet(other_database.other_table,'val', toUInt32(number))
-            )
-            ENGINE = MergeTree
-            PARTITION BY toYYYYMM(event_time)
-            ORDER BY event_time
-        """
-        self.assertEqual(query.format(query.check_valid_write_query(q)), query.format(q))
-
-    def test_create_table_with_materialized_column_with_joinget_is_ok(self):
-        q = """
-            CREATE TABLE visits2
-            (
-                `event_time` DateTime,
-                `query` String,
-                `three` String MATERIALIZED toInt64(joinGet(other_database.other_table,'val', toUInt32(number)))
-            )
-            ENGINE = MergeTree
-            PARTITION BY toYYYYMM(event_time)
-            ORDER BY event_time
-        """
-        self.assertEqual(query.format(query.check_valid_write_query(q)), query.format(q))
-
-    def test_create_table_with_default_column_with_alias_is_ok(self):
-        q = """
-            CREATE TABLE visits2
-            (
-                `event_time` DateTime,
-                `query` String,
-                `three` String ALIAS toInt64(toString(joinGet(other_database.other_table,'val', toUInt32(number))))
-            )
-            ENGINE = MergeTree
-            PARTITION BY toYYYYMM(event_time)
-            ORDER BY event_time
-        """
-        self.assertEqual(query.format(query.check_valid_write_query(q)), query.format(q))
-
     def test_create_table_with_subqueries_in_alias_definition__is_ok(self):
         q = """
             CREATE TABLE visits4
@@ -253,33 +211,6 @@ class TestCreateTable(unittest.TestCase):
                 PARTITION BY toYYYYMM(event_time)
             """)
 
-    def test_create_table_with_primary_key_with_joinget(self):
-        with self.assertRaisesRegex(ValueError, "CREATE TABLE: Unsupported function joinGet: in PRIMARY KEY declaration"):
-            query.check_valid_write_query("""
-                CREATE TABLE visits6
-                (
-                    `event_time` DateTime,
-                    `query` String,
-                    `three` String
-                )
-                ENGINE = MergeTree
-                PARTITION BY toYYYYMM(event_time)
-                PRIMARY KEY (event_time, toInt64(joinGet(default.other_table, 'val', toInt32(event_time))))
-            """)
-
-        with self.assertRaisesRegex(ValueError, "CREATE TABLE: Unsupported function joinGet: in PRIMARY KEY declaration"):
-            query.check_valid_write_query("""
-                CREATE TABLE visits6
-                (
-                    `event_time` DateTime,
-                    `query` String,
-                    `three` String,
-                    PRIMARY KEY (event_time, toInt64(joinGet(default.other_table, 'val', toInt32(event_time))))
-                )
-                ENGINE = MergeTree
-                PARTITION BY toYYYYMM(event_time)
-            """)
-
     def test_create_table_with_projections_is_supported(self):
         q = '''
             CREATE TABLE default.github_events
@@ -332,19 +263,15 @@ class TestCreateTable(unittest.TestCase):
                 ORDER BY id
             """)
 
-    def test_create_JOIN_table_with_projection_should_fail(self):
-        with self.assertRaisesRegex(ValueError, "Engine Join doesn't support projections"):
+    def test_create_table_with_join_engine_is_forbidden(self):
+        with self.assertRaisesRegex(ValueError, "Creation of tables with ENGINE Join is not supported"):
             query.check_valid_write_query("""
-                CREATE TABLE github_events
+                CREATE TABLE join_table
                 (
                     `id` UInt32,
-                    PROJECTION projection_user_sort
-                        (
-                            SELECT *
-                            ORDER BY id
-                        )
+                    `val` String
                 )
-                ENGINE = Join(ANY, LEFT, id);
+                ENGINE = Join(ANY, LEFT, id)
             """)
 
     def test_create_table_as_query_is_forbidden(self):

{tinybird_toolset-2.2.0 → tinybird_toolset-2.2.2}/tests/test_replace_tables.py

@@ -342,90 +342,6 @@ class TestReplaceTables(unittest.TestCase):
         replaced = chquery.replace_tables(sql, replacements)
         self.assertEqual(replaced, chquery.format(expected_query))
 
-    def test_join_get(self):
-        replacements = {("", "abcd"): ("", "t_id_abcd")}
-        expected_query = "select joinGet('t_id_abcd', 'test', 1)"
-        replaced = chquery.replace_tables(
-            "select joinGet('abcd', 'test', 1)", replacements
-        )
-        self.assertEqual(replaced, chquery.format(expected_query))
-
-        expected_query = "select joinGet('t_id_abcd', 'test', 1)"
-        replaced = chquery.replace_tables(
-            "select joinGet(abcd, 'test', 1)", replacements
-        )
-        self.assertEqual(replaced, chquery.format(expected_query))
-
-        sql = "Select joinGet()"
-        replaced = chquery.replace_tables(sql, replacements)
-        self.assertEqual(chquery.format(sql), chquery.format(replaced))
-
-    def test_join_get_with_subquery(self):
-        replacements = {("", "abcd", ""): ("", "(select * from public.nyc_taxi)", "")}
-        with self.assertRaisesRegex(
-            ValueError, "DB::Exception: Can't replace 'abcd' with a subquery"
-        ):
-            chquery.replace_tables("select joinGet(abcd, 'test', 1)", replacements)
-
-        with self.assertRaisesRegex(
-            ValueError, "DB::Exception: Can't replace 'abcd' with a subquery"
-        ):
-            chquery.replace_tables("select joinGet('abcd', 'test', 1)", replacements)
-
-    def test_join_get_database(self):
-        replacements = {("db_0", "abcd"): ("db_1", "t_id_abcd")}
-        expected_query = "select joinGet('db_1.t_id_abcd', 'test', 1)"
-        replaced = chquery.replace_tables(
-            "select joinGet('db_0.abcd', 'test', 1)", replacements
-        )
-        self.assertEqual(replaced, chquery.format(expected_query))
-
-        expected_query = "select joinGet('db_1.t_id_abcd', 'test', 1)"
-        replaced = chquery.replace_tables(
-            "select joinGet(db_0.abcd, 'test', 1)", replacements
-        )
-        self.assertEqual(replaced, chquery.format(expected_query))
-
-    def test_join_get_or_null_database(self):
-        replacements = {("db_0", "abcd"): ("db_1", "t_id_abcd")}
-        expected_query = "select joinGetOrNull('db_1.t_id_abcd', 'test', 1)"
-        replaced = chquery.replace_tables(
-            "select joinGetOrNull('db_0.abcd', 'test', 1)", replacements
-        )
-        self.assertEqual(replaced, chquery.format(expected_query))
-
-        expected_query = "select joinGetOrNull('db_1.t_id_abcd', 'test', 1)"
-        replaced = chquery.replace_tables(
-            "select joinGetOrNull(db_0.abcd, 'test', 1)", replacements
-        )
-        self.assertEqual(replaced, chquery.format(expected_query))
-
-    def test_join_get_nested(self):
-        replacements = {
-            ("d_012345", "t1"): ("d_012345", "t_id_1"),
-            ("d_012345", "t2"): ("d_012345", "t_id_2"),
-            ("d_012345", "t3"): ("d_012345", "t_id_3"),
-        }
-        expected_query = "SELECT joinGet('d_012345.t_id_1', 'c1', concat(joinGet('d_012345.t_id_2', 'c2', i2), '_', joinGet('d_012345.t_id_3', 'c3', i3), '_', 'label'))"
-        replaced = chquery.replace_tables(
-            "SELECT joinGet('t1', 'c1', concat(joinGet('t2', 'c2', i2), '_', joinGet('t3', 'c3', i3), '_', 'label'))",
-            replacements,
-            default_database="d_012345",
-        )
-        self.assertEqual(replaced, chquery.format(expected_query))
-
-    def test_join_nested_2(self):
-        replacements = {
-            ("d_012345", "blabla"): ("d_012345", "alibaba"),
-            ("d_012345", "pp"): ("d_012345", "t_pp_01"),
-        }
-        query = "select joinGet(blabla, 'a', joinGet(pp, 'b', c))"
-        replaced = chquery.replace_tables(
-            query, replacements, default_database="d_012345"
-        )
-        expected_query = "select joinGet('d_012345.alibaba', 'a', joinGet('d_012345.t_pp_01', 'b', c))"
-        self.assertEqual(replaced, chquery.format(expected_query))
-
     def test_qualified_column_in_where(self):
         sql = """
             SELECT
@@ -1520,54 +1436,3 @@ class TestDisabledFunctions(unittest.TestCase):
         )
         expected_query = "WITH (select * from d_012345.repl2 as table2 limit 1) as table1, (select 1 as v where v in d_012345.repl1) as x select x"
         self.assertEqual(replaced, chquery.format(expected_query))
-
-    def test_join_get_column_aliases(self):
-        replacements = {
-            ("d_012345", "table1"): ("d_012345", "repl1"),
-            ("d_012345", "table2"): ("d_012345", "repl2"),
-        }
-        queries = [
-            (
-                "select joinGet(table2, 'col', 1), 'table1' as table2",
-                "select joinGet(d_012345.repl2, 'col', 1), 'table1' as table2",
-            ),
-            (
-                "select 'table1' as table2, joinGet(table2, 'col', 1)",
-                "select 'table1' as table2, joinGet(d_012345.repl2, 'col', 1)",
-            ),
-            (
-                "select '_local.join1' as table2, joinGet(d_012345.repl2, 'b', toInt32(1))",
-                "select '_local.join1' as table2, joinGet(d_012345.repl2, 'b', toInt32(1))",
-            ),
-            (
-                "select concat(y,'1') as table2, '_local.join' as y, joinGet(d_012345.repl2, 'b', toInt32(1))",
-                "select concat(y,'1') as table2, '_local.join' as y, joinGet(d_012345.repl2, 'b', toInt32(1))",
-            ),
-            (
-                "select '_local.join' as y, concat(y,'1') as table2, joinGet(d_012345.repl2, 'b', toInt32(1))",
-                "select '_local.join' as y, concat(y,'1') as table2, joinGet(d_012345.repl2, 'b', toInt32(1))",
-            ),
-            (
-                "select (select 'otherdb.t2') as table2, joinGet(d_012345.repl2, 'c1', i1)",
-                "select (select 'otherdb.t2') as table2, joinGet(d_012345.repl2, 'c1', i1)",
-            ),
-        ]
-        for query, expected_query in queries:
-            replaced = chquery.replace_tables(
-                query, replacements, default_database="d_012345"
-            )
-            self.assertEqual(replaced, chquery.format(expected_query))
-
-    def test_join_get_column_aliases_no_format(self):
-        replacements = {
-            ("d_012345", "table1"): ("d_012345", "repl1"),
-            ("d_012345", "table2"): ("d_012345", "repl2"),
-        }
-        query = "select joinGet(table2, 'col', 1), 'table1' as table2"
-        expected_query = (
-            "SELECT\n    joinGet('d_012345.repl2', 'col', 1),\n    'table1' AS table2"
-        )
-        replaced = chquery.replace_tables(
-            query, replacements, default_database="d_012345"
-        )
-        self.assertEqual(replaced, expected_query)

{tinybird_toolset-2.2.0 → tinybird_toolset-2.2.2}/tests/test_tables.py

@@ -44,58 +44,6 @@ class TestTables(unittest.TestCase):
             "SELECT `cod_store`,`country_iso`,sum(stores_stock) as stores_stock from stores_stock group by `cod_store`,`country_iso`"),
             [('', 'stores_stock', '')])
 
-    def test_join_get(self):
-        self.assertEqual(chquery.tables("select joinGet()"), [])
-        self.assertEqual(chquery.tables("select joinGet(abcd, 'test', 1)"), [('', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGet('abcd', 'test', 1)"), [('', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGet(`aaaa.aaaa.aaaa.aaaa`, 'test', 1)"), [('aaaa', 'aaaa.aaaa.aaaa', '')])
-        self.assertEqual(chquery.tables("SELECT joinGetOrNull('join_test', 'num', 500)"), [('', 'join_test', '')])
-
-    def test_join_get_default_database(self):
-        self.assertEqual(chquery.tables("select joinGet(abcd, 'test', 1)", default_database='d_012345'), [('d_012345', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGet('abcd', 'test', 1)", default_database='d_012345'), [('d_012345', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGet(`aaaa.aaaa.aaaa.aaaa`, 'test', 1)", default_database='d_012345'), [('aaaa', 'aaaa.aaaa.aaaa', '')])
-
-    def test_join_get_database(self):
-        self.assertEqual(chquery.tables("select joinGet(db_extract.abcd, 'test', 1)"), [('db_extract', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGet('db_extract.abcd', 'test', 1)"), [('db_extract', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGet(db_extract.`aaaa.aaaa.aaaa.aaaa`, 'test', 1)", default_database='d_012345'), [('db_extract', 'aaaa.aaaa.aaaa.aaaa', '')])
-
-    def test_join_get_database_default_database(self):
-        self.assertEqual(chquery.tables("select joinGet(db_extract.abcd, 'test', 1)", default_database='d_012345'), [('db_extract', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGet('db_extract.abcd', 'test', 1)", default_database='d_012345'), [('db_extract', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGet(db_extract.`aaaa.aaaa.aaaa.aaaa`, 'test', 1)", default_database='d_012345'), [('db_extract', 'aaaa.aaaa.aaaa.aaaa', '')])
-
-    def test_join_get_or_null(self):
-        self.assertEqual(chquery.tables("select joinGetOrNull('db_extract.abcd', 'test', 1)", default_database='d_012345'), [('db_extract', 'abcd', '')])
-        self.assertEqual(chquery.tables("select joinGetOrNull(db_extract.`aaaa.aaaa.aaaa.aaaa`, 'test', 1)", default_database='d_012345'), [('db_extract', 'aaaa.aaaa.aaaa.aaaa', '')])
-
-    def test_join_get_coredump_regression(self):
-        tables = chquery.tables('SELECT property_id, toDate(visit_date) AS "visit_day", joinGet(destinations, \'property_id_dst\', property_id)\nFROM wpbv\nGROUP BY property_id, visit_day')
-        self.assertEqual(sorted(tables), sorted([('', 'wpbv', ''), ('', 'destinations', '')]))
-
-    def test_join_get_nested(self):
-        tables = chquery.tables("SELECT joinGet('t1', 'c1', concat(joinGet('t2', 'c2', i2), '_', joinGet('t3', 'c3', i3), '_', 'label'))")
-        self.assertEqual(sorted(tables), sorted([('', 't1', ''), ('', 't2', ''), ('', 't3', '')]))
-        self.assertEqual(sorted(chquery.tables("select joinGet('blabla', 'a', joinGet('pp', 'b', c))")), sorted([('', 'blabla', ''), ('', 'pp', '')]))
-        self.assertEqual(sorted(chquery.tables("select joinGet(blabla, 'a', joinGet(pp, 'b', c))")), sorted([('', 'blabla', ''), ('', 'pp', '')]))
-
-    def test_join_get_nested_nested_raises(self):
-        with self.assertRaisesRegex(ValueError, 'quoted literals'):
-            chquery.tables("SELECT joinGet(joinGet('t2', 'c2', i2), 'c1', i1)")
-
-    def test_join_get_nested_alias(self):
-        tables = chquery.tables("with (select 'otherdb.t2' as t) as t select joinGet(t, 'c1', i1)")
-        self.assertEqual(tables, [('', 't', '')])
-
-        tables = chquery.tables("with (select 'otherdb.t2' as t) as t select t")
-        self.assertEqual(tables, [])
-
-    def test_join_get_cte(self):
-        tables = chquery.tables("WITH 'id_val' as a SELECT joinGet(a, 'val',toUInt32(number)) from numbers(4)",
-                                default_database='db_test')
-        self.assertEqual(tables, [('', '', 'numbers'), ('db_test', 'a', '')])
-
     def test_has_column_in_table(self):
         with self.assertRaisesRegex(ValueError, """DB::Exception: Usage of function hasColumnInTable is restricted"""):
             chquery.tables("Select hasColumnInTable('default', 'join_test', 'id')")
@@ -1090,8 +1038,6 @@ SELECT *
                         {"name":"javaHash","case_insensitive":0,"table_function":False},
                         {"name":"javaHashUTF16LE","case_insensitive":0,"table_function":False},
                         {"name":"jdbc","case_insensitive":0,"table_function":True},
-                        {"name":"joinGet","case_insensitive":0,"table_function":False},
-                        {"name":"joinGetOrNull","case_insensitive":0,"table_function":False},
                         {"name":"jsonMergePatch","case_insensitive":0,"table_function":False},
                         {"name":"jumpConsistentHash","case_insensitive":0,"table_function":False},
                         {"name":"kafkaMurmurHash","case_insensitive":0,"table_function":False},
@@ -2144,17 +2090,6 @@ SELECT *
         tables = chquery.tables("WITH (select * from table2 limit 1) as table1, (select 1 as v where v in table1) as x select x")
         self.assertEqual(tables, [('', 'table1', ''), ('', 'table2', '')])
 
-    def test_join_get_column_aliases(self):
-        queries = ["select joinGet(table2, 'col', 1), 'table1' as table2",
-                   "select 'table1' as table2, joinGet(table2, 'col', 1)",
-                   "select '_local.join1' as table2, joinGet(table2, 'b', toInt32(1))",
-                   "select concat(y,'1') as table2, '_local.join' as y, joinGet(table2, 'b', toInt32(1))",
-                   "select '_local.join' as y, concat(y,'1') as table2, joinGet(table2, 'b', toInt32(1))",
-                   "select (select 'otherdb.t2') as table2, joinGet(table2, 'c1', i1)"]
-        for query in queries:
-            tables = chquery.tables(query)
-            self.assertEqual(tables, [('', 'table2', '')])
-
     def test_recursive_cte(self):
         tables = chquery.tables("with recursive test_table as (select 1 as number union all select number + 1 from test_table where number < 100) select sum(number) from test_table")
         self.assertEqual(tables, [])