MindsDB 25.9.3rc1__py3-none-any.whl → 25.10.0rc1__py3-none-any.whl

mindsdb/api/http/initialize.py

@@ -8,8 +8,7 @@ from http import HTTPStatus
 
 
 import requests
-from flask import Flask, url_for, make_response, request, send_from_directory
-from flask.json import dumps
+from flask import Flask, url_for, request, send_from_directory
 from flask_compress import Compress
 from flask_restx import Api
 from werkzeug.exceptions import HTTPException
@@ -47,7 +46,7 @@ from mindsdb.metrics.server import init_metrics
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
-from mindsdb.utilities.json_encoder import CustomJSONProvider
+from mindsdb.utilities.json_encoder import ORJSONProvider
 from mindsdb.utilities.ps import is_pid_listen_port, wait_func_is_true
 from mindsdb.utilities.sentry import sentry_sdk  # noqa: F401
 from mindsdb.utilities.otel import trace  # noqa: F401
@@ -88,14 +87,8 @@ class Swagger_Api(Api):
         return url_for(self.endpoint("specs"), _external=False)
 
 
-def custom_output_json(data, code, headers=None):
-    resp = make_response(dumps(data, cls=CustomJSONProvider), code)
-    resp.headers.extend(headers or {})
-    return resp
-
-
 def get_last_compatible_gui_version() -> Version | bool:
-    logger.debug("Getting last compatible frontend..")
+    logger.debug("Getting last compatible frontend...")
     try:
         res = requests.get(
             "https://mindsdb-web-builds.s3.amazonaws.com/compatible-config.json",
@@ -154,7 +147,7 @@ def get_last_compatible_gui_version() -> Version | bool:
                 all_lower_versions = [parse_version(x) for x in lower_versions.keys()]
                 gui_version_lv = gui_versions[all_lower_versions[-1].base_version]
     except Exception:
-        logger.exception("Error in compatible-config.json structure:")
+        logger.exception("Error in compatible-config.json structure")
         return False
 
     logger.debug(f"Last compatible frontend version: {gui_version_lv}.")
@@ -178,7 +171,6 @@ def get_current_gui_version() -> Version:
 
 
 def initialize_static():
-    logger.debug("Initializing static..")
     last_gui_version_lv = get_last_compatible_gui_version()
     current_gui_version_lv = get_current_gui_version()
     required_gui_version = config["gui"].get("version")
@@ -206,22 +198,28 @@ def initialize_static():
     return success
 
 
-def initialize_app():
+def initialize_app(is_restart: bool = False):
     static_root = config["paths"]["static"]
     logger.debug(f"Static route: {static_root}")
-    gui_exists = Path(static_root).joinpath("index.html").is_file()
-    logger.debug(f"Does GUI already exist.. {'YES' if gui_exists else 'NO'}")
     init_static_thread = None
+    if not is_restart:
+        gui_exists = Path(static_root).joinpath("index.html").is_file()
+        logger.debug(f"Does GUI already exist.. {'YES' if gui_exists else 'NO'}")
+
+        if config["gui"]["autoupdate"] is True or (config["gui"]["open_on_start"] is True and gui_exists is False):
+            logger.debug("Initializing static...")
+            init_static_thread = threading.Thread(target=initialize_static, name="initialize_static")
+            init_static_thread.start()
+        else:
+            logger.debug(f"Skip initializing static: config['gui']={config['gui']}, gui_exists={gui_exists}")
 
-    if config["gui"]["autoupdate"] is True or (config["gui"]["open_on_start"] is True and gui_exists is False):
-        init_static_thread = threading.Thread(target=initialize_static, name="initialize_static")
-        init_static_thread.start()
+    app, api = initialize_flask()
 
-    # Wait for static initialization.
-    if config["gui"]["open_on_start"] is True and init_static_thread is not None:
-        init_static_thread.join()
+    if not is_restart and config["gui"]["open_on_start"]:
+        if init_static_thread is not None:
+            init_static_thread.join()
+        open_gui(init_static_thread)
 
-    app, api = initialize_flask(config, init_static_thread)
     Compress(app)
 
     initialize_interfaces(app)
@@ -240,22 +238,30 @@ def initialize_app():
                 "The endpoint you are trying to access does not exist on the server.",
             )
 
