https://DevOpsCloud.io -- Cloud Monk Losang Jinpa

For now these 2 articles are identical:

• Expert Oracle Database Architecture Index
• Oracle Database Topics - This one will be fleshed out and pair down.

Return to Oracle, Oracle database

navbar_oracledb

Index

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

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

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

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 wareho[[using 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

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 wareho[[using 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

Parallel DML (PDML)

coordinating session/none commits

data wareho[[using 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

Range partitioning

error message

insert option

MAXVALUE clause

RANGE_KEY_COLUMN

SELECT statements

Range partitioning table

ReBALance (RBAL) process

Read consistency

data wareho[[using 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

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

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)

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

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

See Read consistency

restart option

TKPROF utility

UPDATE statement

WHERE clause