src/databao_context_engine/plugins/databases/duckdb_introspector.py [152:268]:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        return r"""
            WITH d AS (
                SELECT 
                    *
                FROM 
                    duckdb_constraints()
                WHERE 
                    schema_name = {SCHEMA}
                    AND constraint_type = 'UNIQUE'
            ),
            cols AS (
                SELECT
                    d.table_name,
                    d.constraint_name,
                    r.pos AS position,
                    d.constraint_column_names[r.pos] AS column_name
                FROM 
                    d,
                    range(1, length(d.constraint_column_names) + 1) AS r(pos)
            )
            SELECT
                table_name,
                constraint_name,
                position,
                column_name
            FROM 
                cols
            ORDER BY
                table_name, 
                constraint_name, 
                position;
        """

    def _sql_checks(self) -> str:
        return r"""
            SELECT
                d.table_name,
                d.constraint_name,
                d.expression        AS expression,
                TRUE                AS validated
            FROM 
                duckdb_constraints() AS d
            WHERE 
                d.schema_name = {SCHEMA}
                AND d.constraint_type = 'CHECK'
            ORDER BY 
                d.table_name, 
                d.constraint_name; 
           """

    def _sql_foreign_keys(self) -> str:
        return r"""
            WITH d AS (
                SELECT 
                    *
                FROM 
                    duckdb_constraints()
                WHERE 
                    schema_name = {SCHEMA}
                    AND constraint_type = 'FOREIGN KEY'
            ),
            cols AS (
                SELECT
                    d.schema_name,
                    d.table_name,
                    d.constraint_name,
                    r.pos AS position,
                    d.constraint_column_names[r.pos]  AS from_column,
                    d.referenced_column_names[r.pos]  AS to_column
                FROM 
                    d,
                    range(1, length(d.constraint_column_names) + 1) AS r(pos)
            ),
            ref AS (
            SELECT
                rc.constraint_schema AS schema_name,
                rc.constraint_name,
                tc.table_schema AS ref_schema,
                tc.table_name   AS ref_table
            FROM 
                information_schema.referential_constraints rc
                JOIN information_schema.table_constraints tc ON 
                    tc.constraint_schema = rc.unique_constraint_schema 
                    AND tc.constraint_name = rc.unique_constraint_name
            ),
            rules AS (
                SELECT
                    constraint_schema AS schema_name,
                    constraint_name,
                    lower(update_rule) AS on_update,
                    lower(delete_rule) AS on_delete
                FROM 
                    information_schema.referential_constraints
            )
            SELECT
                c.table_name,
                c.constraint_name,
                c.position,
                c.from_column,
                r.ref_schema,
                r.ref_table,
                c.to_column,
                coalesce(u.on_update, 'no action') AS on_update,
                coalesce(u.on_delete, 'no action') AS on_delete,
                TRUE AS enforced,
                TRUE AS validated
            FROM 
                cols c JOIN ref r ON r.schema_name = c.schema_name AND r.constraint_name = c.constraint_name
            LEFT JOIN rules u ON u.schema_name = c.schema_name AND u.constraint_name = c.constraint_name
            ORDER BY 
                c.table_name, 
                c.constraint_name, 
                c.position;
        """

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



src/databao_context_engine/plugins/databases/mssql_introspector.py [227:302]:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        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"""
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -