Application Development Guide

Index

Special Characters
Numerics
A B C D E F G H I J K L M N O P Q R S T U V W X

Special Characters

#ifdefs, C/C++ language restrictions (7223)

#include macro, C/C++ language restrictions (7173)

#line macros, C/C++ language restrictions (7174)

Numerics

64-bit integer (BIGINT) data type

supported by DB2 Connect Version 7 (8096)

access to data consideration

DB2 Call Level Interface (DB2 CLI) (5231)

embedded SQL (5227)

JDBC (5235)

Microsoft specifications (5237)

ODBC (5233)

REXX (5229)

using Perl (5252)

using query products (5254)

ACQUIRE statement (8200)

activation time and triggers (6645)

ActiveX Data Object specification

supported in DB2 (5239)

add database wizard (8259)

ADD METHOD (5922)

ADHOC.SQC C program listing (5634)

ADO specification

supported in DB2 (5240)

AFTER triggers (6647), (6663)

aggregating functions (6160)

alerts, supported by triggers (6621)

allocating dynamic memory in a UDF (6560)

ALLOW PARALLEL clause (6383)

ALTER NICKNAME statement

column options (7040)

data type mappings (7056)

altering view (5992)

ambiguous cursors (8127)

APPC, handling interrupts (5557)

application design

access to data (5224)

binding (5331)

character conversion considerations (6713)

character conversion in SQL statements (6715)

character conversions in stored procedures (6721)

COBOL Japanese and traditional Chinese EUC considerations (7689)

COBOL requirements, include files (7533)

code points for special characters (6717)

coding a DB2 application,overview (5140)

creating SQLDA structure, guidelines (5615)

cursor processing, considerations (5483)

data relationship (5270)

data value control consideration (5256)

declaring sufficient SQLVAR entities (5604)

describing SELECT statement (5610)

double-byte character support (DBCS) (6718)

dynamic SQL caching (5401)

error handling, guidelines (5548)

executing statements without variables (5573)

guidelines (5220)

input-SQLDA procedure, sample of (8039)

input-SQLDA stored procedure, sample of (8044)

logic at the server (5279)

OLE automation UDFs (6389)

package renaming (5361)

passing data, guidelines (5619)

precompiling and binding (5330)

receiving database values (5427)

retrieving data a second time (5515)

REXX requirements, registering routines (7863)

sample programs (5524)

saving end user requests (5629)

static SQL, advantages of using (5399)

table function considerations (6529)

use of dynamic SQL, overview of (5567)

using LOB locators in UDFs (6538)

using parameter markers (5637)

varying-list statements, processing of (5627)

application domain and object-orientation (5823)

application environment, for programming (5143)

application forms using CREATE TABLE example (5864)

application logic

data relationship consideration (5278)

data value control consideration (5268)

application logic consideration

stored procedures (5282)

triggers (5286)

user-defined functions (5284)

Application Program Interface (API)

for JDBC applications (7521)

for setting contexts between threads

sqleAttachToCtx() (6882)

sqleBeginCtx() (6880)

sqleDetachFromCtx() (6883)

sqleEndCtx() (6881)

sqleGetCurrentCtx() (6884)

sqleInterruptCtx() (6885)

sqleSetTypeCtx() (6879)

overview of (5299)

restrictions in an XA environment (6928)

syntax for REXX (7936)

types of (5300)

uses of (5301)

argument types, promotions in UDFs (6322)

arguments between UDFs and DB2 (6216)

call-type (6252)

dbinfo (6274)

diagnostic-message (6244)

function-name (6238)

scratchpad (6247)

specific-name (6241)

SQL-argument (6218)

SQL-argument-ind (6226)

SQL-result (6220)

SQL-result-ind (6230)

SQL-state (6235)

arguments, passing from DB2 to a UDF (6213)

ARI (DB2 for VSE & VM) (8112)

arithmetic error

in UDFs (6232)

AS LOCATOR clause (6541)

ASCII

mixed-byte data (8083)

sort order (8154)

assignments in dynamic SQL example (5879)

assignments involving different distinct types example (5881)

assignments involving distinct types example (5877)

asynchronous events (6870), (6873)

asynchronous nature of buffered insert (6969)

ATOMIC compound SQL

not supported in DB2 Connect (8191)

attributes (5886)

automation server, for OLE (6397)

AVG over a UDT example (6179)

back up database wizard (8261)

backing out changes (5205)

BASIC language

implementation of OLE automation UDF (6400)

BASIC types and OLE automation types (6414)

BEFORE triggers (6646), (6662)

BEGIN DECLARE SECTION (5155)

beginning transactions (5194)

BigDecimal Java type (7382)

BIGINT parameter to UDF (6326)

BIGINT SQL data type (5438)

C/C++ (7270)

COBOL (7640)

FORTRAN (7797)

Java (7360)

Java stored procedures (DB2GENERAL) (8014)

OLE DB table function (6502)

BINARY data types in COBOL (7626)

Binary Large Objects (6066) See also BLOBs (Binary Large Objects)

BIND API (5385)

BIND API, creating packages (5357)

bind file

precompile options (5343)

support to REXX applications (7929)

bind files

backwards compatibility (5375)

bind files for REXX (7927)

bind option

INSERT BUF (6963)

bind options

EXPLSNAP (5378)

FUNCPATH (5379)

QUERYOPT (5377)

BIND PACKAGE command

rebinding (5394)

binding

bind file description utility, db2bfd (5386)

considerations (5374)

deferring (5384)

dynamic statements (5362)

options for (5355)

overview of (5356)

blob C/C++ type (7303)

BLOB FORTRAN type (7823)

BLOB parameter to UDF (6352)

BLOB SQL data type (5448), (6435)

C/C++ (7281)

COBOL (7651)

FORTRAN (7808)

Java (7371)

Java stored procedures (DB2GENERAL) (8025)

OLE DB table function (6513)

REXX (7914)

BLOB-FILE COBOL type (7666)

BLOB-LOCATOR COBOL type (7665)

BLOBs (Binary Large Objects)

uses and definition (6063)

blob_file C/C++ type (7305)

BLOB_FILE FORTRAN type (7825)

blob_locator C/C++ type (7304)

BLOB_LOCATOR FORTRAN type (7824)

blocking (8126)

books (8231), (8244)

BSTR OLE automation type (6466)

buffer size for buffered insert (6946)

buffered insert

advantages (6959)

asynchronous nature of (6968)

buffer size (6947)

closed state (6977)

considerations for using (6967)

deadlock errors (6985)

error detection during (6970)

error reporting in buffered insert (6982)

group of rows (6971)

INSERT BUF bind option (6961)

long field restriction (6991)

not supported in CLP (6995)

open state (6978)

overview (6944)

partially filled (6948)

restrictions on using (6989)

savepoint consideration (5687), (6950)

SELECT buffered insert (6975)

statements that close (6952)

transaction log consideration (6966)

unique key violation (6987)

C language type definitions in sqludf.h (6361)

C null-terminated graphic string SQL data type (6434)

C null-terminated string SQL data type (6433)

C++

consideration for stored procedures (5760)

considerations for UDFs (6589)

type decoration consideration (7105)

C++ types and OLE automation types (6415)

C/C++ data types

blob (7326)

blob_file (7328)

blob_locator (7327)

char (7320)

clob (7323)

clob_file (7325)

clob_locator (7324)

dbclob (7331)

dbclob_file (7333)

dbclob_locator (7332)

double (7319)

float (7318)

long (7313)

long int (7314)

long long (7315)

long long int (7317)

null-terminated character form (7330)

short (7311)

short int (7312)

sqldbchar (7321)

sqlint64 (7316)

VARCHAR structured form (7329)

wchar_t (7322)

C/C++ language

character set (7100)

Chinese (Traditional) EUC considerations (7259)

data types supported (7264)

declaring graphic host variables (7206)

declaring host variables (7196)

embedding SQL statements (5321)

file reference declarations (7217)

handling class data members (7231)

handling null-terminated strings (7226)

host variable, naming (7192)

include files, required (7112)

initializing host variables (7220)

input and output files (7109)

Japanese EUC considerations (7260)

LOB data declarations (7209)

LOB locator declarations (7214)

member operator, restriction (7237)

pointer to data type, declaring in C/C++ (7228)

programming restrictions in (7098)

qualification operator, restriction (7236)

supported data types (7262)

trigraph sequences (7101)

Call Level Interface (CLI)

advantages of using (5662), (5664)

comparing embedded SQL and DB2 CLI (5649)

overview (5647)

CALL statement

in Java (7472)

initializing client for stored procedure (DB2DARI)

SQLDA structure (7960)

invoking a stored procedure (5705)

CALL statements

different platforms (8183)

CALL USING DESCRIPTOR statement (OS/400) (8187)

call-type (6534)

contents with scalar functions (6260)

contents with table functions (6266)

call-type, passing to UDF (6250), (6251)

calling convention

for UDFs (6311)

calling from a REXX application (7942)

calling the DB2 CLP from a REXX application (7940)

CARDINALITY specification in table functions (6537)

cascade (8164)

cascading triggers (6668)

CAST FROM clause (6222)

CAST FROM clause in the CREATE FUNCTION statement (6319)

castability (6138)

casting

UDFs (6204)

CHAR (6236)

char C/C++ type (7297)

CHAR parameter to UDF (6335)

CHAR SQL data type (5443), (6427)

C/C++ (7275)

COBOL (7645)

FORTRAN (7802)

Java (7365)

Java stored procedures (DB2GENERAL) (8019)

OLE DB table function (6507)

REXX (7908)

CHAR type (7508)

character comparison, overview (6691)

character conversion

coding SQL statements (6714)

coding stored procedures (6719), (6836)

during precompiling and binding (6722)

expansion (6732)

national language support (NLS) (6727)

programming considerations (6712)

rules for string conversions (6831)

string length overflow (6829)

string length overflow past data types (6833)

supported code pages (6731)

Unicode (UCS-2) (6839)

when executing an application (6723)

when occurs (6730)

character host variables

C/C++ fixed and null-terminated (7198)

C/C++ variable length (7200)

COBOL (7607)

fixed and null-terminated in C/C++ (7199)

FORTRAN (7774)

variable length in C/C++ (7201)

Character Large Objects (6067) See also CLOBs (Character Large Objects)

CHARACTER parameter to UDF (6336)

character sets

extended UNIX code (EUC) (6740)

character translation (8086)

CHARACTER*n FORTRAN type (7819)

CHECKERR REXX program listing (5565)

CHECKERR.CBL program listing (5564)

Chinese (Traditional)

double-byte considerations (6765)

Extended UNIX Code considerations (6764)

Chinese (Traditional) code sets (6743)

C/C++ considerations (7254)

developing applications using (6769)

Chinese (Traditional) EUC code sets

REXX considerations (7948)

CICS (8059)

CICS SYNCPOINT ROLLBACK command (6922)

classes

data members, as host variables in C/C++ (7233)

CLASSPATH environment variable (7487)

CLI (5648) See also Call Level Interface (CLI)

client applications

running stored procedures (5707)

client transforms

binding in instances from a client application (6048)

data type conversion considerations (6049)

implemented using external UDFs (6047)

overview of (6045)

client-based parameter validation

Extended UNIX Code consideration (6818)

client/server

code page conversion (6724)

clob C/C++ type (7300)

CLOB FORTRAN type (7820)

CLOB parameter to UDF (6353)

CLOB SQL data type (5449), (6436)

C/C++ (7282)

COBOL (7652)

FORTRAN (7809)

Java (7372)

Java stored procedures (DB2GENERAL) (8026)

OLE DB table function (6514)

REXX (7915)

CLOB-FILE COBOL type (7664)

CLOB-LOCATOR COBOL type (7663)

CLOBs (Character Large Objects)

uses and definition (6064)

clob_file C/C++ type (7302)

CLOB_FILE FORTRAN type (7822)

clob_locator C/C++ type (7301)

CLOB_LOCATOR FORTRAN type (7821)

CLOSE call (6269)

closed state, buffered insert (6979)

closing a buffered insert (6953)

COBOL

declaring host variables (7604)

embedding SQL statements (5324)

file reference declarations (7621)

include files, list of (7531)

indicator tables (7623)

input and output files (7530)

Japanese and traditional Chinese EUC considerations (7693)

LOB data declarations (7613)

LOB locator declarations (7618)

object oriented restrictions (7695)

restrictions in (7528)

rules for indicator variables (7611)

supported data types (7632)

COBOL data types

BINARY (7628)

BLOB (7677)

BLOB-FILE (7679)

BLOB-LOCATOR (7678)

CLOB (7674)

CLOB-FILE (7676)

CLOB-LOCATOR (7675)

COMP (7629)

COMP-1 (7671)

COMP-3 (7672)

COMP-4 (7630)

COMP-5 (7673)

DBCLOB (7680)

DBCLOB-FILE (7682)

DBCLOB-LOCATOR (7681)

PICTURE (PIC) clause (7669)

USAGE clause (7670)

COBOL language

data types supported (7634)

code page

allocating storage for unequal situations (6808)

binding considerations (5376)

character conversion (6725)

DB2CODEPAGE registry variable (6703)

handling expansion at application (6816)

handling expansion at server (6814)

in SQLERRMC field of SQLCA (8117)

locales

deriving in applications (6708)

how DB2 derives locales (6709)

