Information center home
Welcome to the information center
Supported browsers for the information center
What's new in the information center
Learn to use the information center
Installable information center
Subscribing to information center updates
Navigating in the information center
Searching for information
Searching in the information center
Searching for messages and codes
Searching from external sources
Searching knowledge bases for known problems
Setting bookmarks and printing in the information center
Accessibility and keyboard shortcuts in the information center
Viewing information in different languages
How to read syntax diagrams
Dotted decimal syntax diagrams
Submitting feedback about information
Notices
Links to non-IBM Web sites
Data warehousing and analytics
Overview of InfoSphere Warehouse
Components of InfoSphere Warehouse
Installation architecture on multiple computers
What's new in InfoSphere Warehouse V9.5.x
What's new in installation
What's new in the SQL Warehousing Tool (SQW)
What's new in mining
What's new in workload management (WLM)
What's new in Cubing Services
Installing InfoSphere Warehouse
Installation architecture on multiple computers
Installation requirements
Requirements for the server components
Requirements for the client components
User authority requirements
Database for metadata storage
Before you install
Downloading the installation images
Installation disks
Installation directories
Running the installation program
Installing by using the installation wizards
Installing silently by using a response file
Password encryption in the response file
Installing component products individually
Uninstalling InfoSphere Warehouse
Configuring InfoSphere Warehouse
Configuring security for WebSphere Application Server and its applications
Configuring user access to the Administration Console
Setting up the system logging service
Setting up the notification service
Changing the connection settings to the metadata repository
Creating database connections
Database connections
Data server driver definitions
Creating system resources
Transforming data
Designing SQL warehousing applications
Work flow for building SQL warehousing applications
Setting up the SQL warehousing environment in the Design Studio
Creating a data warehousing project
Working with data warehousing projects
Creating and accessing physical data models
Importing proprietary physical data models
Portable formats for physical data models
Reverse engineering a physical data model
Connecting to databases in the Design Studio
Setting preferences for data warehousing
Changing the locale of the Design Studio
Changing the locale of the Windows system
Designing data flows
Data flows
The data flow editor: a visual tour
Data flow operators
DB2 objects in data flows
Creating a data flow
Working modes for data flows
SQL execution database
Placing data flow operators in the canvas
Managing space in the canvas
Connecting data flow operators
Column-level connections in data flows
Virtual tables
Editing virtual tables
Defining data flow operators
Source operators
Defining a data set import operator
Data set import operators
Data set import–operator properties
Defining an SQL query source operator
SQL query source operators
SQL query source–operator properties
Defining a table source operator
Table source operators
Table source–operator properties
Transform operators
Defining a data station operator
Data station operators
Data station storage types
Data station operator properties
Defining a DB2 table function operator
DB2 table function operators
DB2 table function-operator properties
Defining a distinct operator
Distinct operators
Distinct–operator properties
Defining a fact key replace operator
Fact key replace operators
Fact key replace–operator properties
Defining a group by operator
Group by operators
Group by–operator properties
Defining a key lookup operator
Key lookup operators
Key lookup–operator properties
Defining an order by operator
Order by operators
Order by–operator properties
Defining a pivot operator
Pivot operators
Pivot–operator properties
Defining a select list operator
Select list operators
Select list–operator properties
Defining a sequence operator
Sequence operators
Sequence–operator properties
Defining a splitter operator
Splitter operators
Splitter–operator properties
Defining a table join operator
Table join operators
Table join–operator properties
Defining a union operator
Union operators
Union–operator properties
Defining an unpivot operator
Unpivot operators
Unpivot–operator properties
Defining a where condition operator
Where condition operators
Where condition–operator properties
Target operators
Defining a cross loader operator
Cross loader operators
Cross loader–operator properties
Example–Defining data set import, cross loader, and data set export operators in a data flow
Defining a custom SQL operator in a data flow
Custom SQL operators
Defining a data set export operator
Data set export operators
Data set export–operator properties
Defining a table target operator
Table target operators
Table target–operator properties
Filtering and sorting columns
Propagating changes in data flows
Debugging data flows
Creating a suitable table for data flow operator results
Validating, testing, and running data flows
Creating and using run profiles
Creating a machine resource profile
Resource profiles
Viewing sample content within data flows
Saving flows as image files
Creating a subflow
Subflows
Adding a subflow to a data flow
Creating a nested subflow
Defining the schema of the virtual table in the subflow input
Example–Creating a subflow
SQL Expression Builder
Example: Using a variable to create a data flow condition
Designing control flows
Control flow components
Control flow editor
A visual tour of the control flow editor
How a control flow behaves in the editor
Control flow operators
Operators and ports
Connections
Creating a control flow
Placing operators in the canvas
Connecting operators in the control flow
Defining control flow operators
Properties for control flow operators
Defining a command operator
Command operators
Command–operator properties
Defining a custom SQL operator in a control flow
Data flow operators
Data and mining flow–operator properties
DataStage job sequence operator
DataStage–operator properties
DataStage parallel job
DataStage parallel job–operator properties
Defining a DB2 command operator
DB2 command operators
DB2 command–operator properties
Defining a DB2 online utility operator
DB2 online utility operators
DB2 online utility–operator properties
E-mail operators
E-mail–operator properties
End operators
End–operator properties
Defining an exchange operator
Exchange operators
Exchange–operator properties
Example–Defining an exchange operator in a control flow
Example–Defining a fail operator in a control flow
Fail operators
Defining a file wait operator
File wait operators
File wait–operator properties
Defining a file write operator
File write operators
File write–operator properties
Example–Defining a file write operator
Defining an iterator operator
Iterator operators
Iterator–operator properties
Example–Defining a break operator in a control flow
Break operators
Example–Defining a continue operator in a control flow
Continue operators
End iterator operators
End iterator–operator properties
Defining a job control language operator
Job control language operators
Job control language–operator properties
Example–Defining a JCL operator
Defining a load operator
Load operators
Load operator properties
Example–Defining a load operator
Prerequisites for running the example
Creating the control flow
Defining a parallel container operator
Parallel activities in a control flow
Defining a period row generator
Example–Generating a period table
Period row generator operators
Period row generator–operator properties
Period row generator–predefined values
Defining a reorg operator
Reorg operators
Reorg–operator properties
Defining a runstats operator
Runstats operators
Runstats–operator properties
Example–Defining a runstats operator and a reorg operator in a control flow
Defining a secure command operator
Secure command operators
Secure command–operator properties
Setting up public key authentication over SSH
Defining a secure FTP operator
Secure FTP operators
Secure FTP–operator properties
Start operator
Start–operator properties
Defining a stored procedure operator
Prerequisites for creating a stored procedure
Stored procedure operators
Stored procedure–operator properties
Defining a table partition operator
Table partition operators
Table partition–operator properties
Example–Defining a table partition operator in a control flow
Defining an unload operator
Unload operators
Unload–operator properties
Example–Defining an unload operator in a control flow
Defining a variable assignment operator
Example–Defining a variable assignment operator
Variable assignment operators
Variable assignment–operator properties
Defining a variable comparison operator
Example–Defining a variable comparison operator with a stored procedure operator
Variable comparison operators
Variable comparison operator properties
Creating a subprocess
Subprocesses
Example–Creating a subprocess
Adding a subprocess to a control flow
Example–Creating a nested subprocess
Example–Defining input and output variables in subprocesses
Saving control flows
Validating, testing, and running control flows
Debugging control flows
Example–Debugging a control flow
Using variables in data flows and control flows
Variables overview
Input and output variables
Creating a variable group
Creating a variable
Variable properties
Removing a variable
Selecting a variable for use in an operator field
Example–Defining reserved variables in a control flow
Example–Defining input variables in a data flow
Annotating flows with notes
Customizing the appearance of notes in Design Studio flows
Preparing applications for deployment
Creating an application profile
Application profiles
Miscellaneous files in a data warehousing project
Modifying an application profile
Administering control flows
Control flows
Control flow instances
Instance states
Control flows and activities
Activity attributes
Variables in control flows
Deploying control flows
First deployment of an application
Delta deployment of an application
Monitoring and troubleshooting control flows
Viewing log files
OLAP and cubing
OLAP and cubing overview
Cubing Services overview
Cubing Services architecture
Cubing Services core components
Design Studio
Administration Console
InfoSphere Warehouse metadata database
Cubing Services Cube Server
Cubing Services Optimization Advisor
Cubing Services performance and scalability
Performance overview
Scalability
Cubing Services security
Role-based security in Cubing Services
Managing Cubing Services roles
Creating and editing a role
Assigning users to a role
Viewing assigned users and privileges
Removing users from a role
Deleting a role
Hierarchy security in Cubing Services
Configuring cube security
Configuring cube server security
Logging overview
Cubing and OLAP metadata overview
Dimensional schema design
Dimensional schemas
Star and snowflake schemas
Star schemas
Snowflake schemas
Fact and dimension tables
Primary and foreign keys
Many-to-one relationships
About cube models
Facts objects
Dimensions
Hierarchies
Balanced hierarchy
Unbalanced hierarchy
Ragged hierarchy
Network hierarchy
Levels
Joins
Measures
Attributes
About cubes
Cube facts objects
Cube dimensions
Cube hierarchies
Cube levels
About OLAP metadata objects
Metadata objects that map to relational tables
Example of a cube model that maps to relational tables
Common metadata object properties
Metadata object rules
Attribute rules
Cube rules
Cube dimension rules
Cube facts objects rules
Cube hierarchy rules
Cube level rules
Cube model rules
Dimension rules
Facts objects rules
Hierarchy rules
Join rules
Level rules
Measure rules
Member rule
OLAP object rules
Cubing Services life cycle and work flow
Getting started with Cubing Services
Setting up the DWESAMP sample data
Creating and starting a sample cubeserver1 cube server
Creating a sample Price Analysis cube
Creating an administration console data source
Importing the sample OLAP cube model in the administration console
Adding the Price Analysis cube to the cube server and optimizing the cube
Querying a sample cube by using the command line interface
Getting the updated Cubing Services tutorial
Troubleshooting the Cubing Services setup
Setting up your environment for OLAP
Setting preferences for a metadata repository connection
Setting preferences for Cubing Services logging and tracing in the Design Studio
Creating a project in the Design Studio for OLAP
Creating a physical data model for OLAP
Designing cube models and cubes
Designing cube models
Creating cube models using the Design Studio
Creating a cube model using the Quick Start wizard
Validating a cube model
Creating a complete cube model
Creating a cube model
Creating a facts object
Creating a fact-to-fact join
Creating a measure from columns
Creating a calculated measure
Specifying SQL expressions for a calculated measure or calculated attribute
Specifying a measure's aggregation script
Creating an MDX calculated measure
Creating an MDX calculated member
Creating a dimension
Creating facts-to-dimension joins
Creating a dimension-to-dimension join
Creating a hierarchy for a dimension
Creating levels for hierarchies
Creating an attribute
Creating an attribute in a dimension
Modifying attribute properties
Designing cubes
Creating a cube
Managing metadata
Modifying the properties of OLAP metadata
Dropping a metadata object from a database
Deleting an object from a physical data model
Importing and exporting OLAP objects
Importing OLAP metadata by using the Design Studio
Exporting OLAP metadata by using the Design Studio
Optimizing OLAP cube models
Summary tables
Summary tables with functional dependencies and constraints
Overview of the optimization process
Constraint definitions for optimization
Metadata design considerations for optimization
Optimization slices for cubes
Scenarios for candidate optimization slices
Example of an SQL script to create the summary tables
Summary table maintenance
Optimizing a cube model
Optimizing a cube model using the Design Studio
Parameters for the Optimization Advisor
Tuning query and MQT performance
Deploying OLAP objects using the Design Studio
Managing OLAP and cubing administration tasks
Administration Console topologies
Administration architecture for Cubing Services
Cubing Services administration workflow
Managing cube servers
Creating and maintaining cube servers
Creating a cube server
Data and member caching
Managing cubes
Adding cubes to a cube server in a single step
Changing the runtime configuration properties of a cube
Removing cubes from a cube server in a single step
Starting, stopping, or restarting a cube
Rebuilding the member cache for a cube
Emptying the data cache for a cube
Configuring log services for the cube server
Starting, stopping, or restarting a cube server
Deleting a cube server
Configuring the XMLA provider
Specifying port number for XMLA
Starting, stopping, or querying the status of an XMLA provider
Managing OLAP metadata
Importing OLAP metadata
Managing imported metadata
Adding a cube to multiple cube servers in a single step
Removing a cube from multiple cube servers
Deleting multiple cubes from a cube model
Deleting a cube model
Mapping metadata to a database
Optimizing a cube model
IBM Cubing Services Client ODBO provider
Installing the IBM Cubing Services Client ODBO provider
Connecting to a cube server by using the IBM Cubing Services Client ODBO provider
Retrieving cube data to present in Excel
Cubing Services ODBO provider security
Cubing Services ODBO provider log
Troubleshooting: Unable to connect to cube server
Running the Cubing Services Cube Server as a standalone process
Managing the Windows service
Managing the UNIX daemon
MDX language reference
How to read syntax diagrams
MDX data types
MDX expression syntax
MDX operators
MDX statements
SELECT statement (MDX)
DRILLTHROUGH statement (MDX)
Session-scoped statements
CREATE SET statement (MDX)
CREATE MEMBER statement (MDX)
DROP SET statement (MDX)
DROP MEMBER statement (MDX)
MDX functions
Abs function (MDX)
AddCalculatedMembers function (MDX)
Aggregate function (MDX)
AllMembers dot function (MDX)
Ancestor function (MDX)
Ancestors function (MDX)
Ascendants function (MDX)
Avg function (MDX)
BottomCount function (MDX)
BottomPercent function (MDX)
BottomSum function (MDX)
Caption dot function (MDX)
Children dot function (MDX)
ClosingPeriod function (MDX)
CoalesceEmpty function (MDX)
Count function (MDX)
Count dot function (MDX)
Cousin function (MDX)
Crossjoin function (MDX)
CurrentMember dot function (MDX)
DataMember dot function (MDX)
DefaultMember dot function (MDX)
Descendants function (MDX)
Description dot function (MDX)
Dimension dot function (MDX)
Distinct function (MDX)
Except function (MDX)
Extract function (MDX)
Filter function (MDX)
FirstChild dot function (MDX)
FirstSibling dot function (MDX)
Generate function (MDX)
Head function (MDX)
Hierarchise function (MDX)
Hierarchize function (MDX)
Hierarchy dot function (MDX)
IIf function (MDX)
InStr function (MDX)
Int function (MDX)
Intersect function (MDX)
IsAncestor function (MDX)
IsEmpty function (MDX)
Item dot function (MDX)
Lag dot function (MDX)
LastChild dot function (MDX)
LastPeriods function (MDX)
LastSibling dot function (MDX)
LCase function (MDX)
Lead dot function (MDX)
Left function (MDX)
Len function (MDX)
Level dot function (MDX)
Levels dot function (MDX)
Max function (MDX)
Median function (MDX)
Members dot function (MDX)
Mid function (MDX)
Min function (MDX)
MTD function (MDX)
Name dot function (MDX)
NameToSet function (MDX)
NextMember dot function (MDX)
NonEmptyCrossjoin function (MDX)
OpeningPeriod function (MDX)
Order function (MDX)
Ordinal dot function (MDX)
ParallelPeriod function (MDX)
Parent dot function (MDX)
PatternMatches function (MDX)
PeriodsToDate function (MDX)
Power function (MDX)
PrevMember dot function (MDX)
Properties dot function (MDX)
QTD function (MDX)
Rank function (MDX)
Right function (MDX)
Round function (MDX)
RoundDown function (MDX)
RoundUp function (MDX)
Siblings dot function (MDX)
Sqr function (MDX)
Sqrt function (MDX)
StdDev function (MDX)
StdDevP function (MDX)
Stdev function (MDX)
StdevP function (MDX)
StripCalculatedMembers function (MDX)
Subset function (MDX)
Sum function (MDX)
Tail function (MDX)
TopCount function (MDX)
TopPercent function (MDX)
TopSum function (MDX)
UCase function (MDX)
Union function (MDX)
UniqueName dot function (MDX)
Value dot function (MDX)
Var function (MDX)
Variance function (MDX)
VarianceP function (MDX)
VarP function (MDX)
WTD function (MDX)
YTD function (MDX)
Reference
Installation reference
Shortcut keys
Installation log files
OLAP and cubing interface reference for the Design Studio
OLAP wizards and windows
Quick Start wizard
Import OLAP Objects wizard
Export Cubing Services Objects wizard
Deploy OLAP Objects wizard
OLAP Aggregation Builder
OLAP SQL Expression Builder
OLAP Optimization Advisor wizard
Optimization Slices window
Attribute Pair window
Function Parameters window
OLAP properties views
Cube model properties
Facts objects properties
Dimension properties
Hierarchy properties
Level properties
Join properties
Measure properties
MDX calculated measure properties
Attribute properties
Cube properties
Cube facts object properties
Cube dimension properties
Cube hierarchy properties
Cube level properties
DB2 Version 9.1 for z/OS
DB2 overview
Introduction to DB2 for z/OS
An overview of DB2 and information management
Scenarios for using DB2
Availability and scalability for large businesses
Critical business information for decision makers
Data distribution and Web access
The IBM Information Agenda
DB2 data servers and environments
Enterprise servers
DB2 Database distributed editions
DB2 on smaller-scale servers
Personal, mobile, and pervasive environments
Multiple transaction and application environments
DB2 and network communication
Clients supported by DB2 data servers
Sources of data
Information management tools
Application development tools
Middleware components
IBM Data Studio
IBM Rational Portfolio Manager
DB2 Connect
WebSphere Application Server
WebSphere Studio
WebSphere Host Integration
Federated database support through WebSphere Information Integrator
Data replication through InfoSphere Replication Server
WebSphere DataStage
WebSphere QualityStage
Client application programming interfaces
Open standards
DB2 concepts
Structured query language
Overview of pureXML
DB2 data structures
DB2 tables
DB2 indexes
DB2 keys
DB2 views
DB2 schemas and schema qualifiers
DB2 table spaces
DB2 index spaces
DB2 storage groups
DB2 databases
DB2 system objects
DB2 catalog
DB2 directory
Active and archive logs
Bootstrap data set
Buffer pools
Data definition control support database
Resource limit facility database
Work file database
Support for high availability
Enforcement of business rules
Entity integrity, referential integrity, and referential constraints
Check constraints
Triggers
Application processes and transactions
Packages and application plans
Routines
Functions
Procedures
Distributed data
Remote servers
Connectivity
DB2 for z/OS architecture
z/Architecture and the z/OS operating system
DB2 in the z/OS environment
DB2 internal resource lock manager
DB2 and the z/OS Security Server
DB2 and DFSMS
DB2 attachment facilities
CICS attachment facility
IMS attachment facility
TSO attachment facility
Call attachment facility
Resource Recovery Services attachment facility
Distributed data facility
DB2 in a Parallel Sysplex environment
DB2 objects and their relationships
Logical database design using entity-relationship modeling
Data modeling
Entities for different types of relationships
One-to-one relationships
One-to-many and many-to-one relationships
Many-to-many relationships
Application of business rules to relationships
Attributes for entities
Naming conventions for attributes
Data types for attributes
Values for key attributes
Normalization to avoid redundancy
First normal form
Second normal form
Third normal form
Fourth normal form
Logical database design with Unified Modeling Language
Physical database design
Database design with denormalization
Customized data views
Database design with indexes
SQL: The language of DB2
Ways to access data
Ways to select data from columns
How a SELECT statement works
SQL functions and expressions
Concatenation of strings
Calculation of values in one or more columns
Calculation of aggregate values
Scalar functions
Nested functions
User-defined functions
CASE expressions
Ways to filter the number of returned rows
Null values
Equalities and inequalities
How to test for equality
How to test for inequalities
How to test for equality or inequality in a set of columns
How to test for a false condition
Similarities of character data
Multiple conditions
Ranges of values
Values in a list
Ways to order rows
Sort key
Ascending order
Descending order
Sort keys with multiple columns
Sort keys with expressions
Ways to summarize group values
Ways to merge lists of values
Ways to specify search conditions
Ways to join data from more than one table
Inner join
Left outer join
Right outer join
Full outer join
Subqueries
Ways to access DB2 data that is not in a table
Ways to modify data
Insert statements
Update statements
Merge statements
Delete statements
Truncate statements
Ways to execute SQL
Static SQL
Dynamic SQL
DB2 ODBC
DB2 access for Java: SQLJ and JDBC
Interactive SQL
Use of DB2 Query Management Facility for Workstation
DB2 sample tables
Activity table (DSN8910.ACT)
Department table (DSN8910.DEPT)
Employee table (DSN8910.EMP)
Employee photo and resume table (DSN8910.EMP_PHOTO_RESUME)
Project table (DSN8910.PROJ)
Project activity table (DSN8910.PROJACT)
Employee to project activity table (DSN8910.EMPPROJACT)
Unicode sample table (DSN8910.DEMO_UNICODE)
Relationships among the sample tables
Views on the sample tables
Storage of sample application tables
Storage group for sample application data
Databases for sample application data
Table spaces for sample application data
Application programming for DB2
Development of DB2 applications in integrated development environments
WebSphere Studio Application Developer
DB2 Development Add-In for Visual Studio .NET
Workstation application development tools
Programming languages and methods for developing application programs
Preparation process for an application program
Static SQL applications
Declaration of table and view definitions
Data access with host variables
Data access with host variable arrays
Data access with host structures
Row retrieval with a cursor
Ways to check the execution of SQL statements
Dynamic SQL applications
Types of dynamic SQL
Dynamic SQL programming concepts
Use of ODBC to execute dynamic SQL
Use of Java to execute static and dynamic SQL
SQLJ support
JDBC support
Use of an application program as a stored procedure
Languages used to create stored procedures
Stored procedure processing
Use of the SQL procedural language to create a stored procedure
Creating stored procedures with development tools
Setup of the stored procedure environment
Preparation of a stored procedure
How applications can call stored procedures
Implementation of your database design
Creation of tables
Types of tables
Creation of base tables
Creation of temporary tables
Creation of materialized query tables
Creation of a table with table-controlled partitioning
Definition of columns in a table
Column names
Data types
String data types
Numeric data types
Date, time, and timestamp data types
XML data type
Large object data types
ROWID data type
Distinct types
Encoding schemes for string data
How DB2 compares data types
Null and default values
Null values
Default values
Comparison of null values and default values
Use of check constraints to enforce validity of column values
Use of check constraints to insert rows into tables
Use of check constraints to update tables
Row design
Record lengths and pages
Designs that waste space
Creation of table spaces
Types of DB2 table spaces
Universal table spaces
Partition-by-growth table spaces
Range-partitioned universal table spaces
Table spaces that are exclusively segmented
Table spaces that are exclusively partitioned
EA-enabled table spaces and index spaces
Large object table spaces
XML table spaces
Simple table spaces
How DB2 implicitly creates a table space
How DB2 implicitly creates an XML table space
Storage structure for XML data
Assignment of table spaces to physical storage
Creation of indexes
Types of indexes
How indexes can help to avoid sorts
Index keys
General index attributes
Unique indexes
Nonunique indexes
Clustering indexes
Indexes that are padded or not padded
Index on expression
Compression of indexes
XML index attributes
Partitioned table index attributes
Partitioning indexes
Secondary indexes
Data-partitioned secondary indexes
Nonpartitioned secondary indexes
Example of data-partitioned and nonpartitioned secondary indexes
Creation of views
A view on a single table
A view that combines information from several tables
Inserts and updates of data through views
Creation of large objects
Creation of databases
Creation of relationships with referential constraints
How DB2 enforces referential constraints
Insert rules
Update rules
Delete rules
Construction of a referential structure
Tables in a referential structure
Creation of exception tables
Creation of triggers
Creation of user-defined functions
DB2 performance management
Initial steps for performance management
Performance objectives
Application design for performance
Origin of performance problems
Tools for performance analysis
Ways to move data efficiently through the system
The role of buffer pools in caching data
The effect of data compression on performance
How data organization can affect performance
Use of free space in data and index storage
Guidelines for data reorganization
Ways to improve performance for multiple users
Improved performance through use of locks
Improved performance through concurrency control
Ways to improve query performance
Tools that help you improve query performance
Query and application performance analysis
Using EXPLAIN to understand the access path
Management of DB2 operations
Tools that help you manage DB2
IBM Data Studio and Optimization Service Center
DB2 Administration Tool
DB2 Interactive
DB2 command line processor
Use of commands and utilities to control DB2 operations
DB2 commands
DB2 utilities
Management of data sets
Authorization and security mechanisms for data access
How authorization IDs control data access
How authorization IDs hold privileges and authorities
Ways to control access to DB2 subsystems
Local DB2 access
Remote DB2 access
Ways to control access to data
Ways to control access to DB2 objects through explicit privileges and authorities
Use of multilevel security to control access
Use of views to control access
Use of grant and revoke privileges to control access
Backup, recovery, and restart
Backup and recovery resources and tools
DB2 restart
Regular backups and data checks
Control of database changes and data consistency
Commit and rollback of transactions
Coordinated updates for consistency between servers
Events in the recovery process
Optimization of availability during backup and recovery
DB2 and the Web
Web application environment
Components of Web-based applications
Architectural characteristics of Web-based applications
Benefits of DB2 for z/OS as a server
Web-based applications and WebSphere Studio Application Developer
XML and DB2
Benefits of using XML with DB2 for z/OS
Ways to use XML with DB2 for z/OS
SOA, XML, and Web services
Distributed data access
Ways to implement distributed data in programs
Explicit CONNECT statements
Three-part names
Aliases
Comparison of three-part names and aliases
Ways that other tasks are affected by distributed data
Effects of distributed data on planning
Effects of distributed data on programming
Effects of distributed data on program preparation
How updates are coordinated across distributed systems
DB2 transaction manager support
Servers that support two-phase commit
Servers that do not support two-phase commit
Ways to reduce network traffic
Improvements in query efficiency
Reduction in the volume of messages
Block fetch
Rowset fetches and inserts
Optimization for large and small result sets
Performance improvements for dynamic SQL
Data sharing with your DB2 data
Advantages of DB2 data sharing
Improved availability of data
Scalable growth
Flexible configurations
Protected investments in people and skills
How DB2 protects data consistency in a data sharing environment
How updates are made in a data sharing environment
How DB2 writes changed data to disk in a data sharing environment
Ways that other tasks are affected by data sharing
Ways that availability is affected by data sharing
Index for introduction to DB2 for z/OS
DB2 Licensed Program Specifications
Planning for DB2
What's New?
Introduction
Leveraging your enterprise for information on demand
Seamless integration of XML data and relational data
Compatibility and leadership with SQL
SQL consistency improvements
SELECT FROM UPDATE or SELECT FROM DELETE function
INSTEAD OF triggers
BIGINT data type and function
BINARY data type and function
File reference variables
INTERSECT keyword in a fullselect
EXCEPT keyword in a subselect
Native support for SQL procedures
Nested compound statements in SQL procedures
Expanded support for not logging table spaces
OLAP specifications for RANK, DENSE_RANK, and ROW_NUMBER
COLLATION_KEY function
Capability to create an index on an expression
Automatic creation of a database, a table space, and all system-required objects
IBM Spatial Support for DB2 for z/OS
Leverage existing application programming skills
Enhancements to large object support
SQL enhancements for large objects
Utilities enhancements for large objects
Performance enhancements for large objects
SQL leadership: family firsts
TRUNCATE TABLE statement
DECFLOAT built-in data type
VARBINARY data type
Enhancements to optimistic concurrency control and update detection
MERGE and SELECT FROM MERGE statements
Tools that support your enterprise
Accessing your enterprise data on demand with DB2 QMF
Managing your enterprise with DB2 Tools
Availability
Online REORG with no BUILD2 phase
Faster replacement of one table with another
Universal table spaces
Better availability during REBUILD INDEX operations
Improved availability with column and index renaming capabilities
Modify EARLY code without an IPL
ALTER TABLESPACE and index logging improvements
Support for using SMS storage classes with DB2-defined data sets
DB2 support for extended address volumes (EAV)
Performance
Reduction in CPU processing time for utilities
SQL optimization improvements
Better data for the optimizer with histogram statistics
Improved optimization techniques
IBM Optimization Service Center for DB2 for z/OS
IBM DB2 Optimization Expert for z/OS
Indexing improvements
Improved performance for varying-length rows
Relief for sequential key insert
Improved logging performance
Improved data insert performance
Regulatory compliance
Roles and network trusted contexts
Improved auditing
Support for Secure Socket Layer protocol
More security options with INSTEAD OF triggers
Support for AES encryption
Index for What's New?
Planning for DB2 Version 9.1 for z/OS
Command changes
New commands
Changed commands
Changes to utilities
New utilities
Utility changes
Other utility changes
SQL statement changes
New SQL statements
Changed SQL statements
New functions
Reserved words
Other SQL language changes
Catalog changes
New catalog tables
Changed catalog tables
New and changed indexes
Performance monitoring and tuning changes
Performance changes
EXPLAIN table changes
Format of the Version 9.1 PLAN_TABLE
Descriptions of new and changed columns in PLAN_TABLE
Format of the Version 9.1 DSN_STATEMNT_TABLE
Descriptions of new and changed columns in DSN_STATEMNT_TABLE
Format of the DB2 Version 9.1 for z/OS DSN_FUNCTION_TABLE
Descriptions of new and changed columns in DSN_FUNCTION_TABLE
New statement cache table
New and changed IFCIDs
New IFCIDs
Changed IFCIDs
Installing and migrating DB2
Installation and migration
Introduction to installation, migration, and conversion
Installation and migration tools
Summary of SMP/E steps
Introduction to installation
Summary of installation steps
Introduction to migration and conversion
Planning for release incompatibilities
Summary of migration to conversion mode steps
Summary of fallback steps
Summary of remigration steps
Summary of conversion to enabling-new-function mode steps
Summary of conversion to new-function mode steps
Summary of reversion to conversion mode* steps
Summary of reversion to enabling-new-function mode* steps
Summary of conversion from conversion mode* to enabling-new-function mode steps
Summary of conversion from conversion mode* to new-function mode steps
Summary of conversion from enabling-new-function mode* to new-function mode steps
Preparing your system to install or migrate DB2
Fulfilling hardware and software requirements
Planning storage for DB2
DB2 subsystem storage requirements
DB2 catalog storage requirements
DB2 directory storage requirements
Active log data sets storage requirements
Bootstrap data sets storage requirements
Work file database storage requirements
Default database storage requirements
Temporary table space storage requirements
Calculating the size of the longest row in the declared temporary table
Identifying the columns in the declared temporary table
Determining the lengths of the columns in the declared temporary table
Calculating the length of the longest row in a declared temporary table
Example calculation for the length of the longest row in a declared temporary table
Dump data set size storage requirements
System databases storage requirements
Archive log data sets storage requirements
Profile tables storage requirements
Installation CLIST storage calculation
Virtual storage requirements for address spaces
DB2 distributed data facility address space (DSN1DIST) storage requirements
IRLM address space (IRLMPROC) storage requirements
DB2 system services address space (DSN1MSTR) storage requirements
DB2 database services address space (DSN1DBM1) storage requirements
Allied agent address space storage requirements
Administrative scheduler address space storage requirements
WLM-established stored procedures address spaces storage requirements
Shared memory storage requirements
Common service area storage requirements
Calculating the storage requirement for the common service area
Calculating the storage requirement for the extended common service area
Virtual storage requirements for storage pools and working storage
Calculating buffer pool size
Calculating sort pool size
Calculating sort pool storage in local storage
Calculating sort pool storage in buffer pool storage
Calculating RID pool size
Calculating EDM pool size
Calculating EDM pool space storage for plans and packages
Calculating EDM pool space for the prepared-statement cache
Calculating EDM pool space for the skeleton copies of packages and plans
Calculating EDM pool space for database descriptors
Calculating total EDM pool storage space
Calculating data set control block storage
Calculating working storage requirements
Calculating virtual storage below the 16-MB line
Calculating real storage requirements
Planning for performance of DB2
Changes to DB2 that might impact your migration to Version 9.1 conversion mode
Compatibility mode is now called conversion mode
Availability of new functions in conversion mode and new-function mode
Application and SQL release incompatibilities
Utility release incompatibilities
Command release incompatibilities
Storage release incompatibilities
Other release incompatibilities
Functions that are no longer supported
Functions that are deprecated
Preparing a data sharing group or distributed environment for migration
Migrating a data sharing group
Release coexistence
Release coexistence in a distributed environment
Release coexistence in a data sharing environment
IRLM service and release coexistence
Loading the DB2 libraries
What IBM sends you
DB2 utilities packaging
SMP/E jobs for DB2 utility products
The operation of DB2 utilities in a mixed-release data sharing environment
What you produce
SMP/E step 1: Copy and edit the SMP/E jobs
Copying the SMP/E jobs
Editing the SMP/E jobs
Creating job statements
Choosing link list options
Accessing the correct DB2 program library
Performance implications of installation libraries
Naming conventions for DB2 library names
Specifying SMP/E data set options
Sharing SMP/E data sets with IMS
Establishing SMP/E data sets for two releases
Specifying a new SMP/E prefix for IRLM
SMP/E step 2: Allocate the SMP/E CSI file and SMP/E control data sets: DSNTIJAA (optional)
SMP/E step 3: Allocate distribution and target libraries: DSNALLOC
SMP/E step 4: Run the receive jobs: DSNRECV1, DSNRECV2, DSNRECV3, DSNRECV4
SMP/E step 5: Run the clean-up job for migration: DSNTIJUD (optional)
SMP/E step 6: Run the apply job: DSNAPPL1
SMP/E step 7: Run the accept job: DSNACEP1
SMP/E step 8: Run the receive jobs for the additional FMIDs (optional)
SMP/E step 9: Run the apply job for the additional FMIDs (optional)
SMP/E step 10: Run the accept job for the additional FMIDs (optional)
SMP/E step 11: Ensure installation of proper maintenance
Performing post-SMP/E activities
Tailoring DB2 jobs to your environment using the installation CLIST
Running the installation CLIST
Making the DB2 ISPF libraries available to TSO
Invoking the CLIST
General instructions
Output from the panel session
Actions that are allowed on panels
Panel descriptions
Directory of panels
Directory of panel field names
Directory of subsystem parameters and DSNHDECP values
Subsystem parameters that are not on installation panels
Subsystem parameter module and DSNHDECP values
Main panel: DSNTIPA1
INSTALL TYPE field
DATA SHARING field (DSHARE subsystem parameter)
DATA SET(MEMBER) NAME field
LIBRARY NAME PREFIX field
LIBRARY NAME SUFFIX field
DATA SET NAME PREFIX field
DATA SET NAME SUFFIX field
INPUT MEMBER NAME field
OUTPUT MEMBER NAME field
OTC license usage panel: DSNTIP01
Notice and acceptance of OTC license panel: DSNTIP02
LICENSE TERMS ACCEPTED field (OTC_LICENSE subsystem parameter)
Data parameters panel 1: DSNTIPA2
CATALOG ALIAS field (CATALOG subsystem parameter)
DEFINE CATALOG field
USE SMS field
Data parameters panel 2: DSNTIPA3
PERMANENT UNIT NAME field
TEMPORARY UNIT NAME field
CLIST ALLOCATION field
NON-VSAM DATA field
VSAM CATALOG, DEFAULT AND WORK FILE DATABASE field
DIRECTORY AND CATALOG DATA field
DIRECTORY AND CATALOG INDEXES field
LOG COPY 1, BSDS 2 field
LOG COPY 2, BSDS 1 field
Define group or member panel: DSNTIPK
GROUP NAME field (GRPNAME subsystem parameter)
MEMBER NAME field (MEMBNAME subsystem parameter)
WORK FILE DB field
GROUP ATTACH field (SSID DECP value)
COORDINATOR field (COORDNTR subsystem parameter)
ASSISTANT field (ASSIST subsystem parameter)
System resource data set names panel: DSNTIPH
COPY 1 NAME field
COPY 2 NAME field
NUMBER OF COPIES field (TWOACTV subsystem parameter)
COPY 1 PREFIX field
COPY 2 PREFIX field
NUMBER OF COPIES field (TWOARCH subsystem parameter)
COPY 1 PREFIX field (ARCPFX1 subsystem parameter)
COPY 2 PREFIX field (ARCPFX2 subsystem parameter)
TIMESTAMP ARCHIVES field (TSTAMP subsystem parameter)
Data set names panel 1: DSNTIPT
TEMP CLIST LIBRARY field
SAMPLE LIBRARY field
CLIST LIBRARY field
APPLICATION DBRM field
APPLICATION LOAD field
DECLARATION LIBRARY field
LINK LIST LIBRARY field
LOAD LIBRARY field
MACRO LIBRARY field
LOAD DISTRIBUTION field
EXIT LIBRARY field
DBRM LIBRARY field
IRLM LOAD LIBRARY field
IVP DATA LIBRARY field
INCLUDE LIBRARY field
Data set names panel 2: DSNTIPU
IBM LE RUNTIME LIBRARY field
IBM LE LINK EDIT LIB field
IBM LE PRELINK MSG LIB field
HIGH LEVEL ASSEMBLER LIB field
C/CPP COMPILER MODULE field
C/CPP COMPILER LIBRARY field
C/CPP HEADER LIBRARY field
C/370 COMPILER MESSAGES field
CPP CLASS LIB HEADERS field
CPP AUTO CALL LIBRARY field
CPP CLASS LIBRARY field
CPP PROCEDURE LIBRARY field
COBOL COMPILER LIBRARY field
FORTRAN COMPILER LIBRARY field
FORTRAN LINK EDIT LIB field
PL/I COMPILER LIBRARY field
Data set names panel 3: DSNTIPW
SYSTEM MACLIB field
SYSTEM PROCEDURES field
SORT LIBRARY field
IMS RESLIB field
ISPF ISPLINK MODULE field
GDDM MACLIB field
GDDM LOAD MODULES field
CICS LOAD LIBRARY field
CICS MACRO LIBRARY field
CICS COBOL LIBRARY field
CICS PL/I LIBRARY field
CICS EXCI LIBRARY field
Sizes panel 1: DSNTIPD
DATABASES field for panel DSNTIPD
TABLES field
COLUMNS field
VIEWS field
TABLE SPACES field
PLANS field
PLAN STATEMENTS field
PACKAGES field
PACKAGE STATEMENTS field
PACKAGE LISTS field
EXECUTED STMTS field
TABLES IN STMT field
USER LOB VALUE STG field (LOBVALA subsystem parameter)
SYSTEM LOB VAL STG field (LOBVALS subsystem parameter)
USER XML VALUE STG field (XMLVALA subsystem parameter)
SYSTEM XML VALUE STG field (XMLVALS subsystem parameter)
MAXIMUM LE TOKENS field (LEMAX subsystem parameter)
Sizes panel 2: DSNTIP7
DEFINE DATA SETS field (IMPDSDEF subsystem parameter)
USE DATA COMPRESSION field (IMPTSCMP subsystem parameter)
TABLE SPACE ALLOCATION field (TSQTY subsystem parameter)
INDEX SPACE ALLOCATION field (IXQTY subsystem parameter)
VARY DS CONTROL INTERVAL field (DSVCI subsystem parameter)
OPTIMIZE EXTENT SIZING field (MGEXTSZ subsystem parameter)
Work file database panel: DSNTIP9
TEMP 4K SPACE field
TEMP 4K TBL SPACES field
TEMP 4K SEG SIZE field
TEMP 32K SPACE field
TEMP 32K TBL SPACES field
TEMP 32K SEG SIZE field
MAX TEMP STG/AGENT field (MAXTEMPS subsystem parameter)
Thread management panel: DSNTIPE
DATABASES field for panel DSNTIPE
MAX USERS field (CTHREAD subsystem parameter)
MAX REMOTE ACTIVE field (MAXDBAT subsystem parameter)
MAX REMOTE CONNECTED field (CONDBAT subsystem parameter)
MAX TSO CONNECT field (IDFORE subsystem parameter)
MAX BATCH CONNECT field (IDBACK subsystem parameter)
SEQUENTIAL CACHE field (SEQCACH subsystem parameter)
MAX KEPT DYN STMTS field (MAXKEEPD subsystem parameter)
CONTRACT THREAD STG field (CONTSTOR subsystem parameter)
MANAGE THREAD STORAGE field (MINSTOR subsystem parameter)
LONG-RUNNING READER field (LRDRTHLD subsystem parameter)
PAD INDEXES BY DEFAULT field (PADIX subsystem parameter)
MAX OPEN FILE REFS field (MAXOFILR subsystem parameter)
Buffer pool sizes panel 1: DSNTIP1
DEFAULT 4-KB BUFFER POOL FOR USER DATA field (TBSBPOOL subsystem parameter)
DEFAULT 8-KB BUFFER POOL FOR USER DATA field (TBSBP8K subsystem parameter)
DEFAULT 16-KB BUFFER POOL FOR USER DATA field (TBSBP16K subsystem parameter)
DEFAULT 32-KB BUFFER POOL FOR USER DATA field (TBSBP32K subsystem parameter)
DEFAULT BUFFER POOL FOR USER LOB DATA field (TBSBPLOB subsystem parameter)
DEFAULT BUFFER POOL FOR USER XML DATA field (TBSBPXML subsystem parameter)
DEFAULT BUFFER POOL FOR USER INDEXES field (IDXBPOOL subsystem parameter)
BUFFERPOOL fields BP0 - BP29
Buffer pool sizes panel 2: DSNTIP2
BUFFERPOOL fields BP30 - BP32K9
Tracing parameters panel: DSNTIPN
AUDIT TRACE field (AUDITST subsystem parameter)
TRACE AUTO START field (TRACSTR subsystem parameter)
TRACE SIZE field (TRACTBL subsystem parameter)
SMF ACCOUNTING field (SMFACCT subsystem parameter)
SMF STATISTICS field (SMFSTAT subsystem parameter)
STATISTICS TIME field (STATIME subsystem parameter)
STATISTICS SYNC field (SYNCVAL subsystem parameter)
DATASET STATS TIME field (DSSTIME subsystem parameter)
MONITOR TRACE field (MON subsystem parameter)
MONITOR SIZE field (MONSIZE subsystem parameter)
UNICODE IFCIDS field (UIFCIDS subsystem parameter)
DDF/RRSAF ACCUM field (ACCUMACC subsystem parameter)
AGGREGATION FIELDS field (ACCUMUID subsystem parameter)
Operator functions panel: DSNTIPO
WTO ROUTE CODES field (ROUTCDE subsystem parameter)
RECALL DATABASE field (RECALL subsystem parameter)
RECALL DELAY field (RECALLD subsystem parameter)
RLF AUTO START field (RLF subsystem parameter)
RLST NAME SUFFIX field (RLFTBL subsystem parameter)
RLST ACCESS ERROR field (RLFERR subsystem parameter)
PARAMETER MODULE field
AUTO BIND field (ABIND subsystem parameter)
EXPLAIN PROCESSING field (ABEXP subsystem parameter)
DPROP SUPPORT field (EDPROP and CHGDC subsystem parameters)
SITE TYPE field (SITETYP subsystem parameter)
TRACKER SITE field (TRKRSITE subsystem parameter)
READ COPY2 ARCHIVE field (ARC2FRST subsystem parameter)
REAL TIME STATS field (STATSINT subsystem parameter)
Application programming defaults panel 1: DSNTIPF
LANGUAGE DEFAULT field (DEFLANG DECP value)
DECIMAL POINT IS field (DECIMAL DECP value)
STRING DELIMITER field (DELIM DECP value)
SQL STRING DELIMITER field (SQLDELI DECP value)
DIST SQL STR DELIMTR field (DSQLDELI DECP value)
MIXED DATA field (MIXED DECP value)
EBCDIC CCSID field (SCCSID, MCCSID, and GCCSID DECP values)
ASCII CCSID field (ASCCSID, AMCCSID, AGCCSID DECP values)
UNICODE CCSID field (USCCSID, UMCCSID, and UGCCSID DECP values)
DEF ENCODING SCHEME field (ENSCHEME DECP value)
APPLICATION ENCODING field (APPENSCH DECP value)
LOCALE LC_CTYPE field (LC_TYPE DECP value)
DECFLOAT ROUNDING MODE field (DEF_DECFLOAT_ROUND_MODE DECP value)
Application programming defaults panel 2: DSNTIP4
MINIMUM DIVIDE SCALE field (DECDIV3 subsystem parameter)
DECIMAL ARITHMETIC field (DECARTH DECP value)
USE FOR DYNAMICRULES field (DYNRULS DECP value)
DESCRIBE FOR STATIC field (DESCSTAT subsystem parameter)
DATE FORMAT field (DATE DECP value)
TIME FORMAT field (TIME DECP value)
LOCAL DATE LENGTH field (DATELEN DECP value)
LOCAL TIME LENGTH field (TIMELEN DECP value)
STD SQL LANGUAGE field (STDSQL DECP value)
PAD NUL-TERMINATED field (PADNTSTR subsystem parameter)
Performance and optimization panel: DSNTIP8
CURRENT DEGREE field (CDSSRDEF subsystem parameter)
CACHE DYNAMIC SQL field (CACHEDYN subsystem parameter)
OPTIMIZATION HINTS field (OPTHINTS subsystem parameter)
VARCHAR FROM INDEX field (RETVLCFK subsystem parameter)
MAX DEGREE field (PARAMDEG subsystem parameter)
UPDATE PART KEY COLS field (PARTKEYU subsystem parameter)
LARGE EDM BETTER FIT field (EDMBFIT subsystem parameter)
IMMEDIATE WRITE field (IMMEDWRI subsystem parameter)
EVALUATE UNCOMMITTED field (EVALUNC subsystem parameter)
SKIP UNCOMM INSERTS field (SKIPUNCI subsystem parameter)
CURRENT REFRESH AGE field (REFSHAGE subsystem parameter)
CURRENT MAINT TYPES field (MAINTYPE subsystem parameter)
STAR JOIN QUERIES field (STARJOIN subsystem parameter)
MAX DATA CACHING field (MXDTCACH subsystem parameter)
IRLM panel 1: DSNTIPI
INSTALL IRLM field
SUBSYSTEM NAME field (IRLMSID subsystem parameter)
RESOURCE TIMEOUT field (IRLMRWT subsystem parameter)
AUTO START field (IRLMAUT subsystem parameter)
PROC NAME field (IRLMPRC subsystem parameter)
TIME TO AUTOSTART field (IRLMSWT subsystem parameter)
U LOCK FOR RR/RS field (RRULOCK subsystem parameter)
X LOCK FOR SEARCHED U/D field (XLKUPDLT subsystem parameter)
START IRLM CTRACE field
IMS BMP TIMEOUT field (BMPTOUT subsystem parameter)
DL/I BATCH TIMEOUT field (DLITOUT subsystem parameter)
RETAINED LOCK TIMEOUT field (RETLWAIT subsystem parameter)
IRLM panel 2: DSNTIPJ
PAGE PROTECT field
MAX STORAGE FOR LOCKS field
LOCKS PER TABLE(SPACE) field (NUMLKTS subsystem parameter)
LOCKS PER USER field (NUMLKUS subsystem parameter)
DEADLOCK TIME field
DEADLOCK CYCLE field
MEMBER IDENTIFIER field
IRLM XCF GROUP NAME field
LOCK ENTRY SIZE field
NUMBER OF LOCK ENTRIES field
DISCONNECT IRLM field
DB2 utilities parameters panel: DSNTIP6
SYSTEM-LEVEL BACKUPS field (SYSTEM_LEVEL_BACKUPS subsystem parameter)
RESTORE/RECOVER field (RESTORE_ RECOVER_FROMDUMP subsystem parameter)
DUMP CLASS NAME field (UTILS_DUMP_CLASS_NAME subsystem parameter)
MAXIMUM TAPE UNITS field (RESTORE_TAPEUNITS subsystem parameter)
TEMP DS UNIT NAME field (VOLTDEVT subsystem parameter)
UTILITY CACHE OPTION field (SEQPRES subsystem parameter)
STATISTICS HISTORY field (STATHIST subsystem parameter)
STATISTICS ROLLUP field (STATROLL subsystem parameter)
STATISTICS CLUSTERING field (STATCLUS subsystem parameter)
UTILITY TIMEOUT field (UTIMOUT subsystem parameter)
UT SORT DATA SET ALLOCATION field (UTSORTAL subsystem parameter)
IGNORE SORTNUM STAT field (IGNSORTN subsystem parameter)
Protection panel: DSNTIPP
ARCHIVE LOG RACF field (PROTECT subsystem parameter)
USE PROTECTION field (AUTH subsystem parameter)
SYSTEM ADMIN 1 field (SYSADM subsystem parameter)
SYSTEM ADMIN 2 field (SYSADM2 subsystem parameter)
SYSTEM OPERATOR 1 field (SYSOPR1 subsystem parameter)
SYSTEM OPERATOR 2 field (SYSOPR2 subsystem parameter)
UNKNOWN AUTHID field (DEFLTID subsystem parameter)
RESOURCE AUTHID field (RLFAUTH subsystem parameter)
BIND NEW PACKAGE field (BINDNV subsystem parameter)
PLAN AUTH CACHE field (AUTHCACH subsystem parameter)
PACKAGE AUTH CACHE field (CACHEPAC subsystem parameter)
ROUTINE AUTH CACHE field (CACHERAC subsystem parameter)
DBADM CREATE AUTH field (DBACRVW subsystem parameter)
AUTH EXIT LIMIT field (AEXITLIM subsystem parameter)
MVS PARMLIB updates panel: DSNTIPM
SUBSYSTEM NAME field (SSID DECP value)
COMMAND PREFIX field
SUBSYSTEM MEMBER field
SUBSYSTEM SEQUENCE field
AUTH MEMBER field
AUTH SEQUENCE field
LINK LIST ENTRY field
LINK LIST SEQUENCE field
COMMAND SCOPE field
SUPPRESS SOFT ERRORS field (SUPERRS subsystem parameter)
Active log data set parameters: DSNTIPL
NUMBER OF LOGS field
OUTPUT BUFFER field (OUTBUFF subsystem parameter)
ARCHIVE LOG FREQ field
UPDATE RATE field
LOG APPLY STORAGE field (LOGAPSTG subsystem parameter)
CHECKPOINT FREQ field (CHKFREQ subsystem parameter)
FREQUENCY TYPE field
UR CHECK FREQ field (URCHKTH subsystem parameter)
UR LOG WRITE CHECK field (URLGWTH subsystem parameter)
LIMIT BACKOUT field (LBACKOUT subsystem parameter)
BACKOUT DURATION field (BACKODUR subsystem parameter)
RO SWITCH CHKPTS field (PCLOSEN subsystem parameter)
RO SWITCH TIME field (PCLOSET subsystem parameter)
LEVELID UPDATE FREQ field (DLDFREQ subsystem parameter)
Archive log data set parameters panel: DSNTIPA
ALLOCATION UNITS field (ALCUNIT subsystem parameter)
PRIMARY QUANTITY field (PRIQTY subsystem parameter)
SECONDARY QTY field (SECQTY subsystem parameter)
CATALOG DATA field (CATALOG subsystem parameter)
DEVICE TYPE 1 field (UNIT subsystem parameter)
DEVICE TYPE 2 field (UNIT2 subsystem parameter)
BLOCK SIZE field (BLKSIZE subsystem parameter)
READ TAPE UNITS field (MAXRTU subsystem parameter)
DEALLOC PERIOD field (DEALLCT subsystem parameter)
RECORDING MAX field (MAXARCH subsystem parameter)
WRITE TO OPER field (ARCWTOR subsystem parameter)
WTOR ROUTE CODE field (ARCWRTC subsystem parameter)
RETENTION PERIOD field (ARCRETN subsystem parameter)
QUIESCE PERIOD field (QUIESCE subsystem parameter)
COMPACT DATA field (COMPACT subsystem parameter)
SINGLE VOLUME field (SVOLARC subsystem parameter)
Databases and spaces to start automatically panel: DSNTIPS
RESTART OR DEFER field (RESTART subsystem parameter)
START NAMES field (ALL subsystem parameter)
Distributed data facility panel 1: DSNTIPR
DDF STARTUP OPTION field (DDF subsystem parameter)
DB2 LOCATION NAME field
DB2 NETWORK LUNAME field
DB2 NETWORK PASSWORD field
RLST ACCESS ERROR field (RLFERRD subsystem parameter)
RESYNC INTERVAL field (RESYNC subsystem parameter)
DDF THREADS field (CMTSTAT subsystem parameter)
MAX INACTIVE DBATS field (MAXTYPE1 subsystem parameter)
DB2 GENERIC LUNAME field
IDLE THREAD TIMEOUT field (IDTHTOIN subsystem parameter)
EXTENDED SECURITY field (EXTSEC subsystem parameter)
Distributed data facility panel 2: DSNTIP5
DRDA PORT field
SECURE PORT field
RESYNC PORT field
TCP/IP ALREADY VERIFIED field (TCPALVER subsystem parameter)
EXTRA BLOCKS REQ field (EXTRAREQ subsystem parameter)
EXTRA BLOCKS SRV field (EXTRASRV subsystem parameter)
AUTH AT HOP SITE field (HOPAUTH subsystem parameter)
TCP/IP KEEPALIVE field (TCPKPALV subsystem parameter)
POOL THREAD TIMEOUT field (POOLINAC subsystem parameter)
Routine parameters panel: DSNTIPX
WLM PROC NAME field
NUMBER OF TCBS field
MAX ABEND COUNT field (STORMXAB subsystem parameter)
TIMEOUT VALUE field (STORTIME subsystem parameter)
WLM ENVIRONMENT field (WLMENV subsystem parameter)
MAX OPEN CURSORS field (MAX_NUM_CUR subsystem parameter)
MAX STORED PROCS field (MAX_ST_PROC subsystem parameter)
Data definition control support panel: DSNTIPZ
INSTALL DD CONTROL SUPT field (RGFINSTL subsystem parameter)
CONTROL ALL APPLICATIONS field (RGFDEDPL subsystem parameter)
REQUIRE FULL NAMES field (RGFFULLQ subsystem parameter)
UNREGISTERED DDL DEFAULT field (RGFDEFLT subsystem parameter)
ART/ORT ESCAPE CHARACTER field (RGFESCP subsystem parameter)
REGISTRATION OWNER field (RGFCOLID subsystem parameter)
REGISTRATION DATABASE field (RGFDBNAM subsystem parameter)
APPL REGISTRATION TABLE field (RGFNMPRT subsystem parameter)
OBJT REGISTRATION TABLE field (RGFNMORT subsystem parameter)
Job editing panel: DSNTIPY
REMOTE LOCATION field
Job card information field
CLIST calculations panel 1: DSNTIPC
DSMAX field (DSMAX subsystem parameter)
EDMPOOL STORAGE SIZE field (EDMPOOL subsystem parameter)
EDM STATEMENT CACHE field (EDMSTMTC subsystem parameter)
EDM DBD CACHE field (EDMDBDC subsystem parameter)
EDM SKELETON POOL SIZE field (EDM_SKELETON_POOL subsystem parameter)
BUFFER POOL SIZE field
SORT POOL SIZE field (SRTPOOL subsystem parameter)
RID POOL SIZE field (MAXRBLK subsystem parameter)
CLIST messages fields for panel DSNTIPC
Storage messages fields
CLIST calculations panel 2: DSNTIPC1
CLIST messages fields for panel DSNTIPC1
Completing the CLIST processing
CLIST messages
Installation jobs that the CLIST tailors
Tailoring the installation jobs
Job DSNTIJUZ and the subsystem parameter load module, DSNHDECP values, and DSNHMCID
The update process
Update selection menu panel: DSNTIPB
Panels to update field
Updating parameters through the Update selection menu panel: DSNTIPB
Updating other parameters
Installing or migrating DB2
Installing DB2
Installation step 1: Define DB2 to z/OS: DSNTIJMV
DSNTIJMV updates to SYS1.PARMLIB
DSNTIJMV updates to SYS1.PROCLIB
Installation step 2: Define the ICF catalog and alias: DSNTIJCA
Installation step 3: Define system data sets: DSNTIJIN
Job DSNTIJIN
Job DSNTIJDE
Installation step 4: Define DB2 initialization parameters: DSNTIJUZ
Installation step 5: Initialize system data sets: DSNTIJID
Installation step 6: Define user authorization exit routines: DSNTIJEX (optional)
Installation step 7: Record DB2 data to SMF (optional)
Installation step 8: Establish subsystem security (optional)
Installation step 9: Connect DB2 to TSO
Make DB2 load modules available to TSO and batch users
Make DB2 CLISTs available to TSO and batch users (DSNTIJVC)
Ensure that PL/I options are available
Make panels, messages, and load modules available to ISPF and TSO
Connect DB2I panels to the ISPF main panel
Installation step 10: Connect IMS to DB2 (optional)
Installation step 11: Connect CICS to DB2 (optional)
Installation step 12: IPL z/OS
Installation step 13: Start the DB2 subsystem
Installation step 14: Tailor the DB2 catalog: DSNTIJTC
CATMAINT
Syntax and options of the CATMAINT control statement
Before running CATMAINT
Data sets that CATMAINT uses
Concurrency and compatibility
Updating the catalog for a new release
Renaming the owner, creator, and schema of database objects, plans, and packages
Changing the ownership of objects from an authorization ID to a role
Changing the catalog name used by storage groups or index spaces and table spaces
Identifying invalidated plans and packages after the owner, creator, or schema name of an object is renamed
Termination or restart of CATMAINT
Installation step 15: Create default storage group, define temporary work files, and bind DB2 REXX Language Support: DSNTIJTM
Installation step 16: Define and bind DB2 objects: DSNTIJSG
Installation step 17: Populate the user-maintained databases (optional)
Installation step 18: Create and bind objects for the Optimization Service Center, Optimization Expert and IBM Data Studio Developer: DSNTIJOS (optional)
Installation step 19: Back up the DB2 directory and catalog: DSNTIJIC
Installation step 20: Set up the administrative scheduler
Installation step 21: Verify a successful installation
Installation step 22: Enable additional capabilities for DB2
Installing support for a communications network
Installing support for Java
Installing a second DB2 subsystem on the same operating system
Implications of a second DB2 subsystem
Loading DB2 libraries for a second DB2 subsystem
Tailoring installation jobs for a second DB2 subsystem
Installing a second DB2 subsystem
Connecting attachment facilities to a second DB2 subsystem
Preparing DB2 for use
Verifying your installation process for a second DB2 subsystem
Enabling multiple DB2 subsystems to share disk storage
Loading data with an SQL cursor
Special packages and plans for SPUFI
Running SPUFI at remote systems
Making SPUFI work with different terminal CCSIDs
Migrating DB2
Migrating your DB2 subsystem to conversion mode
Migration step 1: Actions that you must perform before migration
Make adjustments for release incompatibilities
Make a backup copy of the BSDS
Save critical access paths
Change stored procedures that specify DSNWZPR as the external module name to specify DSNWZP
Examine all new and changed values for DB2I panels
Ensure that sample objects from your previous release are available
Ensure that no utility jobs are running
Specify a non-zero value for EBCDIC and ASCII CCSIDs
Perform premigration queries (DSNTIJPM)
Migration step 2: Run the link checker on DB2 Version 8 table spaces (optional)
Migration step 3: Determine which plans and packages are invalid after migration (optional)
Migration step 4: Check for consistency between catalog tables (optional)
Migration step 5: Take image copies of the directory and catalog: DSNTIJIC
Migration step 6: Connect DB2 to TSO
Make DB2 load modules available to TSO and batch users
Make DB2 CLISTs available to TSO and batch users: DSNTIJVC
Make panels, messages, and load modules available to ISPF and TSO
Migration step 7: Connect IMS to DB2 (optional)
Migration step 8: Connect CICS to DB2 (optional)
Migration step 9: Stop DB2 Version 8 activity
Migration step 10: Back up your DB2 Version 8 volumes (optional)
Migration step 11: Define DB2 initialization parameters: DSNTIJUZ
DSNTIJUZ actions
Add a second BSDS
Migration step 12: Establish subsystem security (optional)
Migration step 13: Define DB2 Version 9.1 to z/OS: DSNTIJMV
DSNTIJMV actions
Completing DSNTIJMV
Migration step 14: Define system data sets: DSNTIJIN
Migration step 15: Define user authorization exit routines: DSNTIJEX (optional)
Migration step 16: IPL z/OS
Migration step 17: Start DB2 Version 9.1
Migration step 18: Tailor DB2 Version 9.1 catalog: DSNTIJTC
Migration step 19: Ensure that the catalog has no problems (optional)
Migration step 20: Rebuild indexes: DSNTIJRI (optional)
Migration step 21: Enable change data capture
Migration step 22: Prepare dynamic SQL program: DSNTIJTM
Migration step 23: Bind SPUFI and DCLGEN and user-maintained database activity: DSNTIJSG
Migration step 24: Create and bind objects for the Optimization Service Center, Optimization Expert, and IBM Data Studio Developer: DSNTIJOS (optional)
Migration step 25: Migrate objects for the Optimization Service Center: DSNTIJOM
Migration step 26: Verify views
Migration step 27: Take an image copy of the DB2 Version 9.1 conversion mode catalog: DSNTIJIC
Migration step 28: Set up the administrative scheduler
Migration step 29: Verify your DB2 Version 9.1 conversion mode system (optional)
Migration step 30: Configure the DB2 environment for running stored procedures and user-defined functions (optional)
Falling back
Implications of falling back
Fallback procedure
Fallback step 1: Stop DB2 Version 9.1 activity
Fallback step 2: Reactivate DB2 Version 8 code: DSNTIJFV
Fallback step 3: Reconnect TSO, IMS, and CICS to DB2 Version 8
Fallback step 4: Start DB2 Version 8
Fallback step 5: Verify fallback
Remigrating
Migrating your DB2 subsystem to new-function mode
Implications of converting to Version 9.1 new-function mode
Converting from conversion mode to enabling-new-function mode
Completing enabling-new-function mode processing
CATENFM
Syntax and options of the control statement
Before converting the catalog
Data sets that CATENFM uses when converting the catalog
Concurrency and compatibility for CATENFM
Converting to new-function mode
Termination or halt of CATENFM
Job DSNTIJEN
Converting from enabling-new-function mode to new-function mode
Job DSNTIJNF
Job DSNTIJNG
Job DSNTIJNX
Reverting to conversion mode* or enabling-new-function mode*
Reverting to conversion mode*
Reverting to enabling-new-function mode*
Returning to enabling-new-function mode or new-function mode
Moving from conversion mode* to enabling-new-function mode
Moving from conversion mode* to new-function mode
Converting from enabling-new-function mode* to new-function mode
Verifying that installation or migration was successful with the sample applications
Installation verification phases and programs
Planning for verification
COBOL options to use with the installation verification procedures
C and C++ language options to use with the installation verification procedures
PL/I options to use with the installation verification procedures
Phase 0: Deleting the sample objects (DSNTEJ0)
Phase 1: Creating and loading sample tables
Job DSNTEJ1
Job DSNTEJ1L
Job DSNTEJ1P
Job DSNTEJ1U
Phase 2: Testing the batch environment
Job DSNTEJ2A
Job DSNTEJ2C
Job DSNTEJ2D
Job DSNTEJ2E
Job DSNTEJ2F
Job DSNTEJ2P
Job DSNTEJ2U
Phase 3: Testing SPUFI, DRDA access, dynamic SQL, and TSO
Testing SPUFI
Dynamic SQL and the ISPF/CAF application
Jobs DSNTEJ3C and DSNTEJ3P
Job DSNTEJ3M
Starting an application in an ISPF/TSO environment
Phase 4: Testing the IMS environment
Jobs DSNTEJ4C and DSNTEJ4P
Starting an application in an IMS environment
Using the phone application in IMS
Phase 5: Testing the CICS environment
Job DSNTEJ5A
Jobs DSNTEJ5C and DSNTEJ5P
Starting an application in a CICS environment
Using the phone application in CICS
Using CICS storage-handling facilities
Phase 6: Accessing data at a remote site
DRDA access sample
Job DSNTEJ6
DB2 private protocol access sample
Starting an application in an ISPF/TSO environment in phase 6
Stored procedure samples
Stored procedure sample without result set
Job DSNTEJ6S
Job DSNTEJ6P
Stored procedure sample with result set
Job DSNTEJ6T
Job DSNTEJ6D
Sample callers of utilities stored procedures
Job DSNTEJ6U
Job DSNTEJ6R
Job DSNTEJ6V
Job DSNTEJ6W
Job DSNTEJ6Z
Sample ODBA stored procedure
Job DSNTEJ61
Job DSNTEJ62
Sample SQL procedures
Job DSNTEJ63
Job DSNTEJ64
Job DSNTEJ65
Job DSNTEJ66
Phase 7: Accessing LOB data
Job DSNTEJ7
Job DSNTEJ71 (optional)
Job DSNTEJ73
Job DSNTEJ75
Job DSNTEJ76
Job DSNTEJ77
Job DSNTEJ78
Starting an application in an ISPF/TSO environment in phase 7
The sample applications
Printing options for the sample application listings
The sample application panels
Allowable combinations of values on the sample application panels
DATA field values on the sample application panels
Function keys on the sample application panels
Working with scenarios
Working with the project application scenario
Updating an activity
Working with the organization application scenario
Starting a new operation
Adding a new department
Deleting an entry
Transferring an employee
Working with the phone application scenario
Viewing or changing an employee's telephone number
Using the phone application under batch
Working with the distributed organization application scenario
Displaying department structure at the local location
Displaying department information at the local location
Updating a department at the local location
Adding an employee at a remote location
Erasing an employee at a remote location
Working with the employee resume and photo scenarios
Using the resume application in the LOB application scenario
Using the photo application in the LOB application scenario
Sample LOB table: EMP_PHOTO_RESUME
Edit exit routine
Huffman compression exit routine
Sample field procedure
Dynamic SQL statements: DSNTESA, DSNTESQ
DSNTESA
DSNTESQ
Dynamic SQL programs: DSNTIAD, DSNTEP2, DSNTIAUL
Working with additional capabilities for DB2
Configuring DB2 for running stored procedures and user-defined functions
Setting up a WLM application environment for stored procedures
WLM management of stored procedures
Setting up Language Environment for stored procedures
Implementing RRS for stored procedures
Enabling DB2-supplied routines
Enabling the DB2-supplied stored procedures for preparing Java routines
Enabling the stored procedures and objects for XML schema support
Creating stored procedures and tables for JDBC and ODBC support
Enabling the administrative scheduler and administrative enablement routines
Enabling the DSNAEXP EXPLAIN stored procedure
Enabling the DSN8EXP sample EXPLAIN stored procedure
Enabling the CICS transaction invocation procedure
Enabling the IMS transaction invocation procedures
Enabling the common SQL API stored procedures
Setting up support for external SQL procedures
Enabling WebSphere MQ user-defined functions
Moving from previous versions of the WebSphere MQ user-defined functions
Converting from the AMI-based MQ functions to the MQI-based MQ functions
Editing the WebSphere MQ configuration files (for deprecated functions only)
Using caches for AMI files (for deprecated functions only)
Creating and configuring a broker domain
Starting the queue manager
Starting the broker
Customizing a WLM application environment for running WebSphere MQ user-defined function support
Defining the WebSphere MQ user-defined functions to DB2
Verifying the DB2 and WebSphere MQ setup
Enabling WebSphere MQ XML user-defined functions and stored procedures
Job DSNTIJMX
Enabling DB2 Web services
Enabling Web service user-defined functions
Supported Web service calls
Enabling the Web service user-defined function support for HTTPS
Enabling DB2 as a Web service provider
Enabling DB2 as a Web service consumer
Installing the IBM Data Server Driver for JDBC and SQLJ
Connecting the IMS attachment facility
Making DB2 load modules available to IMS
Defining DB2 to IMS
Defining new programs and transactions to IMS
Defining DB2 plans for IMS applications (optional)
Generating a user language interface (optional)
IMS attachment facility macro (DSNMAPN)
Connecting distributed database systems
The database protocols (DRDA vs private)
Preparing your system for DRDA access
The private to DRDA protocol REXX tool (DSNTP2DP)
The communications protocols
The role of the communications database (CDB)
DRDA enhancements
DDF installation and implications for DB2
Connecting systems with VTAM
Customize VTAM for DB2
Choosing names and a password
Choosing names for the local subsystem
Choosing a password for the local subsystem
Names that you need from the remote systems
Names that Spiffy Computer Company chose
Defining the DB2 subsystem to VTAM
The APPL statement
Options for which you must choose values
Options that you must code exactly as given
Options that must use VTAM defaults
Other options of interest
Options that are ignored by DB2
The MODEENT macro
Default modes
Sample mode entries
MODEENT options
Populating the communications database
VTAM-relevant columns of the SYSIBM.LOCATIONS table
VTAM-relevant columns of the SYSIBM.LUNAMES table
VTAM-relevant columns of the SYSIBM.USERNAMES table
Starting VTAM to use DB2
Tuning the VTAM system
Controlling buffer storage
Controlling pacing
Recommendation for APPL pacing option
Recommendation for MODEENT pacing options
Modifying default session limits
Modifying class of service
Associating applications with modes
Update LUNAMES to associate modes with LU names
Update SYSIBM.LUMODES with conversation limits
Update SYSIBM.MODESELECT to associate plans with modes
When updates to CDB values take effect
Calculating session limits
Calculating session limits for DB2 private protocol access
Implications of using both DB2 private protocol access and DRDA access
Calculating VTAM I/O buffer pool (IOBUF) storage
CNOS processing in DB2
Sample VTAM definitions to connect two DB2 subsystems
Basic VTAM definitions
Definitions for channel-connected DB2 subsystems
NCP-connected DB2 subsystems
Using the change log inventory utility to update the BSDS
Connecting systems with TCP/IP
TCP/IP terminology
Enabling TCP/IP communication
TCP/IP limitations
Initializing a TCP stack for use with a VIPA
Initializing a TCP stack for use with both IPv4 and IPv6 addresses
Two-phase commit for TCP/IP clients
Multiple TCP/IP stacks and DB2
Multiple DB2 subsystems with multiple TCP/IP stacks
Multiple DB2 subsystems with one TCP/IP stack
Preparing the Language Environment runtime library
Enabling DDF for UNIX System Services
Defining the DB2 subsystem to TCP/IP
Customizing the TCP/IP data sets or files
Modify the change log inventory job
Populating the communications database for use with TCP/IP
TCP/IP-relevant columns of the SYSIBM.LOCATIONS table
TCP/IP-relevant columns of the SYSIBM.IPLIST table
TCP/IP-relevant columns of the SYSIBM.IPNAMES table
TCP/IP-relevant columns of the SYSIBM.USERNAMES table
Starting TCP/IP support
Tuning TCP/IP
Specifying security requirements
Using the DB2 command line processor
Command line processor prerequisites
Setting up your system to use the DB2 command line processor
Enabling IBM Text Search for DB2 for z/OS
Working with international data
Character conversion concepts
System-coded character set identifiers
Unicode support in DB2
Customizing support for Unicode
EBCDIC and ASCII support
Implications of character conversions
Converting to the euro symbol
How an entry in SYSIBM.SYSSTRINGS works with character conversion
Conversion-related changes that require remote packages to be rebound
Locales for uppercase and lowercase conversion of EBCDIC data
Setting up z/OS to allow uppercase and lowercase conversion of Unicode and ASCII data
Installing and using the msys for Setup DB2 Customization Center
Introduction to msys for Setup
Using the DB2 Customization Center
Adding the DB2 Customization Center to msys for Setup
Refreshing the msys for Setup workplace
Customizing DB2 with msys for Setup
Updating DB2 with msys for Setup
Index for installation and migration
DB2 Program Directory
DB2 administration
Administration
Designing a database
Database objects and relationships
Logical database design with the entity-relationship model
Modeling your data
Recommendations for logical data modeling
Practical examples of data modeling
Entities for different types of relationships
Entity attributes
Attribute names
Data types of attributes
Appropriate values for attributes
Entity normalization
Logical database design with Unified Modeling Language
Physical database design
Denormalization of tables
Views as a way to customize what data users see
Indexes on table columns
Implementing your database design
Implementing DB2 databases
Creating DB2 databases
Dropping DB2 databases
Implementing DB2 storage groups
Advantages of storage groups
Control interval sizing
Creating DB2 storage groups
Enabling SMS to control DB2 storage groups
Deferring allocation of DB2-managed data sets
How DB2 extends data sets
DB2 space allocation
Primary space allocation
Secondary space allocation
Example of primary and secondary space allocation
Managing DB2 data sets with DFSMShsm
Migrating to DFSMShsm
How archive logs are recalled by DFSMShsm
The RECOVER utility and the DFSMSdss RESTORE command
Restrictions associated with the BACKUP SYSTEM utility and DFSMShsm
Incremental system-level backups
Managing your own data sets
Defining data sets
Data set naming conventions
Extending user-managed data sets
Deleting user-managed data sets
Defining index space storage
Creating EA-enabled table spaces and index spaces
Implementing DB2 table spaces
Creating a table space explicitly
Guidelines and recommendations for table spaces
General naming guidelines for table spaces
Coding guidelines for explicitly defined table spaces
Coding guidelines for implicitly defined table spaces
Recommendations for page size
Factors for determining table space page size
Recommendations for LOB page size
Factors for determining LOB table space page size
Examples of table space definitions
Implementing DB2 tables
Creating base tables
Guidelines for table names
Creating temporary tables
Creating created temporary tables
Creating declared temporary tables
Distinctions between DB2 base tables and temporary tables
Creating materialized query tables
Creating tables that use table-controlled partitioning
Differences between partitioning methods
Automatic conversion to table-controlled partitioning
Nullable partitioning columns
Creating tables that use index-controlled partitioning
Creating a clone table
Exchanging base table and clone table data
Implementing DB2 views
Creating DB2 views
Guidelines for view names
How DB2 inserts and updates data through views
Dropping DB2 views
Implementing DB2 indexes
Creating DB2 indexes
Guidelines for defining indexes
How DB2 implicitly creates an index
Recommendations for index page size
Index versions
Compressing indexes
Implementing DB2 schemas
Creating a schema by using the schema processor
Processing schema definitions
Loading data into DB2 tables
Loading data with the LOAD utility
How the LOAD utility loads DB2 tables
Restricted status after LOAD
Loading data by using the INSERT SQL statement
Inserting a single row
Inserting multiple rows
Implications of using an INSERT statement to load tables
Loading data from DL/I
Implementing DB2 stored procedures
Creating stored procedures
Deleting stored procedures
Implementing DB2 user-defined functions
Creating user-defined functions
Deleting user-defined functions
Estimating disk storage for user data
General approach to estimating storage
Calculating the space required for a table
Calculations for record lengths and pages
Estimating storage for LOBs
Estimating storage when using the LOAD utility
Calculating the space required for an index
Levels of index pages
Estimating storage from the number of index pages
Saving space with data compression
Compressing data
Calculating the space that is required for a dictionary
Calculating disk requirements for a dictionary
Calculating virtual storage requirements for a dictionary
Altering your database design
Altering DB2 databases
ALTER DATABASE options
Altering DB2 storage groups
Letting SMS manage your DB2 storage groups
Adding or removing volumes from a DB2 storage group
Altering table spaces
Changing the logging attribute
The NOT LOGGED attribute
Changing the space allocation for user-managed data sets
Dropping, recreating, or converting a table space
Rebalancing data in partitioned table spaces
Altering a page set to contain DB2-defined extents
Altering DB2 tables
Adding a new column to a table
Specifying a default value when altering a column
Altering the data type of a column
What happens to the column
What happens to an index on the column
Table space versions
Reorganizing table spaces
Recycling table space version numbers
Altering a table for referential integrity
Adding referential constraints to existing tables
Adding parent keys and foreign keys
Implications of adding parent or foreign keys
Dropping parent keys and foreign keys
Adding or dropping table check constraints
Adding a partition
Altering partitions
Changing the boundary between partitions
Rotating partitions
Extending the boundary of the last partition
Reverting to the previous boundary
Adding a partition when the last partition is in REORG-pending status
Inserting rows at the end of a partition
Adding XML columns
Altering materialized query tables
Registering an existing table as a materialized query table
Changing a materialized query table to a base table
Changing the attributes of a materialized query table
Changing the definition of a materialized query table
Altering the assignment of a validation routine
Altering a table for capture of changed data
Changing an edit procedure or a field procedure
Altering the subtype of a string column
Altering the attributes of an identity column
Changing data types by dropping and re-creating the table
Implications of dropping a table
Objects that depend on the dropped table
Re-creating a table
Moving a table to a table space of a different page size
Altering DB2 views
Altering views by using the INSTEAD OF trigger
Altering DB2 indexes
Adding a column to an index when you add the column to a table
Altering how varying-length index columns are stored
Altering the clustering of an index
Dropping and redefining a DB2 index
Reorganizing indexes
Recycling index version numbers
Altering stored procedures
Altering user-defined functions
Altering implicitly created XML objects
Changing the high-level qualifier for DB2 data sets
Defining a new integrated catalog alias
Changing the qualifier for system data sets
Changing the load module to reflect the new qualifier
Stopping DB2 when no activity is outstanding
Renaming system data sets with the new qualifier
Updating the BSDS with the new qualifier
Establishing a new xxxxMSTR cataloged procedure
Starting DB2 with the new xxxxMSTR and load module
Changing qualifiers for other databases and user data sets
Changing your work database to use the new high-level qualifier
Changing your work database for a new installation of DB2
Changing your work database for a migrated installation of DB2
Changing user-managed objects to use the new qualifier
Changing DB2-managed objects to use the new qualifier
Tools for moving DB2 data
Moving DB2 data
Moving a DB2 data set
Moving data without REORG or RECOVER
Moving DB2-managed data with REORG, RECOVER, or REBUILD
Scenario: Moving from index-controlled to table-controlled partitioning
Security and auditing
Getting started with DB2 security
DB2 security solutions
What's new in DB2 Version 9.1 security?
DB2 data access control
ID-based access control within DB2
Role-based access control within DB2
Ownership-based access control within DB2
Access control through multilevel security
Access control through exit routines
DB2 subsystem access control
Managing access requests from local applications
Managing access requests from remote applications
Data set protection
RACF for data protection
Data encryption
Scenario: Securing data access at Spiffy Computer
Determining security objectives
Securing manager access to employee data
Creating views of employee data
Granting managers the SELECT privilege
Managing distributed access
Planning for distributed access
Implementing distributed access at the central server
Implementing distributed access at remote locations
Auditing manager access
Securing access to payroll operations and management
Creating views of payroll operations
Securing compensation accounts with update tables
Securing compensation updates with other measures
Granting privileges to payroll operations and management
Creating a RACF group for payroll operations
Creating a RACF group for payroll management
Auditing payroll operations and management
Managing access privileges of other authorities
Managing access by the DBADM authority
Managing access by the SYSADM authority
Managing access by object owners
Managing access by other users
Managing access through authorization IDs or roles
Authorization IDs and roles
Authorization IDs
Roles in a trusted context
Privileges and authorities
Explicit privileges
Explicit collection privileges
Explicit database privileges
Explicit package privileges
Explicit plan privileges
Explicit routine privileges
Explicit schema privileges
Explicit system privileges
Explicit table and view privileges
Explicit usage privileges
Explicit use privileges
Implicit privileges through object ownership
Administrative authorities
Installation SYSADM
SYSADM
SYSCTRL
Installation SYSOPR
SYSOPR
DBADM
DBCTRL
DBMAINT
PACKADM
Utility authorities for DB2 catalog and directory
Privileges by authorization ID and authority
Privileges required for common job roles and tasks
Checking access authorization for data definition statements
Privileges required for handling plans and packages
Privileges required for using dynamic SQL statements
Managing explicit privileges
Granting privileges to a role
Granting privileges to the PUBLIC ID
Granting privileges to remote users
Granting privileges through views
Granting privileges with the GRANT statement
Granting privileges to secondary IDs
Granting privileges to user groups
Granting privileges for binding plans
Granting privileges for rebinding plans and packages
Granting privileges for accessing distributed data
Revoking privileges with the REVOKE statement
Revoking privileges granted by multiple IDs
Revoking privileges granted by all IDs
Revoking privileges granted by a role
Revoking all privileges from a role
Revoking privileges for views
Revoking privileges for materialized query tables
Revoking privileges for plans or packages
Revoking the SYSADM authority from IDs with the installation SYSADM authority
Changing IDs with the installation SYSADM authority
Deleting extraneous IDs with the SYSADM authority
Restrictions on privilege revocation
Managing implicit privileges
Managing implicit privileges through object ownership
Ownership of objects with unqualified names
Ownership of objects with qualified names
Ownership of objects within a trusted context
Changing object ownership
Granting implicit privileges of object ownership
Managing implicit privileges through plan or package ownership
Establishing or changing plan or package ownership
Establishing plan and package ownership in a trusted context
How DB2 resolves unqualified names
Validating authorization for executing plans or packages
Checking authorization at a DB2 database server
Checking authorization for executing an RRSAF application without a plan
Caching authorization IDs for better performance
Caching authorization IDs for plans
Caching authorization IDs for packages
Caching authorization IDs for routines
Authorizing plan or package access through applications
Restricting access of plans or packages to particular systems
Authorization checking for executing packages remotely
Managing implicit privileges through routines
Privileges required for executing routines
Granting privileges through routines
Implementing a user-defined function
Defining a user-defined function
Using a user-defined function
Authorization ID validation
Authorization behaviors for dynamic SQL statements
Run behavior
Bind behavior
Define behavior
Invoke behavior
Common attribute values for bind, define, and invoke behaviors
Determining authorization IDs for dynamic SQL statements in routines
Simplifying access authorization for routines
Using composite privileges
Performing multiple actions in one statement
Retrieving privilege records in the DB2 catalog
Catalog tables with privilege records
Retrieving all authorization IDs or roles with granted privileges
Retrieving multiple grants of the same privilege
Retrieving all authorization IDs or roles with the DBADM authority
Retrieving all IDs or roles with access to the same table
Retrieving all IDs or roles with access to the same routine
Retrieving tables or views accessible by an ID
Retrieving plans or packages with access to the same table
Retrieving privilege information through views
Implementing multilevel security with DB2
Multilevel security
Security labels
Determining the security label of a user
Security levels
Security categories
Users and objects in multilevel security
Global temporary tables with multilevel security
Materialized query tables with multilevel security
Constraints in a multilevel-secure environment
Field, edit, and validation procedures in a multilevel-secure environment
Triggers in a multilevel-secure environment
Mandatory access checking
Dominance relationships between security labels
Write-down control
Granting write-down privileges
Implementing multilevel security at the object level
Implementing multilevel security with row-level granularity
Creating tables with multilevel security
Adding multilevel security to existing tables
Removing tables with multilevel security
Caching security labels
Restricting access to the security label column
Managing data in a multilevel-secure environment
Using the SELECT statement with multilevel security
Using the INSERT statement with multilevel security
Using the UPDATE statement with multilevel security
Using the MERGE statement with multilevel security
Using the DELETE statement with multilevel security
Using the TRUNCATE statement with multilevel security
Using utilities with multilevel security
Implementing multilevel security in a distributed environment
Configuring TCP/IP with multilevel security
Configuring SNA with multilevel security
Managing access through RACF
Establishing RACF protection for DB2
Defining DB2 resources to RACF
Naming protected access profiles
Enabling RACF checking for the DSNR and SERVER classes
Enabling partner LU verification
Permitting RACF access
Defining RACF user IDs for DB2-started tasks
Adding RACF groups
Granting users and groups access
Granting authorization on DB2 commands
Permitting access from remote requesters
Managing authorization for stored procedures
Authorizing IDs for using RRSAF
Specifying WLM-established server address spaces for stored procedures
Authorizing users to create stored procedures in WLM environments
Authorizing users to refresh WLM environments
Protecting stored procedures with RACF
Granting the CREATEIN privilege on schemas for stored procedures
Granting the BINDADD privilege on packages for stored procedures
Granting privileges for using distinct types
Granting privileges for using JAR files
Granting privileges for executing stored procedures
Granting privileges for executing stored procedures that are dynamically called
Granting privileges for executing stored procedures that are statically called
Granting privileges for executing stored procedure packages
Executing stored procedures in trusted contexts
Protecting connection requests that use the TCP/IP protocol
Establishing Kerberos authentication through RACF
Implementing DB2 support for enterprise identity mapping
Configuring the z/OS LDAP server
Setting up RACF for the z/OS LDAP server
Setting up the EIM domain controller
Adding the SAF user mapping plug-in data set to LNKLIST
Managing connection requests from local applications
Processing of connection requests
Using secondary IDs for connection requests
Processing of sign-on requests
Using secondary IDs for sign-on requests
Using sample connection and sign-on exit routines for CICS transactions
Managing connection requests from remote applications
Security mechanisms for DRDA and SNA
Security mechanisms for DB2 for z/OS as a requester
Security mechanisms for DB2 for z/OS as a server
Communications database for the server
SYSIBM.LUNAMES columns
SYSIBM.USERNAMES columns
Enabling change of user passwords
Authorization failure code
Managing inbound SNA-based connection requests
Processing of remote attachment requests
Controlling LU attachments to the network
Verifying partner LUs
Accepting remote attachment requests
Managing inbound IDs through DB2
Managing inbound IDs through RACF
Authenticating partner LUs
Encrypting passwords
Authenticating users through Kerberos
Translating inbound IDs
Associating inbound IDs with secondary IDs
Managing inbound TCP/IP-based connection requests
Processing of TCP/IP-based connection requests
Managing denial-of-service attacks
Managing outbound connection requests
Communications database for the requester
SYSIBM.LUNAMES columns
SYSIBM.IPNAMES columns
SYSIBM.USERNAMES columns
SYSIBM.LOCATIONS columns
Processing of outbound connection requests
Translating outbound IDs
Sending passwords
Sending RACF-encrypted passwords
Sending RACF PassTickets
Sending encrypted passwords from DB2 for z/OS clients
Sending encrypted passwords from workstation clients
Managing access through trusted contexts
Trusted contexts
Trusted connections
Defining trusted contexts
Creating local trusted connections
Establishing remote trusted connections by DB2 for z/OS requesters
Establishing remote trusted connections to DB2 for z/OS servers
Switching users of a trusted connection
Reusing a local trusted connection through the DSN command processor and DB2I
Reusing a remote trusted connection by DB2 for z/OS requesters
Reusing a remote trusted connection through DB2 for z/OS servers
Reusing a local trusted connection through RRSAF
Reusing a local trusted connection through the SQL CONNECT statement
Defining external security profiles
Enabling users to perform actions on behalf of others
Performing tasks on objects for other users
Managing access through data definition control
Data definition statements
Data definition control support
Registration tables
ART columns
ORT columns
Installing data definition control support
Enabling data definition control
Controlling data definition by application name
Controlling data definition by application name with exceptions
Controlling data definition by object name
Controlling data definition by object name with exceptions
Registering object sets
Disabling data definition control
Managing registration tables and indexes
Creating registration tables and indexes
Naming registration tables and indexes
Dropping registration tables and indexes
Creating table spaces for registration tables
Adding columns to registration tables
Updating registration tables
Protecting data through encryption and RACF
Encrypting your data through DB2 built-in functions
Defining columns for encrypted data
Defining column-level encryption
Creating views with column-level encryption
Using password hints with column-level encryption
Defining value-level encryption
Using password hints with value-level encryption
Encrypting non-character values
Using predicates for encrypted data
Optimizing performance of encrypted data
Encrypting your data with Secure Socket Layer support
AT-TLS configuration
Configuring the DB2 server for SSL
Configuring the DB2 requester for SSL
Protecting data sets through RACF
Adding groups to control DB2 data sets
Creating generic profiles for data sets
Authorizing DB2 IDs to use data set profiles
Enabling DB2 IDs to create data sets
Auditing access to DB2
Determining active security measures
DB2 audit trace
Authorization IDs traced by auditing
Audit classes
Audit trace reports
Audit trace records
Limitations of the audit trace
Starting the audit trace
Stopping the audit trace
Collecting audit trace records
Formatting audit trace records
Auditing in a distributed data environment
Additional sources of audit information
Determining ID privileges and authorities
Auditing specific IDs or roles
Auditing specific tables
Ensuring data accuracy and integrity
Ensuring data presence and uniqueness
Protecting data integrity
Tracking data changes
Checking for lost and incomplete transactions
Ensuring data consistency
Using referential integrity for data consistency
Using locks for data consistency
Checking data consistency
Checking data consistency with SQL queries
Checking data consistency with the CHECK utilities
Checking data consistency with the DISPLAY DATABASE command
Checking data consistency with the REPORT utility
Checking data consistency with the operation log
Checking data consistency with internal integrity reports
Operation and recovery
DB2 basic operational concepts
Recommendations for entering commands
DB2 operator commands
Where DB2 commands are entered
Where command responses go
Authorities for DB2 commands
DB2 message identifiers
Unsolicited DB2 messages
Operational control options
Starting and stopping DB2
Starting DB2
Messages at start
Options at start
Restricting access to data
Ending the wait state at start
Restart options after an abend
Stopping DB2
Submitting work to DB2
Submitting work by using DB2I
Running TSO application programs
DSN subcommands for TSO environments
Sources that DB2 uses to find authorization access by the application program
Running IMS application programs
Running CICS application programs
Running batch application programs
Running application programs using CAF
Running application programs using RRSAF
Scheduling administrative tasks
Interacting with the administrative task scheduler
Adding a task
Scheduling capabilities of the administrative task scheduler
Defining task schedules
Choosing an administrative task scheduler in a data sharing environment
ADMIN_TASK_ADD
UNIX cron format
Listing scheduled tasks
Listing the last execution status of scheduled tasks
Removing a scheduled task
ADMIN_TASK_REMOVE
Manually starting the administrative task scheduler
Manually stopping the administrative task scheduler
Synchronization between administrative task schedulers in a data sharing environment
Troubleshooting the administrative task scheduler
Enabling tracing for administrative task scheduler problem determination
Recovering the administrative task scheduler task list
Problem executing a task
Problem in user-defined table functions
Problem in stored procedures
Architecture of the administrative task scheduler
The lifecycle of the administrative task scheduler
Scheduler task lists
Architecture of the administrative task scheduler in a data sharing environment
Security guidelines for the administrative task scheduler
User roles in the administrative task scheduler
Protection of the interface of the administrative task scheduler
Protection of the resources of the administrative task scheduler
Secure execution of tasks in the administrative task scheduler
Execution of scheduled tasks in the administrative task scheduler
Multi-threading in the administrative task scheduler
Scheduled execution of a stored procedure
How the administrative task scheduler works with Unicode
Scheduled execution of a JCL job
Execution of scheduled tasks in a data sharing environment
Monitoring and controlling DB2 and its connections
Controlling DB2 databases and buffer pools
Starting databases
Starting an object with a specific status
Starting a table space or index space that has restrictions
Monitoring databases
Obtaining information about application programs
Identifying who and what are using an object
Determining which programs are holding locks on an object
Obtaining information about and handling pages in error
Characteristics of pages that are in error
Displaying the logical page list
Removing pages from the logical page list
Displaying a write error page range
Using the STOP DATABASE command to make objects available
Commands to stop databases
Altering buffer pools
Monitoring buffer pools
Controlling user-defined functions
Starting user-defined functions
Monitoring user-defined functions
Stopping user-defined functions
Controlling DB2 utilities
Starting online utilities
Monitoring and changing online utilities
Controlling DB2 stand-alone utilities
Stand-alone utilities
Controlling the IRLM
z/OS commands that operate on IRLM
Starting the IRLM
Stopping the IRLM
Monitoring threads
Types of threads
Output of the DISPLAY THREAD command
Displaying information about threads
Displaying information by location
Displaying information for non-DB2 locations
Displaying conversation-level information about threads
Displaying threads by LUWID
Displaying threads by type
Monitoring all DBMSs in a transaction
Controlling connections
Controlling TSO connections
Connecting to DB2 from TSO
Monitoring TSO and CAF connections
Disconnecting from DB2 while under TSO
Controlling CICS connections
Connecting from CICS
Restarting CICS
Defining CICS threads
Monitoring CICS threads
Displaying CICS-DB2 indoubt units of recovery
Recovering CICS-DB2 indoubt units of recovery
Displaying CICS postponed units of recovery
Disconnecting CICS applications
Disconnecting from CICS
Performing an orderly termination from CICS
Performing a forced termination from CICS
Controlling IMS connections
Connections to the IMS control region
IMS thread attachment
Duplicate IMS correlation IDs
Displaying IMS attachment facility threads
Terminating IMS attachment facility threads
Displaying IMS-DB2 indoubt units of recovery
Recovering IMS-DB2 indoubt units of recovery
Displaying postponed IMS-DB2 units of recovery
Resolving IMS residual recovery entries
IMS residual recovery entries
Controlling IMS dependent region connections
How IMS dependent region connections work
Disconnecting from IMS dependent regions
Monitoring activity on connections from DB2
Monitoring activity of connections from IMS
Disconnecting from IMS
Controlling RRS connections
Abnormal termination involving DB2 and RRS
Displaying RRS indoubt units of recovery
Recovering RRS indoubt units of recovery manually
Displaying RRS postponed units of recovery
Monitoring and displaying RRSAF connections
Disconnecting RRSAF applications from DB2
Controlling connections to remote systems
Starting DDF
Suspending DDF server activity
Resuming DDF server activity
Displaying information about DDF work
DB2 commands for monitoring connections to other systems
Displaying information about connections with other locations
Canceling dynamic SQL from a client application
Canceling threads
Effects of the CANCEL THREAD command
Monitoring and controlling stored procedures
Displaying information about stored procedures with DB2 commands
Displaying statistics about stored procedures
Displaying thread information about stored procedures
Determining the status of an application environment
Refreshing a WLM application environment for stored procedures
Obtaining diagnostic information and debugging stored procedures
Migrating stored procedures from test to production
Migrating native SQL procedures from test to production
Migrating external SQL procedures from test to production
Migrating external stored procedures from test to production
Monitoring DDF problems by using NetView
DDF alerts
Stopping DDF
Stopping DDF using the QUIESCE option
Stopping DDF using the FORCE option
Stopping DDF using VTAM commands
Controlling traces
Types of DB2 traces
Diagnostic traces for attachment facilities
Controlling the DB2 trace
Diagnostic trace for the IRLM
Controlling the resource limit facility (governor)
Changing subsystem parameter values
Managing the log and the bootstrap data set
How database changes are made
Units of recovery and points of consistency
How DB2 rolls back work
How the initial DB2 logging environment is established
How DB2 creates log records
How DB2 writes the active log
How DB2 writes (offloads) the archive log
What triggers an offload
Role of the operator in the offload process
Messages that are returned during offloading
Effects of interruptions and errors on the offload process
Archive log data sets
How dual archive logging works
Tips for archiving
Tips for archiving to tape
Tips for archiving to disk
Tips for archiving with DFSMS
Automatic archive log deletion
How DB2 retrieves log records
Managing the log
Quiescing activity before offloading
Archiving the log
Dynamically changing the checkpoint frequency
Setting limits for archive log tape units
Monitoring the system checkpoint
Displaying log information
Resetting the log RBA
Log RBA range
Resetting the log RBA value in a data sharing environment
Resetting the log RBA value in a non-data sharing environment
Canceling and restarting an offload
Displaying the status of an offload
Discarding archive log records
Locating archive log data sets
Management of the bootstrap data set
Restoring dual mode BSDS
BSDS copies with archive log data sets
Recommendations for changing the BSDS log inventory
Restarting DB2 after termination
Methods of restarting
Types of termination
Normal termination
Abnormal terminations (abends)
Normal restart and recovery
Phase 1: Log initialization
Phase 2: Current status rebuild
Phase 3: Forward log recovery
Phase 4: Backward log recovery
Automatic restart
Restart in a data sharing environment
Restart implications for table spaces that are not logged
Conditional restart
Terminating DB2 normally
Restarting automatically
Deferring restart processing
Deferral of restart
Performing conditional restart
Options for recovery operations after conditional restart
Conditional restart records
Resolving postponed units of recovery
RECOVER POSTPONED command
Recovering from an error during RECOVER POSTPONED processing
Maintaining consistency across multiple systems
Multiple system consistency
Two-phase commit process
Commit coordinator and multiple participants
Illustration of multi-site update
Termination for multiple systems
Consistency after termination or failure
Normal restart and recovery for multiple systems
Multiple-system restart with conditions
Heuristic decisions about whether to commit or abort an indoubt thread
Resolving indoubt units of recovery
Resolution of IMS indoubt units of recovery
Resolution of CICS indoubt units of recovery
Resolution of RRS indoubt units of recovery
Resolving WebSphere Application Server indoubt units of recovery
Resolving remote DBMS indoubt units of recovery
Determining the coordinator's commit or abort decision
Recovering indoubt threads
Resetting the status of an indoubt thread
Backing up and recovering your data
Plans for backup and recovery
Plans for recovery of distributed data
Plans for extended recovery facility toleration
Plans for recovery of indexes
Preparation for recovery: a scenario
Events that occur during recovery
Complete recovery cycles
A recovery cycle example when using image copies
How DFSMShsm affects your recovery environment
Tips for maximizing data availability during backup and recovery
Where to find recovery information
How to report recovery information
How to discard SYSCOPY and SYSLGRNX records
Preparations for disaster recovery
System-wide points of consistency
Recommendations for more effective recovery from inconsistency
Actions to take to aid in successful recovery of inconsistent data
Actions to avoid in recovery of inconsistent data
How to recover multiple objects in parallel
Automatic fast log apply during RECOVER
Recovery of page sets and data sets
Recovery of the work file database
Page set and data set copies
How to make concurrent copies using DFSMS
Backing up with RVA storage control or Enterprise Storage Server
System-level backups for object-level recoveries
Recovery of data to a prior point of consistency
Point-in-time recovery with system-level backups
Point-in-time recovery using the RECOVER utility
Implications of moving data sets after a system-level backup
Recovery of table spaces
Recovery of partitioned table spaces
Recovery of segmented table spaces
Recovery of LOB table spaces
Recovery of XML table spaces
Recovery of table space sets
Recovery of partition-by-growth table spaces
Recovery of indexes
Recovery of indexes on altered tables
Recovery of indexes on tables in partitioned table spaces
Preparing to recover to a prior point of consistency
Identifying objects to recover
Resetting exception status
Copying the data
Establishing a point of consistency
Preparing to recover an entire DB2 subsystem to a prior point in time using image copies or object-level backups
Creating essential disaster recovery elements
Resolving problems with a user-defined work file data set
Resolving problems with DB2-managed work file data sets
Recovering error ranges for a work file table space
Recovery of error ranges for a work file table space
Recovering after a conditional restart of DB2
Recovery of the catalog and directory
Regenerating missing identity column values
Recovery of tables that contain identity columns
Recovering a table space and all of its indexes
Recovery implications for objects that are not logged
Clearing the informational COPY-pending status (ICOPY)
The LOG option of LOAD or REORG
Clearing the RECOVER-pending status
Removing various pending states from LOB and XML table spaces
Restoring data by using DSN1COPY
Backing up and restoring data with non-DB2 dump and restore
Recovering accidentally dropped objects
How to avoid accidentally dropping objects
Recovering an accidentally dropped table
Recovering an accidentally dropped table space
Recovering accidentally dropped DB2-managed data sets
Recovering accidentally dropped user-managed data sets
Recovering your DB2 system to a given point in time by using the RESTORE SYSTEM utility
Options for restoring data to a previous point-in-time
Plans for point-in-time recovery
Data consistency for point-in-time recoveries
The RECOVER TOLOGPOINT option in a data sharing system
The RECOVER TOLOGPOINT option in a non-data sharing system
Recommendations for recovery of compressed data
Recovering by using DB2 restart recovery
Recovering by using FlashCopy backups
Making catalog definitions consistent with your data after recovery to a prior point in time
Recovery of catalog and directory tables
Performing remote site recovery from a disaster at a local site
Recovering with BACKUP SYSTEM
Recovering without BACKUP SYSTEM
Backup and recovery involving clone tables
Data restore of an entire system
Reading log records
Contents of the log
Unit of recovery log records
Database exception table records
Typical unit of recovery log records
Classes of changes to data
Checkpoint log records
Database page set control records
Other exception information
The physical structure of the log
Physical and logical log records
The log record header
The log control interval definition (LCID)
Log record type codes
Log record subtype codes
Interpreting data change log records
Reading log records with IFI
Reading log records into a buffer
Reading specific log records (IFCID 0129)
Reading complete log data (IFCID 0306)
Specifying the return area
Qualifying log records
Reading log records with OPEN, GET, and CLOSE
JCL DD statements for DB2 stand-alone log services
Data sharing members that participate in a read
Registers and return codes
Stand-alone log OPEN request
Stand-alone log GET request
Stand-alone log CLOSE request
Sample application that uses stand-alone log services
Reading log records with the log capture exit routine
Exit routines
Connection routines and sign-on routines
Specifying connection and sign-on routines
Sample connection and sign-on routines
When connection and sign-on routines are taken
Exit parameter list for connection and sign-on routines
Authorization ID parameter list for connection and sign-on routines
Input values for connection routines
Input values for sign-on routines
Expected output for connection and sign-on routines
Processing in sample connection and sign-on routines
Performance considerations for connection and sign-on routines
Debugging connection and sign-on routines
Session variables in connection and sign-on routines
Access control authorization exit routines
Specifying access control authorization routines
The default access control authorization routine
When access control authorization routines are taken
Considerations for access control authorization routines
When DB2 cannot provide an ACEE
Authorization IDs and ACEEs
Invalid and inoperative plans and packages
Using BINDAGENT
Dropping views
Caching of EXECUTE on plans, packages, and routines
Caching of dynamic SQL statements
Resolution of user-defined functions
Creating materialized query tables
&