src/databao_context_engine/plugins/databases/mssql_introspector.py [104:302]:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        return TableBuilder.build_from_components(
            rels=results.get("relations", []),
            cols=results.get("columns", []),
            pk_cols=results.get("pk", []),
            uq_cols=results.get("uq", []),
            checks=results.get("checks", []),
            fk_cols=results.get("fks", []),
            idx_cols=results.get("idx", []),
        )

    def _component_queries(self) -> dict[str, str]:
        return {
            "relations": self._sql_relations(),
            "columns": self._sql_columns(),
            "pk": self._sql_primary_keys(),
            "uq": self._sql_uniques(),
            "checks": self._sql_checks(),
            "fks": self._sql_foreign_keys(),
            "idx": self._sql_indexes(),
        }

    def _sql_relations(self) -> str:
        return r"""
            SELECT
                t.name AS table_name,
                'table' AS kind,
                CAST(ep.value AS nvarchar(4000)) AS description
            FROM 
                sys.tables t
                JOIN sys.schemas s ON s.schema_id = t.schema_id
                LEFT JOIN sys.extended_properties ep 
                          ON ep.major_id = t.object_id AND ep.minor_id = 0 AND ep.class = 1 AND ep.name = 'MS_Description'
            WHERE 
                s.name = {SCHEMA}
            UNION ALL
            SELECT
                v.name                    AS table_name,
                'view'                    AS kind,
                CAST(ep.value AS nvarchar(4000)) AS description
            FROM 
                sys.views v
                JOIN sys.schemas s ON s.schema_id = v.schema_id
                LEFT JOIN sys.extended_properties ep 
                          ON ep.major_id = v.object_id AND ep.minor_id = 0 AND ep.class = 1 AND ep.name = 'MS_Description'
            WHERE 
                s.name = {SCHEMA}
            UNION ALL
            SELECT
                et.name AS table_name,
                'external_table' AS kind,
                CAST(ep.value AS nvarchar(4000)) AS description
            FROM 
                sys.external_tables et
                JOIN sys.schemas s ON s.schema_id = et.schema_id
                LEFT JOIN sys.extended_properties ep 
                          ON ep.major_id = et.object_id AND ep.minor_id = 0 AND ep.class = 1 AND ep.name = 'MS_Description'
            WHERE 
                s.name = {SCHEMA}
            ORDER BY 
                table_name;
        """

    # TODO: simplify case when for datatype
    def _sql_columns(self) -> str:
        return r"""
            SELECT
                o.name AS table_name,
                c.name AS column_name,
                c.column_id AS ordinal_position,
                CASE
                    WHEN t.name IN ('varchar','char','varbinary','binary') THEN t.name + '(' + CASE WHEN c.max_length = -1 THEN 'MAX' ELSE CAST(c.max_length AS varchar(10)) END + ')'
                    WHEN t.name IN ('nvarchar','nchar') THEN t.name + '(' + CASE WHEN c.max_length = -1 THEN 'MAX' ELSE CAST(c.max_length / 2 AS varchar(10)) END + ')'
                    WHEN t.name IN ('decimal','numeric') THEN t.name + '(' + CAST(c.precision AS varchar(10)) + ',' + CAST(c.scale AS varchar(10)) + ')'
                    ELSE t.name
                END AS data_type,
                CAST(c.is_nullable AS bit) AS is_nullable,
                CASE
                    WHEN cc.object_id IS NOT NULL THEN CAST(cc.definition AS nvarchar(4000))
                    ELSE CAST(dc.definition AS nvarchar(4000))
                END AS default_expression,
                CASE
                    WHEN c.is_identity = 1 THEN 'identity'
                    WHEN c.is_computed = 1 THEN 'computed'
                END AS generated,
                CAST(ep.value AS nvarchar(4000)) AS description
            FROM 
                sys.columns c
                JOIN sys.objects o ON o.object_id = c.object_id AND o.type IN ('U','V')
                JOIN sys.schemas s ON s.schema_id = o.schema_id
                JOIN sys.types t ON t.user_type_id = c.user_type_id
                LEFT JOIN sys.computed_columns cc ON cc.object_id = c.object_id AND cc.column_id = c.column_id    
                LEFT JOIN sys.default_constraints dc ON dc.object_id = c.default_object_id
                LEFT JOIN sys.extended_properties ep ON ep.class = 1 AND ep.major_id = c.object_id AND ep.minor_id = c.column_id AND ep.name = 'MS_Description'
            WHERE 
                s.name = {SCHEMA}
            ORDER BY 
                o.name, 
                c.column_id;
        """

    def _sql_primary_keys(self) -> str:
        return r"""
            SELECT
                t.name AS table_name,
                kc.name AS constraint_name,
                c.name AS column_name,
                ic.key_ordinal AS position
            FROM 
                sys.key_constraints kc
                JOIN sys.tables t ON t.object_id = kc.parent_object_id
                JOIN sys.schemas s ON s.schema_id = t.schema_id
                JOIN sys.index_columns ic ON ic.object_id = kc.parent_object_id AND ic.index_id = kc.unique_index_id AND ic.is_included_column = 0
                JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
            WHERE 
                s.name = {SCHEMA}
                AND kc.type = 'PK'
            ORDER BY 
                t.name, 
                kc.name, 
                ic.key_ordinal;
        """

    def _sql_uniques(self) -> str:
        return r"""
            SELECT
                t.name AS table_name,
                kc.name AS constraint_name,
                c.name AS column_name,
                ic.key_ordinal AS position
            FROM 
                sys.key_constraints kc
                JOIN sys.tables t ON t.object_id = kc.parent_object_id
                JOIN sys.schemas s ON s.schema_id = t.schema_id
                JOIN sys.index_columns ic ON ic.object_id = kc.parent_object_id AND ic.index_id = kc.unique_index_id AND ic.is_included_column = 0
                JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
            WHERE 
                s.name = {SCHEMA}
                AND kc.type = 'UQ'
            ORDER BY 
                t.name, 
                kc.name, 
                ic.key_ordinal;
        """

    def _sql_checks(self) -> str:
        return r"""
            SELECT
                t.name AS table_name,
                cc.name AS constraint_name,
                CAST(cc.definition AS nvarchar(4000)) AS expression,
                CAST(CASE 
                         WHEN cc.is_not_trusted = 0 THEN 1 
                         ELSE 0 
                    END AS bit) AS validated
            FROM 
                sys.check_constraints cc
                JOIN sys.tables t ON t.object_id = cc.parent_object_id
                JOIN sys.schemas s ON s.schema_id = t.schema_id
            WHERE 
                s.name = {SCHEMA}
            ORDER BY 
                t.name, 
                cc.name;
        """

    def _sql_foreign_keys(self) -> str:
        return r"""
            SELECT
                t.name AS table_name,
                fk.name AS constraint_name,
                fkc.constraint_column_id AS position,
                pc.name AS from_column,
                rs.name AS ref_schema,
                rt.name AS ref_table,
                rc.name AS to_column,
                CAST(CASE WHEN fk.is_disabled = 0 THEN 1 ELSE 0 END AS bit) AS enforced,
                CAST(CASE WHEN fk.is_not_trusted = 0 THEN 1 ELSE 0 END AS bit) AS validated,
                LOWER(fk.update_referential_action_desc) AS on_update,
                LOWER(fk.delete_referential_action_desc) AS on_delete
            FROM 
                sys.foreign_keys fk
                JOIN sys.tables t   ON t.object_id = fk.parent_object_id
                JOIN sys.schemas s  ON s.schema_id = t.schema_id
                JOIN sys.tables rt  ON rt.object_id = fk.referenced_object_id
                JOIN sys.schemas rs ON rs.schema_id = rt.schema_id
                JOIN sys.foreign_key_columns fkc ON fkc.constraint_object_id = fk.object_id
                JOIN sys.columns pc ON pc.object_id = fkc.parent_object_id    AND pc.column_id = fkc.parent_column_id
                JOIN sys.columns rc ON rc.object_id = fkc.referenced_object_id AND rc.column_id = fkc.referenced_column_id
            WHERE 
                s.name = {SCHEMA}
            ORDER BY 
                t.name, 
                fk.name, 
                fkc.constraint_column_id;
        """

    # TODO: case when is confusing
    def _sql_indexes(self) -> str:
        return r"""
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -



src/databao_context_engine/plugins/databases/mysql_introspector.py [89:246]:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        return TableBuilder.build_from_components(
            rels=results.get("relations", []),
            cols=results.get("columns", []),
            pk_cols=results.get("pk", []),
            uq_cols=results.get("uq", []),
            checks=results.get("checks", []),
            fk_cols=results.get("fks", []),
            idx_cols=results.get("idx", []),
        )

    def _component_queries(self) -> dict[str, str]:
        return {
            "relations": self._sql_relations(),
            "columns": self._sql_columns(),
            "pk": self._sql_primary_keys(),
            "uq": self._sql_uniques(),
            "checks": self._sql_checks(),
            "fks": self._sql_foreign_keys(),
            "idx": self._sql_indexes(),
        }

    def _sql_relations(self) -> str:
        return r"""
            SELECT
                t.TABLE_NAME        AS table_name,
                CASE t.TABLE_TYPE
                    WHEN 'BASE TABLE'  THEN 'table'
                    WHEN 'VIEW'        THEN 'view'
                    ELSE LOWER(t.TABLE_TYPE)
                END                 AS kind,
                CASE t.TABLE_TYPE
                    WHEN 'VIEW' THEN NULL
                    ELSE NULLIF(t.TABLE_COMMENT, '')
                END                 AS description
            FROM 
                INFORMATION_SCHEMA.TABLES t
            WHERE 
                t.TABLE_SCHEMA = {SCHEMA}
            ORDER BY 
                t.TABLE_NAME
        """

    def _sql_columns(self) -> str:
        return r"""
            SELECT
                c.TABLE_NAME                         AS table_name,
                c.COLUMN_NAME                        AS column_name,
                c.ORDINAL_POSITION                   AS ordinal_position,
                c.COLUMN_TYPE                        AS data_type,
                CASE 
                    WHEN c.IS_NULLABLE = 'YES' THEN TRUE 
                    ELSE FALSE 
                END AS is_nullable,
                CASE
                    WHEN c.EXTRA RLIKE '\\b(VIRTUAL|STORED) GENERATED\\b' THEN NULLIF(c.GENERATION_EXPRESSION, '')
                    ELSE c.COLUMN_DEFAULT
                END AS default_expression,
                CASE
                    WHEN c.EXTRA LIKE '%auto_increment%' THEN 'identity'
                    WHEN c.EXTRA RLIKE '\\b(VIRTUAL|STORED) GENERATED\\b' THEN 'computed'
                    ELSE NULL
                END AS "generated",
                NULLIF(c.COLUMN_COMMENT, '')         AS description
            FROM 
                INFORMATION_SCHEMA.COLUMNS c
            WHERE 
                c.TABLE_SCHEMA = {SCHEMA}
            ORDER BY 
                c.TABLE_NAME, 
                c.ORDINAL_POSITION
        """

    def _sql_primary_keys(self) -> str:
        return r"""
            SELECT
                tc.TABLE_NAME         AS table_name,
                tc.CONSTRAINT_NAME    AS constraint_name,
                kcu.COLUMN_NAME       AS column_name,
                kcu.ORDINAL_POSITION  AS position
            FROM 
                INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
                JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu 
                     ON kcu.CONSTRAINT_NAME = tc.CONSTRAINT_NAME AND kcu.TABLE_SCHEMA = tc.TABLE_SCHEMA AND kcu.TABLE_NAME = tc.TABLE_NAME
            WHERE 
                tc.TABLE_SCHEMA = {SCHEMA}
                AND tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
            ORDER BY 
                tc.TABLE_NAME, 
                tc.CONSTRAINT_NAME, 
                kcu.ORDINAL_POSITION
        """

    def _sql_uniques(self) -> str:
        return r"""
            SELECT
                tc.TABLE_NAME         AS table_name,
                tc.CONSTRAINT_NAME    AS constraint_name,
                kcu.COLUMN_NAME       AS column_name,
                kcu.ORDINAL_POSITION  AS position
            FROM 
                INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
                JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu ON kcu.CONSTRAINT_NAME = tc.CONSTRAINT_NAME AND kcu.TABLE_SCHEMA = tc.TABLE_SCHEMA AND kcu.TABLE_NAME = tc.TABLE_NAME
            WHERE 
                tc.TABLE_SCHEMA = {SCHEMA}
                AND tc.CONSTRAINT_TYPE = 'UNIQUE'
            ORDER BY 
                tc.TABLE_NAME, 
                tc.CONSTRAINT_NAME, 
                kcu.ORDINAL_POSITION
        """

    def _sql_checks(self) -> str:
        return r"""
            SELECT
                tc.TABLE_NAME        AS table_name,
                tc.CONSTRAINT_NAME   AS constraint_name,
                cc.CHECK_CLAUSE      AS expression,
                TRUE                 AS validated
            FROM 
                INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
                JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc ON cc.CONSTRAINT_SCHEMA = tc.TABLE_SCHEMA AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
            WHERE 
                tc.TABLE_SCHEMA = {SCHEMA}
                AND tc.CONSTRAINT_TYPE = 'CHECK'
            ORDER BY 
                tc.TABLE_NAME, 
                tc.CONSTRAINT_NAME
        """

    def _sql_foreign_keys(self) -> str:
        return r"""
            SELECT
                kcu.TABLE_NAME                 AS table_name,
                kcu.CONSTRAINT_NAME            AS constraint_name,
                kcu.ORDINAL_POSITION           AS position,
                kcu.COLUMN_NAME                AS from_column,
                kcu.REFERENCED_TABLE_SCHEMA    AS ref_schema,
                kcu.REFERENCED_TABLE_NAME      AS ref_table,
                kcu.REFERENCED_COLUMN_NAME     AS to_column,
                LOWER(rc.UPDATE_RULE)          AS on_update,
                LOWER(rc.DELETE_RULE)          AS on_delete,
                TRUE                           AS enforced,
                TRUE                           AS validated
            FROM 
                INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
                JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA AND tc.TABLE_NAME = kcu.TABLE_NAME
                JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc ON rc.CONSTRAINT_SCHEMA = kcu.TABLE_SCHEMA AND rc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
            WHERE 
                kcu.TABLE_SCHEMA = {SCHEMA}
                AND tc.CONSTRAINT_TYPE = 'FOREIGN KEY'
            ORDER BY 
                kcu.TABLE_NAME, 
                kcu.CONSTRAINT_NAME, 
                kcu.ORDINAL_POSITION
        """

    def _sql_indexes(self) -> str:
        return r"""
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -