锐客网

  1. 首页 > 生活百科 > it技术 > >

oracle怎么查询缓存 oracle查看存储空间

数据IT技术

如何查看memchaed缓存的信息Linux下看内存和CPU使用率一般都用top命令 ， 但是实际在用的时候，用top查看出来的内存占用率都非常高，如：
Mem:4086496k total, 4034428k used,52068k free,112620k buffers
Swap: 4192956k total,799952k used, 3393004k free, 1831700k cached
接近98.7%，而实际上的应用程序占用的内存往往并没这么多，
PID
USERPR NI VIRT RES SHR S %CPU %MEMTIME
COMMAND
25801 sybase150 2648m 806m 805m S 1.0 20.2 27:56.96
dataserver
12084 oracle160 1294m 741m 719m S 0.0 18.60:13.50
oracle
27576 xugy250 986m 210m 1040 S 1.0 5.3 28:51.24 cti
25587 yaoyang170 1206m 162m 3792 S 0.0 4.19:21.14 java
仔细看top关于内存的显示输出，有两个数据buffers和cached，在Linux系统下的buffer指的是磁盘写缓存 ， 而cache则指的是磁盘读缓存 。
(A buffer is something that has yet to be "written" to disk.
A cache is something that has been "read" from the disk and stored for later use.)
而这两块是为了提高系统效率而分配的内存，在内存富余的时候，操作系统将空闲内存利用起来，而有内存需求时，系统会释放这部分的内存供应用程序使用 。
这样，真正应用程序可用的内存就是free buffer cache，上面的例子就是：
52068k112620k1831700k = 1996388k
而已用内存则是used-buffer-cache，上面的例子为：
4034428k - 112620k - 1831700k = 2090108k
Linux下查看内存还有一个更方便的命令，free:
$ free
totalusedfreesharedbufferscached
Mem:408649640340445245201127561831564
-/buffers/cache:20897241996772
Swap:41929567999523393004
Mem:这列就是用top命令看到的内存使用情况，而-/ buffers/cache这列就是刚刚做的计算结果 ， used-buffer-cache/free buffer cache
也可以加-m或者-g参数查看按MB或者GB换算的结果 。
$ free -m
totalusedfreesharedbufferscached
Mem:39903906830901786
-/buffers/cache:20291961
Swap:40947813312
这样，真正应用程序的内存使用量就可以得出来了，上面的例子中内存占用率为51.1%
oracle keep pool会不会自动缓存cache的表数据的更改ORACLE缓存是把ORACLE近期查看的语句防止在ORACLE设定的缓存当中
ORACLE缓存表是把表某个表放置在缓存当中oracle怎么查询缓存 ， 缓存是ORACLE在内存中的一个分区
表缓存的设定
oracle中如何将表缓存到内存中
由于在一些静态资料表在数据库中被频繁的访问，所以可以考虑将这些数据量不大的表缓存到内存当中 。
将fisher表缓存到内存中
alter table fisher cache;方法一
2）alter table fisher storage(buffer_pool keep);方法二
--取消缓存
1）alter table fisher nocache;
2）alter table fisher storage(buffer_pool default);
select table_name,OWNER,cache,buffer_pool from dba_tables where table_name='FISHER'; --查看是否缓存
select * from dba_segments where segment_name='FISHER' ; --查看表大小
方法一： cache是将表缓存到share pool 中，该操作直接将表缓存的热端，受LRU算法控制 。
方法二：将表缓存到一个固定的内存空间中，默认情况下buffer_pool空间为0, 。需手动设置空间大小 。
设置空间大?。篴lter system set db_keep_cache_size=50M scope=both sid=‘*';
--表缓存
alter table table_name cache = alter table table_name storage(buffer_pool default);
alter table table_name storage(buffer_pool keep);
--已经加入到KEEP区的表想要移出缓存，使用
alter table table_name nocache;
--查看哪些表被放在缓存区 但并不意味着该表已经被缓存
select table_name from dba_tables where buffer_pool='keep';
--查询到该表是否已经被缓存
select table_name,cache,buffer_pool from user_TABLES where cache like '%Y';
--查询当前用户下表的情况
select table_name,cache,buffer_pool from user_TABLES;
--对于普通LOB类型的segment的cache方法
alter table t2 modify lob(c2) (storage (buffer_pool keep) cache);
--取消缓存
alter table test modify lob(address) (storage (buffer_pool keep) nocache);
keep Buffer Pool
Keep Buffer Pool 的作用是缓存那些需要经常查询的对象但又容易被默认缓冲区置换出去的对象 ， 按惯例 ， Keep pool设置为合理的大小 ， 以使其中存储的对象不再age out，也就是查询这个对象的操作不会引起磁盘IO操作，可以极大地提高查询性能 。
默认的情况下 db_keep_cache_size=0，未启用，如果想要启用 ， 需要手工设置db_keep_cache_size的值 ， 设置oracle怎么查询缓存了这个值之后 db_cache_size 会减少 。
并不是我们设置了keep pool 之后 ， 热点表就一定能够缓存在 keep pool，keep pool 同样也是由LRU 链表管理的，当keep pool 不够的时候，最先缓存到 keep pool 的对象会被挤出 ， 不过与default pool 中的 LRU 的管理方式不同，在keep pool 中表永远是从MRU 移动到LRU，不会由于oracle怎么查询缓存你做了FTS而将表缓存到LRU端，在keep pool中对象永远是先进先出 。当oracle发现你的表太太，大过你设定keep pool的大小是，根本就不会放到keep池中去的（如keep pool设定100M ，设定的用户缓存的表为200M） 。可以用select segment_name from dba_segments where BUFFER_POOL = 'KEEP';语句查看便知 。
10g中SGA自动管理，ORACLE并不会为我们管理keep pool ，ORACLE只会管理default pool 。
查看 keep pool 大小
SQL select component,current_size from v$sga_dynamic_components
2 where component='KEEP buffer cache';
COMPONENT CURRENT_SIZE
---------------------------------------------------------------- ------------
KEEP buffer cache 0
手动分配keep pool
SQL show parameter keep
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
buffer_pool_keep string
control_file_record_keep_time integer 7
db_keep_cache_size big integer 0
SQL alter system set db_keep_cache_size=10m;
系统已更改 。
SQL show parameter keep
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
buffer_pool_keep string
control_file_record_keep_time integer 7
db_keep_cache_size big integer 16M这里keep pool 16M，可我前面设置命名是10m了oracle怎么查询缓存？
SQL select component,current_size from v$sga_dynamic_components where component='KEEP buffer cache';
COMPONENT CURRENT_SIZE
---------------------------------------------------------------- ------------
KEEP buffer cache 16777216 这里keep pool 16M，可我前面设置命名是10m了？
查看keep pool剩余大小
SQL select p.name,a.cnum_repl "total buffers",a.anum_repl "free buffers" from x$kcbwds a, v$buffer_pool p
2 where a.set_id=p.LO_SETID and p.name='KEEP';
NAME total buffers free buffers
-------------------- ------------- ------------
KEEP 1984 1984
可以看到没有使用过keep 池
指定table的缓存池
SQLcreate table test as select * from dba_objects;;
Table created.
SQL alter table test storage(buffer_pool keep);
Table altered.
或者是
create table test storage(buffer_pool keep) as select * from dba_objects;
查看放入Keep的对象
SQL select segment_name from dba_segments where BUFFER_POOL = 'KEEP';
SEGMENT_NAME
--------------------------------------------------------------------------------
TEST
SQL /
NAME total buffers free buffers
-------------------- ------------- ------------
KEEP 1984 1962 可以看到使用了22个block
查看以上的表占用了db_keep_cache_size 多大的空间？
SQL select substr(sum(b.NUMBER_OF_BLOCKS) * 8129 / 1024 / 1024, 1, 5) || 'M'
from (SELECT o.OBJECT_NAME, COUNT(*) NUMBER_OF_BLOCKS
FROM DBA_OBJECTS o, V$BH bh, dba_segments dd
WHERE o.DATA_OBJECT_ID = bh.OBJD
AND o.OWNER = dd.owner
and dd.segment_name = o.OBJECT_NAME
and dd.buffer_pool != 'DEFAULT'
GROUP BY o.OBJECT_NAME
ORDER BY COUNT(*)) b; 2 3 4 5 6 7 8 9
SUBSTR(SUM(
-----------
3.643M
SQL select table_name,cache,blocks from dba_tables where wner='ROBINSON' and buffer_pool='KEEP';
TABLE_NAME CACHE BLOCKS
------------------------------ -------------------- ----------
TEST N 22
可以看到这个表的 22个block 全部cache 到 keep pool，这里的cache 字段表明 这个表 还没有使用 这个命令 alter table test cache,如果 使用了 alter table test cache ,命令，那么 N 将变成Y
总结：如果表经常使用，而且表较?。?可以设置 keep pool，将table 全部 cache 到 keep pool, keep pool 要么 全部 cache 一个table，要么不cache。所以 ， 对于大表来说，如果想要 cache 到 keep pool，就需要设置 较大的 keep pool，以容纳大的 table ， 否者就没有作用了 。
Recycle Buffer Pool
Recycle Buffer Pool正好相反 。Recycle Buffer Pool用于存储临时使用的、不被经常使用的较大的对象，这些对象放置在Default Buffer Pool显然是不合适的，这些块会导致过量的缓冲区刷新输出，而且不会带来任何好处 ， 因为等你想要再用这个块时，它可已经老化退出了缓存 。要把这些段与默认池和保持池中的段分开，这样就不会导致默认池和保持池中的块老化而退出缓存 。
SQL show parameter recyc
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
buffer_pool_recycle string
db_recycle_cache_size big integer 12M
recyclebin string on
如何将一个表放入Recycle Buffer Pool中：
SQL alter table test1 storage (buffer_pool recycle);
Table altered.
很多老的文档会提及buffer_pool_keep和buffer_pool_recycle 这两个参数 ， 其实这两个参数已经废弃，由新参数db_keep_cache_size和db_recycle_cache_size 替代：
SQLselect ISDEPRECATED,NAME from v$parameter where name = 'buffer_pool_keep';
ISDEP NAME
----- -----------------
TRUE buffer_pool_keep
=======================================================================================
--表缓存
alter table ..... storage(buffer_pool keep);
--查看哪些表被放在缓存区 但并不意味着该表已经被缓存
select table_name from dba_tables where buffer_pool='keep';
--查询到该表是否已经被缓存
select table_name,cache,buffer_pool from user_TABLES where cache like '%Y';
--已经加入到KEEP区的表想要移出缓存 ， 使用
alter table table_name nocache;
--批量插入ORACLE建议用
insert all into ...insert into ...select 1 from dual;
insert all into ... insert into ...select 1 from dual;
--查询当前用户下表的情况
select table_name,cache,buffer_pool from user_TABLES;
--对于普通LOB类型的segment的cache方法
alter table t2 modify lob(c2) (storage (buffer_pool keep) cache);
--取消缓存
alter table test modify lob(address) (storage (buffer_pool keep) nocache);
--查询段
select segment_name,segment_type,buffer_pool from user_segments;
--对基于CLOB类型的对象的cache方法
alter table lob1 modify lob(c1.xmldata) (storage (buffer_pool keep) cache);
--查询该用户下所有表内的大字段情况
select column_name,segment_name from user_lobs;
来一段Tom关于Multiple Buffer Pools的解释 ， 讲解得很清楚：
实际上，这3 个池会以大体相同的方式管理块；将块老化或缓存的算法并没有根本的差异 。这样做的目标是让DBA 能把段聚集到“热”区（hot）、“温”区（warm）和“不适合缓存”区（do not care to cache） 。
理论上讲，默认池中的对象应该足够热（也就是说 ， 用得足够多） ， 可以保证一直呆在缓存中 。缓存会把它们一直留在内存中，因为它们是非常热门的块 。可能还有一些段相当热门，但是并不太热；这些块就作为温块 。这些段的块可以从缓存刷新输出，为不常用的一些块（“不适合缓存”块）腾出空间 。为了保持这些温段的块得到缓存，可以采取下面的某种做法：将这些段分配到保持池，力图让温块在缓冲区缓存中停留得更久 。将“不适合缓存”段分配到回收池，让回收池相当小，以便块能快速地进入缓存和离开缓存（减少管理的开销） 。这样会增加DBA 所要执行的管理工作，因为要考虑3 个缓存，要确定它们的大?。?还要为这些缓存分配对象 。还要记?。庑┏刂涿挥泄蚕恚?所以，如果保持池有大量未用的空间 ， 即使默认池或回收池空间不够用了，保持池也不会把未用空间交出来 。总之 ， 这些池一般被视为一种非常精细的低级调优设备，只有所有其他调优手段大多用过之后才应考虑使用 。
按以上步骤把表storage到keep pool中 ， 然后调用alter system flush buffer_cache清空缓存，再全表扫描该表并打开执行计划跟踪，发现有physical reads，如下：
第一次执行计划如下：
----------------------------------------------------------
0 recursive calls
0 db block gets
253 consistent gets
251 physical reads
0 redo size
520 bytes sent via SQL*Net to client
469 bytes received via SQL*Net from client
2 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
1 rows processed
第二次执行计划如下：
----------------------------------------------------------
0 recursive calls
0 db block gets
253 consistent gets
0 physical reads
0 redo size
520 bytes sent via SQL*Net to client
469 bytes received via SQL*Net from client
2 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
1 rows processed
不知道是否可以这样理解：对于storage到keep pool中的表 ， 第一次会直接physical reads 到keep pool中，下次就直接从keep pool中读了 。flush buffer_cache会清空keep pool，这个试验就可以证明 。
像上面这样连续执行2次再看执行计划，和不设置keep pool时的执行计划应该一样的，因为读第二次时，也是从default cache中读 。但是当我们多读几个大表到buffer cache后，也就是替换原来从default cache中读取的数据后，再去读放入keep中的表时，就会发现keep确实起作用了，唉，终于明白怎么一回事，害得我为flush buffer导致keep中的表也phisical郁闷了半天 。
ORACLE缓存设置
Oracle缓存由两个参数控制SGA_TARGET和PGA_AGGREGATE_TARGET，设置了这两个参数，其他的基本内存部分都由Oracle自动配置为最优值 ， 这也是Oracle推荐的方式 。
SGA_TARGET 和PGA_AGGREGATE_TARGET是动态参数 ， 可以在不重启数据库的情况下修改 。但是SGA_TARGET受限于 sga_max_size，SGA_TARGET不能超过sga_max_size，所以要增大sga_target先要增大sga_max_size，而sga_max_size是静态参数 ， 修改sga_max_size必须重启Oracle 。
所以修改sga_target和pga_aggregate_target的过程如下：
1、修改sga_max_size
SQLALTER SYSTEM SET sga_max_size=4g scope=spfile;
2、重启Oracle
3、设置参数sga_target和pga_aggregate_target，
alter system set sga_target=4G;
alter system set pga_aggregate_target=1g;
如果使用的是10g，已经是ASM, oracle会根据统计的信息，自动的来调整你的内存组件的大小，你只需要设置sga_target即可 。当然你可以手动设置 db_cache_size，如果设置了的话，Oracle会在自动调整内存大小的时候把这个作为db_cache_size的最小值 。
对于sga_target,在动态修改的时候，最大值不能操过sga_max_size, 如果是用scope=spfile这个方式来修改可以超过sga_max_size，应该此时sga_max_size也跟着变大了，如果超过的话 。
Oracle 对数据库的cache有他自己的计算的，10g以后 ， 内存是动态的根据对你使用系统的统计来进行调整的，如果出现问题，这块不是原因，你之所以db cache还没有上去，可能是访问的数据比较少，不过你加大db_cache_size的值，会保留这个内存空间的，但是也是一样的，数据 load到内存里，才看得到变化 。
数据访问是什么样的访问，你的系统是OLAP还是OLTP，这些应用上的东西对你的决定也有影响的，要谨记，数据库的优化和维护，不仅仅是DBA来做的 。如果是到了只能通过DBA来做这一步的话，就相当于看病已经到了拿手术刀这一步了 。你的改变带来的风险和代价最高 。
要想减少磁盘读,只能增大内存的使用.楼主可以看看这个视图v$db_cache_size,并执行下面的查询:
select block_size, size_for_estimate, size_factor, estd_physical_read_factor, estd_physical_reads from v$db_cache_advice;
Oracle在这个视图中针对db_cache_size的大小会给出一些建议 。
下面解释几个列的含义
size_for_estimate：估计的cache size大小
size_factor： 估计的cache size大小与当前大小的比值
estd_physical_reads：在估计的cache size大小情况下 ， 会产生的物理读数量
estd_physical_read_factor：估计的物理读数量与当前物理读数量的比值 。
例子：
SIZE_FOR_ESTIMATE SIZE_FACTOR ESTD_PHYSICAL_READ_FACTOR ESTD_PHYSICAL_READS
oracle的字典缓存命中率是什么意思？1、 ORACLE 实例――包括内存结构与后台进程2、 ORACLE 数据库――物理操作系统文件的集合3、 了解内存结构的组成4、 了解后台进程的作用
1、 Oracle 实例――包括内存结构与后台进程
2、 Oracle 数据库――物理操作系统文件的集合
3、 了解内存结构的组成
4、 了解后台进程的作用
5、 了解数据库的物理文件
6、 解释各种逻辑结构
一、Oracle实例
1、Oracle 实例
System Global Area(SGA) 和 Background Process 称为数据库的实例 。
2、Oracle 数据库
一系列物理文件的集合（数据文件，控制文件，联机日志，参数文件等）
3、系统全局共享区System Global Area(SGA)
System Global Area 是一块巨大的共享内存区域，他被看做是Oracle 数据库的一个大缓冲池 ， 这里的数据可以被Oracle的各个进程共用 。其大小可以通过如下语句查看：
SQL select * from v$sga;
NAME VALUE
-------------------- ---------
Fixed Size 39816
Variable Size 259812784
Database Buffers 1.049E 09
Redo Buffers 327680
更详细的信息可以参考V$sgastat、V$buffer_pool
主要包括以下几个部分：
a、 共享池(Shared pool)
共享池是SGA中最关键的内存片段，特别是在性能和可伸缩性上 。一个太小的共享池会扼杀性能，使系统停止，太大的共享池也会有同样的效果，将会消耗大量的CPU来管理这个共享池 。不正确的使用共享池只会带来灾难 。共享池主要又可以分为以下两个部分：
SQL语句缓冲(Library Cache)
当一个用户提交一个SQL语句，Oracle会将这句SQL进行分析(parse)，这个过程类似于编译，会耗费相对较多的时间 。在分析完这个SQL，Oracle会把他的分析结果给保存在Shared pool的Library Cache中，当数据库第二次执行该SQL时，Oracle自动跳过这个分析过程，从而减少了系统运行的时间 。这也是为什么第一次运行的SQL 比第二次运行的SQL要慢一点的原因 。
下面举例说明parse的时间
SQL select count(*) fromscpass ;
COUNT(*)
----------
243
Elapsed: 00:00:00.08
这是在Share_pool 和Data buffer 都没有数据缓冲区的情况下所用的时间
SQL alter system flush SHARED_POOL;
System altered.
清空Share_pool ， 保留Data buffer
SQL select count(*) from scpass ;
COUNT(*)
----------
243
Elapsed: 00:00:00.02
SQL select count(*) from scpass ;
COUNT(*)
----------
243
Elapsed: 00:00:00.00
从两句SQL 的时间差上可以看出该SQL 的Parse 时间约为00:00:00.02
对于保存在共享池中的SQL语句 ， 可以从V$Sqltext、v$Sqlarea中查询到，对于编程者来说，要尽量提高语句的重用率，减少语句的分析时间 。一个设计的差的应用程序可以毁掉整个数据库的Share pool ， 提高SQL语句的重用率必须先养成良好的变成习惯，尽量使用Bind变量 。
数据字典缓冲区(Data Dictionary Cache)
显而易见，数据字典缓冲区是Oracle特地为数据字典准备的一块缓冲池 ， 供Oracle内部使用，没有什么可以说的 。
b、块缓冲区高速缓存(Database Buffer Cache)
这些缓冲是对应所有数据文件中的一些被使用到的数据块 。让他们能够在内存中进行操作 。在这个级别里没有系统文件,，户数据文件，临时数据文件 ， 回滚段文件之分 。也就是任何文件的数据块都有可能被缓冲 。数据库的任何修改都在该缓冲里完成 ， 并由DBWR进程将修改后的数据写入磁盘 。
这个缓冲区的块基本上在两个不同的列表中管理 。一个是块的“脏”表(Dirty List) ， 需要用数据库块的
书写器(DBWR)来写入，另外一个是不脏的块的列表(Free List)，一般的情况下 ， 是使用最近最少使用 (Least Recently Used,LRU)算法来管理 。块缓冲区高速缓存又可以细分为以下三个部分（Default pool,Keep pool,Recycle pool） 。如果不是人为设置初始化参数(Init.ora)，Oracle将默认为Default pool 。由于操作系统寻址能力的限制，不通过特殊设置，在32位的系统上，块缓冲区高速缓存最大可以达到1.7G，在64位系统上 ， 块缓冲区高速缓存最大可以达到10G 。
c、重做日志缓冲区(Redo log buffer)
重做日志文件的缓冲区，对数据库的任何修改都按顺序被记录在该缓冲，然后由LGWR进程将它写入磁盘 。这些修改信息可能是DML语句，如(Insert,Update,Delete) ， 或DDL语句，如(Create,Alter,Drop等) 。重做日志缓冲区的存在是因为内存到内存的操作比较内存到硬盘的速度快很多，所以重作日志缓冲区可以加快数据库的操作速度 ， 但是考虑的数据库的一致性与可恢复性，数据在重做日志缓冲区中的滞留时间不会很长 。所以重作日志缓冲区一般都很小，大于3M之后的重作日志缓冲区已经没有太大的实际意义 。
d、Java程序缓冲区(Java Pool)
Java 的程序区，Oracle 8I 以后，Oracle 在内核中加入了对Java的支持 。该程序缓冲区就是为Java 程序保留的 。如果不用Java程序没有必要改变该缓冲区的默认大小 。
e、大池(Large Pool)
大池的得名不是因为大，而是因为它用来分配大块的内存 ， 处理比共享池更大的内存，在8.0开始引入 。
下面对象使用大池：
MTS――在SGA的Large Pool中分配UGA
语句的并行查询(Parallel Executeion of Statements)――允许进程间消息缓冲区的分配，用来协调 并行查询服务器
备份(Backup)――用于RMAN磁盘I/O缓存
4、后台进程(Background process)
后台进程是Oracle的程序，用来管理数据库的读写，恢复和监视等工作 。Server Process主要是通过他和user process进行联系和沟通，并由他和user process进行数据的交换 。在Unix机器上 ， Oracle后台进程相对于操作系统进程，也就是说，一个Oracle后台进程将启动一个操作系统进程；在Windows机器上， Oracle后台进程相对于操作系统线程，打开任务管理器，我们只能看到一个Oracle.EXE的进程，但是通过另外的工具，就可以看到包含在这里进程中的线程 。
在Unix上可以通过如下方法查看后台进程：
ps ?ef | grep ora_
# ps -ef | grep ora_ | grep XCLUAT
Oracle 29431 1 0 Sep 02 2:02 ora_dbwr_SID
Oracle 29444 1 0 Sep 02 0:03 ora_ckpt_SID
Oracle 29448 1 0 Sep 02 2:42 ora_smon_SID
Oracle 29442 1 0 Sep 02 3:25 ora_lgwr_SID
Oracle 29427 1 0 Sep 02 0:01 ora_pmon_SID
a、Oracle系统有5 个基本进程他们是
DBWR(数据文件写入进程)
LGWR(日志文件写入进程)
SMON(系统监护进程)
PMON(用户进程监护进程)
CKPT(检查点进程,同步数据文件, 日志文件,控制文件)
b、DBWR
将修改过的数据缓冲区的数据写入对应数据文件
维护系统内的空缓冲区
这里指出几个容易错误的概念:
当一个更新提交后,DBWR把数据写到磁盘并返回给用户提交完成.
DBWR会触发CKPT 后台进程
DBWR不会触发LGWR 进程
上面的概念都是错误的.
DBWR是一个很底层的工作进程 ， 他批量的把缓冲区的数据写入磁盘 。和任何前台用户的进程几乎没有什么关系，也不受他们的控制 。至于DBWR会不会触发LGWR和CKPT进程，我们将在下面几节里讨论 。
DBWR工作的主要条件如下
DBWR 超时
系统中没有多的空缓冲区用来存放数据
CKPT 进程触发DBWR 等
c、LGWR
将重做日志缓冲区的数据写入重做日志文件，LGWR是一个必须和前台用户进程通信的进程 。当数据被修改的时候 ， 系统会产生一个重做日志并记录在重做日志缓冲区内 。这个重做日志可以类似的认为是以下的一个结构:
SCN=000000001000
数据块ID
对象ID=0801
数据行=02
修改后的数据=0011
提交的时候，LGWR必须将被修改的数据的重做日志缓冲区内数据写入日志数据文件 ， 然后再通知前台进程提交成功，并由前台进程通知用户 。从这点可以看出LGWR承担了维护系统数据完整性的任务 。
LGWR 工作的主要条件如下
用户提交
有1/3 重做日志缓冲区未被写入磁盘
有大于1M 重做日志缓冲区未被写入磁盘
超时
DBWR需要写入的数据的SCN号大于LGWR 记录的SCN号，DBWR 触发LGWR写入
d、SMON
工作主要包含
清除临时空间
在系统启动时，完成系统实例恢复
聚结空闲空间
从不可用的文件中恢复事务的活动
OPS中失败节点的实例恢复
清除OBJ$表
缩减回滚段
使回滚段脱机
e、PMON
主要用于清除失效的用户进程，释放用户进程所用的资源 。如PMON将回滚未提交的工作，释放锁，释放分配给失败进程的SGA资源 。
f、CKPT
同步数据文件，日志文件和控制文件 ， 由于DBWR/LGWR的工作原理，造成了数据文件，日志文件，控制文件的不一至 ， 这就需要CKPT进程来同步 。CKPT会更新数据文件/控制文件的头信息 。
CKPT工作的主要条件如下
在日志切换的时候
数据库用immediate ,transaction , normal 选项shutdown 数据库的时候
根据初始话文件LOG_CHECKPOINT_INTERVAL、LOG_CHECKPOINT_TIMEOUT、FAST_START_IO_TARGET 的设置的数值来确定
用户触发
以下进程的启动需要手工配置
g、ARCH
当数据库以归档方式运行的时候，Oracle会启动ARCH进程，当重做日志文件被写满时，日志文件进行切换，旧的重做日志文件就被ARCH进程复制到一个/多个特定的目录/远程机器 。这些被复制的重做日志文件被叫做归档日志文件 。
h、RECO
负责解决分布事物中的故障 。Oracle可以连接远程的多个数据库，当由于网络问题，有些事物处于悬而未决的状态 。RECO进程试图建立与远程服务器的通信，当故障消除后，RECO进程自动解决所有悬而未决的会话 。
i、服务进程Server Process
服务进程的分类
专用服务进程(Dedicated Server Process)
一个服务进程对应一个用户进程
共享服务进程(MultiTreaded Server Process)
一个服务进程对应多个用户进程，轮流为用户进程服务 。
PGAUGA
PGA = Process Global Area
UGA = User Global Area
他保存了用户的变量、权限、堆栈、排序空间等用户信息，对于专用服务器进程 ， UGA在PGA中分配 。对于多线程进程，UGA在Large pool中分配 。
j、用户进程User Process
在客户端，将用户的SQL 语句传递给服务进程
5、一个贯穿数据库全局的概念----系统改变号SCN(System Change Number)
系统改变号，一个由系统内部维护的序列号 。当系统需要更新的时候自动增加 ， 他是系统中维持数据的一致性和顺序恢复的重要标志 。
a. 查询语句不会使SCN增加，就算是同时发生的更新，数据库内部对应的SCN也是不同的 。这样一来就保证了数据恢复时候的顺序 。
b. 维持数据的一致性，当一
二、Oracle 数据库
Oracle数据库的组成――物理操作系统文件的集合 。主要包括以下几种 。
1、控制文件（参数文件init.ora记录了控制文件的位置）
控制文件包括如下主要信息
数据库的名字，检查点信息，数据库创建的时间戳
所有的数据文件，联机日志文件，归档日志文件信息
备份信息等
有了这些信息 ， Oracle就知道那些文件是数据文件，现在的重做日志文件是哪些，这些都是系统启动和运行的基本条件，所以他是Oracle运行的根本 。如果没有控制文件系统是不可能启动的 。控制文件是非常重要的，一般采用多个镜相复制来保护控制文件，或采用RAID来保护控制文件 。控制文件的丢失 ， 将使数据库的恢复变的很复杂 。
控制文件信息可以从V$Controlfile中查询获得
2、数据文件（数据文件的详细信息记载在控制文件中）
可以通过如下方式查看数据文件
SQL select name from v$datafile;
NAME
---------------------------------------------
/u05/dbf/PROD/system_01.dbf
/u06/dbf/PROD/temp_01.dbf
/u04/dbf/PROD/users_01.dbf
/u09/dbf/PROD/rbs_01.dbf
/u06/dbf/PROD/applsys_indx_01.dbf
/u05/dbf/PROD/applsys_data_01.dbf
从以上可以看出，数据文件大致可以分为以下几类：
i. 系统数据文件(system_01.dbf)
存放系统表和数据字典 ， 一般不放用户的数据，但是用户脚本，如过程，函数，包等却是保存在数据字典中的 。
名词解释：数据字典 数据字典是一些系统表或视图，他存放系统的信息，他包括数据库版本，数据文件信息，表与索引等段信息，系统的运行状态等各种和系统有关的信息和用户脚本信息 。数据库管理员可以通过对数据字典的查询，就可以了解到Oracle的运行状态 。
ii. 回滚段文件(rbs_01.dbf)
如果数据库进行对数据的修改，那么就必须使用回滚段，回滚段是用来临时存放修改前的数据(Before Image) 。回滚段通常都放在一个单独的表空间上（回滚表空间），避免表空间碎片化，这个表空间包含的数据文件就是回滚数据文件 。
iii. 临时数据文件(temp_01.dbf)
主要存放用户的排序等临时数据，与回滚段相似 ， 临时段也容易引起表空间碎片化，而且没有办法在一个永久表空间上开辟临时段，所以就必须有一个临时表空间 ， 它所包含的数据文件就是临时数据文件，主要用于不能在内存上进行的排序操作 。我们必须为用户指定一个临时表空间 。
iv. 用户数据文件(/applsys_data_01.dbf ,applsys_indx_01.dbf)
存放用户数据，这里列举了两类常见的用户型数据，一般数据和索引数据，一般来说，如果条件许可的话，可以考虑放在不同的磁盘上 。
3、重做日志文件（联机重做日志）
用户对数据库进行的任何操作都会记录在重做日志文件 。在了解重做日志之前必须了解重做日志的两个概念 ， 重做日志组和重做日志组成员(Member) ， 一个数据库中至少要有两个日志组文件，一组写完后再写另一组 ， 即轮流写 。每个日志组中至少有一个日志成员，一个日志组中的多个日志成员是镜相关系，有利于日志文件的保护，因为日志文件的损坏，特别是当前联机日志的损坏，对数据库的影响是巨大的 。
联机日志组的交换过程叫做切换，需要特别注意的是，日志切换在一个优化效果不好的数据库中会引起临时的“挂起” 。挂起大致有两种情况：
在归档情况下，需要归档的日志来不及归档，而联机日志又需要被重新利用
检查点事件还没有完成（日志切换引起检查点），而联机日志需要被重新利用
解决这种问题的常用手段是：
i.增加日志组
ii.增大日志文件成员大小
通过v$log可以查看日志组，v$logfile可以查看具体的成员文件 。
4、归档日志文件
Oracle可以运行在两种模式之中，归档模式和不归档模式 。如果不用归档模式，当然，你就不会有归档日志，但是，你的系统将不会是一个实用系统，特别是不能用于生产系统，因为你可能会丢失数据 。但是在归档模式中，为了保存用户的所有修改，在重做日志文件切换后和被覆盖之间系统将他们另外保存成一组连续的文件系列，该文件系列就是归档日志文件 。
有人或许会说，归档日志文件占领我大量的硬盘空间，其实，具体想一想，你是愿意浪费一点磁盘空间来保护你的数据，还是愿意丢失你的数据呢？显而义见 ， 我们需要保证我们的数据的安全性 。其实，归档并不是一直占领你的磁盘空间，你可以把她备份到磁带上，或则删除上一次完整备份前的所有日志文件 。
5、初始化参数文件
initSID.ora或init.ora文件 ， 因为版本的不一样 ， 其位置也可能会不一样 。在8i中 ， 通常位于$Oracle_HOME/admin//Pfile下，初始化文件记载了许多数据库的启动参数，如内存，控制文件，进程数等，在数据库启动的时候加载（Nomount时加载），初始化文件记录了很多重要参数，对数据库的性能影响很大，如果不是很了解，不要轻易乱改写，否则会引起数据库性能下降 。
6、其他文件
i . 密码文件
用于Oracle 的具有sysdba权限用户的认证.
ii. 日志文件
报警日志文件（alert.log或alrt.ora）
记录数据库启动，关闭和一些重要的出错信息 。数据库管理员应该经常检查这个文件，并对出现的问题作出即使的反应 。你可以通过以下SQL 找到他的路径select value from v$PARAMETER where name ="background_dump_dest";
后台或用户跟踪文件
系统进程或用户进程出错前写入的信息，一般不可能读懂，可以通过Oracle的TKPROF工具转化为可以读懂的格式 。对于系统进程产生的跟踪文件与报警日志文件的路径一样，用户跟踪文件的路径，你可以通过以下SQL找到他的路径select value from v$PARAMETER where name ="user_dump_dest";
三、Oracle逻辑结构
1、 表空间(tablespace)
表空间是数据库中的基本逻辑结构，一系列数据文件的集合 。一个表空间可以包含多个数据文件，但是一个数据文件只能属于一个表空间 。
2、 段(Segment)
段是对象在数据库中占用的空间，虽然段和数据库对象是一一对应的，但段是从数据库存储的角度来看的 。一个段只能属于一个表空间，当然一个表空间可以有多个段 。
表空间和数据文件是物理存储上的一对多的关系，表空间和段是逻辑存储上的一对多的关系，段不直接和数据文件发生关系 。一个段可以属于多个数据文件，关于段可以指定扩展到哪个数据文件上面 。
段基本可以分为以下四种
数据段(Data Segment)
索引段(Index Segment)
回滚段(Rollback Segment)
临时段(Temporary Segment)
3、区间(Extent)
关于Extent的翻译有多种解释，有的译作扩展，有的译作盘区，我这里通常译为区间 。在一个段中可以存在多个区间，区间是为数据一次性预留的一个较大的存储空间，直到那个区间被用满 ， 数据库会继续申请一个新的预留存储空间，即新的区间，一直到段的最大区间数(Max Extent)或没有可用的磁盘空间可以申请 。在Oracle8i以上版本，理论上一个段可以无穷个区间，但是多个区间对Oracle却是有性能影响的，Oracle建议把数据分布在尽量少的区间上，以减少Oracle的管理与磁头的移动 。
4、Oracle数据块(Block)
Oracle最基本的存储单位，他是OS数据块的整数倍 。Oracle的操作都是以块为基本单位 ， 一个区间可以包含多个块（如果区间大小不是块大小的整数倍，Oracle实际也扩展到块的整数倍） 。
5、基本表空间介绍
a. 系统表空间
主要存放数据字典和内部系统表基表
查看数据数据字典的SQL
select * from dict
查看内部系统表的SQL
select * from v$fixed_view_definition
DBA对系统的系统表中的数据字典必须有一个很深刻的了解，他们必须准备一些基础的SQL语句，通过这些SQL可以立即了解系统的状况和数据库的状态 ， 这些基本的SQL包括
系统的剩余空间
系统的SGA
状态系统的等待
用户的权限
当前的用户锁
缓冲区的使用状况等
在成为DBA 的道路上我们不建议你过分的依赖于OEM/Quest 等优秀的数据库管理工具 ， 因为他们不利于你对数据数据字典的理解，SQL语句可以完成几乎全部的数据库管理工作 。
大量的读少量的写是该表空间的一个显著的特点 。
b. 临时表空间.
临时表空间顾名思义是用来存放临时数据的，例如排序操作的临时空间，他的空间会在下次系统启动的时候全部被释放 。
c. 回滚段表空间
i. 回滚段在系统中的作用
当数据库进行更新插入删除等操作的时候，新的数据被更新到原来的数据文件 ， 而旧的数据(Before Image)就被放到回滚段中，如果数据需要回滚，那么可以从回滚段将数据再复制到数据文件中 。来完成数据的回滚 。在系统恢复的时候，回滚段可以用来回滚没有被commit 的数据，解决系统的一至性 。
回滚段在什么情况下都是大量的写，一般是少量读，因此建议把回滚段单独出来放在一个单独的设备（如单独的磁盘或RAID），以减少磁盘的IO争用 。
ii. 回滚段的工作方式
一个回滚表空间可以被划分成多个回滚段.
一个回滚段可以保存多个会话的数据.
回滚段是一个圆形的数据模型
假设回滚段由4 个区间组成，他们的使用顺序就是区间1à区间2à区间3à区间4à区间1 。也就是说，区间是可以循环使用的，当区间4到区间1的时候，区间1里面的会话还没有结束, 区间4用完后就不能再用区间1,这时系统必须分配区间5 ， 来继续为其他会话服务服务 。
我们分析一个Update 语句的完成
①. 用户提交一个Update 语句
②. Server Process 检查内存缓冲.
如果没有该数据块的缓冲 ， 则从磁盘读入
i. 如果没有内存的有效空间，DBWR被启动将未写入磁盘的脏缓冲写入磁盘
ii. 如果有有效空间，则读入
③. 在缓冲内更新数据
i. 申请一个回滚段入口 ， 将旧数据写如回滚段
ii. 加锁并更新数据
iii. 并在同时将修改记录在Redo log buffer中
Oracle查询时，第一次查询很慢 ， 第二次及以后查询速度就很快了，那后面的查询的结果集会不会不是最新的Oracle查询时，第一次查询很慢 ， 第二次及以后查询速度就很快了 这种情况是正常的，因为第一次查询的时候，oracle会自动建立索引 ， 之后的查询会利用第一次建立的索引进行查询 。所以后面的查询会相对快很多 ， 尤其数据量比较大的时候，很明显 。至于你说“表中数据被更新到20000，再次查询还是从缓存中拿到的结果集 ， 依然是10000行” 。这种情况出现可能性不大，建议你更新数据后一定要提交更新，commit 一下，这些数据才会真正写到库中 。
oracle 缓存结果集 会自动变化吗oracle的结果集缓存
oracle 调整结果集缓存 ， 只有3个参数 。
RESULT_CACHE_MAX_SIZE=500M /* Megabytes
RESULT_CACHE_MAX_RESULT=20 /* Percentage
RESULT_CACHE_REMOTE_EXPIRATION=3600 /* Minutes
但是在 result_cache_mode 为force 的时候才会去保存所有的查询，在manual 的时候需要 HINT 来enable .
alter session set result_cache_mode=force;
show parameter result_cache
NAMETYPEVALUE
------------------------------------ ----------- ------------------------------
client_result_cache_lagbig integer 3000
client_result_cache_sizebig integer 0
result_cache_max_resultinteger5
result_cache_max_sizebig integer 5984K
result_cache_modestringMANUAL
result_cache_remote_expirationinteger0
查询下内存分配情况
SQL SET SERVEROUTPUT ON
SQL execute dbms_result_cache.memory_report
R e s u l t C a c h e M e m o r yR e p o r t
[Parameters]
Block Size= 1K bytes
Maximum Cache Size = 5984K bytes (5984 blocks)
Maximum Result Size = 299K bytes (299 blocks)
[Memory]
Total Memory = 174752 bytes [0.027% of the Shared Pool]
... Fixed Memory = 10696 bytes [0.002% of the Shared Pool]
... Dynamic Memory = 164056 bytes [0.026% of the Shared Pool]
....... Overhead = 131288 bytes
....... Cache Memory = 32K bytes (32 blocks)
........... Unused Memory = 30 blocks
........... Used Memory = 2 blocks
............... Dependencies = 1 blocks (1 count)
............... Results = 1 blocks
................... SQL = 1 blocks (1 count)
PL/SQL procedure successfully completed.
好像只有oracle 有这个东西，DB2 和mysql 都没有 。
oracle 库高速缓存和缓冲区缓存 区别数据高速缓存跟操作系统的缓存类似，其存储最近从数据文件中读取的数据块，其中的数据可以被所有的用户所访问 。如当我们利用Select语句从数据库中查询员工信息的时候，其首先不是从数据文件中去查询这个数据，而是从数据高速缓存中去查找 ， 而没有这个必要再去查询磁盘中的数据文件了 。只有在数据缓存中没有这个数据的时候，数据库才会从数据文件中去查询 。Oracle数据库为什么要如此设计呢?这是由于数据库在读取数据的时候，读取内存的速度比读取磁盘的速度要快很多倍 ， 所以这种机制可以提高数据的整体访问效率 。
缓冲区缓存
重新启动数据库后，系统就会为数据库分配一些空闲的缓存块 。空闲缓存块中是没有任何数据的，他在那边默默的等着别写入记录 。当Oracle 数据库从数据文件中读取数据后，数据库就会寻找是否有空闲的缓存块 ， 以便将数据写入其中 。
一般来说，数据库在启动的时候，就会在内存中预先分配这些缓存块 。所以 ， Oracle数据库在启动的时候，会占用比较多的内存 。但是，这可以免去在实际需要时向内存申请的时间 。所以，有时候Oracle数据库虽然已启动 ， 内存的占用率就很高，但是 ， 其后续仍然可以正常运行的原因 。而其他数据库虽然刚启动的时候内存占用率不是很高，但是，但系统内存到达80%以上时，在进行数据处理就会受到明显的影响 。
【oracle怎么查询缓存 oracle查看存储空间】关于oracle怎么查询缓存和oracle查看存储空间的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：如何搭建NFS服务器？ 怎么建立nfs服务器

    下一篇：mysql搜索关键字 mysql搜索教程