Application Development Guide

Index

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

Special Characters

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

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

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

Numerics

64-bit integer (BIGINT) data type

supported by DB2 Connect Version 6 (7650)

access to data consideration

DB2 Call Level Interface (DB2 CLI) (4959)

embedded SQL (4955)

JDBC (4963)

Microsoft specifications (4965)

ODBC (4961)

REXX (4957)

using Perl (4980)

using query products (4982)

ACQUIRE statement, DB2 Connect support (7734)

activation time and triggers (6212)

ActiveX Data Object specification

supported in DB2 (4967)

ADHOC.SQC C program listing (5384)

Administering Satellites Guide and Reference (7776)

Administration Guide (7756)

Administrative API Reference (7757)

ADO specification

supported in DB2 (4968)

AFTER triggers (6214), (6230)

aggregating functions (5661)

alerts, supported by triggers (6188)

allocating dynamic memory in a UDF (6115)

ALLOW PARALLEL clause (5934)

ALTER NICKNAME statement

column options (6615)

data type mappings (6629)

ambiguous cursors (7677)

APPC, CPI-C and SNA Sense Codes (7759)

APPC, handling interrupts (5299)

Application Building Guide (7758)

application design

access to data (4952)

binding (5054)

character conversion considerations (6290)

character conversion in SQL statements (6292)

character conversions in stored procedures (6298)

COBOL Japanese and traditional Chinese EUC considerations (7236)

COBOL requirements, include files (7080)

code points for special characters (6294)

coding a DB2 application,overview (4868)

collating sequences, guidelines (6271)

creating SQLDA structure, guidelines (5365)

cursor processing, considerations (5209)

data relationship (4998)

data value control consideration (4984)

declaring sufficient SQLVAR entities (5354)

describing SELECT statement (5360)

double-byte character support (DBCS) (6295)

dynamic SQL caching (5125)

error handling, guidelines (5291)

executing statements without variables (5321)

guidelines (4948)

input-SQLDA procedure, sample of (7594)

input-SQLDA stored procedure, sample of (7599)

logic at the server (5007)

OLE automation UDFs (5940)

package renaming (5084)

passing data, guidelines (5369)

precompiling and binding (5053)

receiving database values (5153)

retrieving data a second time (5251)

REXX requirements, registering routines (7410)

sample programs (5260)

saving end user requests (5379)

static SQL, advantages of using (5123)

table function considerations (6084)

use of dynamic SQL, overview of (5315)

user-defined function (UDF) (5757)

using LOB locators in UDFs (6093)

using parameter markers (5387)

varying-list statements, processing of (5377)

Application Development Guide (7760)

application domain and object-orientation (5532)

application environment, for programming (4871)

application forms using CREATE TABLE example (5736)

application logic

data relationship consideration (5006)

data value control consideration (4996)

application logic consideration

stored procedures (5010)

triggers (5014)

user-defined functions (5012)

Application Program Interface (API)

for JDBC applications (7069)

for setting contexts between threads

sqleAttachToCtx() (6457)

sqleBeginCtx() (6455)

sqleDetachFromCtx() (6458)

sqleEndCtx() (6456)

sqleGetCurrentCtx() (6459)

sqleInterruptCtx() (6460)

sqleSetTypeCtx() (6454)

overview of (5022)

restrictions in an XA environment (6503)

syntax for REXX (7494)

types of (5023)

uses of (5024)

argument types, promotions in UDFs (5873)

arguments between UDFs and DB2 (5767)

call-type (5803)

dbinfo (5825)

diagnostic-message (5795)

function-name (5789)

scratchpad (5798)

specific-name (5792)

SQL-argument (5769)

SQL-argument-ind (5777)

SQL-result (5771)

SQL-result-ind (5781)

SQL-state (5786)

arguments, passing from DB2 to a UDF (5764)

ARI (DB2 for VSE & VM) (7664)

arithmetic error

in UDFs (5783)

AS LOCATOR clause (6096)

ASCII

mixed-byte data (7632)

sort order (7696)

assignments in dynamic SQL example (5751)

assignments involving different UDTs example (5753)

assignments involving UDTs example (5749)

asynchronous events (6445), (6448)

asynchronous nature of buffered insert (6543)

ATOMIC compound SQL, not supported in DB2 Connect (7725)

automation server, for OLE (5948)

AVG over a UDT example (5684)

backing out changes (4933)

BASIC language

implementation of OLE automation UDF (5951)

BASIC types and OLE automation types (5966)

BEFORE triggers (6213), (6229)

BEGIN DECLARE SECTION (4883)

beginning transactions (4922)

big integer, data type (7651) See also 64-bit integer (BIGINT) data type

BigDecimal Java type (6950)

BIGINT parameter to UDF (5877)

BIGINT SQL data type (5164)

C/C++ (6841)

COBOL (7187)

FORTRAN (7344)

Java (6928)

Java stored procedures (DB2GENERAL) (7569)

OLE DB table function (6057)

BINARY data types in COBOL (7173)

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

BIND API (5108)

BIND API, creating packages (5080)

bind file

precompile options (5066)

support to REXX applications (7487)

bind files

backwards compatibility (5098)

bind files for REXX (7485)

bind option

INSERT BUF (6537)

bind options

EXPLSNAP (5101)

FUNCPATH (5102)

QUERYOPT (5100)

BIND PACKAGE command

rebinding (5117)

binding

bind file description utility, db2bfd (5109)

considerations (5097)

deferring (5107)

dynamic statements (5085)

options for (5078)

overview of (5079)

blob C/C++ type (6873)

BLOB FORTRAN type (7370)

BLOB parameter to UDF (5903)

BLOB SQL data type (5174), (5987)

C/C++ (6852)

COBOL (7198)

FORTRAN (7355)

Java (6939)

Java stored procedures (DB2GENERAL) (7580)

OLE DB table function (6068)

REXX (7468)

BLOB-FILE COBOL type (7213)

BLOB-LOCATOR COBOL type (7212)

BLOBs (Binary Large Objects)

uses and definition (5565)

blob_file C/C++ type (6875)

BLOB_FILE FORTRAN type (7372)

blob_locator C/C++ type (6874)

BLOB_LOCATOR FORTRAN type (7371)

blocking (7676)

BSTR OLE automation type (6018)

buffer size for buffered insert (6520)

buffered insert

advantages (6533)

asynchronous nature of (6542)

buffer size (6521)

closed state (6551)

considerations for using (6541)

deadlock errors (6559)

error detection during (6544)

error reporting in buffered insert (6556)

group of rows (6545)

INSERT BUF bind option (6535)

long field restriction (6565)

not supported in CLP (6569)

open state (6552)

overview (6518)

partially filled (6522)

restrictions on using (6563)

savepoint consideration (6524)

SELECT buffered insert (6549)

statements that close (6526)

transaction log consideration (6540)

unique key violation (6561)

C language type definitions in sqludf.h (5912)

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

C null-terminated string SQL data type (5985)

C++

consideration for stored procedures (5492)

considerations for UDFs (6144)

type decoration consideration (6678)

C++ types and OLE automation types (5967)

C/C++ data types

blob (6895)

blob_file (6897)

blob_locator (6896)

char (6889)

clob (6892)

clob_file (6894)

clob_locator (6893)

dbclob (6900)

dbclob_file (6902)

dbclob_locator (6901)

double (6888)

float (6887)

long (6883)

long int (6884)

long long (6885)

long long int (6886)

null-terminated character form (6899)

short (6881)

short int (6882)

sqldbchar (6890)

VARCHAR structured form (6898)

wchar_t (6891)

C/C++ language

character set (6673)

Chinese (Traditional) EUC considerations (6830)

data types supported (6835)

declaring graphic host variables (6777)

declaring host variables (6769)

embedding SQL statements (5044)

file reference declarations (6788)

handling class data members (6802)

handling null-terminated strings (6797)

host variable, naming (6765)

include files, required (6685)

initializing host variables (6791)

input and output files (6682)

Japanese EUC considerations (6831)

LOB data declarations (6780)

LOB locator declarations (6785)

member operator, restriction (6808)

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

programming restrictions in (6671)

qualification operator, restriction (6807)

supported data types (6833)

trigraph sequences (6674)

Call Level Interface (CLI)

advantages of using (5414), (5416)

comparing embedded SQL and DB2 CLI (5401)

overview (5399)

CALL statement

in Java (7020)

initializing client for stored procedure (DB2DARI)

SQLDA structure (7518)

invoking a stored procedure (5431)

on different platforms (7720)

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

call-type (6089)

contents with scalar functions (5811)

contents with table functions (5817)

call-type, passing to UDF (5801), (5802)

calling convention

for UDFs (5862)

calling from a REXX application (7500)

calling the DB2 CLP from a REXX application (7498)

CARDINALITY specification in table functions (6092)

cascade (7704)

cascading triggers (6235)

CAST FROM clause (5773)

CAST FROM clause in the CREATE FUNCTION statement (5870)

castability (5639)

casting, UDFs (5716)

CHAR (5787)

char C/C++ type (6867)

CHAR parameter to UDF (5886)

CHAR SQL data type (5169), (5979)

C/C++ (6846)

COBOL (7192)

FORTRAN (7349)

Java (6933)

Java stored procedures (DB2GENERAL) (7574)

OLE DB table function (6062)

REXX (7462)

CHAR type (7056)

character comparison, overview (6258)

character conversion

coding SQL statements (6291)

coding stored procedures (6296), (6410)

during precompiling and binding (6299)

expansion (6309)

national language support (NLS) (6304)

programming considerations (6289)

rules for string conversions (6405)

string length overflow (6403)

string length overflow past data types (6407)

supported code pages (6308)

Unicode (UCS-2) (6413)

when executing an application (6300)

when occurs (6307)

character host variables

C/C++

fixed and null-terminated (6771)

variable length (6772)

COBOL (7154)

FORTRAN (7321)

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

CHARACTER parameter to UDF (5887)

character translation (7635)

CHARACTER*n FORTRAN type (7366)

CHECKERR REXX program listing (5313)

CHECKERR.CBL program listing (5309)

Chinese (Traditional)

double-byte considerations (6339)

Extended UNIX Code considerations (6338)

Chinese (Traditional) code sets (6317)

C/C++ considerations (6825)

developing applications using (6343)

Chinese (Traditional) EUC code sets

REXX considerations (7506)

CICS (7614)

CICS SYNCPOINT ROLLBACK command (6497)

classes

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

CLASSPATH environment variable (7035)

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

CLI Guide and Reference (7761)

client applications

running stored procedures (5433)

client-based parameter validation

Extended UNIX Code consideration (6392)

client/server

code page conversion (6301)

clob C/C++ type (6870)

CLOB FORTRAN type (7367)

CLOB parameter to UDF (5904)

CLOB SQL data type (5175), (5988)

C/C++ (6853)

COBOL (7199)

FORTRAN (7356)

Java (6940)

Java stored procedures (DB2GENERAL) (7581)

OLE DB table function (6069)

REXX (7469)

CLOB-FILE COBOL type (7211)

CLOB-LOCATOR COBOL type (7210)

CLOBs (Character Large Objects)

uses and definition (5566)

clob_file C/C++ type (6872)

CLOB_FILE FORTRAN type (7369)

clob_locator C/C++ type (6871)

CLOB_LOCATOR FORTRAN type (7368)

CLOSE call (5820)

closed state, buffered insert (6553)

closing a buffered insert (6527)

COBOL

declaring host variables (7151)

embedding SQL statements (5047)

file reference declarations (7168)

include files, list of (7078)

indicator tables (7170)

input and output files (7077)

Japanese and traditional Chinese EUC considerations (7240)

LOB data declarations (7160)

LOB locator declarations (7165)

object oriented restrictions (7242)

restrictions in (7075)

rules for indicator variables (7158)

supported data types (7179)

COBOL data types

BINARY (7175)

BLOB (7224)

BLOB-FILE (7226)

BLOB-LOCATOR (7225)

CLOB (7221)

CLOB-FILE (7223)

CLOB-LOCATOR (7222)

COMP (7176)

COMP-1 (7218)

COMP-3 (7219)

COMP-4 (7177)

COMP-5 (7220)

DBCLOB (7227)

DBCLOB-FILE (7229)

DBCLOB-LOCATOR (7228)

PICTURE (PIC) clause (7216)

USAGE clause (7217)

COBOL language

data types supported (7181)

