MindsDB 25.4.3.2__py3-none-any.whl → 25.4.5.0__py3-none-any.whl

mindsdb/api/litellm/start.py

@@ -0,0 +1,82 @@
+import asyncio
+from mindsdb.utilities import log
+from mindsdb.utilities.config import Config
+from mindsdb.interfaces.agents.litellm_server import run_server, run_server_async
+
+logger = log.getLogger(__name__)
+
+
+async def start_async(verbose=False):
+    """Start the LiteLLM server
+
+    Args:
+        verbose (bool): Whether to enable verbose logging
+    """
+    config = Config()
+
+    # Get agent name from command line args
+    agent_name = config.cmd_args.agent
+    if not agent_name:
+        logger.error("Agent name is required for LiteLLM server. Use --agent parameter.")
+        return 1
+
+    # Get project name or use default
+    project_name = config.cmd_args.project or "mindsdb"
+
+    # Get MCP server connection details
+    mcp_host = config.get('api', {}).get('mcp', {}).get('host', '127.0.0.1')
+    mcp_port = int(config.get('api', {}).get('mcp', {}).get('port', 47337))
+
+    # Get LiteLLM server settings
+    litellm_host = config.get('api', {}).get('litellm', {}).get('host', '0.0.0.0')
+    litellm_port = int(config.get('api', {}).get('litellm', {}).get('port', 8000))
+
+    logger.info(f"Starting LiteLLM server for agent '{agent_name}' in project '{project_name}'")
+    logger.info(f"Connecting to MCP server at {mcp_host}:{mcp_port}")
+    logger.info(f"Binding to {litellm_host}:{litellm_port}")
+
+    return await run_server_async(
+        agent_name=agent_name,
+        project_name=project_name,
+        mcp_host=mcp_host,
+        mcp_port=mcp_port,
+        host=litellm_host,
+        port=litellm_port
+    )
+
+
+def start(verbose=False):
+    """Start the LiteLLM server (synchronous wrapper)
+
+    Args:
+        verbose (bool): Whether to enable verbose logging
+    """
+    from mindsdb.interfaces.storage import db
+    db.init()
+
+    # Run the async function in the event loop
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    result = loop.run_until_complete(start_async(verbose))
+
+    if result == 0:
+        # Run the server
+        config = Config()
+        agent_name = config.cmd_args.agent
+        project_name = config.cmd_args.project or "mindsdb"
+        mcp_host = config.get('api', {}).get('mcp', {}).get('host', '127.0.0.1')
+        mcp_port = int(config.get('api', {}).get('mcp', {}).get('port', 47337))
+        litellm_host = config.get('api', {}).get('litellm', {}).get('host', '0.0.0.0')
+        litellm_port = int(config.get('api', {}).get('litellm', {}).get('port', 8000))
+
+        return run_server(
+            agent_name=agent_name,
+            project_name=project_name,
+            mcp_host=mcp_host,
+            mcp_port=mcp_port,
+            host=litellm_host,
+            port=litellm_port
+        )
+    else:
+        logger.error("LiteLLM server initialization failed")
+        return result

mindsdb/api/mysql/mysql_proxy/libs/constants/mysql.py

@@ -179,6 +179,139 @@ class MYSQL_DATA_TYPE(enum.Enum):
     BOOLEAN = 'BOOLEAN'
 
 
