qodalis-cli-server-plugin-data-explorer-mssql 1.0.0b18__py3-none-any.whl

qodalis_cli_data_explorer_mssql/__init__.py

@@ -0,0 +1,5 @@
+"""Qodalis CLI Data Explorer MSSQL plugin — MS SQL Server provider."""
+
+from .mssql_provider import MssqlDataExplorerProvider
+
+__all__ = ["MssqlDataExplorerProvider"]

qodalis_cli_data_explorer_mssql/mssql_provider.py

@@ -0,0 +1,209 @@
+"""MS SQL Server-backed Data Explorer provider."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+import time
+
+import pymssql
+
+from qodalis_cli_server_abstractions import (
+    DataExplorerExecutionContext,
+    DataExplorerProviderOptions,
+    DataExplorerResult,
+    DataExplorerSchemaColumn,
+    DataExplorerSchemaResult,
+    DataExplorerSchemaTable,
+    IDataExplorerProvider,
+)
+
+_CS_RE = re.compile(r"(?P<key>[^=;]+)=(?P<value>[^;]*)", re.IGNORECASE)
+
+
+def _parse_connection_string(connection_string: str) -> dict[str, str]:
+    """Return a lower-cased key dict from an ADO.NET connection string."""
+    result: dict[str, str] = {}
+    for match in _CS_RE.finditer(connection_string):
+        key = match.group("key").strip().lower().replace(" ", "")
+        value = match.group("value").strip()
+        result[key] = value
+    return result
+
+
+class MssqlDataExplorerProvider(IDataExplorerProvider):
+    """Executes SQL queries against a Microsoft SQL Server database.
+
+    Connection string format (ADO.NET style)::
+
+        Server=host,1433;Database=mydb;User Id=sa;Password=secret;TrustServerCertificate=true
+    """
+
+    def __init__(self, connection_string: str) -> None:
+        self._connection_string = connection_string
+        params = _parse_connection_string(connection_string)
+
+        server_raw = params.get("server", "localhost")
+        if "," in server_raw:
+            host_part, port_part = server_raw.split(",", 1)
+            self._host = host_part.strip()
+            try:
+                self._port = int(port_part.strip())
+            except ValueError:
+                self._port = 1433
+        else:
+            self._host = server_raw
+            self._port = 1433
+
+        self._database = params.get("database", "master")
+        self._user = params.get("userid") or params.get("uid", "sa")
+        self._password = params.get("password") or params.get("pwd", "")
+
+    def _connect(self) -> pymssql.Connection:
+        """Open a connection to the SQL Server instance."""
+        return pymssql.connect(
+            server=self._host,
+            port=self._port,
+            user=self._user,
+            password=self._password,
+            database=self._database,
+        )
+
+    def _execute_sync(
+        self, context: DataExplorerExecutionContext
+    ) -> DataExplorerResult:
+        """Synchronous query execution, called via ``asyncio.to_thread``."""
+        start = time.monotonic()
+        conn: pymssql.Connection | None = None
+        try:
+            conn = self._connect()
+            cursor = conn.cursor()
+            cursor.execute(context.query, context.parameters or ())
+
+            if cursor.description:
+                columns = [desc[0] for desc in cursor.description]
+                rows_raw = cursor.fetchall()
+                rows = [list(row) for row in rows_raw]
+                return DataExplorerResult(
+                    success=True,
+                    source=context.options.name,
+                    language=context.options.language,
+                    default_output_format=context.options.default_output_format,
+                    execution_time=int((time.monotonic() - start) * 1000),
+                    columns=columns,
+                    rows=rows,
+                    row_count=len(rows),
+                    truncated=False,
+                    error=None,
+                )
+            else:
+                conn.commit()
+                return DataExplorerResult(
+                    success=True,
+                    source=context.options.name,
+                    language=context.options.language,
+                    default_output_format=context.options.default_output_format,
+                    execution_time=int((time.monotonic() - start) * 1000),
+                    columns=["changes"],
+                    rows=[[cursor.rowcount]],
+                    row_count=1,
+                    truncated=False,
+                    error=None,
+                )
+        except Exception as exc:
+            return DataExplorerResult(
+                success=False,
+                source=context.options.name,
+                language=context.options.language,
+                default_output_format=context.options.default_output_format,
+                execution_time=int((time.monotonic() - start) * 1000),
+                columns=None,
+                rows=[],
+                row_count=0,
+                truncated=False,
+                error=str(exc),
+            )
+        finally:
+            if conn is not None:
+                conn.close()
+
+    def _get_schema_sync(
+        self, options: DataExplorerProviderOptions
+    ) -> DataExplorerSchemaResult | None:
+        """Synchronous schema introspection, called via ``asyncio.to_thread``."""
+        conn: pymssql.Connection | None = None
+        try:
+            conn = self._connect()
+            cursor = conn.cursor()
+
+            cursor.execute(
+                "SELECT TABLE_NAME, TABLE_TYPE "
+                "FROM INFORMATION_SCHEMA.TABLES "
+                "WHERE TABLE_SCHEMA = 'dbo' "
+                "ORDER BY TABLE_NAME"
+            )
+            table_rows = cursor.fetchall()
+
+            tables: list[DataExplorerSchemaTable] = []
+            for table_name, table_type in table_rows:
+                cursor.execute(
+                    "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE "
+                    "FROM INFORMATION_SCHEMA.COLUMNS "
+                    "WHERE TABLE_SCHEMA = 'dbo' AND TABLE_NAME = %s "
+                    "ORDER BY ORDINAL_POSITION",
+                    (table_name,),
+                )
+                col_rows = cursor.fetchall()
+
+                cursor.execute(
+                    "SELECT kcu.COLUMN_NAME "
+                    "FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS tc "
+                    "JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu "
+                    "  ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME "
+                    "  AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA "
+                    "  AND tc.TABLE_NAME = kcu.TABLE_NAME "
+                    "WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY' "
+                    "  AND tc.TABLE_SCHEMA = 'dbo' "
+                    "  AND tc.TABLE_NAME = %s",
+                    (table_name,),
+                )
+                pk_rows = cursor.fetchall()
+                pk_columns = {row[0] for row in pk_rows}
+
+                columns = [
+                    DataExplorerSchemaColumn(
+                        name=col_name,
+                        type=data_type or "varchar",
+                        nullable=is_nullable.upper() == "YES",
+                        primary_key=col_name in pk_columns,
+                    )
+                    for col_name, data_type, is_nullable in col_rows
+                ]
+
+                normalised_type = (
+                    "view" if table_type.strip().upper() == "VIEW" else "table"
+                )
+                tables.append(
+                    DataExplorerSchemaTable(
+                        name=table_name,
+                        type=normalised_type,
+                        columns=columns,
+                    )
+                )
+
+            return DataExplorerSchemaResult(source=options.name, tables=tables)
+        finally:
+            if conn is not None:
+                conn.close()
+
+    async def execute_async(
+        self, context: DataExplorerExecutionContext
+    ) -> DataExplorerResult:
+        """Execute a SQL query against the SQL Server database."""
+        return await asyncio.to_thread(self._execute_sync, context)
+
+    async def get_schema_async(
+        self, options: DataExplorerProviderOptions
+    ) -> DataExplorerSchemaResult | None:
+        """Return the dbo schema (tables, views, and their columns)."""
+        return await asyncio.to_thread(self._get_schema_sync, options)

qodalis_cli_server_plugin_data_explorer_mssql-1.0.0b18.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.5
+Name: qodalis-cli-server-plugin-data-explorer-mssql
+Version: 1.0.0b18
+Summary: MS SQL Server Data Explorer provider plugin for Qodalis CLI servers
+Project-URL: Homepage, https://github.com/qodalis-solutions/cli-server-python
+Project-URL: Repository, https://github.com/qodalis-solutions/cli-server-python
+Project-URL: Issues, https://github.com/qodalis-solutions/cli-server-python/issues
+Author-email: Nicolae Lupei <nicolae.lupei@qodalis.com>
+License-Expression: MIT
+Keywords: cli,data-explorer,mssql,plugin,qodalis,sql-server
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: pymssql>=2.3.0
+Requires-Dist: qodalis-cli-server-abstractions

qodalis_cli_server_plugin_data_explorer_mssql-1.0.0b18.dist-info/RECORD

@@ -0,0 +1,5 @@
+qodalis_cli_data_explorer_mssql/__init__.py,sha256=mDbSMloN-aeqfQy0j_u-dC-XeluO2FrkdVuPN_KVLDc,169
+qodalis_cli_data_explorer_mssql/mssql_provider.py,sha256=uEFZFy3ydH0xAtA5HSXM7SPzzSJsAyzrbw5T_yM4cAE,7822
+qodalis_cli_server_plugin_data_explorer_mssql-1.0.0b18.dist-info/METADATA,sha256=BqmGgNjFQQ98-xzaIcxLtTYzEeRXpiPY-VdxRgoCK6k,1041
+qodalis_cli_server_plugin_data_explorer_mssql-1.0.0b18.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+qodalis_cli_server_plugin_data_explorer_mssql-1.0.0b18.dist-info/RECORD,,

qodalis_cli_server_plugin_data_explorer_mssql-1.0.0b18.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any