code page

allocating storage for unequal situations (6382)

binding considerations (5099)

character conversion (6302)

DB2CODEPAGE environment variable (6276)

handling expansion at application (6390)

handling expansion at server (6388)

how determined (6275)

in SQLERRMC field of SQLCA (7669)

locales

deriving in applications (6285)

how DB2 derives locales (6286)

national language support (NLS) (6303)

stored procedure considerations (5486)

supported Windows 95 code pages (6277)

supported Windows NT code pages (6278)

unequal situations (6314), (6375)

code point (6254)

code point, definition of (6250)

code set

in SQLERRMC field of SQLCA (7671)

coding Java UDFs (5920)

collating sequence

case independent comparisons (6260)

code point (6253)

collating_sequence option (6274)

EBCDIC and ASCII (7694)

EBCDIC and ASCII sort order example (6262)

federated database concerns (6273)

general concerns (6270)

identity sequence (6255)

include files

in C/C++ (6713)

in COBOL (7106)

in FORTRAN (7279)

multi-byte characters (6257)

overview of (6252)

samples of (6269)

simulating EBCDIC binary collation (7750)

sort order example (6261)

specifying (6263)

use in character comparisons (6259)

collation

Chinese (Traditional) code sets (6369)

Japanese code sets (6368)

collection ID (7684)

DB2 Universal Database for AS/400 (7686)

COLLECTION parameters (5095)

collections (7687)

column

setting null values in (5156)

supported SQL data types (5161)

using indicator variables on nullable data columns (5197)

column functions (5660)

column options

ALTER NICKNAME statement (6614)

description (6612)

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

column types, creating in COBOL (7182)

column types, creating in FORTRAN (7340)

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

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

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

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

COM.ibm.db2.app.UDF (5929), (7587)

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

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

Command Line Processor (7499)

command line processor

prototyping utility (5039)

Command Reference (7762)

comments

SQL, rules for (7141), (7308)

comments, SQL, rules for (6758)

COMMIT statement (4876)

association with cursor (5213)

ending a transaction (4926)

ending transactions (4941)

pass-through (6658), (6666)

COMMIT WORK RELEASE

not supported in DB2 Connect (7742)

committing changes, tables (4929)

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

COMP-1 in COBOL types (7207)

COMP-3 in COBOL types (7208)

COMP-5 in COBOL types (7209)

comparisons involving UDTs example (5741), (5745)

compiled applications, creating packages for (5055)

compiling (5075)

client application (5506)

stored procedures (5504)

compiling a UDF (5665)

completion code (4896) See also SQLCODE or SQLSTATE

compound SQL, NOT ATOMIC (7726)

configuration parameter

LOCKTIMEOUT (6486)

CONNECT

connect

application programs (4914)

CONNECT RESET statement (7657)

CONNECT TO statement (7656)

implicit connect (7659)

null CONNECT (7658)

sample programs (5265)

SQLCA.SQLERRD settings (6386)

CONNECT RESET statement

ending transactions (4943)

CONNECT statement (4875)

CONNECT TYPE 2

considerations with stored procedures (5501)

connecting DB2 application programs (4913)

connection handle (5407)

Connectivity Supplement (7766)

consideration

access to data (4954)

application logic at server (5009)

data relationship control (5000)

data value control (4986)

DB2 application design (4951)

consistency

of data (4918)

consistency of data (4917)

consistent behavior and UDTs (5719)

constraint mechanisms on large objects (5552)

contexts

application dependencies between (6478)

database dependencies between (6475)

preventing deadlocks between (6483)

setting in multithreaded DB2 applications (6447)

control information to access large object data (5584)

conventions used in this book (4867)

CONVERT

WCHARTYPE

in stored procedures (5497)

coordinator node

behavior without buffered insert (6529)

cost of a UDT example (5682)

counter for UDFs example (6163)

counter OLE automation UDF object example in BASIC (6171)

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

counting and defining UDFs example (5686)

counting with an OLE automation object (5689)

country code

in SQLERRMC field of SQLCA (7668)

creatable multi-use OLE automation server (6034)

creatable single-use OLE automation server (6033)

CREATE DATABASE API

SQLEDBDESC structure (6267)

CREATE DISTINCT TYPE statement

and castability (5641)

examples of using (5726)

to define a UDT (5724)

CREATE FUNCTION MAPPING statement

estimating overhead of invoking functions (6652)

making data source functions known to federated server (6642)

reducing overhead of invoking functions (6646)

specifying function names (6653)

CREATE FUNCTION statement (5799), (5805), (5826), (6091), (6097)

CAST FROM clause (5868)

for OLE automation UDFs (5949)

in federated systems (6644)

Java UDFs (5935)

RETURNS clause (5869)

to register a UDF (5672)

CREATE PROCEDURE statement (5438), (7028)

CREATE SERVER statement (6049)

CREATE STORGROUP statement

DB2 Connect support (7619)

CREATE TABLE statement

defining LOB columns (5585)

examples of using (5732)

lob-options-clause (5586)

tablespace-options-clause (5587)

CREATE TABLESPACE statement

DB2 Connect support (7620)

CREATE TRIGGER statement

multiple triggers (6240)

order of trigger activation (6215)

overview (6194)

REFERENCING clause (6220)

CREATE TYPE MAPPING statement (6625)

CREATE USER MAPPING statement (6053)

creating

Java stored procedures (7025)

Java UDFs (5915)

OLE automation UDFs (5943)

creating packages for compiled applications (5056)

creator (7683)

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

critical sections (6480)

ctr() UDF C program listing (6165)

CURRENT EXPLAIN MODE register (5088)

CURRENT FUNCTION PATH register (5089)

CURRENT QUERY OPTIMIZATION register (5087)

cursor

ambiguous (5235)

completing a unit of work (5216)

declared WITH HOLD (5218)

declaring (5210)

FOR FETCH ONLY (5232)

issuing a COMMIT statement (5215)

naming and defining of (5205)

naming, in REXX (7421)

positioning at table end (5255)

processing with SQLDA structure (5364)

processing, in dynamic SQL (5336)

processing, sample program (5219), (5338)

processing, summary of (5203)

read only, application requirements for (5212)

read-only (5206), (5231)

retrieving multiple rows with (5200), (5207)

sample program (5237)

updatable (5234)

use in CLI (5402)

cursor stability (7708)

cursor usage in REXX (7476)

CURSOR.SQB COBOL program listing (5225)

CURSOR.SQC C program listing (5221)

CURSOR.SQF FORTRAN program listing (5227)

Cursor.sqlj Java program listing (5223)

cursors declared WITH HOLD

X/Open XA Interface (6499)

data

avoiding bottlenecks when extracting (6572)

extracting large volumes (6571)

data control language (DCL) (7653)

data definition language (DDL) (7617)

data manipulation language (DML) (7622)

Data Movement Utilities Guide and Reference (7763)

data relationship consideration

application logic (5005)

referential integrity (5001)

triggers (5003)

data sources in federated systems

accessing tables, views (6602)

invoking functions (6638)

mapping data types from (6622)

mapping DB2 functions to (6639)

mapping isolation levels to (6620)

using distributed requests to query (6631)

using pass-through to query (6655)

data structure

allocating for stored procedures (5427)

manipulating for DB2DARI stored procedure (7526)

SQLEDBDESC (6266)

user-defined, with multiple threads (6469)

data structures, declaring (4874)

data transfer

updating (5258)

data type mappings

ALTER NICKNAME statement (6628)

CREATE TYPE MAPPING statement (6626)

creating for data sources (6624)

creating for specific columns (6627)

default (6623)

data types

BLOBs (5579)

character conversion overflow (6408)

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

CLOB in C/C++ (6913)

CLOBs (5580)

conversion

between DB2 and C/C++ (6838)

between DB2 and COBOL (7184)

between DB2 and FORTRAN (7341)

between DB2 and Java (6924)

between DB2 and OLE DB table function (6054)

between DB2 and REXX (7455)

conversion between DB2 and OLE automation (5970)

data value control consideration (4988)

DBCLOBs (5581)

decimal

in FORTRAN (7385)

description (4885)

Extended UNIX Code consideration (6400)

FOR BIT DATA

in C/C++ (6911)

FOR BIT DATA, in COBOL (7232)

how they are passed to a UDF (5866)

in C/C++ (6834)

in COBOL (7180)

in FORTRAN (7338)

Java stored procedures (DB2GENERAL) (7566)

list of types and their representations in UDFs (5867)

numeric (7628)

object-oriented (5541)

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

selecting graphic types (6814)

SQL column types, list of (5160)

supported

in C/C++ (6832), (6837), (6905)

in COBOL (7178), (7183)

in COBOL, rules for (7231)

in FORTRAN (7336)

in FORTRAN, rules for (7388)

in OLE automation UDFs (5969)

VARCHAR in C/C++ (6912)

data value control consideration

application logic and variable type (4995)

data types (4987)

referential integrity constraints (4991)

table check constraints (4989)

views with check option (4993)

database access

using different contexts (6444)

using multiple threads (6443)

database creation, specifying collating sequence (6264)

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

database manager APIs

calling using stored procedures (5421)

defining, sample programs (5261)

DATE OLE automation type (6017)

DATE parameter to UDF (5900)

DATE SQL data type (5177), (5990)

C/C++ (6855)

COBOL (7201)

FORTRAN (7357)

Java (6942)

Java stored procedures (DB2GENERAL) (7583)

OLE DB table function (6071)

REXX (7471)

DB2 BIND command

creating packages (5081)

DB2 Call Level Interface (DB2 CLI)

access to data consideration (4960)

DB2 Connect (7607)

isolation level (7718)

DB2 Connect Enterprise Edition for OS/2 and Windows NT Quick Beginnings (7783)

DB2 Connect Enterprise Edition for UNIX Quick Beginnings (7784)

DB2 Connect Personal Edition Quick Beginnings (7764)

DB2 Connect programming considerations (7610)

DB2 Connect User's Guide (7765)

DB2 Data Links Manager for AIX Quick Beginnings (7785)

DB2 Data Links Manager for Windows NT Quick Beginnings (7786)

DB2 Enterprise - Extended Edition for UNIX Quick Beginnings (7781)

DB2 Enterprise - Extended Edition for Windows NT Quick Beginnings (7782)

DB2 library

books (7755)

Information Center (7793)

language identifier for books (7790)

late-breaking information (7791)

online help (7754)

ordering printed books (7798)

printing PostScript books (7797)

searching online information (7796)

setting up document server (7794)

SmartGuides (7753)

structure of (7752)

viewing online information (7792)

DB2 Personal Edition Quick Beginnings (7777)

DB2 PREP command

example of (5061)

overview of (5060)

DB2 program

set up (4878)

DB2 Query Patroller Administration Guide (7787)

DB2 Query Patroller Installation Guide (7788)

DB2 Query Patroller User's Guide (7789)

DB2 System Controller (5514)

DB2 Universal Database for AS/400

FOR BIT DATA stored procedure considerations (5490)

DB2 Universal Database for OS/390

FOR BIT DATA stored procedure considerations (5489)

DB2 using DB2 Connect (7604)

DB2Appl.java

application example (6981)

DB2ARXCS.BND REXX bind file (7488)

DB2ARXNC.BND REXX bind file (7492)

DB2ARXRR.BND REXX bind file (7489)

DB2ARXRS.BND REXX bind file (7491)

DB2ARXUR.BND REXX bind file (7490)

db2bfd, bind file dump utility (5110)

db2dari executable (5473)

DB2DARI stored procedures (5460)

db2diag.log file (6581)

DB2GENERAL stored procedures (5461)

DB2INCLUDE environment variable (6750), (7146), (7304)

db2nodes.cfg file (6595)

db2udf executable (6142)

DB2Udf.java (5918)

DBCLOB

Chinese (Traditional) code sets (6365)

Japanese code sets (6364)

dbclob C/C++ type (6878)

DBCLOB parameter to UDF (5905)

DBCLOB SQL data type (5176), (5989)

C/C++ (6854)

COBOL (7200)

Java (6941)

Java stored procedures (DB2GENERAL) (7582)

OLE DB table function (6070)

REXX (7470)

DBCLOB type (7055)

DBCLOB-FILE COBOL type (7215)

DBCLOB-LOCATOR COBOL type (7214)

DBCLOBs (Double-Byte Character Large Objects)

uses and definition (5567)

dbclob_file C/C++ type (6880)

dbclob_locator C/C++ type (6879)

DBCS (6320) See also double-byte character set

dbinfo (6090)

DBINFO keyword (5827)

dbinfo, passing to UDF (5824)

dbminfo argument, elements of (5828)

(ver_rel) version/release number (5852)

application authorization ID (authid) (5835)

application authorization ID length (authidlen) (5833)

appl_id (unique application identifier) (5859)

authid (application authorization ID) (5836)

authidlen (application authorization ID length) (5834)

codepg (database code page) (5838)

colname (column name) (5850)

colnamelen (column name length) (5848)

column name (colname) (5849)

column name length (colnamelen) (5847)

data base name (dbname) (5831)

data base name length (dbnamelen) (5829)

database code page (codepg) (5837)

dbname (data base name) (5832)

dbnamelen (data base name length) (5830)

numtfcol (table function columns entries) (5855)

platform (5853)

schema name (tbschema) (5841)

schema name length (tbschemalen) (5839)

table function column list (tfcolumn) (5856)

table function columns entries (numtfcol) (5854)

table name (tbname) (5845)

table name length (tbnamelen) (5843)

tbname (table name) (5846)

tbnamelen (table name length) (5844)

tbschema (schema name) (5842)

tbschemalen (schema name length) (5840)

tfcolumn (table function column list) (5857)

unique application identifier (appl_id) (5858)

version/release number (ver_rel) (5851)

DCL (data control language) (7652)

DDL (data definition language) (7616)

deadlocks

error in buffered insert (6558)

in multithreaded applications (6481)

preventing in multiple contexts (6484)

debugging

Java programs (6964)

SQLJ programs (6965)

stored procedures (5511), (5527)

using Stored Procedure Builder (7038)

using Visual Studio (5529)

debugging your UDF (6179)

DECIMAL parameter to UDF (5878)

DECIMAL SQL data type (5166), (5975)

C/C++ (6844)

COBOL (7190)

FORTRAN (7347)

Java (6931)

Java stored procedures (DB2GENERAL) (7572)

OLE DB table function (6060)

REXX (7460)

DECLARE CURSOR statement (4912)

DECLARE CURSOR statement, overview of (5204)

DECLARE PROCEDURE statement (OS/400) (7722)

declare section

in C/C++ (6766), (6903)

in COBOL (7149), (7230)

in FORTRAN (7317), (7387)

rules for statements (5146)

DECLARE STATEMENT

DECLARE statement

DB2 Connect support (7743)

DB2 Connect support (7735)

declaring

host variable, rules for (5144)

indicator variables (5150)

deferring the evaluation of a LOB expression example (5605)

defining the UDT and UDFs example (5558)

DELETE

DB2 Connect support (7626)

triggers (6218)

DELETE operation and triggers (6200)

DESCRIBE statement

DB2 Connect support (7737), (7744)

double-byte character set consideration (6396)

Extended UNIX Code consideration (6395)

Extended UNIX Code consideration with EUC database (6397)

processing arbitrary statements (5374)

descriptor handle (5408)

designing DB2 applications, guidelines (4950)

DFT_SQLMATHWARN configuration parameter (5782)

diagnostic-message, passing to UDF (5794)

differences between different DB2 products (7615)

differences between host or AS/400 server and workstation (7733), (7741)

differences in SQLCODEs and SQLSTATEs (7710)

directed DSS (6514)

distinct type (5640)

distributed environment (7608)

distributed requests

coding (6632)

optimizing (6634)

divid() UDF C program listing (6150)

DML (data manipulation language) (7621)

double C/C++ type (6866)

double Java type (6948)

double OLE automation type (6016)

DOUBLE parameter to UDF (5880), (5883)

DOUBLE PRECISION parameter to UDF (5884)

DOUBLE SQL data type (5168), (5977)

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

double-byte character set

Chinese (Traditional) code sets (6349)

configuration parameters (6315)

considerations for collation (6366)

Japanese code sets (6348)

mixed code set environments (6370)

Traditional Chinese considerations (6341)

unequal code pages (6373)

double-byte character set (DBCS)

Chinese (Traditional) code sets (6326)

Japanese code sets (6325)

double-byte code pages (6334)

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

DUOW (6420) See also multisite update

dynamic cursors (7680)

dynamic memory, allocating in the UDF (6122)

dynamic SQL

arbitrary statements, processing of (5372)

authorization considerations (5019)

comparing to static SQL (5332)

considerations (5333)

contrast with dynamic SQL (5121)

cursor processing (5337)

cursor processing, sample program (5339)

DB2 Connect support (7612)

declaring an SQLDA (5353)

EXECUTE IMMEDIATE statement, summary of (5320)

EXECUTE statement, summary of (5326)

limitations (5329)

overview (5314)

parameter markers in (5386)

PREPARE statement, summary of (5323)

supported statements, list of (5316)

syntax, differences with static (5328)

using PREPARE, DESCRIBE, and FETCH (5334)

dynamic statements

binding (5086)

DYNAMIC.CMD REXX program listing (5349)

Dynamic.java Java program listing (5343)

DYNAMIC.SQB COBOL program listing (5345)

DYNAMIC.SQC C program listing (5341)

DYNAMIC.SQF FORTRAN program listing (5347)

easier maintenance using triggers (6192)

EBCDIC

mixed-byte data (7631)

sort order (7695)

embedded SQL

access to data consideration (4956)

embedded SQL statement

comments, rules for (6759)

examples of (5050)

overview of (5043)

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

rules for, in COBOL (7140)

rules for, in FORTRAN (7307)

syntax rules (5048)

embedded SQL statements

comments, rules for (7142), (7309)

host variable, referencing in (5149)

encapsulation and UDTs (5720)

END DECLARE SECTION (4884)

ending transactions (4924)

ending transactions implicitly (4945)

environment APIs

include file for C/C++ (6708)

include file for COBOL (7100)

include file for FORTRAN (7276)

environment handle (5406)

environment,for programming (4869)

error code (4895) See also SQLCODE or SQLSTATE

error detection in a buffered insert (6547)

error handling

C/C++ language precompiler (6752)

considerations in a partitioned environment (6576)

during precompilation (5067)

identifying partition that returns the error (6593)

in a looping application (6596)

in a suspended application (6597)

include file

for C/C++ applications (6728), (6731)

for FORTRAN (7267), (7298)

in COBOL (7090), (7093), (7127)

merged multiple SQLCA structures (6583)

overview of (5278)

reporting (6586)

resetting (4904)

SQLCA structure (6587)

SQLCODE (6588)

using WHENEVER statement (5293)

WHENEVER statement (4901)

with the SQLCA (4890)

error messages

error conditions flag (5286)

exception condition flag (5285)

SQLCA structure (5281)

SQLSTATE (5288)

SQLWARN structure (5290)

timestamps, when precompiling (5115)

warning condition flag (5284)

EUC (6318) See also Extended UNIX Code

examples

ADHOC.SQC C program listing (5383)

application forms using CREATE TABLE (5734)

assignments in dynamic SQL (5750)

assignments involving different UDTs (5752)

assignments involving UDTs (5748)

AVG over a UDT (5683)

BLOB data declarations (6781)

CHECKERR REXX program listing (5312)

CHECKERR.CBL program listing (5308)

CLOB data declarations (6782)

CLOB file reference (6789)

CLOB locator (6786)

comparisons involving UDTs (5740), (5744)

cost of a UDT (5681)

counter for UDFs (6162)

counter OLE automation UDF object in BASIC (6170)

counter OLE automation UDF object in C++ (6172)

counting and defining UDFs (5685)

counting with an OLE automation object (5687)

ctr() UDF C program listing (6164)

CURSOR.SQB COBOL program listing (5224)

CURSOR.SQC C program listing (5220)

CURSOR.SQF FORTRAN program listing (5226)

Cursor.sqlj Java program listing (5222)

DB2Appl.java (6980)

DBCLOB data declarations (6783)

declaring BLOB file references using COBOL (7169)

declaring BLOB file references using FORTRAN (7335)

declaring BLOB locator using COBOL (7166)

declaring BLOBs using COBOL (7161)

declaring BLOBs using FORTRAN (7328)

declaring CLOB file locator using FORTRAN (7332)

declaring CLOBs using COBOL (7162)

declaring CLOBs using FORTRAN (7329)

declaring DBCLOBs using COBOL (7163)

deferring the evaluation of a LOB expression (5604)

defining the UDT and UDFs (5557)

divid() UDF C program listing (6149)

DYNAMIC.CMD REXX program listing (5348)

Dynamic.java Java program listing (5342)

DYNAMIC.SQB COBOL program listing (5344)

DYNAMIC.SQC C program listing (5340)

DYNAMIC.SQF FORTRAN program listing (5346)

exploiting LOB function to populate the database (5559)

exploiting UDFs to query instances of UDTs (5561)

exponentiation and defining UDFs (5673)

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

extracting large volumes of data

program listing (6573)

find the vowel, fold the CLOB (6154)

findvwl() UDF C program listing (6159)

fold() UDF C program listing (6157)

function invocations (5697)

function using LOB locator (6168)

implementation of OLE automation UDF

in BASIC language (5952), (6028)

in C++ language (6030), (6035)

INPCLI.SQF FORTRAN program listing (7595)

INPSRV.CMD REXX program listing (7600)

inserting data into a CLOB column (5631)

integer divide operator for UDFs (6147)

Java applets (6984)

LOBEVAL.SQB COBOL program listing (5610)

LOBEVAL.SQC C program listing (5608)

LOBFILE.SQB COBOL program listing (5629)

LOBFILE.SQC C program listing (5627)

LOBLOC.SQB COBOL program listing (5600)

LOBLOC.SQC C program listing (5598)

LOBLOC.SQF FORTRAN program listing (5602)

mail OLE automation UDF object in BASIC (6174)

money using CREATE DISTINCT TYPE (5727)

OPENFTCH.SQB COBOL program listing (5242)

OPENFTCH.SQC C program listing (5238)

OPENFTCH.SQF FORTRAN program listing (5244)

Openftch.sqlj Java program listing (5240)

Outcli.java Java program listing (5481)

Outsrv.sqlj Java program listing (5483)

parameter markers in functions (5700)

registering SQLEXEC, SQLDBS and SQLDB2

on AIX (7414)

registering SQLEXEC, SQLDBS and SQLDB2 for REXX

on OS/2 (7412)

on Windows (7413)

resume using CREATE DISTINCT TYPE (5728)

sales using CREATE TABLE (5733)

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

search string and BLOBs (5677)

SQLException handling (5306)

static update (5266)

STATIC.SQB COBOL program listing (5135)

STATIC.SQC C program listing (5131)

STATIC.SQF FORTRAN program listing (5137)

Static.sqlj Java program listing (5133)

string search and defining UDFs (5675)

string search over UDT (5679)

syntax for character host variables in FORTRAN (7322), (7323)

table function returning document IDs (5690)

tfweather_u table function C program listing (6166)

unqualified function reference (5706)

UPDAT.CMD REXX program listing (5276)

UPDAT.SQB COBOL program listing (5272)

UPDAT.SQC C program listing (5268)

UPDAT.SQF FORTRAN program listing (5274)

Updat.sqlj Java program listing (5270)

use of UDTs in UNION (5754)

user-defined sourced functions on UDTs (5746)

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

using class data members in an SQL statement (6805)

using GET ERROR MESSAGE (5303)

using indicator variables (5199)

using parameter markers in search and update (5390)

using qualified function reference (5703)

UTIL.C program listing (5304)

UTIL.F program listing (5310)

Varinp.java Java program listing (5393)

VARINP.SQB COBOL program listing (5395)

VARINP.SQC C program listing (5391)

VARINP.SQF FORTRAN program listing (5397)

EXCSQLSTT, host or AS/400 command (7739)

EXEC SQL INCLUDE SQLCA

multithreading considerations (6473)

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

EXECUTE IMMEDIATE statement, summary of (5319)

EXECUTE statement, summary of (5325)

execution requirements for REXX (7479)

exit routines, use restrictions (5302)

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

Explain Snapshot (5106)

EXPLAIN, prototyping utility (5040)

exploiting

LOB function to populate the database example (5560)

UDFs to query instances of UDTs example (5562)

EXPLSNAP bind option (5104)

exponentiation and defining UDFs example (5674)

extended dynamic SQL statements

not supported in DB2 Connect (7749)

Extended UNIX Code (EUC)

character conversion overflow (6401)

character conversions in stored procedures (6409)

character string length overflow (6406)

Chinese (Traditional)

C/C++ consideration (6826)

REXX consideration (7508)

Chinese (Traditional) code sets (6324), (6345)

client-based parameter validation (6391)

considerations for collation (6367)

considerations for DBCLOB files (6363)

double-byte code pages (6336)

expansion at application (6389)

expansion at server (6387)

expansion samples (6393)

fixed or varying length data types (6398)

graphic constants (6353)

graphic data handling (6350)

Japanese

C/C++ consideration (6827)

REXX consideration (7507)

Japanese and traditional Chinese

COBOL consideration (7238)

FORTRAN consideration (7393)

Japanese code sets (6323), (6344)

mixed code pages (6335)

mixed code set environments (6371)

rules for string conversions (6404)

stored procedures considerations (6360)

Traditional Chinese considerations (6340)

UDF considerations (6356)

unequal code pages (6374)

using the DESCRIBE statement (6394)

extensibility and UDTs (5717)

extern declaration

C++ (6680)

EXTERNAL ACTION option and UDFs (6125)

EXTERNAL clause (5450)

EXTERNAL NAME clause (6044), (6048)

extracting

large volumes of data (6570)

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

faster application development using triggers (6190)

federated database

collating sequences, guidelines (6272)

federated systems

column options (6613)

data integrity (6619)

data source functions (6637)

data source tables, views

cataloging information about (6608)

considerations, restrictions (6610)

nicknames for (6606)

data type mappings (6621)

distributed requests (6630)

function mapping options (6650)

function mappings (6640)

introduction (6601)

isolation levels (6618)

nicknames (6605)

pass-through (6654)

server options (6633)

FENCED option and UDFs (6126)

FETCH call (5821)

FETCH statement

host variables (5335)

repeated access, technique for (5249)

scroll backwards, technique for (5246)

using SQLDA structure with (5361)

file extensions

sample programs (7517)

file reference declarations in REXX (7451)

file reference variables

examples of using (5624)

for manipulating LOBs (5576)

input values (5615)

output values (5619)

FINAL CALL clause (5822)

FINAL CALL keyword (5806)

final call, to a UDF (5809)

finalize Java method (5933)

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

findvwl() UDF C program listing (6160)

FIPS 127-2 standard (4898)

first call, to a UDF (5810)

FIRST call (5819)

fixed or varying length data types

Extended UNIX Code consideration (6399)

flagger utility, used in precompiling (5074)

flexibility and UDTs (5718)

float C/C++ type (6865)

float OLE automation type (6015)

FLOAT parameter to UDF (5885)

FLOAT SQL data type (5165), (5974)

C/C++ (6842)

COBOL (7188)

FORTRAN (7345)

Java (6929)

Java stored procedures (DB2GENERAL) (7570)

OLE DB table function (6058)

REXX (7458)

floating point parameter to UDF (5881)

flushed buffered insert (6523)

fold() UDF C program listing (6158)

FOR BIT DATA

considerations for stored procedures (5488)

data type in C/C++ (6914)

FOR BIT DATA modifier in UDFs (5888)

FOR BIT DATA SQL data type (5980)

FOR EACH ROW trigger (6207)

FOR EACH STATEMENT trigger (6208)

FOR UPDATE clause (5228)

FORCE command (7673)

foreign key, DB2 Connect support (7702)

FORTRAN

data types supported (7337), (7386)

embedding SQL statements (5045)

file reference declarations (7334)

host variables, overview (7314)

indicator variables, rules for (7325)

input and output files (7249)

Japanese and traditional Chinese EUC considerations (7395)

LOB data declarations (7327)

LOB locator declarations (7331)

programming considerations (7244)

programming restrictions (7247)

referencing host variables (7312)

FORTRAN data types

BLOB (7382)

BLOB_FILE (7384)

BLOB_LOCATOR (7383)

CHARACTER*n (7378)

CLOB (7379)

CLOB_FILE (7381)

CLOB_LOCATOR (7380)

INTEGER*2 (7373)

INTEGER*4 (7374)

REAL*2 (7375)

REAL*4 (7376)

REAL*8 (7377)

FORTRAN language

data types supported (7339)

fullselect

buffered insert consideration (6566)

fullselect consideration (6567)

fully qualified name (6045)

FUNCPATH bind option (5105)

function directory (5451)

function invocations example (5698)

function mappings

CREATE FUNCTION MAPPING statement (6641), (6645)

options (6651)

function path and UDFs (5648)

function references, summary for UDFs (5709)

function selection algorithm and UDFs (5650)

function templates (6643)

function-name, passing to UDF (5788)

functions

aggregating functions (5657)

column functions (5656)

scalar functions (5655)

syntax for referring to (5696)

table functions (5658)

with SQL triggered statements (6233)

GENERAL stored procedures (5457)

GENERAL WITH NULLS stored procedures (5458)

GET ERROR MESSAGE API (7429)

getAsciiStream JDBC API (7067)

getString JDBC API (7066)

getUnicodeStream JDBC API (7068)

global enforcement of business rules using triggers (6191)

Glossary (7767)

GRANT statement

DB2 Connect support (7654)

graphic constants

Chinese (Traditional) code sets (6355)

Japanese code sets (6354)

graphic data

Chinese (Traditional) code sets (6330), (6352)

Japanese code sets (6329), (6351)

graphic data types

selecting (6815)

graphic host variables

C/C++ (6778)

COBOL (7155)

GRAPHIC parameter to UDF (5891)

GRAPHIC SQL data type

C/C++ (6849)

COBOL (7195)

FORTRAN, not supported in (7352)

Java (6936)

Java stored procedures (DB2GENERAL) (7577)

OLE DB table function (6065)

REXX (7465) See also VARGRAPHIC SQL data type

graphic strings

character conversion (6313)

GRAPHIC type (7054)

graphical objects

considerations for Java (7051)

GROUP BY clause

sort order (7698)

group of rows

in buffered insert (6546)

guideline

access to data (4953)

application logic at server (5008)

data relationship control (4999)

data value control (4985)

DB2 application design (4949)

handle

connection handle (5410)

descriptor handle (5411)

environment handle (5409)

statement handle (5405)

host or AS/400

accessing host servers (6442)

Host or AS/400 environment, programming (7603)

host variables

allocating in stored procedures (5425)

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

clearing LOB host variables in REXX (7452)

considerations for stored procedures (5495)

declaring (5143)

in C/C++ (6768)

in COBOL (7150)

in FORTRAN (7316), (7318)

declaring as pointer to data type (6800)

declaring graphic

in C/C++ (6776)

in COBOL (7156)

declaring using variable list statement (5378)

declaring, examples of (5147)

declaring, rules for (5145)

declaring, sample programs (5263)

definition (5140)

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

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

file reference declarations in COBOL (7167)

file reference declarations in FORTRAN (7333)

file reference declarations in REXX (7449)

FORTRAN, overview of (7313)

graphic data (6811)

handling graphic

multi-byte character encoding (6812)

WCHARTYPE precompiler option (6820)

in REXX (7424)

initializing for stored procedure (5424)

initializing in C/C++ (6790)

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

LOB data declarations in COBOL (7159)

LOB data declarations in FORTRAN (7326)

LOB data in REXX (7445)

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

LOB locator declarations in COBOL (7164)

LOB locator declarations in FORTRAN (7330)

LOB locator declarations in REXX (7447)

naming

in C/C++ (6764)

in COBOL (7148)

in FORTRAN (7315)

in REXX (7425)

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

referencing

in C/C++ (6763)

in COBOL (7147)

in FORTRAN (7311)

in REXX (7426)

referencing from SQL, examples (5148)

relating to an SQL statement (4886)

selecting graphic data types (6813)

static SQL (5142)

use in dynamic SQL (5317)

used to pass blocks of data (6510)

how to use this book (4866)

HTML page

tagging for Java applets (6983)

identity sequence (6256)

implementing a UDF (5664)

implicit connect (7660)

IN stored procedure parameters (5443), (5467)

include file

C/C++ requirements for (6686)

COBOL requirements for (7079)

FORTRAN requirements for (7250)

SQL

C/C++ (6687)

COBOL (7082)

FORTRAN (7251)

SQL1252A

COBOL (7118)

FORTRAN (7291)

SQL1252B

COBOL (7119)

FORTRAN (7293)

SQLADEF

C/C++ (6690)

SQLAPREP

C/C++ (6692)

COBOL (7084)

FORTRAN (7254)

SQLCA

C/C++ (6693)

COBOL (7085)

FORTRAN (7255)

SQLCA_92

COBOL (7089)

FORTRAN (7262)

SQLCA_CN

FORTRAN (7256)

SQLCA_CS

FORTRAN (7257)

SQLCLI

C/C++ (6697)

SQLCLI1

C/C++ (6699)

SQLCODES

C/C++ (6700)

COBOL (7092)

FORTRAN (7266)

SQLDA

C/C++ (6702)

COBOL (7095)

FORTRAN (7268)

SQLDACT

FORTRAN (7269)

SQLE819A

C/C++ (6711)

COBOL (7105)

FORTRAN (7278)

SQLE819B

C/C++ (6714)

COBOL (7108)

FORTRAN (7281)

SQLE850A

C/C++ (6716)

COBOL (7110)

FORTRAN (7283)

SQLE850B

C/C++ (6718)

COBOL (7112)

FORTRAN (7285)

SQLE932A

C/C++ (6720)

COBOL (7114)

FORTRAN (7287)

SQLE932B

C/C++ (6722)

COBOL (7116)

FORTRAN (7289)

SQLEAU

C/C++ (6704)

COBOL (7096)

FORTRAN (7272)

SQLENV

C/C++ (6707)

COBOL (7099)

FORTRAN (7275)

SQLETSD

COBOL (7102)

SQLEXT

C/C++ (6709)

SQLJACB

C/C++ (6724)

SQLMON

C/C++ (6727)

COBOL (7122)

FORTRAN (7295)

SQLMONCT

COBOL (7124)

SQLSTATE

C/C++ (6730)

COBOL (7126)

FORTRAN (7297)

SQLSYSTM

C/C++ (6732)

SQLUDF

C/C++ (6735)

SQLUTBCQ

COBOL (7129)

SQLUTBSQ

COBOL (7132)

SQLUTIL

C/C++ (6737)

COBOL (7135)

FORTRAN (7300)

SQLUV

C/C++ (6739)

SQLUVEND

C/C++ (6741)

SQLXA

C/C++ (6744)

include files

locating in C/C++ (6749)

locating in COBOL (7145)

locating in FORTRAN (7303)

INCLUDE SQLCA

pseudocode (4888)

INCLUDE SQLDA statement (4911)

INCLUDE SQLDA statement, creating SQLDA structure (5367)

INCLUDE statement (4910)

inconsistent data (4919)

inconsistent state (4920)

indicator tables, COBOL support for (7171)

indicator variables

declaring (5151)

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

in COBOL, rules for (7157)

in FORTRAN, rules for (7324)

in REXX, rules for (7427)

using in DB2DARI stored procedures (7529)

using on nullable columns (5198)

indicator variables and LOB locators (5613)

infix notation and UDFs (5712)

INOUT stored procedure parameters (5445)

INOUT stored procedure paramter (5470)

INPCLI.SQF FORTRAN program listing (7596)

INPSRV.CMD REXX program listing (7601)

input and output files

C/C++ (6681)

COBOL (7076)

FORTRAN (7248)

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

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

INSERT BUF bind option

buffered inserts (6536)

INSERT operation and triggers (6198)

INSERT statement

DB2 Connect support (7624), (7639)

not supported in CLP (6568)

with VALUES clause (6531)

inserting data into a CLOB column example (5632)

inserts

without buffered insert (6528)

Installation and Configuration Supplement (7768)

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

Int Java type (6947)

INTEGER (5804)

integer divide operator for UDFs example (6148)

INTEGER or INT parameter to UDF (5876)

INTEGER SQL data type (5163), (5973)

C/C++ (6840)

COBOL (7186)

FORTRAN (7343)

Java (6927)

Java stored procedures (DB2GENERAL) (7568)

OLE DB table function (6056)

REXX (7457)

INTEGER*2 FORTRAN type (7361)

INTEGER*4 FORTRAN type (7362)

interactive SQL

processing, sample program (5381)

interrupt handling with SQL statements (5294)

interrupts, SIGUSR1 (5301)

invoking UDFs (5693)

ISO 10646 standard (6332)

ISO 2022 standard (6331)

ISO/ANS SQL92 (7689)

ISO/ANS SQL92 standard (4899)

isolation level (6617), (7717)

Japanese and traditional Chinese EUC code sets

COBOL considerations (7237)

FORTRAN considerations (7392)

Japanese code sets (6316)

C/C++ considerations (6824)

developing applications using (6342)

Japanese EUC code sets

REXX considerations (7505)

Java

applet support (6970)

application support (6969)

comparison of SQLJ with JDBC (6920)

comparison with other languages (6923)

debugging (6963)

distributing and running applets (6982)

distributing and running applications (6979)

embedding SQL statements (5046)

installing JAR files (7043), (7046)

JDBC

example program using (6978)

JDBC specification (6967)

overview (6919)

overview of DB2 support for (6968)

SQLJ (Embedded SQL for Java)

calling stored procedures (7022)

example program using (7017)

host variables (7019)

SQLJ (Embedded SQLJ for Java) (6989)

applets (7002)

db2profc (6996), (6997)

db2profp (6995)

declaring cursors (7015)

declaring iterators (7014)

embedding SQL statments in (7006)

example clauses (7007)

positioned DELETE statement (7013)

positioned UPDATE statement (7012)

profconv (6998)

restrictions (7003)

translator (6999)

SQLJ specification (6966)

stored procedures (7042), (7045)

examples (7048)

UDFs (user-defined functions) (7044), (7047)

examples (7049)

Java application

SCRATCHPAD consideration (5932)

signature for UDFs (5921)

using graphical and large objects (7050)

Java class files

CLASSPATH environment variable (7032)

java_heap_sz configuration parameter (7034)

jdk11_path configuration parameter (7033)

where to place (7031)

Java data types

BigDecimal (6955)

Blob (6958)

double (6954)

Int (6953)

java.math.BigDecimal (6956)

short (6952)

String (6957)

Java Database Connectivity (6972) See also JDBC

Java I/O streams

System.err (5925)

System.in (5923)

System.out (5924)

Java packages and classes (6971)

COM.ibm.db2.app (6925)

JAVA stored procedures (5459)

Java UDF consideration (5763)

java.math.BigDecimal Java type (6949)

java_heap_sz configuration parameter (7037)

JDBC

access to data consideration (4964)

APIs

getAsciiStream (7061)

getString (7060)

getUnicodeStream (7062)

setAsciiStream (7058)

setString (7057)

setUnicodeStream (7059)

comparison with SQLJ (6921)

drivers

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

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

installing (6987)

version 1.22 (6985)

version 2.0 (6986)

example program using (6977)

SQLJ interoperability (7070)

jdk11_path configuration parameter (7036)

LABEL ON statement

DB2 Connect support (7736)

LANGLEVEL precompile option

MIA

SAA1 (6906)

using SQL92E and SQLSTATE or SQLCODE variables (6918), (7235), (7391)

LANGLEVEL SQL92E precompile option (7688)

LANGUAGE OLE clause (5950)

large object data type (7641) See also LOB data type

large object descriptor (5578)

large object value (5577)

latch

status with multiple threads (6450)

limitations

stored procedures (DB2DARI) (7525)

linking

client application (5507)

overview of (5076)

stored procedures (5505)

linking a UDF (5666)

LOB data type

supported by DB2 Connect Version 6 (7640)

LOB locator APIs, used in UDFs

sqludf_append API (6107)

sqludf_create_locator API (6108)

sqludf_free_locator API (6109)

sqludf_length API (6105)

sqludf_substr API (6106)

LOB locator example program listing (6169)

LOB locators

scenarios for using (6111)

used in UDFs (6094)

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

LOBEVAL.SQB COBOL program listing (5611), (5630)

LOBEVAL.SQC C program listing (5609), (5628)

LOBLOC.SQB COBOL program listing (5601)

LOBLOC.SQC C program listing (5599)

LOBLOC.SQF FORTRAN program listing (5603)

LOBs (Large Objects)

and DB2 object extensions (5542)

considerations for Java (7052)

file reference variables (5572)

examples of using (5623)

input values (5614)

output values (5618)

SQL_FILE_APPEND, output value option (5622)

SQL_FILE_CREATE, output value option (5620)

SQL_FILE_OVERWRITE, output value option (5621)

SQL_FILE_READ, input value option (5616)

large object descriptor (5574)

large object value (5571)

locators (5573), (5593)

example of using (5595), (5606)

indicator variables (5612)

programming scenarios (5607)

manipulating (5544)

programming options for values (5594)

storing (5543)

synergy with triggers, UDTs, and UDFs (6244)

synergy with UDTs and UDFs

examples of complex applications (5556)

local bypass (6516)

locales

deriving in application programs (6287)

how DB2 derives (6288)

locating include files

C/C++ (6748)

COBOL (7144)

FORTRAN (7302)

locators for manipulating LOBs (5575)

locking (7705)

buffered insert error (6557)

LOCKTIMEOUT configuration parameter (6485)

LOCKTIMEOUT multisite update configuration parameter (6430)

long C/C++ type (6861)

long field restriction

using buffered inserts (6564)

long fields (7638)

long int C/C++ type (6862)

long long C/C++ type (6863)

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

long OLE automation type (6014)

LONG VARCHAR

parameter to UDF (5890)

storage limits (5563)

LONG VARCHAR SQL data type (5171), (5982)

C/C++ (6848)

COBOL (7194)

FORTRAN (7351)

Java (6935)

Java stored procedures (DB2GENERAL) (7576)

OLE DB table function (6064)

REXX (7464)

LONG VARGRAPHIC

parameter to UDF (5897)

storage limits (5564)

LONG VARGRAPHIC SQL data type (5173), (5984)

C/C++ (6851)

COBOL (7197)

FORTRAN (7354)

Java (6938)

Java stored procedures (DB2GENERAL) (7579)

OLE DB table function (6067)

REXX (7467)

LONGVAR type (7053)

looping application

diagnosing (6598)

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

macros in sqludf.h (5913)

mail OLE automation UDF object example in BASIC (6175)

manipulating large objects (5549)

maxdari configuration parameter (7030)

maximum size for large object columns, defining (5583)

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

memory

decreasing requirement using LOB locators (6098)

memory allocation for unequal code pages (6380)

memory size, shared for UDFs (6129)

memory, allocating dynamic in the UDF (6121)

message file, definition of (5068)

Message Reference (7769)

method invocation

for OLE automation UDFs (5958)

MIA (6907)

Microsoft Exchange, used in mail example (6176)

Microsoft specifications

access to data consideration (4978)

ADO (ActiveX Data Object) (4973)

MTS (Microsoft Transaction Server) (4975)

RDO (Remote Data Object) (4974)

Visual Basic (4977)

Visual C++ (4976)

Microsoft Transaction Server specification

access to data consideration (4979)

mixed code set environments

application design (6372)

mixed Extended UNIX Code considerations (6333)

mixed-byte data (7629)

model for DB2 programming (4947)

modelling entities as independent objects (5533)

money using CREATE DISTINCT TYPE example (5729)

moving large objects using a file reference variable (5582)

multi-byte character support

code points for special characters (6293)

multi-byte code pages

Chinese (Traditional) code sets (6328), (6347)

Japanese code sets (6327), (6346)

multi-byte considerations

Chinese (Traditional) code sets

in C/C++ (6829)

Chinese (Traditional) EUC code sets

in REXX (7510)

Japanese and traditional Chinese EUC code sets

in COBOL (7239)

in FORTRAN (7394)

Japanese code sets

in C/C++ (6828)

Japanese EUC code sets

in REXX (7509)

multiple definitions of SQLCA, avoiding (4906)

multiple threads

application dependencies between contexts (6477)

database dependencies between contexts (6474)

guidelines (6468)

preventing deadlocks between contexts (6482)

using in DB2 applications (6446)

multiple triggers, ordering of (6239)

multisite update (6414), (7731) See also multisite update, multisite update

coding SQL for a multisite update application (6423)

configuration parameters (6424)

considerations with stored procedures (5500)

DB2 Connect support (7730)

general considerations (6415)

overview (6421)

restrictions (6425)

when to use (6422)

multisite update configuration parameter

LOCKTIMEOUT (6431)

RESYNC_INTERVAL (6429)

SPM_LOG_NAME (6440)

SPM_NAME (6437)

SPM_RESYNC_AGENT_LIMIT (6435)

TM_DATABASE (6427)

TP_MON_NAME (6433)

national language support

mixed-byte data (7630)

national language support (NLS)

character conversion (6305)

code page (6306)

considerations (6249)

nicknames

cataloging related information (6607)

considerations, restrictions (6609)

CREATE NICKNAME statement (6611)

using with views (6616)

NOCONVERT

WCHARTYPE

in stored procedures (5498)

NOLINEMACRO

PREP option (6753)

nonexecutable SQL statements

DECLARE CURSOR (4909)

INCLUDE (4907)

INCLUDE SQLDA (4908)

normal call, to a UDF (5808)

NOT ATOMIC compound SQL (7724)

NOT DETERMINISTIC option and UDFs (6124)

NOT FENCED LOB locator UDFs (6110)

NOT FENCED stored procedures

considerations (5520), (5521)

precompiling (5517)

working with (5513)

NOT NULL CALL clause (5778)

NOT NULL CALL option and UDFs (6123)

NULL value

receiving, preparing for (5152)

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

null-terminator (6910)

numeric conversion overflows (7716)

numeric data types (7627)

numeric host variables

C/C++ (6770)

COBOL (7153)

FORTRAN (7320)

NUMERIC parameter to UDF (5879)

NUMERIC SQL data type (5978)

C/C++ (6845)

COBOL (7191)

FORTRAN (7348)

Java (6932)

Java stored procedures (DB2GENERAL) (7573)

OLE DB table function (6061)

REXX (7461)

object instances

for OLE automation UDFs (5956)

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

object oriented COBOL restrictions (7241)

object, large data type (7642) See also LOB data type

object-orientation and UDFs (5638)

object-oriented extensions and UDTs (5722)

object-relational

application domain and object-orientation (5531)

constraint mechanisms (5539)

data types (5535)

definition (5530)

LOBs (5537)

support for (5553)

triggers (5538)

UDTs and UDFs (5536)

why use the DB2 object extensions (5534)

ODBC

access to data consideration (4962)

OLE automation data types (5971)

BSTR (6025)

DATE (6024)

double (6023)

float (6022)

long (6021)

SAFEARRAY (6026)

short (6020)

OLE automation object counting example (5688)

OLE automation server (5947)

OLE automation types (5960)

OLE automation types and BASIC types (5964)

OLE automation types and C++ types (5965)

OLE automation UDFs

creatable multi-use OLE automation server (6032)

creatable single-use OLE automation server (6031)

implementation (5941)

implementation in BASIC (6027)

implementation in C++ (6029)

object instances (5953)

scratchpad considerations (5954)

UDFs (5938)

OLE DB

example

using connection string (6041)

using CONNECTSTRING option (6039)

using server name (6040)

supported in DB2 (4966)

table functions

CREATE SERVER statement (6047)

CREATE USER MAPPING statement (6051)

creating (6038)

defining a user mapping (6050)

EXTERNAL NAME clause (6043)

fully qualified names (6042)

identifying servers (6046)

overview (6036)

OLE keyword (5939)

OLE messaging example (6177)

OLE programmatic ID (progID) (5945)

open state, buffered insert (6550)

OPENFTCH.SQB COBOL program listing (5243)

OPENFTCH.SQC C program listing (5239)

OPENFTCH.SQF FORTRAN program listing (5245)

Openftch.sqlj Java program listing (5241)

ORDER BY clause

sort order (7697)

OS/400 using DB2 Connect (7605)

OUT stored procedure parameters (5444), (5468)

Outcli.java Java program listing (5482)

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

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

Outsrv.sqlj Java program listing (5484)

overloading

function names (5649)

stored procedure names (5440)

owner (7682)

package

attributes (7685)

creating (5077)

creating for compiled applications (5057)

renaming (5082)

support to REXX applications (7486)

timestamp errors (5114)

page-level locking (7706)

parameter markers (5403)

in functions example (5701)

in processing arbitrary statements (5375)

programming example (5389)

SQLVAR entries (5388)

use in dynamic SQL (5385)

partitioned environment

error handling considerations (6575)

identifying when errors occur (6592)

improving performance (6512)

severe error considerations (6578)

pass-through

COMMIT statement (6657), (6664)

considerations, restrictions (6659)

SET PASSTHRU RESET statement (6662)

SET PASSTHRU statement (6660)

SQL processing (6656)

passing contexts between threads (6453)

performance

dynamic SQL caching (5124)

factors affecting, static SQL (5122)

improving

in partitioned environments (6511)

using buffered inserts (6519)

using directed DSS (6515)

using local bypass (6517)

using stored procedures (5418)

with READ ONLY cursors (6513)

improving with read only cursors (5233)

increasing using LOB locators (6099)

large objects (5592)

NOT FENCED stored procedure (5512)

optimizing with packages (5111)

passing blocks of data (6508)

precompiling static SQL statements (5112)

UDFs (5637)

performance advantages

with buffered insert (6534)

performance and UDTs (5721)

Perl

access to data consideration (4981)

PICTURE (PIC) clause in COBOL types (7205)

portability (5415)

porting applications (7609)

precompile option

WCHARTYPE NOCONVERT (5519)

precompiler

C/C++ language

#include macro (6670)

character set (6676)

debugging (6751)

macro processing (6668)

qualification and member operators (6806)

symbol substitution (6669)

trigraph sequences (6675)

COBOL (7073)

DB2 Connect support (7618), (7674)

FORTRAN (7245)

options (5062)

overview of (5049)

supported languages (4872)

types of output (5063)

precompiling (5071)

accessing DRDA application server through DB2 Connect (5070)

accessing multiple servers (5072)

client application (5508)

example of (5059)

flagger utility (5073)

options, updatable cursor (5236)

overview of (5058)

supporting dynamic SQL statements (5318)

PREP option

NOLINEMACRO (6754)

PREPARE statement

DB2 Connect support (7745)

processing arbitrary statements (5373)

summary of (5322)

preprocessor functions and the SQL precompiler (6792)

prerequisites, for programming (4870)

primary key, DB2 Connect support (7701)

printf() for debugging UDFs (6183)

problem resolution

stored procedures (5526)

processing SQL statements in REXX (7418)

program variable type, data value control consideration (4997)

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

programming considerations

accessing host or AS/400 servers (6441)

collating sequences (6247)

conversion between different code pages (6248)

in a host or AS/400 environment (7602)

in C/C++ (6667)

in COBOL (7072)

in FORTRAN (7243)

in REXX (7396)

national language support (6246)

programming in complex environments (6245)

X/Open XA interface (6488)

programming framework (4946)

protecting UDFs (6114)

prototyping SQL code (5038)

PUT statement

not supported in DB2 Connect (7746)

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

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

qualifier

different platforms (7681)

query products, access to data consideration (4983)

QUERYOPT bind option (5103)

Quick Beginnings for OS/2 (7778)

Quick Beginnings for UNIX (7779)

Quick Beginnings for Windows NT (7780)

RAISE_ERROR built-in function (6232)

RDO specification

supported in DB2 (4970)

re-entrant

stored procedures (5516)

UDFs (6078)

re-use and UDFs (5636)

REAL parameter to UDF (5882)

REAL SQL data type (5167), (5976)

C/C++ (6843)

COBOL (7189)

FORTRAN (7346)

Java (6930)

Java stored procedures (DB2GENERAL) (7571)

OLE DB table function (6059)

REXX (7459)

REAL*2 FORTRAN type (7363)

REAL*4 FORTRAN type (7364)

REAL*8 FORTRAN type (7365)

rebinding

description (5116)

REBIND PACKAGE command (5118)

REDEFINES in COBOL (7172)

REFERENCING clause in the CREATE TRIGGER statement (6221)

referential integrity

data relationship consideration (5002)

DB2 Connect support (7700)

referential integrity constraint

data value control consideration (4992)

registering

OLE automation UDFs (5944)

UDFs (5667)

registering Java stored procedures (7029)

releasing your connection

CMS applications (4928)

to DB2 (4931)

Remote Data Object specification

supported in DB2 (4969)

remote unit of work (6418)

renaming, package (5083)

REORGANIZE TABLE command (6337)

repeatable read, technique for (5248)

Replication Guide and Reference (7770)

reporting errors (6589)

restoring data (4934)

restrictions

for UDFs (6127)

in C/C++ (6795)

in COBOL (7074)

in FORTRAN (7246)

in REXX (7403)

on using buffered inserts (6562)

restrictions for DB2DARI stored procedures (7524)

result code (4893) See also SQLCODE or SQLSTATE

RESULT REXX predefined variable (7438)

result sets

from stored procedures (5523)

resume using CREATE DISTINCT TYPE example (5730)

RESYNC_INTERVAL multisite update configuration parameter (6428)

retrieving

multiple rows (5202)

one row (5130)

rows (5230)

retrieving data

a second time (5252)

scroll backwards, technique for (5247)

updating (5259)

return code (4894) See also SQLCODE or SQLSTATE

SQLCA structure (5279)

RETURNS clause in the CREATE FUNCTION statement (5871)

RETURNS TABLE clause (5772)

REVOKE statement

DB2 Connect support (7655)

REXX

access to data consideration (4958)

API syntax (7493)

bind files

DB2ARXCS.BND REXX bind file (7480)

DB2ARXNC.BND REXX bind file (7484)

DB2ARXRR.BND REXX bind file (7481)

DB2ARXRS.BND REXX bind file (7483)

DB2ARXUR.BND REXX bind file (7482)

calling the DB2 CLP from application (7497)

Chinese (Traditional) considerations (7512)

clearing LOB host variables (7453)

cursor identifiers (7422)

data types supported (7475)

execution requirements (7478)

indicator variables (7428), (7477)

initializing variables (7502)

Japanese considerations (7511)

LOB data (7446)

LOB file reference declarations (7450)

LOB locator declarations (7448)

predefined variables

RESULT (7431)

SQLCA (7434)

SQLISL (7433)

SQLMSG (7432)

SQLRDAT (7437)

SQLRIDA (7436)

SQLRODA (7435)

programming considerations (7405)

registering routines in (7411)

registering SQLEXEC, SQLDBS and SQLDB2 (7406)

restrictions in (7404)

stored procedures in (7501)

supported SQL statements (7419)

REXX and C++ data types (7454)

REXX APIs

SQLDB2 (7399), (7495)

SQLDBS (7398)

SQLEXEC (7397)

ROLLBACK statement (4877)

association with cursor (5214)

backing out changes (4936)

ending transactions (4942)

in DB2 Connect (7672)

restoring data (4937)

rolling back changes (4938)

ROLLBACK WORK RELEASE

not supported in DB2 Connect (7747)

rolling back changes (4935)

row

order of in table, positioning (5256)

order of, controlling (5253)

retrieving multiple with cursor (5229)

retrieving one (5127)

retrieving using SQLDA (5362)

selecting one, with SELECT INTO statement (5129)

row blocking

customizing for performance (6507)

row id, data type (7649) See also ROWID data type

row-level locking (7707)

ROWID data type

supported by DB2 Connect Version 6 (7648)

rows

set of rows affected by triggers (6205)

RQRIOBLK field (7679)

rules that govern operations on large objects (5551)

run-time services

multiple threads, affect on latches (6449)

RUOW (6417) See also remote unit of work

SAA1 (6908)

SAFEARRAY OLE automation type (6019)

sales using CREATE TABLE example (5735)

sample programs (5119) See also examples

Application Program Interface (API) (7515)

embedded SQL statements (7514)

Java stored procedures (7027)

Java UDFs (5917)

location of (7516)

savepoint, buffered insert consideration (6525)

scalar functions (5659)

contents of call-type argument (5812)

schema-name and UDFs (5652)

scratchpad and UDFs (5930), (6077)

SCRATCHPAD clause (5823)

scratchpad considerations

for OLE automation UDFs (5955)

SCRATCHPAD keyword (5800), (5807), (5931), (6079)

SCRATCHPAD option

for OLE automation UDFs (5957)

scratchpad, passing to UDF (5766), (5797)

section number (7738)

SELECT INTO statement

overview of (5128)

SELECT statement

association with EXECUTE statement (5327)

buffered insert consideration (6548)

DB2 Connect support (7623)

declaring an SQLDA (5352)

describing, after allocating SQLDA (5359)

in DECLARE CURSOR statement (5208)

retrieving data a second time (5250)

retrieving multiple rows with (5201)

updating retrieved data (5257)

varying-list, overview of (5376)

self-referencing tables (7703)

semantic behavior of stored objects (5550)

semaphores (6479)

serialization of data structures (6470)

serialization of SQL statement execution (6451)

server options (6635)

SET CURRENT FUNCTION PATH statement (5663)

SET CURRENT PACKAGESET statement (5096)

SET CURRENT statement

DB2 Connect support (7748)

SET PASSTHRU RESET statement (6663)

SET PASSTHRU statement (6661), (6665)

SET SERVER OPTION statement (6636)

setAsciiStream JDBC API (7064)

setString JDBC API (7063)

setting up a DB2 program (4879)

setting up document server (7795)

setUnicodeStream JDBC API (7065)

severe errors

considerations in a partitioned environment (6577)

shared memory size for UDFs (6128)

shift-out and shift-in characters (7633)

short C/C++ type (6859)

short int C/C++ type (6860)

short Java type (6946)

short OLE automation type (6013)

signal handlers

installing, sample programs (5264)

with SQL statements (5295)

SIGNAL SQLSTATE SQL statement to validate input data (6186)

signature, two functions and the same (5653)

SIGUSR1 interrupt (5300)

SIMPLE stored procedures (5455) See also GENERAL stored procedures

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

SMALLINT (5779), (5784)

SMALLINT parameter to UDF (5875)

SMALLINT SQL data type (5162), (5972)

C/C++ (6839)

COBOL (7185)

FORTRAN (7342)

Java (6926)

Java stored procedures (DB2GENERAL) (7567)

OLE DB table function (6055)

REXX (7456)

snapshot monitor

diagnosing a suspended or looping application (6600)

solving problems

numeric conversion overflows (7715)

sort order (7693)

sorting, specifying collating sequence (6265)

source file

creating, overview of (5052)

file name extensions (5065)

modified source file, definition of (5064)

requirements (5069)

SQL file extensions (5051)

source-level debuggers and UDFs (6182)

sourced UDF (5742)

special registers

CURRENT EXPLAIN MODE (5091)

CURRENT FUNCTION PATH (5092)

CURRENT QUERY OPTIMIZATION (5090)

specific-name, passing to UDF (5791)

SPM_LOG_SIZE multisite update configuration parameter (6438)

SPM_NAME multisite update configuration parameter (6436)

SPM_RESYNC_AGENT_LIMIT multisite update configuration parameter (6434)

SQL

authorization considerations (5017)

authorization considerations for dynamic SQL (5018)

authorization considerations for static SQL (5020)

authorization considerations using APIs (5021)

dynamically prepared (5413)

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

SQL Communications Area (SQLCA) (4891)

SQL Data Types

SQL data types (5961), (5968)

BIGINT (5182)

BLOB (5191), (6007)

CHAR (5186), (5999)

CLOB (5192), (6008)

COBOL (7204)

conversion to C/C++ (6858)

DATE (5194), (6010)

DBCLOB (5193), (6009)

DECIMAL (5184)

DOUBLE (5996)

FLOAT (5183), (5995)

FOR BIT DATA (6000)

FORTRAN (7360)

GRAPHIC (6003)

INTEGER (5181), (5994)

Java (6945)

LONG GRAPHIC (6004)

LONG VARCHAR (5188), (6002)

LONG VARGRAPHIC (5190), (6006)

NUMERIC (5998)

OLE DB table function (6074)

REAL (5185), (5997)

REXX (7474)

SMALLINT (5180), (5993)

TIME (5195), (6011)

TIMESTAMP (5196), (6012)

VARCHAR (5187), (6001)

VARGRAPHIC (5189), (6005)

SQL data types, passed to a UDF (5863)

SQL declare section (4880)

SQL Getting Started (7771)

SQL include file

for C/C++ applications (6688)

for COBOL applications (7081)

for FORTRAN applications (7252)

SQL Reference (7772)

SQL statement categories (7613)

SQL statement execution

serialization (6452)

SQL statements

C/C++ syntax (6756)

COBOL syntax (7137), (7139)

DB2 Connect support (7732), (7740)

exception handlers (5298)

FORTRAN syntax (7306)

grouping using stored procedures (5420)

interrupt handlers (5297)

REXX syntax (7416)

saving end user requests (5380)

signal handlers (5296)

supported in REXX (7420)

SQL-argument (5813)

SQL-argument, passing to UDF (5768)

SQL-argument-ind (5814)

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

SQL-result (5815), (6087)

SQL-result, passing to UDF (5770)

SQL-result-ind (5816), (6088)

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

SQL-state, passing to UDF (5785)

SQL/DS using DB2 Connect (7606)

SQL1252A include file

for COBOL applications (7117)

for FORTRAN applications (7290)

SQL1252B include file

for COBOL applications (7120)

for FORTRAN applications (7292)

SQL92 (7690)

SQLADEF include file

for C/C++ applications (6689)

SQLAPREP include file

for C/C++ applications (6691)

for COBOL applications (7083)

for FORTRAN applications (7253)

SQLCA

avoiding multiple definitions (4905)

error reporting in buffered insert (6554)

incomplete insert when error occurs (6555)

multithreading considerations (6471)

SQLERRMC field (7666), (7727)

SQLERRP field (7662)

SQLCA include file

for C/C++ applications (6695)

for COBOL applications (7087)

for FORTRAN applications (7258)

SQLCA predefined variable (7441)

SQLCA structure

defining, sample programs (5262)

include file

for C/C++ applications (6694)

for COBOL applications (7086)

for FORTRAN applications (7259)

merged multiple structures (6584)

overview (5280)

reporting errors (6590)

requirements (5282)

sqlerrd (6585)

SQLERRD(6) field (6594)

SQLWARN1 field (5157)

using in stored procedures (7556)

warnings (5155)

SQLCA.SQLERRD settings on CONNECT (6385)

SQLCA_92 include file

for COBOL applications (7088)

for FORTRAN applications (7263)

SQLCA_92 structure

include file

for FORTRAN applications (7264)

SQLCA_CN include file (7261)

SQLCA_CS include file (7260)

SQLCHAR structure

passing data with (5371)

SQLCLI include file

for C/C++ applications (6696)

SQLCLI1 include file

for C/C++ applications (6698)

SQLCODE

in Java programs (6959)

including SQLCA (4892)

platform differences (7711)

reporting errors (6591)

standalone (7691)

structure (5283)

SQLCODE -1015 (6580)

SQLCODE -1034 (6579)

SQLCODE -1224 (6582)

SQLCODES include file

for C/C++ applications (6701)

for COBOL applications (7091)

for FORTRAN applications (7265)

SQLDA

multithreading considerations (6472)

SQLDA include file

for C/C++ applications (6703)

for COBOL applications (7094)

for FORTRAN applications (7270)

SQLDA structure

association with PREPARE statement (5324)

creating (allocating) (5366)

creating, host language examples (5368)

declaring (5351)

declaring sufficient SQLVAR entities (5357)

fields used in stored procedures

SQLDATA (7560)

SQLIND (7561)

SQLLEN (7559)

SQLTYPE (7558)

initializing for stored procedure (DB2DARI) (7519)

input-SQLDA procedure, sample of (7593)

manipulation with DB2DARI stored procedure (7527)

passing data with (5370)

preparing statements using minimum (5356)

server input procedure, sample of (7598)

used to pass blocks of data (6509)

using in stored procedures (7555)

using, sample program (5382)

sqlda.n.SQLDAT (7548)

sqlda.n.SQLDATALEN (7554)

sqlda.n.SQLDATATYPE_NAME (7552)

sqlda.n.SQLIND (7549)

sqlda.n.SQLLEN (7547)

sqlda.n.SQLLONGLEN (7553)

sqlda.n.SQLNAME.data (7551)

sqlda.n.SQLNAME.length (7550)

sqlda.n.SQLTYPE (7546)

sqlda.SQLDABC (7544)

sqlda.SQLDAID (7543)

sqlda.SQLN (7545)

SQLDACT include file (7271)

SQLDATA field (7564)

SQLDB2 REXX API (7402), (7496)

SQLDB2, registering for REXX (7409)

sqldbchar and wchar_t, selecting data types (6817)

sqldbchar C/C++ type (6868)

sqldbchar data type (5892), (5895), (5898), (5906), (6819)

SQLDBS REXX API (7401)

SQLDBS, registering for REXX (7408)

SQLE819A include file

for C/C++ applications (6712)

for COBOL applications (7104)

for FORTRAN applications (7277)

SQLE819B include file

for C/C++ applications (6715)

for COBOL applications (7107)

for FORTRAN applications (7280)

SQLE850A include file

for COBOL applications (7109)

for FORTRAN applications (7282)

SQLE850B include file

for COBOL applications (7111)

for FORTRAN applications (7284)

SQLE859A include file

for C/C++ applications (6717)

SQLE859B include file

for C/C++ applications (6719)

SQLE932A include file

for C/C++ applications (6721)

for COBOL applications (7113)

for FORTRAN applications (7286)

SQLE932B include file

for C/C++ applications (6723)

for COBOL applications (7115)

for FORTRAN applications (7288)

sqleAttachToCtx() API (6464)

SQLEAU include file

for C/C++ applications (6705)

for COBOL applications (7097)

for FORTRAN applications (7273)

sqleBeginCtx() API (6462)

sqleDetachFromCtx() API (6465)

sqleEndCtx() API (6463)

sqleGetCurrentCtx() API (6466)

sqleInterruptCtx() API (6467)

SQLENV include file

for C/C++ applications (6706)

for COBOL applications (7098)

for FORTRAN applications (7274)

SQLERRD(1) (6311), (6377), (6383)

SQLERRD(2) (6312), (6378), (6384)

SQLERRD(3)

in an XA environment (6501)

SQLERRMC field of SQLCA (6310), (7667), (7728)

SQLERRP field of SQLCA (7661)

sqleSetTypeCtx() API (6461)

SQLETSD include file

for COBOL applications (7101)

SQLException

handling (5307)

retrieving SQLCODE from (6961)

retrieving SQLSTATE from (6962)

SQLEXEC

processing SQL statements in REXX (7417)

SQLEXEC REXX API (7400)

SQLEXEC, registering for REXX (7407)

SQLEXT include file

for CLI applications (6710)

SQLIND field (7565)

SQLISL predefined variable (7440)

SQLJ (Embedded SQL for Java)

applets (7000)

calling stored procedures (7021)

db2profc (6991), (6992)

db2profp (6990)

declaring cursors (7011)

declaring iterators (7010)

embedding SQL statements in (7004)

example clauses (7005)

example program using (7016)

host variables (7018)

Java Database Connectivity (JDBC) interoperability (7071)

overview (6988)

positioned DELETE statement (7009)

positioned UPDATE statement (7008)

profconv (6993)

restrictions (7001)

translator (6994)

SQLJ (Embedded SQLJ for Java)

comparison with Java Database Connectivity (JDBC) (6922)

SQLJACB include file

for C/C++ applications (6725)

SQLLEN field (7563)

SQLMON include file

for C/C++ applications (6726)

for COBOL applications (7121)

for FORTRAN applications (7294)

SQLMONCT include file

for COBOL applications (7123)

SQLMSG predefined variable (7439)

SQLRDAT predefined variable (7444)

SQLRIDA predefined variable (7443)

SQLRODA predefined variable (7442)

SQLSTATE

differences (7712)

in CLI (5412)

in Java programs (6960)

in SQLERRMC field of SQLCA (7729)

standalone (7692)

SQLSTATE field, in error messages (5287)

SQLSTATE include file

for C/C++ applications (6729)

for COBOL applications (7125)

for FORTRAN applications (7296)

SQLSYSTM include file

for C/C++ applications (6733)

SQLTYPE field (7562)

SQLUDF include file

description (5909)

for C/C++ applications (6734)

UDF interface (5760)

sqludf.h include file (5872)

sqludf.h include file for UDFs (5910)

sqludf_append API (6102)

sqludf_create_locator API (6103)

sqludf_free_locator API (6104)

sqludf_length API (6100)

sqludf_substr API (6101)

SQLUTBCQ include file

for COBOL applications (7128)

SQLUTBSQ include file

for COBOL applications (7131)

SQLUTIL include file

for C/C++ applications (6736)

for COBOL applications (7134)

for FORTRAN applications (7299)

SQLUV include file

for C/C++ applications (6740)

SQLUVEND include file

for C/C++ applications (6742)

SQLVAR entities

declaring sufficient number of (5358)

variable number of, declaring (5350)

SQLWARN structure, overview of (5289)

SQLXA include file

for C/C++ applications (6743)

SQLZ_DISCONNECT_PROC return value (5477)

SQLZ_HOLD_PROC return value (5478)

SQL_API_FN macro (5860), (7520)

SQL_FILE_READ, input value option (5617)

SQL_WCHART_CONVERT preprocessor macro (6822)

statement handle (5404)

statements

BEGIN DECLARE SECTION (4881)

COMMIT (4925)

CONNECT (4915)

END DECLARE SECTION (4882)

INCLUDE SQLCA (4889)

ROLLBACK (4932)

static SQL

coding statements to retrieve and manipulate data (5139)

comparing to dynamic SQL (5330)

considerations (5331)

DB2 Connect support (7611)

overview (5120)

precompiling, advantages of (5113)

sample program (5126)

static update programming example (5267)

using host variables (5141)

STATIC.SQB COBOL program listing (5136)

STATIC.SQC C program listing (5132)

STATIC.SQF FORTRAN program listing (5138)

Static.sqlj Java program listing (5134)

storage

allocating to hold row (5363)

declaring sufficient SQLVAR entities (5355)

storage allocation for unequal code pages (6379)

Stored Procedure Builder

debug table (7041)

environment settings (7040)

stored procedures (7719)

advantages (5419)

allocating storage (5428)

allowed SQL statements in (5472)

application logic consideration (5011)

application troubleshooting (5524)

architecture (5422)

building an application (5502)

C++ consideration (5491)

CALL statement (5429), (5435)

character conversion (6297)

character conversions, for EUC (6411)

Chinese (Traditional) code sets (6362)

client application (5432)

code page considerations (5485)

compiling and linking (5503)

CONTAINS SQL clause (5471)

CREATE PROCEDURE statement (5436)

creating and using in Java (7023)

db2dari executable (5475)

debugging (5509)

using Stored Procedure Builder (7039)

declaring parameter modes (5441)

example (5465)

EXTERNAL clause (5448)

FOR BIT DATA considerations (5487)

graphic host variable considerations (5494)

host variables (5426)

initializing REXX variables (7504)

input-SQLDA procedure, sample of (7592)

input-SQLDA stored procedure, sample of (7597)

invoking (5430)

Japanese code sets (6361)

LANGUAGE clause (5453)

languages supported (5452)

location (5447)

multisite update considerations (5499)

NOT FENCED (5510)

OUT host variable, sample (5479)

overloading names (5439)

overview of (5417), (5434)

PARAMETER STYLE clause (5454)

parameters (5442), (5466), (5469)

passing DBINFO structures (5462)

path (5446)

PROGRAM TYPE clause (5464)

registering in Java (7024)

registering with CREATE PROCEDURE (5437)

requirements for (5423)

restrictions (5474)

return values (5476)

returning result sets (5522)

REXX applications (7503)

sample OUT client program (5480)

using the SQLDA and SQLCA structures (7557)

where to place (5449)

written as a main function (5463)

stored procedures (DB2DARI)

calling convention

parameter conversion (7522)

SQL_API_FN (7521)

data structure usage (7530)

NOT FENCED (7591)

parameter variables

sqlda.n.SQLDAT (7536)

sqlda.n.SQLDATALEN (7542)

sqlda.n.SQLDATATYPE_NAME (7540)

sqlda.n.SQLIND (7537)

sqlda.n.SQLLEN (7535)

sqlda.n.SQLLONGLEN (7541)

sqlda.n.SQLNAME.data (7539)

sqlda.n.SQLNAME.length (7538)

sqlda.n.SQLTYPE (7534)

sqlda.SQLDABC (7532)

sqlda.SQLDAID (7531)

sqlda.SQLN (7533)

restrictions (7523)

using indicator variables (7528)

storing large objects (5548)

String (6951)

string search and defining UDFs example (5676)

string search on BLOBs (5678)

string search over UDT example (5680)

strong typing and UDTs (5739)

structure definitions in sqludf.h (5911)

Structured Query Language (SQL)

statements, summary (5016)

table of supported statements (7513)

success code (4897) See also SQLCODE or SQLSTATE

surrogate functions (6187)

suspended application

diagnosing (6599)

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

Sync Point Manager (6439)

syntax

character host variables (6773)

declare section

in C/C++ (6767)

in COBOL (7152)

in FORTRAN (7319)

embedded SQL statement

avoiding line breaks (6761)

comments in C/C++ (6760)

comments in COBOL (7143)

comments in FORTRAN (7310)

comments in REXX (7423)

in C/C++ (6755)

in COBOL (7138)

in FORTRAN (7305)

substitution of white space characters (6762)

graphic host variable

in C/C++ (6775)

processing SQL statement

in REXX (7415)

syntax for referring to functions (5695)

SYSCAT.FUNCMAPOPTIONS catalog view (6647)

SYSCAT.FUNCTIONS catalog view (6648)

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

SYSSTAT.FUNCTIONS catalog view (6649)

system catalog

DB2 Connect support (7713)

system catalog views

prototyping utility (5041)

system configuration parameter for shared memory size (6130)

System Monitor Guide and Reference (7773)

System.err Java I/O stream (5928)

System.in Java I/O stream (5926)

System.out Java I/O stream (5927)

table

committing changes (4930)

data source tables (6603)

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

positioning cursor at end (5254)

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

table check constraint, data value control consideration (4990)

table function (5774)

SQL-result argument (5775)

table function example (5691)

table functions (5662)

application design considerations (6085)

contents of call-type argument (5818)

in Java (5922)

OLE DB (6037) See also OLE DB table functions

table names

resolving unqualified (5094)

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

target partition

behavior without buffered insert (6530)

territory, in SQLERRMC field of SQLCA (7670)

test data

generating (5032)

test database

CREATE DATABASE API (5030)

creating (5029)

recommendations (5031)

testing and debugging utilities

database system monitor (5036)

Explain facility (5035)

flagger (5037)

system catalog views (5034)

updating system catalog statistics (5033)

testing environment

for partitioned environments (6574)

setting up (5027)

test databases, guidelines for creating (5028)

testing your UDF (6180)

tfweather_u table function C program listing (6167)

TIME parameter to UDF (5901)

TIME SQL data type (5178), (5991)

C/C++ (6856)

COBOL (7202)

FORTRAN (7358)

Java (6943)

Java stored procedures (DB2GENERAL) (7584)

OLE DB table function (6072)

REXX (7472)

timeout on a lock (7709)

TIMESTAMP parameter to UDF (5902)

TIMESTAMP SQL data type (5179), (5992)

C/C++ (6857)

COBOL (7203)

FORTRAN (7359)

Java (6944)

Java stored procedures (DB2GENERAL) (7585)

OLE DB table function (6073)

REXX (7473)

TM_DATABASE multisite update configuration parameter (6426)

TP_MON_NAME multisite update configuration parameter (6432)

transaction

beginning a transaction (4921)

committing work done (4927)

description (4916)

ending a transaction (4923)

ending the program

COMMIT and ROLLBACK statements (4940)

implicitly ending (4944)

rolling back work done (4939)

transaction log consideration

for buffered insert (6539)

transaction log, buffered insert consideration (6538)

transaction processing monitors

X/Open XA Interface (6487)

transition tables

based on type of trigger event (6223)

OLD_TABLE and NEW_TABLE (6222)

transition variables, OLD and NEW

transition variables based on type of trigger event (6217)

translation, character (7636)

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

triggers

activation time (6209)

AFTER triggers (6211), (6228)

and DB2 object extensions (5540)

application logic consideration (5015)

BEFORE triggers (6210), (6227)

benefits (6189)

cascading (6234)

data relationship consideration (5004)

definition (6184)

DELETE operation (6203)

functions with SQL triggered statements

RAISE_ERROR built-in function (6231)

INSERT operation (6201)

interactions with referential constraints (6236)

multiple triggers, ordering of (6238)

overview (6193)

referential constraints, interactions with using triggers (6237)

set of affected rows (6204)

synergy with UDTs, UDFs, and LOBs (6241)

transition tables (6219)

transition variables (6216)

trigger event (6196)

trigger granularity (6206)

triggered action condition (6224)

triggered SQL statement (6226)

UPDATE operation (6202)

WHEN clause (6225)

why use triggers (6185)

trigraph sequences (6677)

troubleshooting

stored procedures (5525)

using Visual Studio (5528)

Troubleshooting Guide (7774)

truncation

host variables (5159)

indicator variables (5158)

type conversion

between SQL types and OLE automation types (5959)

type decoration

in stored procedures (5493)

in UDFs (6145)

type decoration consideration

C++ (6679)

type mapping

OLE automation types and BASIC types (5962)

OLE automation types and C++ types (5963)

types or arguments, promotions in UDFs (5874)

types, abstract (7647) See also User Defined Types

types, user defined (7645) See also User Defined Types

types, user defined distinct (7646) See also User Defined Types

UCS-2 (6319) See also Unicode

UDFs (User-defined Functions)

UDFs (User-defined functions)

allocating dynamic memory in the UDF (6116)

and DB2 object extensions (5546)

C++ consideration (6143)

calling convention (5861)

casting (5715)

caveats (6131)

Chinese (Traditional) code sets (6359)

code page differences (6139)

coding in Java (5919)

concepts (5642)

considerations when using protected resources (6138)

creating and using in Java (5914)

db2udf executable (6137)

debugging your UDF (6178)

definition (5633)

DETERMINISTIC (6082)

example (6156)

examples of UDF code (6146)

EXTERNAL ACTION option (6119)

FENCED option (6120)

function path (5644)

function selection algorithm (5646)

general considerations (5710)

hints and tips for coding (6113)

implementing UDFs (5634)

infix notation (5711)

input and output to screen and keyboard (6135)

interface between DB2 and a UDF (5758)

invoking

examples of invocations (5692)

parameter markers in functions (5699)

qualified function reference (5702)

unqualified function reference (5705)

Japanese code sets (6358)

Java consideration (5762)

list of types and their representations in UDFs (5865)

LOB locator usage scenarios (6112)

LOB types (5713)

NOT DETERMINISTIC (6081)

NOT DETERMINISTIC option (6118)

NOT FENCED (6153)

NOT NULL CALL (6152)

NOT NULL CALL option (6117)

OLE automation UDFs (5936)

output and input to screen and keyboard (6136)

overloading function names (5645)

passing arguments from DB2 to a UDF (5761)

process of implementation (5668)

re-entrant UDFs (6076)

referring to functions (5694)

registering UDFs (5671)

examples of registering (5670)

restrictions and caveats (6132)

save state in function (6080)

schema-name and UDFs (5647)

SCRATCHPAD (6083)

scratchpad considerations (6075)

shared memory size (6133)

sourced (5743)

SQL data types, how they are passed (5864)

SQLUDF include file (5759), (5908)

SQL_API_FN (6151)

SUBSTR built-in function (6161)

summary of function references (5708)

synergy with triggers, UDTs, and LOBs (6243)

synergy with UDTs and LOBs

examples of complex applications (5555)

system configuration parameter for shared memory size (6134)

table functions (6086)

type of functions (5654)

unqualified reference (5643)

using LOB locators (6095)

why use UDFs (5635)

writing UDFs (5669)

writing your own UDF (5756)

UDFs and LOB types (5714)

UDTs (User-defined Types)

UDTs (User-defined types)

and DB2 object extensions (5545)

defining a UDT (5723)

defining tables (5731)

manipulating

examples of (5737)

resolving unqualified UDTs (5725)

strong typing (5738)

synergy with triggers, UDFs, and LOBs (6242)

synergy with UDFs and LOBs

examples of complex applications (5554)

UDTs type (7644) See also User Defined Types

unambiguous cursors (7678)

unequal code pages (6376)

allocating storage (6381)

unfenced stored procedures (5515) See also NOT FENCED

Unicode (UCS-2)

character conversion (6412)

character conversion overflow (6402)

Chinese (Traditional) code sets (6322)

Japanese code sets (6321)

UDF considerations (6357)

unique key violation

buffered insert (6560)

unit of work

completing (5217)

cursor considerations (5211)

distributed (6416)

remote (6419)

unqualified function reference example (5707)

unqualified reference (5651)

unqualified table names

resolving (5093)

UPDAT.CMD REXX program listing (5277)

UPDAT.SQB COBOL program listing (5273)

UPDAT.SQC C program listing (5269)

UPDAT.SQF FORTRAN program listing (5275)

Updat.sqlj Java program listing (5271)

update operation (6195)

UPDATE operation and triggers (6199)

UPDATE statement

DB2 Connect support (7625)

USAGE clause in COBOL types (7206)

use of UDTs in UNION example (5755)

User Defined Types

supported by DB2 Connect (7643)

USER MAPPING in OLE DB table functions (6052)

user updatable catalog statistics

prototyping utility (5042)

user-defined collating sequence (7699), (7751)

user-defined function, application logic consideration (5013)

user-defined sourced functions on UDTs example (5747)

using

Java stored procedures (7026)

Java UDFs (5916)

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

using qualified function reference example (5704)

UTIL.C program listing (5305)

UTIL.F program listing (5311)

utility APIs

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

include file for COBOL applications (7103), (7130), (7133), (7136)

include file for FORTRAN applications (7301)

VALIDATE RUN

DB2 Connect support (7675)

VALUES clause

on INSERT statement (6532)

VARCHAR (5790), (5793), (5796)

VARCHAR FOR BIT DATA parameter to UDF (5889)

VARCHAR SQL data type (5170), (5981)

C or C++ (6915)

C/C++ (6847)

COBOL (7193)

FORTRAN (7350)

Java (6934)

Java stored procedures (DB2GENERAL) (7575)

OLE DB table function (6063)

REXX (7463)

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

VARGRAPHIC data (6909)

VARGRAPHIC parameter to UDF (5894)

VARGRAPHIC SQL data type (5172), (5983)

C/C++ (6850)

COBOL (7196)

FORTRAN (7353)

Java (6937)

Java stored procedures (DB2GENERAL) (7578)

OLE DB table function (6066)

REXX (7466)

variable-length strings (7637)

variables

SQLCODE (6917), (7234), (7390)

SQLSTATE (6916), (7233), (7389)

variables, declaring (4873)

variables, predefined in REXX (7430)

Varinp.java Java program listing (5394)

VARINP.SQB COBOL program listing (5396)

VARINP.SQC C program listing (5392)

VARINP.SQF FORTRAN program listing (5398)

view

data source views (6604)

data value control consideration (4994)

DB2 Connect support (7714)

Visual Basic

supported in DB2 (4971)

Visual C++

supported in DB2 (4972)

warning message, truncation (5154)

WCHARTYPE

guidelines (6823)

in stored procedures (5496)

WCHARTYPE precompiler option (5518), (6821)

wchar_t and sqldbchar, selecting data types (6816)

wchar_t C/C++ type (6869)

wchar_t data type (5893), (5896), (5899), (5907), (6818)

weight, definition of (6251)

What's New (7775)

WHENEVER SQLERROR CONTINUE statement (4903)

WHENEVER statement

caution in using with SQL statements (4902)

error indicators with SQLCA (4900)

in error handling (5292)

wild moves, DB2 checking of (6181)

Windows 95 code pages (6280)

DB2CODEPAGE environment variable (6283)

supported code pages (6284)

Windows NT code pages (6279)

DB2CODEPAGE environment variable (6281)

supported code pages (6282)

Windows registration database

for OLE automation UDFs (5942)

work environment

setting up (5025)

test databases, guidelines for creating (5026)

X/Open XA Interface (6489)

API restrictions (6502)

characteristics of transaction processing (6490)

CICS environment (6491)

COMMIT and ROLLBACK (6495)

cursors declared WITH HOLD (6498)

DISCONNECT (6493)

multithreaded application (6505)

SET CONNECTION (6494)

single-threaded application (6504)

SQL CONNECT (6496)

transactions (6492)

XA environment (6500)

XASerialize (6506)

[ Top of Page | Previous Page | Table of Contents | Index ]

[ DB2 List of Books | Search the DB2 Books ]