Cómo recuperar datos de restricciones de clave externa

Estoy buscando una consulta que permita recuperar información de clave externa (cada línea: tabla y campo de referencia, tabla y campo de referencia) de un esquema completo.

He encontrado esto, pero no proporciona toda la información que necesito: /programming/4389228/sql-for-oracle-to-check-if-a-constraint-exists

Actualmente estoy trabajando en ello y puedo terminar con una solución en los próximos minutos / horas. Pero si alguien ya tiene una solución de trabajo completa, me alegrará saberlo :)

Después de un poco de "ingeniería inversa" en las consultas realizadas por la herramienta Navicat al abrir la ventana de la tabla de diseño para una tabla (las consultas que recuperan información sobre claves externas se muestran en la ventana del historial ), aquí hay una solución:

SELECT
    CONS.CONSTRAINT_NAME,
    CONS.TABLE_NAME,
    COLS.COLUMN_NAME,
    CONS.R_CONSTRAINT_NAME,
    CONS_R.TABLE_NAME R_TABLE_NAME,
    COLS_R.COLUMN_NAME R_COLUMN_NAME

FROM USER_CONSTRAINTS CONS
    LEFT JOIN USER_CONS_COLUMNS COLS ON COLS.CONSTRAINT_NAME = CONS.CONSTRAINT_NAME
    LEFT JOIN USER_CONSTRAINTS CONS_R ON CONS_R.CONSTRAINT_NAME = CONS.R_CONSTRAINT_NAME
    LEFT JOIN USER_CONS_COLUMNS COLS_R ON COLS_R.CONSTRAINT_NAME = CONS.R_CONSTRAINT_NAME

-- returns only foreign key constraints
WHERE CONS.CONSTRAINT_TYPE = 'R'

ORDER BY CONS.TABLE_NAME, COLS.COLUMN_NAME

SQL Developer se entrega con un informe que hace exactamente esto.

Lo hace solo para el esquema de inicio de sesión, pero es una solución rápida para que obtenga todos los FK en la base de datos, aunque es posible que desee omitir esquemas como 'APEX ...' y 'SYS'.

También omite cosas como tablas en la papelera de reciclaje.

El informe original se encuentra en el panel Informes, en los informes del diccionario de datos.

Aquí está la consulta modificada para obtener TODOS los FK.

    SELECT
    c.owner "Owner",
    c.table_name "Table_Name",
    c.constraint_name "Constraint_Name",
    c.delete_rule "Delete_Rule",
    d.columns,
    c.r_owner "Owner of Related Table",
    (
        SELECT
            r.table_name
        FROM
            sys.all_constraints r
        WHERE
            c.r_owner = r.owner
        AND
            c.r_constraint_name = r.constraint_name
    ) "Related Table",
    c.r_constraint_name "Related Constraint"
FROM
    sys.all_constraints c,
    (
        SELECT
            a.owner,
            a.table_name,
            a.constraint_name,
            MAX(
                DECODE(position,1,substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,2,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,3,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,4,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,5,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,6,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,7,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,8,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,9,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,10,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,11,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,12,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,13,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,14,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,15,','
                 ||  substr(column_name,1,30),NULL)
            )
             ||  MAX(
                DECODE(position,16,','
                 ||  substr(column_name,1,30),NULL)
            ) columns
        FROM
            sys.all_constraints a,
            sys.all_cons_columns b
        WHERE
            a.constraint_name = b.constraint_name
        AND
            a.owner = b.owner
        AND
            a.constraint_type = 'R'
        AND
            substr(a.table_name,1,4) != 'BIN$'
        AND
            substr(a.table_name,1,3) != 'DR$'
        AND (
                :table_name IS NULL
            OR
                instr(upper(a.table_name),upper(:table_name) ) > 0
        ) GROUP BY
            a.owner,
            a.table_name,
            a.constraint_name
    ) d
WHERE
    c.owner = d.owner
AND
    c.table_name = d.table_name
AND
    c.constraint_name = d.constraint_name
ORDER BY
    c.owner,
    c.table_name,
    c.constraint_name

Y así es como se ve ese informe.

Un código un poco complicado que también arroja comentarios sobre cols (basado en el código Frosty):

SELECT
    dt.table_name, dt.column_name, dt.data_type, dt.data_length,
    constr.r_tbl r_table, constr.r_col r_column,
    comm.comments
  FROM user_col_comments comm, user_tab_columns dt
  LEFT OUTER JOIN (
    SELECT
      cons.table_name tbl,
      cols.column_name col,
      cons_r.table_name r_tbl,
      cols_r.column_name r_col
    FROM user_constraints cons
      LEFT JOIN user_cons_columns cols ON cols.constraint_name = cons.constraint_name
      LEFT JOIN user_constraints cons_r ON cons_r.constraint_name = cons.r_constraint_name
      LEFT JOIN user_cons_columns cols_r ON cols_r.constraint_name = cons.r_constraint_name
    WHERE cons.constraint_type = 'R'
    ) constr ON constr.tbl = dt.table_name AND constr.col = dt.column_name
  WHERE dt.table_name = comm.table_name
    AND dt.column_name = comm.column_name
  ORDER BY dt.table_name, dt.column_name
  ;

Para que la salida sea más legible, la uso break on TABLE_NAME;en sqlplus(mira mi pregunta /programming/14998296/print-only-first-unique-value-for-column-that-order-by-in-oracle-sqlplus / ).

ACTUALIZACIÓN Consulta más simple que recopila una lista de tablas que tienen referencia de FK a una tabla determinada (útil si desea limpiar las restricciones después de cambiar el nombre de la tabla):

select * from SYS.USER_CONSTRAINTS cons
  join SYS.USER_CONSTRAINTS rcons on rcons.CONSTRAINT_NAME = cons.R_CONSTRAINT_NAME
  where cons.CONSTRAINT_TYPE = 'R' and rcons.TABLE_NAME 'TBL_NAME';

select * from SYS.USER_CONSTRAINTS cons
  join SYS.USER_CONSTRAINTS rcons on rcons.CONSTRAINT_NAME = cons.R_CONSTRAINT_NAME
  where cons.CONSTRAINT_TYPE = 'R' and rcons.TABLE_NAME like '%/_OLD' escape '/';