tinybird 0.0.1.dev33__tar.gz → 0.0.1.dev35__tar.gz

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird
-Version: 0.0.1.dev33
+Version: 0.0.1.dev35
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/context.py

@@ -7,7 +7,7 @@ if TYPE_CHECKING:
 
 workspace_id: ContextVar[str] = ContextVar("workspace_id")
 workspace: ContextVar["User"] = ContextVar("workspace")
-table_id: ContextVar[str] = ContextVar("table_id")
+datasource_id: ContextVar[str] = ContextVar("datasource_id")
 hfi_frequency: ContextVar[float] = ContextVar("hfi_frequency")
 hfi_frequency_gatherer: ContextVar[float] = ContextVar("hfi_frequency_gatherer")
 use_gatherer: ContextVar[bool] = ContextVar("use_gatherer")

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/datafile.py

@@ -3434,14 +3434,33 @@ async def new_ds(
     DATASOURCE_VALID_SERVICES_TO_UPDATE = ["bigquery", "snowflake"]
     if datasource_exists and service and service in [*DATASOURCE_VALID_SERVICES_TO_UPDATE, *PREVIEW_CONNECTOR_SERVICES]:
         connector_required_params = {
-            "bigquery": ["service", "cron", "external_data_source"],
+            "bigquery": ["service", "cron"],
             "snowflake": ["connector", "service", "cron", "external_data_source"],
             "s3": ["connector", "service", "cron", "bucket_uri"],
             "s3_iamrole": ["connector", "service", "cron", "bucket_uri"],
             "gcs": ["connector", "service", "cron", "bucket_uri"],
         }.get(service, [])
 
+        connector_at_least_one_required_param = {
+            "bigquery": ["external_data_source", "query"],
+        }.get(service, [])
+
+        if connector_at_least_one_required_param and not any(
+            key in ds_params for key in connector_at_least_one_required_param
+        ):
+            params = [
+                (ImportReplacements.get_datafile_param_for_linker_param(service, param) or param).upper()
+                for param in connector_at_least_one_required_param
+            ]
+            click.echo(FeedbackManager.error_updating_connector_missing_at_least_one_param(param=" or ".join(params)))
+            return
+
         if not all(key in ds_params for key in connector_required_params):
+            params = [
+                (ImportReplacements.get_datafile_param_for_linker_param(service, param) or param).upper()
+                for param in connector_required_params
+            ]
+            click.echo(FeedbackManager.error_updating_connector_missing_params(param=", ".join(params)))
             return
 
         connector = ds_params.get("connector", None)
@@ -5589,3 +5608,38 @@ def is_file_a_datasource(filename: str) -> bool:
                 return True
 
     return False
+
+
+def update_connector_params(service: str, ds_params: Dict[str, Any], connector_required_params: List[str]) -> None:
+    """
+    Update connector parameters for a given service, ensuring required parameters exist.
+
+    :param service: The name of the service (e.g., 'bigquery').
+    :param ds_params: The data source parameters to be checked.
+    :param connector_required_params: The list of required parameters for the connector.
+    :return: None
+    """
+
+    connector_at_least_one_required_param: List[str] = {
+        "bigquery": ["external_data_source", "query"],
+    }.get(service, [])
+
+    # Handle the "at least one param" requirement
+    if connector_at_least_one_required_param and not any(
+        key in ds_params for key in connector_at_least_one_required_param
+    ):
+        params = [
+            (ImportReplacements.get_datafile_param_for_linker_param(service, param) or param).upper()
+            for param in connector_at_least_one_required_param
+        ]
+        click.echo(FeedbackManager.error_updating_connector_missing_at_least_one_param(param=" or ".join(params)))
+        return
+
+    # Handle the mandatory params requirement
+    if not all(key in ds_params for key in connector_required_params):
+        params = [
+            (ImportReplacements.get_datafile_param_for_linker_param(service, param) or param).upper()
+            for param in connector_required_params
+        ]
+        click.echo(FeedbackManager.error_updating_connector_missing_params(param=", ".join(params)))
+        return

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/feedback_manager.py

@@ -130,6 +130,12 @@ class FeedbackManager:
     error_remove_no_endpoint = error_message("Pipe does not have any endpoint")
     error_updating_pipe = error_message("Failed updating pipe {error}")
     error_updating_connector_not_supported = error_message("Changing {param} is not currently supported")
+    error_updating_connector_missing_at_least_one_param = error_message(
+        "Connection settings not updated. Connection info should have at least one of {param} settings"
+    )
+    error_updating_connector_missing_params = error_message(
+        "Connection settings not updated. Connection info should have {param} settings"
+    )
     error_removing_node = error_message("Failed removing node from pipe {pipe}: {error}")
     error_pushing_pipe = error_message("Failed pushing pipe {pipe}: {error}")
     error_creating_endpoint = error_message("Failed creating endpoint in node {node} on pipe {pipe}: {error}")

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/prompts.py

@@ -643,6 +643,8 @@ datasource_instructions = """
 <datasource_file_instructions>
     - The datasource names must be unique.
     - No indentation is allowed for property names: DESCRIPTION, SCHEMA, ENGINE, ENGINE_PARTITION_KEY, ENGINE_SORTING_KEY, etc.
+    - Use MergeTree engine by default.
+    - Use AggregatingMergeTree engine when the datasource is the target of a materialized pipe.
 </datasource_file_instructions>
 """
 
@@ -732,6 +734,8 @@ sql_instructions = """
     - When aliasing a column, use first the column name and then the alias.
     - General functions and aggregate functions are case sensitive.
     - Character insensitive functions are case insensitive.
+    - When you use defined function with a paremeter inside, do NOT add quotes around the parameter.
+    - Parameters are never quoted in any case.
 </sql_instructions>
 """.format(
     general_functions=general_functions,

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/sql_toolset.py

@@ -3,7 +3,7 @@ import logging
 from collections import defaultdict
 from datetime import datetime
 from functools import lru_cache
-from typing import Any, FrozenSet, List, Optional, Set, Tuple
+from typing import FrozenSet, List, Optional, Set, Tuple
 
 from chtoolset import query as chquery
 from toposort import toposort
@@ -172,7 +172,7 @@ def tables_or_sql(replacement: dict, table_functions=False) -> set:
         return {replacement}
 
 
-def _separate_as_tuple_if_contains_database_and_table(definition: str) -> Any:
+def _separate_as_tuple_if_contains_database_and_table(definition: str) -> str | Tuple[str, str]:
     if "." in definition:
         database_and_table_separated = definition.split(".")
         return database_and_table_separated[0], database_and_table_separated[1]
@@ -219,6 +219,7 @@ def replace_tables(
     output_one_line: bool = False,
     timestamp: Optional[datetime] = None,
     function_allow_list: Optional[FrozenSet[str]] = None,
+    original_replacements: Optional[dict] = None,
 ) -> str:
     """
     Given a query and a list of table replacements, returns the query after applying the table replacements.
@@ -239,6 +240,12 @@ def replace_tables(
         _replacements[rk] = r if isinstance(r, tuple) else (default_database, r)
         _replaced_with.add(r)
 
+    if original_replacements:
+        # Some replacements have been expanded by filters and turned to a query str, but we need to send the original
+        # ones to is_invalid_resource()
+        for r in original_replacements.values():
+            _replaced_with.add(r)
+
     deps: defaultdict = defaultdict(set)
     _tables = sql_get_used_tables(
         sql,

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/cli/introduction.html'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev33'
-__revision__ = '0cbe672'
+__version__ = '0.0.1.dev35'
+__revision__ = '5046116'

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/tb/cli.py

@@ -9,10 +9,10 @@ import tinybird.tb.modules.build
 import tinybird.tb.modules.build_client
 import tinybird.tb.modules.cli
 import tinybird.tb.modules.common
-import tinybird.tb.modules.connection
 import tinybird.tb.modules.create
 import tinybird.tb.modules.datasource
-import tinybird.tb.modules.deploy
+import tinybird.tb.modules.deployment
+import tinybird.tb.modules.endpoint
 import tinybird.tb.modules.fmt
 import tinybird.tb.modules.job
 import tinybird.tb.modules.local

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/tb/modules/build.py

@@ -3,6 +3,7 @@ import glob
 import json
 import logging
 import threading
+import time
 from pathlib import Path
 from typing import List
 
@@ -27,11 +28,16 @@ def build(folder: str, watch: bool) -> None:
     """
 
     tb_client = asyncio.run(get_tinybird_local_client(folder))
+    click.echo(FeedbackManager.highlight(message="\n» Building project..."))
 
     def process() -> None:
         build_project(folder, tb_client)
 
+    time_start = time.time()
     process()
+    time_end = time.time()
+    elapsed_time = time_end - time_start
+    click.echo(FeedbackManager.success(message=f"\n✓ Build completed in {elapsed_time:.1f}s"))
 
     if watch:
         shell = Shell(folder=folder, client=tb_client)
@@ -71,6 +77,7 @@ def build_project(folder: str, tb_client: TinyB) -> None:
         fds = []
         project_path = Path(folder)
         project_files = get_project_files(project_path)
+
         for file_path in project_files:
             relative_path = str(Path(file_path).relative_to(project_path))
             fd = open(file_path, "rb")
@@ -91,7 +98,20 @@ def build_project(folder: str, tb_client: TinyB) -> None:
 
         build_result = result.get("result")
         if build_result == "success":
-            click.echo(FeedbackManager.success(message="Build completed successfully"))
+            datasources = result.get("datasources", [])
+            pipes = result.get("pipes", [])
+            for ds in datasources:
+                ds_path = next((p for p in project_files if p.endswith(ds.get("name") + ".datasource")), None)
+                if ds_path:
+                    ds_path = ds_path.replace(f"{folder}/", "")
+                    click.echo(FeedbackManager.info(message=f"✓ {ds_path} created"))
+            for pipe in pipes:
+                pipe_name = pipe.get("name")
+                pipe_path = next((p for p in project_files if p.endswith(pipe_name + ".pipe")), None)
+                if pipe_path:
+                    pipe_path = pipe_path.replace(f"{folder}/", "")
+                    click.echo(FeedbackManager.info(message=f"✓ {pipe_path} created"))
+
         elif build_result == "failed":
             click.echo(FeedbackManager.error(message="Build failed"))
             build_errors = result.get("errors")

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/tb/modules/cli.py

@@ -210,7 +210,7 @@ async def cli(
 
     logging.debug("debug enabled")
 
-    skip_client = ctx.invoked_subcommand in ["login", "workspace", "local"]
+    skip_client = ctx.invoked_subcommand in ["login", "workspace", "local", "build"]
     client = await create_ctx_client(config, prod, skip_client)
 
     if client:

{tinybird-0.0.1.dev33 → tinybird-0.0.1.dev35}/tinybird/tb/modules/datafile/common.py

@@ -204,6 +204,10 @@ class Datafile:
         if self.kind == DatafileKind.pipe:
             # TODO(eclbg):
             #  [x] node names are unique
+            #  [x] SQL in all nodes
+            #  [x] Materialized nodes have target datasource
+            #  [x] Only one materialized node
+            #  [ ] Only one node of any specific type
             #  [ ] ...
             repeated_node_names = [
                 name for name, count in filter(lambda x: x[1] > 1, Counter(n["name"] for n in self.nodes).items())
@@ -212,7 +216,19 @@ class Datafile:
                 raise DatafileValidationError(
                     f"Pipe node names must be unique. These names are repeated: {repeated_node_names}"
                 )
-            pass
+            for node in self.nodes:
+                if "sql" not in node:
+                    raise DatafileValidationError(f"SQL missing for node {repr(node['name'])}")
+            materialized_nodes_count = 0
+            for node in self.nodes:
+                if node.get("type", "").lower() == "materialized":
+                    materialized_nodes_count += 1
+                    if materialized_nodes_count > 1:
+                        raise DatafileValidationError("Multiple materialized nodes in pipe. There can only be one")
+                    if "datasource" not in node:
+                        raise DatafileValidationError(
+                            f"Materialized node {repr(node['name'])} missing target datasource"
+                        )
         elif self.kind == DatafileKind.datasource:
             # TODO(eclbg):
             #  [x] Just one node

tinybird-0.0.1.dev35/tinybird/tb/modules/datasource.py

@@ -0,0 +1,360 @@
+# This is a command file for our CLI. Please keep it clean.
+#
+# - If it makes sense and only when strictly necessary, you can create utility functions in this file.
+# - But please, **do not** interleave utility functions and command definitions.
+
+import asyncio
+import json
+import re
+from typing import Optional
+
+import click
+import humanfriendly
+from click import Context
+
+from tinybird.client import AuthNoTokenException, DoesNotExistException, TinyB
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import (
+    _analyze,
+    coro,
+    echo_safe_humanfriendly_tables_format_smart_table,
+    get_format_from_filename_or_url,
+    load_connector_config,
+    push_data,
+)
+from tinybird.tb.modules.datafile.common import get_name_version
+from tinybird.tb.modules.exceptions import CLIDatasourceException
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+@cli.group()
+@click.pass_context
+def datasource(ctx):
+    """Data Sources commands"""
+
+
+@datasource.command(name="ls")
+@click.option("--match", default=None, help="Retrieve any resources matching the pattern. eg --match _test")
+@click.option(
+    "--format",
+    "format_",
+    type=click.Choice(["json"], case_sensitive=False),
+    default=None,
+    help="Force a type of the output",
+)
+@click.pass_context
+@coro
+async def datasource_ls(ctx: Context, match: Optional[str], format_: str):
+    """List data sources"""
+
+    client: TinyB = ctx.ensure_object(dict)["client"]
+    ds = await client.datasources()
+    columns = ["shared from", "name", "row_count", "size", "created at", "updated at", "connection"]
+    table_human_readable = []
+    table_machine_readable = []
+    pattern = re.compile(match) if match else None
+
+    for t in ds:
+        stats = t.get("stats", None)
+        if not stats:
+            stats = t.get("statistics", {"bytes": ""})
+            if not stats:
+                stats = {"bytes": ""}
+
+        tk = get_name_version(t["name"])
+        if pattern and not pattern.search(tk["name"]):
+            continue
+
+        if "." in tk["name"]:
+            shared_from, name = tk["name"].split(".")
+        else:
+            shared_from, name = "", tk["name"]
+
+        table_human_readable.append(
+            (
+                shared_from,
+                name,
+                humanfriendly.format_number(stats.get("row_count")) if stats.get("row_count", None) else "-",
+                humanfriendly.format_size(int(stats.get("bytes"))) if stats.get("bytes", None) else "-",
+                t["created_at"][:-7],
+                t["updated_at"][:-7],
+                t.get("service", ""),
+            )
+        )
+        table_machine_readable.append(
+            {
+                "shared from": shared_from,
+                "name": name,
+                "row_count": stats.get("row_count", None) or "-",
+                "size": stats.get("bytes", None) or "-",
+                "created at": t["created_at"][:-7],
+                "updated at": t["updated_at"][:-7],
+                "connection": t.get("service", ""),
+            }
+        )
+
+    if not format_:
+        click.echo(FeedbackManager.info_datasources())
+        echo_safe_humanfriendly_tables_format_smart_table(table_human_readable, column_names=columns)
+        click.echo("\n")
+    elif format_ == "json":
+        click.echo(json.dumps({"datasources": table_machine_readable}, indent=2))
+    else:
+        raise CLIDatasourceException(FeedbackManager.error_datasource_ls_type())
+
+
+@datasource.command(name="append")
+@click.argument("datasource_name")
+@click.argument("url", nargs=-1)
+@click.option("--concurrency", help="How many files to submit concurrently", default=1, hidden=True)
+@click.pass_context
+@coro
+async def datasource_append(
+    ctx: Context,
+    datasource_name: str,
+    url,
+    concurrency: int,
+):
+    """
+    Appends data to an existing Data Source from URL, local file  or a connector
+
+    - Load from URL `tb datasource append [datasource_name] https://url_to_csv`
+
+    - Load from local file `tb datasource append [datasource_name] /path/to/local/file`
+    """
+
+    client: TinyB = ctx.obj["client"]
+    await push_data(
+        client,
+        datasource_name,
+        url,
+        mode="append",
+        concurrency=concurrency,
+    )
+
+
+@datasource.command(name="replace")
+@click.argument("datasource_name")
+@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.pass_context
+@coro
+async def datasource_replace(
+    ctx: Context,
+    datasource_name,
+    url,
+    sql_condition,
+    skip_incompatible_partition_key,
+):
+    """
+    Replaces the data in a data source from a URL, local file or a connector
+
+    - Replace from URL `tb datasource replace [datasource_name] https://url_to_csv --sql-condition "country='ES'"`
+
+    - Replace from local file `tb datasource replace [datasource_name] /path/to/local/file --sql-condition "country='ES'"`
+    """
+
+    replace_options = set()
+    if skip_incompatible_partition_key:
+        replace_options.add("skip_incompatible_partition_key")
+    client: TinyB = ctx.obj["client"]
+    await push_data(
+        client,
+        datasource_name,
+        url,
+        mode="replace",
+        sql_condition=sql_condition,
+        replace_options=replace_options,
+    )
+
+
+@datasource.command(name="analyze")
+@click.argument("url_or_file")
+@click.option(
+    "--connector",
+    type=click.Choice(["bigquery", "snowflake"], case_sensitive=True),
+    help="Use from one of the selected connectors. In this case pass a table name as a parameter instead of a file name or an URL",
+    hidden=True,
+)
+@click.pass_context
+@coro
+async def datasource_analyze(ctx, url_or_file, connector):
+    """Analyze a URL or a file before creating a new data source"""
+    client = ctx.obj["client"]
+
+    _connector = None
+    if connector:
+        load_connector_config(ctx, connector, False, check_uninstalled=False)
+        if connector not in ctx.obj:
+            raise CLIDatasourceException(FeedbackManager.error_connector_not_configured(connector=connector))
+        else:
+            _connector = ctx.obj[connector]
+
+    def _table(title, columns, data):
+        row_format = "{:<25}" * len(columns)
+        click.echo(FeedbackManager.info_datasource_title(title=title))
+        click.echo(FeedbackManager.info_datasource_row(row=row_format.format(*columns)))
+        for t in data:
+            click.echo(FeedbackManager.info_datasource_row(row=row_format.format(*[str(element) for element in t])))
+
+    analysis, _ = await _analyze(
+        url_or_file, client, format=get_format_from_filename_or_url(url_or_file), connector=_connector
+    )
+
+    columns = ("name", "type", "nullable")
+    if "columns" in analysis["analysis"]:
+        _table(
+            "columns",
+            columns,
+            [
+                (t["name"], t["recommended_type"], "false" if t["present_pct"] == 1 else "true")
+                for t in analysis["analysis"]["columns"]
+            ],
+        )
+
+    click.echo(FeedbackManager.info_datasource_title(title="SQL Schema"))
+    click.echo(analysis["analysis"]["schema"])
+
+    values = []
+
+    if "dialect" in analysis:
+        for x in analysis["dialect"].items():
+            if x[1] == " ":
+                values.append((x[0], '" "'))
+            elif type(x[1]) == str and ("\n" in x[1] or "\r" in x[1]):  # noqa: E721
+                values.append((x[0], x[1].replace("\n", "\\n").replace("\r", "\\r")))
+            else:
+                values.append(x)
+
+        _table("dialect", ("name", "value"), values)
+
+
+@datasource.command(name="truncate")
+@click.argument("datasource_name", required=True)
+@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
+@click.option(
+    "--cascade", is_flag=True, default=False, help="Truncate dependent DS attached in cascade to the given DS"
+)
+@click.pass_context
+@coro
+async def datasource_truncate(ctx, datasource_name, yes, cascade):
+    """Truncate a data source"""
+
+    client = ctx.obj["client"]
+    if yes or click.confirm(FeedbackManager.warning_confirm_truncate_datasource(datasource=datasource_name)):
+        try:
+            await client.datasource_truncate(datasource_name)
+        except AuthNoTokenException:
+            raise
+        except DoesNotExistException:
+            raise CLIDatasourceException(FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name))
+        except Exception as e:
+            raise CLIDatasourceException(FeedbackManager.error_exception(error=e))
+
+        click.echo(FeedbackManager.success_truncate_datasource(datasource=datasource_name))
+
+        if cascade:
+            try:
+                ds_cascade_dependencies = await client.datasource_dependencies(
+                    no_deps=False,
+                    match=None,
+                    pipe=None,
+                    datasource=datasource_name,
+                    check_for_partial_replace=True,
+                    recursive=False,
+                )
+            except Exception as e:
+                raise CLIDatasourceException(FeedbackManager.error_exception(error=e))
+
+            cascade_dependent_ds = list(ds_cascade_dependencies.get("dependencies", {}).keys()) + list(
+                ds_cascade_dependencies.get("incompatible_datasources", {}).keys()
+            )
+            for cascade_ds in cascade_dependent_ds:
+                if yes or click.confirm(FeedbackManager.warning_confirm_truncate_datasource(datasource=cascade_ds)):
+                    try:
+                        await client.datasource_truncate(cascade_ds)
+                    except DoesNotExistException:
+                        raise CLIDatasourceException(
+                            FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name)
+                        )
+                    except Exception as e:
+                        raise CLIDatasourceException(FeedbackManager.error_exception(error=e))
+                    click.echo(FeedbackManager.success_truncate_datasource(datasource=cascade_ds))
+
+
+@datasource.command(name="delete")
+@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("--dry-run", is_flag=True, default=False, help="Run the command without deleting anything")
+@click.pass_context
+@coro
+async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait, dry_run):
+    """
+    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`
+    """
+
+    client: TinyB = ctx.ensure_object(dict)["client"]
+    if (
+        dry_run
+        or yes
+        or click.confirm(
+            FeedbackManager.warning_confirm_delete_rows_datasource(
+                datasource=datasource_name, delete_condition=sql_condition
+            )
+        )
+    ):
+        try:
+            res = await client.datasource_delete_rows(datasource_name, sql_condition, dry_run)
+            if dry_run:
+                click.echo(
+                    FeedbackManager.success_dry_run_delete_rows_datasource(
+                        rows=res["rows_to_be_deleted"], datasource=datasource_name, delete_condition=sql_condition
+                    )
+                )
+                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:
+                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
+                print(f"\n{progress_str}", end="")  # noqa: T201
+
+                def progress_line(n):
+                    print(f"\r{progress_str} {progress_symbols[n % len(progress_symbols)]}", end="")  # noqa: T201
+
+                i = 0
+                while True:
+                    try:
+                        res = await client._req(f"v0/jobs/{job_id}")
+                    except Exception:
+                        raise CLIDatasourceException(FeedbackManager.error_job_status(url=job_url))
+                    if res["status"] == "done":
+                        print("\n")  # noqa: T201
+                        click.echo(
+                            FeedbackManager.success_delete_rows_datasource(
+                                datasource=datasource_name, delete_condition=sql_condition
+                            )
+                        )
+                        break
+                    elif res["status"] == "error":
+                        print("\n")  # noqa: T201
+                        raise CLIDatasourceException(FeedbackManager.error_exception(error=res["error"]))
+                    await asyncio.sleep(1)
+                    i += 1
+                    progress_line(i)
+
+        except AuthNoTokenException:
+            raise
+        except DoesNotExistException:
+            raise CLIDatasourceException(FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name))
+        except Exception as e:
+            raise CLIDatasourceException(FeedbackManager.error_exception(error=e))