tinybird 4.6.3.dev0__tar.gz → 4.6.5__tar.gz

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 4.6.3.dev0
+Version: 4.6.5
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird
@@ -52,6 +52,16 @@ The Tinybird command-line tool allows you to use all the Tinybird functionality
 Changelog
 ----------
 
+4.6.5
+*******
+
+- `Changed` `tb pull` now automatically creates cloud secrets and shows full Kafka connections.
+
+4.6.4
+*******
+
+- `Added` ``tb datasource delete`` now accepts ``--lightweight-delete``, ``--partition`` and ``--projection-mode``, backed by the new ``POST /v1/datasources/{name}/delete`` endpoint that uses ClickHouse's lightweight ``DELETE FROM`` instead of the heavy ``ALTER TABLE ... DELETE`` mutation. Lightweight delete is synchronous by default and returns the affected row count plus a partition-level mutation block; pass ``--no-wait`` to enqueue a ``LightweightDeleteJob`` and receive the v0-compatible job envelope.
+
 4.6.2
 *******
 

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/ch_utils/engine.py

@@ -354,31 +354,6 @@ def sorting_key_is_valid(columns: List[Dict[str, Any]], value: Optional[str]) ->
     return value
 
 
-def case_insensitive_check(valid_values: List[str]) -> Callable[[List[Dict[str, Any]], str], Optional[str]]:
-    """
-    >>> valid_values = ['ANY', 'ALL']
-    >>> checker = case_insensitive_check(valid_values)
-    >>> checker([],'ALL')
-
-    >>> valid_values = ['ANY', 'ALL']
-    >>> checker = case_insensitive_check(valid_values)
-    >>> checker([],'any')
-
-    >>> valid_values = ['ANY', 'ALL']
-    >>> checker = case_insensitive_check(valid_values)
-    >>> checker([],'foo')
-    Traceback (most recent call last):
-    ...
-    ValueError: valid values are ANY, ALL
-    """
-
-    def checker(columns: List[Dict[str, Any]], value: str):
-        if value.upper() not in valid_values:
-            raise ValueError(f"valid values are {', '.join(valid_values)}")
-
-    return checker
-
-
 # [PARTITION BY expr]
 # [ORDER BY expr]
 # [PRIMARY KEY expr]

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/client.py

@@ -470,10 +470,26 @@ class TinyB:
     async def datasource_truncate(self, datasource_name: str):
         return await self._req(f"/v0/datasources/{datasource_name}/truncate", method="POST", data="")
 
-    async def datasource_delete_rows(self, datasource_name: str, delete_condition: str, dry_run: bool = False):
-        params = {"delete_condition": delete_condition}
+    async def datasource_delete_rows(
+        self,
+        datasource_name: str,
+        delete_condition: str,
+        dry_run: bool = False,
+        lightweight: bool = False,
+        wait: bool = True,
+        partition: Optional[str] = None,
+        projection_mode: Optional[str] = None,
+    ):
+        params: Dict[str, Any] = {"delete_condition": delete_condition}
+        if lightweight:
+            params["wait"] = "true" if wait else "false"
+            if partition:
+                params["partition"] = partition
+            if projection_mode:
+                params["projection_mode"] = projection_mode
+            return await self._req(f"/v1/datasources/{datasource_name}/delete", method="POST", data=params)
         if dry_run:
-            params.update({"dry_run": "true"})
+            params["dry_run"] = "true"
         return await self._req(f"/v0/datasources/{datasource_name}/delete", method="POST", data=params)
 
     async def datasource_dependencies(

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/config.py

@@ -112,12 +112,6 @@ async def get_config(
     return config
 
 
-async def write_config(config: Dict[str, Any], dest_file: str = ".tinyb"):
-    config_file = Path(getcwd()) / dest_file
-    async with aiofiles.open(config_file, "w") as file:
-        await file.write(json.dumps(config, indent=4, sort_keys=True))
-
-
 def get_display_host(ui_host: str):
     return LEGACY_HOSTS.get(ui_host, ui_host)
 

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/datafile/common.py

@@ -96,10 +96,6 @@ class IndexesSyntaxError(DatafileSyntaxError):
         super().__init__(message=message, lineno=lineno, pos=pos, hint=hint)
 
 
-class MalformedColumnError(Exception):
-    pass
-
-
 class PipeTypes:
     MATERIALIZED = "materialized"
     ENDPOINT = "endpoint"
@@ -2369,17 +2365,6 @@ def get_project_filenames(folder: str, with_vendor=False) -> List[str]:
     return filenames
 
 
-def get_project_fixtures(folder: str) -> List[str]:
-    folders: List[str] = [
-        f"{folder}/fixtures/*.ndjson",
-        f"{folder}/fixtures/*.csv",
-    ]
-    filenames: List[str] = []
-    for x in folders:
-        filenames += glob.glob(x)
-    return filenames
-
-
 def has_internal_datafiles(folder: str) -> bool:
     folder = folder or "."
     filenames = get_project_filenames(folder)

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/datatypes.py

@@ -108,10 +108,6 @@ def is_type_date(type_to_check: str) -> bool:
     return date_type_pattern.match(type_to_check) is not None
 
 
-def string_test(x: str) -> bool:
-    return True
-
-
 def date_test(x: str) -> bool:
     return date_pattern.match(x) is not None
 

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/feedback_manager.py

@@ -879,6 +879,11 @@ class FeedbackManager:
     success_delete_rows_datasource = success_message(
         "** Data Source '{datasource}' rows deleted matching condition \"{delete_condition}\""
     )
+    success_lightweight_delete_rows_datasource = success_message(
+        "** Data Source '{datasource}' rows deleted matching condition \"{delete_condition}\""
+        "\n   Rows affected: {rows_affected}"
+        "\n   Partitions scanned: {partitions_scanned} (done: {partitions_done}, in progress: {partitions_in_progress})"
+    )
     success_dry_run_delete_rows_datasource = success_message(
         "** [DRY RUN] Data Source '{datasource}' rows '{rows}' matching condition \"{delete_condition}\" to be deleted"
     )

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/prompts.py

@@ -1,5 +1,4 @@
 from datetime import date
-from typing import Optional
 
 general_functions = [
     "BLAKE3",
@@ -400,64 +399,6 @@ Follow the instructions and generate the following response with no additional t
 """
 
 
-def create_prompt(existing_resources: str, feedback: str = "", history: str = "") -> str:
-    feedback_history = ""
-    if feedback and history:
-        feedback_history = f"""In case the <feedback> and <history> tags are present and not empty,
-it means there was a previous attempt to generate the resources and the user provided feedback and history about previous responses.
-Use the following feedback and history to regenerate the response:
-Feedback to improve the response:
-{feedback}
-History of previous results:
-{history}"""
-
-    return """
-You are a Tinybird expert. You will be given a prompt to generate new or update existing Tinybird resources: datasources and/or pipes.
-<existing_resources>{existing_resources}</existing_resources>
-{datasource_instructions}
-{pipe_instructions}
-{sql_instructions}
-{datasource_example}
-{pipe_example}
-{copy_pipe_instructions}
-{materialized_pipe_instructions}
-{sink_pipe_instructions}
-{connection_instructions}
-{kafka_connection_example}
-{gcs_connection_example}
-{gcs_hmac_connection_example}
-{s3_connection_example}
-
-{feedback_history}
-
-Use the following format to generate the response and do not wrap it in any other text, including the <response> tag.
-<response>
-    <resource>
-        <type>[datasource or pipe or connection]</type>
-        <name>[resource name here]</name>
-        <content>[resource content here]</content>
-    </resource>
-</response>
-
-""".format(
-        existing_resources=existing_resources,
-        datasource_instructions=datasource_instructions,
-        pipe_instructions=pipe_instructions,
-        sql_instructions=sql_instructions,
-        datasource_example=datasource_example,
-        pipe_example=pipe_example,
-        copy_pipe_instructions=copy_pipe_instructions,
-        materialized_pipe_instructions=materialized_pipe_instructions,
-        sink_pipe_instructions=sink_pipe_instructions,
-        connection_instructions=connection_instructions,
-        kafka_connection_example=kafka_connection_example,
-        gcs_connection_example=gcs_connection_example,
-        gcs_hmac_connection_example=gcs_hmac_connection_example,
-        s3_connection_example=s3_connection_example,
-        feedback_history=feedback_history,
-    )
-
-
 def mock_prompt(rows: int, feedback: str = "") -> str:
     today = date.today().isoformat()
 
@@ -824,7 +765,7 @@ Follow these instructions when creating or updating any type of .pipe file:
 </pipe_file_instructions>
 """
 
-sql_instructions = """
+sql_instructions = f"""
 <sql_instructions>
     - The SQL query must be a valid ClickHouse SQL query that mixes ClickHouse syntax and Tinybird templating syntax (Tornado templating language under the hood).
     - SQL queries with parameters must start with "%" character and a newline on top of every query to be able to use the parameters. Examples:
@@ -882,186 +823,7 @@ sql_instructions = """
     - Use the following syntax in the SQL section for the iceberg table function: iceberg('s3://bucket/path/to/table', {{{{tb_secret('aws_access_key_id')}}}}, {{{{tb_secret('aws_secret_access_key')}}}})
     - Use the following syntax in the SQL section for the postgres table function: postgresql('host:port', 'database', 'table', {{{{tb_secret('db_username')}}}}, {{{{tb_secret('db_password')}}}}), 'schema')
 </sql_instructions>
-""".format(
-    general_functions=general_functions,
-    general_functions_insensitive=general_functions_insensitive,
-    aggregate_functions=aggregate_functions,
-)
-
-
-def rules_prompt(source: Optional[str] = None) -> str:
-    base_command = source or "tb"
-    return """
-You are an expert in SQL and Tinybird. Follow these instructions when working with .datasource and .pipe files:
-
-<command_calling>
-You have commands at your disposal to develop a tinybird project:
-- {base_command} build: to build the project locally and check it works.
-- {base_command} deployment create --wait --auto: to create a deployment and promote it automatically
-- {base_command} test run: to run existing tests
-- {base_command} endpoint url <pipe_name>: to get the url of an endpoint, token included.
-- {base_command} endpoint data <pipe_name>: to get the data of an endpoint. You can pass parameters to the endpoint like this: {base_command} endpoint data <pipe_name> --param1 value1 --param2 value2
-- {base_command}  token ls: to list all the tokens
-There are other commands that you can use, but these are the most common ones. Run `{base_command} -h` to see all the commands if needed.
-When you need to work with resources or data in cloud, add always the --cloud flag before the command. Example: {base_command} --cloud datasource ls
-</command_calling>
-<development_instructions>
-- When asking to create a tinybird data project, if the needed folders are not already created, use the following structure:
-├── connections
-├── copies
-├── sinks
-├── datasources
-├── endpoints
-├── fixtures
-├── materializations
-├── pipes
-└── tests
-- The local development server will be available at http://localhost:7181. Even if some response uses another base url, use always http://localhost:7181.
-- After every change in your .datasource, .pipe or .ndjson files, run `{base_command} build` to build the project locally.
-- When you need to ingest data locally in a datasource, create a .ndjson file with the same name of the datasource and the data you want and run `{base_command} build` so the data is ingested.
-- The format of the generated api endpoint urls is: http://localhost:7181/v0/pipe/<pipe_name>.json?token=<token>
-- Before running the tests, remember to have the project built with `{base_command} build` with the latest changes.
-</development_instructions>
-When asking for ingesting data, adding data or appending data do the following depending on the environment you want to work with:
-<ingest_data_instructions>
-- When building locally, create a .ndjson file with the data you want to ingest and do `{base_command} build` to ingest the data in the build env.
-- We call `cloud` the production environment.
-- When appending data in cloud, use `{base_command} --cloud datasource append <datasource_name> <file_name>`
-- When you have a response that says “there are rows in quarantine”, do `{base_command} [--cloud] datasource data <datasource_name>_quarantine` to understand what is the problem.
-</ingest_data_instructions>
-<datasource_file_instructions>
-Follow these instructions when creating or updating .datasource files:
-{datasource_instructions}
-</datasource_file_instructions>
-
-<pipe_file_instructions>
-Follow these instructions when creating or updating .pipe files:
-{pipe_instructions}
-{sql_instructions}
-{datasource_example}
-{pipe_example}
-{copy_pipe_instructions}
-{materialized_pipe_instructions}
-{sink_pipe_instructions}
-{connection_instructions}
-{kafka_connection_example}
-{gcs_connection_example}
-{gcs_hmac_connection_example}
-{s3_connection_example}
-</pipe_file_instructions>
-<test_file_instructions>
-Follow these instructions when creating or updating .yaml files for tests:
-{test_instructions}
-</test_file_instructions>
-<deployment_instruction>
-Follow these instructions when evolving a datasource schema:
-{deployment_instructions}
-</deployment_instruction>
-""".format(
-        base_command=base_command,
-        datasource_instructions=datasource_instructions,
-        pipe_instructions=pipe_instructions,
-        sql_instructions=sql_instructions,
-        datasource_example=datasource_example,
-        pipe_example=pipe_example,
-        copy_pipe_instructions=copy_pipe_instructions,
-        materialized_pipe_instructions=materialized_pipe_instructions,
-        sink_pipe_instructions=sink_pipe_instructions,
-        test_instructions=test_instructions,
-        deployment_instructions=deployment_instructions,
-        connection_instructions=connection_instructions,
-        kafka_connection_example=kafka_connection_example,
-        gcs_connection_example=gcs_connection_example,
-        gcs_hmac_connection_example=gcs_hmac_connection_example,
-        s3_connection_example=s3_connection_example,
-    )
-
-
-def claude_rules_prompt(source: Optional[str] = None) -> str:
-    base_command = source or "tb"
-    return """
-# Tinybird CLI rules
-
-## Commands
-You have commands at your disposal to develop a tinybird project:
-- {base_command} build: to build the project locally and check it works.
-- {base_command} deployment create --wait --auto: to create a deployment and promote it automatically
-- {base_command} test run: to run existing tests
-- {base_command} endpoint url <pipe_name>: to get the url of an endpoint, token included.
-- {base_command} endpoint data <pipe_name>: to get the data of an endpoint. You can pass parameters to the endpoint like this: {base_command} endpoint data <pipe_name> --param1 value1 --param2 value2
-- {base_command}  token ls: to list all the tokens
-There are other commands that you can use, but these are the most common ones. Run `{base_command} -h` to see all the commands if needed.
-When you need to work with resources or data in cloud, add always the --cloud flag before the command. Example: {base_command} --cloud datasource ls
-
-## Development instructions
-- When asking to create a tinybird data project, if the needed folders are not already created, use the following structure:
-├── connections
-├── copies
-├── sinks
-├── datasources
-├── endpoints
-├── fixtures
-├── materializations
-├── pipes
-└── tests
-- The local development server will be available at http://localhost:7181. Even if some response uses another base url, use always http://localhost:7181.
-- After every change in your .datasource, .pipe or .ndjson files, run `{base_command} build` to build the project locally.
-- When you need to ingest data locally in a datasource, create a .ndjson file with the same name of the datasource and the data you want and run `{base_command} build` so the data is ingested.
-- The format of the generated api endpoint urls is: http://localhost:7181/v0/pipe/<pipe_name>.json?token=<token>
-- Before running the tests, remember to have the project built with `{base_command} build` with the latest changes.
-</development_instructions>
-When asking for ingesting data, adding data or appending data do the following depending on the environment you want to work with:
-
-## Ingestion instructions
-- When building locally, create a .ndjson file with the data you want to ingest and do `{base_command} build` to ingest the data in the build env.
-- We call `cloud` the production environment.
-- When appending data in cloud, use `{base_command} --cloud datasource append <datasource_name> <file_name>`
-- When you have a response that says “there are rows in quarantine”, do `{base_command} [--cloud] datasource data <datasource_name>_quarantine` to understand what is the problem.
-
-## .datasource file instructions
-Follow these instructions when creating or updating .datasource files:
-{datasource_instructions}
-
-## .pipe file instructions
-Follow these instructions when creating or updating .pipe files:
-{pipe_instructions}
-{sql_instructions}
-{datasource_example}
-{pipe_example}
-{copy_pipe_instructions}
-{materialized_pipe_instructions}
-{sink_pipe_instructions}
-{connection_instructions}
-{kafka_connection_example}
-{gcs_connection_example}
-{gcs_hmac_connection_example}
-{s3_connection_example}
-
-## .test file instructions
-Follow these instructions when creating or updating .yaml files for tests:
-{test_instructions}
-
-## Deployment instructions
-Follow these instructions when evolving a datasource schema:
-{deployment_instructions}
-""".format(
-        base_command=base_command,
-        datasource_instructions=datasource_instructions,
-        pipe_instructions=pipe_instructions,
-        sql_instructions=sql_instructions,
-        datasource_example=datasource_example,
-        pipe_example=pipe_example,
-        copy_pipe_instructions=copy_pipe_instructions,
-        materialized_pipe_instructions=materialized_pipe_instructions,
-        sink_pipe_instructions=sink_pipe_instructions,
-        test_instructions=test_instructions,
-        deployment_instructions=deployment_instructions,
-        connection_instructions=connection_instructions,
-        kafka_connection_example=kafka_connection_example,
-        gcs_connection_example=gcs_connection_example,
-        gcs_hmac_connection_example=gcs_hmac_connection_example,
-        s3_connection_example=s3_connection_example,
-    )
+"""
 
 
 test_instructions = """
@@ -1132,38 +894,6 @@ FORWARD_QUERY >
 """
 
 
-def readme_prompt(readme: str, host: str, token: str, resources_xml: str) -> str:
-    return f"""
-You are an expert in SQL and Tinybird. Follow these instructions to generate a new README.md file for a tinybird project:
-Current README.md file:
-<current_resources_xml>
-{resources_xml}
-</current_resources_xml>
-<readme>{readme}</readme>
-<readme_instructions>
-- If it is not present in the current readme, generate a new ## Tinybird section with the following content:
-    - ### Overview section:
-        - Explaining the purpose of the project.
-    - ### Data sources section:
-        - Explaining the purpose of each datasource.
-        - Add a snippet of how to ingest data into each datasource like the following (where the payload example matches the datasource schema respecting non-nullable types):
-        curl -X POST "{host}/v0/events?name=events" \
-    -H "Authorization: Bearer {token}" \
-    -d '{{"date":"2025-01-31","id":"123","user_id":"abc"}}'
-    - ### Endpoints section:
-        - Explaining the purpose of each endpoint.
-        - Add a snippet of how to use each endpoint like the following:
-        curl -X GET "{host}/v0/pipes/pipe_name.json?token={token}"
-        - DateTime parameters must be formatted as YYYY-MM-DD HH:MM:SS, or else will fail.
-- Do not include any other extra info related to Tinybird just maintain the existing one in the <readme> tag.
-- Make sure the API host is correct, {host}.
-- It is mandatory to return a <resource> tag with type "readme" in the response.
-- The response must follow the following format:
-<readme>[readme content here]</readme>
-</readme_instructions>
-"""
-
-
 def quarantine_prompt(datasource_definition: str) -> str:
     return f"""
 - You are an expert in Tinybird.

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/service_datasources.py

@@ -6,7 +6,7 @@ for both Tinybird and Organization scopes.
 """
 
 from functools import lru_cache
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
 
 def get_tinybird_service_datasources() -> List[Dict[str, Any]]:
@@ -1126,20 +1126,3 @@ def get_service_datasources() -> List[Dict[str, Any]]:
         List[Dict[str, Any]]: A combined list of all service datasource definitions.
     """
     return get_tinybird_service_datasources() + get_organization_service_datasources()
-
-
-def get_service_datasource_by_name(name: str) -> Optional[Dict[str, Any]]:
-    """
-    Get a specific service datasource by name. Name should include the type (e.g. tinybird.datasources_ops_log)
-
-    Args:
-        name: The name of the service datasource to retrieve.
-
-    Returns:
-        Optional[Dict[str, Any]]: The service datasource definition or None if not found.
-    """
-    service_datasources = get_service_datasources()
-    for ds in service_datasources:
-        if ds["name"] == name:
-            return ds
-    return None

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/sql.py

@@ -911,30 +911,6 @@ def engine_replicated_to_local(engine: str) -> str:
     return _RE_REPLICATED_MT.sub(_replace, engine.strip())
 
 
-def engine_patch_replicated_engine(engine: str, engine_full: Optional[str], new_table_name: str) -> Optional[str]:
-    """
-    >>> engine_patch_replicated_engine("ReplicatedMergeTree", "ReplicatedMergeTree('/clickhouse/tables/1-1/table_name', 'replica') PARTITION BY toYYYYMM(EventDate) ORDER BY (CounterID, EventDate, intHash32(UserID)) SAMPLE BY intHash32(UserID) SETTINGS index_granularity = 8192", 'table_name_staging')
-    "ReplicatedMergeTree('/clickhouse/tables/1-1/table_name_staging', 'replica') PARTITION BY toYYYYMM(EventDate) ORDER BY (CounterID, EventDate, intHash32(UserID)) SAMPLE BY intHash32(UserID) SETTINGS index_granularity = 8192"
-    >>> engine_patch_replicated_engine("ReplicatedMergeTree", "ReplicatedMergeTree('/clickhouse/tables/{layer}-{shard}/sales_product_rank_rt_replicated_2', '{replica}') PARTITION BY toYYYYMM(date) ORDER BY (purchase_location, sku_rank_lc, date)", 'sales_product_rank_rt_replicated_2_staging')
-    "ReplicatedMergeTree('/clickhouse/tables/{layer}-{shard}/sales_product_rank_rt_replicated_2_staging', '{replica}') PARTITION BY toYYYYMM(date) ORDER BY (purchase_location, sku_rank_lc, date)"
-    >>> engine_patch_replicated_engine("ReplicatedMergeTree", None, 't_000') is None
-    True
-    >>> engine_patch_replicated_engine("Log", "Log()", 't_000')
-    'Log()'
-    >>> engine_patch_replicated_engine("MergeTree", "MergeTree PARTITION BY toYYYYMM(event_date) ORDER BY (event_date, event_time) SETTINGS index_granularity = 1024", 't_000')
-    'MergeTree PARTITION BY toYYYYMM(event_date) ORDER BY (event_date, event_time) SETTINGS index_granularity = 1024'
-    """
-    if not engine_full:
-        return None
-    if engine.lower().startswith("Replicated".lower()):
-        parts = _RE_REPLICATED_ENGINE_SPLIT.split(engine_full)
-        paths = parts[2].split("/")
-        paths[-1] = new_table_name
-        zoo_path = "/".join(paths)
-        return "".join([*parts[:2], zoo_path, *parts[3:]])
-    return engine_full
-
-
 if __name__ == "__main__":
     print(  # noqa: T201
         _parse_table_structure(

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/sql_template.py

@@ -1542,35 +1542,6 @@ def generate(self, **kwargs) -> Tuple[str, TemplateExecutionResults]:
         raise e
 
 
-class CodeWriter:
-    def __init__(self, file, template):
-        self.file = file
-        self.current_template = template
-        self.apply_counter = 0
-        self._indent = 0
-
-    def indent_size(self):
-        return self._indent
-
-    def indent(self):
-        class Indenter:
-            def __enter__(_):
-                self._indent += 1
-                return self
-
-            def __exit__(_, *args):
-                assert self._indent > 0
-                self._indent -= 1
-
-        return Indenter()
-
-    def write_line(self, line, line_number, indent=None):
-        if indent is None:
-            indent = self._indent
-        line_comment = "  # %s:%d" % ("<generated>", line_number)
-        print("    " * indent + line + line_comment, file=self.file)
-
-
 def get_var_names(t: Template):
     """
     Extract variable names from a template.

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/sql_toolset.py

@@ -158,7 +158,7 @@ def has_unoptimized_join(sql: str, left_table: Optional[Union[Tuple[str, str], T
             raise UnoptimizedJoinException(sql)
 
 
-def format_where_for_mutation_command(where_clause: str) -> str:
+def format_where_for_mutation_command(where_clause: str, lightweight: bool = False) -> str:
     """
     >>> format_where_for_mutation_command("numnights = 99")
     'DELETE WHERE numnights = 99'
@@ -170,11 +170,14 @@ def format_where_for_mutation_command(where_clause: str) -> str:
     "DELETE WHERE reservationid = \\\\'\\\\\\\\\\\\'foo\\\\'"
     >>> format_where_for_mutation_command("reservationid = '\\\\'foo'")
     "DELETE WHERE reservationid = \\\\'\\\\\\\\\\\\'foo\\\\'"
+    >>> format_where_for_mutation_command("number < 3", lightweight=True)
+    'UPDATE _row_exists = 0 WHERE number < 3'
     """
     formatted_condition = chquery.format(f"""SELECT {where_clause}""").split("SELECT ")[1]
     formatted_condition = formatted_condition.replace("\\", "\\\\").replace("'", "''")
     quoted_condition = chquery.format(f"SELECT '{formatted_condition}'").split("SELECT ")[1]
-    return f"DELETE WHERE {quoted_condition[1:-1]}"
+    prefix = "UPDATE _row_exists = 0 WHERE" if lightweight else "DELETE WHERE"
+    return f"{prefix} {quoted_condition[1:-1]}"
 
 
 # Functions that take table/dictionary names as string literal arguments.

{tinybird-4.6.3.dev0 → tinybird-4.6.5}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/forward/commands'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '4.6.3.dev0'
-__revision__ = '78e5916'
+__version__ = '4.6.5'
+__revision__ = '939e465'