national language support (NLS) (6726)

stored procedure considerations (5754)

supported Windows code pages (6704)

unequal situations (6737), (6801)

code point (6687)

code point, definition of (6683)

code set

in SQLERRMC field of SQLCA (8119)

coding Java UDFs (6369)

collating sequence

case independent comparisons (6693)

code point (6686)

EBCDIC and ASCII (8152)

EBCDIC and ASCII sort order example (6695)

identity sequence (6688)

include files

in COBOL (7559)

in FORTRAN (7732)

include files in C/C++ (7140)

multi-byte characters (6690)

overview of (6685)

samples of (6702)

simulating EBCDIC binary collation (8227)

sort order example (6694)

specifying (6696)

use in character comparisons (6692)

collation

Chinese (Traditional) code sets (6795)

Japanese code sets (6794)

collection ID attribute

DB2 Universal Database for AS/400 (8143)

package (8142)

COLLECTION parameters (5372)

collections (8144)

column

setting null values in (5430)

supported SQL data types (5435)

using indicator variables on nullable data columns (5471)

column functions (6159)

column options (5958)

ALTER NICKNAME statement (7039)

description (7037)

column types

creating (6019)

overview of (6018)

column types, creating in C/C++ (7265)

column types, creating in COBOL (7635)

column types, creating in FORTRAN (7793)

columns

derived (5668)

generated (5667)

identity (5670)

COM.ibm.db2.app.Blob (8034)

COM.ibm.db2.app.Clob (8035)

COM.ibm.db2.app.Lob (8033)

COM.ibm.db2.app.StoredProc (8031)

COM.ibm.db2.app.UDF (6378), (8032)

COM.ibm.db2.jdbc.app.DB2Driver (7412)

COM.ibm.db2.jdbc.net.DB2Driver (7413)

Command Line Processor (7941)

command line processor

prototyping utility (5316)

commands

EXCSQLSTT (8210)

FORCE (8122)

comments

SQL, rules for (7594), (7761)

comments, SQL, rules for (7185)

COMMIT statement (5148)

association with cursor (5487)

ending a transaction (5198)

ending transactions (5213)

pass-through (7085), (7093)

COMMIT WORK RELEASE statement

not supported (8214)

not supported in DB2 Connect (8213)

committing changes, tables (5201)

COMP and COMP-4 data types in COBOL (7627)

COMP-1 in COBOL types (7660)

COMP-3 in COBOL types (7661)

COMP-5 in COBOL types (7662)

comparisons involving distinct types example (5869), (5873)

compiled applications, creating packages for (5332)

compiling (5352)

compiling a UDF (6164)

completion code (5168) See also SQLCODE or SQLSTATE

compound SQL

NOT ATOMIC (8192)

condition handlers

example (5795)

overview (5791)

SQL procedures (5793)

configuration parameter

LOCKTIMEOUT (6911)

configure multisite update wizard (8263)

CONNECT

connect

application programs (5186)

CONNECT RESET statement (8104)

CONNECT TO statement (8103)

implicit connect (8106)

null CONNECT (8105)

sample programs (5529)

SQLCA.SQLERRD settings (6812)

CONNECT RESET statement

ending transactions (5215)

CONNECT statement (5147)

CONNECT TYPE 2

considerations with stored procedures (5769)

connecting DB2 application programs (5185)

connection handle (5655)

connection pooling in Java (7431)

consideration

access to data (5226)

application logic at server (5281)

data relationship control (5272)

data value control (5258)

DB2 application design (5223)

consistency

of data (5190)

consistency of data (5189)

consistent behavior and distinct types (5847)

constraint mechanisms on large objects (5843)

constructor functions (5909)

contexts

application dependencies between (6903)

database dependencies between (6900)

preventing deadlocks between (6908)

setting in multithreaded DB2 applications (6872)

control information to access large object data (6082)

conventions used in this book (5139)

CONVERT

WCHARTYPE

in stored procedures (5765)

coordinator node

behavior without buffered insert (6955)

cost of a UDT example (6178)

counter for UDFs example (6602)

counter OLE automation UDF object example in BASIC (6606)

counter OLE automation UDF object example in C++ (6607)

counting and defining UDFs example (6180)

counting with an OLE automation object (6182)

country code

in SQLERRMC field of SQLCA (8116)

creatable multi-use OLE automation server (6480)

creatable single-use OLE automation server (6479)

CREATE DATABASE API

SQLEDBDESC structure (6700)

create database wizard (8265)

CREATE DISTINCT TYPE statement

and castability (6140)

examples of using (5854)

to define a distinct type (5852)

CREATE FUNCTION MAPPING statement

estimating overhead of invoking functions (7079)

making data source functions known to federated server (7069)

reducing overhead of invoking functions (7073)

specifying function names (7080)

CREATE FUNCTION statement (6248), (6254), (6275), (6536), (6542)

CAST FROM clause (6317)

for OLE automation UDFs (6398)

in federated systems (7071)

Java UDFs (6384)

RETURNS clause (6318)

to register a UDF (6172)

CREATE METHOD (5923)

CREATE METHOD statement

to register a method (6173)

CREATE PROCEDURE statement (5712), (7480)

CREATE SERVER statement (6494)

CREATE STORGROUP statement

DB2 Connect support (8064)

create table space wizard (8269)

CREATE TABLE statement

defining column options in (5959)

defining LOB columns (6083)

examples of using (5860)

lob-options-clause (6084)

tablespace-options-clause (6085)

create table wizard (8267)

CREATE TABLESPACE statement

DB2 Connect support (8066)

CREATE TRIGGER statement

multiple triggers (6673)

order of trigger activation (6648)

overview (6627)

REFERENCING clause (6653)

CREATE TYPE

structured types (5898)

CREATE TYPE MAPPING statement (7052)

CREATE TYPE statement

MODE DB2SQL clause (5887)

REF USING clause (5899)

CREATE USER MAPPING statement (6498)

CREATE VIEW statement with

creating typed views (5977)

creating

Java stored procedures (7477)

Java UDFs (6364)

OLE automation UDFs (6392)

creating packages for compiled applications (5333)

creating typed views (5976)

creator attributes

package (8141)

critical section routine, in multiple threads, guidelines (6901)

critical sections (6905)

ctr() UDF C program listing (6603)

CURRENT EXPLAIN MODE register (5365)

CURRENT FUNCTION PATH register (5366)

CURRENT QUERY OPTIMIZATION register (5364)

cursor

ambiguous (5504)

completing a unit of work (5490)

declared WITH HOLD (5492)

declaring (5484)

FOR FETCH ONLY (5501)

issuing a COMMIT statement (5489)

naming and defining of (5479)

naming, in REXX (7873)

positioning at table end (5519)

processing with SQLDA structure (5614)

processing, in dynamic SQL (5588)

processing, sample program (5493), (5590)

processing, summary of (5477)

read only, application requirements for (5486)

read-only (5480), (5500)

retrieving multiple rows with (5474), (5481)

sample program (5506)

updatable (5503)

use in CLI (5650)

cursor stability (8170)

cursor usage in REXX (7922)

CURSOR.SQB COBOL program listing (5496)

CURSOR.SQC C program listing (5494)

Cursor.sqlj Java program listing (5495)

cursors

ambiguous (8129)

dynamic (8133)

unambiguous (8130)

cursors declared WITH HOLD

X/Open XA Interface (6924)

data

avoiding bottlenecks when extracting (6998)

extracting large volumes (6997)

data control language (DCL) (8098)

Data Definition Language (DDL)

data definition language (DDL) (8062)

issuing in savepoints (5685)

data manipulation language (DML) (8069)

data relationship consideration

application logic (5277)

referential integrity (5273)

triggers (5275)

data sources in federated systems

accessing tables, views (7027)

invoking functions (7065)

mapping data types from (7049)

mapping DB2 functions to (7066)

mapping isolation levels to (7045)

using distributed requests to query (7058)

using pass-through to query (7082)

data structure

allocating for stored procedures (5701)

manipulating for DB2DARI stored procedure (7968)

SQLEDBDESC (6699)

user-defined, with multiple threads (6894)

data structures, declaring (5146)

data transfer

updating (5522)

data type mappings (7048)

ALTER NICKNAME statement (7055)

CREATE TYPE MAPPING statement (7053)

creating for data sources (7051)

creating for specific columns (7054)

default (7050)

data types

BLOBs (6077)

C/C++ (7261), (7266), (7336)

character conversion overflow (6834)

class data members, declaring in C/C++ (7230)

CLOB in C/C++ (7345)

CLOBs (6078)

conversion

between DB2 and COBOL (7637)

between DB2 and FORTRAN (7794)

between DB2 and OLE DB table function (6499)

conversion between DB2 and C/C++ (7267)

conversion between DB2 and OLE automation (6418)

conversion between DB2 and REXX (7901)

conversion considerations (6050)

data value control consideration (5260)

DBCLOBs (6079)

decimal

in FORTRAN (7838)

description (5157)

Extended UNIX Code consideration (6826)

FOR BIT DATA in C/C++ (7343)

FOR BIT DATA, in COBOL (7685)

how they are passed to a UDF (6315)

in C/C++ (7263)

in COBOL (7633)

in FORTRAN (7791)

Java (7356)

Java stored procedures (DB2GENERAL) (8011)

list of types and their representations in UDFs (6316)

numeric (8079)

object-oriented (5832)

OLE automation (6417)

pointer to, declaring in C/C++ (7227)

selecting graphic types (7243)

SQL column types, list of (5434)

supported

in COBOL (7631), (7636)

in COBOL, rules for (7684)

in FORTRAN (7789)

in FORTRAN, rules for (7841)

VARCHAR in C/C++ (7344)

data value control consideration

application logic and variable type (5267)

data types (5259)

referential integrity constraints (5263)

table check constraints (5261)

views with check option (5265)

database access

using different contexts (6869)

using multiple threads (6868)

database creation, specifying collating sequence (6697)

Database Descriptor Block (SQLEDBDESC), specifying collating sequences (6701)

database manager APIs

calling using stored procedures (5695)

defining, sample programs (5525)

DATE OLE automation type (6465)

DATE parameter to UDF (6349)

DATE SQL data type (5451), (6438)

C/C++ (7284)

COBOL (7654)

FORTRAN (7810)

Java (7374)

Java stored procedures (DB2GENERAL) (8028)

OLE DB table function (6516)

REXX (7917)

DB2 BIND command

creating packages (5358)

DB2 Call Level Interface (DB2 CLI)

access to data consideration (5232)

DB2 Connect (8053)

isolation level (8180)

DB2 Connect programming considerations (8055)

DB2 library

books (8230)

Information Center (8252)

language identifier for books (8235)

late-breaking information (8237)

online help (8245)

ordering printed books (8243)

printing PDF books (8240)

searching online information (8278)

setting up document server (8276)

structure of (8229)

viewing online information (8247)

wizards (8255)

DB2 PREP command

example of (5338)

overview of (5337)

DB2 program

set up (5150)

DB2 System Controller (5775)

DB2 Universal Database for AS/400

FOR BIT DATA stored procedure considerations (5758)

DB2 Universal Database for OS/390

FOR BIT DATA stored procedure considerations (5757)

DB2 using DB2 Connect (8050)

DB2Appl.java

application example (7418)

DB2ARXCS.BND REXX bind file (7930)

DB2ARXNC.BND REXX bind file (7934)

DB2ARXRR.BND REXX bind file (7931)

DB2ARXRS.BND REXX bind file (7933)

DB2ARXUR.BND REXX bind file (7932)

db2bfd, bind file dump utility (5387)

DB2CODEPAGE registry variable (6707)

db2dari executable (5749)

DB2DARI stored procedures (5736)

db2dclgn command (5418)

db2diag.log file (7006)

DB2GENERAL stored procedures (5737)

DB2INCLUDE environment variable (7177), (7599), (7757)

db2nodes.cfg file (7020)

db2udf executable (6587)

DB2Udf.java (6367)

DB2_SQLROUTINE_KEEP_FILES (5820)

DBCLOB

Chinese (Traditional) code sets (6791)

Japanese code sets (6790)

dbclob C/C++ type (7308)

DBCLOB parameter to UDF (6354)

DBCLOB SQL data type (5450), (6437)

C/C++ (7283)

COBOL (7653)

Java (7373)

Java stored procedures (DB2GENERAL) (8027)

OLE DB table function (6515)

REXX (7916)

DBCLOB type (7507)

DBCLOB-FILE COBOL type (7668)

DBCLOB-LOCATOR COBOL type (7667)

DBCLOBs (Double-Byte Character Large Objects)

uses and definition (6065)

dbclob_file C/C++ type (7310)

dbclob_locator C/C++ type (7309)

DBCS (6746) See also double-byte character set

dbinfo (6535)

DBINFO keyword (6276)

dbinfo, passing to UDF (6273)

dbminfo argument, elements of (6277)

(ver_rel) version/release number (6301)

application authorization ID (authid) (6284)

application authorization ID length (authidlen) (6282)

appl_id (unique application identifier) (6308)

authid (application authorization ID) (6285)

authidlen (application authorization ID length) (6283)

codepg (database code page) (6287)

colname (column name) (6299)

colnamelen (column name length) (6297)

column name (colname) (6298)

column name length (colnamelen) (6296)

data base name (dbname) (6280)

data base name length (dbnamelen) (6278)

database code page (codepg) (6286)

dbname (data base name) (6281)

dbnamelen (data base name length) (6279)

numtfcol (table function columns entries) (6304)

platform (6302)

schema name (tbschema) (6290)

schema name length (tbschemalen) (6288)

table function column list (tfcolumn) (6305)

table function columns entries (numtfcol) (6303)

table name (tbname) (6294)

table name length (tbnamelen) (6292)

tbname (table name) (6295)

tbnamelen (table name length) (6293)

tbschema (schema name) (6291)

tbschemalen (schema name length) (6289)

tfcolumn (table function column list) (6306)

unique application identifier (appl_id) (6307)

version/release number (ver_rel) (6300)

DCL (data control language) (8097)

DDL (data definition language) (8061)

deadlocks

error in buffered insert (6984)

in multithreaded applications (6906)

preventing in multiple contexts (6909)

debugging

Java programs (7401)

SQL procedures (5813), (5815), (5817)

SQLJ programs (7402)

stored procedures (5772), (5788)

using Stored Procedure Builder (7490)

using Visual Studio (5790)

debugging your UDF (6612)

DECIMAL parameter to UDF (6327)

DECIMAL SQL data type (5440), (6423)

C/C++ (7273)

COBOL (7643)

FORTRAN (7800)

Java (7363)

Java stored procedures (DB2GENERAL) (8017)

OLE DB table function (6505)

REXX (7906)

DECLARE CURSOR statement (5184)

DECLARE CURSOR statement, overview of (5478)

DECLARE PROCEDURE statement (OS/400) (8186)

declare section

creating with db2dclgn (5419)

in C/C++ (7193), (7334)

in COBOL (7602), (7683)

in FORTRAN (7770), (7840)

rules for statements (5417)

DECLARE STATEMENT

DECLARE statement (8202)

DB2 Connect support (8216)

declared temporary tables (5671)

declaring

host variable, rules for (5415)

indicator variables (5424)

deferring the evaluation of a LOB expression example (6101)

DELETE

DB2 Connect support (8076)

triggers (6651)

DELETE operation and triggers (6633)

DEREF function

definition (6000)

privileges required (6007)

dereference operator (5933)

dereference operators

queries using (5997)

derived columns (5666)

DESCRIBE statement (8206)

DB2 Connect support (8218)

double-byte character set consideration (6822)

Extended UNIX Code consideration (6821)

Extended UNIX Code consideration with EUC database (6823)

processing arbitrary statements (5624)

structured types (6059)

descriptor handle (5656)

designing DB2 applications, guidelines (5222)

DFT_SQLMATHWARN configuration parameter (6231)

diagnostic-message, passing to UDF (6243)

differences between different DB2 products (8060)

differences between host or AS/400 server and workstation (8199), (8212)

differences in SQLCODEs and SQLSTATEs (8172)

distinct type (6139)

distinct types

defining a distinct type (5851)

defining tables (5859)

manipulating

examples of (5865)

resolving unqualified distinct types (5853)

strong typing (5866)

distributed environment (8048)

distributed requests

coding (7059)

optimizing (7061)

distributed subsection (DSS) (6939)

divid() UDF C program listing (6593)

DML (data manipulation language) (8068)

double C/C++ type (7296)

double Java type (7380)

double OLE automation type (6464)

DOUBLE parameter to UDF (6329), (6332)

DOUBLE PRECISION parameter to UDF (6333)

DOUBLE SQL data type (5442), (6425)

Double-Byte Character Large Objects (6068) See also DBCLOBs (Double-Byte Character Large Objects)

double-byte character set

Chinese (Traditional) code sets (6775)

configuration parameters (6741)

considerations for collation (6792)

Japanese code sets (6774)

mixed code set environments (6796)

Traditional Chinese considerations (6767)

unequal code pages (6799)

double-byte character set (DBCS)

Chinese (Traditional) code sets (6752)

Japanese code sets (6751)

double-byte code pages (6760)

DROP statement

type mappings (5985)

user-defined types (5984)

dropping user-defined types (5983)

dropping view (5993)

DSN (DB2 Universal Database for OS/390) (8111)

DSS (distributed subsection) (6940)

DUOW (6845) See also multisite update

dynamic cursors (8132)

dynamic memory, allocating in the UDF (6567)

dynamic SQL

arbitrary statements, processing of (5622)

authorization considerations (5296)

comparing to static SQL (5584)

considerations (5585)

contrast with dynamic SQL (5397)

cursor processing (5589)

cursor processing, sample program (5591)

DB2 Connect support (8057)

declaring an SQLDA (5603)

EXECUTE IMMEDIATE statement, summary of (5572)

EXECUTE statement, summary of (5578)

limitations (5581)

overview (5566)

parameter markers in (5636)

PREPARE statement, summary of (5575)

supported statements, list of (5568)

syntax, differences with static (5580)

transform groups for structured types (6035)

using PREPARE, DESCRIBE, and FETCH (5586)

dynamic statements

binding (5363)

dynamic types (5940)

DYNAMIC.CMD REXX program listing (5599)

Dynamic.java Java program listing (5595)

DYNAMIC.SQB COBOL program listing (5597)

DYNAMIC.SQC C program listing (5593)

easier maintenance using triggers (6625)

EBCDIC

mixed-byte data (8082)

sort order (8153)

embedded SQL

access to data consideration (5228)

embedded SQL statement

comments, rules for (7186)

examples of (5327)

overview of (5320)

rules for, in C/C++ (7184)

rules for, in COBOL (7593)

rules for, in FORTRAN (7760)

syntax rules (5325)

embedded SQL statements

comments, rules for (7595), (7762)

host variable, referencing in (5423)

encapsulation and distinct types (5848)

END DECLARE SECTION (5156)

ending transactions (5196)

ending transactions implicitly (5217)

environment APIs

include file for C/C++ (7135)

include file for COBOL (7553)

include file for FORTRAN (7729)

environment handle (5654)

environment,for programming (5141)

error code (5167) See also SQLCODE or SQLSTATE

error detection in a buffered insert (6973)

error handling

C/C++ language precompiler (7179)

considerations in a partitioned environment (7001)

during precompilation (5344)

identifying partition that returns the error (7018)

in a looping application (7021)

in a suspended application (7022)

include file

for FORTRAN (7720), (7751)

in COBOL (7543), (7546), (7580)

include file for C/C++ (7155), (7158)

merged multiple SQLCA structures (7008)

overview of (5535)

reporting (7011)

resetting (5176)

SQLCA structure (7012)

SQLCODE (7013)

using WHENEVER statement (5550)

WHENEVER statement (5173)

with the SQLCA (5162)

error messages

error conditions flag (5543)

exception condition flag (5542)

SQLCA structure (5538)

SQLSTATE (5545)

SQLWARN structure (5547)

timestamps, when precompiling (5392)

warning condition flag (5541)

EUC (6744) See also Extended UNIX Code

EUC (extended UNIX code)

character sets (6739)

examples

ADHOC.SQC C program listing (5633)

application forms using CREATE TABLE (5862)

assignments in dynamic SQL (5878)

assignments involving different distinct types (5880)

assignments involving distinct types (5876)

BLOB data declarations (7210)

CLOB data declarations (7211)

CLOB file reference (7218)

CLOB locator (7215)

comparisons involving distinct types (5868), (5872)

DB2Appl.java (7417)

DBCLOB data declarations (7212)

declaring BLOB file references using COBOL (7622)

declaring BLOB file references using FORTRAN (7788)

declaring BLOB locator using COBOL (7619)

declaring BLOBs using COBOL (7614)

declaring BLOBs using FORTRAN (7781)

declaring CLOB file locator using FORTRAN (7785)

declaring CLOBs using COBOL (7615)

declaring CLOBs using FORTRAN (7782)

declaring DBCLOBs using COBOL (7616)

deferring the evaluation of a LOB expression (6100)

DYNAMIC.CMD REXX program listing (5598)

Dynamic.java Java program listing (5594)

DYNAMIC.SQB COBOL program listing (5596)

DYNAMIC.SQC C program listing (5592)

extracting a document to a file (CLOB elements in a table) (6121)

inserting data into a CLOB column (6127)

Java applets (7421)

LOBEVAL.SQB COBOL program listing (6106)

LOBEVAL.SQC C program listing (6104)

LOBFILE.SQB COBOL program listing (6125)

LOBFILE.SQC C program listing (6123)

LOBLOC.SQB COBOL program listing (6098)

LOBLOC.SQC C program listing (6096)

money using CREATE DISTINCT TYPE (5855)

registering SQLEXEC, SQLDBS and SQLDB2 (7866)

registering SQLEXEC, SQLDBS and SQLDB2 for REXX (7865)

resume using CREATE DISTINCT TYPE (5856)

sales using CREATE TABLE (5861)

sample SQL declare section for supported SQL data types (7335)

syntax for character host variables in FORTRAN (7775), (7776)

use of distinct types in UNION (5882)

user-defined sourced functions on distinct types (5874)

using a locator to work with a CLOB value (6094)

using class data members in an SQL statement (7234)

using parameter markers in search and update (5640)

V5SPCLI.SQC C program listing (8040)

V5SPSRV.SQC C program listing (8045)

Varinp.java Java program listing (5643)

VARINP.SQB COBOL program listing (5645)

VARINP.SQC C program listing (5641)

EXCSQLSTT command (8209)

EXEC SQL INCLUDE SQLCA

multithreading considerations (6898)

EXEC SQL INCLUDE statement, C/C++ language restrictions (7172)

EXECUTE IMMEDIATE statement, summary of (5571)

EXECUTE statement, summary of (5577)

execution requirements for REXX (7925)

exit routines, use restrictions (5560)

expansion of data on the host or AS/400 server (8085)

Explain Snapshot (5383)

EXPLAIN, prototyping utility (5317)

EXPLSNAP bind option (5381)

exponentiation and defining UDFs example (6174)

extended dynamic SQL statements

not supported in DB2 Connect (8226)

Extended UNIX Code (EUC)

extended UNIX code (EUC)

character conversion overflow (6827)

character conversions in stored procedures (6835)

character sets (6738)

character string length overflow (6832)

Chinese (Traditional) code sets (6750), (6771)

Chinese (Traditional) in C/C++ (7255)

Chinese (Traditional) in REXX (7950)

client-based parameter validation (6817)

considerations for collation (6793)

considerations for DBCLOB files (6789)

double-byte code pages (6762)

expansion at application (6815)

expansion at server (6813)

expansion samples (6819)

fixed or varying length data types (6824)

graphic constants (6779)

graphic data handling (6776)

Japanese and traditional Chinese

COBOL consideration (7691)

FORTRAN consideration (7846)

Japanese code sets (6749), (6770)

Japanese in C/C++ (7256)

Japanese in REXX (7949)

mixed code pages (6761)

mixed code set environments (6797)

rules for string conversions (6830)

stored procedures considerations (6786)

Traditional Chinese considerations (6766)

UDF considerations (6782)

unequal code pages (6800)

using the DESCRIBE statement (6820)

extensibility and distinct types (5845)

extern declaration

C++ (7107)

EXTERNAL ACTION option and UDFs (6570)

EXTERNAL clause (5724)

EXTERNAL NAME clause (6489), (6493)

extracting

large volumes of data (6996)

extracting a document to a file (CLOB elements in a table) example (6122)

faster application development using triggers (6623)

federated systems

column options (7038)

data integrity (7044)

data source functions (7064)

data source tables, views

cataloging information about (7033)

considerations, restrictions (7035)

nicknames for (7031)

data type mappings (7046)

distributed requests (7057)

function mapping options (7077)

function mappings (7067)

introduction (7026)

isolation levels (7043)

nicknames (7030)

pass-through (7081)

server options (7060)

FENCED option and UDFs (6571)

FETCH call (6270)

FETCH statement

host variables (5587)

repeated access, technique for (5513)

scroll backwards, technique for (5510)

using SQLDA structure with (5611)

file extensions

sample programs (7959)

file reference declarations in REXX (7897)

file reference variables

examples of using (6120)

for manipulating LOBs (6074)

input values (6111)

output values (6115)

FINAL CALL clause (6271)

FINAL CALL keyword (6255)

final call, to a UDF (6258)

finalize Java method (6382)

find the vowel, fold the CLOB for UDFs example (6597)

findvwl() UDF C program listing (6600)

FIPS 127-2 standard (5170)

FIRST call (6268)

first call, to a UDF (6259)

fixed or varying length data types

Extended UNIX Code consideration (6825)

flagger utility, used in precompiling (5351)

flexibility and distinct types (5846)

float C/C++ type (7295)

float OLE automation type (6463)

FLOAT parameter to UDF (6334)

FLOAT SQL data type (5439), (6422)

C/C++ (7271)

COBOL (7641)

FORTRAN (7798)

Java (7361)

Java stored procedures (DB2GENERAL) (8015)

OLE DB table function (6503)

REXX (7904)

floating point parameter to UDF (6330)

flushed buffered insert (6949)

fold() UDF C program listing (6599)

FOR BIT DATA

considerations for stored procedures (5756)

data type in C/C++ (7346)

FOR BIT DATA modifier in UDFs (6337)

FOR BIT DATA SQL data type (6428)

FOR EACH ROW trigger (6640)

FOR EACH STATEMENT trigger (6641)

FOR UPDATE clause (5497)

FORCE command (8121)

foreign key (8162)

FORTRAN

data types supported (7790), (7839)

embedding SQL statements (5322)

file reference declarations (7787)

host variables, overview (7767)

indicator variables, rules for (7778)

input and output files (7702)

Japanese and traditional Chinese EUC considerations (7848)

LOB data declarations (7780)

LOB locator declarations (7784)

programming considerations (7697)

programming restrictions (7700)

referencing host variables (7765)

FORTRAN data types

BLOB (7835)

BLOB_FILE (7837)

BLOB_LOCATOR (7836)

CHARACTER*n (7831)

CLOB (7832)

CLOB_FILE (7834)

CLOB_LOCATOR (7833)

INTEGER*2 (7826)

INTEGER*4 (7827)

REAL*2 (7828)

REAL*4 (7829)

REAL*8 (7830)

FORTRAN language

data types supported (7792)

FROM SQL transforms (6036)

fullselect

buffered insert consideration (6992)

fullselect consideration (6993)

fully qualified name (6490)

FUNCPATH bind option (5382)

function directory (5725)

function invocations example (6189)

function mappings

CREATE FUNCTION MAPPING statement (7068), (7072)

options (7078)

function path and UDFs (6147)

function references

summary for UDFs (6197)

function selection algorithm and UDFs (6149)

function templates (7070)

function transforms

implemented as SQL-bodied routines (6042)

overview of (6041)

passing parameters to external routines (6043)

function-name, passing to UDF (6237)

functions

aggregating functions (6156)

column functions (6155)

scalar functions (6154)

syntax for referring to (6188)

table functions (6157)

with SQL triggered statements (6666)

GENERAL stored procedures (5733)

GENERAL WITH NULLS stored procedures (5734)

generated columns (5665)

GET ERROR MESSAGE API (5561), (7881)

getAsciiStream JDBC method (7519)

getString JDBC method (7518)

getUnicodeStream JDBC method (7520)

global enforcement of business rules using triggers (6624)

GRANT statement

DB2 Connect support (8099)

issuing on table hierarchies (5955)

graphic constants

Chinese (Traditional) code sets (6781)

Japanese code sets (6780)

graphic data

Chinese (Traditional) code sets (6756), (6778)

Japanese code sets (6755), (6777)

graphic data types

selecting (7244)

graphic host variables

C/C++ (7207)

COBOL (7608)

GRAPHIC parameter to UDF (6340)

GRAPHIC SQL data type

C/C++ (7278)

COBOL (7648)

FORTRAN, not supported in (7805)

Java (7368)

Java stored procedures (DB2GENERAL) (8022)

OLE DB table function (6510)

REXX (7911) See also VARGRAPHIC SQL data type

graphic strings

character conversion (6736)

GRAPHIC type (7506)

graphical objects

considerations for Java (7503)

GROUP BY clause

sort order (8156)

group of rows

in buffered insert (6972)

guideline

access to data (5225)

application logic at server (5280)

data relationship control (5271)

data value control (5257)

DB2 application design (5221)

handle

connection handle (5658)

descriptor handle (5659)

environment handle (5657)

statement handle (5653)

handlers

example (5796)

overview (5792)

hierarchy

structured types (5894)

holdability in SQLJ iterators (7460)

host or AS/400

accessing host servers (6867)

Host or AS/400 environment

programming (8049)

host variables

allocating in stored procedures (5699)

class data members, handling in C/C++ (7232)

clearing LOB host variables in REXX (7898)

considerations for stored procedures (5763)

declaring (5414)

in COBOL (7603)

in FORTRAN (7769), (7771)

declaring as pointer to data type (7229)

declaring graphic

in COBOL (7609)

declaring graphic in C/C++ (7205)

declaring in C/C++ (7195)

declaring structured types (6057)

declaring using db2dclgn (5420)

declaring using variable list statement (5628)

declaring, examples of (5421)

declaring, rules for (5416)

declaring, sample programs (5527)

definition (5411)

determining how to define for use with a column (5159)

file reference declarations in C/C++ (7216)

file reference declarations in COBOL (7620)

file reference declarations in FORTRAN (7786)

file reference declarations in REXX (7895)

FORTRAN, overview of (7766)

graphic data (7240)

in REXX (7876)

initializing for stored procedure (5698)

initializing in C/C++ (7219)

LOB data declarations in C/C++ (7208)

LOB data declarations in COBOL (7612)

LOB data declarations in FORTRAN (7779)

LOB data in REXX (7891)

LOB locator declarations in C/C++ (7213)

LOB locator declarations in COBOL (7617)

LOB locator declarations in FORTRAN (7783)

LOB locator declarations in REXX (7893)

multi-byte character encoding (7241)

naming

in COBOL (7601)

in FORTRAN (7768)

naming in C/C++ (7191)

naming in REXX (7877)

null-terminated strings, handling in C/C++ (7225)

referencing

in COBOL (7600)

in FORTRAN (7764)

referencing from SQL, examples (5422)

referencing in C/C++ (7190)

referencing in REXX (7878)

relating to an SQL statement (5158)

selecting graphic data types (7242)

static SQL (5413)

use in dynamic SQL (5569)

used to pass blocks of data (6935)

WCHARTYPE precompiler option (7249)

how to use this book (5138)

HTML

sample programs (8234)

HTML page

tagging for Java applets (7420)

IBM DB2 Universal Database Project Add-In for Microsoft Visual C++ (5288), (5291)

IBM DB2 Universal Database Tools Add-In for Microsoft Visual C++, activating (5292)

identity columns (5669)

identity sequence (6689)

implementing a UDF (6163)

implicit connect (8107)

IN stored procedure parameters (5717), (5741)

include file

C/C++ requirements for (7113)

COBOL requirements for (7532)

FORTRAN requirements for (7703)

SQL

COBOL (7535)

FORTRAN (7704)

SQL for C/C++ (7114)

SQL1252A

COBOL (7571)

FORTRAN (7744)

SQL1252B

COBOL (7572)

FORTRAN (7746)

SQLADEF for C/C++ (7117)

SQLAPREP

COBOL (7537)

FORTRAN (7707)

SQLAPREP for C/C++ (7119)

SQLCA

COBOL (7538)

FORTRAN (7708)

SQLCA for C/C++ (7120)

SQLCA_92

COBOL (7542)

FORTRAN (7715)

SQLCA_CN

FORTRAN (7709)

SQLCA_CS

FORTRAN (7710)

SQLCLI for C/C++ (7124)

SQLCLI1 for C/C++ (7126)

SQLCODES

COBOL (7545)

FORTRAN (7719)

SQLCODES for C/C++ (7127)

SQLDA

COBOL (7548)

FORTRAN (7721)

SQLDA for C/C++ (7129)

SQLDACT

FORTRAN (7722)

SQLE819A

COBOL (7558)

FORTRAN (7731)

SQLE819A for C/C++ (7138)

SQLE819B

COBOL (7561)

FORTRAN (7734)

SQLE819B for C/C++ (7141)

SQLE850A

COBOL (7563)

FORTRAN (7736)

SQLE850A for C/C++ (7143)

SQLE850B

COBOL (7565)

FORTRAN (7738)

SQLE850B for C/C++ (7145)

SQLE932A

COBOL (7567)

FORTRAN (7740)

SQLE932A for C/C++ (7147)

SQLE932B

COBOL (7569)

FORTRAN (7742)

SQLE932B for C/C++ (7149)

SQLEAU

COBOL (7549)

FORTRAN (7725)

SQLEAU for C/C++ (7131)

SQLENV

COBOL (7552)

FORTRAN (7728)

SQLENV for C/C++ (7134)

SQLETSD

COBOL (7555)

SQLEXT for C/C++ (7136)

SQLJACB for C/C++ (7151)

SQLMON

COBOL (7575)

FORTRAN (7748)

SQLMON for C/C++ (7154)

SQLMONCT

COBOL (7577)

SQLSTATE

COBOL (7579)

FORTRAN (7750)

SQLSTATE for C/C++ (7157)

SQLSYSTM for C/C++ (7159)

SQLUDF for C/C++ (7162)

SQLUTBCQ

COBOL (7582)

SQLUTBSQ

COBOL (7585)

SQLUTIL

COBOL (7588)

FORTRAN (7753)

SQLUTIL for C/C++ (7164)

SQLUV for C/C++ (7166)

SQLUVEND for C/C++ (7168)

SQLXA for C/C++ (7171)

include files

locating in C/C++ (7176)

locating in COBOL (7598)

locating in FORTRAN (7756)

INCLUDE SQLCA

pseudocode (5160)

INCLUDE SQLDA statement (5183)

INCLUDE SQLDA statement, creating SQLDA structure (5617)

INCLUDE statement (5182)

inconsistent data (5191)

inconsistent state (5192)

index extensions (5844)

index wizard (8271)

indicator tables, COBOL support for (7624)

indicator variables

declaring (5425)

examples (5473)

in C/C++, rules for (7203)

in COBOL, rules for (7610)

in FORTRAN, rules for (7777)

in REXX, rules for (7879)

using in DB2DARI stored procedures (7971)

using on nullable columns (5472)

indicator variables and LOB locators (6109)

infix notation and UDFs (6200)

Information Center (8253)

INHERIT SELECT PRIVILEGES clause (5952)

inheritance

controlling with ONLY clause (5951)

INOUT stored procedure parameters (5719)

INOUT stored procedure paramter (5744)

input and output files

C/C++ (7108)

COBOL (7529)

FORTRAN (7701)

input and output to screen and keyboard and UDFs (6585)

input file extensions, C/C++ language (7110)

INSERT BUF bind option

buffered inserts (6962)

INSERT operation and triggers (6631)

INSERT statement

DB2 Connect support (8072), (8090)

not supported in CLP (6994)

populating typed tables with (5965)

with VALUES clause (6957)

inserting data into a CLOB column example (6128)

inserts

without buffered insert (6954)

installing

Netscape browser (8250)

instances of object-oriented data types, storing (5838)

instantiability (5943)

Int Java type (7379)

INTEGER (6253)

integer divide operator for UDFs example (6592)

INTEGER or INT parameter to UDF (6325)

INTEGER SQL data type (5437), (6421)

C/C++ (7269)

COBOL (7639)

FORTRAN (7796)

Java (7359)

Java stored procedures (DB2GENERAL) (8013)

OLE DB table function (6501)

REXX (7903)

INTEGER*2 FORTRAN type (7814)

INTEGER*4 FORTRAN type (7815)

interactive SQL

processing, sample program (5631)

interrupt handling with SQL statements (5552)

interrupts, SIGUSR1 (5559)

invoking UDFs (6185)

IS OF predicate

restricting returned types with (6010)

ISO 10646 standard (6758)

ISO 2022 standard (6757)

ISO/ANS SQL92 (8146)

ISO/ANS SQL92 standard (5171)

isolation level (7042), (8179)

isolation levels (8181)

Japanese and traditional Chinese EUC code sets

COBOL considerations (7690)

FORTRAN considerations (7845)

Japanese code sets (6742)

C/C++ considerations (7253)

developing applications using (6768)

Japanese EUC code sets

REXX considerations (7947)

Java

applet support (7407)

application support (7406)

comparison of SQLJ with JDBC (7352)

comparison with other languages (7355)

connection pooling (7430)

debugging (7400)

distributing and running applets (7419)

distributing and running applications (7416)

embedding SQL statements (5323)

installing JAR files (7495), (7498)

JDBC 2.0 Optional Package API support (7425)

JDBC example program (7415)

JDBC specification (7404)

JNDI support (7427)

overview (7351)

overview of DB2 support for (7405)

SQLCODE (7391)

SQLJ (Embedded SQL for Java)

calling stored procedures (7474)

example program using (7469)

host variables (7471)

SQLJ (Embedded SQLJ for Java) (7435)

applets (7448)

db2profc (7442), (7443)

db2profp (7441)

declaring cursors (7467)

declaring iterators (7466)

embedding SQL statments in (7452)

example clauses (7453)

holdability (7462)

positioned DELETE statement (7465)

positioned UPDATE statement (7464)

profconv (7444)

restrictions (7449)

returnability (7463)

translator (7445)

SQLJ specification (7403)

SQLMSG (7392)

SQLSTATE (7393)

stored procedures (7494), (7497)

examples (7500)

Transaction API (JTA) (7432)

UDFs (user-defined functions) (7496), (7499)

examples (7501)

Java application

SCRATCHPAD consideration (6381)

signature for UDFs (6370)

using graphical and large objects (7502)

Java class files

CLASSPATH environment variable (7484)

java_heap_sz configuration parameter (7486)

jdk11_path configuration parameter (7485)

where to place (7483)

Java data types

BigDecimal (7387)

Blob (7390)

double (7386)

Int (7385)

java.math.BigDecimal (7388)

short (7384)

String (7389)

Java Database Connectivity (7409) See also JDBC

Java I/O streams

System.err (6374)

System.in (6372)

System.out (6373)

Java Naming and Directory Interface (JNDI) (7428)

Java packages and classes (7408)

COM.ibm.db2.app (7357)

JAVA stored procedures (5735)

Java UDF consideration (6212)

java.math.BigDecimal Java type (7381)

java_heap_sz configuration parameter (7489)

JDBC

1.22 drivers (7423)

2.0 Core API (7424)

2.0 drivers (7422)

2.0 Optional Package API (7426)

access to data consideration (5236)

COM.ibm.db2.jdbc.app.DB2Driver (7410)

COM.ibm.db2.jdbc.net.DB2Driver (7411)

comparison with SQLJ (7353)

example program using (7414)

getAsciiStream method (7513)

getString method (7512)

getUnicodeStream method (7514)

setAsciiStream method (7510)

setString method (7509)

setUnicodeStream method (7511)

SQLJ interoperability (7523)

jdk11_path configuration parameter (7488)

JNDI (Java Naming and Directory Interface) (7429)

JTA (Java Transaction API) (7433)

keys

foreign (8161)

primary (8160)

LABEL ON statement (8204)

LANGLEVEL precompile option

MIA (7337)

SAA1 (7338)

using SQL92E and SQLSTATE or SQLCODE variables (7350), (7688), (7844)

LANGLEVEL SQL92E precompile option (8145)

language identifier

books (8236)

LANGUAGE OLE clause (6399)

large object descriptor (6076)

large object value (6075)

latch

status with multiple threads (6875)

late-breaking information (8238)

limitations

stored procedures (DB2DARI) (7967)

linking

overview of (5353)

linking a UDF (6165)

LOB data type

supported by DB2 Connect Version 7 (8092)

LOB locator APIs, used in UDFs

sqludf_append API (6552)

sqludf_create_locator API (6553)

sqludf_free_locator API (6554)

sqludf_length API (6550)

sqludf_substr API (6551)

LOB locator example program listing (6605)

LOB locators

scenarios for using (6556)

used in UDFs (6539)

lob-options-clause of the CREATE TABLE statement (6086)

LOBEVAL.SQB COBOL program listing (6107), (6126)

LOBEVAL.SQC C program listing (6105), (6124)

LOBLOC.SQB COBOL program listing (6099)

LOBLOC.SQC C program listing (6097)

LOBs (Large Objects)

and DB2 object extensions (5833)

considerations for Java (7504)

file reference variables (6070)

examples of using (6119)

input values (6110)

output values (6114)

SQL_FILE_APPEND, output value option (6118)

SQL_FILE_CREATE, output value option (6116)

SQL_FILE_OVERWRITE, output value option (6117)

SQL_FILE_READ, input value option (6112)

large object descriptor (6072)

large object value (6069)

locators (6071), (6091)

example of using (6093), (6102)

indicator variables (6108)

programming scenarios (6103)

manipulating (5835)

programming options for values (6092)

storing (5834)

synergy with triggers, UDTs, and UDFs (6677)

local bypass (6942)

locales

deriving in application programs (6710)

how DB2 derives (6711)

locating include files

C/C++ (7175)

COBOL (7597)

FORTRAN (7755)

locators for manipulating LOBs (6073)

locking

buffered insert error (6983)

page-level (8165)

row-level (8166)

timeout (8167)

LOCKTIMEOUT configuration parameter (6910)

LOCKTIMEOUT multisite update configuration parameter (6855)

long C/C++ type (7290)

long field restriction

using buffered inserts (6990)

long fields (8089)

long int C/C++ type (7291)

long long C/C++ type (7292)

long long int C/C++ type (7294)

long OLE automation type (6462)

LONG VARCHAR

parameter to UDF (6339)

storage limits (6061)

LONG VARCHAR SQL data type (5445), (6430)

C/C++ (7277)

COBOL (7647)

FORTRAN (7804)

Java (7367)

Java stored procedures (DB2GENERAL) (8021)

OLE DB table function (6509)

REXX (7910)

LONG VARGRAPHIC

parameter to UDF (6346)

storage limits (6062)

LONG VARGRAPHIC SQL data type (5447), (6432)

C/C++ (7280)

COBOL (7650)

FORTRAN (7807)

Java (7370)

Java stored procedures (DB2GENERAL) (8024)

OLE DB table function (6512)

REXX (7913)

LONGVAR type (7505)

looping application

diagnosing (7023)

macro processing for the C/C++ language (7099)

macros in sqludf.h (6362)

mail OLE automation UDF object example in BASIC (6608)

manipulating large objects (5840)

maxdari configuration parameter (7482)

maximum size for large object columns, defining (6081)

member operator, C/C++ restriction (7238)

memory

decreasing requirement using LOB locators (6543)

memory allocation for unequal code pages (6806)

memory size, shared for UDFs (6574)

memory, allocating dynamic in the UDF (6566)

message file, definition of (5345)

method invocation

for OLE automation UDFs (6406)

methods

definition (6130)

implementing (6133)

invocation operator (5919)

invoking (5918)

rationale (6134)

registering (6171)

writing (6169), (6206)

MIA (7339)

Microsoft Exchange, used in mail example (6609)

Microsoft specifications

access to data consideration (5250)

ADO (ActiveX Data Object) (5245)

MTS (Microsoft Transaction Server) (5247)

RDO (Remote Data Object) (5246)

Visual Basic (5249)

Visual C++ (5248)

Microsoft Transaction Server specification

access to data consideration (5251)

Microsoft Visual C++

IBM DB2 Universal Database Project Add-In (5289)

mixed code set environments

application design (6798)

mixed Extended UNIX Code considerations (6759)

mixed-byte data (8080)

MODE DB2SQL clause (5889)

model for DB2 programming (5219)

modelling entities as independent objects (5824)

money using CREATE DISTINCT TYPE example (5857)

moving large objects using a file reference variable (6080)

multi-byte character support

code points for special characters (6716)

multi-byte code pages

Chinese (Traditional) code sets (6754), (6773)

Japanese code sets (6753), (6772)

multi-byte considerations

Chinese (Traditional) code sets in C/C++ (7258)

Chinese (Traditional) EUC code sets in REXX (7952)

Japanese and traditional Chinese EUC code sets

in COBOL (7692)

in FORTRAN (7847)

Japanese code sets in C/C++ (7257)

Japanese EUC code sets in REXX (7951)

multiple definitions of SQLCA, avoiding (5178)

multiple threads

application dependencies between contexts (6902)

database dependencies between contexts (6899)

guidelines (6893)

preventing deadlocks between contexts (6907)

using in DB2 applications (6871)

multiple triggers, ordering of (6672)

multisite update

coding SQL for a multisite update application (6848)

configuration parameters (6849)

considerations with stored procedures (5768)

DB2 Connect support (8196)

general considerations (6840)

overview (6846)

restrictions (6850)

support (8197)

when to use (6847)

multisite update configuration parameter

LOCKTIMEOUT (6856)

RESYNC_INTERVAL (6854)

SPM_LOG_NAME (6865)

SPM_NAME (6862)

SPM_RESYNC_AGENT_LIMIT (6860)

TM_DATABASE (6852)

TP_MON_NAME (6858)

mutator methods (5912)

national language support (NLS)

character conversion (6728)

code page (6729)

considerations (6682)

mixed-byte data (8081)

nested stored procedures (5748)

parameter passing (5803)

recursion (5807)

restrictions (5806)

returning result sets (5804)

SQL procedures (5802)

Netscape browser

installing (8251)

nicknames

cataloging related information (7032)

considerations, restrictions (7034)

CREATE NICKNAME statement (7036)

using with views (7041)

NOCONVERT

WCHARTYPE

in stored procedures (5766)

NOLINEMACRO

PREP option (7180)

nonexecutable SQL statements

DECLARE CURSOR (5181)

INCLUDE (5179)

INCLUDE SQLDA (5180)

normal call, to a UDF (6257)

NOT ATOMIC compound SQL (8190)

NOT DETERMINISTIC option and UDFs (6569)

NOT FENCED LOB locator UDFs (6555)

NOT FENCED stored procedures

considerations (5781), (5782)

precompiling (5778)

working with (5774)

NOT NULL CALL clause (6227)

NOT NULL CALL option and UDFs (6568)

NULL value

receiving, preparing for (5426)

null-terminated character form C/C++ type (7307)

null-terminator (7342)

numeric conversion overflows (8178)

numeric data types (8078)

numeric host variables

C/C++ (7197)

COBOL (7606)

FORTRAN (7773)

NUMERIC parameter to UDF (6328)

NUMERIC SQL data type (6426)

C/C++ (7274)

COBOL (7644)

FORTRAN (7801)

Java (7364)

Java stored procedures (DB2GENERAL) (8018)

OLE DB table function (6506)

REXX (7907)

object identifier columns (5903), (5904)

naming (5948)

object identifiers

choosing representation type for (5968)

creating constraints on (6016)

generating automatically (6015)

object instances

for OLE automation UDFs (6404)

Object Linking and Embedding (OLE) (6386) See also OLE automation UDFs

object oriented COBOL restrictions (7694)

object-orientation and UDFs (6137)

object-oriented extensions and distinct types (5850)

object-relational

application domain and object-orientation (5822)

constraint mechanisms (5830)

data types (5826)

definition (5821)

LOBs (5828)

triggers (5829)

UDTs and UDFs (5827)

why use the DB2 object extensions (5825)

observer methods (5915)

ODBC

access to data consideration (5234)

OLE automation data types (6419)

BSTR (6473)

DATE (6472)

double (6471)

float (6470)

long (6469)

SAFEARRAY (6474)

short (6468)

OLE automation object counting example (6181)

OLE automation server (6396)

OLE automation types (6408)

OLE automation types and BASIC types (6412)

OLE automation types and C++ types (6413)

OLE automation UDFs

creatable multi-use OLE automation server (6478)

creatable single-use OLE automation server (6477)

implementation (6390)

implementation in BASIC (6475)

implementation in C++ (6476)

object instances (6401)

scratchpad considerations (6402)

UDFs (6387)

OLE DB

supported in DB2 (5238)

table functions (6481)

CREATE SERVER statement (6492)

CREATE USER MAPPING statement (6496)

creating (6483)

defining a user mapping (6495)

EXTERNAL NAME clause (6488)

fully qualified names (6487)

identifying servers (6491)

using connection string (6486)

using CONNECTSTRING option (6484)

using server name (6485)

OLE keyword (6388)

OLE messaging example (6610)

OLE programmatic ID (progID) (6394)

online help (8246)

online information

searching (8280)

viewing (8249)

ONLY clause

restricting returned types with (6008)

open state, buffered insert (6976)

OPENFTCH.SQB COBOL program listing (5509)

OPENFTCH.SQC C program listing (5507)

Openftch.sqlj Java program listing (5508)

ORDER BY clause

sort order (8155)

OS/400 using DB2 Connect (8051)

OUT stored procedure parameters (5718), (5742)

OUTER keyword

returning subtype attributes with (6012)

output and input to screen and keyboard and UDFs (6586)

output file extensions, C/C++ language (7111)

overloading

function names (6148)

stored procedure names (5714)

owner attributes

package (8140)

package

attributes (8134)

creating (5354)

creating for compiled applications (5334)

renaming (5359)

support to REXX applications (7928)

timestamp errors (5391)

package attributes

creator (8137)

owner (8136)

qualifier (8135)

page-level locking (8168)

parameter markers (5651)

in functions example (6191)

in processing arbitrary statements (5625)

programming example (5639)

SQLVAR entries (5638)

use in dynamic SQL (5635)

partitioned environment

error handling considerations (7000)

identifying when errors occur (7017)

improving performance (6937)

severe error considerations (7003)

pass-through

COMMIT statement (7084), (7091)

considerations, restrictions (7086)

SET PASSTHRU RESET statement (7089)

SET PASSTHRU statement (7087)

SQL processing (7083)

passing contexts between threads (6878)

PDF (8241)

performance

dynamic SQL caching (5400)

factors affecting, static SQL (5398)

improving

using stored procedures (5692)

improving in partitioned environments (6936)

improving with buffered inserts (6945)

improving with directed DSS (6941)

improving with local bypass (6943)

improving with READ ONLY cursors (6938)

improving with read only cursors (5502)

increasing using LOB locators (6544)

large objects (6090)

NOT FENCED stored procedure (5773)

optimizing with packages (5388)

passing blocks of data (6933)

precompiling static SQL statements (5389)

UDFs (6136)

performance advantages

with buffered insert (6960)

performance and distinct types (5849)

performance configuration wizard (8273)

Perl

access to data consideration (5253)

PICTURE (PIC) clause in COBOL types (7658)

portability (5663)

porting applications (8054)

precompile option

WCHARTYPE NOCONVERT (5780)

precompiler

C/C++ #include macro (7097)

C/C++ character set (7103)

C/C++ language (7235)

C/C++ language debugging (7178)

C/C++ macro processing (7095)

C/C++ symbol substitution (7096)

C/C++ trigraph sequences (7102)

COBOL (7526)

DB2 Connect support (8063), (8124)

FORTRAN (7698)

options (5339)

overview of (5326)

supported languages (5144)

types of output (5340)

precompiling (5348)

accessing host or AS/400 application server through DB2 Connect (5347)

accessing multiple servers (5349)

example of (5336)

flagger utility (5350)

options, updatable cursor (5505)

overview of (5335)

supporting dynamic SQL statements (5570)

PREP option

NOLINEMACRO (7181)

PREPARE statement

DB2 Connect support (8220)

processing arbitrary statements (5623)

summary of (5574)

preprocessor functions and the SQL precompiler (7221)

prerequisites, for programming (5142)

primary key (8159)

printf() for debugging UDFs (6616)

printing PDF books (8242)

problem resolution

stored procedures (5787)

processing SQL statements in REXX (7870)

program variable type, data value control consideration (5269)

programmatic ID (progID) for OLE automation UDFs (6395)

programming considerations

accessing host or AS/400 servers (6866)

collating sequences (6680)

conversion between different code pages (6681)

in a host or AS/400 environment (8047)

in C/C++ (7094)

in COBOL (7525)

in FORTRAN (7696)

in REXX (7849)

national language support (6679)

programming in complex environments (6678)

X/Open XA interface (6913)

programming framework (5218)

protecting UDFs (6559)

prototyping SQL code (5315)

PUT statement

not supported in DB2 Connect (8222)

QSQ (DB2 Universal Database for AS/400) (8113)

qualification and member operators in C/C++ (7239)

qualifier attributes

different platforms (8139)

package (8138)

query products, access to data consideration (5255)

QUERYOPT bind option (5380)

RAISE_ERROR built-in function (6665)

RDO specification

supported in DB2 (5242)

re-entrant

stored procedures (5777)

UDFs (6523)

re-use and UDFs (6135)

REAL parameter to UDF (6331)

REAL SQL data type (5441), (6424)

C/C++ (7272)

COBOL (7642)

FORTRAN (7799)

Java (7362)

Java stored procedures (DB2GENERAL) (8016)

OLE DB table function (6504)

REXX (7905)

REAL*2 FORTRAN type (7816)

REAL*4 FORTRAN type (7817)

REAL*8 FORTRAN type (7818)

rebinding

description (5393)

REBIND PACKAGE command (5395)

REDEFINES in COBOL (7625)

REF USING clause (5900)

reference columns

assigning scope in typed views (5982)

defining the scope of (5961)

reference types

casting (5907)

choosing representation type for (5967)

comparing (5908), (5969)

definition (5901)

references

comparison with referential constraints (5935)

defining relationships using (5931)

dereference operator (5934)

REFERENCING clause in the CREATE TRIGGER statement (6654)

referential integrity (8158)

comparison to scoped references (5973)

data relationship consideration (5274)

referential integrity constraint

data value control consideration (5264)

registering

OLE automation UDFs (6393)

UDFs (6166)

registering Java stored procedures (7481)

release notes (8239)

RELEASE SAVEPOINT statement (5677)

releasing your connection

CMS applications (5200)

to DB2 (5203)

Remote Data Object specification

supported in DB2 (5241)

remote unit of work (6843)

renaming, package (5360)

REORGANIZE TABLE command (6763)

repeatable read, technique for (5512)

reporting errors (7014)

representation types (5905)

restore wizard (8275)

restoring data (5206)

restrictions

for UDFs (6572)

in C/C++ (7224)

in COBOL (7527)

in FORTRAN (7699)

in REXX (7856)

on using buffered inserts (6988)

restrictions for DB2DARI stored procedures (7966)

result code (5165) See also SQLCODE or SQLSTATE

RESULT REXX predefined variable (7884)

result sets

from stored procedures (5784)

returning from SQL procedures (5811)

resume using CREATE DISTINCT TYPE example (5858)

RESYNC_INTERVAL multisite update configuration parameter (6853)

retrieving

multiple rows (5476)

one row (5406)

rows (5499)

retrieving data

a second time (5516)

scroll backwards, technique for (5511)

updating (5523)

return code (5166) See also SQLCODE or SQLSTATE

SQLCA structure (5536)

returnability in SQLJ iterators (7461)

RETURNS clause in the CREATE FUNCTION statement (6320)

RETURNS TABLE clause (6221)

REVOKE statement

DB2 Connect support (8101)

issuing on table hierarchies (5954)

statement (8102)

REXX

access to data consideration (5230)

API syntax (7935)

bind files (7926)

calling the DB2 CLP from application (7939)

Chinese (Traditional) considerations (7954)

clearing LOB host variables (7899)

cursor identifiers (7874)

data types supported (7921)

execution requirements (7924)

indicator variables (7880), (7923)

initializing variables (7944)

Japanese considerations (7953)

LOB data (7892)

LOB file reference declarations (7896)

LOB locator declarations (7894)

predefined variables (7883)

programming considerations (7858)

registering routines in (7864)

registering SQLEXEC, SQLDBS and SQLDB2 (7859)

restrictions in (7857)

stored procedures in (7943)

supported SQL statements (7871)

REXX and C++ data types (7900)

REXX APIs

SQLDB2 (7852), (7937)

SQLDBS (7851)

SQLEXEC (7850)

ROLLBACK statement (5149), (8120)

association with cursor (5488)

backing out changes (5208)

ending transactions (5214)

restoring data (5209)

rolling back changes (5210)

ROLLBACK TO SAVEPOINT statement (5678)

ROLLBACK WORK RELEASE

not supported in DB2 Connect (8223)

rolling back changes (5207)

root types (5897)

row

order of in table, positioning (5520)

order of, controlling (5517)

retrieving multiple with cursor (5498)

retrieving one (5403)

retrieving using SQLDA (5612)

selecting one, with SELECT INTO statement (5405)

row blocking

customizing for performance (6932)

row-level locking (8169)

ROWID data type

supported by DB2 Connect Version 7 (8094)

rows

set of rows affected by triggers (6638)

RQRIOBLK field (8131)

rules that govern operations on large objects (5842)

run-time services

multiple threads, affect on latches (6874)

RUOW (6842) See also remote unit of work

SAA1 (7340)

SAFEARRAY OLE automation type (6467)

sales using CREATE TABLE example (5863)

sample programs

Application Program Interface (API) (7957)

cross-platform (8233)

embedded SQL statements (7956)

HTML (8232)

Java stored procedures (7479)

Java UDFs (6366)

location of (7958)

SAVEPOINT statement (5676)

savepoint, buffered insert consideration (6951)

savepoints (5674)

atomic compound SQL (5680)

blocking cursors (5688)

buffered inserts (5686)

Data Definition Language (5684)

nested (5681)

restrictions (5679)

SET INTEGRITY statement (5683)

triggers (5682)

XA transaction managers (5689)

scalar functions (6158)

contents of call-type argument (6261)

schema-name and UDFs (6151)

scoped references

comparison to referential integrity (5974)

scoping references (5963)

scratchpad and UDFs (6379), (6522)

SCRATCHPAD clause (6272)

scratchpad considerations

for OLE automation UDFs (6403)

SCRATCHPAD keyword (6249), (6256), (6380), (6524)

SCRATCHPAD option

for OLE automation UDFs (6405)

scratchpad, passing to UDF (6215), (6246)

searching

online information (8254), (8279)

section number (8208)

SELECT INTO statement

overview of (5404)

SELECT statement

association with EXECUTE statement (5579)

buffered insert consideration (6974)

DB2 Connect support (8070)

declaring an SQLDA (5602)

dereference operators in (5998)

describing, after allocating SQLDA (5609)

in DECLARE CURSOR statement (5482)

inheriting privileges from supertables (5953)

retrieving data a second time (5514)

retrieving multiple rows with (5475)

scoped references in (5999)

typed tables (5995)

updating retrieved data (5521)

varying-list, overview of (5626)

self-referencing tables (8163)

self-referencing typed tables (5972)

semantic behavior of stored objects (5841)

semaphores (6904)

serialization of data structures (6895)

serialization of SQL statement execution (6876)

server options (7062)

SET CURRENT FUNCTION PATH statement (6162)

SET CURRENT PACKAGESET statement (5373)

SET CURRENT statement

DB2 Connect support (8224)

SET PASSTHRU RESET statement (7090)

SET PASSTHRU statement (7088), (7092)

SET SERVER OPTION statement (7063)

setAsciiStream JDBC method (7516)

setString JDBC method (7515)

setting up a DB2 program (5151)

setting up document server (8277)

setUnicodeStream JDBC method (7517)

severe errors

considerations in a partitioned environment (7002)

shared memory size for UDFs (6573)

shift-out and shift-in characters (8084)

short C/C++ type (7288)

short int C/C++ type (7289)

short Java type (7378)

short OLE automation type (6461)

signal handlers

installing, sample programs (5528)

with SQL statements (5553)

SIGNAL SQLSTATE SQL statement to validate input data (6619)

signature, two functions and the same (6152)

SIGUSR1 interrupt (5558)

SIMPLE stored procedures (5731) See also GENERAL stored procedures

SIMPLE WITH NULLS stored procedures (5732) See also GENERAL WITH NULLS stored procedures

SMALLINT (6228), (6233)

SMALLINT parameter to UDF (6324)

SMALLINT SQL data type (5436), (6420)

C/C++ (7268)

COBOL (7638)

FORTRAN (7795)

Java (7358)

Java stored procedures (DB2GENERAL) (8012)

OLE DB table function (6500)

REXX (7902)

SmartGuides

wizards (8256)

snapshot monitor

diagnosing a suspended or looping application (7025)

solving problems

numeric conversion overflows (8177)

sort order

collating sequence (8151)

defining (8150)

sorting, specifying collating sequence (6698)

source file

creating, overview of (5329)

file name extensions (5342)

modified source file, definition of (5341)

requirements (5346)

SQL file extensions (5328)

source-level debuggers and UDFs (6615)

sourced UDF (5870)

special registers

CURRENT EXPLAIN MODE (5368)

CURRENT FUNCTION PATH (5369)

CURRENT QUERY OPTIMIZATION (5367)

specific-name, passing to UDF (6240)

SPM_LOG_SIZE multisite update configuration parameter (6863)

SPM_NAME multisite update configuration parameter (6861)

SPM_RESYNC_AGENT_LIMIT multisite update configuration parameter (6859)

SQL

authorization considerations (5294)

authorization considerations for dynamic SQL (5295)

authorization considerations for static SQL (5297)

authorization considerations using APIs (5298)

dynamically prepared (5661)

SQL arguments, passing from DB2 to a UDF (6214)

SQL Communications Area (SQLCA) (5163)

SQL Data Types

SQL data types (6409), (6416)

BIGINT (5456)

BLOB (5465), (6455)

CHAR (5460), (6447)

CLOB (5466), (6456)

COBOL (7657)

conversion to C/C++ (7287)

DATE (5468), (6458)

DBCLOB (5467), (6457)

DECIMAL (5458)

DOUBLE (6444)

FLOAT (5457), (6443)

FOR BIT DATA (6448)

FORTRAN (7813)

GRAPHIC (6451)

INTEGER (5455), (6442)

Java (7377)

LONG GRAPHIC (6452)

LONG VARCHAR (5462), (6450)

LONG VARGRAPHIC (5464), (6454)

NUMERIC (6446)

OLE DB table function (6519)

REAL (5459), (6445)

REXX (7920)

SMALLINT (5454), (6441)

TIME (5469), (6459)

TIMESTAMP (5470), (6460)

VARCHAR (5461), (6449)

VARGRAPHIC (5463), (6453)

SQL data types, passed to a UDF (6312)

SQL declare section (5152)

SQL include file

for C/C++ applications (7115)

for COBOL applications (7534)

for FORTRAN applications (7705)

SQL procedures

CALL statements in (5800)

condition handlers (5794)

debugging (5814), (5816), (5818)

dynamic SQL (5799)

log file (5819)

receiving result sets (5812)

recursion (5809)

RESIGNAL (5798)

restrictions (5808)

returning result sets (5805), (5810)

SIGNAL (5797)

SQL statement execution

serialization (6877)

SQL statements

C/C++ syntax (7183)

categories (8058)

COBOL syntax (7590), (7592)

DB2 Connect support (8198), (8211)

exception handlers (5556)

FORTRAN syntax (7759)

grouping using stored procedures (5694)

interrupt handlers (5555)

REXX syntax (7868)

saving end user requests (5630)

signal handlers (5554)

supported in REXX (7872)

SQL-argument (6262)

SQL-argument, passing to UDF (6217)

SQL-argument-ind (6263)

SQL-argument-ind, passing to UDF (6225)

SQL-result (6264), (6532)

SQL-result, passing to UDF (6219)

SQL-result-ind (6265), (6533)

SQL-result-ind, passing to UDF (6229)

SQL-state, passing to UDF (6234)

SQL/DS using DB2 Connect (8052)

SQL1252A include file

for COBOL applications (7570)

for FORTRAN applications (7743)

SQL1252B include file

for COBOL applications (7573)

for FORTRAN applications (7745)

SQL92 (8147)

SQLADEF include file

for C/C++ applications (7116)

SQLAPREP include file

for C/C++ applications (7118)

for COBOL applications (7536)

for FORTRAN applications (7706)

SQLCA

avoiding multiple definitions (5177)

error reporting in buffered insert (6980)

incomplete insert when error occurs (6981)

multithreading considerations (6896)

SQLERRMC field (8114), (8193)

SQLERRP field (8110)

SQLCA include file

for C/C++ applications (7122)

for COBOL applications (7540)

for FORTRAN applications (7711)

SQLCA predefined variable (7887)

SQLCA structure

defining, sample programs (5526)

include file

for COBOL applications (7539)

for FORTRAN applications (7712)

include file for C/C++ (7121)

merged multiple structures (7009)

multiple definitions (5551)

overview (5537)

reporting errors (7015)

requirements (5539)