+# Default values for attributes of MySQL data types as they appear in information_schema.columns
+# These values match the MySQL v8.0.37 defaults and are used to properly represent column metadata
+MYSQL_DATA_TYPE_COLUMNS_DEFAULT = {
+    MYSQL_DATA_TYPE.TINYINT: {
+        'NUMERIC_PRECISION': 3,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.SMALLINT: {
+        'NUMERIC_PRECISION': 5,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.MEDIUMINT: {
+        'NUMERIC_PRECISION': 7,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.INT: {
+        'NUMERIC_PRECISION': 10,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.BIGINT: {
+        'NUMERIC_PRECISION': 19,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.FLOAT: {
+        'NUMERIC_PRECISION': 12
+    },
+    MYSQL_DATA_TYPE.DOUBLE: {
+        'NUMERIC_PRECISION': 22
+    },
+    MYSQL_DATA_TYPE.DECIMAL: {
+        'NUMERIC_PRECISION': 10,
+        'NUMERIC_SCALE': 0,
+        'COLUMN_TYPE': 'decimal(10,0)'
+    },
+    MYSQL_DATA_TYPE.YEAR: {
+        # every column is null
+    },
+    MYSQL_DATA_TYPE.TIME: {
+        'DATETIME_PRECISION': 0
+    },
+    MYSQL_DATA_TYPE.DATE: {
+        # every column is null
+    },
+    MYSQL_DATA_TYPE.DATETIME: {
+        'DATETIME_PRECISION': 0
+    },
+    MYSQL_DATA_TYPE.TIMESTAMP: {
+        'DATETIME_PRECISION': 0
+    },
+    MYSQL_DATA_TYPE.CHAR: {
+        'CHARACTER_MAXIMUM_LENGTH': 1,
+        'CHARACTER_OCTET_LENGTH': 4,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin',
+        'COLUMN_TYPE': 'char(1)'
+    },
+    MYSQL_DATA_TYPE.BINARY: {
+        'CHARACTER_MAXIMUM_LENGTH': 1,
+        'CHARACTER_OCTET_LENGTH': 1,
+        'COLUMN_TYPE': 'binary(1)'
+    },
+    MYSQL_DATA_TYPE.VARCHAR: {
+        'CHARACTER_MAXIMUM_LENGTH': 1024,   # NOTE mandatory for field creation
+        'CHARACTER_OCTET_LENGTH': 4096,     # NOTE mandatory for field creation
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin',
+        'COLUMN_TYPE': 'varchar(1024)'
+    },
+    MYSQL_DATA_TYPE.VARBINARY: {
+        'CHARACTER_MAXIMUM_LENGTH': 1024,   # NOTE mandatory for field creation
+        'CHARACTER_OCTET_LENGTH': 1024,     # NOTE mandatory for field creation
+        'COLUMN_TYPE': 'varbinary(1024)'
+    },
+    MYSQL_DATA_TYPE.TINYBLOB: {
+        'CHARACTER_MAXIMUM_LENGTH': 255,
+        'CHARACTER_OCTET_LENGTH': 255
+    },
+    MYSQL_DATA_TYPE.TINYTEXT: {
+        'CHARACTER_MAXIMUM_LENGTH': 255,
+        'CHARACTER_OCTET_LENGTH': 255,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin'
+    },
+    MYSQL_DATA_TYPE.BLOB: {
+        'CHARACTER_MAXIMUM_LENGTH': 65535,
+        'CHARACTER_OCTET_LENGTH': 65535
+    },
+    MYSQL_DATA_TYPE.TEXT: {
+        'CHARACTER_MAXIMUM_LENGTH': 65535,
+        'CHARACTER_OCTET_LENGTH': 65535,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin'
+    },
+    MYSQL_DATA_TYPE.MEDIUMBLOB: {
+        'CHARACTER_MAXIMUM_LENGTH': 16777215,
+        'CHARACTER_OCTET_LENGTH': 16777215
+    },
+    MYSQL_DATA_TYPE.MEDIUMTEXT: {
+        'CHARACTER_MAXIMUM_LENGTH': 16777215,
+        'CHARACTER_OCTET_LENGTH': 16777215,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin'
+    },
+    MYSQL_DATA_TYPE.LONGBLOB: {
+        'CHARACTER_MAXIMUM_LENGTH': 4294967295,
+        'CHARACTER_OCTET_LENGTH': 4294967295,
+    },
+    MYSQL_DATA_TYPE.LONGTEXT: {
+        'CHARACTER_MAXIMUM_LENGTH': 4294967295,
+        'CHARACTER_OCTET_LENGTH': 4294967295,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin'
+    },
+    MYSQL_DATA_TYPE.BIT: {
+        'NUMERIC_PRECISION': 1,
+        'COLUMN_TYPE': 'bit(1)'
+        # 'NUMERIC_SCALE': null
+    },
+    MYSQL_DATA_TYPE.BOOL: {
+        'DATA_TYPE': 'tinyint',
+        'NUMERIC_PRECISION': 3,
+        'NUMERIC_SCALE': 0,
+        'COLUMN_TYPE': 'tinyint(1)'
+    },
+    MYSQL_DATA_TYPE.BOOLEAN: {
+        'DATA_TYPE': 'tinyint',
+        'NUMERIC_PRECISION': 3,
+        'NUMERIC_SCALE': 0,
+        'COLUMN_TYPE': 'tinyint(1)'
+    }
+}
+
+
 # Map between data types and C types
 # https://dev.mysql.com/doc/c-api/8.0/en/c-api-prepared-statement-type-codes.html
 DATA_C_TYPE_MAP = {

mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py

@@ -68,6 +68,10 @@ class ChromaDBHandler(VectorStoreHandler):
             "persist_directory": self.persist_directory,
         }
 
+        self.create_collection_metadata = {
+            "hnsw:space": config.distance,
+        }
+
         self._use_handler_storage = False
 
         self.connect()
@@ -398,7 +402,7 @@ class ChromaDBHandler(VectorStoreHandler):
         Insert/Upsert data into ChromaDB collection.
         If records with same IDs exist, they will be updated.
         """
-        collection = self._client.get_or_create_collection(collection_name)
+        collection = self._client.get_or_create_collection(collection_name, metadata=self.create_collection_metadata)
 
         # Convert metadata from string to dict if needed
         if TableField.METADATA.value in df.columns:
@@ -484,7 +488,8 @@ class ChromaDBHandler(VectorStoreHandler):
         """
         Create a collection with the given name in the ChromaDB database.
         """
-        self._client.create_collection(table_name, get_or_create=if_not_exists)
+        self._client.create_collection(table_name, get_or_create=if_not_exists,
+                                       metadata=self.create_collection_metadata)
         self._sync()
 
     def drop_table(self, table_name: str, if_exists=True):

mindsdb/integrations/handlers/chromadb_handler/settings.py

@@ -14,6 +14,7 @@ class ChromaHandlerConfig(BaseModel):
     host: str = None
     port: str = None
     password: str = None
+    distance: str = 'cosine'
 
     class Config:
         extra = "forbid"

mindsdb/integrations/handlers/mssql_handler/mssql_handler.py

@@ -241,14 +241,23 @@ class SqlServerHandler(DatabaseHandler):
 
         query = f"""
             SELECT
-                column_name as "Field",
-                data_type as "Type"
+                COLUMN_NAME,
+                DATA_TYPE,
+                ORDINAL_POSITION,
+                COLUMN_DEFAULT,
+                IS_NULLABLE,
+                CHARACTER_MAXIMUM_LENGTH,
+                CHARACTER_OCTET_LENGTH,
+                NUMERIC_PRECISION,
+                NUMERIC_SCALE,
+                DATETIME_PRECISION,
+                CHARACTER_SET_NAME,
+                COLLATION_NAME
             FROM
                 information_schema.columns
             WHERE
                 table_name = '{table_name}'
         """
         result = self.native_query(query)
-        if result.resp_type is RESPONSE_TYPE.TABLE:
-            result.data_frame['mysql_data_type'] = result.data_frame['Type'].apply(_map_type)
+        result.to_columns_table_response(map_type_fn=_map_type)
         return result

mindsdb/integrations/handlers/mysql_handler/mysql_handler.py

@@ -231,14 +231,23 @@ class MySQLHandler(DatabaseHandler):
         """
         q = f"""
             select
-                COLUMN_NAME AS FIELD, DATA_TYPE AS TYPE
+                COLUMN_NAME,
+                DATA_TYPE,
+                ORDINAL_POSITION,
+                COLUMN_DEFAULT,
+                IS_NULLABLE,
+                CHARACTER_MAXIMUM_LENGTH,
+                CHARACTER_OCTET_LENGTH,
+                NUMERIC_PRECISION,
+                NUMERIC_SCALE,
+                DATETIME_PRECISION,
+                CHARACTER_SET_NAME,
+                COLLATION_NAME
             from
                 information_schema.columns
             where
-                table_name = '{table_name}'
+                table_name = '{table_name}';
         """
         result = self.native_query(q)
-        if result.resp_type is RESPONSE_TYPE.TABLE:
-            result.data_frame = result.data_frame.rename(columns={'FIELD': 'Field', 'TYPE': 'Type'})
-            result.data_frame['mysql_data_type'] = result.data_frame['Type'].apply(_map_type)
+        result.to_columns_table_response(map_type_fn=_map_type)
         return result

mindsdb/integrations/handlers/openai_handler/helpers.py

@@ -4,7 +4,6 @@ import time
 import math
 
 import openai
-from openai import OpenAI
 
 import tiktoken
 
@@ -181,17 +180,16 @@ def count_tokens(messages: List[Dict], encoder: tiktoken.core.Encoding, model_na
         )
 
 
-def get_available_models(api_key: Text, api_base: Text) -> List[Text]:
+def get_available_models(client) -> List[Text]:
     """
     Returns a list of available openai models for the given API key.
 
     Args:
-        api_key (Text): OpenAI API key
-        api_base (Text): OpenAI API base URL
+        client: openai sdk client
 
     Returns:
         List[Text]: List of available models
     """
-    res = OpenAI(api_key=api_key, base_url=api_base).models.list()
+    res = client.models.list()
 
     return [models.id for models in res.data]

mindsdb/integrations/handlers/openai_handler/openai_handler.py

@@ -9,7 +9,7 @@ import subprocess
 import concurrent.futures
 from typing import Text, Tuple, Dict, List, Optional, Any
 import openai
-from openai import OpenAI, NotFoundError, AuthenticationError
+from openai import OpenAI, AzureOpenAI, NotFoundError, AuthenticationError
 import numpy as np
 import pandas as pd
 
@@ -87,7 +87,7 @@ class OpenAIHandler(BaseMLEngine):
         if api_key is not None:
             org = connection_args.get('api_organization')
             api_base = connection_args.get('api_base') or os.environ.get('OPENAI_API_BASE', OPENAI_API_BASE)
-            client = self._get_client(api_key=api_key, base_url=api_base, org=org)
+            client = self._get_client(api_key=api_key, base_url=api_base, org=org, args=connection_args)
             OpenAIHandler._check_client_connection(client)
 
     @staticmethod
@@ -188,7 +188,9 @@ class OpenAIHandler(BaseMLEngine):
                 "temperature",
                 "openai_api_key",
                 "api_organization",
-                "api_base"
+                "api_base",
+                "api_version",
+                "provider",
             }
         )
 
@@ -204,7 +206,7 @@ class OpenAIHandler(BaseMLEngine):
         api_key = get_api_key('openai', args, engine_storage=engine_storage)
         api_base = args.get('api_base') or connection_args.get('api_base') or os.environ.get('OPENAI_API_BASE', OPENAI_API_BASE)
         org = args.get('api_organization')
-        client = OpenAIHandler._get_client(api_key=api_key, base_url=api_base, org=org)
+        client = OpenAIHandler._get_client(api_key=api_key, base_url=api_base, org=org, args=args)
         OpenAIHandler._check_client_connection(client)
 
     def create(self, target, args: Dict = None, **kwargs: Any) -> None:
@@ -228,7 +230,8 @@ class OpenAIHandler(BaseMLEngine):
             api_key = get_api_key(self.api_key_name, args, self.engine_storage)
             connection_args = self.engine_storage.get_connection_args()
             api_base = args.get('api_base') or connection_args.get('api_base') or os.environ.get('OPENAI_API_BASE') or self.api_base
-            available_models = get_available_models(api_key, api_base)
+            client = self._get_client(api_key=api_key, base_url=api_base, org=args.get('api_organization'), args=args)
+            available_models = get_available_models(client)
 
             if not args.get('mode'):
                 args['mode'] = self.default_mode
@@ -810,6 +813,7 @@ class OpenAIHandler(BaseMLEngine):
             api_key=api_key,
             base_url=args.get('api_base'),
             org=args.pop('api_organization') if 'api_organization' in args else None,
+            args=args
         )
 
         try:
@@ -891,7 +895,8 @@ class OpenAIHandler(BaseMLEngine):
                 client = self._get_client(
                     api_key=api_key,
                     base_url=args.get('api_base'),
-                    org=args.get('api_organization')
+                    org=args.get('api_organization'),
+                    args=args,
                 )
                 meta = client.models.retrieve(model_name)
             except Exception as e:
@@ -935,7 +940,7 @@ class OpenAIHandler(BaseMLEngine):
 
         api_base = using_args.get('api_base', os.environ.get('OPENAI_API_BASE', OPENAI_API_BASE))
         org = using_args.get('api_organization')
-        client = self._get_client(api_key=api_key, base_url=api_base, org=org)
+        client = self._get_client(api_key=api_key, base_url=api_base, org=org, args=args)
 
         args = {**using_args, **args}
         prev_model_name = self.base_model_storage.json_get('args').get('model_name', '')
@@ -1173,7 +1178,7 @@ class OpenAIHandler(BaseMLEngine):
         return ft_stats, result_file_id
 
     @staticmethod
-    def _get_client(api_key: Text, base_url: Text, org: Optional[Text] = None) -> OpenAI:
+    def _get_client(api_key: Text, base_url: Text, org: Optional[Text] = None, args: dict = None) -> OpenAI:
         """
         Get an OpenAI client with the given API key, base URL, and organization.
 
@@ -1185,4 +1190,11 @@ class OpenAIHandler(BaseMLEngine):
         Returns:
             openai.OpenAI: OpenAI client.
         """
+        if args is not None and args.get('provider') == 'azure':
+            return AzureOpenAI(
+                api_key=api_key,
+                azure_endpoint=base_url,
+                api_version=args.get('api_version'),
+                organization=org
+            )
         return OpenAI(api_key=api_key, base_url=base_url, organization=org)

mindsdb/integrations/handlers/oracle_handler/oracle_handler.py

@@ -282,13 +282,23 @@ class OracleHandler(DatabaseHandler):
         """
         query = f"""
             SELECT
-                column_name AS field,
-                data_type AS type
+                COLUMN_NAME,
+                DATA_TYPE,
+                COLUMN_ID AS ORDINAL_POSITION,
+                DATA_DEFAULT AS COLUMN_DEFAULT,
+                CASE NULLABLE WHEN 'Y' THEN 'YES' ELSE 'NO' END AS IS_NULLABLE,
+                CHAR_LENGTH AS CHARACTER_MAXIMUM_LENGTH,
+                NULL AS CHARACTER_OCTET_LENGTH,
+                DATA_PRECISION AS NUMERIC_PRECISION,
+                DATA_SCALE AS NUMERIC_SCALE,
+                NULL AS DATETIME_PRECISION,
+                CHARACTER_SET_NAME,
+                NULL AS COLLATION_NAME
             FROM USER_TAB_COLUMNS
             WHERE table_name = '{table_name}'
+            ORDER BY TABLE_NAME, COLUMN_ID;
         """
         result = self.native_query(query)
         if result.resp_type is RESPONSE_TYPE.TABLE:
-            result.data_frame.columns = [name.lower() for name in result.data_frame.columns]
-            result.data_frame['mysql_data_type'] = result.data_frame['type'].apply(_map_type)
+            result.to_columns_table_response(map_type_fn=_map_type)
         return result

mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py

@@ -40,8 +40,31 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler):
         # we get these from the connection args on PostgresHandler parent
         self._is_sparse = self.connection_args.get('is_sparse', False)
         self._vector_size = self.connection_args.get('vector_size', None) 
-        if self._is_sparse and not self._vector_size:
-            raise ValueError("vector_size is required when is_sparse=True")
+
+        if self._is_sparse:
+            if not self._vector_size:
+                raise ValueError("vector_size is required when is_sparse=True")
+
+                # Use inner product for sparse vectors
+                distance_op = "<#>"
+
+        else:
+            distance_op = '<=>'
+            if 'distance' in self.connection_args:
+                distance_ops = {
+                    'l1': '<+>',
+                    'l2': '<->',
+                    'ip': '<#>',  # inner product
+                    'cosine': '<=>',
+                    'hamming': '<~>',
+                    'jaccard': '<%>'
+                }
+
+                distance_op = distance_ops.get(self.connection_args['distance'])
+                if distance_op is None:
+                    raise ValueError(f'Wrong distance type. Allowed options are {list(distance_ops.keys())}')
+
+        self.distance_op = distance_op
         self.connect()
 
     def _make_connection_args(self):
@@ -224,20 +247,16 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler):
                         from pgvector.utils import SparseVector
                         embedding = SparseVector(search_vector, self._vector_size)
                         search_vector = embedding.to_text()
-                    # Use inner product for sparse vectors
-                    distance_op = "<#>"
                 else:
                     # Convert list to vector string if needed
                     if isinstance(search_vector, list):
                         search_vector = f"[{','.join(str(x) for x in search_vector)}]"
-                    # 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"
+                    targets = f"{targets}, (embeddings {self.distance_op} '{search_vector}') as distance"
                 
-                return f"SELECT {targets} FROM {table_name} {where_clause} ORDER BY embeddings {distance_op} '{search_vector}' ASC {limit_clause} {offset_clause} "
+                return f"SELECT {targets} FROM {table_name} {where_clause} ORDER BY embeddings {self.distance_op} '{search_vector}' ASC {limit_clause} {offset_clause} "
 
             else:
                 # if filter conditions, return rows that satisfy the conditions
@@ -418,18 +437,14 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler):
         """
         table_name = self._check_table(table_name)
 
-        data_dict = data.to_dict(orient="list")
-
-        if 'metadata' in data_dict:
-            data_dict['metadata'] = [json.dumps(i) for i in data_dict['metadata']]
-        transposed_data = list(zip(*data_dict.values()))
-
-        columns = ", ".join(data.keys())
-        values = ", ".join(["%s"] * len(data.keys()))
+        if 'metadata' in data.columns:
+             data['metadata'] = data['metadata'].apply(json.dumps)
 
-        insert_statement = f"INSERT INTO {table_name} ({columns}) VALUES ({values})"
-
-        self.raw_query(insert_statement, params=transposed_data)
+        resp = super().insert(table_name, data)
+        if resp.resp_type == RESPONSE_TYPE.ERROR:
+            raise RuntimeError(resp.error_message)
+        if resp.resp_type == RESPONSE_TYPE.TABLE:
+            return resp.data_frame
 
     def update(
         self, table_name: str, data: pd.DataFrame, key_columns: List[str] = None

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -1,7 +1,6 @@
 import time
 import json
 from typing import Optional
-import threading
 
 import pandas as pd
 import psycopg
@@ -43,7 +42,8 @@ def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
         ('real', 'money', 'float'): MYSQL_DATA_TYPE.FLOAT,
         ('numeric', 'decimal'): MYSQL_DATA_TYPE.DECIMAL,
         ('double precision',): MYSQL_DATA_TYPE.DOUBLE,
-        ('character varying', 'varchar', 'character', 'char', 'bpchar', 'bpchar', 'text'): MYSQL_DATA_TYPE.TEXT,
+        ('character varying', 'varchar'): MYSQL_DATA_TYPE.VARCHAR,
+        ('character', 'char', 'bpchar', 'bpchar', 'text'): MYSQL_DATA_TYPE.TEXT,
         ('timestamp', 'timestamp without time zone', 'timestamp with time zone'): MYSQL_DATA_TYPE.DATETIME,
         ('date', ): MYSQL_DATA_TYPE.DATE,
         ('time', 'time without time zone', 'time with time zone'): MYSQL_DATA_TYPE.TIME,
@@ -76,9 +76,7 @@ class PostgresHandler(DatabaseHandler):
 
         self.connection = None
         self.is_connected = False
-        self.thread_safe = True
-
-        self._insert_lock = threading.Lock()
+        self.thread_safe = False
 
     def __del__(self):
         if self.is_connected:
@@ -266,15 +264,13 @@ class PostgresHandler(DatabaseHandler):
 
         columns = df.columns
 
-        # postgres 'copy' is not thread safe. use lock to prevent concurrent execution
-        with self._insert_lock:
-            resp = self.get_columns(table_name)
+        resp = self.get_columns(table_name)
 
         # copy requires precise cases of names: get current column names from table and adapt input dataframe columns
         if resp.data_frame is not None and not resp.data_frame.empty:
             db_columns = {
                 c.lower(): c
-                for c in resp.data_frame['field']
+                for c in resp.data_frame['COLUMN_NAME']
             }
 
             # try to get case of existing column
@@ -288,11 +284,10 @@ class PostgresHandler(DatabaseHandler):
 
         with connection.cursor() as cur:
             try:
-                with self._insert_lock:
-                    with cur.copy(f'copy "{table_name}" ({",".join(columns)}) from STDIN WITH CSV') as copy:
-                        df.to_csv(copy, index=False, header=False)
+                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()
+                connection.commit()
             except Exception as e:
                 logger.error(f'Error running insert to {table_name} on {self.database}, {e}!')
                 connection.rollback()
@@ -366,8 +361,18 @@ class PostgresHandler(DatabaseHandler):
             schema_name = 'current_schema()'
         query = f"""
             SELECT
-                column_name as "Field",
-                data_type as "Type"
+                COLUMN_NAME,
+                DATA_TYPE,
+                ORDINAL_POSITION,
+                COLUMN_DEFAULT,
+                IS_NULLABLE,
+                CHARACTER_MAXIMUM_LENGTH,
+                CHARACTER_OCTET_LENGTH,
+                NUMERIC_PRECISION,
+                NUMERIC_SCALE,
+                DATETIME_PRECISION,
+                CHARACTER_SET_NAME,
+                COLLATION_NAME
             FROM
                 information_schema.columns
             WHERE
@@ -376,9 +381,7 @@ class PostgresHandler(DatabaseHandler):
                 table_schema = {schema_name}
         """
         result = self.native_query(query)
-        if result.resp_type is RESPONSE_TYPE.TABLE:
-            result.data_frame.columns = [name.lower() for name in result.data_frame.columns]
-            result.data_frame['mysql_data_type'] = result.data_frame['type'].apply(_map_type)
+        result.to_columns_table_response(map_type_fn=_map_type)
         return result
 
     def subscribe(self, stop_event, callback, table_name, columns=None, **kwargs):