MindsDB 25.9.2.0a1__py3-none-any.whl → 25.10.0rc1__py3-none-any.whl

mindsdb/api/executor/command_executor.py

@@ -49,6 +49,7 @@ from mindsdb_sql_parser.ast.mindsdb import (
     CreateDatabase,
     CreateJob,
     CreateKnowledgeBase,
+    AlterKnowledgeBase,
     CreateMLEngine,
     CreatePredictor,
     CreateSkill,
@@ -196,11 +197,13 @@ def match_two_part_name(
         ValueError: If the identifier does not contain one or two parts, or if ensure_lower_case is True and the name is not lowercase.
     """
     db_name = None
+
     match identifier.parts, identifier.is_quoted:
         case [name], [is_quoted]:
             ...
-        case [db_name, name], [_, is_quoted]:
-            ...
+        case [db_name, name], [db_is_quoted, is_quoted]:
+            if not db_is_quoted:
+                db_name = db_name.lower()
         case _:
             raise ValueError(f"Only single-part or two-part names are allowed: {identifier}")
     if not is_quoted:
@@ -655,6 +658,8 @@ class ExecuteCommands:
             return self.answer_drop_chatbot(statement, database_name)
         elif statement_type is CreateKnowledgeBase:
             return self.answer_create_kb(statement, database_name)
+        elif statement_type is AlterKnowledgeBase:
+            return self.answer_alter_kb(statement, database_name)
         elif statement_type is DropKnowledgeBase:
             return self.answer_drop_kb(statement, database_name)
         elif statement_type is CreateSkill:
@@ -710,9 +715,7 @@ class ExecuteCommands:
 
     def answer_create_trigger(self, statement, database_name):
         triggers_controller = TriggersController()
-        project_name, trigger_name = match_two_part_name(
-            statement.name, ensure_lower_case=True, default_db_name=database_name
-        )
+        project_name, trigger_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         triggers_controller.add(
             trigger_name,
@@ -726,9 +729,7 @@ class ExecuteCommands:
     def answer_drop_trigger(self, statement, database_name):
         triggers_controller = TriggersController()
 
-        name = statement.name
-        trigger_name = statement.name.parts[-1]
-        project_name = name.parts[-2] if len(name.parts) > 1 else database_name
+        project_name, trigger_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         triggers_controller.delete(trigger_name, project_name)
 
@@ -736,9 +737,7 @@ class ExecuteCommands:
 
     def answer_create_job(self, statement: CreateJob, database_name):
         jobs_controller = JobsController()
-        project_name, job_name = match_two_part_name(
-            statement.name, ensure_lower_case=True, default_db_name=database_name
-        )
+        project_name, job_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         try:
             jobs_controller.create(job_name, project_name, statement)
@@ -757,14 +756,12 @@ class ExecuteCommands:
         except EntityNotExistsError:
             if statement.if_exists is False:
                 raise
-        except Exception as e:
-            raise e
 
         return ExecuteAnswer()
 
     def answer_create_chatbot(self, statement, database_name):
         chatbot_controller = ChatBotController()
-        project_name, name = match_two_part_name(statement.name, ensure_lower_case=True, default_db_name=database_name)
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
         is_running = statement.params.pop("is_running", True)
 
@@ -796,9 +793,7 @@ class ExecuteCommands:
     def answer_update_chatbot(self, statement, database_name):
         chatbot_controller = ChatBotController()
 
-        name = statement.name
-        name_no_project = name.parts[-1]
-        project_name = name.parts[-2] if len(name.parts) > 1 else database_name
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
         # From SET keyword parameters
         updated_name = statement.params.pop("name", None)
@@ -815,7 +810,7 @@ class ExecuteCommands:
             database_id = database["id"]
 
         updated_chatbot = chatbot_controller.update_chatbot(
-            name_no_project,
+            name,
             project_name=project_name,
             name=updated_name,
             model_name=model_name,
@@ -825,16 +820,15 @@ class ExecuteCommands:
             params=statement.params,
         )
         if updated_chatbot is None:
-            raise ExecutorException(f"Chatbot with name {name_no_project} not found")
+            raise ExecutorException(f"Chatbot with name {name} not found")
         return ExecuteAnswer()
 
     def answer_drop_chatbot(self, statement, database_name):
         chatbot_controller = ChatBotController()
 
-        name = statement.name
-        project_name = name.parts[-2] if len(name.parts) > 1 else database_name
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
-        chatbot_controller.delete_chatbot(name.parts[-1], project_name=project_name)
+        chatbot_controller.delete_chatbot(name, project_name=project_name)
         return ExecuteAnswer()
 
     def answer_evaluate_metric(self, statement, database_name):
@@ -844,7 +838,7 @@ class ExecuteCommands:
         try:
             sqlquery = SQLQuery(statement.data, session=self.session, database=database_name)
         except Exception as e:
-            raise Exception(f'Nested query failed to execute with error: "{e}", please check and try again.')
+            raise Exception(f'Nested query failed to execute with error: "{e}", please check and try again.') from e
         df = sqlquery.fetched_data.to_df()
         df.columns = [str(t.alias) if hasattr(t, "alias") else str(t.parts[-1]) for t in statement.data.targets]
 
@@ -974,6 +968,10 @@ class ExecuteCommands:
             identifier.is_quoted = [False] + identifier.is_quoted
 
         database_name, model_name, model_version = resolve_model_identifier(identifier)
+        # at least two part in identifier
+        identifier.parts[0] = database_name
+        identifier.parts[1] = model_name
+
         if database_name is None:
             database_name = database_name
 
@@ -1161,7 +1159,7 @@ class ExecuteCommands:
         Raises:
             ValueError: If the ml_engine name format is invalid.
         """
-        name = match_one_part_name(statement.name, ensure_lower_case=True)
+        name = match_one_part_name(statement.name)
 
         handler = statement.handler
         params = statement.params
@@ -1210,7 +1208,7 @@ class ExecuteCommands:
             ast_drop = DropMLEngine(name=Identifier(name))
             self.answer_drop_ml_engine(ast_drop)
             logger.info(msg)
-            raise ExecutorException(msg)
+            raise ExecutorException(msg) from e
 
         return ExecuteAnswer()
 
@@ -1247,7 +1245,7 @@ class ExecuteCommands:
         Returns:
             ExecuteAnswer: 'ok' answer
         """
-        database_name = match_one_part_name(statement.name, ensure_lower_case=True)
+        database_name = match_one_part_name(statement.name)
 
         engine = (statement.engine or "mindsdb").lower()
 
@@ -1336,9 +1334,7 @@ class ExecuteCommands:
         Returns:
             ExecuteAnswer: answer for the command
         """
-        project_name, view_name = match_two_part_name(
-            statement.name, default_db_name=database_name, ensure_lower_case=isinstance(statement, CreateView)
-        )
+        project_name, view_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         query_str = statement.query_str
 
@@ -1390,10 +1386,15 @@ class ExecuteCommands:
                 case _:
                     raise ValueError(f"Invalid view name: {name}")
 
+            if not db_name_quoted:
+                database_name = database_name.lower()
+            if not view_name_quoted:
+                view_name = view_name.lower()
+
             project = self.session.database_controller.get_project(database_name, db_name_quoted)
 
             try:
-                project.drop_view(view_name, strict_case=view_name_quoted)
+                project.drop_view(view_name, strict_case=True)
             except EntityNotExistsError:
                 if statement.if_exists is not True:
                     raise
@@ -1407,9 +1408,7 @@ class ExecuteCommands:
                 "Please pass the model parameters as a JSON object in the embedding_model field."
             )
 
-        project_name, kb_name = match_two_part_name(
-            statement.name, ensure_lower_case=True, default_db_name=database_name
-        )
+        project_name, kb_name = match_two_part_name(statement.name, default_db_name=database_name)
 
         if statement.storage is not None:
             if len(statement.storage.parts) != 2:
@@ -1433,6 +1432,20 @@ class ExecuteCommands:
 
         return ExecuteAnswer()
 
+    def answer_alter_kb(self, statement: AlterKnowledgeBase, database_name: str):
+        project_name, kb_name = match_two_part_name(
+            statement.name, ensure_lower_case=True, default_db_name=database_name
+        )
+
+        # update the knowledge base
+        self.session.kb_controller.update(
+            name=kb_name,
+            project_name=project_name,
+            params=statement.params,
+        )
+
+        return ExecuteAnswer()
+
     def answer_drop_kb(self, statement: DropKnowledgeBase, database_name: str) -> ExecuteAnswer:
         project_name, kb_name = match_two_part_name(statement.name, default_db_name=database_name)
 
@@ -1446,7 +1459,7 @@ class ExecuteCommands:
         return ExecuteAnswer()
 
     def answer_create_skill(self, statement, database_name):
-        project_name, name = match_two_part_name(statement.name, ensure_lower_case=True, default_db_name=database_name)
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
         try:
             _ = self.session.skills_controller.add_skill(name, project_name, statement.type, statement.params)
@@ -1482,7 +1495,7 @@ class ExecuteCommands:
         return ExecuteAnswer()
 
     def answer_create_agent(self, statement, database_name):
-        project_name, name = match_two_part_name(statement.name, ensure_lower_case=True, default_db_name=database_name)
+        project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
         skills = statement.params.pop("skills", [])
         provider = statement.params.pop("provider", None)
@@ -1538,11 +1551,9 @@ class ExecuteCommands:
 
     @mark_process("learn")
     def answer_create_predictor(self, statement: CreatePredictor, database_name: str):
-        integration_name, model_name = match_two_part_name(
-            statement.name, ensure_lower_case=True, default_db_name=database_name
-        )
+        integration_name, model_name = match_two_part_name(statement.name, default_db_name=database_name)
 
-        statement.name.parts = [integration_name.lower(), model_name]
+        statement.name.parts = [integration_name, model_name]
         statement.name.is_quoted = [False, False]
 
         ml_integration_name = "lightwood"  # default
@@ -2018,7 +2029,7 @@ class ExecuteCommands:
         else:
             # drop model
             try:
-                project = self.session.database_controller.get_project(project_name)
+                project = self.session.database_controller.get_project(project_name, strict_case=True)
                 project.drop_model(model_name)
             except Exception as e:
                 if not statement.if_exists:

mindsdb/api/executor/datahub/datanodes/datanode.py

@@ -4,7 +4,7 @@ from mindsdb.api.executor.datahub.classes.response import DataHubResponse
 
 
 class DataNode:
-    type = 'meta'
+    type = "meta"
 
     def __init__(self):
         pass
@@ -21,5 +21,5 @@ class DataNode:
     def get_table_columns_names(self, table_name: str, schema_name: str | None = None) -> list[str]:
         pass
 
-    def query(self, query=None, native_query=None, session=None) -> DataHubResponse:
+    def query(self, query=None, session=None) -> DataHubResponse:
         pass

mindsdb/api/executor/datahub/datanodes/information_schema_datanode.py

@@ -94,17 +94,7 @@ class InformationSchemaDataNode(DataNode):
         self.integration_controller = session.integration_controller
         self.project_controller = ProjectController()
         self.database_controller = session.database_controller
-
-        self.persis_datanodes = {"log": self.database_controller.logs_db_controller}
-
-        databases = self.database_controller.get_dict()
-        if "files" in databases:
-            self.persis_datanodes["files"] = IntegrationDataNode(
-                "files",
-                ds_type="file",
-                integration_controller=self.session.integration_controller,
-            )
-
+        self.persist_datanodes_names = ("log", "files")
         self.tables = {t.name: t for t in self.tables_list}
 
     def __getitem__(self, key):
@@ -119,8 +109,12 @@ class InformationSchemaDataNode(DataNode):
         if name_lower == "log":
             return self.database_controller.get_system_db("log")
 
-        if name_lower in self.persis_datanodes:
-            return self.persis_datanodes[name_lower]
+        if name_lower == "files":
+            return IntegrationDataNode(
+                "files",
+                ds_type="file",
+                integration_controller=self.session.integration_controller,
+            )
 
         existing_databases_meta = self.database_controller.get_dict()  # filter_type='project'
         database_name = None

mindsdb/api/executor/datahub/datanodes/integration_datanode.py

@@ -1,5 +1,6 @@
 import time
 import inspect
+import functools
 from dataclasses import astuple
 from typing import Iterable, List
 
@@ -20,7 +21,7 @@ from mindsdb.integrations.utilities.utils import get_class_name
 from mindsdb.metrics import metrics
 from mindsdb.utilities import log
 from mindsdb.utilities.profiler import profiler
-from mindsdb.utilities.exception import format_db_error_message
+from mindsdb.utilities.exception import QueryError
 from mindsdb.api.executor.datahub.datanodes.system_tables import infer_mysql_type
 
 logger = log.getLogger(__name__)
@@ -30,6 +31,51 @@ class DBHandlerException(Exception):
     pass
 
 
+def collect_metrics(func):
+    """Decorator for collecting performance metrics if integration handler query.
+
+    The decorator measures:
+    - Query execution time using high-precision performance counter
+    - Response size (number of rows returned)
+
+    Args:
+        func: The function to be decorated (integration handler method)
+
+    Returns:
+        function: Wrapped function that includes metrics collection and error handling
+    """
+
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        try:
+            time_before_query = time.perf_counter()
+            result = func(self, *args, **kwargs)
+
+            # metrics
+            handler_class_name = get_class_name(self.integration_handler)
+            elapsed_seconds = time.perf_counter() - time_before_query
+            query_time_with_labels = metrics.INTEGRATION_HANDLER_QUERY_TIME.labels(handler_class_name, result.type)
+            query_time_with_labels.observe(elapsed_seconds)
+
+            num_rows = 0
+            if result.data_frame is not None:
+                num_rows = len(result.data_frame.index)
+            response_size_with_labels = metrics.INTEGRATION_HANDLER_RESPONSE_SIZE.labels(
+                handler_class_name, result.type
+            )
+            response_size_with_labels.observe(num_rows)
+            logger.debug(f"Handler '{handler_class_name}' returned {num_rows} rows in {elapsed_seconds:.3f} seconds")
+        except Exception as e:
+            msg = str(e).strip()
+            if msg == "":
+                msg = e.__class__.__name__
+            msg = f"[{self.ds_type}/{self.integration_name}]: {msg}"
+            raise DBHandlerException(msg) from e
+        return result
+
+    return wrapper
+
+
 class IntegrationDataNode(DataNode):
     type = "integration"
 
@@ -46,16 +92,10 @@ class IntegrationDataNode(DataNode):
         response = self.integration_handler.get_tables()
         if response.type == RESPONSE_TYPE.TABLE:
             result_dict = response.data_frame.to_dict(orient="records")
-            result = []
-            for row in result_dict:
-                result.append(TablesRow.from_dict(row))
-            return result
+            return [TablesRow.from_dict(row) for row in result_dict]
         else:
             raise Exception(f"Can't get tables: {response.error_message}")
 
-        result_dict = response.data_frame.to_dict(orient="records")
-        return [TablesRow.from_dict(row) for row in result_dict]
-
     def get_table_columns_df(self, table_name: str, schema_name: str | None = None) -> pd.DataFrame:
         """Get a DataFrame containing representation of information_schema.columns for the specified table.
 
@@ -84,7 +124,7 @@ class IntegrationDataNode(DataNode):
         df.columns = [name.upper() for name in df.columns]
         if "FIELD" not in df.columns or "TYPE" not in df.columns:
             logger.warning(
-                f"Response from the handler's `get_columns` call does not contain required columns: f{df.columns}"
+                f"Response from the handler's `get_columns` call does not contain required columns: {list(df.columns)}"
             )
             return pd.DataFrame([], columns=astuple(INF_SCHEMA_COLUMNS_NAMES))
 
@@ -214,50 +254,54 @@ class IntegrationDataNode(DataNode):
         return self.integration_handler.query_stream(query, fetch_size=fetch_size)
 
     @profiler.profile()
-    def query(self, query: ASTNode | None = None, native_query: str | None = None, session=None) -> DataHubResponse:
-        try:
-            time_before_query = time.perf_counter()
-            if query is not None:
-                result: HandlerResponse = self.integration_handler.query(query)
-            else:
-                # try to fetch native query
-                result: HandlerResponse = self.integration_handler.native_query(native_query)
+    def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
+        """Execute a query against the integration data source.
 
-            # metrics
-            elapsed_seconds = time.perf_counter() - time_before_query
-            query_time_with_labels = metrics.INTEGRATION_HANDLER_QUERY_TIME.labels(
-                get_class_name(self.integration_handler), result.type
-            )
-            query_time_with_labels.observe(elapsed_seconds)
+        This method processes SQL queries either as ASTNode objects or raw SQL strings
 
-            num_rows = 0
-            if result.data_frame is not None:
-                num_rows = len(result.data_frame.index)
-            response_size_with_labels = metrics.INTEGRATION_HANDLER_RESPONSE_SIZE.labels(
-                get_class_name(self.integration_handler), result.type
-            )
-            response_size_with_labels.observe(num_rows)
-        except Exception as e:
-            msg = str(e).strip()
-            if msg == "":
-                msg = e.__class__.__name__
-            msg = f"[{self.ds_type}/{self.integration_name}]: {msg}"
-            raise DBHandlerException(msg) from e
+        Args:
+            query (ASTNode | str, optional): The query to execute. Can be either:
+                - ASTNode: A parsed SQL query object
+                - str: Raw SQL query string
+            session: Session object (currently unused but kept for compatibility)
+
+        Returns:
+            DataHubResponse: Response object
+
+        Raises:
+            NotImplementedError: If query is not ASTNode or str type
+            Exception: If the query execution fails with an error response
+        """
+        if isinstance(query, ASTNode):
+            result: HandlerResponse = self.query_integration_handler(query=query)
+        elif isinstance(query, str):
+            result: HandlerResponse = self.native_query_integration(query=query)
+        else:
+            raise NotImplementedError("Thew query argument must be ASTNode or string type")
 
         if result.type == RESPONSE_TYPE.ERROR:
-            failed_sql_query = native_query
-            if query is not None:
-                failed_sql_query = query.to_string()
-
-            raise Exception(
-                format_db_error_message(
-                    db_name=self.integration_handler.name,
-                    db_type=self.integration_handler.__class__.name,
-                    db_error_msg=result.error_message,
-                    failed_query=failed_sql_query,
-                )
+            if isinstance(query, ASTNode):
+                try:
+                    query_str = query.to_string()
+                except Exception:
+                    # most likely it is CreateTable with exotic column types
+                    query_str = "can't be dump"
+            else:
+                query_str = query
+
+            exception = QueryError(
+                db_name=self.integration_handler.name,
+                db_type=self.integration_handler.__class__.name,
+                db_error_msg=result.error_message,
+                failed_query=query_str,
+                is_expected=result.is_expected_error,
             )
 
+            if result.exception is None:
+                raise exception
+            else:
+                raise exception from result.exception
+
         if result.type == RESPONSE_TYPE.OK:
             return DataHubResponse(affected_rows=result.affected_rows)
 
@@ -271,8 +315,8 @@ class IntegrationDataNode(DataNode):
             # replace python's Nan, np.NaN, np.nan and pd.NA to None
             # TODO keep all NAN to the end of processing, bacause replacing also changes dtypes
             df.replace([np.NaN, pd.NA, pd.NaT], None, inplace=True)
-        except Exception as e:
-            logger.error(f"Issue with clearing DF from NaN values: {e}")
+        except Exception:
+            logger.exception("Issue with clearing DF from NaN values:")
         # endregion
 
         columns_info = [{"name": k, "type": v} for k, v in df.dtypes.items()]
@@ -280,3 +324,11 @@ class IntegrationDataNode(DataNode):
         return DataHubResponse(
             data_frame=df, columns=columns_info, affected_rows=result.affected_rows, mysql_types=result.mysql_types
         )
+
+    @collect_metrics
+    def query_integration_handler(self, query: ASTNode) -> HandlerResponse:
+        return self.integration_handler.query(query)
+
+    @collect_metrics
+    def native_query_integration(self, query: str) -> HandlerResponse:
+        return self.integration_handler.native_query(query)

mindsdb/api/executor/datahub/datanodes/project_datanode.py

@@ -2,6 +2,7 @@ from copy import deepcopy
 from dataclasses import astuple
 
 import pandas as pd
+from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb_sql_parser import parse_sql
 from mindsdb_sql_parser.ast import (
     BinaryOperation,
@@ -99,9 +100,9 @@ class ProjectDataNode(DataNode):
 
         return ml_handler.predict(model_name, df, project_name=self.project.name, version=version, params=params)
 
-    def query(self, query=None, native_query=None, session=None) -> DataHubResponse:
-        if query is None and native_query is not None:
-            query = parse_sql(native_query)
+    def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
+        if isinstance(query, str):
+            query = parse_sql(query)
 
         if isinstance(query, Update):
             query_table = query.table.parts[0].lower()
@@ -132,7 +133,10 @@ class ProjectDataNode(DataNode):
                 case [query_table, str(version)], [is_quoted, _] if version.isdigit():
                     ...
                 case _:
-                    raise ValueError("Table name should contain only one part")
+                    raise EntityNotExistsError(
+                        f"Table '{query.from_table}' not found in the database. The project database support only single-part names",
+                        self.project.name,
+                    )
 
             if not is_quoted:
                 query_table = query_table.lower()

mindsdb/api/executor/datahub/datanodes/system_tables.py

@@ -102,9 +102,10 @@ class TablesTable(Table):
             row = TablesRow(TABLE_TYPE=TABLES_ROW_TYPE.SYSTEM_VIEW, TABLE_NAME=name)
             data.append(row.to_list())
 
-        for ds_name, ds in inf_schema.persis_datanodes.items():
+        for ds_name in inf_schema.persist_datanodes_names:
             if databases is not None and ds_name not in databases:
                 continue
+            ds = inf_schema.get(ds_name)
 
             if hasattr(ds, "get_tables_rows"):
                 ds_tables = ds.get_tables_rows()
@@ -131,7 +132,7 @@ class TablesTable(Table):
                     row.TABLE_SCHEMA = ds_name
                     data.append(row.to_list())
             except Exception:
-                logger.error(f"Can't get tables from '{ds_name}'")
+                logger.exception(f"Can't get tables from '{ds_name}'")
 
         for project_name in inf_schema.get_projects_names():
             if databases is not None and project_name not in databases:

mindsdb/api/executor/exceptions.py

@@ -1,39 +1,58 @@
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import ERR
 
 
 # base exception for unknown error
 class UnknownError(Exception):
-    # err_code = ERR.ER_UNKNOWN_ERROR
-    pass
+    mysql_error_code = ERR.ER_UNKNOWN_ERROR
+    is_expected = False
 
 
 # base exception for known error
 class ExecutorException(Exception):
-    pass
+    mysql_error_code = ERR.ER_UNKNOWN_ERROR
+    is_expected = False
 
 
 class NotSupportedYet(ExecutorException):
-    pass
+    mysql_error_code = ERR.ER_NOT_SUPPORTED_YET
+    is_expected = True
 
 
 class BadDbError(ExecutorException):
-    pass
+    mysql_error_code = ERR.ER_BAD_DB_ERROR
+    is_expected = True
 
 
 class BadTableError(ExecutorException):
-    pass
+    mysql_error_code = ERR.ER_BAD_DB_ERROR
+    is_expected = True
 
 
 class KeyColumnDoesNotExist(ExecutorException):
-    pass
+    mysql_error_code = ERR.ER_KEY_COLUMN_DOES_NOT_EXIST
+    is_expected = True
 
 
 class TableNotExistError(ExecutorException):
-    pass
+    mysql_error_code = ERR.ER_TABLE_EXISTS_ERROR
+    is_expected = True
 
 
 class WrongArgumentError(ExecutorException):
-    pass
+    mysql_error_code = ERR.ER_WRONG_ARGUMENTS
+    is_expected = True
 
 
 class LogicError(ExecutorException):
-    pass
+    mysql_error_code = ERR.ER_WRONG_USAGE
+    is_expected = True
+
+
+class SqlSyntaxError(ExecutorException):
+    err_code = ERR.ER_SYNTAX_ERROR
+    is_expected = True
+
+
+class WrongCharsetError(ExecutorException):
+    err_code = ERR.ER_UNKNOWN_CHARACTER_SET
+    is_expected = True