baucli 1.0.1__py3-none-any.whl

baucli/db/mssql.py

@@ -0,0 +1,443 @@
+"""BAUCLI — SQL Server database extractor.
+
+Uses python-tds (pytds) — pure Python, no compilation needed.
+Works on Windows, macOS, Linux without FreeTDS or Visual C++.
+Extracts:
+  - Functions from sys.objects + OBJECT_DEFINITION()
+  - Procedures from sys.objects + OBJECT_DEFINITION()
+  - Triggers from sys.triggers + OBJECT_DEFINITION()
+  - Views from sys.views + OBJECT_DEFINITION()
+  - Table metadata from INFORMATION_SCHEMA.COLUMNS, sys.indexes, etc.
+"""
+
+from typing import Optional
+from baucli.db import BaseExtractor
+
+
+class MSSQLExtractor(BaseExtractor):
+    """SQL Server database extractor using pytds."""
+
+    engine = "MSSQL"
+
+    def connect(self):
+        import pytds
+        from baucli import __version__
+        self._conn = pytds.connect(
+            server=self.host,
+            port=self.port,
+            database=self.database,
+            user=self.user,
+            password=self.password,
+            appname=f"BAUCLI v{__version__}",
+            login_timeout=60,
+            timeout=14400,  # 4 hours query timeout for large schemas
+            autocommit=True,
+        )
+
+    def disconnect(self):
+        if self._conn:
+            try:
+                self._conn.close()
+            except Exception:
+                pass
+            self._conn = None
+
+    def test_connection(self) -> dict:
+        cur = self._conn.cursor()
+        cur.execute("SELECT @@VERSION")
+        row = cur.fetchone()
+        version = row[0] if row else "Unknown"
+        cur.execute("SELECT DB_NAME()")
+        row = cur.fetchone()
+        db_name = row[0] if row else "Unknown"
+        cur.execute("SELECT SCHEMA_NAME()")
+        row = cur.fetchone()
+        current_schema = row[0] if row else "dbo"
+        cur.close()
+        return {
+            "status": "ok",
+            "engine": "MSSQL",
+            "version": version.split('\n')[0] if version else "Unknown",
+            "db_name": db_name,
+            "current_schema": current_schema,
+        }
+
+    def get_native_identifier(self) -> Optional[str]:
+        try:
+            cur = self._conn.cursor()
+            cur.execute("SELECT SERVERPROPERTY('ServerName')")
+            row = cur.fetchone()
+            cur.close()
+            return str(row[0]) if row else None
+        except Exception:
+            return None
+
+    def count_objects(self, schema: str) -> int:
+        cur = self._conn.cursor()
+        cur.execute("""
+            SELECT COUNT(*) FROM sys.objects o
+            JOIN sys.schemas s ON s.schema_id = o.schema_id
+            WHERE s.name = %s AND o.type IN ('P', 'FN', 'IF', 'TF', 'AF', 'TR')
+            AND o.is_ms_shipped = 0
+        """, (schema,))
+        cnt = cur.fetchone()[0]
+        cur.close()
+        return cnt
+
+    def count_tables(self, schema: str) -> int:
+        cur = self._conn.cursor()
+        cur.execute("""
+            SELECT COUNT(*) FROM sys.objects o
+            JOIN sys.schemas s ON s.schema_id = o.schema_id
+            WHERE s.name = %s AND o.type IN ('U', 'V') AND o.is_ms_shipped = 0
+        """, (schema,))
+        cnt = cur.fetchone()[0]
+        cur.close()
+        return cnt
+
+    def extract_sequences(self, schema: str) -> list:
+        """Sequences do schema (sys.sequences, SQL Server 2012+).
+
+        IDENTITY columns NAO sao sequences (o vinculo de identity nao entra
+        aqui). O servidor persiste os metadados e roda DISCOVER (default de
+        coluna `NEXT VALUE FOR seq`).
+        """
+        cur = self._conn.cursor()
+        try:
+            cur.execute("""
+                SELECT sch.name, seq.name, seq.minimum_value, seq.maximum_value,
+                       seq.increment, seq.is_cycling, seq.cache_size, seq.current_value
+                  FROM sys.sequences seq
+                  JOIN sys.schemas sch ON sch.schema_id = seq.schema_id
+                 WHERE sch.name = %s
+            """, (schema,))
+            rows = cur.fetchall()
+        except Exception:
+            rows = []
+        cur.close()
+
+        def _n(v):
+            return int(v) if v is not None else None
+
+        out = []
+        for r in rows:
+            cyc = "Y" if (r[5] in (1, True)) else "N"
+            out.append({"owner": r[0], "sequence_name": r[1],
+                        "min_value": _n(r[2]), "max_value": _n(r[3]),
+                        "increment_by": _n(r[4]),
+                        "cycle_flag": cyc, "order_flag": "N",
+                        "cache_size": _n(r[6]), "last_number": _n(r[7])})
+        return out
+
+    def extract_objects(self, schema: str, since_date: str = None, on_progress=None, name_filter: str = None) -> list:
+        """Extract functions, procedures, triggers from SQL Server.
+
+        Uses two-pass strategy: fast listing query, then OBJECT_DEFINITION per object
+        for real-time progress reporting.
+        """
+        result = []
+        cur = self._conn.cursor()
+
+        # ═══ Functions, Procedures ═══
+        date_filter = ""
+        params = [schema]
+        if since_date:
+            date_filter = "AND o.modify_date >= %s"
+            params.append(since_date[:19])
+
+        # Pass 1: fast listing (no OBJECT_DEFINITION — instant)
+        cur.execute(f"""
+            SELECT o.name,
+                   CASE o.type
+                       WHEN 'P'  THEN 'PROCEDURE'
+                       WHEN 'FN' THEN 'FUNCTION'
+                       WHEN 'IF' THEN 'FUNCTION'
+                       WHEN 'TF' THEN 'FUNCTION'
+                       WHEN 'AF' THEN 'FUNCTION'
+                   END AS type,
+                   CONVERT(VARCHAR(19), o.modify_date, 126) AS last_ddl,
+                   o.object_id
+            FROM sys.objects o
+            JOIN sys.schemas s ON s.schema_id = o.schema_id
+            WHERE s.name = %s
+            AND   o.type IN ('P', 'FN', 'IF', 'TF', 'AF')
+            AND   o.is_ms_shipped = 0
+            {date_filter}
+            ORDER BY o.type, o.name
+        """, tuple(params))
+
+        obj_list = cur.fetchall()
+        total_obj = len(obj_list)
+
+        # Pass 2: get source per object (progress callback per item)
+        for idx, (name, obj_type, last_ddl, obj_id) in enumerate(obj_list):
+            if on_progress:
+                on_progress(idx + 1, total_obj, name)
+
+            try:
+                cur.execute("SELECT CAST(OBJECT_DEFINITION(%s) AS NVARCHAR(MAX))", (obj_id,))
+                row = cur.fetchone()
+                source = row[0] if row and row[0] else None
+            except Exception:
+                source = None
+
+            if source:
+                result.append({
+                    "name": name,
+                    "type": obj_type,
+                    "source": source,
+                    "last_ddl": last_ddl,
+                })
+
+        # ═══ Triggers ═══
+        trig_params = [schema]
+        trig_date_filter = ""
+        if since_date:
+            trig_date_filter = "AND t.modify_date >= %s"
+            trig_params.append(since_date[:19])
+
+        try:
+            cur.execute(f"""
+                SELECT t.name,
+                       CONVERT(VARCHAR(19), t.modify_date, 126) AS last_ddl,
+                       CAST(OBJECT_DEFINITION(t.object_id) AS NVARCHAR(MAX)) AS source,
+                       OBJECT_NAME(t.parent_id) AS table_name,
+                       CASE WHEN t.is_instead_of_trigger = 1 THEN 'INSTEAD OF' ELSE 'AFTER' END AS timing
+                FROM sys.triggers t
+                JOIN sys.objects o ON o.object_id = t.parent_id
+                JOIN sys.schemas s ON s.schema_id = o.schema_id
+                WHERE s.name = %s
+                AND   t.is_ms_shipped = 0
+                {trig_date_filter}
+                ORDER BY t.name
+            """, tuple(trig_params))
+
+            trg_rows = cur.fetchall()
+            for name, last_ddl, source, table_name, timing in trg_rows:
+                if on_progress:
+                    on_progress(total_obj + len([r for r in result if r['type']=='TRIGGER']) + 1,
+                                total_obj + len(trg_rows), name)
+                if source:
+                    result.append({
+                        "name": name,
+                        "type": "TRIGGER",
+                        "source": source,
+                        "last_ddl": last_ddl,
+                        "description": f"Trigger on {table_name} ({timing})",
+                    })
+        except Exception:
+            pass
+
+        cur.close()
+        return result
+
+    def extract_tables(self, schema: str, since_date: str = None, on_progress=None, name_filter: str = None) -> list:
+        """Extract table metadata from INFORMATION_SCHEMA and sys views.
+
+        Args:
+            schema: Schema name (e.g. 'dbo')
+            since_date: Filter by modify_date
+        """
+        result = []
+        cur = self._conn.cursor()
+
+        # Get tables AND views
+        date_filter = ""
+        params = [schema]
+        if since_date:
+            date_filter = "AND o.modify_date >= %s"
+            params.append(since_date[:19])
+
+        cur.execute(f"""
+            SELECT o.name AS TABLE_NAME,
+                   CONVERT(VARCHAR(19), o.modify_date, 126) AS last_ddl,
+                   CASE o.type WHEN 'U' THEN 'TABLE' WHEN 'V' THEN 'VIEW' END AS table_type,
+                   CAST(OBJECT_DEFINITION(o.object_id) AS NVARCHAR(MAX)) AS view_source
+            FROM sys.objects o
+            JOIN sys.schemas s ON s.schema_id = o.schema_id
+            WHERE s.name = %s
+            AND   o.type IN ('U', 'V')
+            AND   o.is_ms_shipped = 0
+            {date_filter}
+            ORDER BY o.type, o.name
+        """, tuple(params))
+
+        tables = cur.fetchall()
+        total_tbl = len(tables)
+
+        if total_tbl == 0:
+            cur.close()
+            return []
+
+        # Report progress during pre-load phases
+        CHUNK = 500  # Process in chunks for large schemas
+        import time as _time
+
+        # ═══ Pre-load columns in chunks ═══
+        all_columns = {}
+        col_count = 0
+        table_names = [t[0] for t in tables]
+        total_chunks = (len(table_names) + CHUNK - 1) // CHUNK
+        chunk_times = []
+
+        for ci, cs in enumerate(range(0, len(table_names), CHUNK)):
+            chunk = table_names[cs:cs + CHUNK]
+            t0 = _time.time()
+
+            eta = ""
+            if len(chunk_times) >= 2:
+                avg = sum(chunk_times) / len(chunk_times)
+                remaining = total_chunks - ci
+                eta_s = int(remaining * avg)
+                eta = f" ETA {eta_s//60}m{eta_s%60:02d}s" if eta_s >= 60 else f" ETA {eta_s}s"
+
+            if on_progress:
+                on_progress(0, total_tbl, f"loading columns {cs}/{total_tbl}{eta}")
+
+            placeholders = ','.join(['%s'] * len(chunk))
+            cur.execute(f"""
+                SELECT c.TABLE_NAME, c.COLUMN_NAME, c.DATA_TYPE,
+                       CASE
+                           WHEN c.DATA_TYPE IN ('varchar','nvarchar','char','nchar')
+                               THEN c.DATA_TYPE + '(' + CASE WHEN c.CHARACTER_MAXIMUM_LENGTH = -1 THEN 'MAX' ELSE CAST(c.CHARACTER_MAXIMUM_LENGTH AS VARCHAR) END + ')'
+                           WHEN c.DATA_TYPE IN ('decimal','numeric')
+                               THEN c.DATA_TYPE + '(' + CAST(c.NUMERIC_PRECISION AS VARCHAR) + ',' + CAST(c.NUMERIC_SCALE AS VARCHAR) + ')'
+                           ELSE c.DATA_TYPE
+                       END AS full_type,
+                       c.IS_NULLABLE, c.COLUMN_DEFAULT, c.ORDINAL_POSITION
+                FROM INFORMATION_SCHEMA.COLUMNS c
+                WHERE c.TABLE_SCHEMA = %s AND c.TABLE_NAME IN ({placeholders})
+                ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION
+            """, tuple([schema] + chunk))
+            for row in cur.fetchall():
+                tname = row[0]
+                if tname not in all_columns:
+                    all_columns[tname] = []
+                all_columns[tname].append({
+                    "name": row[1], "type": row[3],
+                    "nullable": row[4], "default": str(row[5]) if row[5] else None,
+                    "ordinal": row[6],
+                })
+                col_count += 1
+            chunk_times.append(_time.time() - t0)
+
+        if on_progress:
+            on_progress(0, total_tbl, f"columns done ({col_count}), loading PKs...")
+
+        # ═══ Pre-load ALL primary keys ═══
+        pk_cols = set()
+        try:
+            cur.execute("""
+                SELECT ku.TABLE_NAME, ku.COLUMN_NAME
+                FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+                JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku
+                    ON ku.CONSTRAINT_NAME = tc.CONSTRAINT_NAME AND ku.TABLE_SCHEMA = tc.TABLE_SCHEMA
+                WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY' AND tc.TABLE_SCHEMA = %s
+            """, (schema,))
+            for tname, cname in cur.fetchall():
+                pk_cols.add(f"{tname}.{cname}")
+        except Exception:
+            pass
+
+        if on_progress:
+            on_progress(0, total_tbl, f"PKs loaded ({len(pk_cols)}), loading comments...")
+
+        # ═══ Pre-load ALL table comments (extended properties) ═══
+        table_comments = {}
+        try:
+            cur.execute("""
+                SELECT o.name, CAST(ep.value AS VARCHAR(500))
+                FROM sys.extended_properties ep
+                JOIN sys.objects o ON o.object_id = ep.major_id
+                JOIN sys.schemas s ON s.schema_id = o.schema_id
+                WHERE s.name = %s AND ep.name = 'MS_Description' AND ep.minor_id = 0
+            """, (schema,))
+            for tname, comment in cur.fetchall():
+                table_comments[tname] = comment
+        except Exception:
+            pass
+
+        if on_progress:
+            on_progress(0, total_tbl, f"comments loaded, loading col comments...")
+
+        # ═══ Pre-load ALL column comments ═══
+        col_comments = {}
+        try:
+            cur.execute("""
+                SELECT o.name AS table_name, c.name AS column_name, CAST(ep.value AS VARCHAR(500))
+                FROM sys.extended_properties ep
+                JOIN sys.columns c ON c.object_id = ep.major_id AND c.column_id = ep.minor_id
+                JOIN sys.objects o ON o.object_id = ep.major_id
+                JOIN sys.schemas s ON s.schema_id = o.schema_id
+                WHERE s.name = %s AND ep.name = 'MS_Description' AND ep.minor_id > 0
+            """, (schema,))
+            for tname, cname, comment in cur.fetchall():
+                col_comments[f"{tname}.{cname}"] = comment
+        except Exception:
+            pass
+
+        if on_progress:
+            on_progress(0, total_tbl, f"loading constraints...")
+
+        # ═══ Pre-load ALL constraints ═══
+        all_constraints = {}
+        try:
+            cur.execute("""
+                SELECT tc.TABLE_NAME, tc.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE,
+                       STRING_AGG(ku.COLUMN_NAME, ',') WITHIN GROUP (ORDER BY ku.ORDINAL_POSITION) AS columns
+                FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+                JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku
+                    ON ku.CONSTRAINT_NAME = tc.CONSTRAINT_NAME AND ku.TABLE_SCHEMA = tc.TABLE_SCHEMA
+                WHERE tc.TABLE_SCHEMA = %s
+                GROUP BY tc.TABLE_NAME, tc.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE
+                ORDER BY tc.TABLE_NAME, tc.CONSTRAINT_TYPE, tc.CONSTRAINT_NAME
+            """, (schema,))
+            for tname, cname, ctype, cols in cur.fetchall():
+                if tname not in all_constraints:
+                    all_constraints[tname] = []
+                all_constraints[tname].append({
+                    "name": cname, "type": ctype, "columns": cols,
+                })
+        except Exception:
+            pass
+
+        if on_progress:
+            on_progress(0, total_tbl, f"all metadata loaded, building {total_tbl} entries...")
+
+        # ═══ Build results per table ═══
+        for idx, (table_name, last_ddl, table_type, view_src) in enumerate(tables):
+            if on_progress:
+                on_progress(idx + 1, total_tbl, table_name)
+
+            # Columns from pre-loaded dict
+            columns = []
+            for c in all_columns.get(table_name, []):
+                col = {"name": c["name"], "type": c["type"], "nullable": c["nullable"]}
+                if f"{table_name}.{c['name']}" in pk_cols:
+                    col["is_pk"] = "Y"
+                if c["default"]:
+                    col["default"] = c["default"]
+                comment = col_comments.get(f"{table_name}.{c['name']}")
+                if comment:
+                    col["comment"] = comment
+                columns.append(col)
+
+            table_comment = table_comments.get(table_name)
+            constraints = all_constraints.get(table_name, [])
+
+            entry = {
+                "name": table_name,
+                "type": table_type,
+                "last_ddl": last_ddl,
+                "columns": columns,
+            }
+            if table_comment:
+                entry["comment"] = table_comment
+            if constraints:
+                entry["constraints"] = constraints
+            if view_src:
+                entry["source"] = view_src
+            result.append(entry)
+
+        cur.close()
+        return result