-
1. Vérifiez le nom et la taille de l'espace table
sélectionnez t.tablespace_name, round(sum(bytes/(1024*1024)),0) ts_size
à partir de dba_tablespaces t, dba_data_files d
où t.tablespace_name = d.tablespace_name
regrouper par t.tablespace_name ;
2. Affichez le nom et la taille des fichiers physiques dans l'espace table
sélectionnez tablespace_name, file_id, file_name,
tour(octets/(1024*1024),0) espace_total
de dba_data_files
trier par nom_espace_table ;
3. Vérifiez le nom et la taille du segment d'annulation
sélectionnez nom_segment, nom_espace_table, r.status,
(initial_extent/1024) InitialExtent, (next_extent/1024) NextExtent,
max_extents, v.curext CurExtent
Depuis dba_rollback_segs r, v$rollstat v
Où r.segment_id = v.usn(+)
trier par nom_segment ;
4. Afficher le fichier de contrôle
sélectionnez le nom dans v$controlfile ;
5. Afficher les fichiers journaux
sélectionnez un membre dans v$logfile ;
6. Vérifiez l'utilisation de l'espace table
sélectionnez sum(bytes)/(1024*1024) comme free_space,tablespace_name
de dba_free_space
regrouper par nom_espace_table ;
SELECT A.TABLESPACE_NAME,A.BYTES TOTAL,B.BYTES UTILISÉS, C.BYTES FREE,
(B.BYTES*100)/A.BYTES "% UTILISÉ",(C.BYTES*100)/A.BYTES "% GRATUIT"
FROM SYS.SM$TS_AVAIL A,SYS.SM$TS_USED B,SYS.SM$TS_FREE C
OÙ A.TABLESPACE_NAME=B.TABLESPACE_NAME ET A.TABLESPACE_NAME=C.TABLESPACE_NAME ;
7. Afficher les objets de la base de données
sélectionnez le propriétaire, le type d'objet, le statut, le nombre (*) count# dans le groupe all_objects par propriétaire, le type d'objet, le statut ;
8. Vérifiez la version de la base de données
Sélectionnez la version FROM Product_component_version
Où SUBSTR(PRODUCT,1,6)='Oracle';
9. Afficher la date de création et la méthode d'archivage de la base de données
Sélectionnez Créé, Log_Mode, Log_Mode à partir de V$Database ;
10. Capturez du SQL qui fonctionne depuis longtemps
format de nom d'utilisateur de colonne a12
format de nom d'opération de colonne a16
format de progression de la colonne a8
sélectionnez le nom d'utilisateur, le sid, le nom de l'utilisateur,
round(jusqu'à présent*100 / totalwork,0) || '%' en progression,
temps_restant,sql_text
de v$session_longops , v$sql
où temps_restant <> 0
et sql_address = adresse
et sql_hash_value = hash_value
/
11. Afficher les informations sur les paramètres de la fiche technique
SELECT nom_partition, valeur_élevée, longueur_valeur_élevée, nom_espace_table,
pct_free, pct_used, ini_trans, max_trans, initial_extent,
next_extent, min_extent, max_extent, pct_increase, FREELISTS,
freelist_groups, LOGGING, BUFFER_POOL, num_rows, blocs,
empty_blocks, avg_space, chain_cnt, avg_row_len, sample_size,
dernier_analysé
DEPUIS dba_tab_partitions
--WHERE nom_table = :tname ET propriétaire_table = :towner
COMMANDER PAR partition_position
12. Afficher les transactions non validées
sélectionnez * dans v$locked_object ;
sélectionnez * dans v$transaction ;
13. Rechercher par quels processus l'objet est utilisé
sélectionner
p.spid,
s.sid,
s.serial# numéro_série,
s.nom d'utilisateur nom_utilisateur,
a.type type_objet,
s.osuser os_user_name,
a.propriétaire,
a.object nom_objet,
décoder(signe(48 - commande),
1,
to_char(commande), 'Code d'action #' || to_char(commande) ),
p.programme oracle_process,
au terminal,
le programme de programme,
s.status session_status
à partir de v$session s, v$access a, v$process p
où s.paddr = p.addr et
s.type = 'UTILISATEUR' et
a.sid = s.sid et
a.object='SUBSCRIBER_ATTR'
commander par s.username, s.osuser
14. Vue du segment d'annulation
sélectionnez rownum, sys.dba_rollback_segs.segment_name Nom, v$rollstat.extents
Étendues, v$rollstat.rssize Size_in_Bytes, v$rollstat.xacts XActs,
v$rollstat.gets Obtient, v$rollstat.waits Attend, v$rollstat.writes Écrit,
Statut sys.dba_rollback_segs.status de v$rollstat, sys.dba_rollback_segs,
v$rollname où v$rollname.name(+) = sys.dba_rollback_segs.segment_name et
v$rollstat.usn (+) = v$rollname.usn trié par numéro de ligne
15. Processus consommateur de ressources (session supérieure)
sélectionnez s.schemaname nom_schéma, decode(sign(48 - command), 1,
to_char(commande), 'Code d'action #' || to_char(commande) ) action, statut
statut_de session, s.osuser nom_utilisateur_os, s.sid, p.spid, s.serial# numéro_série,
nvl(s.username, '[Oracle process]') user_name, s.terminal terminal,
s.program programme, st.value critères_valeur de v$sesstat st, v$session s, v$process p
où st.sid = s.sid et st.statistic# = to_number('38') et ('ALL' = 'ALL'
ou s.status = 'ALL') et p.addr = s.paddr ordre par st.value desc, p.spid asc, s.username asc, s.osuser asc
16. Vérifier l'état du verrouillage
sélectionnez /*+ RÈGLE */ ls.osuser os_user_name, ls.username user_name,
decode(ls.type, 'RW', 'Verrou de mise en file d'attente d'attente de ligne', 'TM', 'Verrou de mise en file d'attente DML', 'TX',
'Verrou de mise en file d'attente des transactions', 'UL', 'Verrou fourni par l'utilisateur') lock_type,
objet o.object_name, decode(ls.lmode, 1, null, 2, 'Row Share', 3,
"Ligne exclusive", 4, "Partager", 5, "Partager la ligne exclusive", 6, "Exclusif", null)
lock_mode, o.owner, ls.sid, ls.serial# serial_num, ls.id1, ls.id2
à partir de sys.dba_objects o, (sélectionnez s.osuser, s.username, l.type,
l.lmode, s.sid, s.serial#, l.id1, l.id2 de v$session s,
v$lock l où s.sid = l.sid ) ls où o.object_id = ls.id1 et o.owner
<> Commande 'SYS' par o.owner, o.object_name
17. Vérifier l'état d'attente
SELECT v$waitstat.class, v$waitstat.count nombre, SUM(v$sysstat.value) sum_value
FROM v$waitstat, v$sysstat OÙ v$sysstat.name IN ('le bloc de base de données obtient',
'cohérent obtient') groupe par v$waitstat.class, v$waitstat.count
18. Vérifiez la situation du sga
SELECT NOM, BYTES FROM SYS.V_$SGASTAT ORDER BY NAME ASC
19. Afficher l'objet capturé
SELECT propriétaire, nom, db_link, espace de noms,
type, partage_mem, chargements, exécutions,
verrous, broches, conservés DE v$db_object_cache
20. Afficher V$SQLAREA
SELECT SQL_TEXT, SHARABLE_MEM, PERSISTENT_MEM, RUNTIME_MEM, SORTS,
VERSION_COUNT, LOADED_VERSIONS, OPEN_VERSIONS, USERS_OPENING, EXECUTIONS,
USERS_EXECUTING, LOADS, FIRST_LOAD_TIME, INVALIDATIONS, PARSE_CALLS, DISK_READS,
BUFFER_GETS, ROWS_PROCESSED FROM V$SQLAREA
vingt-et-un. Afficher le nombre de catégories d'objets
sélectionnez décoder (o.type#,1,'INDEX' , 2,'TABLE' , 3 , 'CLUSTER' , 4, 'VIEW' , 5 ,
'SYNONYM' , 6 , 'SEQUENCE' , 'OTHER' ) type_objet , nombre (*) quantité à partir de
sys.obj$ o où o.type# > 1 regrouper par décodage (o.type#,1,'INDEX' , 2,'TABLE' , 3
, 'CLUSTER' , 4, 'VIEW' , 5 , 'SYNONYM' , 6 , 'SEQUENCE' , 'OTHER' ) sélection d'union
'COLUMN' , count(*) de sys.col$ union select 'DB LINK' , count(*) de
vingt-deux. Afficher les types d'objets par utilisateur
sélectionnez le schéma u.name, les index sum(decode(o.type#, 1, 1, NULL)),
somme(decode(o.type#, 2, 1, NULL)) tableaux, somme(decode(o.type#, 3, 1, NULL))
clusters, vues sum(decode(o.type#, 4, 1, NULL)), sum(decode(o.type#, 5, 1,
NULL)) synonymes, séquences sum(decode(o.type#, 6, 1, NULL)),
somme(decode(o.type#, 1, NULL, 2, NULL, 3, NULL, 4, NULL, 5, NULL, 6, NULL, 1))
d'autres de sys.obj$ o, sys.user$ u où o.type# >= 1 et u.user# =
o.owner# et u.name <> groupe 'PUBLIC' par u.name trié par
sys.link$ union select 'CONSTRAINT' , count(*) from sys.con$
vingt-trois. Informations connexes sur la connexion
1) Vérifiez quels utilisateurs sont connectés
sélectionnez s.osuser os_user_name, decode(sign(48 - command), 1, to_char(command),
'Code d'action #' || to_char(commande) ), p.programme oracle_process,
status session_status, s.terminal terminal, s.program programme,
s.username user_name, s.fixed_table_sequenceactivity_meter, 'requête,
0 mémoire, 0 max_memory, 0 cpu_usage, s.sid, s.serial# serial_num
à partir de v$session s, v$process p où s.paddr=p.addr et s.type = 'USER'
commander par s.username, s.osuser
2) Vérifiez l'utilisation des ressources de la connexion correspondante en fonction de v.sid
sélectionnez n.nom,
v.valeur,
n.classe,
n.statistique#
de v$statname n,
v$sesstatv
où v.sid = 71 et
v.statistique# = n.statistique#
trier par n.class, n.statistic#
3) Vérifiez le SQL en cours d'exécution de la connexion correspondante en fonction du sid
sélectionnez /*+ PUSH_SUBQ */
type_commande,
sql_text,
partage_mem,
persistant_mem,
runtime_mem,
sortes,
nombre_version,
versions_chargées,
versions ouvertes,
utilisateurs_ouverture,
exécutions,
utilisateurs_executing,
des charges,
first_load_time,
invalidations,
analyse_calls,
disque_reads,
tampon_gets,
lignes_processed,
sysdate heure_début,
sysdate finish_time,
'>' || adresse adresse_sql,
Statut 'N'
de v$sqlarea
où adresse = (sélectionnez sql_address dans v$session où sid = 71)
vingt-quatre. Requête sur l'utilisation de l'espace table, sélectionnez a.tablespace_name "nom de l'espace table",
100-round((nvl(b.bytes_free,0)/a.bytes_alloc)*100,2) "Occupation (%)",
round(a.bytes_alloc/1024/1024,2) "Capacité (M)",
round(nvl(b.bytes_free,0)/1024/1024,2) "Gratuit(M)",
round((a.bytes_alloc-nvl(b.bytes_free,0))/1024/1024,2) "Utiliser (M)",
Le plus grand "Segment d'extension maximale (M)",
to_char(sysdate,'aaaa-mm-jj hh24:mi:ss') "heure d'échantillonnage"
à partir de (sélectionnez f.tablespace_name,
somme (f.octets) octets_alloc,
sum(decode(f.autoextensible,'YES',f.maxbytes,'NO',f.bytes)) maxbytes
de dba_data_files f
grouper par tablespace_name) a,
(sélectionnez f.tablespace_name,
somme (f.octets) octets_libre
de dba_free_space f
grouper par tablespace_name) b,
(sélectionnez round(max(ff.length)*16/1024,2) Le plus grand,
ts.name nom_espace_table
de sys.fet$ ff, sys.file$ tf,sys.ts$ ts
où ts.ts#=ff.ts# et ff.file#=tf.relfile# et ts.ts#=tf.ts#
grouper par ts.name, tf.blocks) c
où a.tablespace_name = b.tablespace_name et a.tablespace_name = c.tablespace_name
25. Interroger le degré de fragmentation de l'espace table
sélectionnez tablespace_name,count(tablespace_name) dans le groupe dba_free_space par tablespace_name
avoir count(tablespace_name)>10 ;
modifier le nom de l'espace de table fusionner ;
modifier le nom de la table, désallouer les éléments inutilisés ;
créer ou remplacer la vue ts_blocks_v comme
sélectionnez nom_espace table, block_id, octets, blocs, nom_segment 'espace libre' dans dba_free_space
syndicat tous
sélectionnez tablespace_name, block_id,bytes,blocks,segment_name dans dba_extents ;
sélectionnez * dans ts_blocks_v ;
sélectionnez tablespace_name, sum (bytes), max (bytes), count (block_id) depuis dba_free_space
regrouper par nom_espace_table ;
26. Vérifiez quelles instances sont en cours d'exécution :
sélectionnez * dans v$active_instances ;
-