Oracle 相关的专业术语 说明
2PC: (See two-phase commit)
ACID: The properties of a reliable transactional system: Atomic,Consistent, Isolated and Durable.
archived redo logfile: (See log file(archived))
array: A list of related items of uniform size. If you know the size of anitem, you can calculate the location of the nth item in the list.
AMM(automatic memory management): Introduced in11g, this allows you to tell the instance how much memory it is allowed toacquire, but lets the instance decide dynamically how to share the memorybetween the server processes and the SGA.
Oracle 11gR2RAC ORA-00845 MEMORY_TARGET not supported on this system 解决方法
http://blog.csdn.net/tianlesoftware/article/details/6013777
ASM (automatic storagemanagement): Introduced in 10g, this is the featurethat uses a special version of an Oracle instance to act like a logical volumemanager, mapping the connection between database files and disk devices.
http://blog.csdn.net/tianlesoftware/article/details/5314541
ASM 专栏
http://blog.csdn.net/tianlesoftware/article/category/799909
ASMM (automatic shared memory management): Introduced in 10g, this allows you to tell the instance how muchmemory to allocate for the SGA as a whole, allowing the instance to decidedynamically how much should be allocated to each large-scale structure withinthe SGA.
ASSM (automatic segment space management): The default space management mechanism for tablespaces, originallyintroduced in 9i to relieve the DBA of a need to worry about setting the numberof freelists or freelist groups for a data object.
Oracle 自动段空间管理(ASSM:autosegment space management)
http://blog.csdn.net/tianlesoftware/article/details/4958989
AUM (automatic undo management): Introduced in 9i as a mechanism to relieve the DBA of a need tospecify the number and size of undo (rollback) segments.
http://blog.csdn.net/tianlesoftware/article/details/7620628
block: The smallest unit of file handling in an Oracle database. Itgenerally refers to the data block.
block address: The absolute address of a block in a database. For datafiles it ismade up of the absolute file number and the block number within file.
block header: An area at the start of each block holding various pieces ofinformation about the contents of the block.
buffer:
(a) Memory used as a high-speed storagelayer between the user and the discs.
(b) The memory used to hold copies ofrecently accessed data blocks (typical Oracle usage).
(c) A unit of memory sized to hold exactlyone data block (alternate Oracle usage).
(d) A copy of the latest section of theredo log file currently being written to (log buffer).
buffer handle: (See buffer pin)
buffer header: A chunk of memory describing the content of a single data bufferand holding various pointers and flags describing the state of the buffer.Buffer headers are stored in an array in the same memory granule as the buffersthey describe.
buffer pin (also bufferhandle): A small chunk of memory from the shared poolthat connects a user to a data buffer. It is associated with the buffer throughone of two linked lists attached to the buffer header.
change vector: (See redo change)
checkpoint:
(a) As a noun, the moment Oracle startscopying the content of current blocks from buffers to disc in order to bring(some part of) the datafiles up-to-date with respect to the redo log files.
(b) As a verb, the action of copyingbuffers to disc. Checkpoints may be full (e.g., at database shutdown) orpartial (e.g., at tablespace read only calls).
checkpoint (incremental):A checkpoint that is invoked every three seconds tocopy data blocks with the oldest recorded changes from the data buffer to disc(rather than copying datablocks of a specific part of the database, such as atable or tablespace). The database control file is updated with a timestamp (inthe form of an SCN and Redo Byte Address) of the oldest change to a data blockthat has not yet been protected by this copy. There will be occasions whenthere are no blocks in the data buffer that need copying.
child cursor: A collection of objects in the library cache that define theexecution plan, dependencies, and environment that allow a session to executean SQL statement. A single statement may end up generating multiple childcursors.
circular reference: (See reference, circular)
cluster (1): A data structure available to Oracle that allows rows with relatedvalues to be stored in the same data blocks. There are two options, hashclusters and index clusters. A cluster may hold multiple tables.
cluster (2): A network of closely coupled computers engineered to behave as asingle unit through the constant exchange of messages.
commit: Instruction to Oracle to allow the changes made by a transaction tobecome visible to other users of the database, and ensure that the changes aremade durable by writing the relevant part of the log buffer to disc.
commitcleanout: The action of revisiting blocks to update a transaction's ITL entryin each block with the commit SCN at the moment the transaction commits(Oracle-specific).
http://blog.csdn.net/tianlesoftware/article/details/6663527
commit SCN: The SCN generated at the moment a transaction commits.
consistent get: The act of visiting a buffer that contains a copy of a blockprocessed to show only those changes committed at a required target SCN.Getting to this state sometimes needs no work done.
current get: The act of visiting a buffer that is known to contain the mostup-to-date version of a block.
database: The physical storage component of an Oracle system, comprised at aminimum of datafiles, tempfiles, online redo log files, control files, andparameter files.
database writer (dbwr): The process (dbwN, if there are multiple processes) responsible forcopying the current version of blocks from the buffer to disc.
datafile: A file holding persistent data, which may be end-user data, Oracle'sdata and metadata, or the recent history (in the undo records) of datagenerated by Oracle.
dbwr (also dbwN): (See database writer)
delayed block cleanout: If a block has not been updated with a commit SCN by a committingtransaction, the next session to read the block will be required to update therelevant ITL entry with a suitable commit SCN, and clear out any lockinginformation that the transaction left behind.
delayed logging blockcleanout: When a commit cleanout occurs, the sessiondoes not log the change made to the ITL. Instead, the next session to modifythe block finishes the cleanout and writes the complete log of all the changesthat the committing session should have made – hence the logging for thecommitting session has been delayed.
dynamic performanceviews: Generic name for the x$ memory structures and(more commonly) v$ and gv$ views that allow the SYS account to see some of theinternal structures used by the Oracle program as it runs.
http://blog.csdn.net/tianlesoftware/article/details/5863191
enqueue: Used to serialize access to objects. The code path for enqueues islonger that the code path for latches and mutexes, but enqueues allow for agreater variation in the options for how restrictive the serialization can be.Enqueues tend to be used to protect "real" physical parts of thedatabase.
enqueue resource: A chunk of memory labeled to represent an object in the database.RAC has two layers of resources—the local ones that we see in single instanceOracle, and a much greater volume of global ones that are used to coordinatemultiple SGAs.
fast commit: The term used to describe Oracle's mechanism for doing the smallestamount of work possible when a transaction commits.
free space credit: Part of an ITL entry that reports the number of bytes of space in ablock that would become free if the transaction owning the ITL entry commits.(Note: This is never set to a value less than zero.)
OraceITL(Interested Transaction List) 说明
http://blog.csdn.net/tianlesoftware/article/details/6573988
GCS (global cacheservices): In RAC, the mechanism that deals withkeeping the data caches of all the SGAs coherent.
GES (global enqueuesservices): In RAC, the mechanism that coordinateslocking activity (other than simple row-locking) across all instances.
granule (also memorygranule): The large-scale unit of memory that Oracleuses to organize the SGA and allow memory to be transferred between thedifferent functions of the SGA. Possible granule sizes are 4 MB, 8 MB, 16 MBand 64MB , dependent on version and SGA size.
GRD (global resourcedirectory): In RAC, the set of distributed resourcesused to coordinate the activity of the multiple SGAs. The GRD is shared acrossall instances, and Oracle has an algorithm for calculating where to find aparticular master resource.
group commit: When the log writer (lgwr) is posted to write, it will write thecontents of the log buffer up to the highest used point. This means that anytransactions that happen to have their commit record in the log buffer betweenthe start and end of the write are all made durable at the same time. Oncompleting the write, lgwr will post all sessions that are waiting for a blockto be written if that has a lower address than the last block written.
hash bucket: A single location in a hash table used as the starting point of alinked list of items that produce a matching value when a particular arithmeticfunction is applied to a key attribute of the item. (Sometimes usedsynonymously with hash chain.)
hash chain: A linked list of items in a single hash bucket.
Hash Function: A mathematical algorithm that will always give the same output valuefor a given input value and will attempt to distribute all allowable inputvalues evenly across the allowed output values.
hash table: An array of hash buckets used as the basis of an access method,allowing rapid location of a data item through a key value.
in-memory undo: Along with private redo, Oracle 10g introduced "privateundo." This is memory in the SGA that acts as a set of miniature logbuffers that may be allocated to individual sessions for the duration of atransaction; however, these buffers will only hold redo relating to the changesa transaction should make to undo blocks. When a transaction commits, thein-memory undo will be copied into the public log buffer immediately after theprivate redo. There are various reasons why this copy may happen prematurely.
incremental checkpoint: (See checkpoint, incremental)
initrans: A parameter in an object (table, index, or cluster) definitionspecifying, and reserving space for, the minimum number of concurrenttransactions that will be allowed to modify any given block in the object. (Seealso maxtrans)
instance: The collective name for the shared memory segment and the Oracleprocesses that access it. Many instances can have concurrent access to a singledatabase.
Interested TransactionList: (See ITL)
ITL (interestedtransaction list): An area in each block of a dataobject (table, index, cluster) holding information about transactions thatrecently modified that block.
Java pool: One of the subheaps of the SGA. It is reserved for use by the JavaVirtual Machine.
KGL lock: A small chunk of memory that can be attached, through a linked list,to an item in the library cache to associate it with a session that has beenusing it. KGL locks are exposed through the dynamic performance viewv$open_cursor.
KGL pin: A small chunk of memory that can be attached, through a linked list,to an item in the library cache to associate it with a session that is currentlyusing it. KGL pins have largely been replaced in 11.2by mutexes.
--KGL pins 在11.2中主要被mutexes替代。
large pool: One of the subheaps of the SGA. It is reserved for allocations oflarge chunks of memory of a fairly uniform size. Created as a way to reducefragmentation of the shared pool, the large pool tends to hold memory chunksallocated by RMAN, parallel execution slaves and, for systems usingshared_server technology, session heaps.
last change SCN: An SCN value recorded on each data block that, in combination with asingle byte counter, records the SCN at the moment the block was last modified.The counter is restarted at one when a change is made at a new SCN, and the SCNis incremented after the counter reaches 254.
latch: A small chunk of memory, combined with an atomic CPU operation,which can be used to act as a serialization mechanism. The structure is largerand the code path is longer than it is for a mutex because the latch allowsmore space and code for instrumentation. Latches tend to be used to protectobjects that are fixed, in-memory structures.
lgwr (log writer): The background process responsible for copying the log buffer todisc. The log writer is scheduled to run on a very regular basis to ensure thatthe log buffer stays nearly empty at all times.
library cache: The collection of items in the shared pool relating to SQL andPL/SQL statements, including object dependencies, privileges, and executionplans for statements.
linked list: A collection of related data items that are connected only by aseries of pointers. Each item in the list points to the next one, and the onlyway to find a specific item is to follow pointers along the list until you getto the item you want. Oracle makes frequent use of linked lists (and especiallydoubly-linked lists, where each item points forward to the next item andbackwards to the previous item).
lock: (See enqueues and KGL lock)
lock byte: An attribute of a row (or index entry). When any rows in a blockhave been modified by a given transaction, there will be an ITL entry in thatblock identifying the transaction. The index of the ITL entry used by thattransaction will be written into a single-byte location at the start of therow. This allows other processes to see that the row has been locked, and whichtransaction locked it.
lock mode: Although locks (enqueues) act to serialize access to objects, thereare ways in which sessions may share, or partially share, objects. Oracleallows for six different levels (i.e., modes) of locking, and a complexarrangement of lock compatibility.
log buffer: Sometimes called the public log buffer or public redo thread, thisis a relatively small chunk of memory in the SGA used as a window into thecurrent redo log file. Most Oracle processes may copy change records into the logbuffer, but only the log writer can transfer the contents of the buffer todisc. Since 9i it has been possible to have multiplelog buffers, and this happens automatically in 10g. (10g also introduced"private" log buffers.)
log buffer, private: (See private redo thread) log file (redo log file): A file holdingthe stream of change records produced by sessions as they modify data blocks.Each instance in RAC will have its own set of log files. An instance usuallyhas a small number of "online" redo log files that are constantlyreused.
log file (archived): If a database is running in archivelog mode, then each online redolog file has to be copied to an alternative location before it can be reused.These copies are referred to as archived redo log files.
log writer: (See lgwr)
logical standby: A copy of a live database opened in a special mode that allows theredo information from the live database to be translated into SQL statements,which can be run against the standby. The standby will be open in read/writemode and can be used for other work. The redo selected can be a subset of thefull redo.
LRU (least recentlyused): An algorithm for optimizing the effectiveness ofa buffer by arranging the contents in a list and promoting popular (recentlyused) items to the top of the list while allowing unpopular items to drift tothe end of the list and fall off.
master resource: In RAC, the global resource directory (GRD) holds a list ofresources representing individual items (blocks, sequences, transactions) at afine level of granularity. One instance will hold a complete record for an itemlisting all the interested instances—this complete record is the masterresource.
maxtrans: A parameter in an object (table, index or cluster) definition thatlimits the number of concurrent transactions that can modify any given block inthe object. (See also initrans)
memory granule: (See granule)
multi-threaded server: (See shared server)
mutex: A small chunk of memory combined with an atomic CPU operation, whichcan be used to act as either a serialization mechanism or (with a longer holdtime) a pinning mechanism. The structure is significantly smaller and the codepath is much shorter than it is for a latch because a mutex has very littleinstrumentation. Mutexes are generally embedded inobjects, so can be created dynamically, making them more numerous (offeringreduced contention), but harder to track. Mutexes tend to be used to protectobjects that are fairly transient, in-memory structures.
online redo log: (See log file)
oradebug: A debugging utility supplied by Oracle, which can be run by asuitably privileged user connected to an instance through SQL*Plus. Oradebugallows you to examine structures (physical database and in-memory instance) andmanipulate the code path and memory content of a running instance.
physical standby: A copy of the live database started in recovery mode so that the rawinformation from the redo log of the live database can be applied to it to keepit in synch (with a small delay) with the live database. 11g introduced a(licensed) option to open a physical standby for reporting while the redo isstill being applied.
piggyback commit: (See group commit)
pmon (process monitor): One of the basic background processes in an Oracle instance thatdeals with cleaning up any memory structures that have been left by a failedsession (or end-user process).
pointer: A memory location holding the address of another memory location.
private redo thread: Since 10g, Oracle has allocated chunks of memory in the SGA to actas mini log buffers that may be allocated to individual sessions for theduration of a transaction. When a session commits it will copy the content ofits private log buffer into the public log buffer. (There are various reasonswhy this copy can take place prematurely).
RAC (real applicationcluster): A version of the Oracle code that allowsmultiple instances to share the same set of database files, which, ifimplemented correctly, can offer benefits of scalability and availability.
read consistent: As in "a read consistent copy of block X." A way ofdescribing a copy of a block that shows only the transactions committed as at aspecific SCN. (See consistent get)
real application cluster:(See RAC)
recovery: The process of taking an old copy of a database and bringing thecopy up-to-date by applying the redo that has been generated since the copy wasmade—and rolling back any uncommitted transactions that are still visible inthe database once all the relevant redo has been applied.
redo change:The description of the effects of a single atomicchange to a datafile block.
redo record:A group of redo change vectors which constitutes asingle contiguous item to copy into the log buffer (and on to the log file).
redo strand, private: (See private redo thread)
reference, circular: (See circular reference)
rocket science: A generic term suggesting that a topic is technically too complexfor an ordinary individual to understand; for example, "Oracle iscomplicated, but it's not rocket science."
rollback: A command to apply the undo records generated by a transaction sothat the changes made by that transaction are effectively removed from thedatabase; also the action of applying undo records.
rollback segments: A common term used to describe undo segments before automatic undomanagement was introduced in 9i.
row directory: A section of an index or table block that contains a list ofoffsets (pointers) to the starting position of rows (index entries) in theblock.
savepoint: It is possible to create named savepoints part way through atransaction so that, prior to commit, the transaction can be partially undoneby a call to roll back to a specific savepoint.
science: A mechanism for establishing the degree to which an abstract modelof the real world matches the real world.
SCN (system change/commitnumber): A counter stored in the SGA of an instancethat acts as a clocking mechanism. Each time a session commits a transaction(and on a few other occasions) the SCN is incremented. In a RAC environment,the different instances are constantly re-synchronizing their SCNs.
SCN, commit: (See commit SCN)
SCN, last change: (See last change SCN)
segment header: A special block (once guaranteed to be the first block in asegment) holding metadata about the segment. In an ASSM tablespace there willbe a few segment space management blocks before the segment header block.
segmented array: An array that is broken into a number of chunks. This allows thearray to grow as needed without having to pre-allocate a large amount ofmemory. Oracle makes frequent use of segmented arrays to build simple lists.
SGA (also known as systemglobal area and shared global area): The memory that ismade publicly available (i.e., shared memory) to all processes accessing thedatabase. The combination of the memory and processes is known collectively asthe instance.
SGA heap: In computing terms, the shared pool is structured as a"heap," and a heapdump at level 2 will dump the shared pool—labelingit as the SGA heap.
shadow resource: In RAC, the global resource directory (GRD) holds a list ofresources representing individual items (blocks, sequences, transactions) at afine level of granularity. One instance will hold a complete record for anitem, listing all the interested instances. Every other instance that has aninterest in that item will hold a smaller record holding information only aboutthat instance's interest. These smaller records are the shadow resources.
Shared Global Area: (See SGA)
shared pool: Apart from the data cache, the largest allocation of memory in theSGA. It holds information about SQL and PL/SQL statements, object definitions,dependencies and privileges, and a few other structures.
single point of failure: (See SPOF)
smon (system monitor): A background process that wakes up every five minutes to check thestate of health of the instance and do various housekeeping tasks, such asdropping undo segments and deleting temporary segments from failed indexbuilds.
SPOF (single point offailure): Is there one piece of equipment in yoursystem that you could destroy to make your system unusable? If there is, youare looking at a single point of failure.
state object (SO): A chunk of memory in a session's heap that, typically, keeps trackof an object in the SGA; for example if a session has a transaction active, thesession memory will hold a 'transaction state object' corresponding to the rowit is using in x$ktcxb.
standby database: A generic label for a copy of a production database that uses thecontent of the live redo log files to keep itself automatically up-to-date innear real time. (See also logical standby and physical standby.)
streams pool: One of the subheaps of the SGA. It is reserved for use by Oracle'sStreams technology to avoid excess disk I/O when forwarding data to otherdatabases.
System Change Number: (See SCN)
System Commit Number: (See SCN)
sysaux tablespace: (See tablespace (sysaux))
System Global Area: (See SGA)
system tablespace: (See tablespace (system))
table directory: A section of a table block that identifies the starting point in therow directory for each of the tables stored in the block. It is only relevantto blocks belonging to clusters (1).
tablespace: The "large scale" unit of storage in Oracle. A tablespacemay be made up of many files that can be recovered individually, but logicallyit is better to think of the tablespace as the unit of recovery. In 10g Oracle introduced the "bigfile" tablespacewhich is limited to a single file.
tablespace (sysaux): A tablespace introduced in 10g to hold the high-volume, non-criticalinformation associated with various Oracle tools and features. Although thereis no special internal handling for the sysaux tablespace, user data should notbe stored in the sysaux tablespace.
http://blog.csdn.net/tianlesoftware/article/details/6290994
tablespace (system): The primary tablespace in the database that holds the datadictionary and a few other system related objects. There are a few specialmechanisms involved in the way Oracle handles the system tablespace and userdata should not be stored in the system tablespace.
tablespace (temporary): A special type of tablespace used by Oracle to hold transient dataand the intermediate results of in-memory operations that are large enough torequire "virtual" memory. Temporary tablespaces are subject to somevery special internal handling. Although transient user data in the form ofinstantiated global temporary tables may be stored in the temporarytablespaces, user objects cannot be defined to use temporary tablespaces.
http://blog.csdn.net/tianlesoftware/article/details/4697417
tablespace (undo): A special tablespace (or set of tablespaces), one active perinstance, used to store undo information. The undo tablespace is subject tosome very special internal handling, and user objects cannot be stored in theundo tablespaces.
temporary tablespace: (See tablespace (temporary))
trace file: A text file dumped in response to an error raised by Oracle or dueto an event set by the user. The default location of trace files varies withversion of Oracle and according to parameters that may be set by the DBA.
transaction: A set of changes that takes the database from one consistent state toanother consistent state. The set of changes becomes publicly visible only whenthe session making the changes issues a commit. No other session is allowed tosee any of the changes until it is allowed to see all of the changes.
transaction table: A short list in each undo segment header block that holds referencedetails for recent transactions.
transaction control: A section in each undo segment header block that holds summaryinformation about the state of the segment's transaction table.
two-phase commit (2PC): A protocol used in distributed transactions to ensure that all thecomponents of the transactions end up in the same state, that is, all committedor all rolled back.
undo record: The unit of information stored in an undo tablespace describing howto reverse out a single change to a data block.
undo segment: Segment created in the undo tablespace for storing undo information.
undo segment header: The first block of an undo segment holding, in particular, thetransaction table and transaction control for the segment.
undo tablespace: (See tablespace (undo))
upper bound commit: The SCN written to an ITL during delayed block cleanout. Thetransaction may have committed before this SCN, but the process doing thecleanout doesn't need to know exactly when the commit took place.
整理自《Oracle Core Essential Internals for DBAsand Developers》
-------------------------------------------------------------------------------------------------------
Skype: tianlesoftware
QQ: tianlesoftware@gmail.com
Email: tianlesoftware@gmail.com
Blog: http://www.tianlesoftware.com
Weibo: http://weibo.com/tianlesoftware
Twitter: http://twitter.com/tianlesoftware
Facebook: http://www.facebook.com/tianlesoftware
Linkedin: http://cn.linkedin.com/in/tianlesoftware
-------加群需要在备注说明Oracle表空间和数据文件的关系，否则拒绝申请----
DBA1 群：62697716(满); DBA2 群：62697977(满) DBA3 群：62697850(满)
DBA 超级群：63306533(满); DBA4 群：83829929 DBA5群： 142216823
DBA6 群：158654907 DBA7 群：172855474 DBA总群：104207940
