Index
A
Alert log files
APEX (Application Express)
Application domain indexes
Architecture
components
database sharding
dedicated server configuration
instance/database
multitenant container database
networking case
client software
connection string
dedicated server connections
easy connect plus
listener process
shared server connections
tnsnames.ora file
SGA/background processes
sharded database
shared server
single-tenant/non-container database
Archive Process (ARCn)
redo/undo
Automatic Storage Management Background (ASMB)
focused background processes
data pump
Atomicity
Autocommit
Automatic Diagnostic Repository (ADR)
Automatic Diagnostic Repository Command Interpreter (ADRCI)
Automatic indexing
action working process
CONFIGURE procedure
database management
DBA_INDEXES
feature creation
management
Automatic Memory Management (AMM)
Automatic Shared Memory Management (ASMM)
automatic techniques
components
manual management
SGA_TARGET
Automatic Storage Management (ASM)
database types
datafiles
Automatic Workload Repository (AWR)
Autonomous transactions
actions/consequences
AUTONOMOUS_INSERT procedure
controlling method
error log information
features
LOG_ERROR procedure
NONAUTONOMOUS_INSERT procedure
PL/SQL statements
procedures
ROLLBACK command
SYS.SEQ$ table
B
Background processes
Bad transaction habits
configuration issue
data integrity
loop process
ORA-01555 error
performance implications
restartable processes
snapshot/old error message
UPDATE statement
Bitmap indexes
ad hoc queries
AND/OR
data warehouse/large reporting system
DBMS_RANDOM package
DEPT.DEPTNO
experimentation
features
GENDER, LOCATION, and AGE_GROUP
JOB-IDX representation
join index
low distinct cardinality
OR representation
read/write-intensive environment
Black box approach
approaches
autonomous transactions
bitmap index
blocking/serialization issue
built-in queuing capabilities
competent
concurrency issues
database application
error-logging mechanism
Fear, Uncertainty, and Doubt (FUD)
features
find/lock records
hard database
indexing
instrumenting code
massive performance issues
PDB1 source code
projects failures
scalable database
scenario
serialization problem
SKIP LOCKED
subtransaction
unprocessed records
Blockchain technology
CREATE BLOCKCHAIN TABLE clauses
DBMS_BLOCKCHAIN_TABLE
drop table clause
features
hash/data format clause
insert-only tables
row retention clause controls
sensitive financial information
table creation
Block cleanout
redo
artificial conditions
buffer cache
COMMIT-time processing
concept
DBMS_STATS
modified blocks
OLTP system
PL/SQL procedure
processing information
remove
SELECT command
table and commit
working process
undo
ALL_OBJECTS table
COMMIT SCN
modification
ORA-01555 error conditions
PL/SQL procedure
run.sh file
run.sh script
tablespace
test2.sql
transaction table
UPDATE statement
Blocking
AUTONOMOUS_TRANSACTION
DBMS_LOCK
DML statements
holding session
INSERT option
merges/updates/deletes
SYS_GUID() built-in function
well-designed application
B*Tree indexes
binary search tree
branch blocks
clustering factor
COLOCATED_PK index
descending indexes
different cases
fast full scan
fraction
general-purpose mechanism
height balanced
index key compression
COMPRESS index
IDX_STATS table
OPT_CMPR_PCTSAVE
OWNER component
prefix and suffix component
table/index
index range scan
layout
leaf nodes/blocks
nonunique index
physical organization
ARRAYSIZE logical I/O
COLOCATED table
DISORGANIZED table
features
physical data layout
primary key
TKPROF (SQL Trace) output
primary key index
reverse key indexes
DUMP function
features
network connection
performance test
PL/SQL environment
RAC instances
REVERSE command
rules of thumb
TABLE ACCESS BY INDEX ROWID
C
CASCADE UPDATE
Change tracking file
Change Tracking Processes (CTWR)
Character (or comma) separated values (CSV)
Checkpoint process (CKPT)
Commit/rollback processing
block cleanout
CLASSPATH variable
COMMIT statement
COMMIT modified blocks
DBMS_UTILITY package
doInserts() method
drop table structure
factors contribution
human-readable performance output
INSERT/COMMIT
insert/binding/executing option
LGWR writes
main method
operations
OS command line
PL/SQL commit-time optimization
ROLLBACK
scarce system resources
System Change Number (SCN)
TKPROF utility
trace directory
Composite partition
Concurrency control mechanisms
access issues
context switching
database transactions
implementation
locking model
multiversioning
SeeMultiversioning model
nonblocking approach
page-level locking
resource scheduling program
SCHEDULES table
TX transaction locks
Container database (CDB)
Control files
D
Database administrator (DBA)
Database independence
ANSI method
approaches
concurrent request
deadlock
entity relation diagram (ERD)
features/functions
IDENTITY attribute
initial features
inline views
layered programming
nonblocking
NULL comparisons
openness
outcomes
scalar subqueries
sequence generation
serializable transaction
session’s transaction
solving problems
SQL99 standards
SQL queries
stored procedures
theoretical advantage
UPDATE/SELECT queries
Windows/UNIX/Linux
Database Resident Connection Pooling (DRCP)
benefits
server process pooling
Database Resource Manager Process (DBRM)
Database tables
blockchain tables
blockchain technology
clustered index
cluster objects
definition
external tables
general information
hash clustered tables
hash clusters
heap-organized table
index-organized tables
nested tables
object tables
object type
sorted hash clustered tables
sorted hash clusters
temporary tables
terminology
types
Data definition language (DDL)
atomicity
extent trimming
allocation depiction
UNIFORM vs. AUTOALLOCATEs extents
AUTOALLOCATE_TEST tablespace
big_table.log file
CREATE TABLE AS SELECT
external table definition
locally managed tablespace (LMT)
tablespaces
UNIFORM_TEST
USER_SEGMENTS
locking
ALTER TABLE T
CREATE/ALTER
CREATE VIEW command
DBA_DDL_LOCKS view
direct load (DL) locks
ONLINE keyword
operation
store procedure
types
parallelization
commands
CREATE TABLE AS SELECT statement
direct path
extent trimming
USER_INFO table
Datafiles
file system mechanisms
ASM design
blocks
clustered file system
extents
OS file system
segments
storage hierarchy
tablespace
OMF naming convention
pluggable databases
single instance container database
SYSTEM datafiles
Data loading/unloading
bulk data loading tools
data pump format
external tables
approaches
DEFAULT DIRECTORY clause
demo1.bad file
demo1.log file
error message
EXTERNAL_TABLE parameter
features
INSERT statement
load different files
modification
multiuser issue
parallel processing
PREPROCESSOR clause
project referenced column
SQLLDR control files
SQL*Plus
tasks
tmp directory
flat file
AUTHID CURRENT_USER
control file
CONTROL_FILES parameter
raw data (.dat) file
datafile
DESCRIBE table
NLS_DATE_FORMAT
PL/SQL utility
SQL*Plus command line
UTL_FILE
SQLLDR
SeeSQLLDR
techniques
Data manipulation language (DML)
classes
TM locks
transaction (TX) locks
stored procedure
TRACE file
Datatypes
BFILE
binary data
binary data (RAW types)
BINARY_FLOAT/BINARY_DOUBLE
BLOB
CHAR
character/binary string types
character sets
NLS controls
CHAR/VARCHAR2/NVARCHAR2
character string
bytes/character
CHAR/NCHAR types
CHAR, VARCHAR2, NCHAR, and NVARCHAR2
CHAR type
CHAR_COLUMN
Hello World
“N” Variant
string types
variable-length strings
CLOB
DATE
DATE, TIMESTAMP, and INTERVAL
adding/subtracting time
ADD_MONTHS function
DATE type
definition
differences
formats
INTERVAL type
MONTHS_BETWEEN function
TIMESTAMP
extended types
container database
LOB segment details
MAX_STRING_SIZE
nonextended column
single instance database
USER_LOBS
USER_OBJECTS
HEXTORAW function
INTERVAL DAY TO SECOND/YEAR TO MONTH
JSON
JSON format
LONG types
ALL_VIEWS dictionary view
AUTHID CURRENT_USER
coping types
DBMS_SQL.COLUMN_VALUE_LONG
key points
restriction (LONG RAW types)
manual states
SUBSTR_OF
WHERE clause operations
LONG RAW
NCHAR type
NCLOB
number types
approximate numbers
BINARY_FLOAT/BINARY_DOUBLE types
floating-point number
non-native types
NUMBER type
performance implications
storing numbers
VSIZE function
overview
RAW/NUMBER
RAWTOHEX function
ROWID
ROWID/UROWID types
TIMESTAMP
TIME ZONE
UROWID
VARCHAR2
Data warehouse/decision support system
Data warehousing technique
Database block writer (DBWn)
Deadlocks
COL_CNT
commit/roll back
DEPT table
foreign key
problematic cases
sessions
short-term occurrence
source code
table modification
trace file
unindexed foreign key
Dedicated server connections
architecture
features
one-to-one mapping
Deferrable constraints
CASCADE UPDATE
CHILD
COMMIT statement
IMMEDIATE mode
NOT NULL
NULLs
optimizer index
source code
UNIQUE/PRIMARY KEY constraint
UPDATE command
Diagnosability Process (DIAG)
Distributed transactions
Data Pump master (DMnn)
Do-It-Yourself (DIY) parallelism
DBA_PARALLEL_EXECUTE_CHUNKS
DBMS_JOB
DBMS_PARALLEL_EXECUTE
JOB_QUEUE_PROCESSES
NTILE built-in analytic function
PL/SQL block
PROCESS BIG TABLE
ROWID ranges
SERIAL procedure
task removing
E
Edition-based redefinition (EBR)
Enterprise JavaBeans (EJBs)
Entity Relation Diagram (ERD)
Event Monitor Processes (EMNC)
F
Fast Recovery Area (FRA)
File types
alert log
data pump
backup/recovery operations
change tracking
control files
database/instance
datafiles
data pump/flat process
flashback logs
flat files
parameter files
SeeParameter files
password
redo log
SPFILEs
SeeServer Parameter Files (SPFILEs)
temporary datafiles (temp files)
trace files
Fine-grained access control (FGAC)
Flashback data archiver process (FBDA)
Flashback logs files
Flat files
CSV files
definition
HTML file
JSON file
SQLLDR/external tables
Focused background processes
architecture design
ARCn process
checkpoint
database instance
database block writer (DBWn)
DIAG process monitors
flashback data archiver process
general task execution
init.ora parameters
LGWR process
LMON process
LREG process
naming convention
nonnegotiable function
PMON
RAC goals
RECO process
resource manager
single instance/RAC instances
SMON system
source code
UNIX/Linux system
Function-based indexes
case-insensitive index
CREATE INDEX statement
DETERMINISTIC
key points
MY_SOUNDEX function
rows index
SCOTT schema
selective uniqueness implementation
SUBSTR
TEMPORARY column
TO_DATE function
unindexed vs. indexed
UPPER value
UPPER_ENAME
virtual column
G
General task execution process (GEN0)
Globally unique identifier (GUID)
Global temporary tables (redo)
generalizations
INSERT/UPDATE/DELETE
PERM/TEMP tables
standby database
temporary/permanent tables
TEMP_UNDO_ENABLED parameter
Global indexes
asynchronous
data integrity
data warehouses
DELETE and INSERT operations
fast access
maintenance considerations
MAXVALUE
nonprefixed index
OLTP system
PARTITIONED_IDX_LOCAL index
partition operation
sliding window
TIMESTAMP column
UPDATE GLOBAL INDEXES clause
H
Hash clustered tables
ALL_OBJECTS
characteristics
cluster key index
conventional index
CPU utilization
CREATE CLUSTER statement
graphical representation
HASHED implementation
HASHKEYS option
HEAP/HASHED
index clusters
key points
one-to-one mapping
PL/SQL code
simulations
SINGLE TABLE
single table hash cluster
SQL_TRACE
Hash partitioning
divide and conquer
HASH_KEY_COLUMN
histogram data
insert
partition-extended table
partition position (PNAME)
table creation
working process
Heap-organized table
COMPRESS/NOCOMPRESS
CREATE TABLE statement
DBMS_METADATA
PCTFREE/INITRANS
retrieve data
space/disk/memory
High-water mark (HWM)
HyperText Markup Language (HTML)
I
Index clustered tables
cluster key index
conventional tables
CREATE TABLE statement
database blocks
DBMS_ROWID package
DEPT table
EMP records
graphical representation
normal storage parameters
object-related data
root container
SIZE parameter
TABLESPACE/PCTFREE
Indexes
partitioning
global indexes
local/global index
local indexes
methods
partial indexes
Indexing
application domain indexes
bitmap indexes
black box approach
B*Tree
SeeB*Tree indexes
case studies
automatic indexing
character column
DBMS_XPLAN package
discriminating elements
FULL SCANNING
INDEXED_COLUMN
INDEX UNIQUE SCAN
optimizer usage
SELECT COUNT(*) FROM T query
source code
space reusing process
threshold
TRUNC(DATE_COL)
commonsense approach
descending indexes
extended columns
creation
function-based solution
options
STANDARD_HASH function
virtual column solution
WHERE clause
foreign keys
function-based indexes
index-organized tables
INSERT statements
invisible
modifications
multiple (column) indexes
null entries
reactive tuning
reverse key
statistics
types
view working process
Index-organized tables (IOTs)
ANALYZE command
AUTOTRACE
benefits
BETWEEN queries
blocks
COMPRESS
conventional heap table
DBMS_METADATA
definition
EMP table
HEAP_ADDRESSES/IOT_ADDRESSES tables
HOME/PREV/SCHOOL
INCLUDING clause
KEYWORDS table
logical rowids
NOCOMPRESS option
OPT_CMPR_COUNT
OPT_CMPR_PCTSAVE
ORCL record
OVERFLOW and INCLUDING
overflow segment
PCTTHRESHOLD
PCTUSED clause
PL/SQL block
TABLE ACCESS
table creation
WORD/WORD/POSITION columns
Internal locks and latches
Interprocess communication (IPC)
INTERVAL type
DAY TO SECOND
definition
EXTRACT built-in function
LOB
SeeLarge objects (LOB)
NUMTODSINTERVAL
NUMTOYMINTERVAL function
YEAR TO MONTH
Interval and reference partitioning
Interval partitioning
AUDIT_TRAIL rows
definition
HIGH_VALUE
INTERVAL partition
MAXVALUE partition
NUMTOYMINTERVAL specification
range partitioning
recursive transaction
traditional method
USERS tablespace
J, K
JavaScript Object Notation (JSON)
flat files
Java Server Pages (JSPs)
Java virtual machine (JVM)
L
Large objects (LOB)
BasicFiles
BFILE type
components
CHUNK clause
IN ROW clause
internal types
LOBINDEX-LOBSEGMENT
primary key constraint
RETENTION clause
BasicFiles
CREATE TABLE statement
LOBSEGMENT
read consistency
SecureFiles
STORAGE clause
SecureFiles
TABLESPACE
types
Latches
atomic instructions
enqueues
expensive operation
in-memory data structure
lightweight serialization devices
shared resource
hard-coded variable (bind variable)
multiuser environment
performance/scalability comparison
string concatenation (bind variables)
testing process
sophisticated serialization device
spinning
Lock (LCK0) process
Log writer (LGWR)
redo/undo
Lightweight Directory Access Protocol (LDAP)
List partitioning
Lock manager daemon (LMD0) process
Lock monitor (LMON) process
Lock manager server (LMSn) process
Local indexes
eliminate partitions
DBMS_XPLAN.DISPLAY
LOCAL_NONPREFIXED
LOCAL_PREFIXED
PSTART/PSTOP column
source code
types
UNIQUE/PRIMARY KEY constraints
Locking mechanisms
benchmark
blocking
clustered table
components
DBMS_LOCK package
DDL operation
deadlocks
DML locks
escalation
general classes
issues
key features
latches
SeeLatches
LOCK TABLE statement
manual locking/user-defined locks
mutexes
optimistic method
page-level/concurrency
pessimistic method
row-level
serialization device
shared resource
single-user database
stateful/connected environment
Sybase SQL Server
twofold
updates
Listener Registration Process (LREG)
M
Memory management
learning application
modes
process global area
allocating memory
automatic management
control memory allocation
manual management
meaning
MEMORY_TARGET
PGA_AGGREGATE_TARGET
SGA
SeeSystem Global Area (SGA)
user global area
Memory Manager (MMAN)
Multiple (column) indexes
Multitenant container database (CDB)
Multiversioning
accounts table contents
flashback query
read-consistent/nonblocking reads
data warehousing technique
I/O hot tables
system change/system commit number (SCN)
technical aspects
timing/operations
transaction data
undo/rollback segment
transaction isolation
SeeTransaction isolation levels
write consistency
Mutexes
N
National Language Support (NLS)
ASCII data
character set conversion
controls
DUMP function
SQL DUMP function
heterogeneous
lossy conversion
unintentional character set conversion
Nested tables
CAST and MULTISET syntax
CREATE TABLE statement
DEPT_AND_EMP table
EMP and DEPT data
equivalent implementation
inserting and deleting table
NESTED_TABLE_GET_REFS
object-relational extensions
parent/child relational table
permanent storage mechanism
PL/SQL code
SELECT command
storage information
CREATE statement
CREATE TABLE command
DBMS_METADATA.GET_DDL
index structure
NESTED_TABLE_ID column
physical implementation
RETURN AS VALUE clause
unique constraint
syntax
NOLOGGING operation
ARCHIVELOG mode
CREATE TABLE command
index/table
key points
operations
SQL statements
O
Object tables
ADDRESS_TYPE
CREATE TABLE statement
data structures
defined types
DESCRIBE
object-relational components
OIDINDEX clause
OID ‘<big hex number>’ syntax
people.sql file
PERSON_TYPE
pseudo primary key
single object table
SYS_NC_OID$ column
Operating system (OS)
Optimistic locking method
checksum/hash function
approaches
database functionality
goal/concepts
ORA_HASH built-in function
client/server applications
concurrency controls
implementation
UPDATE
version column
working process
Oracle applications
app development
black box approach
broad statements
concurrency control
cursor sharing
database
database-centric approach
DBA-developer relationship
design and implementation level
developing database
independence
multiversioning
PDB1 source code
PL/SQL
scenario
SQL Server architecture
Windows vs. UNIX/Linux
P, Q
Parallel DML (PDML)
coordinating session/none commits
data warehousing environment
DBMS_XPLAN
features
independent transaction information
INSERT, UPDATE, DELETE, and MERGE
parallel operations
pseudo-distributed implementation
UPDATE statement
Parallel execution
definition
goals
PQ
SeeParallel Query (PQ) slaves
procedural parallelism
DIY procedure
pipelined functions
PROCESS_DATA procedure
SESSION_ID
types
UPDATE/INSERT
V$MYSTAT
processing analogy
one-page summary
ten-chapter report fast
resources
Parallel query coordinator (Pnnn)
Parallel Query (PQ) slaves
ALTER TABLE command
BIG_TABLE
COUNT(STATUS) values
CPU machine
execution servers
parallel DDL
parallel DML (PDML)
PARALLEL_MIN_SERVERS initialization parameter
Parallel Statement Queuing (PSQ)
physical devices
pluggable database
query coordinator SID (QCSID)
SID session
Parameter files
backup and recovery tool
CONTROL_FILES parameter
init.ora file
legacy init.ora file
SCOTT schema
SHOW PARAMETER command
tnsnames.ora file
Partitioning
administrative burden
aggregate index
ALTER TABLE MOVE statements
massive transactions
meaning
MOVE operation
sliding windows
tablespaces
temporary resources
benefits
decreasing contention
divide/conquer logic
ease maintenance
cascade truncate
exchange
features
maintenance operation
ON DELETE CASCADE clause
TRUNCATE ... CASCADE
utility function
enhanced statement performance
data warehouse
OLTP systems
parallel DML (PDML)
query performance
SELECT, INSERT, UPDATE, DELETE, MERGE
increased availability
indexes
ORDER BY statement
query performance
segment space compression
tables and indexes
table schemes
composite partition
hash table
interval partition
interval reference partition
list partition
methods
range table
reference partition
row movement
time-based data
virtual column partition
Password files
Pessimistic locking method
Pluggable database (PDB)
Process monitor (PMON)
Preprocessing
cases
file system
PREPROCESSOR directive
reading/filtering compressed files
run_df.bsh script
trimming characters
Private temporary tables (redo)
Procedure-level atomicity
different block
PL/SQL stored procedure
RAISE_APPLICATION_ERROR
stored procedure
WHEN OTHERS exception handler
Processes
background
classes
focused processes
meaning
source code
utility processes
broad classes
server
SeeServer processes
slave system
Process (Program) Global Area (PGA)
allocating memory
gen_load.sql file
initialization
LAG() function
metrics
observations
PGA_AGGREGATE_TARGET setting
pivot feature
SQL*Plus script
stats.sql file
table creation
automatic management
control memory allocation
CHAR array
dedicated server
PGA_AGGREGATE_TARGET
server code
utilization
manual management
memory management
MEMORY_TARGET
PGA_AGGREGATE_TARGET
PL/SQL tables
process-specific piece
SORT_AREA_SIZE
Process spawner (PSP0) process
R
Range partitioning
error message
insert option
MAXVALUE clause
RANGE_KEY_COLUMN
SELECT statements
Range partitioning table
ReBALance (RBAL) process
Read consistency
data warehousing technique
I/Os tables
nonblocking reads
SERIALIZABLE session
Real Application Clusters (RAC)
instance/database
multitenant database
single-tenant database
Recovery Writer (RVWR)
Redo log files
ARCHIVELOG/NOARCHIVELOG mode
checkpointing
DROP TABLE statement
instance/media failure
online log file
peak processing
recovery purposes
Redo/undo
archiver (ARCn) process
AUTOTRACE
block cleanout
COMMIT
SeeCommit/rollback processing
DBWn processes
database writer (DBWR)
DELETE
features
flashback technology
GET_STAT_VAL function
index statement
INSERT
buffer cache fills
log buffer flush
scenario
system crashes
log writer (LGWR)
LGWR background process
log buffer memory area
log contention
causes
cooked file system
LGWR and ARCn
log file sync events
log flow
optimal log configuration
RAID-5
log files
log generation
index/table
meaning
NOLOGGING mode
SQL (NOLOGGING clause)
warning messages (alert.log)
NOARCHIVELOG mode database
online/archived
RAC configurations
serialization
temporary tables
features
global tables
private tables
transacting data and writing redo
undo
SeeUndo
UPDATE
application rolls
log file representation
system crashes
working process
Reference partitioning, ORDERS table
Root container database
ROWID and UROWID types
Row movement schemes
S
SERIALIZABLE transaction
data modification
error message
events
OLTP benchmark
optimistic approach
SELECT ... FOR UPDATE
Server Parameter Files (SPFILEs)
ALTER SYSTEM SET command
conversion
CREATE PFILE...FROM SPFILE command
fixing corruption
initialization/parameter files
legacy parameter files
naming convention
pluggable databases
unsetting value
value setting
Server processes
connection modes
connection types
connection vs. sessions
AUTOTRACE command
CONNECT command
DBMS_LOCK command
definition
DISCONNECT command
DML operations
network
PADDR server
parameters
physical connection
pluggable database
PROGRAM information
SCOTT
shared server session
tnsnames.ora file
user account and query
dedicated server mode
shared server connections
workhorse
Shared server connection
architecture
artificial deadlock
benefits
concurrent users vs. transactions per second
database link concentration
features
many-to-one relationship
memory system
OLTP system
operating system processes/threads
Site identifier (SID)
Single Client Access Name (SCAN)
Single-tenant database architecture
Slave processes
I/O systems/devices
parallel query execution (Pnnn)
parameters control
types
Space management coordinator (SMCO)
System Monitor (SMON)
Sorted hash clusters
SQLLDR
access parameters
APPEND, TRUNCATE/REPLACE
CHAR(255)
command line overrides control file
control files
demo1.ctl
DEPT table
embedded newlines
character selection
FIX attribute
free-form data
round up
STR attribute
VAR attribute
express mode
CREATE ANY DIRECTORY
dept.dat file
dept.log file
direct path method
INSERT statement
SQL table
table creation
temporary table/directory object
external tables
key function
large objects (LOBs)
complex secondary datafiles
DBMS_LOB package
DIRECTORY object
end of file (EOF)
error message
inline function
LoadCLOBFromFile
loading data line
LONG/LONG RAW field
object columns
PL/SQL procedure
secondary datafiles (SDFs)
loading data
comma-separated values (CSV) format
dates
delimited data
embedded newlines
ENTIRE_LINE columns
FIELDS TERMINATED BY clause
FILLER keyword
functions (database sequences)
load fixed-width positional data
log file
POSITION keyword
tab-delimited data
TERMINATED BY WHITESPACE clause
operation modes
Oracle Call Interface (OCI)
ORGANIZATION EXTERNAL clause
REUSE STORAGE option
round-off
stored procedure
TRUNCATE option
TRUNCATE SQL command
Statement-level atomicity
Structured query language (SQL)
bind variables
approaches
AUTONOMOUS_TRANSACTION
CPU time
CREATE PROCEDURE
error-prone
evil developer/user
granted privileges
hard/soft parsing
injection
latches
less resource-intensive
malicious code
NLS_DATE_FORMAT
parsing unique statements
placeholder query
PL/SQL procedure
PWD_MGR
scalability
security via obscurity
SELECT privilege
serialization devices
small procedure
stored procedures
string concatenation
System Global Area (SGA)
unions
USER_PW table
NOLOGGING clause
ramification
single connection
System administrator (SA), information systems
System Global Area (SGA)
buffer cache
block management
DBA_OBJECTS view
DUMMY column
multiple block sizes
recycle pool
SGA_MAX_SIZE parameter
store cached blocks
database block buffer cache
warm segments blocks
fixed components
granules
in-memory features
Java pool
large pool
memory components
memory management
AMM recommendations
automatic memory management
recommendations
shared management
shared memory area
MEMORY_TARGET
parameters
redo buffer logs
SGASTAT
shared memory structure
shared pool
bind variables
program data
SHARED_POOL_SIZE
standard operating procedure
unique query
source code
streams pool
UNIX/Linux
various pools
System Global Area (SGA)
background processes
memory components
T
Transaction (TX) locks
AUTONOMOUS_TRANSACTION
character strings
data dictionary
datafile number
data modification
DEPT update
EMP and DEPT tables
INITRANS
key points
lock query
MAXTRANS
physical attribute parameters
stored procedure
V$LOCK
V$TRANSACTION
Temporary datafiles (temp files)
Temporary tables
CREATE TABLE AS SELECT (CTAS)
global tables
attributes/features
cost-based optimizer (CBO)
DELETE/TRUNCATE
differences
direct path operations
disadvantages
INLINE VIEW
ON COMMIT DELETE ROWS
palm sync application
PL/SQL
SCOTT.EMP table
session-based rows
session-level
shared statistics
statistics
tablespace
TEMP table
TEMPORARY and DURATION columns
transaction/session
USER_TAB_STATISTICS
private tables
COMMIT/ROLLBACK
definition
features
ON COMMIT clause
PRIVATE_TEMP_TABLE_PREFIX
session/transaction
types
Terminology
character large object (CLOB)
CREATE TABLE statement
high-water mark (HWM)
index partitions
INITRANS
LOGGING/NOLOGGING
managing space
PCTFREE parameter
coalescing free space
data block
definition
migrated row depiction
row migration
values
segment types
TIMESTAMP type
adding/subtracting time
components
definition
differences
DUMP function
LOCAL TIME ZONE
NUMTOYMINTERVAL
TIME ZONE type
Transport monitor process (TMON)
Trace files
command-line tool
debugging information
diagnostic/performance-related information
general types
instrumentation
internal error
locations
naming convention
service request (SR)
tagging files
types
Transaction isolation levels
ANSI isolation levels
definition
dirty/nonrepeatable read
phantom read
READ COMMITTED
READ COMMITTED/SERIALIZABLE
READ ONLY transactions
READ UNCOMMITTED
REPEATABLE READ
goals
lost update prevention
non-Oracle database
shared read lock
REPEATABLE READ and SERIALIZABLE levels
rollback segment
SERIALIZABLE transaction
Transactions
ACID characteristics
atomicity
autonomous
bad habits
COMMIT statement
control statements
distributed
durability
ALL_OBJECTS
cases
COMMIT statement
PL/SQL nondistributed block
WRITE extension
file system
integrity constraints
DEFERRABLE
IMMEDIATE mode
ROLLBACK TO SAVEPOINT command
ROLLBACK WORK
SAVEPOINT
SET TRANSACTION
transaction-level atomicity
Transaction (TX) locks
COMMIT/ROLLBACK
concurrency controls
ID representation
memory-based lock manager
V$ tables
Redo transport slave (TT00)
U
Undo segments
automatic management
block cleanout
components
definition
empty table creation
error message
high-water mark (HWM)
indexes
INSERT statement
INSERT/UPDATE/DELETE
I/O table
longest-running query
long-running process
manual management
misconception
modifications
ORA-01555 error message
PL/SQL procedure
ROLLBACK statement
sequences
space allocation
steps
tablespace
transaction address (TADDR)
UNDO_RETENTION setting
UPDATE option
working process
User global area (UGA)
SeeProcess (Program) Global Area (PGA)
Utility background processes
CTWR process
DMnn/worker processes
EMNC process
features
job queue process
manageability monitors
MMAN process
QMNC/Qnnn process
recovery writer
transport monitor process/redo transport slave
V
Virtual column partitioning
Virtual sch(K)eduler for Resource Manager (VKRM)
Virtual keeper of time (VKTM) process
W, X, Y, Z
Write consistency
consistent/current reads
nontransactional trigger
read
SeeRead consistency
restart option
TKPROF utility
UPDATE statement
WHERE clause
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.