MindsDB 25.4.1.0__py3-none-any.whl → 25.4.2.0__py3-none-any.whl

mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py

@@ -1,5 +1,6 @@
 import ast
 import sys
+import os
 from typing import Dict, List, Optional, Union
 import hashlib
 
@@ -67,6 +68,8 @@ class ChromaDBHandler(VectorStoreHandler):
             "persist_directory": self.persist_directory,
         }
 
+        self._use_handler_storage = False
+
         self.connect()
 
     def validate_connection_parameters(self, name, **kwargs):
@@ -79,11 +82,15 @@ class ChromaDBHandler(VectorStoreHandler):
 
         config = ChromaHandlerConfig(**_config)
 
-        if config.persist_directory and not self.handler_storage.is_temporal:
-            # get full persistence directory from handler storage
-            self.persist_directory = self.handler_storage.folder_get(
-                config.persist_directory
-            )
+        if config.persist_directory:
+            if os.path.isabs(config.persist_directory):
+                self.persist_directory = config.persist_directory
+            elif not self.handler_storage.is_temporal:
+                # get full persistence directory from handler storage
+                self.persist_directory = self.handler_storage.folder_get(
+                    config.persist_directory
+                )
+                self._use_handler_storage = True
 
         return config
 
@@ -105,7 +112,7 @@ class ChromaDBHandler(VectorStoreHandler):
 
     def _sync(self):
         """Sync the database to disk if using persistent storage"""
-        if self.persist_directory:
+        if self.persist_directory and self._use_handler_storage:
             self.handler_storage.folder_sync(self.persist_directory)
 
     def __del__(self):
@@ -162,6 +169,8 @@ class ChromaDBHandler(VectorStoreHandler):
             FilterOperator.LESS_THAN_OR_EQUAL: "$lte",
             FilterOperator.GREATER_THAN: "$gt",
             FilterOperator.GREATER_THAN_OR_EQUAL: "$gte",
+            FilterOperator.IN: "$in",
+            FilterOperator.NOT_IN: "$nin",
         }
 
         if operator not in mapping:
@@ -308,7 +317,7 @@ class ChromaDBHandler(VectorStoreHandler):
         }
 
         if columns is not None:
-            payload = {column: payload[column] for column in columns}
+            payload = {column: payload[column] for column in columns if column != TableField.DISTANCE.value}
 
         # always include distance
         distance_filter = None
@@ -316,10 +325,11 @@ class ChromaDBHandler(VectorStoreHandler):
         if distances is not None:
             payload[distance_col] = distances
 
-            for cond in conditions:
-                if cond.column == distance_col:
-                    distance_filter = cond
-                    break
+            if conditions is not None:
+                for cond in conditions:
+                    if cond.column == distance_col:
+                        distance_filter = cond
+                        break
 
         df = pd.DataFrame(payload)
         if distance_filter is not None:
@@ -413,8 +423,8 @@ class ChromaDBHandler(VectorStoreHandler):
             collection.upsert(
                 ids=data_dict[TableField.ID.value],
                 documents=data_dict[TableField.CONTENT.value],
-                embeddings=data_dict.get(TableField.EMBEDDINGS.value),
-                metadatas=data_dict.get(TableField.METADATA.value)
+                embeddings=data_dict.get(TableField.EMBEDDINGS.value, None),
+                metadatas=data_dict.get(TableField.METADATA.value, None)
             )
             self._sync()
         except Exception as e:

mindsdb/integrations/handlers/mssql_handler/mssql_handler.py

@@ -177,7 +177,7 @@ class SqlServerHandler(DatabaseHandler):
                         )
                     )
                 else:
-                    response = Response(RESPONSE_TYPE.OK)
+                    response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
                 connection.commit()
             except Exception as e:
                 logger.error(f'Error running query: {query} on {self.database}, {e}!')

mindsdb/integrations/handlers/mysql_handler/mysql_handler.py

@@ -178,10 +178,11 @@ class MySQLHandler(DatabaseHandler):
                         pd.DataFrame(
                             result,
                             columns=[x[0] for x in cur.description]
-                        )
+                        ),
+                        affected_rows=cur.rowcount
                     )
                 else:
