baucli 1.0.1__py3-none-any.whl

baucli/db/mysql.py

@@ -0,0 +1,388 @@
+"""BAUCLI — MySQL database extractor.
+
+Uses mysql-connector-python.
+Extracts:
+  - Functions from INFORMATION_SCHEMA.ROUTINES + SHOW CREATE FUNCTION
+  - Procedures from INFORMATION_SCHEMA.ROUTINES + SHOW CREATE PROCEDURE
+  - Triggers from INFORMATION_SCHEMA.TRIGGERS + SHOW CREATE TRIGGER
+  - Views from INFORMATION_SCHEMA.VIEWS + SHOW CREATE VIEW
+  - Table metadata from INFORMATION_SCHEMA.COLUMNS, TABLE_CONSTRAINTS, etc.
+
+In MySQL, schema = database (they are the same concept).
+"""
+
+from typing import Optional
+from baucli.db import BaseExtractor
+
+
+class MySQLExtractor(BaseExtractor):
+    """MySQL database extractor using mysql-connector-python."""
+
+    engine = "MYSQL"
+
+    def connect(self):
+        import mysql.connector
+        from baucli import __version__
+        self._conn = mysql.connector.connect(
+            host=self.host,
+            port=self.port,
+            database=self.database,
+            user=self.user,
+            password=self.password,
+            charset='utf8mb4',
+            connection_timeout=30,
+        )
+        # Set application name via session variable
+        try:
+            cur = self._conn.cursor()
+            cur.execute(f"SET @baucli = 'BAUCLI v{__version__}'")
+            cur.close()
+        except Exception:
+            pass
+
+    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 DATABASE()")
+        row = cur.fetchone()
+        db_name = row[0] if row else "Unknown"
+        cur.execute("SELECT CURRENT_USER()")
+        row = cur.fetchone()
+        current_user = row[0] if row else "Unknown"
+        cur.close()
+        return {
+            "status": "ok",
+            "engine": "MYSQL",
+            "version": version,
+            "db_name": db_name,
+            "current_schema": current_user,
+        }
+
+    def get_native_identifier(self) -> Optional[str]:
+        try:
+            cur = self._conn.cursor()
+            cur.execute("SELECT @@server_uuid")
+            row = cur.fetchone()
+            cur.close()
+            return str(row[0]) if row else None
+        except Exception:
+            try:
+                cur = self._conn.cursor()
+                cur.execute("SELECT @@server_id")
+                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 INFORMATION_SCHEMA.ROUTINES
+            WHERE ROUTINE_SCHEMA = %s
+        """, (schema,))
+        cnt = cur.fetchone()[0]
+        # Add triggers
+        cur.execute("""
+            SELECT COUNT(*) FROM INFORMATION_SCHEMA.TRIGGERS
+            WHERE TRIGGER_SCHEMA = %s
+        """, (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 INFORMATION_SCHEMA.TABLES
+            WHERE TABLE_SCHEMA = %s AND TABLE_TYPE IN ('BASE TABLE', 'VIEW')
+        """, (schema,))
+        cnt = cur.fetchone()[0]
+        cur.close()
+        return cnt
+
+    def extract_sequences(self, schema: str) -> list:
+        """MySQL nao tem objetos SEQUENCE (usa AUTO_INCREMENT em coluna).
+
+        DOCSEQ fica vazio para MySQL — nada a enviar. (MariaDB 10.3+ tem
+        SEQUENCE, mas fica fora do escopo desta fase.)
+        """
+        return []
+
+    def extract_objects(self, schema: str, since_date: str = None, on_progress=None, name_filter: str = None) -> list:
+        """Extract functions, procedures, triggers, and views from MySQL.
+
+        In MySQL, schema = database name.
+
+        Args:
+            schema: Database name
+            since_date: Filter by LAST_ALTERED (for routines) or CREATED (for triggers)
+        """
+        result = []
+        cur = self._conn.cursor()
+
+        # ═══ Functions ═══
+        date_filter = ""
+        params = [schema]
+        if since_date:
+            date_filter = "AND LAST_ALTERED >= %s"
+            params.append(since_date[:19])  # Trim to YYYY-MM-DDTHH:MI:SS
+
+        cur.execute(f"""
+            SELECT ROUTINE_NAME, ROUTINE_TYPE,
+                   REPLACE(CAST(LAST_ALTERED AS CHAR), ' ', 'T') AS LAST_DDL,
+                   ROUTINE_COMMENT
+            FROM INFORMATION_SCHEMA.ROUTINES
+            WHERE ROUTINE_SCHEMA = %s
+            AND   ROUTINE_TYPE IN ('FUNCTION', 'PROCEDURE')
+            {date_filter}
+            ORDER BY ROUTINE_TYPE, ROUTINE_NAME
+        """, params)
+
+        routines = cur.fetchall()
+        total_routines = len(routines)
+        for idx, (name, rtype, last_ddl, comment) in enumerate(routines):
+            if on_progress:
+                on_progress(idx + 1, total_routines, name)
+            try:
+                cur.execute(f"SHOW CREATE {rtype} `{schema}`.`{name}`")
+                row = cur.fetchone()
+                # SHOW CREATE returns: (name, sql_mode, create_stmt, ...)
+                source = row[2] if row and len(row) > 2 else None
+                if not source and row and len(row) > 1:
+                    source = row[1]
+            except Exception:
+                source = None
+
+            if source:
+                entry = {
+                    "name": name,
+                    "type": rtype,
+                    "source": source,
+                    "last_ddl": last_ddl,
+                }
+                if comment:
+                    entry["description"] = comment
+                result.append(entry)
+
+        # ═══ Triggers ═══
+        trig_params = [schema]
+        trig_date_filter = ""
+        if since_date:
+            trig_date_filter = "AND CREATED >= %s"
+            trig_params.append(since_date[:19])
+
+        try:
+            cur.execute(f"""
+                SELECT TRIGGER_NAME,
+                       EVENT_OBJECT_TABLE,
+                       ACTION_TIMING,
+                       EVENT_MANIPULATION,
+                       REPLACE(CAST(CREATED AS CHAR), ' ', 'T') AS LAST_DDL
+                FROM INFORMATION_SCHEMA.TRIGGERS
+                WHERE TRIGGER_SCHEMA = %s
+                {trig_date_filter}
+                ORDER BY TRIGGER_NAME
+            """, trig_params)
+
+            triggers = cur.fetchall()
+            for name, table_name, timing, event, last_ddl in triggers:
+                try:
+                    cur.execute(f"SHOW CREATE TRIGGER `{schema}`.`{name}`")
+                    row = cur.fetchone()
+                    # SHOW CREATE TRIGGER returns: (name, sql_mode, create_stmt, ...)
+                    source = row[2] if row and len(row) > 2 else None
+                except Exception:
+                    source = None
+
+                if source:
+                    result.append({
+                        "name": name,
+                        "type": "TRIGGER",
+                        "source": source,
+                        "last_ddl": last_ddl,
+                        "description": f"Trigger on {table_name} ({timing} {event})",
+                    })
+        except Exception:
+            pass  # Skip triggers if query fails
+
+        # Views are extracted via extract_tables (as DOCTAB entries, not PL/SQL objects)
+
+        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.
+
+        Args:
+            schema: Database name (MySQL schema = database)
+            since_date: Filter by UPDATE_TIME
+        """
+        result = []
+        cur = self._conn.cursor()
+
+        # Get tables AND views
+        date_filter = ""
+        params = [schema]
+        if since_date:
+            date_filter = "AND (t.UPDATE_TIME >= %s OR t.CREATE_TIME >= %s)"
+            params.extend([since_date[:19], since_date[:19]])
+
+        cur.execute(f"""
+            SELECT t.TABLE_NAME,
+                   REPLACE(CAST(COALESCE(t.UPDATE_TIME, t.CREATE_TIME) AS CHAR), ' ', 'T') AS LAST_DDL,
+                   t.TABLE_COMMENT,
+                   t.TABLE_TYPE
+            FROM INFORMATION_SCHEMA.TABLES t
+            WHERE t.TABLE_SCHEMA = %s
+            AND   t.TABLE_TYPE IN ('BASE TABLE', 'VIEW')
+            {date_filter}
+            ORDER BY t.TABLE_TYPE, t.TABLE_NAME
+        """, params)
+
+        tables = cur.fetchall()
+        total_tbl = len(tables)
+
+        if total_tbl == 0:
+            cur.close()
+            return []
+
+        CHUNK = 500
+
+        # ═══ Pre-load columns in chunks ═══
+        all_columns = {}
+        table_names = [t[0] for t in tables]
+        col_count = 0
+
+        import time as _time
+        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 TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE,
+                       COLUMN_DEFAULT, COLUMN_COMMENT, COLUMN_KEY, ORDINAL_POSITION
+                FROM INFORMATION_SCHEMA.COLUMNS
+                WHERE TABLE_SCHEMA = %s AND TABLE_NAME IN ({placeholders})
+                ORDER BY TABLE_NAME, 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[2], "nullable": row[3],
+                    "default": str(row[4]) if row[4] is not None else None,
+                    "comment": row[5] if row[5] else None,
+                    "is_pk": "Y" if row[6] == "PRI" else "N",
+                })
+                col_count += 1
+            chunk_times.append(_time.time() - t0)
+
+        if on_progress:
+            on_progress(0, total_tbl, f"columns done ({col_count})")
+
+        if on_progress:
+            on_progress(0, total_tbl, "loading constraints...")
+
+        # ═══ Pre-load ALL constraints ═══
+        all_constraints = {}
+        try:
+            cur.execute("""
+                SELECT tc.TABLE_NAME, tc.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE,
+                       rc.REFERENCED_TABLE_NAME
+                FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+                LEFT JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
+                    ON rc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+                    AND rc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
+                    AND rc.TABLE_NAME = tc.TABLE_NAME
+                WHERE tc.TABLE_SCHEMA = %s
+                AND tc.CONSTRAINT_TYPE IN ('UNIQUE', 'FOREIGN KEY', 'CHECK')
+                ORDER BY tc.TABLE_NAME, tc.CONSTRAINT_TYPE
+            """, (schema,))
+            for tname, cname, ctype, ref_table in cur.fetchall():
+                if tname not in all_constraints:
+                    all_constraints[tname] = []
+                bau_type = {'UNIQUE': 'U', 'FOREIGN KEY': 'R', 'CHECK': 'C'}.get(ctype, ctype)
+                c = {"name": cname, "type": bau_type}
+                if ref_table:
+                    c["ref_table"] = ref_table
+                all_constraints[tname].append(c)
+        except Exception:
+            pass
+
+        if on_progress:
+            on_progress(0, total_tbl, "building entries...")
+
+        # ═══ Build results per table ═══
+        for idx, (table_name, last_ddl, table_comment, mysql_type) in enumerate(tables):
+            if on_progress:
+                on_progress(idx + 1, total_tbl, table_name)
+            bau_type = 'VIEW' if mysql_type == 'VIEW' else 'TABLE'
+
+            # View source (per-object — small number)
+            view_source = None
+            if bau_type == 'VIEW':
+                try:
+                    cur.execute("""
+                        SELECT VIEW_DEFINITION FROM INFORMATION_SCHEMA.VIEWS
+                        WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s
+                    """, (schema, table_name))
+                    row = cur.fetchone()
+                    if row and row[0]:
+                        view_source = f"CREATE OR REPLACE VIEW `{schema}`.`{table_name}` AS\n{row[0]}"
+                except Exception:
+                    pass
+
+            # Columns from pre-loaded dict
+            columns = []
+            for c in all_columns.get(table_name, []):
+                col = {"name": c["name"], "type": c["type"], "nullable": c["nullable"], "is_pk": c["is_pk"]}
+                if c["default"]:
+                    col["default"] = c["default"]
+                if c["comment"]:
+                    col["comment"] = c["comment"]
+                columns.append(col)
+
+            constraints = all_constraints.get(table_name, [])
+
+            entry = {
+                "name": table_name,
+                "type": bau_type,
+                "last_ddl": last_ddl,
+                "columns": columns,
+            }
+            if table_comment:
+                entry["comment"] = table_comment
+            if constraints:
+                entry["constraints"] = constraints
+            if view_source:
+                entry["source"] = view_source
+            result.append(entry)
+
+        cur.close()
+        return result