-        # Normalize the path.
-        full_path = os.path.normpath(os.path.join(static_root, path))
+        try:
+            # Ensure the requested path is within the static directory
+            # https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.is_relative_to
+            requested_path = (static_root / path).resolve()
+
+            if not requested_path.is_relative_to(static_root.resolve()):
+                return http_error(
+                    HTTPStatus.FORBIDDEN,
+                    "Forbidden",
+                    "You are not allowed to access the requested resource.",
+                )
+
+            if requested_path.is_file():
+                return send_from_directory(static_root, path)
+            else:
+                return send_from_directory(static_root, "index.html")
 
-        # Check for directory traversal attacks.
-        if not full_path.startswith(str(static_root)):
+        except (ValueError, OSError):
             return http_error(
-                HTTPStatus.FORBIDDEN,
-                "Forbidden",
-                "You are not allowed to access the requested resource.",
+                HTTPStatus.BAD_REQUEST,
+                "Bad Request",
+                "Invalid path requested.",
             )
 
-        if os.path.isfile(full_path):
-            return send_from_directory(static_root, path)
-        else:
-            return send_from_directory(static_root, "index.html")
-
     protected_namespaces = [
         tab_ns,
         utils_ns,
@@ -309,7 +315,6 @@ def initialize_app():
 
     @app.before_request
     def before_request():
-        logger.debug(f"HTTP {request.method}: {request.path}")
         ctx.set_default()
 
         h = request.headers.get("Authorization")
@@ -348,15 +353,15 @@ def initialize_app():
         if company_id is not None:
             try:
                 company_id = int(company_id)
-            except Exception:
-                logger.exception(f"Could not parse company id: {company_id} | exception:")
+            except Exception as e:
+                logger.error(f"Could not parse company id: {company_id} | exception: {e}")
                 company_id = None
 
         if user_class is not None:
             try:
                 user_class = int(user_class)
-            except Exception:
-                logger.exception(f"Could not parse user_class: {user_class} | exception:")
+            except Exception as e:
+                logger.error(f"Could not parse user_class: {user_class} | exception: {e}")
                 user_class = 0
         else:
             user_class = 0
@@ -370,8 +375,8 @@ def initialize_app():
     return app
 
 
-def initialize_flask(config, init_static_thread):
-    logger.debug("Initializing flask..")
+def initialize_flask():
+    logger.debug("Initializing flask...")
     # region required for windows https://github.com/mindsdb/mindsdb/issues/2526
     mimetypes.add_type("text/css", ".css")
     mimetypes.add_type("text/javascript", ".js")
@@ -392,7 +397,7 @@ def initialize_flask(config, init_static_thread):
 
     app.config["SEND_FILE_MAX_AGE_DEFAULT"] = 60
     app.config["SWAGGER_HOST"] = "http://localhost:8000/mindsdb"
-    app.json = CustomJSONProvider()
+    app.json = ORJSONProvider(app)
 
     authorizations = {"apikey": {"type": "apiKey", "in": "header", "name": "Authorization"}}
 
@@ -406,30 +411,41 @@ def initialize_flask(config, init_static_thread):
         doc="/doc/",
     )
 
-    api.representations["application/json"] = custom_output_json
+    def __output_json_orjson(data, code, headers=None):
+        from flask import current_app, make_response
 
-    port = config["api"]["http"]["port"]
-    host = config["api"]["http"]["host"]
+        dumped = current_app.json.dumps(data)
+        resp = make_response(dumped, code)
+        if headers:
+            resp.headers.extend(headers)
+        resp.mimetype = "application/json"
+        return resp
 
-    if config["gui"]["open_on_start"]:
-        if host in ("", "0.0.0.0"):
-            url = f"http://127.0.0.1:{port}/"
-        else:
-            url = f"http://{host}:{port}/"
-        logger.info(f" - GUI available at {url}")
-
-        pid = os.getpid()
-        thread = threading.Thread(
-            target=_open_webbrowser,
-            args=(url, pid, port, init_static_thread, config["paths"]["static"]),
-            daemon=True,
-            name="open_webbrowser",
-        )
-        thread.start()
+    api.representations["application/json"] = __output_json_orjson
 
     return app, api
 
 
+def open_gui(init_static_thread):
+    port = config["api"]["http"]["port"]
+    host = config["api"]["http"]["host"]
+
+    if host in ("", "0.0.0.0"):
+        url = f"http://127.0.0.1:{port}/"
+    else:
+        url = f"http://{host}:{port}/"
+    logger.info(f" - GUI available at {url}")
+
+    pid = os.getpid()
+    thread = threading.Thread(
+        target=_open_webbrowser,
+        args=(url, pid, port, init_static_thread, config["paths"]["static"]),
+        daemon=True,
+        name="open_webbrowser",
+    )
+    thread.start()
+
+
 def initialize_interfaces(app):
     app.integration_controller = integration_controller
     app.database_controller = DatabaseController()

mindsdb/api/http/namespaces/agents.py

@@ -26,9 +26,6 @@ def create_agent(project_name, name, agent):
     if name is None:
         return http_error(HTTPStatus.BAD_REQUEST, "Missing field", 'Missing "name" field for agent')
 
-    if not name.islower():
-        return http_error(HTTPStatus.BAD_REQUEST, "Wrong name", f"The name must be in lower case: {name}")
-
     model_name = agent.get("model_name")
     provider = agent.get("provider")
     skills = agent.get("skills", [])

mindsdb/api/http/namespaces/chatbots.py

@@ -18,9 +18,6 @@ def create_chatbot(project_name, name, chatbot):
     if name is None:
         return http_error(HTTPStatus.BAD_REQUEST, "Missing field", 'Missing "name" field for chatbot')
 
-    if not name.islower():
-        return http_error(HTTPStatus.BAD_REQUEST, "Wrong name", f"The name must be in lower case: {name}")
-
     model_name = chatbot.get("model_name", None)
     agent_name = chatbot.get("agent_name", None)
     if model_name is None and agent_name is None:
@@ -241,8 +238,6 @@ class ChatBotResource(Resource):
                         "Chatbot already exists",
                         f"Chatbot with name {name} already exists. Please choose a different one.",
                     )
-            if not name.islower():
-                return http_error(HTTPStatus.BAD_REQUEST, "Wrong name", f"The name must be in lower case: {name}")
 
         if existing_chatbot is None:
             # Create

mindsdb/api/http/namespaces/file.py

@@ -196,6 +196,8 @@ class File(Resource):
                 return http_error(400, "Wrong content.", "Archive must contain data file in root.")
 
         try:
+            if not Path(mindsdb_file_name).suffix == "":
+                return http_error(400, "Error", "File name cannot contain extension.")
             ca.file_controller.save_file(mindsdb_file_name, file_path, file_name=original_file_name)
         except FileProcessingError as e:
             return http_error(400, "Error", str(e))

mindsdb/api/http/namespaces/handlers.py

@@ -125,11 +125,16 @@ def prepare_formdata():
         params[name] = value
 
     def on_file(file):
-        file_name = file.field_name.decode()
-        if file_name not in ("code", "modules"):
-            raise ValueError(f"Wrong field name: {file_name}")
-        params[file_name] = file.file_object
-        file_names.append(file_name)
+        file_name = file.file_name.decode()
+        if Path(file_name).name != file_name:
+            raise ValueError(f"Wrong file name: {file_name}")
+
+        field_name = file.field_name.decode()
+        if field_name not in ("code", "modules"):
+            raise ValueError(f"Wrong field name: {field_name}")
+
+        params[field_name] = file.file_object
+        file_names.append(field_name)
 
     temp_dir_path = tempfile.mkdtemp(prefix="mindsdb_file_")
 

mindsdb/api/http/namespaces/knowledge_bases.py

@@ -241,6 +241,26 @@ class KnowledgeBaseResource(Resource):
             if kb_data.get("query"):
                 table.insert_query_result(kb_data["query"], project_name)
 
+            # update KB
+            update_kb_data = {}
+            if "params" in kb_data:
+                allowed_keys = [
+                    "id_column",
+                    "metadata_columns",
+                    "content_columns",
+                    "preprocessing",
+                    "reranking_model",
+                    "embedding_model",
+                ]
+                update_kb_data = {k: v for k, v in kb_data["params"].items() if k in allowed_keys}
+            if update_kb_data or "preprocessing" in kb_data:
+                session.kb_controller.update(
+                    knowledge_base_name,
+                    project.name,
+                    params=update_kb_data,
+                    preprocessing_config=kb_data.get("preprocessing"),
+                )
+
         except ExecutorException as e:
             logger.exception("Error during preprocessing and insertion:")
             return http_error(

mindsdb/api/http/namespaces/sql.py

@@ -63,13 +63,13 @@ class Query(Resource):
                 }
                 logger.warning(f"Error query processing: {e}")
             except QueryError as e:
-                error_type = "expected" if e.is_acceptable else "unexpected"
+                error_type = "expected" if e.is_expected else "unexpected"
                 query_response = {
                     "type": SQL_RESPONSE_TYPE.ERROR,
                     "error_code": 0,
                     "error_message": str(e),
                 }
-                if e.is_acceptable:
+                if e.is_expected:
                     logger.warning(f"Query failed due to expected reason: {e}")
                 else:
                     logger.exception("Error query processing:")

mindsdb/api/http/start.py

@@ -23,12 +23,12 @@ gc.enable()
 logger = log.getLogger(__name__)
 
 
-def start(verbose, app: Flask = None):
+def start(verbose, app: Flask = None, is_restart: bool = False):
     db.init()
     init_lexer_parsers()
 
     if app is None:
-        app = initialize_app()
+        app = initialize_app(is_restart)
 
     port = config["api"]["http"]["port"]
     host = config["api"]["http"]["host"]

mindsdb/api/mysql/mysql_proxy/utilities/dump.py

@@ -4,6 +4,7 @@ from typing import Any
 from array import array
 
 import numpy as np
+import orjson
 from numpy import dtype as np_dtype
 import pandas as pd
 from pandas.api import types as pd_types
@@ -21,7 +22,8 @@ from mindsdb.utilities.json_encoder import CustomJSONEncoder
 
 logger = log.getLogger(__name__)
 
-json_encoder = CustomJSONEncoder()
+# Pre-bind default encoder for custom types so we can serialize JSON consistently
+_default_json = CustomJSONEncoder().default
 
 
 def column_to_mysql_column_dict(column: Column, database_name: str | None = None) -> dict[str, str | int]:
@@ -115,7 +117,11 @@ def _dump_str(var: Any) -> str | None:
             return str(var)[2:-1]
     if isinstance(var, (dict, list)):
         try:
-            return json_encoder.encode(var)
+            return orjson.dumps(
+                var,
+                default=_default_json,
+                option=orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_PASSTHROUGH_DATETIME,
+            ).decode("utf-8")
         except Exception:
             return str(var)
     # pd.isna returns array of bools for list

mindsdb/integrations/handlers/byom_handler/byom_handler.py

@@ -1,10 +1,9 @@
 """BYOM: Bring Your Own Model
 
 env vars to contloll BYOM:
- - MINDSDB_BYOM_ENABLED - can BYOM be uysed or not. Locally enabled by default.
+ - MINDSDB_BYOM_ENABLED - can BYOM be used or not. Locally enabled by default.
  - MINDSDB_BYOM_INHOUSE_ENABLED - enable or disable 'inhouse' BYOM usage. Locally enabled by default.
  - MINDSDB_BYOM_DEFAULT_TYPE - [inhouse|venv] default byom type. Locally it is 'venv' by default.
- - MINDSDB_BYOM_TYPE - [safe|unsafe] - obsolete, same as above.
 """
 
 import os
@@ -73,15 +72,8 @@ class BYOMHandler(BaseMLEngine):
             self._default_byom_type = BYOM_TYPE.VENV
             if os.environ.get("MINDSDB_BYOM_DEFAULT_TYPE") is not None:
                 self._default_byom_type = BYOM_TYPE[os.environ.get("MINDSDB_BYOM_DEFAULT_TYPE").upper()]
-            else:
-                env_var = os.environ.get("MINDSDB_BYOM_DEFAULT_TYPE")
-                if env_var == "SAVE":
-                    self._default_byom_type = BYOM_TYPE["VENV"]
-                elif env_var == "UNSAVE":
-                    self._default_byom_type = BYOM_TYPE["INHOUSE"]
-                else:
-                    raise KeyError
         except KeyError:
+            logger.warning(f"Wrong value of env var MINDSDB_BYOM_DEFAULT_TYPE, {BYOM_TYPE.VENV} will be used")
             self._default_byom_type = BYOM_TYPE.VENV
         # endregion
 

mindsdb/integrations/handlers/databricks_handler/databricks_handler.py

@@ -1,24 +1,50 @@
 from typing import Text, Dict, Any, Optional
 
+import pandas as pd
 from databricks.sql import connect, RequestError, ServerOperationError
 from databricks.sql.client import Connection
 from databricks.sqlalchemy import DatabricksDialect
 from mindsdb_sql_parser.ast.base import ASTNode