-                    response = Response(RESPONSE_TYPE.OK)
+                    response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
         except mysql.connector.Error as e:
             logger.error(f'Error running query: {query} on {self.connection_data["database"]}!')
             response = Response(

mindsdb/integrations/handlers/oracle_handler/oracle_handler.py

@@ -205,8 +205,10 @@ class OracleHandler(DatabaseHandler):
         with connection.cursor() as cur:
             try:
                 cur.execute(query)
-                result = cur.fetchall()
-                if result:
+                if cur.description is None:
+                    response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
+                else:
+                    result = cur.fetchall()
                     response = Response(
                         RESPONSE_TYPE.TABLE,
                         data_frame=pd.DataFrame(
@@ -214,8 +216,6 @@ class OracleHandler(DatabaseHandler):
                             columns=[row[0] for row in cur.description],
                         ),
                     )
-                else:
-                    response = Response(RESPONSE_TYPE.OK)
 
                 connection.commit()
             except DatabaseError as database_error:

mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py

@@ -149,7 +149,7 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler):
         for key, value in filter_conditions.items():
             if key == "embeddings":
                 continue
-            if value['op'].lower() == 'in':
+            if value['op'].lower() in ('in', 'not in'):
                 values = list(repr(i) for i in value['value'])
                 value['value'] = '({})'.format(', '.join(values))
             else:
@@ -165,9 +165,9 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler):
 
     @staticmethod
     def _construct_full_after_from_clause(
+        where_clause: str,
         offset_clause: str,
         limit_clause: str,
-        where_clause: str,
     ) -> str:
 
         return f"{where_clause} {offset_clause} {limit_clause}"
@@ -200,10 +200,20 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler):
             where_clause, offset_clause, limit_clause
         )
 
-        if columns is None:
-            targets = '*'
+        # Handle distance column specially since it's calculated, not stored
+        modified_columns = []
+        has_distance = False
+        if columns is not None:
+            for col in columns:
+                if col == TableField.DISTANCE.value:
+                    has_distance = True
+                else:
+                    modified_columns.append(col)
         else:
-            targets = ', '.join(columns)
+            modified_columns = ['id', 'content', 'embeddings', 'metadata']
+            has_distance = True
+
+        targets = ', '.join(modified_columns)
 
 
         if filter_conditions:
@@ -227,6 +237,10 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler):
                     # Use cosine similarity for dense vectors
                     distance_op = "<=>"
 
+                # Calculate distance as part of the query if needed
+                if has_distance:
+                    targets = f"{targets}, (embeddings {distance_op} '{search_vector}') as distance"
+                
                 return f"SELECT {targets} FROM {table_name} ORDER BY embeddings {distance_op} '{search_vector}' ASC {after_from_clause}"
 
             else:

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -228,7 +228,7 @@ class PostgresHandler(DatabaseHandler):
                 else:
                     cur.execute(query)
                 if cur.pgresult is None or ExecStatus(cur.pgresult.status) == ExecStatus.COMMAND_OK:
-                    response = Response(RESPONSE_TYPE.OK)
+                    response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
                 else:
                     result = cur.fetchall()
                     df = DataFrame(
@@ -238,7 +238,8 @@ class PostgresHandler(DatabaseHandler):
                     self._cast_dtypes(df, cur.description)
                     response = Response(
                         RESPONSE_TYPE.TABLE,
-                        df
+                        data_frame=df,
+                        affected_rows=cur.rowcount
                     )
                 connection.commit()
             except Exception as e:
@@ -255,15 +256,16 @@ class PostgresHandler(DatabaseHandler):
 
         return response
 
-    def insert(self, table_name: str, df: pd.DataFrame):
+    def insert(self, table_name: str, df: pd.DataFrame) -> Response:
         need_to_close = not self.is_connected
 
         connection = self.connect()
 
         columns = [f'"{c}"' for c in df.columns]
+        rowcount = None
         with connection.cursor() as cur:
             try:
-                with cur.copy(f'copy "{table_name}" ({",".join(columns)}) from STDIN  WITH CSV') as copy:
+                with cur.copy(f'copy "{table_name}" ({",".join(columns)}) from STDIN WITH CSV') as copy:
                     df.to_csv(copy, index=False, header=False)
 
                 connection.commit()
@@ -271,10 +273,13 @@ class PostgresHandler(DatabaseHandler):
                 logger.error(f'Error running insert to {table_name} on {self.database}, {e}!')
                 connection.rollback()
                 raise e
+            rowcount = cur.rowcount
 
         if need_to_close:
             self.disconnect()
 
+        return Response(RESPONSE_TYPE.OK, affected_rows=rowcount)
+
     @profiler.profile()
     def query(self, query: ASTNode) -> Response:
         """

mindsdb/integrations/handlers/redshift_handler/redshift_handler.py

@@ -52,7 +52,7 @@ class RedshiftHandler(PostgresHandler):
         with connection.cursor() as cur:
             try:
                 cur.executemany(query, df.values.tolist())
-                response = Response(RESPONSE_TYPE.OK)
+                response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
 
                 connection.commit()
             except Exception as e:

mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py

@@ -230,18 +230,25 @@ class SnowflakeHandler(DatabaseHandler):
                     # Fallback for CREATE/DELETE/UPDATE. These commands returns table with single column,
                     # but it cannot be retrieved as pandas DataFrame.
                     result = cur.fetchall()
-                    if result:
-                        response = Response(
-                            RESPONSE_TYPE.TABLE,
-                            DataFrame(
-                                result,
-                                columns=[x[0] for x in cur.description]
+                    match result:
+                        case (
+                            [{'number of rows inserted': affected_rows}]
+                            | [{'number of rows deleted': affected_rows}]
+                            | [{'number of rows updated': affected_rows, 'number of multi-joined rows updated': _}]
+                        ):
+                            response = Response(RESPONSE_TYPE.OK, affected_rows=affected_rows)
+                        case list():
+                            response = Response(
+                                RESPONSE_TYPE.TABLE,
+                                DataFrame(
+                                    result,
+                                    columns=[x[0] for x in cur.description]
+                                )
                             )
-                        )
-                    else:
-                        # Looks like SnowFlake always returns something in response, so this is suspicious
-                        logger.warning('Snowflake did not return any data in response.')
-                        response = Response(RESPONSE_TYPE.OK)
+                        case _:
+                            # Looks like SnowFlake always returns something in response, so this is suspicious
+                            logger.warning('Snowflake did not return any data in response.')
+                            response = Response(RESPONSE_TYPE.OK)
             except Exception as e:
                 logger.error(f"Error running query: {query} on {self.connection_data.get('database')}, {e}!")
                 response = Response(

mindsdb/integrations/libs/ml_handler_process/learn_process.py

@@ -78,8 +78,7 @@ def learn_process(data_integration_ref: dict, problem_definition: dict, fetch_da
                     query_ast = parse_sql(fetch_data_query)
                     sqlquery = SQLQuery(query_ast, session=sql_session)
 
-                result = sqlquery.fetch(view='dataframe')
-                training_data_df = result['result']
+                training_data_df = sqlquery.fetched_data.to_df()
 
             training_data_columns_count, training_data_rows_count = 0, 0
             if training_data_df is not None:

mindsdb/integrations/libs/response.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from pandas import DataFrame
 
 from mindsdb.utilities import log
@@ -8,13 +9,16 @@ from mindsdb_sql_parser.ast import ASTNode
 logger = log.getLogger(__name__)
 
 class HandlerResponse:
-    def __init__(self, resp_type: RESPONSE_TYPE, data_frame: DataFrame = None,
-                 query: ASTNode = 0, error_code: int = 0, error_message: str = None) -> None:
+    def __init__(self, resp_type: RESPONSE_TYPE, data_frame: DataFrame = None, query: ASTNode = 0, error_code: int = 0,
+                 error_message: Optional[str] = None, affected_rows: Optional[int] = None) -> None:
         self.resp_type = resp_type
         self.query = query
         self.data_frame = data_frame
         self.error_code = error_code
         self.error_message = error_message
+        self.affected_rows = affected_rows
+        if isinstance(self.affected_rows, int) is False or self.affected_rows < 0:
+            self.affected_rows = 0
 
     @property
     def type(self):
@@ -35,13 +39,14 @@ class HandlerResponse:
                  "error": self.error_message}
 
     def __repr__(self):
-        return "%s: resp_type=%s, query=%s, data_frame=%s, err_code=%s, error=%s" % (
+        return "%s: resp_type=%s, query=%s, data_frame=%s, err_code=%s, error=%s, affected_rows=%s" % (
                 self.__class__.__name__,
                 self.resp_type,
                 self.query,
                 self.data_frame,
                 self.error_code,
-                self.error_message
+                self.error_message,
+                self.affected_rows
             )
 
 class HandlerStatusResponse:

mindsdb/integrations/libs/vectordatabase_handler.py

@@ -20,7 +20,7 @@ from mindsdb_sql_parser.ast.base import ASTNode
 
 from mindsdb.integrations.libs.response import RESPONSE_TYPE, HandlerResponse
 from mindsdb.utilities import log
-from mindsdb.integrations.utilities.sql_utils import conditions_to_filter, FilterCondition, FilterOperator
+from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator
 
 from mindsdb.integrations.utilities.query_traversal import query_traversal
 from .base import BaseHandler
@@ -39,6 +39,7 @@ class TableField(Enum):
     METADATA = "metadata"
     SEARCH_VECTOR = "search_vector"
     DISTANCE = "distance"
+    RELEVANCE = "relevance"
 
 
 class DistanceFunction(Enum):
@@ -69,6 +70,10 @@ class VectorStoreHandler(BaseHandler):
             "name": TableField.METADATA.value,
             "data_type": "json",
         },
+        {
+            "name": TableField.DISTANCE.value,
+            "data_type": "float",
+        },
     ]
 
     def validate_connection_parameters(self, name, **kwargs):
@@ -231,7 +236,7 @@ class VectorStoreHandler(BaseHandler):
 
         return self.do_upsert(table_name, pd.DataFrame(data))
 
-    def _dispatch_update(self, query: Update):
+    def dispatch_update(self, query: Update, conditions: List[FilterCondition] = None):
         """
         Dispatch update query to the appropriate method.
         """
@@ -250,8 +255,15 @@ class VectorStoreHandler(BaseHandler):
                     pass
             row[k] = v
 
-        filters = conditions_to_filter(query.where)
-        row.update(filters)
+        if conditions is None:
+            where_statement = query.where
+            conditions = self.extract_conditions(where_statement)
+
+        for condition in conditions:
+            if condition.op != FilterOperator.EQUAL:
+                raise NotImplementedError
+
+            row[condition.column] = condition.value
 
         # checks
         if TableField.EMBEDDINGS.value not in row:
@@ -381,7 +393,7 @@ class VectorStoreHandler(BaseHandler):
             CreateTable: self._dispatch_create_table,
             DropTables: self._dispatch_drop_table,
             Insert: self._dispatch_insert,
-            Update: self._dispatch_update,
+            Update: self.dispatch_update,
             Delete: self.dispatch_delete,
             Select: self.dispatch_select,
         }

mindsdb/integrations/utilities/rag/rerankers/reranker_compressor.py

@@ -54,7 +54,7 @@ class LLMReranker(BaseDocumentCompressor):
                 max_retries=2  # Client-level retries
             )
 
-    async def search_relevancy(self, query: str, document: str) -> Any:
+    async def search_relevancy(self, query: str, document: str, custom_event: bool = True) -> Any:
         await self._init_client()
 
         async with self._semaphore:
@@ -82,7 +82,8 @@ class LLMReranker(BaseDocumentCompressor):
                     }
 
                     # Stream reranking update.
-                    dispatch_custom_event("rerank", rerank_data)
+                    if custom_event:
+                        dispatch_custom_event("rerank", rerank_data)
                     return rerank_data
 
                 except Exception as e:
@@ -93,7 +94,7 @@ class LLMReranker(BaseDocumentCompressor):
                     retry_delay = self.retry_delay * (2 ** attempt) + random.uniform(0, 0.1)
                     await asyncio.sleep(retry_delay)
 
-    async def _rank(self, query_document_pairs: List[Tuple[str, str]]) -> List[Tuple[str, float]]:
+    async def _rank(self, query_document_pairs: List[Tuple[str, str]], custom_event: bool = True) -> List[Tuple[str, float]]:
         ranked_results = []
 
         # Process in larger batches for better throughput
@@ -102,7 +103,7 @@ class LLMReranker(BaseDocumentCompressor):
             batch = query_document_pairs[i:i + batch_size]
             try:
                 results = await asyncio.gather(
-                    *[self.search_relevancy(query=query, document=document) for (query, document) in batch],
+                    *[self.search_relevancy(query=query, document=document, custom_event=custom_event) for (query, document) in batch],
                     return_exceptions=True
                 )
 
@@ -227,16 +228,7 @@ class LLMReranker(BaseDocumentCompressor):
             "remove_irrelevant": self.remove_irrelevant,
         }
 
-    def get_scores(self, query: str, documents: list[str], disable_events: bool = True):
-        """
-        Get relevance scores for documents given a query.
-        Args:
-            query: The query text
-            documents: List of document texts to score
-            disable_events: Whether to disable event dispatching (default True)
-        Returns:
-            List of relevance scores
-        """
+    def get_scores(self, query: str, documents: list[str], custom_event: bool = False):
         query_document_pairs = [(query, doc) for doc in documents]
         # Create event loop and run async code
         import asyncio
@@ -246,89 +238,7 @@ class LLMReranker(BaseDocumentCompressor):
             # If no running loop exists, create a new one
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
-        # If disable_events is True, we need to modify the _rank function to not use dispatch_custom_event
-        if disable_events:
-            # Create a wrapper function that doesn't dispatch events
-            async def _rank_without_events(query_document_pairs):
-                ranked_results = []
-                # Process in larger batches for better throughput
-                batch_size = min(self.max_concurrent_requests * 2, len(query_document_pairs))
-                for i in range(0, len(query_document_pairs), batch_size):
-                    batch = query_document_pairs[i:i + batch_size]
-                    try:
-                        # Define a no-events version of search_relevancy inside this closure
-                        async def search_relevancy_no_events(query, document):
-                            await self._init_client()
-                            async with self._semaphore:
-                                for attempt in range(self.max_retries):
-                                    try:
-                                        response = await self.client.chat.completions.create(
-                                            model=self.model,
-                                            messages=[
-                                                {"role": "system", "content": "Rate the relevance of the document to the query. Respond with 'yes' or 'no'."},
-                                                {"role": "user", "content": f"Query: {query}\nDocument: {document}\nIs this document relevant?"}
-                                            ],
-                                            temperature=self.temperature,
-                                            n=1,
-                                            logprobs=True,
-                                            max_tokens=1
-                                        )
-                                        # Extract response and confidence score
-                                        answer = response.choices[0].message.content
-                                        logprob = response.choices[0].logprobs.content[0].logprob
-                                        # No event dispatch here
-                                        return {"document": document, "answer": answer, "logprob": logprob}
-                                    except Exception as e:
-                                        if attempt == self.max_retries - 1:
-                                            log.error(f"Failed after {self.max_retries} attempts: {str(e)}")
-                                            raise
-                                        # Exponential backoff with jitter
-                                        retry_delay = self.retry_delay * (2 ** attempt) + random.uniform(0, 0.1)
-                                        await asyncio.sleep(retry_delay)
-                        # Use our no-events version for this batch
-                        results = await asyncio.gather(
-                            *[search_relevancy_no_events(query=query, document=document) for (query, document) in batch],
-                            return_exceptions=True
-                        )
-                        for idx, result in enumerate(results):
-                            if isinstance(result, Exception):
-                                log.error(f"Error processing document {i+idx}: {str(result)}")
-                                ranked_results.append((batch[idx][1], 0.0))
-                                continue
-                            answer = result["answer"]
-                            logprob = result["logprob"]
-                            prob = math.exp(logprob)
-                            # Convert answer to score using the model's confidence
-                            if answer.lower().strip() == "yes":
-                                score = prob  # If yes, use the model's confidence
-                            elif answer.lower().strip() == "no":
-                                score = 1 - prob  # If no, invert the confidence
-                            else:
-                                score = 0.5 * prob  # For unclear answers, reduce confidence
-                            ranked_results.append((batch[idx][1], score))
-                            # Check if we should stop early
-                            try:
-                                high_scoring_docs = [r for r in ranked_results if r[1] >= self.filtering_threshold]
-                                can_stop_early = (
-                                    self.early_stop  # Early stopping is enabled
-                                    and self.num_docs_to_keep  # We have a target number of docs
-                                    and len(high_scoring_docs) >= self.num_docs_to_keep  # Found enough good docs
-                                    and score >= self.early_stop_threshold  # Current doc is good enough
-                                )
-                                if can_stop_early:
-                                    log.info(f"Early stopping after finding {self.num_docs_to_keep} documents with high confidence")
-                                    return ranked_results
-                            except Exception as e:
-                                # Don't let early stopping errors stop the whole process
-                                log.warning(f"Error in early stopping check: {str(e)}")
-                    except Exception as e:
-                        log.error(f"Batch processing error: {str(e)}")
-                        continue
-                return ranked_results
-            # Use our no-events version
-            documents_and_scores = loop.run_until_complete(_rank_without_events(query_document_pairs))
-        else:
-            # Use the original _rank method
-            documents_and_scores = loop.run_until_complete(self._rank(query_document_pairs))
+
+        documents_and_scores = loop.run_until_complete(self._rank(query_document_pairs, custom_event=custom_event))
         scores = [score for _, score in documents_and_scores]
         return scores

mindsdb/interfaces/database/log.py

@@ -1,21 +1,21 @@
+from typing import List
 from copy import deepcopy
 from abc import ABC, abstractmethod
-from typing import List, Union, Tuple
 from collections import OrderedDict
 
 import pandas as pd
-
 from mindsdb_sql_parser import parse_sql
 from mindsdb_sql_parser.ast import Select, Identifier, Star, BinaryOperation, Constant, Join, Function
 from mindsdb_sql_parser.utils import JoinType
+
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.integrations.utilities.query_traversal import query_traversal
-
 from mindsdb.utilities.functions import resolve_table_identifier
 from mindsdb.api.executor.utilities.sql import get_query_tables
 from mindsdb.utilities.exception import EntityNotExistsError
 import mindsdb.interfaces.storage.db as db
 from mindsdb.utilities.context import context as ctx
+from mindsdb.api.executor.datahub.classes.response import DataHubResponse
 from mindsdb.api.executor.datahub.classes.tables_row import (
     TABLES_ROW_TYPE,
     TablesRow,
@@ -223,8 +223,7 @@ class LogDBController:
             for table_name in self._tables.keys()
         ]
 
-    def query(self, query: Select = None, native_query: str = None,
-              session=None, return_as: str = 'split') -> Union[pd.DataFrame, Tuple[pd.DataFrame, list]]:
+    def query(self, query: Select = None, native_query: str = None, session=None) -> DataHubResponse:
         if native_query is not None:
             if query is not None:
                 raise Exception("'query' and 'native_query' arguments can not be used together")
@@ -286,12 +285,12 @@ class LogDBController:
                     df[df_column_name] = df[df_column_name].astype(column_type)
         # endregion
 
-        if return_as != 'split':
-            return df
-
         columns_info = [{
             'name': k,
             'type': v
         } for k, v in df.dtypes.items()]
 
-        return df, columns_info
+        return DataHubResponse(
+            data_frame=df,
+            columns=columns_info
+        )

mindsdb/interfaces/database/projects.py

@@ -137,14 +137,10 @@ class Project:
                 view_meta['query_ast'],
                 session=session
             )
-            result = sqlquery.fetch(view='dataframe')
-
+            df = sqlquery.fetched_data.to_df()
         finally:
             query_context_controller.release_context('view', view_meta['id'])
 
-        if result['success'] is False:
-            raise Exception(f"Cant execute view query: {view_meta['query_ast']}")
-        df = result['result']
         # remove duplicated columns
         df = df.loc[:, ~df.columns.duplicated()]