MindsDB 25.7.3.0__py3-none-any.whl → 25.8.2.0__py3-none-any.whl

mindsdb/integrations/handlers/openai_handler/helpers.py

@@ -14,6 +14,7 @@ class PendingFT(openai.OpenAIError):
     """
     Custom exception to handle pending fine-tuning status.
     """
+
     message: str
 
     def __init__(self, message) -> None:
@@ -65,10 +66,7 @@ def retry_with_exponential_backoff(
 
             if isinstance(hour_budget, float) or isinstance(hour_budget, int):
                 try:
-                    max_retries = round(
-                        (math.log((hour_budget * 3600) / initial_delay))
-                        / math.log(exponential_base)
-                    )
+                    max_retries = round((math.log((hour_budget * 3600) / initial_delay)) / math.log(exponential_base))
                 except ValueError:
                     max_retries = 10
             else:
@@ -81,22 +79,20 @@ def retry_with_exponential_backoff(
 
                 except status_errors as e:
                     raise Exception(
-                        f'Error status {e.status_code} raised by OpenAI API: {e.body.get("message", "Please refer to `https://platform.openai.com/docs/guides/error-codes` for more information.")}'   # noqa
+                        f"Error status {e.status_code} raised by OpenAI API: {e.body.get('message', 'Please refer to `https://platform.openai.com/docs/guides/error-codes` for more information.')}"  # noqa
                     )  # noqa
 
                 except wait_errors:
                     num_retries += 1
                     if num_retries > max_retries:
-                        raise Exception(
-                            f"Maximum number of retries ({max_retries}) exceeded."
-                        )
+                        raise Exception(f"Maximum number of retries ({max_retries}) exceeded.")
                     # Increment the delay and wait
                     delay *= exponential_base * (1 + jitter * random.random())
                     time.sleep(delay)
 
                 except openai.OpenAIError as e:
                     raise Exception(
-                        f'General {str(e)} error raised by OpenAI. Please refer to `https://platform.openai.com/docs/guides/error-codes` for more information.'    # noqa
+                        f"General {str(e)} error raised by OpenAI. Please refer to `https://platform.openai.com/docs/guides/error-codes` for more information."  # noqa
                     )
 
                 except Exception as e:
@@ -107,7 +103,7 @@ def retry_with_exponential_backoff(
     return _retry_with_exponential_backoff
 
 
-def truncate_msgs_for_token_limit(messages: List[Dict], model_name: Text, max_tokens: int, truncate: Text = 'first'):
+def truncate_msgs_for_token_limit(messages: List[Dict], model_name: Text, max_tokens: int, truncate: Text = "first"):
     """
     Truncates message list to fit within the token limit.
     The first message for chat completion models are general directives with the system role, which will ideally be kept at all times.
@@ -129,20 +125,18 @@ def truncate_msgs_for_token_limit(messages: List[Dict], model_name: Text, max_to
     except KeyError:
         # If the encoding is not found, defualt to cl100k_base.
         # This is applicable for handlers that extend the OpenAI handler such as Anyscale.
-        model_name = 'gpt-3.5-turbo-0301'
-        encoder = tiktoken.get_encoding('cl100k_base')
+        model_name = "gpt-3.5-turbo-0301"
+        encoder = tiktoken.get_encoding("cl100k_base")
 
     sys_priming = messages[0:1]
     n_tokens = count_tokens(messages, encoder, model_name)
     while n_tokens > max_tokens:
         if len(messages) == 2:
-            return messages[
-                :-1
-            ]  # edge case: if limit is surpassed by just one input, we remove initial instruction
+            return messages[:-1]  # edge case: if limit is surpassed by just one input, we remove initial instruction
         elif len(messages) == 1:
             return messages
 
-        if truncate == 'first':
+        if truncate == "first":
             messages = sys_priming + messages[2:]
         else:
             messages = sys_priming + messages[1:-1]
@@ -151,7 +145,7 @@ def truncate_msgs_for_token_limit(messages: List[Dict], model_name: Text, max_to
     return messages
 
 
-def count_tokens(messages: List[Dict], encoder: tiktoken.core.Encoding, model_name: Text = 'gpt-3.5-turbo-0301'):
+def count_tokens(messages: List[Dict], encoder: tiktoken.core.Encoding, model_name: Text = "gpt-3.5-turbo-0301"):
     """
     Counts the number of tokens in a list of messages.
 
@@ -160,24 +154,23 @@ def count_tokens(messages: List[Dict], encoder: tiktoken.core.Encoding, model_na
         encoder: Tokenizer
         model_name: Model name
     """
-    if (
-        "gpt-3.5-turbo" in model_name
-    ):  # note: future models may deviate from this (only 0301 really complies)
-        num_tokens = 0
-        for message in messages:
-            num_tokens += (
-                4  # every message follows <im_start>{role/name}\n{content}<im_end>\n
-            )
-            for key, value in message.items():
-                num_tokens += len(encoder.encode(value))
-                if key == "name":  # if there's a name, the role is omitted
-                    num_tokens += -1  # role is always required and always 1 token
-        num_tokens += 2  # every reply is primed with <im_start>assistant
-        return num_tokens
+    if "gpt-3.5-turbo" in model_name:  # note: future models may deviate from this (only 0301 really complies)
+        tokens_per_message = 4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
+        tokens_per_name = -1
     else:
-        raise NotImplementedError(
-            f"""_count_tokens() is not presently implemented for model {model_name}."""
-        )
+        tokens_per_message = 3
+        tokens_per_name = 1
+
+    num_tokens = 0
+    for message in messages:
+        num_tokens += tokens_per_message
+
+        for key, value in message.items():
+            num_tokens += len(encoder.encode(value))
+            if key == "name":  # if there's a name, the role is omitted
+                num_tokens += tokens_per_name
+    num_tokens += 2  # every reply is primed with <im_start>assistant
+    return num_tokens
 
 
 def get_available_models(client) -> List[Text]:

mindsdb/integrations/handlers/openai_handler/openai_handler.py

@@ -24,7 +24,7 @@ from mindsdb.integrations.handlers.openai_handler.helpers import (
     PendingFT,
 )
 from mindsdb.integrations.handlers.openai_handler.constants import (
-    CHAT_MODELS,
+    CHAT_MODELS_PREFIXES,
     IMAGE_MODELS,
     FINETUNING_MODELS,
     OPENAI_API_BASE,
@@ -62,7 +62,6 @@ class OpenAIHandler(BaseMLEngine):
         self.rate_limit = 60  # requests per minute
         self.max_batch_size = 20
         self.default_max_tokens = 100
-        self.chat_completion_models = CHAT_MODELS
         self.supported_ft_models = FINETUNING_MODELS  # base models compatible with finetuning
         # For now this are only used for handlers that inherits OpenAIHandler and don't need to override base methods
         self.api_key_name = getattr(self, "api_key_name", self.name)
@@ -89,6 +88,13 @@ class OpenAIHandler(BaseMLEngine):
             client = self._get_client(api_key=api_key, base_url=api_base, org=org, args=connection_args)
             OpenAIHandler._check_client_connection(client)
 
+    @staticmethod
+    def is_chat_model(model_name):
+        for prefix in CHAT_MODELS_PREFIXES:
+            if model_name.startswith(prefix):
+                return True
+        return False
+
     @staticmethod
     def _check_client_connection(client: OpenAI) -> None:
         """
@@ -350,11 +356,6 @@ class OpenAIHandler(BaseMLEngine):
                 "user": pred_args.get("user", None),
             }
 
-            if args.get("mode", self.default_mode) != "default" and model_name not in self.chat_completion_models:
-                raise Exception(
-                    f"Conversational modes are only available for the following models: {', '.join(self.chat_completion_models)}"
-                )  # noqa
-
             if args.get("prompt_template", False):
                 prompts, empty_prompt_ids = get_completed_prompts(base_template, df, strict=strict_prompt_template)
 
@@ -515,7 +516,7 @@ class OpenAIHandler(BaseMLEngine):
                 return _submit_image_completion(kwargs, prompts, api_args)
             elif model_name == "embedding":
                 return _submit_embedding_completion(kwargs, prompts, api_args)
-            elif model_name in self.chat_completion_models:
+            elif self.is_chat_model(model_name):
                 if model_name == "gpt-3.5-turbo-instruct":
                     return _submit_normal_completion(kwargs, prompts, api_args)
                 else:
@@ -579,13 +580,14 @@ class OpenAIHandler(BaseMLEngine):
                         tidy_comps.append(c.text.strip("\n").strip(""))
                 return tidy_comps
 
-            kwargs["prompt"] = prompts
             kwargs = {**kwargs, **api_args}
 
             before_openai_query(kwargs)
-            resp = _tidy(client.completions.create(**kwargs))
-            _log_api_call(kwargs, resp)
-            return resp
+            responses = []
+            for prompt in prompts:
+                responses.extend(_tidy(client.completions.create(prompt=prompt, **kwargs)))
+            _log_api_call(kwargs, responses)
+            return responses
 
         def _submit_embedding_completion(kwargs: Dict, prompts: List[Text], api_args: Dict) -> List[float]:
             """

mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py

@@ -5,7 +5,19 @@ from urllib.parse import urlparse
 
 import pandas as pd
 import psycopg
-from mindsdb_sql_parser.ast import Parameter, Identifier, Update, BinaryOperation
+from mindsdb_sql_parser.ast import (
+    Parameter,
+    Identifier,
+    BinaryOperation,
+    Tuple as AstTuple,
+    Constant,
+    Select,
+    OrderBy,
+    TypeCast,
+    Delete,
+    Update,
+    Function,
+)
 from pgvector.psycopg import register_vector
 
 from mindsdb.integrations.handlers.postgres_handler.postgres_handler import (
@@ -17,6 +29,7 @@ from mindsdb.integrations.libs.vectordatabase_handler import (
     VectorStoreHandler,
     DistanceFunction,
     TableField,
+    FilterOperator,
 )
 from mindsdb.integrations.libs.keyword_search_base import KeywordSearchBase
 from mindsdb.integrations.utilities.sql_utils import KeywordSearchArgs
@@ -169,31 +182,42 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
         embedding_condition = None
 
         for condition in conditions:
+            is_embedding = condition.column == "embeddings"
+
             parts = condition.column.split(".")
-            key = parts[0]
+            key = Identifier(parts[0])
+
             # converts 'col.el1.el2' to col->'el1'->>'el2'
             if len(parts) > 1:
                 # intermediate elements
                 for el in parts[1:-1]:
-                    key += f" -> '{el}'"
+                    key = BinaryOperation(op="->", args=[key, Constant(el)])
 
                 # last element
-                key += f" ->> '{parts[-1]}'"
+                key = BinaryOperation(op="->>", args=[key, Constant(parts[-1])])
 
             type_cast = None
-            if isinstance(condition.value, int):
+            value = condition.value
+            if (
+                isinstance(value, list)
+                and len(value) > 0
+                and condition.op in (FilterOperator.IN, FilterOperator.NOT_IN)
+            ):
+                value = condition.value[0]
+
+            if isinstance(value, int):
                 type_cast = "int"
-            elif isinstance(condition.value, float):
+            elif isinstance(value, float):
                 type_cast = "float"
             if type_cast is not None:
-                key = f"({key})::{type_cast}"
+                key = TypeCast(type_cast, key)
 
             item = {
                 "name": key,
                 "op": condition.op.value,
                 "value": condition.value,
             }
-            if key == "embeddings":
+            if is_embedding:
                 embedding_condition = item
             else:
                 filter_conditions.append(item)
@@ -205,64 +229,24 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
         """
         Construct where clauses from filter conditions
         """
-        if filter_conditions is None:
-            return ""
 
-        where_clauses = []
+        where_clause = None
 
         for item in filter_conditions:
             key = item["name"]
 
             if item["op"].lower() in ("in", "not in"):
-                values = list(repr(i) for i in item["value"])
-                item["value"] = "({})".format(", ".join(values))
+                values = [Constant(i) for i in item["value"]]
+                value = AstTuple(values)
             else:
-                if item["value"] is None:
-                    item["value"] = "null"
-                else:
-                    item["value"] = repr(item["value"])
-            where_clauses.append(f"{key} {item['op']} {item['value']}")
-
-        if len(where_clauses) > 1:
-            return f"WHERE {' AND '.join(where_clauses)}"
-        elif len(where_clauses) == 1:
-            return f"WHERE {where_clauses[0]}"
-        else:
-            return ""
-
-    @staticmethod
-    def _construct_where_clause_with_keywords(filter_conditions=None, keyword_query=None, content_column_name=None):
-        if not keyword_query or not content_column_name:
-            return PgVectorHandler._construct_where_clause(filter_conditions)
-
-        keyword_query_condition = (
-            f"""to_tsvector('english', {content_column_name}) @@ websearch_to_tsquery('english', '{keyword_query}')"""
-        )
-        if filter_conditions is None:
-            return ""
-
-        where_clauses = []
-
-        for item in filter_conditions:
-            key = item["name"]
+                value = Constant(item["value"])
+            condition = BinaryOperation(op=item["op"], args=[key, value])
 
-            if item["op"].lower() in ("in", "not in"):
-                values = list(repr(i) for i in item["value"])
-                item["value"] = "({})".format(", ".join(values))
+            if where_clause is None:
+                where_clause = condition
             else:
-                if item["value"] is None:
-                    item["value"] = "null"
-                else:
-                    item["value"] = repr(item["value"])
-            where_clauses.append(f"{key} {item['op']} {item['value']}")
-
-        where_clauses.append(keyword_query_condition)
-        if len(where_clauses) > 1:
-            return f"WHERE {' AND '.join(where_clauses)}"
-        elif len(where_clauses) == 1:
-            return f"WHERE {where_clauses[0]}"
-        else:
-            return ""
+                where_clause = BinaryOperation(op="AND", args=[where_clause, condition])
+        return where_clause
 
     @staticmethod
     def _construct_full_after_from_clause(
@@ -275,9 +259,8 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
     def _build_keyword_bm25_query(
         self,
         table_name: str,
-        query: str,
+        keyword_search_args: KeywordSearchArgs,
         columns: List[str] = None,
-        content_column_name: str = "content",
         conditions: List[FilterCondition] = None,
         limit: int = None,
         offset: int = None,
@@ -286,21 +269,44 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
             columns = ["id", "content", "metadata"]
 
         filter_conditions, _ = self._translate_conditions(conditions)
+        where_clause = self._construct_where_clause(filter_conditions)
 
-        # given filter conditions, construct where clause
-        where_clause = self._construct_where_clause_with_keywords(filter_conditions, query, content_column_name)
-
-        query = f"""
-            SELECT
-                {", ".join(columns)},
-                ts_rank_cd(to_tsvector('english', {content_column_name}), websearch_to_tsquery('english', '{query}')) as distance
-            FROM
-                {table_name}
-            {where_clause if where_clause else ""}
-            {f"LIMIT {limit}" if limit else ""}
-            {f"OFFSET {offset}" if offset else ""};"""
+        if keyword_search_args:
+            keyword_query_condition = BinaryOperation(
+                op="@@",
+                args=[
+                    Function("to_tsvector", args=[Constant("english"), Identifier(keyword_search_args.column)]),
+                    Function("websearch_to_tsquery", args=[Constant("english"), Constant(keyword_search_args.query)]),
+                ],
+            )
 
-        return query
+            if where_clause:
+                where_clause = BinaryOperation(op="AND", args=[where_clause, keyword_query_condition])
+            else:
+                where_clause = keyword_query_condition
+
+        distance = Function(
+            "ts_rank_cd",
+            args=[
+                Function("to_tsvector", args=[Constant("english"), Identifier(keyword_search_args.column)]),
+                Function("websearch_to_tsquery", args=[Constant("english"), Constant(keyword_search_args.query)]),
+            ],
+            alias=Identifier("distance"),
+        )
+
+        targets = [Identifier(col) for col in columns]
+        targets.append(distance)
+
+        limit_clause = Constant(limit) if limit else None
+        offset_clause = Constant(offset) if offset else None
+
+        return Select(
+            targets=targets,
+            from_table=Identifier(table_name),
+            where=where_clause,
+            limit=limit_clause,
+            offset=offset_clause,
+        )
 
     def _build_select_query(
         self,
@@ -309,12 +315,12 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
         conditions: List[FilterCondition] = None,
         limit: int = None,
         offset: int = None,
-    ) -> str:
+    ) -> Select:
         """
         given inputs, build string query
         """
-        limit_clause = f"LIMIT {limit}" if limit else ""
-        offset_clause = f"OFFSET {offset}" if offset else ""
+        limit_clause = Constant(limit) if limit else None
+        offset_clause = Constant(offset) if offset else None
 
         # translate filter conditions to dictionary
         filter_conditions, embedding_search = self._translate_conditions(conditions)
@@ -335,7 +341,15 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
             modified_columns = ["id", "content", "embeddings", "metadata"]
             has_distance = True
 
-        targets = ", ".join(modified_columns)
+        targets = [Identifier(col) for col in modified_columns]
+
+        query = Select(
+            targets=targets,
+            from_table=Identifier(table_name),
+            where=where_clause,
+            limit=limit_clause,
+            offset=offset_clause,
+        )
 
         if embedding_search:
             search_vector = embedding_search["value"]
@@ -352,15 +366,18 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
                 if isinstance(search_vector, list):
                     search_vector = f"[{','.join(str(x) for x in search_vector)}]"
 
+            vector_op = BinaryOperation(
+                op=self.distance_op,
+                args=[Identifier("embeddings"), Constant(search_vector)],
+                alias=Identifier("distance"),
+            )
             # Calculate distance as part of the query if needed
             if has_distance:
-                targets = f"{targets}, (embeddings {self.distance_op} '{search_vector}') as distance"
+                query.targets.append(vector_op)
 
-            return f"SELECT {targets} FROM {table_name} {where_clause} ORDER BY embeddings {self.distance_op} '{search_vector}' ASC {limit_clause} {offset_clause} "
+            query.order_by = [OrderBy(vector_op, direction="ASC")]
 
-        else:
-            # if filter conditions, return rows that satisfy the conditions
-            return f"SELECT {targets} FROM {table_name} {where_clause} {limit_clause} {offset_clause}"
+        return query
 
     def _check_table(self, table_name: str):
         # Apply namespace for a user
@@ -386,8 +403,8 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
             columns = ["id", "content", "embeddings", "metadata"]
 
         query = self._build_select_query(table_name, columns, conditions, limit, offset)
-
-        result = self.raw_query(query)
+        query_str = self.renderer.get_string(query, with_failback=True)
+        result = self.raw_query(query_str)
 
         # ensure embeddings are returned as string so they can be parsed by mindsdb
         if "embeddings" in columns:
@@ -408,12 +425,10 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
 
         if columns is None:
             columns = ["id", "content", "embeddings", "metadata"]
-        content_column_name = keyword_search_args.column
-        query = self._build_keyword_bm25_query(
-            table_name, keyword_search_args.query, columns, content_column_name, conditions, limit, offset
-        )
 
-        result = self.raw_query(query)
+        query = self._build_keyword_bm25_query(table_name, keyword_search_args, columns, conditions, limit, offset)
+        query_str = self.renderer.get_string(query, with_failback=True)
+        result = self.raw_query(query_str)
 
         # ensure embeddings are returned as string so they can be parsed by mindsdb
         if "embeddings" in columns:
@@ -622,8 +637,9 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
         filter_conditions, _ = self._translate_conditions(conditions)
         where_clause = self._construct_where_clause(filter_conditions)
 
-        query = f"DELETE FROM {table_name} {where_clause}"
-        self.raw_query(query)
+        query = Delete(table=Identifier(table_name), where=where_clause)
+        query_str = self.renderer.get_string(query, with_failback=True)
+        self.raw_query(query_str)
 
     def drop_table(self, table_name: str, if_exists=True):
         """

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -1,5 +1,3 @@
-import csv
-import io
 import time
 import json
 from typing import Optional, Any
@@ -625,7 +623,7 @@ class PostgresHandler(MetaDatabaseHandler):
         result = self.native_query(query)
         return result
 
-    def meta_get_column_statistics(self, table_names: Optional[list] = None) -> dict:
+    def meta_get_column_statistics(self, table_names: Optional[list] = None) -> Response:
         """
         Retrieves column statistics (e.g., most common values, frequencies, null percentage, and distinct value count)
         for the specified tables or all tables if no list is provided.
@@ -634,54 +632,58 @@ class PostgresHandler(MetaDatabaseHandler):
             table_names (list): A list of table names for which to retrieve column statistics.
 
         Returns:
-            dict: A dictionary containing the column statistics.
+            Response: A response object containing the column statistics.
         """
-        query = """
+        table_filter = ""
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            table_filter = f" AND ps.tablename IN ({','.join(quoted_names)})"
+
+        query = (
+            """
             SELECT
-                ps.attname AS column_name,
-                ps.tablename AS table_name,
-                ps.most_common_vals AS most_common_values,
-                ps.most_common_freqs::text AS most_common_frequencies,
-                ps.null_frac * 100 AS null_percentage,
-                ps.n_distinct AS distinct_values_count,
-                ps.histogram_bounds AS histogram_bounds
+                ps.tablename AS TABLE_NAME,
+                ps.attname AS COLUMN_NAME,
+                ROUND(ps.null_frac::numeric * 100, 2) AS NULL_PERCENTAGE,
+                CASE 
+                    WHEN ps.n_distinct < 0 THEN NULL
+                    ELSE ps.n_distinct::bigint
+                END AS DISTINCT_VALUES_COUNT,
+                ps.most_common_vals AS MOST_COMMON_VALUES,
+                ps.most_common_freqs AS MOST_COMMON_FREQUENCIES,
+                ps.histogram_bounds
             FROM pg_stats ps
             WHERE ps.schemaname = current_schema()
             AND ps.tablename NOT LIKE 'pg_%'
             AND ps.tablename NOT LIKE 'sql_%'
         """
-
-        if table_names is not None and len(table_names) > 0:
-            table_names = [f"'{t}'" for t in table_names]
-            query += f" AND ps.tablename IN ({','.join(table_names)})"
+            + table_filter
+            + """
+            ORDER BY ps.tablename, ps.attname
+        """
+        )
 
         result = self.native_query(query)
-        df = result.data_frame
 
-        def parse_pg_array_string(x):
-            try:
-                return (
-                    [item.strip(" ,") for row in csv.reader(io.StringIO(x.strip("{}"))) for item in row if item.strip()]
-                    if x
-                    else []
-                )
-            except IndexError:
-                logger.error(f"Error parsing PostgreSQL array string: {x}")
-                return []
-
-        # Convert most_common_values and most_common_frequencies from string representation to lists.
-        df["most_common_values"] = df["most_common_values"].apply(lambda x: parse_pg_array_string(x))
-        df["most_common_frequencies"] = df["most_common_frequencies"].apply(lambda x: parse_pg_array_string(x))
-
-        # Get the minimum and maximum values from the histogram bounds.
-        df["minimum_value"] = df["histogram_bounds"].apply(lambda x: parse_pg_array_string(x)[0] if x else None)
-        df["maximum_value"] = df["histogram_bounds"].apply(lambda x: parse_pg_array_string(x)[-1] if x else None)
-
-        # Handle cases where distinct_values_count is negative (indicating an approximation).
-        df["distinct_values_count"] = df["distinct_values_count"].apply(lambda x: x if x >= 0 else None)
+        if result.type == RESPONSE_TYPE.TABLE and result.data_frame is not None:
+            df = result.data_frame
 
-        result.data_frame = df.drop(columns=["histogram_bounds"])
+            # Extract min/max from histogram bounds
+            def extract_min_max(histogram_str):
+                if histogram_str and str(histogram_str) != "nan":
+                    clean = str(histogram_str).strip("{}")
+                    if clean:
+                        values = clean.split(",")
+                        min_val = values[0].strip(" \"'") if values else None
+                        max_val = values[-1].strip(" \"'") if values else None
+                        return min_val, max_val
+                return None, None
 
+            min_max_values = df["histogram_bounds"].apply(extract_min_max)
+            df["MINIMUM_VALUE"] = min_max_values.apply(lambda x: x[0])
+            df["MAXIMUM_VALUE"] = min_max_values.apply(lambda x: x[1])
+
+        result.data_frame = df.drop(columns=["histogram_bounds"])
         return result
 
     def meta_get_primary_keys(self, table_names: Optional[list] = None) -> Response: