Luego de de nuestra prolongada selección de datos resolvimos este atascamiento que suelen tener muchos de nuestros usuarios. Te compartimos la respuesta y nuestro deseo es serte de mucha ayuda.
Solución:
Solución 1:
A través de OEM 10g,
- Conéctese a la base de datos como de costumbre
- Clickea en el
Schema
pestaña - Sobre el
Tables
enlace dentro de los objetos de la base de datos - Ingrese el nombre del esquema y el nombre del objeto (opcional) y haga clic en
Go
- Use el botón de radio para seleccionar la tabla que desea ver y haga clic en
Edit
(No haga clic en el enlace del nombre de la tabla) - Clickea en el
Segments
pestaña (y espera…) - Verá el tamaño de los datos de la tabla y los índices utilizados.
De acuerdo, técnicamente respondió a tu pregunta. Pero una mejor forma es:
- Iniciar sesión usando SQLPLUS
- Ejecute el script de Vincent.
Me gusta guardar el guión como t.sql
como referencia rápida
COLUMN size_mb FORMAT '999,999,990.0'
COLUMN num_rows FORMAT '999,999,990'
COLUMN fmt_short FORMAT A24
COLUMN owner FORMAT A16
COLUMN table_name LIKE fmt_short
COLUMN tablespace_name LIKE fmt_short
SET LINESIZE 200
SET AUTOTRACE OFF
COMPUTE SUM OF size_mb ON REPORT
BREAK ON REPORT
SELECT
lower( owner ) AS owner
,lower(table_name) AS table_name
,tablespace_name
,num_rows
,blocks*8/1024 AS size_mb
,pct_free
,compression
,logging
FROM all_tables
WHERE owner LIKE UPPER('&1')
OR owner = USER
ORDER BY 1,2;
CLEAR COMPUTES
CLEAR BREAKS
Solucion 2:
El espacio utilizado por una tabla es el espacio utilizado por todas sus extensiones:
SELECT SUM(bytes), SUM(bytes)/1024/1024 MB
FROM dba_extents
WHERE owner = :owner
AND segment_name = :table_name;
SUM(BYTES) MB
---------- ----------
3066429440 2924,375
Solución 3:
¿Está seguro de que el enfoque original que usa la vista all_tables incluye extensiones LOB? Yo pensaría que no. Aquí hay uno que me resulta útil:
with da as (
SELECT owner, segment_name, SUM(bytes)/1024/1024 size_mb
FROM dba_extents
group by rollup(owner, segment_name)
) select owner, segment_name, size_mb, round(size_mb/total_mb*100)
from da
cross join (
select size_mb as total_mb
from da t where owner is null and segment_name is null
)
order by size_mb desc
Me muestra qué ocupa más espacio.
Solución 4:
Después de algunas búsquedas y experimentos en Google, he creado la siguiente consulta, que me proporciona el resultado más preciso. Para un usuario de Oracle, proporciona el espacio libre / usado / total por Tabla y tipo de segmento (TABLA *, ÍNDICE *, LOB *). Puede ampliarlo fácilmente para proporcionar estadísticas adicionales como recuentos de bloques.
La salida típica es:
table ; segment type ; used (mb) ; unused (mb) ; total (mb)
user ; INDEX ; 0,78; 0,00; 0,78
user ; LOBINDEX ; 0,15; 0,00; 0,15
user ; LOBSEGMENT ; 3,48; 1,19; 4,67
user ; TABLE ; 12,11; 2,74; 14,85
address ; INDEX ; 0,12; 0,00; 0,12
(...)
Texto:
DECLARE
input_owner NVARCHAR2(128) := 'MY_ORACLE_OWNER';
segment_size_blocks NUMBER;
segment_size_bytes NUMBER;
used_blocks NUMBER;
used_bytes NUMBER;
expired_blocks NUMBER;
expired_bytes NUMBER;
unexpired_blocks NUMBER;
unexpired_bytes NUMBER;
total_blocks NUMBER;
total_bytes NUMBER;
unused_blocks NUMBER;
unused_bytes NUMBER;
last_ext_file_id NUMBER;
last_ext_blk_id NUMBER;
last_used_blk NUMBER;
result_table NVARCHAR2(128);
result_segment_type NVARCHAR2(128);
result_used_mb NUMBER;
result_unused_mb NUMBER;
result_total_mb NUMBER;
CURSOR cur
IS
SELECT
s.segment_name AS segment_name,
s.owner AS segment_owner,
s.partition_name AS partition_name,
s.segment_type AS segment_type,
CASE WHEN s.segment_type IN ('TABLE', 'TABLE PARTITION', 'TABLE SUBPARTITION')
THEN s.segment_name
WHEN s.segment_type IN ('INDEX', 'INDEX PARTITION', 'INDEX SUBPARTITION')
THEN (SELECT i.table_name
FROM dba_indexes i
WHERE s.segment_name = i.index_name AND s.owner = i.owner)
WHEN s.segment_type IN ('LOBSEGMENT', 'LOB PARTITION')
THEN (SELECT l.table_name
FROM dba_lobs l
WHERE s.segment_name = l.segment_name AND s.owner = l.owner)
WHEN s.segment_type IN ('LOBINDEX')
THEN (SELECT l.table_name
FROM dba_lobs l
WHERE s.segment_name = l.index_name AND s.owner = l.owner)
ELSE 'Unknown'
END AS table_name,
s.bytes AS segment_bytes
FROM dba_segments s
WHERE owner = input_owner
ORDER BY table_name, segment_type;
BEGIN
dbms_output.put_line('table ; segment type ; used (mb) ; unused (mb) ; total (mb)');
FOR ro IN cur
LOOP
result_table := ro.table_name;
result_segment_type := ro.segment_type;
IF ro.segment_type IN ('TABLE', 'INDEX')
THEN
dbms_space.unused_space(
segment_owner => ro.segment_owner,
segment_name => ro.segment_name,
segment_type => ro.segment_type,
total_blocks => total_blocks,
total_bytes => total_bytes,
unused_blocks => unused_blocks,
unused_bytes => unused_bytes,
last_used_extent_file_id => last_ext_file_id,
last_used_extent_block_id => last_ext_blk_id,
last_used_block => last_used_blk);
result_used_mb := (total_bytes - unused_bytes) / 1024 / 1024;
result_unused_mb := unused_bytes / 1024 / 1024;
result_total_mb := total_bytes / 1024 / 1024;
ELSIF ro.segment_type IN ('LOBSEGMENT')
THEN
dbms_space.space_usage(
segment_owner => ro.segment_owner,
segment_name => ro.segment_name,
segment_type => 'LOB',
partition_name => ro.partition_name,
segment_size_blocks => segment_size_blocks,
segment_size_bytes => segment_size_bytes,
used_blocks => used_blocks,
used_bytes => used_bytes,
expired_blocks => expired_blocks,
expired_bytes => expired_bytes,
unexpired_blocks => unexpired_blocks,
unexpired_bytes => unexpired_bytes
);
result_used_mb := used_bytes / 1024 / 1024;
result_unused_mb := (segment_size_bytes - used_bytes) / 1024 / 1024;
result_total_mb := segment_size_bytes / 1024 / 1024;
ELSE
-- TODO ??
result_used_mb := ro.segment_bytes / 1024 / 1024;
result_unused_mb := 0;
result_total_mb := result_used_mb + result_unused_mb;
END IF;
dbms_output.put_line(
RPAD(result_table, 30) || '; ' ||
RPAD(result_segment_type, 20)|| '; ' ||
TO_CHAR(result_used_mb / 1024 / 1024, '999999999990D00')|| '; ' ||
TO_CHAR(result_unused_mb / 1024 / 1024, '999999999990D00')|| '; ' ||
TO_CHAR(result_total_mb / 1024 / 1024, '999999999990D00'));
END LOOP;
END;
Si aceptas, puedes dejar una sección acerca de qué le añadirías a esta noticia.