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

mindsdb/api/mysql/mysql_proxy/mysql_proxy.py

@@ -21,7 +21,8 @@ import sys
 import tempfile
 import traceback
 from functools import partial
-from typing import Dict, List
+from typing import Dict, List, Optional
+from dataclasses import dataclass
 
 from numpy import dtype as np_dtype
 from pandas.api import types as pd_types
@@ -71,6 +72,7 @@ from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import (
     TYPES,
     getConstName,
 )
+from mindsdb.api.executor.data_types.answer import ExecuteAnswer
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 from mindsdb.api.mysql.mysql_proxy.utilities import (
     ErWrongCharset,
@@ -93,24 +95,16 @@ def empty_fn():
     pass
 
 
+@dataclass
 class SQLAnswer:
-    def __init__(
-        self,
-        resp_type: RESPONSE_TYPE,
-        columns: List[Dict] = None,
-        data: List[Dict] = None,
-        status: int = None,
-        state_track: List[List] = None,
-        error_code: int = None,
-        error_message: str = None,
-    ):
-        self.resp_type = resp_type
-        self.columns = columns
-        self.data = data
-        self.status = status
-        self.state_track = state_track
-        self.error_code = error_code
-        self.error_message = error_message
+    resp_type: RESPONSE_TYPE = RESPONSE_TYPE.OK
+    columns: Optional[List[Dict]] = None
+    data: Optional[List[Dict]] = None   # resultSet ?
+    status: Optional[int] = None
+    state_track: Optional[List[List]] = None
+    error_code: Optional[int] = None
+    error_message: Optional[str] = None
+    affected_rows: Optional[int] = None
 
     @property
     def type(self):
@@ -333,7 +327,7 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
                 packages.append(self.last_packet())
             self.send_package_group(packages)
         elif answer.type == RESPONSE_TYPE.OK:
-            self.packet(OkPacket, state_track=answer.state_track).send()
+            self.packet(OkPacket, state_track=answer.state_track, affected_rows=answer.affected_rows).send()
         elif answer.type == RESPONSE_TYPE.ERROR:
             self.packet(
                 ErrPacket, err_code=answer.error_code, msg=answer.error_message
@@ -546,21 +540,23 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
     @profiler.profile()
     def process_query(self, sql):
         executor = Executor(session=self.session, sqlserver=self)
-
         executor.query_execute(sql)
+        executor_answer = executor.executor_answer
 
-        if executor.data is None:
+        if executor_answer.data is None:
             resp = SQLAnswer(
                 resp_type=RESPONSE_TYPE.OK,
-                state_track=executor.state_track,
+                state_track=executor_answer.state_track,
+                affected_rows=executor_answer.affected_rows
             )
         else:
             resp = SQLAnswer(
                 resp_type=RESPONSE_TYPE.TABLE,
-                state_track=executor.state_track,
-                columns=self.to_mysql_columns(executor.columns),
-                data=executor.data,
+                state_track=executor_answer.state_track,
+                columns=self.to_mysql_columns(executor_answer.data.columns),
+                data=executor_answer.data,
                 status=executor.server_status,
+                affected_rows=executor_answer.affected_rows
             )
 
         # Increment the counter and include metadata in attributes
@@ -604,18 +600,20 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
 
     def answer_stmt_execute(self, stmt_id, parameters):
         prepared_stmt = self.session.prepared_stmts[stmt_id]
-        executor = prepared_stmt["statement"]
+        executor: Executor = prepared_stmt["statement"]
 
         executor.stmt_execute(parameters)
 
-        if executor.data is None:
+        executor_answer: ExecuteAnswer = executor.executor_answer
+
+        if executor_answer.data is None:
             resp = SQLAnswer(
-                resp_type=RESPONSE_TYPE.OK, state_track=executor.state_track
+                resp_type=RESPONSE_TYPE.OK, state_track=executor_answer.state_track
             )
             return self.send_query_answer(resp)
 
         # TODO prepared_stmt['type'] == 'lock' is not used but it works
-        columns_def = self.to_mysql_columns(executor.columns)
+        columns_def = self.to_mysql_columns(executor_answer.data.columns)
         packages = [self.packet(ColumnCountPacket, count=len(columns_def))]
 
         packages.extend(self._get_column_defenition_packets(columns_def))
@@ -624,14 +622,14 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
             packages.append(self.packet(EofPacket, status=0x0062))
 
         # send all
-        for row in executor.data.to_lists():
+        for row in executor_answer.data.to_lists():
             packages.append(
                 self.packet(BinaryResultsetRowPacket, data=row, columns=columns_def)
             )
 
         server_status = executor.server_status or 0x0002
         packages.append(self.last_packet(status=server_status))
-        prepared_stmt["fetched"] += len(executor.data)
+        prepared_stmt["fetched"] += len(executor_answer.data)
 
         return self.send_package_group(packages)
 
@@ -639,23 +637,24 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
         prepared_stmt = self.session.prepared_stmts[stmt_id]
         executor = prepared_stmt["statement"]
         fetched = prepared_stmt["fetched"]
+        executor_answer: ExecuteAnswer = executor.executor_answer
 
-        if executor.data is None:
+        if executor_answer.data is None:
             resp = SQLAnswer(
-                resp_type=RESPONSE_TYPE.OK, state_track=executor.state_track
+                resp_type=RESPONSE_TYPE.OK, state_track=executor_answer.state_track
             )
             return self.send_query_answer(resp)
 
         packages = []
-        columns = self.to_mysql_columns(executor.columns)
-        for row in executor.data[fetched:limit].to_lists():
+        columns = self.to_mysql_columns(executor_answer.data.columns)
+        for row in executor_answer.data[fetched:limit].to_lists():
             packages.append(
                 self.packet(BinaryResultsetRowPacket, data=row, columns=columns)
             )
 
-        prepared_stmt["fetched"] += len(executor.data[fetched:limit])
+        prepared_stmt["fetched"] += len(executor_answer.data[fetched:limit])
 
-        if len(executor.data) <= limit + fetched:
+        if len(executor_answer.data) <= limit + fetched:
             status = sum(
                 [
                     SERVER_STATUS.SERVER_STATUS_AUTOCOMMIT,
@@ -772,6 +771,8 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
                 elif p.type.value == COMMANDS.COM_FIELD_LIST:
                     # this command is deprecated, but console client still use it.
                     response = SQLAnswer(RESPONSE_TYPE.OK)
+                elif p.type.value == COMMANDS.COM_STMT_RESET:
+                    response = SQLAnswer(RESPONSE_TYPE.OK)
                 else:
                     logger.warning("Command has no specific handler, return OK msg")
                     logger.debug(str(p))

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):
@@ -89,7 +94,7 @@ class VectorStoreHandler(BaseHandler):
         else:
             return value
 
-    def _extract_conditions(self, where_statement) -> Optional[List[FilterCondition]]:
+    def extract_conditions(self, where_statement) -> Optional[List[FilterCondition]]:
         conditions = []
         # parse conditions
         if where_statement is not None:
@@ -110,13 +115,7 @@ class VectorStoreHandler(BaseHandler):
                             right_hand = node.args[1].value
                     elif isinstance(node.args[1], Tuple):
                         # Constant could be actually a list i.e. [1.2, 3.2]
-                        right_hand = [
-                            ast.literal_eval(item.value)
-                            if isinstance(item, Constant)
-                            and not isinstance(item.value, list)
-                            else item.value
-                            for item in node.args[1].items
-                        ]
+                        right_hand = [item.value for item in node.args[1].items]
                     else:
                         raise Exception(f"Unsupported right hand side: {node.args[1]}")
                     conditions.append(
@@ -125,18 +124,21 @@ class VectorStoreHandler(BaseHandler):
 
             query_traversal(where_statement, _extract_comparison_conditions)
 
-            # try to treat conditions that are not in TableField as metadata conditions
-            for condition in conditions:
-                if not self._is_condition_allowed(condition):
-                    condition.column = (
-                        TableField.METADATA.value + "." + condition.column
-                    )
-
         else:
             conditions = None
 
         return conditions
 
+    def _convert_metadata_filters(self, conditions):
+        if conditions is None:
+            return
+        # try to treat conditions that are not in TableField as metadata conditions
+        for condition in conditions:
+            if not self._is_condition_allowed(condition):
+                condition.column = (
+                    TableField.METADATA.value + "." + condition.column
+                )
+
     def _is_columns_allowed(self, columns: List[str]) -> bool:
         """
         Check if columns are allowed.
@@ -234,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.
         """
@@ -253,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:
@@ -325,14 +334,16 @@ class VectorStoreHandler(BaseHandler):
         if not df_insert.empty:
             self.insert(table_name, df_insert)
 
-    def dispatch_delete(self, query: Delete):
+    def dispatch_delete(self, query: Delete, conditions: List[FilterCondition] = None):
         """
         Dispatch delete query to the appropriate method.
         """
         # parse key arguments
         table_name = query.table.parts[-1]
-        where_statement = query.where
-        conditions = self._extract_conditions(where_statement)
+        if conditions is None:
+            where_statement = query.where
+            conditions = self.extract_conditions(where_statement)
+        self._convert_metadata_filters(conditions)
 
         # dispatch delete
         return self.delete(table_name, conditions=conditions)
@@ -356,9 +367,10 @@ class VectorStoreHandler(BaseHandler):
             )
 
         # check if columns are allowed
-        where_statement = query.where
         if conditions is None:
-            conditions = self._extract_conditions(where_statement)
+            where_statement = query.where
+            conditions = self.extract_conditions(where_statement)
+        self._convert_metadata_filters(conditions)
 
         # get offset and limit
         offset = query.offset.value if query.offset is not None else None
@@ -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,
         }