diff --git a/universql/catalog/snow/show_iceberg_tables.py b/universql/catalog/snow/show_iceberg_tables.py
index f5ab91a..097be83 100644
--- a/universql/catalog/snow/show_iceberg_tables.py
+++ b/universql/catalog/snow/show_iceberg_tables.py
@@ -201,7 +201,7 @@ def get_table_references(self, cursor: duckdb.DuckDBPyConnection, tables: List[s
         result = cur.fetchall()
         used_tables = ",".join(set(table.sql() for table in tables))
         logging.getLogger("❄️cloud").info(
-            f"Executed metadata query to get Iceberg table locations for tables {used_tables}")
+            f"[{self.query_id}] Executed metadata query to get Iceberg table locations for tables {used_tables}")
         return {table: SnowflakeShowIcebergTables._get_ref(json.loads(result[0][idx])) for idx, table in
                 enumerate(tables)}
 
diff --git a/universql/warehouse/duckdb.py b/universql/warehouse/duckdb.py
index ad956e7..67393a7 100644
--- a/universql/warehouse/duckdb.py
+++ b/universql/warehouse/duckdb.py
@@ -114,26 +114,26 @@ def _do_query(self, raw_query: str) -> (str, List, pyarrow.Table):
                         break
                     sql = transformed_ast.sql(dialect="duckdb", pretty=True)
                     planned_duration = time.perf_counter() - start_time
-                    timedelta = datetime.timedelta(seconds=planned_duration)
 
-                    logger.info("[%s] Re-written for DuckDB as: (%s)\n%s" % (self.token, timedelta, sql))
                     try:
                         self.duckdb_emulator.execute(sql)
+                        timedelta = datetime.timedelta(seconds=planned_duration)
+                        logger.info("[%s] Duckdb environment is prepared. (%s)\n%s" % (self.token, timedelta, sql))
                     # except duckdb.Error as e:
                     except DatabaseError as e:
-                        local_error_message = f"DuckDB error: {e.args}"
+                        local_error_message = f"Unable to run the query locally on DuckDB. {e.msg}"
                         can_run_locally = False
                         break
 
-        if compute == Compute.LOCAL.value:
-            if not should_run_locally:
-                raise SnowflakeError(self.token, f"Can't run the query locally, {local_error_message}")
-            return self.get_snowflake_result()
         if can_run_locally and not run_snowflake_already and should_run_locally:
             formatting = (self.token, datetime.timedelta(seconds=time.perf_counter() - start_time))
-            logger.info(f"[{self.token}] Run locally 🚀 ({formatting})")
+            logger.info(f"[{self.token}] Run locally 🚀 ({formatting[1]})")
             return self.get_duckdb_result()
         else:
+            if local_error_message:
+                logger.error(f"[{self.token}] {local_error_message}")
+                if not should_run_locally:
+                    raise SnowflakeError(self.token, f"Can't run the query locally. {local_error_message}")
             self.do_snowflake_query(queries, raw_query, start_time, local_error_message)
             return self.get_snowflake_result()
 
@@ -141,7 +141,7 @@ def do_snowflake_query(self, queries, raw_query, start_time, local_error_message
         try:
             self.snowflake.execute(queries, raw_query)
             formatting = (self.token, datetime.timedelta(seconds=time.perf_counter() - start_time))
-            logger.info(f"[{self.token}] Query is done. ({formatting})")
+            logger.info(f"[{self.token}] Query is done. ({formatting[1]})")
         except SnowflakeError as e:
             final_error = f"{local_error_message}. {e.message}"
             cloud_logger.error(f"[{self.token}] {final_error}")