sqlerrd (7010)

SQLERRD(6) field (7019)

SQLWARN1 field (5431)

using in stored procedures (7998)

warnings (5429)

SQLCA.SQLERRD settings on CONNECT (6811)

SQLCA_92 include file

for COBOL applications (7541)

for FORTRAN applications (7716)

SQLCA_92 structure

include file

for FORTRAN applications (7717)

SQLCA_CN include file (7714)

SQLCA_CS include file (7713)

SQLCHAR structure

passing data with (5621)

SQLCLI include file

for C/C++ applications (7123)

SQLCLI1 include file

for C/C++ applications (7125)

SQLCODE

in Java programs (7394)

including SQLCA (5164)

platform differences (8173)

reporting errors (7016)

standalone (8148)

structure (5540)

SQLCODE -1015 (7005)

SQLCODE -1034 (7004)

SQLCODE -1224 (7007)

SQLCODES include file

for C/C++ applications (7128)

for COBOL applications (7544)

for FORTRAN applications (7718)

SQLDA

multithreading considerations (6897)

SQLDA include file

for C/C++ applications (7130)

for COBOL applications (7547)

for FORTRAN applications (7723)

SQLDA structure

association with PREPARE statement (5576)

creating (allocating) (5616)

creating, host language examples (5618)

declaring (5601)

declaring sufficient SQLVAR entities (5607)

fields used in stored procedures

SQLDATA (8002)

SQLIND (8003)

SQLLEN (8001)

SQLTYPE (8000)

initializing for stored procedure (DB2DARI) (7961)

input-SQLDA procedure, sample of (8038)

manipulation with DB2DARI stored procedure (7969)

passing data with (5620)

preparing statements using minimum (5606)

server input procedure, sample of (8043)

used to pass blocks of data (6934)

using in stored procedures (7997)

using, sample program (5632)

sqlda.n.SQLDAT (7990)

sqlda.n.SQLDATALEN (7996)

sqlda.n.SQLDATATYPE_NAME (7994)

sqlda.n.SQLIND (7991)

sqlda.n.SQLLEN (7989)

sqlda.n.SQLLONGLEN (7995)

sqlda.n.SQLNAME.data (7993)

sqlda.n.SQLNAME.length (7992)

sqlda.n.SQLTYPE (7988)

sqlda.SQLDABC (7986)

sqlda.SQLDAID (7985)

sqlda.SQLN (7987)

SQLDACT include file (7724)

SQLDATA field (8006)

SQLDB2 REXX API (7855), (7938)

SQLDB2, registering for REXX (7862)

sqldbchar and wchar_t, selecting data types (7246)

sqldbchar C/C++ type (7298)

sqldbchar data type (6341), (6344), (6347), (6355), (7248)

SQLDBS REXX API (7854)

SQLDBS, registering for REXX (7861)

SQLE819A include file

for C/C++ applications (7139)

for COBOL applications (7557)

for FORTRAN applications (7730)

SQLE819B include file

for C/C++ applications (7142)

for COBOL applications (7560)

for FORTRAN applications (7733)

SQLE850A include file

for COBOL applications (7562)

for FORTRAN applications (7735)

SQLE850B include file

for COBOL applications (7564)

for FORTRAN applications (7737)

SQLE859A include file

for C/C++ applications (7144)

SQLE859B include file

for C/C++ applications (7146)

SQLE932A include file

for C/C++ applications (7148)

for COBOL applications (7566)

for FORTRAN applications (7739)

SQLE932B include file

for C/C++ applications (7150)

for COBOL applications (7568)

for FORTRAN applications (7741)

sqleAttachToCtx() API (6889)

SQLEAU include file

for C/C++ applications (7132)

for COBOL applications (7550)

for FORTRAN applications (7726)

sqleBeginCtx() API (6887)

sqleDetachFromCtx() API (6890)

sqleEndCtx() API (6888)

sqleGetCurrentCtx() API (6891)

sqleInterruptCtx() API (6892)

SQLENV include file

for C/C++ applications (7133)

for COBOL applications (7551)

for FORTRAN applications (7727)

SQLERRD(1) (6734), (6803), (6809)

SQLERRD(2) (6735), (6804), (6810)

SQLERRD(3)

in an XA environment (6926)

SQLERRMC field of SQLCA (6733), (8115), (8194)

SQLERRP field of SQLCA (8109)

sqleSetTypeCtx() API (6886)

SQLETSD include file

for COBOL applications (7554)

SQLException

handling (5563)

retrieving SQLCODE from (7397)

retrieving SQLMSG from (7398)

retrieving SQLSTATE from (7399)

SQLEXEC

processing SQL statements in REXX (7869)

SQLEXEC REXX API (7853)

SQLEXEC, registering for REXX (7860)

SQLEXT include file

for CLI applications (7137)

SQLIND field (8007)

sqlint64 C/C++ type (7293)

SQLISL predefined variable (7886)

SQLJ (Embedded SQL for Java)

applets (7446)

calling stored procedures (7473)

db2profc command (7437), (7438)

db2profp command (7436)

declaring cursors (7459)

declaring iterators (7458)

embedding SQL statements in (7450)

example clauses (7451)

example program using (7468)

holdability (7454)

host variables (7470)

Java Database Connectivity (JDBC) interoperability (7524)

overview (7434)

positioned DELETE statement (7457)

positioned UPDATE statement (7456)

profconv command (7439)

restrictions (7447)

returnability (7455)

translator command (7440)

SQLJ (Embedded SQLJ for Java)

comparison with Java Database Connectivity (JDBC) (7354)

SQLJACB include file

for C/C++ applications (7152)

SQLLEN field (8005)

SQLMON include file

for C/C++ applications (7153)

for COBOL applications (7574)

for FORTRAN applications (7747)

SQLMONCT include file

for COBOL applications (7576)

SQLMSG

in Java programs (7395)

SQLMSG predefined variable (7885)

SQLRDAT predefined variable (7890)

SQLRIDA predefined variable (7889)

SQLRODA predefined variable (7888)

SQLSTATE

differences (8174)

in CLI (5660)

in Java programs (7396)

in SQLERRMC field of SQLCA (8195)

standalone (8149)

SQLSTATE field, in error messages (5544)

SQLSTATE include file

for C/C++ applications (7156)

for COBOL applications (7578)

for FORTRAN applications (7749)

SQLSYSTM include file

for C/C++ applications (7160)

SQLTYPE field (8004)

SQLUDF include file

description (6358)

for C/C++ applications (7161)

UDF interface (6209)

sqludf.h include file (6321)

sqludf.h include file for UDFs (6359)

sqludf_append API (6547)

sqludf_create_locator API (6548)

sqludf_free_locator API (6549)

sqludf_length API (6545)

sqludf_substr API (6546)

SQLUTBCQ include file

for COBOL applications (7581)

SQLUTBSQ include file

for COBOL applications (7584)

SQLUTIL include file

for C/C++ applications (7163)

for COBOL applications (7587)

for FORTRAN applications (7752)

SQLUV include file

for C/C++ applications (7167)

SQLUVEND include file

for C/C++ applications (7169)

SQLVAR entities

declaring sufficient number of (5608)

variable number of, declaring (5600)

SQLWARN structure, overview of (5546)

SQLXA include file

for C/C++ applications (7170)

SQLZ_DISCONNECT_PROC return value (8009)

SQLZ_HOLD_PROC return value (8010)

SQL_API_FN macro (6309), (7962)

SQL_FILE_READ, input value option (6113)

SQL_WCHART_CONVERT preprocessor macro (7251)

statement handle (5652)

statements

ACQUIRE (8201)

BEGIN DECLARE SECTION (5153)

call (8184)

COMMIT (5197)

COMMIT WORK RELEASE (8215)

CONNECT (5187)

connect (8108)

CREATE STORGROUP (8065)

CREATE TABLESPACE (8067)

DECLARE (8203), (8217)

DELETE (8077)

DESCRIBE (8207), (8219)

END DECLARE SECTION (5154)

GRANT (8100)

INCLUDE SQLCA (5161)

INSERT (8073), (8091)

LABEL ON (8205)

PREPARE (8221)

ROLLBACK (5204), (8123)

SELECT (8071)

SET CURRENT (8225)

UPDATE (8075)

static SQL

coding statements to retrieve and manipulate data (5410)

comparing to dynamic SQL (5582)

considerations (5583)

DB2 Connect support (8056)

overview (5396)

precompiling, advantages of (5390)

sample program (5402)

static update programming example (5530)

transform groups for structured types (6034)

using host variables (5412)

static types (5939)

STATIC.SQB COBOL program listing (5409)

STATIC.SQC C program listing (5407)

Static.sqlj Java program listing (5408)

storage

allocating to hold row (5613)

declaring sufficient SQLVAR entities (5605)

storage allocation for unequal code pages (6805)

Stored Procedure Builder

debug table (7493)

environment settings (7492)

features (8189)

overview (8188)

stored procedures

advantages (5693)

allocating storage (5702)

allowed SQL statements in (5746)

application logic consideration (5283)

application troubleshooting (5785)

architecture (5696)

C++ consideration (5759)

CALL statement (5703), (5709)

CALL statements in (5801)

character conversion (6720)

character conversions, for EUC (6837)

Chinese (Traditional) code sets (6788)

client application (5706)

code page considerations (5753)

CONTAINS SQL clause (5745)

CREATE PROCEDURE statement (5710)

creating and using in Java (7475)

db2dari executable (5751)

debugging (5770)

using Stored Procedure Builder (7491)

declaring parameter modes (5715)

example (5739)

EXTERNAL clause (5722)

FOR BIT DATA considerations (5755)

general (8182)

graphic host variable considerations (5762)

host variables (5700)

initializing REXX variables (7946)

input-SQLDA procedure, sample of (8037)

input-SQLDA stored procedure, sample of (8042)

invoking (5704)

Japanese code sets (6787)

LANGUAGE clause (5727)

languages supported (5726)

location (5721)

multisite update considerations (5767)

nested (5747)

NOT FENCED (5771)

OUT parameter client program (5752)

overloading names (5713)

overview of (5691), (5708)

PARAMETER STYLE clause (5730)

parameters (5716), (5740), (5743)

passing DBINFO structures (5738)

path (5720)

PROGRAM TYPE clause (5729)

registering in Java (7476)

registering with CREATE PROCEDURE (5711)

requirements for (5697)

restrictions (5750)

returning result sets (5783)

REXX applications (7945)

using the SQLDA and SQLCA structures (7999)

where to place (5723)

written as a main function (5728)

stored procedures (DB2DARI)

calling convention

parameter conversion (7964)

SQL_API_FN (7963)

data structure usage (7972)

NOT FENCED (8036)

parameter variables

sqlda.n.SQLDAT (7978)

sqlda.n.SQLDATALEN (7984)

sqlda.n.SQLDATATYPE_NAME (7982)

sqlda.n.SQLIND (7979)

sqlda.n.SQLLEN (7977)

sqlda.n.SQLLONGLEN (7983)

sqlda.n.SQLNAME.data (7981)

sqlda.n.SQLNAME.length (7980)

sqlda.n.SQLTYPE (7976)

sqlda.SQLDABC (7974)

sqlda.SQLDAID (7973)

sqlda.SQLN (7975)

restrictions (7965)

return values (8008)

using indicator variables (7970)

storing large objects (5839)

String (7383)

string search and defining UDFs example (6175)

string search on BLOBs (6176)

string search over UDT example (6177)

strong typing and distinct types (5867)

structure definitions in sqludf.h (6360)

Structured Query Language (SQL)

statements, summary (5293)

table of supported statements (7955)

structured types

accessing subtypes in type hierarchy (5938)

advantages (5890)

attributes (5885)

binding in subtypes with tranform functions (6056)

comparing instances with (6011)

constructor functions (5910)

creating an instance of (5911)

creating typed tables (5925)

declaring host variables for (6058)

defining behavior for (5921)

defining structured type attributes for (6020)

DESCRIBE statement (6060)

dynamic types (5941)

hierarchy (5893)

inheritance (5891)

inserting instances into columns (6021)

instantiable types (5945)

invoking methods of (6022)

invoking methods on (5920)

MODE DB2SQL clause (5888)

mutator methods (5913)

noninstantiable types (5944)

observer methods (5916)

overview (5884)

passing instances to client applications (6046)

referring to row objects (5902)

representation types (5906)

retrieving attribute values (5917)

retrieving instances as single values (6024)

retrieving internal ID of (6005)

retrieving schema name of (6006)

retrieving subtype attributes of (6026)

retrieving type name of (6004)

returning information about (6028)

static types (5942)

storing (5892)

storing as rows (5924)

storing in columns (6017)

storing objects in columns (5936)

updating attributes of (5914), (6023), (6027)

subtables

creating (5927)

inheriting attributes from subtables (5950)

subtitutability (5929), (5937)

subtypes (5896)

binding in with tranform functions (6055)

returning attributes using OUTER (6013)

writing transform functions for (6053)

success code (5169) See also SQLCODE or SQLSTATE

supertypes (5895)

surrogate functions (6620)

suspended application

diagnosing (7024)

symbol substitutions, C/C++ language restrictions (7222)

Sync Point Manager (6864)

syntax

character host variables (7202)

declare section

in COBOL (7605)

in FORTRAN (7772)

declare section in C/C++ (7194)