-from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
-import pandas as pd
 
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.integrations.libs.base import DatabaseHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
     RESPONSE_TYPE,
+    INF_SCHEMA_COLUMNS_NAMES_SET,
 )
 from mindsdb.utilities import log
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 
 logger = log.getLogger(__name__)
 
 
+def _map_type(internal_type_name: str | None) -> MYSQL_DATA_TYPE:
+    """Map MyDatabricks SQL text types names to MySQL types as enum.
+
+    Args:
+        internal_type_name (str): The name of the Databricks type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type enum that corresponds to the MySQL text type name.
+    """
+    if not isinstance(internal_type_name, str):
+        return MYSQL_DATA_TYPE.TEXT
+    if internal_type_name.upper() == "STRING":
+        return MYSQL_DATA_TYPE.TEXT
+    if internal_type_name.upper() == "LONG":
+        return MYSQL_DATA_TYPE.BIGINT
+    if internal_type_name.upper() == "SHORT":
+        return MYSQL_DATA_TYPE.SMALLINT
+    try:
+        return MYSQL_DATA_TYPE(internal_type_name.upper())
+    except Exception:
+        logger.info(f"Databricks handler: unknown type: {internal_type_name}, use TEXT as fallback.")
+        return MYSQL_DATA_TYPE.TEXT
+
+
 class DatabricksHandler(DatabaseHandler):
     """
     This handler handles the connection and execution of SQL statements on Databricks.
@@ -64,11 +90,8 @@ class DatabricksHandler(DatabaseHandler):
             return self.connection
 
         # Mandatory connection parameters.
-        if not all(
-            key in self.connection_data
-            for key in ["server_hostname", "http_path", "access_token"]
-        ):
-            raise ValueError('Required parameters (server_hostname, http_path, access_token) must be provided.')
+        if not all(key in self.connection_data for key in ["server_hostname", "http_path", "access_token"]):
+            raise ValueError("Required parameters (server_hostname, http_path, access_token) must be provided.")
 
         config = {
             "server_hostname": self.connection_data["server_hostname"],
@@ -88,19 +111,17 @@ class DatabricksHandler(DatabaseHandler):
                 config[parameter] = self.connection_data[parameter]
 
         try:
-            self.connection = connect(
-                **config
-            )
+            self.connection = connect(**config)
             self.is_connected = True
             return self.connection
         except RequestError as request_error:
-            logger.error(f'Request error when connecting to Databricks: {request_error}')
+            logger.error(f"Request error when connecting to Databricks: {request_error}")
             raise
         except RuntimeError as runtime_error:
-            logger.error(f'Runtime error when connecting to Databricks: {runtime_error}')
+            logger.error(f"Runtime error when connecting to Databricks: {runtime_error}")
             raise
         except Exception as unknown_error:
-            logger.error(f'Unknown error when connecting to Databricks: {unknown_error}')
+            logger.error(f"Unknown error when connecting to Databricks: {unknown_error}")
             raise
 
     def disconnect(self):
@@ -129,7 +150,7 @@ class DatabricksHandler(DatabaseHandler):
 
             # Execute a simple query to check the connection.
             query = "SELECT 1 FROM information_schema.schemata"
-            if 'schema' in self.connection_data:
+            if "schema" in self.connection_data:
                 query += f" WHERE schema_name = '{self.connection_data['schema']}'"
 
             with connection.cursor() as cursor:
@@ -138,14 +159,14 @@ class DatabricksHandler(DatabaseHandler):
 
             # If the query does not return a result, the schema does not exist.
             if not result:
-                raise ValueError(f'The schema {self.connection_data["schema"]} does not exist!')
+                raise ValueError(f"The schema {self.connection_data['schema']} does not exist!")
 
             response.success = True
         except (ValueError, RequestError, RuntimeError, ServerOperationError) as known_error:
-            logger.error(f'Connection check to Databricks failed, {known_error}!')
+            logger.error(f"Connection check to Databricks failed, {known_error}!")
             response.error_message = str(known_error)
         except Exception as unknown_error:
-            logger.error(f'Connection check to Databricks failed due to an unknown error, {unknown_error}!')
+            logger.error(f"Connection check to Databricks failed due to an unknown error, {unknown_error}!")
             response.error_message = str(unknown_error)
 
         if response.success and need_to_close:
@@ -176,30 +197,18 @@ class DatabricksHandler(DatabaseHandler):
                 if result:
                     response = Response(
                         RESPONSE_TYPE.TABLE,
-                        data_frame=pd.DataFrame(
-                            result, columns=[x[0] for x in cursor.description]
-                        ),
+                        data_frame=pd.DataFrame(result, columns=[x[0] for x in cursor.description]),
                     )
 
                 else:
                     response = Response(RESPONSE_TYPE.OK)
                     connection.commit()
             except ServerOperationError as server_error:
-                logger.error(
-                    f'Server error running query: {query} on Databricks, {server_error}!'
-                )
-                response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_message=str(server_error)
-                )
+                logger.error(f"Server error running query: {query} on Databricks, {server_error}!")
+                response = Response(RESPONSE_TYPE.ERROR, error_message=str(server_error))
             except Exception as unknown_error:
-                logger.error(
-                    f'Unknown error running query: {query} on Databricks, {unknown_error}!'
-                )
-                response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_message=str(unknown_error)
-                )
+                logger.error(f"Unknown error running query: {query} on Databricks, {unknown_error}!")
+                response = Response(RESPONSE_TYPE.ERROR, error_message=str(unknown_error))
 
         if need_to_close is True:
             self.disconnect()
@@ -220,29 +229,44 @@ class DatabricksHandler(DatabaseHandler):
         query_str = renderer.get_string(query, with_failback=True)
         return self.native_query(query_str)
 
-    def get_tables(self) -> Response:
+    def get_tables(self, all: bool = False) -> Response:
         """
         Retrieves a list of all non-system tables in the connected schema of the Databricks workspace.
 
+        Args:
+            all (bool): If True - return tables from all schemas.
+
         Returns:
             Response: A response object containing a list of tables in the connected schema.
         """
-        query = """
-            SHOW TABLES;
+        all_filter = "and table_schema = current_schema()"
+        if all is True:
+            all_filter = ""
+        query = f"""
+            SELECT
+                table_schema,
+                table_name,
+                table_type
+            FROM
+                information_schema.tables
+            WHERE
+                table_schema != 'information_schema'
+                {all_filter}
         """
         result = self.native_query(query)
-
-        df = result.data_frame
-        if df is not None:
-            result.data_frame = df.rename(columns={"tableName": "table_name", "database": "schema_name"})
+        if result.resp_type == RESPONSE_TYPE.OK:
+            result = Response(
+                RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame([], columns=list(INF_SCHEMA_COLUMNS_NAMES_SET))
+            )
         return result
 
-    def get_columns(self, table_name: Text) -> Response:
+    def get_columns(self, table_name: str, schema_name: str | None = None) -> Response:
         """
         Retrieves column details for a specified table in the Databricks workspace.
 
         Args:
-            table_name (Text): The name of the table for which to retrieve column information.
+            table_name (str): The name of the table for which to retrieve column information.
+            schema_name (str|None): The name of the schema in which the table is located.
 
         Raises:
             ValueError: If the 'table_name' is not a valid string.
@@ -253,9 +277,37 @@ class DatabricksHandler(DatabaseHandler):
         if not table_name or not isinstance(table_name, str):
             raise ValueError("Invalid table name provided.")
 
-        query = f"DESCRIBE TABLE {table_name};"
+        if isinstance(schema_name, str):
+            schema_name = f"'{schema_name}'"
+        else:
+            schema_name = "current_schema()"
+        query = f"""
+            SELECT
+                COLUMN_NAME,
+                DATA_TYPE,
+                ORDINAL_POSITION,
+                COLUMN_DEFAULT,
+                IS_NULLABLE,
+                CHARACTER_MAXIMUM_LENGTH,
+                CHARACTER_OCTET_LENGTH,
+                NUMERIC_PRECISION,
+                NUMERIC_SCALE,
+                DATETIME_PRECISION,
+                null as CHARACTER_SET_NAME,
+                null as COLLATION_NAME
+            FROM
+                information_schema.columns
+            WHERE
+                table_name = '{table_name}'
+            AND
+                table_schema = {schema_name}
+        """
+
         result = self.native_query(query)
+        if result.resp_type == RESPONSE_TYPE.OK:
+            result = Response(
+                RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame([], columns=list(INF_SCHEMA_COLUMNS_NAMES_SET))
+            )
+        result.to_columns_table_response(map_type_fn=_map_type)
 
-        df = result.data_frame
-        result.data_frame = df.rename(columns={"col_name": "column_name"})
         return result