tinybird-cli 6.5.3.dev0__py3-none-any.whl → 6.5.5.dev0__py3-none-any.whl

tinybird/sql_template.py

@@ -1396,7 +1396,7 @@ _namespace = {
 }
 
 
-reserved_vars = set(["_tt_tmp", "_tt_append", "isinstance", "str", "error", "custom_error", *list(vars(builtins))])
+reserved_vars = {"_tt_tmp", "_tt_append", "isinstance", "str", "error", "custom_error", *list(vars(builtins))}
 for p in DEFAULT_PARAM_NAMES:  # we handle these in an specific manner
     reserved_vars.discard(p)  # `format` is part of builtins
 # Allow 'id' to be used as a template parameter - https://gitlab.com/tinybird/analytics/-/issues/19119
@@ -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.
@@ -1982,11 +1953,12 @@ def get_var_data(content, node_id=None):
     """
 
     def node_to_value(x):
-        if type(x) in (ast.Bytes, ast.Str):
-            return x.s
-        elif type(x) == ast.Num:  # noqa: E721
-            return x.n
-        elif type(x) == ast.NameConstant:  # noqa: E721
+        # ast.Constant supersedes the deprecated ast.Bytes/ast.Str/ast.Num/
+        # ast.NameConstant node classes. Those were aliases of ast.Constant
+        # since Python 3.8 (emitting DeprecationWarning on access in 3.12) and
+        # were removed in Python 3.14. The parser only ever produces
+        # ast.Constant nodes, so .value holds str/bytes/int/float/bool/None.
+        if type(x) == ast.Constant:  # noqa: E721
             return x.value
         elif type(x) == ast.Name:  # noqa: E721
             return x.id
@@ -2000,8 +1972,6 @@ def get_var_data(content, node_id=None):
             if not r:
                 r = node_to_value(x.right)
             return r
-        elif type(x) == ast.Constant:  # noqa: E721
-            return x.value
         elif type(x) == ast.UnaryOp and type(x.operand) == ast.Constant:  # noqa: E721
             if type(x.op) == ast.USub:  # noqa: E721
                 return x.operand.value * -1
@@ -2020,11 +1990,9 @@ def get_var_data(content, node_id=None):
             return []
 
         first_elem = x.elts[0]
-        if type(first_elem) in (ast.Bytes, ast.Str):
-            return [elem.s for elem in x.elts]
-        elif type(first_elem) == ast.Num:  # noqa: E721
-            return [elem.n for elem in x.elts]
-        elif type(first_elem) == ast.NameConstant or type(first_elem) == ast.Constant:  # noqa: E721
+        # See node_to_value: ast.Constant supersedes the deprecated
+        # ast.Bytes/ast.Str/ast.Num/ast.NameConstant (removed in 3.14).
+        if type(first_elem) == ast.Constant:  # noqa: E721
             return [elem.value for elem in x.elts]
         elif type(first_elem) == ast.Name:  # noqa: E721
             return [elem.id for elem in x.elts]
@@ -2295,7 +2263,12 @@ def get_var_names_and_types(t: Template, node_id: Optional[str] = None) -> List[
             vars_out.extend(
                 parse_statement_code_if_new_vars(statement_code, skip_names=typed_names | statement_expr_names)
             )
-            return vars_out
+            # Inside a {% %} statement a type function with a literal first arg
+            # (e.g. {% set x = Float32(1.5) %}) is a plain value cast: the
+            # assigned variable is the parameter, the literal is not. Drop
+            # these artifacts so they don't surface as bogus params nor get
+            # rejected by validate_template_parameter_names.
+            return [vd for vd in vars_out if isinstance(vd["name"], str) and vd["name"]]
 
         def _n(chunks: list, vars_out: list[dict[str, Any]]) -> None:
             for x in chunks:
@@ -2342,6 +2315,43 @@ def get_var_names_and_types_cached(t: Template):
     return get_var_names_and_types(t)
 
 
+def validate_template_parameter_names(sql: str, node_id: Optional[str] = None) -> None:
+    """Reject template parameters that don't have a usable name.
+
+    Type functions such as ``{{Float32(x)}}`` double as casts, so a literal
+    first argument (e.g. ``{{Float32(1682892000.0)}}`` or ``{{String('')}}``)
+    is parsed as a parameter whose name is a number or an empty string instead
+    of an identifier. Such a "parameter" can never be supplied by a caller and
+    breaks parameter metadata consumers, so it must be rejected at write time.
+
+    Raises ``ValueError`` with the same wording used elsewhere for invalid names.
+
+    Templates that fail to parse are left untouched: there are no parameters to
+    validate, and reporting/deferring those errors is the job of the existing
+    render/validation flow (some paths, e.g. ``ignore_sql_errors``, tolerate
+    unparseable SQL on purpose). This keeps the check strictly additive. The
+    only exception is the invalid-name ``ValueError`` that extraction itself
+    raises (e.g. for a list literal used as first argument), which is exactly
+    what this validator exists to report.
+    """
+    try:
+        params = get_var_names_and_types(Template(sql), node_id=node_id)
+    except SQLTemplateException:
+        # Template-level problem (e.g. a SecurityException converted by
+        # get_var_names_and_types), not an invalid parameter name.
+        return
+    except ValueError:
+        # Extraction itself rejects some invalid names (e.g. a list literal
+        # as first argument) with the same ValueError this function raises.
+        raise
+    except Exception:
+        return
+    for param in params:
+        name = param.get("name")
+        if not isinstance(name, str) or not name:
+            raise ValueError(f'"{name}" can not be used as a variable name')
+
+
 def wrap_vars(t, escape_arrays: bool = False):
     def _n(chunks, v):
         for x in chunks:
@@ -2943,13 +2953,21 @@ def extract_variables_from_sql(sql: str, params: List[Dict[str, Any]]) -> Dict[s
     return defaults
 
 
-def render_template_with_secrets(name: str, content: str, secrets: Optional[Dict[str, str]] = None) -> str:
+def render_template_with_secrets(
+    name: str,
+    content: str,
+    secrets: Optional[Dict[str, str]] = None,
+    empty_secret_raises: bool = False,
+) -> str:
     """Renders a template with secrets, allowing for default values.
 
     Args:
         name: The name of the template
         content: The template content
         secrets: A dictionary mapping secret names to their values
+        empty_secret_raises: When True, empty secret values or empty defaults raise
+            instead of returning '""'. Used for sink metadata (Forward deploy) where
+            an empty bucket path must not be baked as s3://"".
 
     Returns:
         The rendered template
@@ -2991,6 +3009,26 @@ def render_template_with_secrets(name: str, content: str, secrets: Optional[Dict
         Traceback (most recent call last):
         ...
         tinybird.sql_template.SQLTemplateException: Template Syntax Error: Cannot access secret 'MISSING_SECRET'. Check the secret exists in the Workspace and the token has the required scope.
+
+        >>> render_template_with_secrets(
+        ...     "sink_bucket",
+        ...     "s3://{{ tb_secret('MISSING_SECRET', '') }}",
+        ...     secrets = {},
+        ...     empty_secret_raises=True,
+        ... )
+        Traceback (most recent call last):
+        ...
+        tinybird.sql_template.SQLTemplateException: Template Syntax Error: Secret 'MISSING_SECRET' resolves to an empty value and cannot be used in sink metadata.
+
+        >>> render_template_with_secrets(
+        ...     "sink_bucket",
+        ...     "s3://{{ tb_secret('EMPTY_SECRET', 'fallback') }}",
+        ...     secrets = {'EMPTY_SECRET': ''},
+        ...     empty_secret_raises=True,
+        ... )
+        Traceback (most recent call last):
+        ...
+        tinybird.sql_template.SQLTemplateException: Template Syntax Error: Secret 'EMPTY_SECRET' resolves to an empty value and cannot be used in sink metadata.
     """
     if not secrets:
         secrets = {}
@@ -3006,15 +3044,24 @@ def render_template_with_secrets(name: str, content: str, secrets: Optional[Dict
             The secret value or default
 
         Raises:
-            SQLTemplateException: If the secret is not found and no default is provided
+            SQLTemplateException: If the secret is not found and no default is provided,
+                or if empty_secret_raises is True and the resolved value is empty
         """
         if secret_name in secrets:
             value = secrets[secret_name]
             if isinstance(value, str) and len(value) == 0:
+                if empty_secret_raises:
+                    raise SQLTemplateException(
+                        f"Secret '{secret_name}' resolves to an empty value and cannot be used in sink metadata."
+                    )
                 return '""'
             return value
         elif default is not None:
             if isinstance(default, str) and len(default) == 0:
+                if empty_secret_raises:
+                    raise SQLTemplateException(
+                        f"Secret '{secret_name}' resolves to an empty value and cannot be used in sink metadata."
+                    )
                 return '""'
             return default
         else:

tinybird/sql_toolset.py

@@ -158,7 +158,20 @@ 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_fragment_for_mutation_command(fragment: str) -> str:
+    """Normalize a SQL fragment the way CH stores it in the
+    `system.mutations.command` column: format the expression with CH's own
+    formatter, then escape it as it appears inside the serialized command
+    (string literals keep backslash-escaped quotes)."""
+    formatted = chquery.format(f"""SELECT {fragment}""").split("SELECT ")[1]
+    formatted = formatted.replace("\\", "\\\\").replace("'", "''")
+    quoted = chquery.format(f"SELECT '{formatted}'").split("SELECT ")[1]
+    return quoted[1:-1]
+
+
+def format_where_for_mutation_command(
+    where_clause: str, lightweight: bool = False, partition: Optional[str] = None
+) -> str:
     """
     >>> format_where_for_mutation_command("numnights = 99")
     'DELETE WHERE numnights = 99'
@@ -170,11 +183,20 @@ 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'
+    >>> format_where_for_mutation_command("number < 3", lightweight=True, partition="201901")
+    'UPDATE _row_exists = 0 IN PARTITION 201901 WHERE number < 3'
+    >>> format_where_for_mutation_command("number < 3", lightweight=True, partition="'2019-01-01'")
+    "UPDATE _row_exists = 0 IN PARTITION \\\\'2019-01-01\\\\' 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]}"
+    quoted_condition = _format_fragment_for_mutation_command(where_clause)
+    prefix = "UPDATE _row_exists = 0" if lightweight else "DELETE"
+    # Partition-scoped mutations store the partition expression in the
+    # command (`… IN PARTITION <expr> WHERE <cond>`), normalized by the same
+    # CH formatter, so it must be part of the match.
+    partition_clause = f" IN PARTITION {_format_fragment_for_mutation_command(partition)}" if partition else ""
+    return f"{prefix}{partition_clause} WHERE {quoted_condition}"
 
 
 # Functions that take table/dictionary names as string literal arguments.
@@ -621,7 +643,7 @@ def replace_tables(
 
         if current_replacements:
             # We need to transform the dictionary into something cacheable, so a sorted tuple of tuples it is
-            r = tuple(sorted([(k, v) for k, v in current_replacements.items()]))
+            r = tuple(sorted(current_replacements.items()))
             sql = replace_tables_chquery_cached(
                 sql,
                 r,

tinybird/tb_cli_modules/branch.py

@@ -590,7 +590,6 @@ async def regression_tests(
 
         if current_main_workspace["id"] == config["id"]:
             raise CLIException(FeedbackManager.error_not_allowed_in_main_branch())
-            return
         try:
             response = await client.branch_regression_tests_file(
                 config["id"], regression_tests_commands, run_in_main=main

tinybird/tb_cli_modules/common.py

@@ -175,11 +175,6 @@ def _get_current_workspace_common(
     return next((workspace for workspace in workspaces if workspace["id"] == current_workspace_id), None)
 
 
-async def get_current_environment(client, config):
-    workspaces: List[Dict[str, Any]] = (await client.user_workspaces_and_branches()).get("workspaces", [])
-    return next((workspace for workspace in workspaces if workspace["id"] == config["id"]), None)
-
-
 async def get_current_workspace_branches(config: CLIConfig) -> List[Dict[str, Any]]:
     current_main_workspace: Optional[Dict[str, Any]] = await get_current_main_workspace(config)
     if not current_main_workspace:
@@ -508,12 +503,6 @@ def format_host(host: str, subdomain: Optional[str] = None) -> str:
     return host
 
 
-def region_from_host(region_name_or_host, regions):
-    """Returns the region that matches region_name_or_host"""
-
-    return next((r for r in regions if _compare_region_host(region_name_or_host, r)), None)
-
-
 def ask_for_user_token(action: str, ui_host: str) -> str:
     return click.prompt(
         f'\nUse the token called "user token" in order to {action}. Copy it from {ui_host}/tokens and paste it here',
@@ -974,7 +963,8 @@ async def push_data(
     sql_condition: Optional[str] = None,
     replace_options=None,
     concurrency: int = 1,
-):
+    use_v1: bool = False,
+) -> Optional[list[str]]:
     if url and type(url) is tuple:
         url = url[0]
     client: TinyB = ctx.obj["client"]
@@ -1011,6 +1001,8 @@ async def push_data(
         datasource_name: str, url: str, mode: str, sql_condition: Optional[str], replace_options: Optional[Set[str]]
     ):
         parsed = urlparse(url)
+        if use_v1 and parsed.scheme in ("http", "https"):
+            raise CLIException("--experimental=use_v1 only supports local files.")
         # poor man's format detection
         _format = get_format_from_filename_or_url(url)
         if parsed.scheme in ("http", "https"):
@@ -1031,8 +1023,15 @@ async def push_data(
                 sql_condition=sql_condition,
                 format=_format,
                 replace_options=replace_options,
+                use_v1=use_v1,
             )
 
+        if use_v1:
+            job_id = res.get("id") or res.get("import_id")
+            if not isinstance(job_id, str):
+                raise CLIException("The v1 import response did not include a job ID.")
+            return job_id
+
         datasource_name = res["datasource"]["name"]
         try:
             datasource = await client.get_datasource(datasource_name)
@@ -1063,6 +1062,8 @@ async def push_data(
     try:
         tasks = [process_url(datasource_name, url, mode, sql_condition, replace_options) for url in urls]
         output = await gather_with_concurrency(concurrency, *tasks)
+        if use_v1:
+            return list(output)
         parser, total_rows, appended_rows = list(output)[-1]
     except AuthNoTokenException:
         raise
@@ -1083,6 +1084,8 @@ async def push_data(
             click.echo(FeedbackManager.success_appended_datasource(datasource=datasource_name))
         click.echo(FeedbackManager.info_data_pushed(datasource=datasource_name))
 
+    return None
+
 
 async def sync_data(ctx, datasource_name: str, yes: bool):
     client: TinyB = ctx.obj["client"]
@@ -1121,11 +1124,6 @@ def validate_datasource_name(name):
         raise CLIException(FeedbackManager.error_datasource_name())
 
 
-def validate_connection_id(connection_id):
-    if not isinstance(connection_id, str) or connection_id == "":
-        raise CLIException(FeedbackManager.error_datasource_connection_id())
-
-
 def validate_kafka_topic(topic):
     if not isinstance(topic, str):
         raise CLIException(FeedbackManager.error_kafka_topic())

tinybird/tb_cli_modules/config.py

@@ -6,8 +6,6 @@ from enum import Enum
 from typing import Any, Dict, List, Optional, Tuple, Union
 from urllib.parse import urlparse
 
-from packaging import version
-
 import tinybird.client as tbc
 from tinybird.config import CURRENT_VERSION, DEFAULT_API_HOST, DEFAULT_LOCALHOST
 
@@ -34,12 +32,6 @@ class FeatureFlags:
         return not ("x.y.z" in CURRENT_VERSION and os.environ.get("TB_CLI_TELEMETRY_SEND_IN_LOCAL", "0") == "0")
 
 
-def compare_versions(a: str, b: str) -> int:
-    va = version.parse(a)
-    vb = version.parse(b)
-    return -1 if va < vb else (1 if va > vb else 0)
-
-
 class ConfigValueOrigin(Enum):
     # Sources for config values (environment variables, .tinyb file or default value)
 
@@ -96,7 +88,7 @@ class CLIConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Helper to ease"""
         result: Dict[str, Any] = self._parent.to_dict() if self._parent else {}
-        result.update(dict((v.name, deepcopy(v.value)) for v in self._values.values()))
+        result.update({v.name: deepcopy(v.value) for v in self._values.values()})
         return result
 
     def __getitem__(self, key) -> Any:
@@ -179,12 +171,6 @@ class CLIConfig:
     def set_semver(self, semver: Optional[str]) -> None:
         self["semver"] = semver
 
-    def get_semver(self) -> Optional[str]:
-        try:
-            return self["semver"]
-        except KeyError:
-            return None
-
     def set_token_for_host(self, token: Optional[str], host: Optional[str]) -> None:
         """Sets the token for the specified host.
 

tinybird/tb_cli_modules/datasource.py

@@ -15,7 +15,7 @@ from click import Context
 
 from tinybird.client import AuthNoTokenException, CanNotBeDeletedException, DoesNotExistException, TinyB
 from tinybird.config import get_display_host
-from tinybird.datafile_common import get_name_version, wait_job
+from tinybird.datafile_common import get_name_version
 from tinybird.feedback_manager import FeedbackManager
 from tinybird.tb_cli_modules.branch import warn_if_in_live
 from tinybird.tb_cli_modules.cli import cli
@@ -34,9 +34,12 @@ from tinybird.tb_cli_modules.common import (
     validate_kafka_auto_offset_reset,
     validate_kafka_group,
     validate_kafka_topic,
+    wait_job,
 )
 from tinybird.tb_cli_modules.config import CLIConfig
-from tinybird.tb_cli_modules.exceptions import CLIDatasourceException
+from tinybird.tb_cli_modules.exceptions import CLIDatasourceException, CLIException
+
+EXPERIMENTAL_FEATURE_USE_V1 = "use_v1"
 
 
 @cli.group()
@@ -45,6 +48,34 @@ def datasource(ctx):
     """Data Sources commands"""
 
 
+def _echo_v1_import_jobs_queued(job_ids: list[str], operation: str) -> None:
+    for job_id in job_ids:
+        click.echo(FeedbackManager.success_import_job_queued(operation=operation, job_id=job_id))
+        click.echo(FeedbackManager.info_import_job_status(job_id=job_id))
+
+
+async def _wait_for_v1_import_jobs(client: TinyB, job_ids: list[str], operation: str) -> None:
+    for job_id in job_ids:
+        try:
+            await wait_job(client, job_id, f"/v0/jobs/{job_id}", f"{operation} import")
+        except CLIException:
+            if await _echo_v1_import_job_details(client, job_id):
+                raise click.exceptions.Exit(1)
+            raise
+        click.echo(FeedbackManager.success_import_job_completed(operation=operation, job_id=job_id))
+
+
+async def _echo_v1_import_job_details(client: TinyB, job_id: str) -> bool:
+    try:
+        job = await client.job(job_id)
+    except Exception:
+        return False
+    click.echo(FeedbackManager.info_job(job=job_id))
+    echo_safe_humanfriendly_tables_format_smart_table([job.values()], column_names=job.keys())
+    click.echo("\n")
+    return True
+
+
 @datasource.command(name="ls")
 @click.option("--match", default=None, help="Retrieve any resources matching the pattern. eg --match _test")
 @click.option(
@@ -135,6 +166,13 @@ async def datasource_ls(ctx: Context, match: Optional[str], format_: str):
     hidden=True,
 )
 @click.option("--concurrency", help="How many files to submit concurrently", default=1, hidden=True)
+@click.option("--wait", is_flag=True, default=False, help="Wait for a v1 import job to finish.")
+@click.option(
+    "--experimental",
+    type=click.Choice([EXPERIMENTAL_FEATURE_USE_V1]),
+    multiple=True,
+    help="Enable an experimental feature. May be specified multiple times.",
+)
 @click.pass_context
 @coro
 async def datasource_append(
@@ -145,6 +183,8 @@ async def datasource_append(
     incremental: Optional[str],
     ignore_empty: bool,
     concurrency: int,
+    experimental: tuple[str, ...],
+    wait: bool,
 ):
     """
     Appends data to an existing Data Source from URL, local file  or a connector
@@ -157,7 +197,14 @@ async def datasource_append(
 
     if not url:
         raise CLIDatasourceException(FeedbackManager.error_missing_url(datasource=datasource_name))
-    await push_data(ctx, datasource_name, url, mode="append", concurrency=concurrency)
+    use_v1 = EXPERIMENTAL_FEATURE_USE_V1 in experimental
+    if wait and not use_v1:
+        raise CLIDatasourceException("--wait requires --experimental=use_v1.")
+    job_ids = await push_data(ctx, datasource_name, url, mode="append", concurrency=concurrency, use_v1=use_v1)
+    if use_v1:
+        _echo_v1_import_jobs_queued(job_ids or [], "Append")
+        if wait:
+            await _wait_for_v1_import_jobs(ctx.obj["client"], job_ids or [], "Append")
 
 
 @datasource.command(name="replace")
@@ -165,6 +212,13 @@ async def datasource_append(
 @click.argument("url", nargs=-1)
 @click.option("--sql-condition", default=None, help="SQL WHERE condition to replace data", hidden=True)
 @click.option("--skip-incompatible-partition-key", is_flag=True, default=False, hidden=True)
+@click.option("--wait", is_flag=True, default=False, help="Wait for a v1 import job to finish.")
+@click.option(
+    "--experimental",
+    type=click.Choice([EXPERIMENTAL_FEATURE_USE_V1]),
+    multiple=True,
+    help="Enable an experimental feature. May be specified multiple times.",
+)
 @click.pass_context
 @coro
 async def datasource_replace(
@@ -173,6 +227,8 @@ async def datasource_replace(
     url,
     sql_condition,
     skip_incompatible_partition_key,
+    experimental: tuple[str, ...],
+    wait: bool,
 ):
     """
     Replaces the data in a data source from a URL, local file or a connector
@@ -189,14 +245,22 @@ async def datasource_replace(
     replace_options = set()
     if skip_incompatible_partition_key:
         replace_options.add("skip_incompatible_partition_key")
-    await push_data(
+    use_v1 = EXPERIMENTAL_FEATURE_USE_V1 in experimental
+    if wait and not use_v1:
+        raise CLIDatasourceException("--wait requires --experimental=use_v1.")
+    job_ids = await push_data(
         ctx,
         datasource_name,
         url,
         mode="replace",
         sql_condition=sql_condition,
         replace_options=replace_options,
+        use_v1=use_v1,
     )
+    if use_v1:
+        _echo_v1_import_jobs_queued(job_ids or [], "Replace")
+        if wait:
+            await _wait_for_v1_import_jobs(ctx.obj["client"], job_ids or [], "Replace")
 
 
 @datasource.command(name="analyze")
@@ -363,23 +427,70 @@ async def datasource_truncate(ctx, datasource_name, yes, cascade):
 @click.argument("datasource_name")
 @click.option("--sql-condition", default=None, help="SQL WHERE condition to remove rows", hidden=True, required=True)
 @click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
-@click.option("--wait", is_flag=True, default=False, help="Wait for delete job to finish, disabled by default")
+@click.option(
+    "--wait/--no-wait",
+    default=None,
+    help="Wait for the delete to finish. Defaults to true with --lightweight-delete (sync request), "
+    "false otherwise (returns a job id).",
+)
 @click.option("--dry-run", is_flag=True, default=False, help="Run the command without deleting anything")
+@click.option(
+    "--lightweight-delete",
+    "lightweight",
+    is_flag=True,
+    default=False,
+    help="Use ClickHouse lightweight DELETE. Defaults to waiting inline and returning rows_affected; "
+    "pass --no-wait to enqueue a job instead. Not compatible with --dry-run.",
+)
+@click.option(
+    "--partition",
+    default=None,
+    help="Restrict the lightweight delete to a single partition expression. Only valid with --lightweight-delete.",
+)
+@click.option(
+    "--projection-mode",
+    type=click.Choice(["throw", "drop", "rebuild"]),
+    default=None,
+    help="How ClickHouse should handle table projections when running the lightweight DELETE. "
+    "throw: fail the DELETE if the table has any projection defined (ClickHouse default). "
+    "drop: drop the affected projections so the DELETE can proceed; they will need to be recreated. "
+    "rebuild: rebuild the affected projections after the DELETE finishes. "
+    "Only valid with --lightweight-delete.",
+)
 @click.pass_context
 @coro
-async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait, dry_run):
+async def datasource_delete_rows(
+    ctx, datasource_name, sql_condition, yes, wait, dry_run, lightweight, partition, projection_mode
+):
     """
     Delete rows from a datasource
 
     - Delete rows with SQL condition: `tb datasource delete [datasource_name] --sql-condition "country='ES'"`
 
     - Delete rows with SQL condition and wait for the job to finish: `tb datasource delete [datasource_name] --sql-condition "country='ES'" --wait`
+
+    - Use ClickHouse lightweight DELETE (synchronous, no job): `tb datasource delete [datasource_name] --sql-condition "country='ES'" --lightweight-delete`
+
+    - Use ClickHouse lightweight DELETE and return immediately with a job id: `tb datasource delete [datasource_name] --sql-condition "country='ES'" --lightweight-delete --no-wait`
     """
 
     semver: str = ctx.ensure_object(dict)["config"]["semver"]
     await warn_if_in_live(semver)
 
     client: TinyB = ctx.ensure_object(dict)["client"]
+    if lightweight and dry_run:
+        raise CLIDatasourceException(
+            FeedbackManager.error_exception(error="--lightweight-delete is not compatible with --dry-run")
+        )
+    if (partition or projection_mode) and not lightweight:
+        raise CLIDatasourceException(
+            FeedbackManager.error_exception(error="--partition and --projection-mode require --lightweight-delete")
+        )
+    # Lightweight delete is sync by default (the endpoint blocks and returns
+    # rows_affected); the classic /v0/ delete is async by default (returns a
+    # job id). The tri-state --wait/--no-wait lets users override either.
+    if wait is None:
+        wait = lightweight
     if (
         dry_run
         or yes
@@ -390,7 +501,15 @@ async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait,
         )
     ):
         try:
-            res = await client.datasource_delete_rows(datasource_name, sql_condition, dry_run)
+            res = await client.datasource_delete_rows(
+                datasource_name,
+                sql_condition,
+                dry_run,
+                lightweight=lightweight,
+                wait=wait,
+                partition=partition,
+                projection_mode=projection_mode,
+            )
             if dry_run:
                 click.echo(
                     FeedbackManager.success_dry_run_delete_rows_datasource(
@@ -398,10 +517,24 @@ async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait,
                     )
                 )
                 return
+            # Lightweight sync path returns rows_affected directly, no job involved.
+            if lightweight and wait:
+                mutation = res.get("mutation") or {}
+                click.echo(
+                    FeedbackManager.success_lightweight_delete_rows_datasource(
+                        datasource=datasource_name,
+                        delete_condition=sql_condition,
+                        rows_affected=res.get("rows_affected", 0),
+                        partitions_scanned=mutation.get("partitions_scanned", 0),
+                        partitions_done=mutation.get("partitions_done", 0),
+                        partitions_in_progress=mutation.get("partitions_in_progress", 0),
+                    )
+                )
+                return
             job_id = res["job_id"]
             job_url = res["job_url"]
             click.echo(FeedbackManager.info_datasource_delete_rows_job_url(url=job_url))
-            if wait:
+            if wait and not lightweight:
                 progress_symbols = ["-", "\\", "|", "/"]
                 progress_str = "Waiting for the job to finish"
                 # TODO: Use click.echo instead of print and see if the behavior is the same