embedded SQL statement

comments in COBOL (7596)

comments in FORTRAN (7763)

in COBOL (7591)

in FORTRAN (7758)

embedded SQL statement avoiding line breaks (7188)

embedded SQL statement comments in C/C++ (7187)

embedded SQL statement comments in REXX (7875)

embedded SQL statement in C/C++ (7182)

embedded SQL statement substitution of white space characters (7189)

graphic host variable in C/C++ (7204)

processing SQL statement in REXX (7867)

syntax for referring to functions (6187)

SYSCAT.FUNCMAPOPTIONS catalog view (7074)

SYSCAT.FUNCTIONS catalog view (7075)

SYSIBM.SYSPROCEDURES catalog (OS/390) (8185)

SYSSTAT.FUNCTIONS catalog view (7076)

system catalog

dropping view implications (5994)

using (8175)

system catalog views

prototyping utility (5318)

system configuration parameter for shared memory size (6575)

System.err Java I/O stream (6377)

System.in Java I/O stream (6375)

System.out Java I/O stream (6376)

table

committing changes (5202)

data source tables (7028)

lob-options-clause of the CREATE TABLE statement (6089)

positioning cursor at end (5518)

tablespace-options-clause of the CREATE TABLE statement (6088)

table check constraint, data value control consideration (5262)

table function (6223)

SQL-result argument (6224)

table function example (6183)

table functions (6161)

application design considerations (6530)

contents of call-type argument (6267)

in Java (6371)

OLE DB (6482) See also OLE DB table functions

table names

resolving unqualified (5371)

tables

temporary (5673)

tablespace-options-clause of the CREATE TABLE statement (6087)

target partition

behavior without buffered insert (6956)

temporary tables (5672)

territory

in SQLERRMC field of SQLCA (8118)

test data

generating (5309)

test database

CREATE DATABASE API (5307)

creating (5306)

recommendations (5308)

testing and debugging utilities

database system monitor (5313)

Explain facility (5312)

flagger (5314)

system catalog views (5311)

updating system catalog statistics (5310)

testing environment

for partitioned environments (6999)

setting up (5304)

test databases, guidelines for creating (5305)

testing your UDF (6613)

tfweather_u table function C program listing (6604)

TIME parameter to UDF (6350)

TIME SQL data type (5452), (6439)

C/C++ (7285)

COBOL (7655)

FORTRAN (7811)

Java (7375)

Java stored procedures (DB2GENERAL) (8029)

OLE DB table function (6517)

REXX (7918)

timeout on a lock (8171)

TIMESTAMP parameter to UDF (6351)

TIMESTAMP SQL data type (5453), (6440)

C/C++ (7286)

COBOL (7656)

FORTRAN (7812)

Java (7376)

Java stored procedures (DB2GENERAL) (8030)

OLE DB table function (6518)

REXX (7919)

TM_DATABASE multisite update configuration parameter (6851)

TO SQL transforms (6037)

TP_MON_NAME multisite update configuration parameter (6857)

transaction

beginning a transaction (5193)

committing work done (5199)

description (5188)

ending a transaction (5195)

ending the program

COMMIT and ROLLBACK statements (5212)

implicitly ending (5216)

rolling back work done (5211)

savepoints (5675)

transaction log consideration

for buffered insert (6965)

transaction log, buffered insert consideration (6964)

transaction processing monitors

X/Open XA Interface (6912)

transform function

binding in subtypes (6054)

transform functions

associating with structured types (6029)

handling subtype parameters (6052)

mapping structured type attributes (6038)

passing objects to external routines (6039), (6040)

passing structured types to client applications (6044)

summary table (6051)

transform groups

for dynamic SQL (6032)

for external routines (6031)

for static SQL (6033)

naming recommendations (6030)

transition tables

based on type of trigger event (6656)

OLD_TABLE and NEW_TABLE (6655)

transition variables, OLD and NEW

transition variables based on type of trigger event (6650)

translation

character (8087)

TREAT expression (6025)

trigger event such as UPDATE, INSERT or DELETE (6630)

triggers

activation time (6642)

AFTER triggers (6644), (6661)

and DB2 object extensions (5831)

application logic consideration (5287)

BEFORE triggers (6643), (6660)

benefits (6622)

cascading (6667)

data relationship consideration (5276)

definition (6617)

DELETE operation (6636)

functions with SQL triggered statements

RAISE_ERROR built-in function (6664)

INSERT operation (6634)

interactions with referential constraints (6669)

multiple triggers, ordering of (6671)

overview (6626)

referential constraints, interactions with using triggers (6670)

set of affected rows (6637)

synergy with UDTs, UDFs, and LOBs (6674)

transition tables (6652)

transition variables (6649)

trigger event (6629)

trigger granularity (6639)

triggered action condition (6657)

triggered SQL statement (6659)

UPDATE operation (6635)

WHEN clause (6658)

why use triggers (6618)

trigraph sequences (7104)

troubleshooting

stored procedures (5786)

using Visual Studio (5789)

truncation

host variables (5433)

indicator variables (5432)

type conversion

between SQL types and OLE automation types (6407)

type decoration

in stored procedures (5761)

in UDFs (6590)

type decoration consideration

C++ (7106)

type mapping

OLE automation types and BASIC types (6410)

OLE automation types and C++ types (6411)

type mappings (7047)

dropping restrictions (5987)

TYPE predicate

restricting returned types with (6009)

typed tables

accessing subtypes in type hierarchy (5930)

controlling privileges on (5956)

creating (5946)

creating subtables (5928)

defining relationships between (5932), (5970)

defining the scope of (5962)

definition of (5926)

determining hierarchy position (5949)

inserting object identifiers (5966)

inserting objects into (5964)

object identifier column (5947)

returning subtype attributes (6014)

selecting data from (5996)

self-referencing (5971)

typed views

assigning scope to reference columns in (5981)

body of (5980)

creating (5975)

creating on root types (5978)

creating on subtypes (5979)

types

ROWID (8095)

types or arguments, promotions in UDFs (6323)

TYPE_ID function (6002)

TYPE_NAME function (6001)

TYPE_SCHEMA function (6003)

UCS-2 (6745) See also Unicode

UDFs (User-defined Functions)

UDFs (User-defined functions)

allocating dynamic memory in the UDF (6561)

and DB2 object extensions (5837)

C++ consideration (6588)

calling convention (6310)

casting (6203)

caveats (6576)

Chinese (Traditional) code sets (6785)

code page differences (6584)

coding in Java (6368)

concepts (6141)

considerations when using protected resources (6583)

creating and using in Java (6363)

db2udf executable (6582)

debugging your UDF (6611)

definition (6129)

DETERMINISTIC (6527)

example (6598)

examples of UDF code (6591)

EXTERNAL ACTION option (6564)

FENCED option (6565)

function path (6143)

function selection algorithm (6145)

general considerations (6198)

hints and tips for coding (6558)

implementing (6131)

infix notation (6199)

input and output to screen and keyboard (6580)

interface between DB2 and a UDF (6207)

invoking (6184)

parameter markers in functions (6190)

qualified function reference (6192)

unqualified function reference (6194)

Japanese code sets (6784)

Java consideration (6211)

list of types and their representations in UDFs (6314)

LOB locator usage scenarios (6557)

LOB types (6201)

NOT DETERMINISTIC (6526)

NOT DETERMINISTIC option (6563)

NOT FENCED (6596)

NOT NULL CALL (6595)

NOT NULL CALL option (6562)

OLE automation UDFs (6385)

output and input to screen and keyboard (6581)

overloading function names (6144)

passing arguments from DB2 to a UDF (6210)

process of implementation (6167)

rationale (6132)

re-entrant UDFs (6521)

referring to functions (6186)

registering (6170)

restrictions and caveats (6577)

save state in function (6525)

schema-name and UDFs (6146)

SCRATCHPAD (6528)

scratchpad considerations (6520)

shared memory size (6578)

sourced (5871)

SQL data types, how they are passed (6313)

SQLUDF include file (6208), (6357)

SQL_API_FN (6594)

SUBSTR built-in function (6601)

summary of function references (6196)

synergy with triggers, UDTs, and LOBs (6676)

system configuration parameter for shared memory size (6579)

table functions (6531)

type of functions (6153)

unqualified reference (6142)

using LOB locators (6540)

writing (6168), (6205)

UDFs and LOB types (6202)

UDTs (User-defined Types)

UDTs (User-defined types)

and DB2 object extensions (5836)

synergy with triggers, UDFs, and LOBs (6675)

unambiguous cursors (8128)

unequal code pages (6802)

allocating storage (6807)

unfenced stored procedures (5776) See also NOT FENCED

Unicode

Java (7522)

Unicode (UCS-2)

character conversion (6838)

character conversion overflow (6828)

Chinese (Traditional) code sets (6748)

Japanese code sets (6747)

UDF considerations (6783)

unique key violation

buffered insert (6986)

unit of work

completing (5491)

cursor considerations (5485)

distributed (6841)

remote (6844)

unqualified function reference example (6195)

unqualified reference (6150)

unqualified table names

resolving (5370)

UPDAT.CMD REXX program listing (5534)

UPDAT.SQB COBOL program listing (5533)

UPDAT.SQC C program listing (5531)

Updat.sqlj Java program listing (5532)

update operation (6628)

UPDATE operation and triggers (6632)

UPDATE statement

DB2 Connect support (8074)

USAGE clause in COBOL types (7659)

use of distinct types in UNION example (5883)

user defined types

supported by DB2 Connect (8093)

USER MAPPING in OLE DB table functions (6497)

user updatable catalog statistics

prototyping utility (5319)

user-defined collating sequence (8157), (8228)

user-defined function, application logic consideration (5285)

user-defined sourced functions on distinct types example (5875)

user-defined type (UDT)

dropping restrictions (5986)

using

Java stored procedures (7478)

Java UDFs (6365)

using a locator to work with a CLOB value example (6095)

using qualified function reference example (6193)

UTILAPI.C program listing (5562)

utility APIs

include file for C/C++ applications (7165)

include file for COBOL applications (7556), (7583), (7586), (7589)

include file for FORTRAN applications (7754)

V5SPCLI.SQC C program listing (8041)

V5SPSRV.SQC C program listing (8046)

VALIDATE RUN

DB2 Connect support (8125)

VALUES clause

on INSERT statement (6958)

VARCHAR (6239), (6242), (6245)

VARCHAR FOR BIT DATA parameter to UDF (6338)

VARCHAR SQL data type (5444), (6429)

C or C++ (7347)

C/C++ (7276)

COBOL (7646)

FORTRAN (7803)

Java (7366)

Java stored procedures (DB2GENERAL) (8020)

OLE DB table function (6508)

REXX (7909)

VARCHAR structured form C/C++ type (7306)

VARGRAPHIC data (7341)

VARGRAPHIC parameter to UDF (6343)

VARGRAPHIC SQL data type (5446), (6431)

C/C++ (7279)

COBOL (7649)

FORTRAN (7806)

Java (7369)

Java stored procedures (DB2GENERAL) (8023)

OLE DB table function (6511)

REXX (7912)

variable-length strings (8088)

variables

SQLCODE (7349), (7687), (7843)

SQLSTATE (7348), (7686), (7842)

variables, declaring (5145)

variables, predefined in REXX (7882)

Varinp.java Java program listing (5644)

VARINP.SQB COBOL program listing (5646)

VARINP.SQC C program listing (5642)

view

altering (5988)

data source views (7029)

data value control consideration (5266)

dropping (5989)

dropping implications for system catalogs (5991)

restrictions (5990)

viewing

online information (8248)

views

system catalogs (8176)

Visual Basic

supported in DB2 (5243)

Visual C++

IBM DB2 Universal Database Project Add-In (5290)

supported in DB2 (5244)

warning message, truncation (5428)

WCHARTYPE

guidelines (7252)

in stored procedures (5764)

WCHARTYPE precompiler option (5779), (7250)

wchar_t and sqldbchar, selecting data types (7245)

wchar_t C/C++ type (7299)

wchar_t data type (6342), (6345), (6348), (6356), (7247)

weight, definition of (6684)

WHENEVER SQLERROR CONTINUE statement (5175)

WHENEVER statement

caution in using with SQL statements (5174)

error indicators with SQLCA (5172)

in error handling (5549)

wild moves, DB2 checking of (6614)

Windows code pages

DB2CODEPAGE registry variable (6705)

supported code pages (6706)

Windows registration database

for OLE automation UDFs (6391)

WITH OPTIONS clause

defining column options with (5957)

defining reference column scope (5960)

wizards

add database (8258)

back up database (8260)

completing tasks (8257)

configure multisite update (8262)

create database (8264)

create table (8266)

create table space (8268)

index (8270)

performance configuration (8272)

restore database (8274)

work environment

setting up (5302)

test databases, guidelines for creating (5303)

X/Open XA Interface (6914)

API restrictions (6927)

characteristics of transaction processing (6915)

CICS environment (6916)

COMMIT and ROLLBACK (6920)

cursors declared WITH HOLD (6923)

DISCONNECT (6918)

multithreaded application (6930)

savepoints (5690)

SET CONNECTION (6919)

single-threaded application (6929)

SQL CONNECT (6921)

transactions (6917)

XA environment (6925)

XASerialize (6931)

[ Top of Page | Previous Page ]