Embedded SQL Programming Guide

Index

Special Characters
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 (6497)

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

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

access control

concurrency, overview (5191)

using locks (5236)

access path

lock attributes, factors affecting (5289)

access to data consideration

Call Level Interface (CLI) (4763)

embedded SQL (4761)

using query products (4767)

using REXX (4765)

ACQUIRE statement, DB2 Connect support (7548)

activation time and triggers (6123)

ADHOC.SQC C program listing (5157)

AFTER triggers (6125), (6141)

aggregating functions (5639)

AIX Encina Monitor (7543)

alerts, supported by triggers (6099)

allocating dynamic memory in a UDF (6026)

ALLOW PARALLEL clause (7394)

ambiguous cursors (7488)

APPC, handling interrupts (5076)

applets, Java (7256)

application design

access to data (4758)

acquiring locks (5238)

binding (4817)

C/C++ Japanese and Traditional-Chinese EUC considerations (6647)

C/C++ language requirements, include files (6521)

character conversion considerations (6191)

character conversion in SQL statements (6193)

character conversion overflow (6294)

character conversions in stored procedures (6199), (6304)

character string length overflow (6300)

client-based parameter validation for EUC (6279)

COBOL Japanese and Traditional-Chinese EUC considerations (6939)

COBOL requirements, include files (6758)

code points for special characters (6195)

coding a DB2 application,overview (4678)

collating sequences, guidelines (6174)

considerations for traditional-Chinese users (6232)

creating SQLDA structure, guidelines (5138)

cursor processing, considerations (4992)

data relationship (4783)

data value control consideration (4769)

deadlock, avoiding (5284)

declaring sufficient SQLVAR entities (5127)

DESCRIBE in EUC applications (6285)

describing SELECT statement (5133)

double-byte character support (DBCS) (6196)

dynamic SQL caching (4912)

enabling buffered insert (6407)

error handling, guidelines (5068)

EUC considerations

for collation (6255)

for DBCLOB files (6252)

for stored procedures (6249)

for UDFs (6246)

example scenarios for EUC parameter validation (6282)

executing statements without variables (5096)

FORTRAN Japanese and Traditional-Chinese EUC considerations (7111)

getting started with DB2 application development (4673)

graphic constants (6243)

graphic data handling (6240)

guidelines (4754)

handling unequal code pages (6261)

input-SQLDA procedure, sample of (5492)

input-SQLDA stored procedure, sample of (5503)

Japanese and Traditional-Chinese EUC code sets (6216), (6236)

lock compatibility, ensuring (5268)

lock escalation (5275)

locking considerations (5305)

locks, converting of (5273)

locks, factors affecting (5287)

logic at the server (4792)

mixed code set environments (6258)

mixed EUC and double-byte considerations (6227)

multiple threads, overview of (6337)

OLE automation UDFs (5890)

output-SQLDA stored procedure, sample of (5481)

overriding locks (5297)

package renaming (4845)

passing data, guidelines (5142)

precompiling and binding (4816)

receiving database values (4938)

retrieving data a second time (5030)

REXX Japanese and Traditional-Chinese EUC considerations (7240)

REXX requirements, registering routines (7130)

REXX, interactive programming using (4810)

rules for string conversions (6297)

sample programs (5039)

saving end user requests (5152)

static SQL, advantages of using (4910)

stored procedures

debugging (5453)

table function considerations (5995)

transaction logging (5229)

transaction management, overview of (5223)

use of dynamic SQL, overview of (5090)

use of stored procedures, overview (5351)

user-defined function (UDF) (5747)

using fixed or variable length data types (6290)

using Java (7247)

using LOB locators in UDFs (6004)

using parameter markers (5160)

using stored procedures, requirements for (5357)

varying-list statements, processing of (5150)

application domain and object-orientation (5519)

application environment, for programming (4676)

application forms using CREATE TABLE example (5715)

application logic

data relationship consideration (4791)

data value control consideration (4781)

application logic consideration

stored procedures (4795)

triggers (4799)

user-defined functions (4797)

Application Program Interface (API)

for JDBC applications (7301)

for setting contexts between threads

sqleAttachToCtx() (6350)

sqleBeginCtx() (6348)

sqleDetachFromCtx() (6351)

sqleEndCtx() (6349)

sqleGetCurrentCtx() (6352)

sqleInterruptCtx() (6353)

sqleSetTypeCtx() (6347)

overview of (4885)

restrictions in an XA environment (6397)

syntax for REXX (7229)

types of (4886)

uses of (4887)

applications, Java (7257)

argument types, promotions in UDFs (5847)

arguments between UDFs and DB2 (5757)

call-type (5793)

dbinfo (5814)

diagnostic-message (5785)

function-name (5779)

scratchpad (5788)

specific-name (5782)

SQL-argument (5759)

SQL-argument-ind (5767)

SQL-result (5761)

SQL-result-ind (5771)

SQL-state (5776)

arguments, passing from DB2 to a UDF (5754)

ARI (DB2 for VSE & VM) (7474)

arithmetic error

in UDFs (5773)

AS LOCATOR clause (6007)

ASCII

mixed-byte data (7450)

sort order (7507)

assignments in dynamic SQL example (5730)

assignments involving different UDTs example (5732)

assignments involving UDTs example (5728)

asynchronous events (6338), (6341)

asynchronous nature of buffered insert (6431)

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

automation server, for OLE (5898)

AVG over a UDT example (5662)

backing out changes (4739)

BASIC language

implementation of OLE automation UDF (5901)

BASIC types and OLE automation types (5916)

BEFORE triggers (6124), (6140)

BEGIN DECLARE SECTION (4689)

beginning transactions (4728)

BigDecimal Java type (7358)

BINARY data types in COBOL (6858)

Binary Large OBjects (5546) See also BLOBs (Binary Large OBjects)

BIND API (4868)

BIND API, creating packages (4841)

bind file

precompile options (4827)

support to REXX applications (7222)

bind files for REXX (7220)

bind option

INSERT BUF (6425)

bind options

EXPLSNAP (4861)

FUNCPATH (4862)

QUERYOPT (4860)

BIND PACKAGE command

rebinding (4877)

binding

bind file dump tool, db2bfd (4869)

considerations (4858)

deferring (4867)

dynamic statements (4846)

isolation level, specifying (5216)

options for (4839)

overview of (4840)

Blob (7360)

blob C/C++ type (6705)

BLOB COBOL type (6913)

BLOB FORTRAN type (7089)

BLOB parameter to UDF (5876)

BLOB SQL data type (4958), (5937), (6671), (6883), (7058) , (7188), (7328)

BLOB-FILE COBOL type (6915)

BLOB-LOCATOR COBOL type (6914)

BLOBs (Binary Large OBjects)

uses and definition (5543)

blob_file C/C++ type (6707)

BLOB_FILE FORTRAN type (7091)

blob_locator C/C++ type (6706)

BLOB_LOCATOR FORTRAN type (7090)

block fetch (5309) See also row blocking

blocking (7487)

broadcast (5332)

broadcast inner-table (5342)

broadcast outer table (5334)

broadcast table queue (5328), (5330)

BSTR OLE automation type (5968)

buffer size for buffered insert (6408)

buffered insert (6405), (6455)

advantages (6421)

asynchronous nature of (6430)

buffer size (6409)

closed state (6439)

considerations for using (6429)

deadlock errors (6447)

error detection during (6432)

error reporting in buffered insert (6444)

group of rows (6433)

INSERT BUF bind option (6423)

long field restriction (6453)

not supported in CLP (6458)

open state (6440)

partially filled (6410)

restrictions on using (6451)

savepoint consideration (6412)

SELECT buffered insert (6437)

statements that close (6414)

transaction log consideration (6428)

unique key violation (6449)

C and C++ data types (6659)

C language type definitions in sqludf.h (5884)

C null-terminated graphic string SQL data type (5936), (7327)

C null-terminated string SQL data type (5935), (7326)

C or C++ data types

blob (6725)

blob_file (6727)

blob_locator (6726)

char (6719)

clob (6722)

clob_file (6724)

clob_locator (6723)

dbclob (6730)

dbclob_file (6732)

dbclob_locator (6731)

double (6718)

float (6717)

long (6715)

long int (6716)

null-terminated character form (6729)

short (6713)

short int (6714)

sqldbchar (6720)

VARCHAR structured form (6728)

wchar_t (6721)

C++

consideration for stored procedures (5405)

considerations for UDFs (6055)

type decoration consideration (6518)

C++ types and OLE automation types (5917)

C/C++ language

character set (6513)

data types supported (6655)

declaring graphic host variables (6604)

declaring host variables (6596)

embedding SQL statements (4803)

file reference declarations (6615)

handling class data members (6625)

handling null-terminated strings (6620)

host variable, naming (6592)

include files, required (6522)

initializing host variables (6618)

input and output files (6500)

Japanese and Traditional-Chinese EUC considerations (6651)

LOB data declarations (6607)

LOB locator declarations (6612)

member operator, restriction (6631)

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

programming restrictions in (6493)

qualification operator, restriction (6630)

supported data types (6653)

trigraph sequences (6514)

Call Level Interface (CLI)

access to data consideration (4764)

advantages of using (5185), (5187)

comparing embedded SQL and DB2 CLI (5172)

overview (5170)

CALL statement

initializing client for stored procedure

SQLDA structure (5361)

invoking a stored procedure (5356)

on different platforms (7531)

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

call-type (6000)

contents with scalar functions (5801)

contents with table functions (5807)

call-type, passing to UDF (5791), (5792)

calling convention

for UDFs (5836)

calling from a REXX application (7235)

calling the DB2 CLP from a REXX application (7233)

CARDINALITY specification in table functions (6003)

cascade (7515)

cascading triggers (6146)

CAST FROM clause (5763)

CAST FROM clause in the CREATE FUNCTION statement (5844)

castability (5617)

casting, UDFs (5694)

CHAR (5777)

char C/C++ type (6699)

CHAR parameter to UDF (5859)

CHAR SQL data type (4953), (5929), (6666), (6878), (7053) , (7183), (7320)

CHAR type (7288)

character comparison, overview (6165)

character conversion

coding SQL statements (6192)

coding stored procedures (6197), (6306)

during precompiling and binding (6200)

expansion (6210)

national language support (NLS) (6205)

programming considerations (6190)

rules for string conversions (6299)

string length overflow (6296)

string length overflow past data types (6302)

supported code pages (6209)

when executing an application (6201)

when occurs (6208)

character host variables

C/C++

fixed and null-terminated (6598)

variable length (6599)

COBOL (6832)

FORTRAN (7024)

Character Large OBjects (5547) See also CLOBs (Character Large OBjects)

CHARACTER parameter to UDF (5860)

character translation (7453)

CHARACTER*n FORTRAN type (7085)

CHECKERR REXX program listing (5088)

CHECKERR.CBL program listing (5084)

Chinese (Traditional) EUC Code set considerations (6225)

CICS (7432), (7545)

CICS SYNCPOINT ROLLBACK command (6390)

classes

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

for Java Stored Procedures and UDFs (7410)

CLASSPATH environment variable (7371)

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

Client Application Enabler

requirement for Java (7253)

client-based parameter validation

EUC consideration (6281)

example scenarios for EUC (6284)

client/server

code page conversion (6202)

CLOB (6746)

clob C/C++ type (6702)

CLOB COBOL type (6910)

CLOB FORTRAN type (7086)

CLOB parameter to UDF (5877)

CLOB SQL data type (4959), (5938), (6672), (6884), (7059) , (7189), (7329)

CLOB-FILE COBOL type (6912)

CLOB-LOCATOR COBOL type (6911)

CLOBs (Character Large OBjects)

uses and definition (5544)

clob_file C/C++ type (6704)

CLOB_FILE FORTRAN type (7088)

clob_locator C/C++ type (6703)

CLOB_LOCATOR FORTRAN type (7087)

CLOSE call (5810)

closed state, buffered insert (6441)

closing a buffered insert (6415)

COBOL

declaring host variables (6829)

embedding SQL statements (4805)

file reference declarations (6846)

group data items (6850)

group data items, methods for using (6852)

group data items, other uses (6854)

host structure support (6849)

include files, list of (6756)

indicator tables (6856)

input and output files (6755)

Japanese and Traditional-Chinese EUC considerations (6943)

LOB data declarations (6838)

LOB locator declarations (6843)

object oriented restrictions (6945)

restrictions in (6753)

rules for indicator variables (6836)

supported data types (6865)

varchar character type (6851)

COBOL data types (6871)

BINARY (6860)

BLOB (6927)

BLOB-FILE (6929)

BLOB-LOCATOR (6928)

CLOB (6924)

CLOB-FILE (6926)

CLOB-LOCATOR (6925)

COMP (6861)

COMP-1 (6921)

COMP-3 (6922)

COMP-4 (6862)

COMP-5 (6923)

DBCLOB (6930)

DBCLOB-FILE (6932)

DBCLOB-LOCATOR (6931)

PICTURE (PIC) clause (6919)

USAGE clause (6920)

COBOL language

data types supported (6867)

code page

allocating storage for unequal situations (6270)

binding considerations (4859)

character conversion (6203)

considerations for Java applications (7302)

considerations for stored procedures (5398)

DB2CODEPAGE environment variable (6177)

handling expansion at application (6278)

handling expansion at server (6276)

handling unequal situations (6263)

how determined (6176)

in SQLERRMC field of SQLCA (7479)

locales

deriving in applications (6186)

how DB2 derives locales (6187)

national language support (NLS) (6204)

supported Windows 95 code pages (6178)

supported Windows NT code pages (6179)

unequal situations (6215)

code point, definition of (6163)

code set

in SQLERRMC field of SQLCA (7481)

coding DB2 applications, alternatives for (4801)

coding Java stored procedures (7405)

coding Java UDFs (7380)

collating sequence

EBCDIC and ASCII (7505)

include files

in C/C++ (6550)

in COBOL (6784)

in FORTRAN (6985)

overview of (6162)

samples of (6173)

simulating EBCDIC binary collation (7564)

specifying (6167)

use in character comparisons (6166)

collating sequences (6161)

collation

Japanese and Traditional-Chinese EUC code sets (6257)

collection ID (7495)

DB2 for AS/400 (7497)

COLLECTION parameters (4856)

collections (7498)

column

setting null values in (4941)

supported SQL data types (4946)

using indicator variables on nullable data columns (4980)

column functions (5638)

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

column types, creating in COBOL (6868)

column types, creating in FORTRAN (7043)

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

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

COM.ibm.db2.app.StoredProc (7409), (7411)

COM.ibm.db2.app.UDF (7389), (7412)

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

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

Command Line Processor (7234)

command line processor

prototyping tool (4902)

comments

SQL, rules for (6819), (7011)

comments, SQL, rules for (6585)

commit point

definition of (5222)

COMMIT statement (4682)

association with cursor (4996)

ending a transaction (4732)

ending transactions (4747)

in transaction management (5224)

COMMIT WORK RELEASE

not supported in DB2 Connect (7556)

committing changes, tables (4735)

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

COMP-1 in COBOL types (6907)

COMP-3 in COBOL types (6908)

COMP-5 in COBOL types (6909)

comparisons involving UDTs example (5720), (5724)

compiled applications, creating packages for (4818)

compiling (4836)

client application (5446)

stored procedures (5444)

compiling a UDF (5643)

completion code (4702) See also SQLCODE or SQLSTATE

compound SQL, NOT ATOMIC (7537)

concurrency

controlling using locks (5237)

overview of (5189)

concurrency and granularity

effect of locks on (5265)

configuration parameter

LOCKTIMEOUT (6379)

CONNECT

connect

application programs (4720)

CONNECT RESET statement (7466)

CONNECT TO statement (7465)

implicit connect (7468)

null CONNECT (7467)

sample programs (5044)

SQLCA.SQLERRD settings (6274)

CONNECT RESET statement

ending transactions (4749)

CONNECT statement (4681)

CONNECT TYPE 2

considerations with stored procedures (5416)

connecting DB2 application programs (4719)

connection handle (5178)

consideration

access to data (4760)

application logic at server (4794)

data relationship control (4785)

data value control (4771)

DB2 application design (4757)

considerations for Java applications (7281)

consistency

of data (4724)

state of, defined (5230)

consistency of data (4723)

consistent behavior and UDTs (5698)

constraint mechanisms on large objects (5539)

contexts

application dependencies between (6371)

database dependencies between (6368)

preventing deadlocks between (6376)

setting in multi-threaded DB2 applications (6340)

control information to access large object data (5562)

conversion

of locks, rules for (5272)

CONVERT

WCHARTYPE

in stored procedures (5412)

coordinator node

behavior without buffered insert (6417)

core level functions (CLI/ODBC) (4813)

cost of a UDT example (5660)

counter for UDFs example (6074)

counter OLE automation UDF object example in BASIC (6082)

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

counting and defining UDFs example (5664)

counting with an OLE automation object (5667)

country code

in SQLERRMC field of SQLCA (7478)

creatable multi-use OLE automation server (5984)

creatable single-use OLE automation server (5983)

CREATE DATABASE API

SQLEDBDESC structure (6171)

CREATE DISTINCT TYPE statement

and castability (5619)

examples of using (5705)

to define a UDT (5703)

CREATE FUNCTION statement (5789), (5795), (5815), (6002), (6008)

CAST FROM clause (5842)

for OLE automation UDFs (5899)

Java UDFs (7395)

RETURNS clause (5843)

to register a UDF (5650)

CREATE PROCEDURE statement (7401)

CREATE STORGROUP statement

DB2 Connect support (7437)

CREATE TABLE statement

defining LOB columns (5563)

examples of using (5711)

lob-options-clause (5564)

tablespace-options-clause (5565)

CREATE TABLESPACE statement

DB2 Connect support (7438)

CREATE TRIGGER statement

multiple triggers (6151)

order of trigger activation (6126)

overview (6105)

REFERENCING clause (6131)

creating

Java stored procedures (7398)

Java UDFs (7375)

OLE automation UDFs (5893)

creating packages for compiled applications (4819)

creator (7494)

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

critical sections (6373)

ctr() UDF C program listing (6076)

CURRENT EXPLAIN MODE register (4849)

CURRENT FUNCTION PATH register (4850)

CURRENT QUERY OPTIMIZATION register (4848)

cursor

ambiguous (5016)

close using WITH RELEASE clause (5303)

completing a unit of work (4999)

declared WITH HOLD (5001)

declaring (4993)

FOR FETCH ONLY (5013)

issuing a COMMIT statement (4998)

naming and defining of (4988)

naming, in REXX (7141)

positioning at table end (5034)

processing with SQLDA structure (5137)

processing, in dynamic SQL (5111)

processing, sample program (5002), (5113)

processing, summary of (4986)

read only, application requirements for (4995)

read only, uncommitted read (5212)

read-only (4989), (5012)

retrieving multiple rows with (4983), (4990)

sample program (5018)

updatable (5015)

updatable, uncommitted read (5213)

use in CLI (5173)

cursor stability (7519)

overview of (5204)

cursor usage in REXX (7211)

CURSOR.SQB COBOL program listing (5006)

CURSOR.SQC C program listing (5004)

CURSOR.SQF FORTRAN program listing (5008)

cursors declared WITH HOLD

X/Open XA programming considerations (6392)

data

avoiding bottlenecks when extracting (6461)

extracting large volumes (6460)

data control language (DCL) (7462)

data definition language (DDL) (7435)

data integrity

concurrency, overview (5190)

protecting using locks (5240)

data manipulation language (DML) (7440)

data relationship consideration

application logic (4790)

referential integrity (4786)

triggers (4788)

data structure

allocating for stored procedures (5363)

manipulating for stored procedure (5379)

SQLEDBDESC (6170)

user-defined, with multiple threads (6362)

data structures, declaring (4680)

data transfer

updating (5037)

data types

BLOBs (5557)

character string length overflow past (6303)

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

CLOB in C/C++ (6743)

CLOBs (5558)

conversion between DB2 and C and C++ (6658)

conversion between DB2 and COBOL (6870)

conversion between DB2 and FORTRAN (7045)

conversion between DB2 and Java (7311)

conversion between DB2 and OLE automation (5920)

conversion between DB2 and REXX (7175)

data value control consideration (4773)

DBCLOBs (5559)

decimal

in FORTRAN (7104)

description (4691)

EUC consideration (6293)

FOR BIT DATA, in C/C++ (6741)

FOR BIT DATA, in COBOL (6935)

how they are passed to a UDF (5840)

in C/C++ (6654)

in COBOL (6866)

in FORTRAN (7041)

list of types and their representations in UDFs (5841)

numeric (7446)

object-oriented (5528)

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

selecting graphic types (6637)

SQL column types, list of (4945)

supported

in C and C++ (6657)

in C/C++ (6652)

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

in COBOL (6864), (6869)

in COBOL, rules for (6934)

in FORTRAN (7039), (7044)

in FORTRAN, rules for (7107)

in Java (7310)

in OLE automation UDFs (5919)

in REXX (7174)

VARCHAR in C/C++ (6742)

data value control consideration

application logic and variable type (4780)

data types (4772)

referential integrity constraints (4776)

table check constraints (4774)

views with check option (4778)

database access

affect of optimization class (5313)

using different contexts (6336)

using Java (7249)

using multiple threads (6335)

database creation, specifying collating sequence (6168)

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

database manager APIs

calling using stored procedures (5354)

defining, sample programs (5040)

DATE OLE automation type (5967)

DATE parameter to UDF (5873)

DATE SQL data type (4961), (5940), (6674), (6886), (7061) , (7191), (7331)

DB2 Agent address space (5459)

DB2 BIND command

creating packages (4842)

DB2 Connect (4672), (7425)

isolation level (7529)

DB2 Connect programming considerations (7428)

DB2 for AS/400

FOR BIT DATA stored procedure considerations (5403)

DB2 for MVS/ESA

FOR BIT DATA stored procedure considerations (5401)

DB2 for OS/390;

FOR BIT DATA stored procedure considerations (5402)

DB2 PREP command

overview of (4822)

DB2 program

set up (4684)

DB2 System Controller (5460)

DB2 using DB2 Connect (7422)

DB2 via DB2 Connect (4669)

DB2Appl.java

application example (7278)

DB2ARXCS.BND REXX bind file (7223)

DB2ARXNC.BND REXX bind file (7227)

DB2ARXRR.BND REXX bind file (7224)

DB2ARXRS.BND REXX bind file (7226)

DB2ARXUR.BND REXX bind file (7225)

db2bfd, bind file dump tool (4870)

DB2CLI.PROCEDURES table

registering stored procedures (5514)

db2dari executable (5377)

db2diag.log file (6469)

DB2INCLUDE environment variable (6508), (6824), (6953)

db2nodes.cfg file (6483)

db2udf executable (6053)

DB2Udf.java (7378)

DBCLOB

Japanese and Traditional-Chinese EUC code sets (6254)

dbclob C/C++ type (6710)

DBCLOB COBOL type (6916)

DBCLOB parameter to UDF (5878)

DBCLOB SQL data type (4960), (5939), (6673), (6885), (7060) , (7190), (7330)

DBCLOB type (7287)

DBCLOB-FILE COBOL type (6918)

DBCLOB-LOCATOR COBOL type (6917)

DBCLOBs (Double-Byte Character Large OBjects)

uses and definition (5545)

dbclob_file C/C++ type (6712)

dbclob_locator C/C++ type (6711)

dbinfo (6001)

DBINFO keyword (5816)

dbinfo, passing to UDF (5813)

dbminfo argument, elements of (5818)

application authorization ID (5822)

application authorization ID length (5821)

column name (5829)

column name length (5828)

data base name (5820)

data base name length (5819)

database code page (5823)

platform (5831)

schema name (5825)

schema name length (5824)

table function column list (5833)

table function columns entries (5832)

table name (5827)

table name length (5826)

version/release number (5830)

DCL (data control language) (7461)

DCLGEN command (MVS) (7485)

DDL (data definition language) (7434)

deadlocks

detecting (5282)

error in buffered insert (6446)

in multi-threaded applications (6374)

overview of (5283)

preventing in multiple contexts (6377)

debugging

stored procedures (5452)

using VisualAge C++ (5455)

debugging your UDF (6090)

DECIMAL parameter to UDF (5851)

DECIMAL SQL data type (4950), (5925), (6663), (6875), (7050) , (7180), (7316)

DECLARE CURSOR statement (4718)

DECLARE CURSOR statement, overview of (4987)

DECLARE PROCEDURE statement (OS/400) (7533)

declare section

in C/C++ (6593), (6733)

in COBOL (6827), (6933)

in FORTRAN (7020), (7106)

rules for statements (4931)

DECLARE STATEMENT

DECLARE statement

DB2 Connect support (7557)

DB2 Connect support (7549)

declaring

host variable, rules for (4929)

indicator variables (4935)

deferring the evaluation of a LOB expression example (5583)

defining the UDT and UDFs example (5739)

DELETE

DB2 Connect support (7444)

triggers (6129)

delete operation and triggers (6111)

DESCRIBE statement

DB2 Connect support (7551), (7558)

EUC consideration (6287)

EUC consideration with DBCS database (6288)

EUC consideration with EUC database (6289)

processing arbitrary statements (5147)

description (5335)

descriptor handle (5179)

designing DB2 applications, guidelines (4756)

DFT_SQLMATHWARN configuration parameter (5772)

diagnostic-message, passing to UDF (5784)

differences between different DB2 products (7433)

differences between DRDA server and workstation (7547), (7555)

differences in SQLCODEs and SQLSTATEs (7521)

directed (5333)

directed inner-table (5345)

directed inner-table and outer-table (5339)

directed outer-table (5337)

directed table queue (5329), (5331)

distinct type (5618)

distributed environment (7426)

distributed unit of work

coding SQL for a DUOW application (6314)

considerations with stored procedures (5415)

DB2 Connect support (7541)

general considerations (6308)

overview (6312)

restrictions (6317)

specifying configuration parameters for a DUOW application (6316)

when to use (6313)

distributing Java applets (7273)

distributing Java applications (7277)

divid() UDF C program listing (6061)

DML (data manipulation language) (7439)

double C/C++ type (6698)

double Java type (7357)

double OLE automation type (5966)

DOUBLE parameter to UDF (5853), (5856)

DOUBLE PRECISION parameter to UDF (5857)

DOUBLE SQL data type (4952), (5927), (6665), (6877), (7052) , (7182), (7318)

Double-Byte Character Large OBjects (5548) See also DBCLOBs (Double-Byte Character Large OBjects)

double-byte considerations (6229)

DRDA

accessing DRDA servers (6334)

DRDA environment, programming (7421)

DSN (DB2 for MVS/ESA) (7472)

DSN (DB2 for OS/390) (7473)

DUOW (7542) See also distributed unit of work

DUOW configuration parameter

LOCKTIMEOUT (6323)

RESYNC_INTERVAL (6321)

SPM_LOG_NAME (6332)

SPM_NAME (6329)

SPM_RESYNC_AGENT_LIMIT (6327)

TM_DATABASE (6319)

TP_MON_NAME (6325)

dynamic cursors (7491)

dynamic memory, allocating in the UDF (6033)

dynamic SQL

arbitrary statements, processing of (5145)

authorization considerations (4882)

comparing to static SQL (5107)

considerations (5108)

contrast with dynamic SQL (4908)

cursor processing (5112)

cursor processing, sample program (5114)

DB2 Connect support (7430)

declaring an SQLDA (5126)

evaluating optimization class (5322)

EXECUTE IMMEDIATE statement, summary of (5095)

EXECUTE statement, summary of (5101)

limitations (5104)

overview (5089)

parameter markers in (5159)

PREPARE statement, summary of (5098)

setting optimization class (5319)

supported statements, list of (5091)

syntax, differences with static (5103)

using PREPARE, DESCRIBE, and FETCH (5109)

dynamic statements

binding (4847)

DYNAMIC.CMD REXX program listing (5122)

DYNAMIC.SQB COBOL program listing (5118)

DYNAMIC.SQC C program listing (5116)

DYNAMIC.SQF FORTRAN program listing (5120)

easier maintenance using triggers (6103)

EBCDIC

mixed-byte data (7449)

sort order (7506)

embedded SQL

access to data consideration (4762)

embedded SQL statement

comments, rules for (6586)

examples of (4808)

overview of (4802)

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

rules for, in COBOL (6818)

rules for, in FORTRAN (7010)

syntax rules (4806)

embedded SQL statements

comments, rules for (6820), (7012)

host variable, referencing in (4934)

enabling buffered insert (6406)

encapsulation and UDTs (5699)

Encina Monitor (7544)

END DECLARE SECTION (4690)

ending transactions (4730)

ending transactions implicitly (4751)

environment APIs

include file for C/C++ (6545)

include file for COBOL (6778)

include file for FORTRAN (6982)

environment handle (5177)

environment,for programming (4674)

error code (4701) See also SQLCODE or SQLSTATE

error detection in a buffered insert (6435)

error handling

C/C++ language precompiler (6510)

considerations in a partitioned environment (6464)

during precompilation (4828)

identifying partition that returns the error (6481)

in a looping application (6484)

in a suspended application (6485)

include file

for C/C++ applications (6565), (6568)

for FORTRAN (6973), (7004)

in COBOL (6768), (6771), (6805)

merged multiple SQLCA structures (6471)

overview of (5055)

reporting (6474)

resetting (4710)

SQLCA structure (6475)

SQLCODE (6476)

using WHENEVER statement (5070)

WHENEVER statement (4707)

with the SQLCA (4696)

error messages

error conditions flag (5063)

exception condition flag (5062)

SQLCA structure (5058)

SQLSTATE (5065)

SQLWARN structure (5067)

timestamps, when precompiling (4875)

warning condition flag (5061)

EUC (6218) See also Extended UNIX Code

EUC considerations (6234)

examples

ADHOC.SQC C program listing (5156)

application forms using CREATE TABLE (5713)

assignments in dynamic SQL (5729)

assignments involving different UDTs (5731)

assignments involving UDTs (5727)

AVG over a UDT (5661)

BLOB data declarations (6608)

CHECKERR REXX program listing (5087)

CHECKERR.CBL program listing (5083)

CLOB data declarations (6609)

CLOB file reference (6616)

CLOB locator (6613)

comparisons involving UDTs (5719), (5723)

cost of a UDT (5659)

counter for UDFs (6073)

counter OLE automation UDF object in BASIC (6081)

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

counting and defining UDFs (5663)

counting with an OLE automation object (5665)

ctr() UDF C program listing (6075)

CURSOR.SQB COBOL program listing (5005)

CURSOR.SQC C program listing (5003)

CURSOR.SQF FORTRAN program listing (5007)

DB2Appl.java (7275)

DBCLOB data declarations (6610)

declaring BLOB file references using COBOL (6847)

declaring BLOB file references using FORTRAN (7038)

declaring BLOB locator using COBOL (6844)

declaring BLOBs using COBOL (6839)

declaring BLOBs using FORTRAN (7031)

declaring CLOB file locator using FORTRAN (7035)

declaring CLOBs using COBOL (6840)

declaring CLOBs using FORTRAN (7032)

declaring DBCLOBs using COBOL (6841)

deferring the evaluation of a LOB expression (5582)

defining the UDT and UDFs (5738)

divid() UDF C program listing (6060)

DYNAMIC.CMD REXX program listing (5121)

DYNAMIC.SQB COBOL program listing (5117)

DYNAMIC.SQC C program listing (5115)

DYNAMIC.SQF FORTRAN program listing (5119)

exploiting LOB function to populate the database (5740)

exploiting LOB locators to manipulate UDT instances (5744)

exploiting UDFs to query instances of UDTs (5742)

exponentiation and defining UDFs (5651)

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

extracting large volumes of data

program listing (6462)

find the vowel, fold the CLOB (6065)

findvwl() UDF C program listing (6070)

fold() UDF C program listing (6068)

function invocations (5675)

function using LOB locator (6079)

implementation of OLE automation UDF

in BASIC language (5902), (5978)

in C++ language (5980), (5985)

INPCLI.CMD REXX program listing (5499)

INPCLI.SQB COBOL program listing (5495)

INPCLI.SQC C program listing (5493)

INPCLI.SQF FORTRAN program listing (5497)

INPSRV.CMD REXX program listing (5510)

INPSRV.SQB COBOL program listing (5506)

INPSRV.SQC C program listing (5504)

INPSRV.SQF FORTRAN program listing (5508)

inserting data into a CLOB column (5609)

integer divide operator for UDFs (6058)

Java applet tagging (7271)

LOBEVAL.SQB COBOL program listing (5588)

LOBEVAL.SQC C program listing (5586)

LOBFILE.SQB COBOL program listing (5607)

LOBFILE.SQC C program listing (5605)

LOBLOC.SQB COBOL program listing (5578)

LOBLOC.SQC C program listing (5576)

LOBLOC.SQF FORTRAN program listing (5580)

mail OLE automation UDF object in BASIC (6085)

money using CREATE DISTINCT TYPE (5706)

OPENFTCH.SQB COBOL program listing (5021)

OPENFTCH.SQC C program listing (5019)

OPENFTCH.SQF FORTRAN program listing (5023)

OUTCLI.CMD REXX program listing (5477)

OUTCLI.SQB COBOL program listing (5473)

OUTCLI.SQC C program listing (5471)

OUTCLI.SQF FORTRAN program listing (5475)

OUTSRV.CMD REXX program listing (5488)

OUTSRV.SQB COBOL program listing (5484)

OUTSRV.SQC C program listing (5482)

OUTSRV.SQF FORTRAN program listing (5486)

parameter markers in functions (5678)

registering SQLEXEC, SQLDBS and SQLDB2

on AIX (7134)

registering SQLEXEC, SQLDBS and SQLDB2 for REXX

on OS/2 (7132)

on Windows (7133)

resume using CREATE DISTINCT TYPE (5707)

REXX sample programs (7246)

sales using CREATE TABLE (5712)

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

search string and BLOBs (5655)

static update (5045)

STATIC.SQB COBOL program listing (4920)

STATIC.SQC C program listing (4918)

STATIC.SQF FORTRAN program listing (4922)

string search and defining UDFs (5653)

string search over UDT (5657)

syntax for character host variables in FORTRAN (7025), (7026)

table function returning document IDs (5668)

tfweather_u table function C program listing (6077)

unqualified function reference (5684)

UPDAT.CMD REXX program listing (5053)

UPDAT.SQB COBOL program listing (5049)

UPDAT.SQC C program listing (5047)

UPDAT.SQF FORTRAN program listing (5051)

use of UDTs in UNION (5733)

user-defined sourced functions on UDTs (5725)

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

using class data members in an SQL statement (6628)

using GET ERROR MESSAGE (5080)

using indicator variables (4982)

using parameter markers in search and update (5163)

using qualified function reference (5681)

UTIL.C program listing (5081)

UTIL.F program listing (5085)

VARINP.SQB COBOL program listing (5166)

VARINP.SQC C program listing (5164)

VARINP.SQF FORTRAN program listing (5168)

exclusive mode

reasons for using (5302)

EXCSQLSTT, DRDA command (7553)

EXEC SQL INCLUDE SQLCA

multi-threading considerations (6366)

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

EXECUTE IMMEDIATE statement, summary of (5094)

EXECUTE statement, summary of (5100)

execution requirements for REXX (7214)

exit routines, use restrictions (5079)

expansion of data on the DRDA server (7452)

Explain Snapshot (4866)

EXPLAIN, prototyping tool (4903)

exploiting

LOB function to populate the database example (5741)

LOB locators to manipulate UDT instances example (5745)

UDFs to query instances of UDTs example (5743)

EXPLSNAP bind option (4864)

exponentiation and defining UDFs example (5652)

extended dynamic SQL statements

not supported in DB2 Connect (7563)

Extended UNIX Code (EUC)

character conversion overflow (6295)

character conversions in stored procedures (6305)

character string length overflow (6301)

client-based parameter validation (6280)

considerations for collation (6256)

considerations for DBCLOB files (6253)

example scenarios, client-based parameter validation (6283)

fixed or varying length data types (6291)

graphic constants (6244)

graphic data handling (6241)

handling unequal code pages (6262)

Japanese and Traditional-Chinese

C/C++ consideration (6649)

COBOL consideration (6941)

FORTRAN consideration (7113)

REXX consideration (7242)

Japanese and Traditional-Chinese code sets (6238)

Japanese and Traditional-Chinese EUC code sets (6219)

mixed code set environments (6259)

mixed EUC and double-byte considerations (6230)

rules for string conversions (6298)

stored procedures considerations (6250)

traditional Chinese considerations (6235)

UDF considerations (6247)

unequal code page, expansion at application (6277)

unequal code page, expansion at server (6275)

using the DESCRIBE statement (6286)

extensibility and UDTs (5696)

extern declaration

C++ (6520)

EXTERNAL ACTION option and UDFs (6036)

extracting

large volumes of data (6459)

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

faster application development using triggers (6101)

FENCED option and UDFs (6037)

FETCH statement

host variables (5110)

repeated access, technique for (5028)

scroll backwards, technique for (5025)

using SQLDA structure with (5134)

file extensions

sample programs (7419)

file reference declarations in REXX (7171)

file reference variables

examples of using (5602)

for manipulating LOBs (5554)

input values (5593)

output values (5597)

FINAL CALL clause (5811)

FINAL CALL keyword (5796)

final call, to a UDF (5799)

finalize Java method (7393)

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

findvwl() UDF C program listing (6071)

FIPS 127-2 standard (4704)

first call, to a UDF (5800)

fixed or varying length data types

EUC consideration (6292)

flagger utility, used in precompiling (4835)

flexibility and UDTs (5697)

float C/C++ type (6697)

float OLE automation type (5965)

FLOAT parameter to UDF (5858)

FLOAT SQL data type (4949), (5924), (6662), (6874), (7049) , (7179), (7315)

floating point parameter to UDF (5854)

flushed buffered insert (6411)

fold() UDF C program listing (6069)

FOR BIT DATA

considerations for stored procedures (5400)

data type in C/C++ (6744)

FOR BIT DATA modifier in UDFs (5861)

FOR BIT DATA SQL data type (5930), (7321)

FOR EACH ROW trigger (6118)

FOR EACH STATEMENT trigger (6119)

FOR UPDATE clause (5009)

FORCE command (7483)

foreign key, DB2 Connect support (7513)

FORTRAN

data types supported (7040), (7105)

embedding SQL statements (4804)

file reference declarations (7037)

host variables, overview (7017)

indicator variables, rules for (7028)

input and output files (6955)

Japanese and Traditional-Chinese EUC considerations (7115)

LOB data declarations (7030)

LOB locator declarations (7034)

programming considerations (6947)

programming restrictions (6950)

referencing host variables (7015)

FORTRAN data types (7046)

BLOB (7101)

BLOB_FILE (7103)

BLOB_LOCATOR (7102)

CHARACTER*n (7097)

CLOB (7098)

CLOB_FILE (7100)

CLOB_LOCATOR (7099)

INTEGER*2 (7092)

INTEGER*4 (7093)

REAL*2 (7094)

REAL*4 (7095)

REAL*8 (7096)

FORTRAN language

data types supported (7042)

fullselect

buffered insert consideration (6454)

fullselect consideration (6456)

FUNCPATH bind option (4865)

function invocations example (5676)

function path and UDFs (5626)

function references, summary for UDFs (5687)

function selection algorithm and UDFs (5628)

function-name, passing to UDF (5778)

functions

aggregating functions (5635)

column functions (5634)

scalar functions (5633)

syntax for referring to (5674)

table functions (5636)

with SQL triggered statements (6144)

GET ERROR MESSAGE API (7149)

getAsciiStream JDBC API (7299)

getString JDBC API (7298)

getUnicodeStream JDBC API (7300)

global enforcement of business rules using triggers (6102)

GRANT statement

DB2 Connect support (7463)

graphic constants

handling Japanese and Traditional-Chinese EUC code sets (6245)

graphic data

handling Japanese and Traditional-Chinese EUC code sets (6242)

Japanese and Traditional-Chinese EUC code sets (6221)

graphic data types

selecting (6638)

graphic host variables

C/C++ (6605)

COBOL (6833)

GRAPHIC parameter to UDF (5864)

graphic strings

character conversion (6214)

GRAPHIC type (7286)

graphical objects

considerations for Java (7283)

GROUP BY clause

sort order (7509)

group data items COBOL

methods for using (6853)

other uses (6855)

group of rows

in buffered insert (6434)

guideline

access to data (4759)

application logic at server (4793)

data relationship control (4784)

data value control (4770)

DB2 application design (4755)

handle

connection handle (5181)

descriptor handle (5182)

environment handle (5180)

statement handle (5176)

highlighting conventions used in this book (4668)

host variables

allocating in stored procedures

client side (5364)

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

clearing LOB host variables in REXX (7172)

considerations for stored procedures (5410)

declaring (4928)

in C/C++ (6595)

in COBOL (6828)

in FORTRAN (7019), (7021)

declaring as pointer to data type (6623)

declaring graphic

in C/C++ (6603)

in COBOL (6834)

declaring using variable list statement (5151)

declaring, examples of (4932)

declaring, rules for (4930)

declaring, sample programs (5042)

definition (4925)

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

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

file reference declarations in COBOL (6845)

file reference declarations in FORTRAN (7036)

file reference declarations in REXX (7169)

FORTRAN, overview of (7016)

graphic data (6634)

handling graphic

multi-byte character encoding (6635)

WCHARTYPE precompiler option (6643)

host structure support in COBOL (6848)

in REXX (7144)

initializing for stored procedure

SQLDA structure (5360)

initializing in C/C++ (6617)

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

LOB data declarations in COBOL (6837)

LOB data declarations in FORTRAN (7029)

LOB data in REXX (7165)

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

LOB locator declarations in COBOL (6842)

LOB locator declarations in FORTRAN (7033)

LOB locator declarations in REXX (7167)

naming

in C/C++ (6591)

in COBOL (6826)

in FORTRAN (7018)

in REXX (7145)

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

referencing

in C/C++ (6590)

in COBOL (6825)

in FORTRAN (7014)

in REXX (7146)

referencing from SQL, examples (4933)

relating to an SQL statement (4692)

selecting graphic data types (6636)

static SQL (4927)

use in dynamic SQL (5092)

used to pass blocks of data (6404)

how to use this book (4667)

HTML page

tagging example (7270)

implementing a UDF (5642)

implicit connect (7469)

include file

C/C++ requirements for (6523)

COBOL requirements for (6757)

FORTRAN requirements for (6956)

SQL

C/C++ (6524)

COBOL (6760)

FORTRAN (6957)

SQL1252A

COBOL (6796)

FORTRAN (6997)

SQL1252B

COBOL (6797)

FORTRAN (6999)

SQLADEF

C/C++ (6527)

SQLAPREP

C/C++ (6529)

COBOL (6762)

FORTRAN (6960)

SQLCA

C/C++ (6530)

COBOL (6763)

FORTRAN (6961)

SQLCA_CN

FORTRAN (6962)

SQLCA_CS

FORTRAN (6963)

SQLCA_92

COBOL (6767)

FORTRAN (6968)

SQLCLI

C/C++ (6534)

SQLCLI1

C/C++ (6536)

SQLCODES

C/C++ (6537)

COBOL (6770)

FORTRAN (6972)

SQLDA

C/C++ (6539)

COBOL (6773)

FORTRAN (6974)

SQLDACT

FORTRAN (6975)

SQLE819A

C/C++ (6548)

COBOL (6783)

FORTRAN (6984)

SQLE819B

C/C++ (6551)

COBOL (6786)

FORTRAN (6987)

SQLE850A

C/C++ (6553)

COBOL (6788)

FORTRAN (6989)

SQLE850B

C/C++ (6555)

COBOL (6790)

FORTRAN (6991)

SQLE932A

C/C++ (6557)

COBOL (6792)

FORTRAN (6993)

SQLE932B

C/C++ (6559)

COBOL (6794)

FORTRAN (6995)

SQLEAU

C/C++ (6541)

COBOL (6774)

FORTRAN (6978)

SQLENV

C/C++ (6544)

COBOL (6777)

FORTRAN (6981)

SQLETSD

COBOL (6780)

SQLEXT

C/C++ (6546)

SQLJACB

C/C++ (6561)

SQLMON

C/C++ (6564)

COBOL (6800)

FORTRAN (7001)

SQLMONCT

COBOL (6802)

SQLSTATE

C/C++ (6567)

COBOL (6804)

FORTRAN (7003)

SQLSYSTM

C/C++ (6569)

SQLUDF

C/C++ (6572)

SQLUTBCQ

COBOL (6807)

SQLUTBSQ

COBOL (6810)

SQLUTIL

C/C++ (6574)

COBOL (6813)

FORTRAN (7006)

SQLUV

C/C++ (6576)

SQLUVEND

C/C++ (6578)

SQLXA

C/C++ (6581)

include files

locating in C/C++ (6507)

locating in COBOL (6823)

locating in FORTRAN (6952)

INCLUDE SQLCA

pseudocode (4694)

INCLUDE SQLDA statement (4717)

INCLUDE SQLDA statement, creating SQLDA structure (5140)

INCLUDE statement (4716)

inconsistent data (4725)

inconsistent state (4726)

index

lock mode (5295)

look-up, affect on locks (5290)

indicator tables, COBOL support for (6857)

indicator variables

declaring (4936)

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

in COBOL, rules for (6835)

in FORTRAN, rules for (7027)

in REXX, rules for (7147)

using in stored procedures (5382)

using on nullable columns (4981)

indicator variables and LOB locators (5591)

infix notation and UDFs (5690)

inflight

defined (5232)

inner-table and outer-table, method (5341)

inner-table, method (5344), (5347)

INPCLI.CMD REXX program listing (5500)

INPCLI.SQB COBOL program listing (5496)

INPCLI.SQC C program listing (5494)

INPCLI.SQF FORTRAN program listing (5498)

INPSRV.CMD REXX program listing (5511)

INPSRV.SQB COBOL program listing (5507)

INPSRV.SQC C program listing (5505)

INPSRV.SQF FORTRAN program listing (5509)

input and output files

C/C++ (6499)

COBOL (6754)

FORTRAN (6954)

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

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

INSERT BUF bind option

buffered inserts (6424)

insert operation and triggers (6109)

INSERT statement

DB2 Connect support (7442), (7457)

not supported in CLP (6457)

with VALUES clause (6419)

inserting data into a CLOB column example (5610)

inserts

without buffered insert (6416)

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

Int Java type (7356)

INTEGER (5794)

integer divide operator for UDFs example (6059)

INTEGER or INT parameter to UDF (5850)

INTEGER SQL data type (4948), (5923), (6661), (6873), (7048) , (7178), (7314)

INTEGER*2 FORTRAN type (7080)

INTEGER*4 FORTRAN type (7081)

interactive SQL

processing, sample program (5154)

interrupt handling with SQL statements (5071)

interrupts, SIGUSR1 (5078)

invoking UDFs (5671)

ISO 10646 standard (6223)

ISO 2022 standard (6222)

ISO/ANS SQL92 (7500)

ISO/ANSI SQL92 standard (4705)

isolation level (7528)

choosing (5214)

cursor stability (5207)

description of (5192)

read stability (5203)

repeatable read (5197)

specifying, overview (5215)

uncommitted read (5208)

Japanese and Traditional-Chinese EUC code sets

C/C++ considerations (6648)

COBOL considerations (6940)

developing applications (6237)

FORTRAN considerations (7112)

overview (6217)

REXX considerations (7241)

Java

applets (7254)

applications (7255)

considerations for stored procedures (5408)

Java applet

distributing and running (7269)

Java application

code page conversion (7303)

distributing and running (7274)

extensions (7279)

limitations (7280)

overloading Java methods (7308)

SCRATCHPAD consideration (7392)

signature for stored procedure (7406)

signature for UDFs (7381)

stored procedure example (7407)

using graphical and large objects (7282)

using stored procedures (7306)

using UDFs (7307)

Java class files

CLASSPATH environment variable (7368)

java_heap_size configuration parameter (7370)

jdk11_path configuration parameter (7369)

where to place (7367)

Java data types

BigDecimal (7364)

Blob (7366)

double (7363)

Int (7362)

short (7361)

String (7365)

Java Database Connectivity (JDBC) (7251)

drivers

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

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

Java Database Connectivity (JDBC) APIs

getAsciiStream (7293)

getString (7292)

getUnicodeStream (7294)

setAsciiStream (7290)

setString (7289)

setUnicodeStream (7291)

Java Development Kit (JDK) (7250)

Java I/O streams

System.err (7385)

System.in (7383)

System.out (7384)

Java interpreter

overview of DB2 support (7261)

Java language

getting started (7252)

overview of DB2 support (7258)

using in DB2 applications (7248)

Java packages and classes (7264)

COM.ibm.db2.app (7312)

Java UDF consideration (5753)

java_heap_size configuration parameter (7373)

jdk11_path configuration parameter (7372)

join strategies (5324), (5325), (5326), (5327)

LABEL ON statement

DB2 Connect support (7550)

LANGLEVEL precompile option

MIA

SAA1 (6736)

using SQL92E and SQLSTATE or SQLCODE variables (6749), (6938), (7110)

LANGLEVEL SQL92E pre-compile option (7499)

LANGUAGE OLE clause (5900)

language support, for stored procedures (5358)

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

large object descriptor (5556)

large object value (5555)

latch

status with multiple threads (6343)

limitations

stored procedures (5376)

linking

client application (5447)

overview of (4837)

stored procedures (5445)

linking a UDF (5644)

LOB data type

not supported in DB2 Connect (7458)

LOB locator APIs, used in UDFs

sqludf_append API (6018)

sqludf_create_locator API (6019)

sqludf_free_locator API (6020)

sqludf_length API (6016)

sqludf_substr API (6017)

LOB locator example program listing (6080)

LOB locators

scenarios for using (6022)

used in UDFs (6005)

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

LOBEVAL.SQB COBOL program listing (5589), (5608)

LOBEVAL.SQC C program listing (5587), (5606)

LOBLOC.SQB COBOL program listing (5579)

LOBLOC.SQC C program listing (5577)

LOBLOC.SQF FORTRAN program listing (5581)

LOBs (Large Objects)

and DB2 object extensions (5529)

considerations for Java (7284)

file reference variables (5550)

examples of using (5601)

input values (5592)

output values (5596)

SQL_FILE_APPEND, output value option (5600)

SQL_FILE_CREATE, output value option (5598)

SQL_FILE_OVERWRITE, output value option (5599)

SQL_FILE_READ, input value option (5594)

large object descriptor (5552)

large object value (5549)

locators (5551), (5571)

example of using (5573), (5584)

indicator variables (5590)

programming scenarios (5585)

manipulating (5531)

programming options for values (5572)

storing (5530)

synergy with triggers, UDTs, and UDFs (6155)

synergy with UDTs and UDFs

examples of complex applications (5737)

locales

deriving in application programs (6188)

how DB2 derives (6189)

locating include files

C/C++ (6506)

COBOL (6822)

FORTRAN (6951)

locators for manipulating LOBs (5553)

LOCK TABLE statement

in minimizing escalations (5278)

use to override locks (5296)

locking (7516)

buffered insert error (6445)

locks

acquiring (5239)

attributes of (5241)

attributes, types of processing (5288)

avoiding global deadlocks (5281)

compatibility of, ensuring (5267)

conversion of (5271)

creating, using cursor stability (5206)

creating, using repeatable read (5196)

deadlock, using FOR UPDATE OF (5285)

duration attribute (5243)

escalation and actions to take (5277)

escalation of (5274)

exclusive (X) mode (5253)

exclusive mode, reasons for using (5301)

factors affecting (5286)

improving concurrency (5276)

intent exclusive (IX) mode (5250)

intent none (IN) mode (5247)

intent share (IS) mode (5248)

locktimeout configuration parameter (5280)

mode attribute (5244)

modes for index scan (5294)

modes for table scan (5292)

object attribute (5242)

overview of (5235)

read stability (5202)

reducing waits for (5279)

share (S) mode (5249)

share mode, reasons for using (5299)

share with intent exclusive (SIX) mode (5251)

state (mode), types of (5246)

superxclusive (Z) mode (5254)

update (U) mode (5252)

LOCKTIMEOUT configuration parameter (6378)

LOCKTIMEOUT DUOW configuration parameter (6322)

log

recovery log, function of (5233)

recovery log, to protect consistency (5226)

long C/C++ type (6695)

long field restriction

using buffered inserts (6452)

long fields (7456)

long int C/C++ type (6696)

long OLE automation type (5964)

LONG VARCHAR

parameter to UDF (5863)

storage limits (5541)

LONG VARCHAR SQL data type (4955), (5932), (6668), (6880), (7055) , (7185), (7323)

LONG VARGRAPHIC

parameter to UDF (5870)

storage limits (5542)

LONG VARGRAPHIC SQL data type (4957), (5934), (6670), (6882), (7057) , (7187), (7325)

LONGVAR type (7285)

looping application

diagnosing (6486)

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

macros in sqludf.h (5885)

mail OLE automation UDF object example in BASIC (6086)

manipulating large objects (5536)

maxdari configuration parameter (7403)

maximum size for large object columns, defining (5561)

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

memory

decreasing requirement using LOB locators (6009)

memory allocation for unequal code pages (6268)

memory size, shared for UDFs (6040)

memory, allocating dynamic in the UDF (6032)

message file, definition of (4829)

method (5338), (5340), (5343), (5346)

method invocation

for OLE automation UDFs (5908)

MIA (6737)

Microsoft Exchange, used in mail example (6087)

mixed code set environments

application design (6260)

mixed EUC considerations (6228)

mixed-byte data (7447)

model for DB2 programming (4753)

modelling entities as independent objects (5520)

money using CREATE DISTINCT TYPE example (5708)

moving large objects using a file reference variable (5560)

multi-byte character support

code points for special characters (6194)

multi-byte considerations

Japanese and Traditional-Chinese EUC code sets (6220), (6239)

in C/C++ (6650)

in COBOL (6942)

in FORTRAN (7114)

in REXX (7243)

multiple definitions of SQLCA, avoiding (4712)

multiple threads

application dependencies between contexts (6370)

database dependencies between contexts (6367)

guidelines (6361)

preventing deadlocks between contexts (6375)

using in DB2 applications (6339)

multiple triggers, ordering of (6150)

national language support

mixed-byte data (7448)

national language support (NLS)

character conversion (6206)

code page (6207)

considerations (6160)

Next Key Exclusive Lock (NX) mode (5260)

Next Key Share Lock (NS) mode (5259)

Next Key Weak Exclusive Lock (NW) mode (5262)

NOCONVERT

WCHARTYPE

in stored procedures (5413)

NOLINEMACRO

PREP option (6511)

nonexecutable SQL statements

DECLARE CURSOR (4715)

INCLUDE (4713)

INCLUDE SQLDA (4714)

normal call, to a UDF (5798)

NOT ATOMIC compound SQL (7535)

NOT DETERMINISTIC option and UDFs (6035)

NOT FENCED LOB locator UDFs (6021)

NOT NULL CALL clause (5768)

NOT NULL CALL option and UDFs (6034)

not-fenced stored procedures

considerations (5465), (5466)

precompiling (5462)

working with (5458)

NS (Next Key Share Lock) mode (5258)

NULL value

receiving, preparing for (4937)

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

null-terminator (6740)

numeric conversion overflows (7527)

numeric data types (7445)

numeric host variables

C/C++ (6597)

COBOL (6831)

FORTRAN (7023)

NUMERIC parameter to UDF (5852)

NUMERIC SQL data type (5928), (7319)

NW (Next Key Weak Exclusive Lock) mode (5263)

NX (Next Key Exclusive Lock) mode (5261)

object instances

for OLE automation UDFs (5906)

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

object oriented COBOL restrictions (6944)

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

object-orientation and UDFs (5616)

object-oriented extensions and UDTs (5701)

object-relational

application domain and object-orientation (5518)

constraint mechanisms (5526)

data types (5522)

definition (5517)

LOBs (5524)

support for (5540)

triggers (5525)

UDTs and UDFs (5523)

why use the DB2 object extensions (5521)

ODBC

and DB2 CLI (4811)

core level functions (4812)

OLE automation data types (5921)

BSTR (5975)

DATE (5974)

double (5973)

float (5972)

long (5971)

SAFEARRAY (5976)

short (5970)

OLE automation object counting example (5666)

OLE automation server (5897)

OLE automation types (5910)

OLE automation types and BASIC types (5914)

OLE automation types and C++ types (5915)

OLE automation UDFs

creatable multi-use OLE automation server (5982)

creatable single-use OLE automation server (5981)

implementation (5891)

implementation in BASIC (5977)

implementation in C++ (5979)

object instances (5903)

scratchpad considerations (5904)

UDFs (5888)

OLE keyword (5889)

OLE messaging example (6088)

OLE programmatic ID (progID) (5895)

OPEN call (5809)

open state, buffered insert (6438)

OPENFTCH.SQB COBOL program listing (5022)

OPENFTCH.SQC C program listing (5020)

OPENFTCH.SQF FORTRAN program listing (5024)

optimization class

guidelines (5321)

levels of (5315)

setting (5317)

optimizer

adjusting amount of optimization (5314)

ORDER BY clause

sort order (7508)

OS/400 via DB2 Connect (4671)

OS/400 using DB2 Connect (7423)

OUTCLI.CMD REXX program listing (5478)

OUTCLI.SQB COBOL program listing (5474)

OUTCLI.SQC C program listing (5472)

OUTCLI.SQF FORTRAN program listing (5476)

outer-table, method (5336)

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

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

OUTSRV.CMD REXX program listing (5489)

OUTSRV.SQB COBOL program listing (5485)

OUTSRV.SQC C program listing (5483)

OUTSRV.SQF FORTRAN program listing (5487)

overloaded function names and UDFs (5627)

overloading Java methods (7309)

owner (7493)

package

attributes (7496)

creating (4838)

creating for compiled applications (4820)

isolation levels, specifying (5193)

renaming (4843)

support to REXX applications (7221)

timestamp errors (4874)

page-level locking (7517)

parameter markers (5174)

in functions example (5679)

in processing arbitrary statements (5148)

programming example (5162)

SQLVAR entries (5161)

use in dynamic SQL (5158)

partitioned environment

error handling considerations (6463)

identifying when errors occur (6480)

severe error considerations (6466)

passing contexts between threads (6346)

performance

adjusting optimization class (5316)

dynamic SQL caching (4911)

factors affecting, static SQL (4909)

guidelines (5349)

improving using stored procedures (5352)

improving with read only cursors (5014)

increasing using LOB locators (6010)

large objects (5570)

locks, effect of (5264)

not-fenced stored procedure (5457)

optimization class, adjusting (5312)

optimizing with packages (4871)

passing blocks of data (6402)

precompiling static SQL statements (4872)

programming considerations (5188)

row blocking, guidelines (5311)

UDFs (5615)

performance advantages

with buffered insert (6422)

performance and UDTs (5700)

PICTURE (PIC) clause in COBOL types (6905)

point of consistency

definition of (5221)

portability (5186)

porting applications (7427)

precompile option

WCHARTYPE NOCONVERT (5464)

precompiler

C/C++ language

#include macro (6492)

character set (6516)

debugging (6509)

macro processing (6490)

qualification and member operators (6629)

symbol substitution (6491)

trigraph sequences (6515)

COBOL (6751)

DB2 Connect support (7436), (7484)

FORTRAN (6948)

options (4823)

overview of (4807)

supported languages (4677)

types of output (4824)

precompiling (4832)

accessing DRDA application server through DB2 Connect (4831)

accessing multiple servers (4833)

client application (5448)

flagger utility (4834)

isolation level, specifying (5217)

options, updatable cursor (5017)

overview of (4821)

supporting dynamic SQL statements (5093)

PREP option

NOLINEMACRO (6512)

PREPARE statement

DB2 Connect support (7559)

processing arbitrary statements (5146)

summary of (5097)

preprocessor functions and the SQL precompiler (6495)

prerequisites, for programming (4675)

primary key, DB2 Connect support (7512)

printf() for debugging UDFs (6094)

problem resolution

stored procedures (5451)

processing SQL statements in REXX (7138)

program variable type, data value control consideration (4782)

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

programming considerations

accessing DRDA servers (6333)

collating sequences (6158)

conversion between different code pages (6159)

in a DRDA environment (7420)

in C/C++ (6489)

in COBOL (6750)

in FORTRAN (6946)

in REXX (7116)

national language support (6157)

programming in complex environments (6156)

X/Open XA interface (6381)

programming framework (4752)

protecting UDFs (6025)

prototyping SQL code (4901)

PUT statement

not supported in DB2 Connect (7560)

QSQ (DB2 for AS/400) (7475)

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

qualifier

different platforms (7492)

query products, access to data consideration (4768)

QUERYOPT bind option (4863)

RAISE_ERROR built-in function (6143)

re-entrant

stored procedures (5461)

UDFs (5989)

re-use and UDFs (5614)

read locks (5304)

read only cursors

uncommitted read (5211)

read stability, overview (5199)

reading

read stability, overview of (5198)

repeatable read, overview of (5194)

uncommitted read, overview of (5209)

REAL parameter to UDF (5855)

REAL SQL data type (4951), (5926), (6664), (6876), (7051) , (7181), (7317)

REAL*2 FORTRAN type (7082)

REAL*4 FORTRAN type (7083)

REAL*8 FORTRAN type (7084)

rebinding

description (4876)

REBIND PACKAGE command (4878)

recovery

log, function of (5234)

log, to protect consistency (5227)

REDEFINES in COBOL (6863)

REFERENCING clause in the CREATE TRIGGER statement (6132)

referential integrity

data relationship consideration (4787)

DB2 Connect support (7511)

referential integrity constraint

data value control consideration (4777)

registering

OLE automation UDFs (5894)

stored procedures (5512)

UDFs (5645)

registering Java stored procedures (7402)

releasing your connection

CMS applications (4734)

to DB2 (4737)

remote unit of work (6310)

renaming, package (4844)

REORGANIZE TABLE command (6231)

repeatable read, technique for (5027)

reporting errors (6477)

restoring data (4740)

restrictions

for UDFs (6038)

in C/C++ (6498)

in COBOL (6752)

in FORTRAN (6949)

in REXX (7123)

on using buffered inserts (6450)

restrictions for stored procedures (5375)

result code (4699) See also SQLCODE or SQLSTATE

RESULT REXX predefined variable (7158)

result sets

from stored procedures (5516)

resume using CREATE DISTINCT TYPE example (5709)

RESYNC_INTERVAL DUOW configuration parameter (6320)

retrieving

multiple rows (4985)

one row (4917)

rows (5011)

retrieving data

a second time (5031)

scroll backwards, technique for (5026)

updating (5038)

return code (4700) See also SQLCODE or SQLSTATE

SQLCA structure (5056)

RETURNS clause in the CREATE FUNCTION statement (5845)

RETURNS TABLE clause (5762)

REVOKE statement

DB2 Connect support (7464)

REXX

access to data consideration (4766)

API syntax (7228)

bind files

DB2ARXCS.BND REXX bind file (7215)

DB2ARXNC.BND REXX bind file (7219)

DB2ARXRR.BND REXX bind file (7216)

DB2ARXRS.BND REXX bind file (7218)

DB2ARXUR.BND REXX bind file (7217)

calling the DB2 CLP from application (7232)

clearing LOB host variables (7173)

cursor identifiers (7142)

data type equivalents for SQL types (7210)

execution requirements (7213)

indicator variables (7148), (7212)

initializing variables (7237)

interactive programming (4809)

isolation level, specifying (5218)

Japanese and Traditional-Chinese EUC considerations (7244)

LOB data (7166)

LOB file reference declarations (7170)

LOB locator declarations (7168)

predefined variables

RESULT (7151)

SQLCA (7154)

SQLISL (7153)

SQLMSG (7152)

SQLRDAT (7157)

SQLRIDA (7156)

SQLRODA (7155)

programming considerations (7125)

registering routines in (7131)

registering SQLEXEC, SQLDBS and SQLDB2 (7126)

restrictions in (7124)

sample programs (7245)

stored procedures in (7236)

supported SQL statements (7139)

REXX and C++ data types (7176)

REXX APIs

SQLDB2 (7119), (7230)

SQLDBS (7118)

SQLEXEC (7117)

ROLLBACK statement (4683)

association with cursor (4997)

backing out changes (4742)

ending transactions (4748)

in DB2 Connect (7482)

in transaction management (5225)

restoring data (4743)

rolling back changes (4744)

ROLLBACK WORK RELEASE

not supported in DB2 Connect (7561)

rolling back changes (4741)

row (5307) See also row blocking

blocking (5306)

lock compatibility, ensuring (5269)

locking (5195), (5201), (5205)

order of in table, positioning (5035)

order of, controlling (5032)

read stability (5200)

retrieving multiple with cursor (5010)

retrieving one (4914)

retrieving using SQLDA (5135)

selecting one, with SELECT INTO statement (4916)

types of locks on (5255)

row blocking

types of (5310)

customizing for performance (6401)

overview of (5308)

row-level locking (7518)

rows

set of rows affected by triggers (6116)

RQRIOBLK field (7490)

rules that govern operations on large objects (5538)

run-time services

multiple threads, affect on latches (6342)

running Java applets (7272)

running Java applications (7276)

running stored procedures

client side (5368)

SAA1 (6738)

SAFEARRAY OLE automation type (5969)

sales using CREATE TABLE example (5714)

sample programs (4906) See also examples

Application Program Interface (API) (7417)

embedded SQL statements (7416)

Java stored procedures (7400)

Java UDFs (7377)

location of (7418)

savepoint, buffered insert consideration (6413)

scalar functions (5637)

contents of call-type argument (5802)

schema-name and UDFs (5630)

scratchpad and UDFs (5988), (7390)

SCRATCHPAD clause (5812)

scratchpad considerations

for OLE automation UDFs (5905)

SCRATCHPAD keyword (5790), (5797), (5990), (7391)

SCRATCHPAD option

for OLE automation UDFs (5907)

scratchpad, passing to UDF (5756), (5787)

section number (7552)

SELECT INTO statement

overview of (4915)

SELECT statement

association with EXECUTE statement (5102)

buffered insert consideration (6436)

DB2 Connect support (7441)

declaring an SQLDA (5125)

describing, after allocating SQLDA (5132)

in DECLARE CURSOR statement (4991)

retrieving data a second time (5029)

retrieving multiple rows with (4984)

updating retrieved data (5036)

varying-list, overview of (5149)

self-referencing tables (7514)

semantic behavior of stored objects (5537)

semaphores (6372)

serialization of data structures (6363)

serialization of SQL statement execution (6344)

SET CURRENT FUNCTION PATH statement (5641)

SET CURRENT PACKAGESET statement (4857)

SET CURRENT QUERY OPTIMIZATION statement

use of (5320)

SET CURRENT statement

DB2 Connect support (7562)

setAsciiStream JDBC API (7296)

setString JDBC API (7295)

setting up a DB2 program (4685)

setUnicodeStream JDBC API (7297)

severe errors

considerations in a partitioned environment (6465)

share mode

reasons for using (5300)

shared memory size for UDFs (6039)

shift-out and shift-in characters (7451)

short C/C++ type (6693)

short int C/C++ type (6694)

short Java type (7355)

short OLE automation type (5963)

signal handlers

installing, sample programs (5043)

with SQL statements (5072)

SIGNAL SQLSTATE SQL statement to validate input data (6097)

signature, two functions and the same (5631)

SIGUSR1 interrupt (5077)

SMALLINT (5769), (5774)

SMALLINT parameter to UDF (5849)

SMALLINT SQL data type (4947), (5922), (6660), (6872), (7047) , (7177), (7313)

snapshot monitor

diagnosing a suspended or looping application (6488)

solving problems

numeric conversion overflows (7526)

sort order (7504)

sorting

specifying collating sequence (6169)

specifying collating sequences (6175)

source file

creating, overview of (4815)

file name extensions (4826)

modified source file, definition of (4825)

requirements (4830)

SQL file extensions (4814)

source-level debuggers and UDFs (6093)

sourced UDF (5721)

special registers

CURRENT EXPLAIN MODE (4852)

CURRENT FUNCTION PATH (4853)

CURRENT QUERY OPTIMIZATION (4851)

specific-name, passing to UDF (5781)

SPM_LOG_SIZE DUOW configuration parameter (6330)

SPM_NAME DUOW configuration parameter (6328)

SPM_RESYNC_AGENT_LIMIT DUOW configuration parameter (6326)

SQL

authorization considerations (4880)

authorization considerations for dynamic SQL (4881)

authorization considerations for static SQL (4883)

authorization considerations using APIs (4884)

dynamically prepared (5184)

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

SQL Communications Area (SQLCA) (4697)

SQL Data Types

SQL data types (5911), (5918)

BLOB (4974), (5957), (6687), (6899), (7074) , (7204), (7349)

C null-terminated graphic string (7348)

C null-terminated string (7347)

CHAR (4969), (5949), (6682), (6894), (7069) , (7199), (7341)

CLOB (4975), (5958), (6688), (6900), (7075) , (7205), (7350)

DATE (4977), (5960), (6690), (6902), (7077) , (7207), (7352)

DBCLOB (4976), (5959), (6689), (6901), (7076) , (7206), (7351)

DECIMAL (4967), (6680), (6892), (7067), (7197) , (7337)

DOUBLE (5946), (7338)

FLOAT (4966), (5945), (6679), (6891), (7066) , (7196), (7336)

FOR BIT DATA (5950), (7342)

GRAPHIC (5953)

INTEGER (4965), (5944), (6678), (6890), (7065) , (7195), (7335)

LONG GRAPHIC (5954)

LONG VARCHAR (4971), (5952), (6684), (6896), (7071) , (7201), (7344)

LONG VARGRAPHIC (4973), (5956), (6686), (6898), (7073) , (7203), (7346)

NUMERIC (5948), (7340)

REAL (4968), (5947), (6681), (6893), (7068) , (7198), (7339)

SMALLINT (4964), (5943), (6677), (6889), (7064) , (7194), (7334)

TIME (4978), (5961), (6691), (6903), (7078) , (7208), (7353)

TIMESTAMP (4979), (5962), (6692), (6904), (7079) , (7209), (7354)

VARCHAR (4970), (5951), (6683), (6895), (7070) , (7200), (7343)

VARGRAPHIC (4972), (5955), (6685), (6897), (7072) , (7202), (7345)

SQL data types, passed to a UDF (5837)

SQL declare section (4686)

SQL include file

for C/C++ applications (6525)

for COBOL applications (6759)

for FORTRAN applications (6958)

SQL statement categories (7431)

SQL statement execution

serialization (6345)

SQL statements

C/C++ syntax (6583)

COBOL syntax (6815), (6817)

DB2 Connect support (7546), (7554)

exception handlers (5075)

FORTRAN syntax (7009)

grouping using stored procedures (5353)

interrupt handlers (5074)

REXX syntax (7136)

saving end user requests (5153)

signal handlers (5073)

supported in REXX (7140)

SQL/DS via DB2 Connect (4670)

SQL-argument (5803)

SQL-argument, passing to UDF (5758)

SQL-argument-ind (5804)

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

SQL-result (5805), (5998)

SQL-result, passing to UDF (5760)

SQL-result-ind (5806), (5999)

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

SQL-state, passing to UDF (5775)

SQL/DS using DB2 Connect (7424)

SQL1252A include file

for COBOL applications (6795)

for FORTRAN applications (6996)

SQL1252B include file

for COBOL applications (6798)

for FORTRAN applications (6998)

SQL92 (7501)

SQLADEF include file

for C/C++ applications (6526)

SQLAPREP include file

for C/C++ applications (6528)

for COBOL applications (6761)

for FORTRAN applications (6959)

SQLCA

avoiding multiple definitions (4711)

error reporting in buffered insert (6442)

incomplete insert when error occurs (6443)

multi-threading considerations (6364)

SQLERRMC field (7476), (7538)

SQLERRP field (7471)

SQLCA include file

for C/C++ applications (6532)

for COBOL applications (6765)

for FORTRAN applications (6964)

SQLCA predefined variable (7161)

SQLCA structure

defining, sample programs (5041)

include file

for C/C++ applications (6531)

for COBOL applications (6764)

for FORTRAN applications (6965)

merged multiple structures (6472)

overview (5057)

reporting errors (6478)

requirements (5059)

sqlerrd (6473)

SQLERRD(6) field (6482)

SQLWARN1 field (4942)

using in stored procedures (5384)

warnings (4940)

SQLCA.SQLERRD settings on CONNECT (6273)

SQLCA_92 include file

for COBOL applications (6766)

for FORTRAN applications (6969)

SQLCA_92 structure

include file

for FORTRAN applications (6970)

SQLCA_CN include file (6967)

SQLCA_CS include file (6966)

SQLCHAR structure

passing data with (5144)

SQLCLI include file

for C/C++ applications (6533)

SQLCLI1 include file

for C/C++ applications (6535)

SQLCODE

including SQLCA (4698)

platform differences (7522)

reporting errors (6479)

standalone (7502)

structure (5060)

SQLCODE -1015 (6468)

SQLCODE -1034 (6467)

SQLCODE -1224 (6470)

SQLCODES include file

for C/C++ applications (6538)

for COBOL applications (6769)

for FORTRAN applications (6971)

SQLDA

multi-threading considerations (6365)

SQLDA include file

for C/C++ applications (6540)

for COBOL applications (6772)

for FORTRAN applications (6976)

SQLDA structure

association with PREPARE statement (5099)

creating (allocating) (5139)

creating, host language examples (5141)

declaring (5124)

declaring sufficient SQLVAR entities (5130)

fields used in stored procedures

SQLDATA (5388)

SQLIND (5389)

SQLLEN (5387)

SQLTYPE (5386)

initializing for stored procedure (5359)

input-SQLDA procedure, sample of (5491)

manipulation with stored procedure (5380)

passing data with (5143)

preparing statements using minimum (5129)

sample output-SQLDA structure (5468)

server input procedure, sample of (5502)

stored procedure, sample of (5480)

used to pass blocks of data (6403)

using in stored procedures (5383)

using, sample program (5155)

sqlda.n.SQLDAT (5435)

sqlda.n.SQLDATALEN (5441)

sqlda.n.SQLDATATYPE_NAME (5439)

sqlda.n.SQLIND (5436)

sqlda.n.SQLLEN (5434)

sqlda.n.SQLLONGLEN (5440)

sqlda.n.SQLNAME.data (5438)

sqlda.n.SQLNAME.length (5437)

sqlda.n.SQLTYPE (5433)

sqlda.SQLDABC (5431)

sqlda.SQLDAID (5430)

sqlda.SQLN (5432)

SQLDACT include file (6977)

SQLDATA field (5392)

SQLDB2 REXX API (7122), (7231)

SQLDB2, registering for REXX (7129)

sqldbchar and wchar_t, selecting data types (6640)

sqldbchar C/C++ type (6700)

sqldbchar data type (5865), (5868), (5871), (5879), (6642)

SQLDBS REXX API (7121)

SQLDBS, registering for REXX (7128)

SQLE819A include file

for C/C++ applications (6549)

for COBOL applications (6782)

for FORTRAN applications (6983)

SQLE819B include file

for C/C++ applications (6552)

for COBOL applications (6785)

for FORTRAN applications (6986)

SQLE850A include file

for COBOL applications (6787)

for FORTRAN applications (6988)

SQLE850B include file

for COBOL applications (6789)

for FORTRAN applications (6990)

SQLE859A include file

for C/C++ applications (6554)

SQLE859B include file

for C/C++ applications (6556)

SQLE932A include file

for C/C++ applications (6558)

for COBOL applications (6791)

for FORTRAN applications (6992)

SQLE932B include file

for C/C++ applications (6560)

for COBOL applications (6793)

for FORTRAN applications (6994)

sqleAttachToCtx() API (6357)

SQLEAU include file

for C/C++ applications (6542)

for COBOL applications (6775)

for FORTRAN applications (6979)

sqleBeginCtx() API (6355)

sqleDetachFromCtx() API (6358)

sqleEndCtx() API (6356)

sqleGetCurrentCtx() API (6359)

sqleInterruptCtx() API (6360)

SQLENV include file

for C/C++ applications (6543)

for COBOL applications (6776)

for FORTRAN applications (6980)

SQLERRD(1) (6212), (6265), (6271)

SQLERRD(2) (6213), (6266), (6272)

SQLERRD(3)

in an XA environment (6395)

SQLERRMC field of SQLCA (6211), (7477), (7539)

SQLERRP field of SQLCA (7470)

sqleSetTypeCtx() API (6354)

SQLETSD include file

for COBOL applications (6779)

SQLEXEC

processing SQL statements in REXX (7137)

SQLEXEC REXX API (7120)

SQLEXEC, registering for REXX (7127)

SQLEXT include file

for CLI applications (6547)

SQLIND field (5393)

SQLISL predefined variable (7160)

SQLJACB include file

for C/C++ applications (6562)

SQLLEN field (5391)

SQLMON include file

for C/C++ applications (6563)

for COBOL applications (6799)

for FORTRAN applications (7000)

SQLMONCT include file

for COBOL applications (6801)

SQLMSG predefined variable (7159)

SQLRDAT predefined variable (7164)

SQLRIDA predefined variable (7163)

SQLRODA predefined variable (7162)

SQLSTATE

differences (7523)

in CLI (5183)

in SQLERRMC field of SQLCA (7540)

standalone (7503)

SQLSTATE field, in error messages (5064)

SQLSTATE include file

for C/C++ applications (6566)

for COBOL applications (6803)

for FORTRAN applications (7002)

SQLSYSTM include file

for C/C++ applications (6570)

SQLTYPE field (5390)

SQLUDF include file

description (5882)

for C/C++ applications (6571)

UDF interface (5750)

sqludf.h include file (5846)

sqludf.h include file for UDFs (5817)

sqludf_append API (6013)

sqludf_create_locator API (6014)

sqludf_free_locator API (6015)

sqludf_length API (6011)

sqludf_substr API (6012)

SQLUTBCQ include file

for COBOL applications (6806)

SQLUTBSQ include file

for COBOL applications (6809)

SQLUTIL include file

for C/C++ applications (6573)

for COBOL applications (6812)

for FORTRAN applications (7005)

SQLUV include file

for C/C++ applications (6577)

SQLUVEND include file

for C/C++ applications (6579)

SQLVAR

allocating in stored procedures

client side (5365)

SQLVAR entities

declaring sufficient number of (5131)

variable number of, declaring (5123)

SQLWARN structure, overview of (5066)

SQLXA include file

for C/C++ applications (6580)

SQLZ_DISCONNECT_PROC return value (5395)

SQLZ_HOLD_PROC return value (5396)

SQL_API_FN macro (5371), (5834)

SQL_FILE_READ, input value option (5595)

SQL_WCHART_CONVERT preprocessor macro (6645)

statement handle (5175)

statements

BEGIN DECLARE SECTION (4687)

COMMIT (4731)

CONNECT (4721)

END DECLARE SECTION (4688)

INCLUDE SQLCA (4695)

ROLLBACK (4738)

static SQL

coding statements to retrieve and manipulate data (4924)

comparing to dynamic SQL (5105)

considerations (5106)

DB2 Connect support (7429)

evaluating optimization class (5323)

overview (4907)

precompiling, advantages of (4873)

sample program (4913)

setting optimization class (5318)

static update programming example (5046)

using host variables (4926)

STATIC.SQB COBOL program listing (4921)

STATIC.SQC C program listing (4919)

STATIC.SQF FORTRAN program listing (4923)

storage

allocating to hold row (5136)

allocation warning, stored procedures (5362)

declaring sufficient SQLVAR entities (5128)

effect of locks on (5266)

storage allocation for unequal code pages (6267)

store procedures

host variables

allocating on the client (5366)

stored procedures (7530)

application logic consideration (4796)

application troubleshooting (5449)

building an application (5442)

C++ consideration (5404)

calling convention

CALL statement (5370)

parameter conversion (5373)

SQL_API_FN (5372)

character conversion (6198)

character conversions, for EUC (6307)

client application

running (5367)

code page considerations (5397)

coding in Java (7404)

compiling and linking (5443)

creating and using in Java (7396)

creating in Java (7305)

data structure usage (5417)

db2dari executable (5378)

description of (5469)

distributed unit of work (DUOW) considerations (5414)

example in Java (7408)

FOR BIT DATA considerations (5399)

graphic host variable considerations (5409)

initializing REXX variables (7239)

input-SQLDA procedure, sample of (5490)

input-SQLDA stored procedure, sample of (5501)

invoking (5355)

Japanese and Traditional-Chinese EUC code sets (6251)

Java considerations (5407)

Java interpreter (7262)

Java support (7259)

not-fenced (5456)

output-SQLDA stored procedure, sample of (5479)

output-SQLDA structure, sample (5467)

overview of (5350), (5369)

parameter variables

sqlda.n.SQLDAT (5423)

sqlda.n.SQLDATALEN (5429)

sqlda.n.SQLDATATYPE_NAME (5427)

sqlda.n.SQLIND (5424)

sqlda.n.SQLLEN (5422)

sqlda.n.SQLLONGLEN (5428)

sqlda.n.SQLNAME.data (5426)

sqlda.n.SQLNAME.length (5425)

sqlda.n.SQLTYPE (5421)

sqlda.SQLDABC (5419)

sqlda.SQLDAID (5418)

sqlda.SQLN (5420)

registering in DB2CLI.PROCEDURES (5513)

registering in Java (7397)

restrictions (5374)

return values (5394)

returning result sets (5515)

REXX applications (7238)

sample output client program (5470)

using indicator variables (5381)

using the SQLDA and SQLCA structures (5385)

storing large objects (5535)

String (7359)

string search and defining UDFs example (5654)

string search on BLOBs (5656)

string search over UDT example (5658)

strong typing and UDTs (5718)

structure definitions in sqludf.h (5883)

Structured Query Language (SQL)

statements, summary (4879)

table of supported statements (7415)

success code (4703) See also SQLCODE or SQLSTATE

surrogate functions (6098)

suspended application

diagnosing (6487)

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

Sync Point Manager (6331)

syntax

character host variables (6600)

declare section

in C/C++ (6594)

in COBOL (6830)

in FORTRAN (7022)

embedded SQL statement

avoiding line breaks (6588)

comments in C/C++ (6587)

comments in COBOL (6821)

comments in FORTRAN (7013)

comments in REXX (7143)

in C/C++ (6582)

in COBOL (6816)

in FORTRAN (7008)

substitution of white space characters (6589)

graphic host variable

in C/C++ (6602)

processing SQL statement

in REXX (7135)

syntax for referring to functions (5673)

SYSIBM.SYSPROCEDURES catalog (MVS) (7532)

system catalog

DB2 Connect support (7524)

system catalog views

prototyping tool (4904)

system configuration parameter for shared memory size (6041)

System.err Java I/O stream (7388)

System.in Java I/O stream (7386)

System.out Java I/O stream (7387)

table

committing changes (4736)

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

lock compatibility, ensuring (5270)

lock mode (5293)

locking (5298)

positioning cursor at end (5033)

scan, affect on locks (5291)

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

types of locks on (5245), (5256)

table check constraint, data value control consideration (4775)

table function (5764)

SQL-result argument (5765)

table function example (5669)

table functions (5640)

application design considerations (5996)

contents of call-type argument (5808)

in Java (7382)

table names

resolving unqualified (4855)

table queues (5348)

table space

types of locks on (5257)

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

target partition

behavior without buffered insert (6418)

territory, in SQLERRMC field of SQLCA (7480)

test data

generating (4895)

test database

CREATE DATABASE API (4893)

creating (4892)

recommendations (4894)

testing and debugging tools

database system monitor (4899)

Explain facility (4898)

flagger (4900)

system catalog views (4897)

updating system catalog statistics (4896)

testing environment

setting up (4890)

test databases, guidelines for creating (4891)

testing your UDF (6091)

tfweather_u table function C program listing (6078)

TIME parameter to UDF (5874)

TIME SQL data type (4962), (5941), (6675), (6887), (7062) , (7192), (7332)

timeout on a lock (7520)

TIMESTAMP parameter to UDF (5875)

TIMESTAMP SQL data type (4963), (5942), (6676), (6888), (7063) , (7193), (7333)

TM_DATABASE DUOW configuration parameter (6318)

TP_MON_NAME DUOW configuration parameter (6324)

traditional Chinese (6233)

Traditional-Chinese EUC Code set considerations (6226)

transaction

beginning a transaction (4727)

committing work done (4733)

description (4722)

ending a transaction (4729)

ending the program

COMMIT and ROLLBACK statements (4746)

implicitly ending (4750)

rolling back work done (4745)

transaction log consideration

for buffered insert (6427)

transaction log, buffered insert consideration (6426)

transaction logging

definition of (5228)

transaction management

overview of (5219)

transaction processing monitors

X/Open XA programming considerations (6380)

transition tables

based on type of trigger event (6134)

OLD_TABLE and NEW_TABLE (6133)

transition variables, OLD and NEW

transition variables based on type of trigger event (6128)

translation, character (7454)

triggering operation such as UPDATE, INSERT or DELETE (6108)

triggers

activation time (6120)

AFTER triggers (6122), (6139)

and DB2 object extensions (5527)

application logic consideration (4800)

BEFORE triggers (6121), (6138)

benefits (6100)

cascading (6145)

data relationship consideration (4789)

definition (6095)

delete operation (6114)

functions with SQL triggered statements

RAISE_ERROR built-in function (6142)

insert operation (6112)

interactions with referential constraints (6147)

multiple triggers, ordering of (6149)

overview (6104)

referential constraints, interactions with using triggers (6148)

set of affected rows (6115)

synergy with UDTs, UDFs, and LOBs (6152)

transition tables (6130)

transition variables (6127)

trigger event (6107)

trigger granularity (6117)

triggered action condition (6135)

triggered SQL statement (6137)

update operation (6113)

WHEN clause (6136)

why use triggers (6096)

trigraph sequences (6517)

troubleshooting

stored procedures (5450)

using VisualAge C++ (5454)

truncation

host variables (4944)

indicator variables (4943)

type conversion

between SQL types and OLE automation types (5909)

type decoration

in stored procedures (5406)

in UDFs (6056)

type decoration consideration

C++ (6519)

type mapping

OLE automation types and BASIC types (5912)

OLE automation types and C++ types (5913)

types or arguments, promotions in UDFs (5848)

UCS-2 code set (6224)

UDFs (User-defined Functions)

UDFs (User-defined functions)

allocating dynamic memory in the UDF (6027)

and DB2 object extensions (5533)

C++ consideration (6054)

calling convention (5835)

casting (5693)

caveats (6042)

code page differences (6050)

coding in Java (7379)

concepts (5620)

considerations when using protected resources (6049)

creating and using in Java (7374)

creating in Java (7304)

db2udf executable (6048)

debugging your UDF (6089)

definition (5611)

DETERMINISTIC (5993)

example (6067)

examples of UDF code (6057)

EXTERNAL ACTION option (6030)

FENCED option (6031)

function path (5622)

function selection algorithm (5624)

general considerations (5688)

hints and tips for coding (6024)

implementing UDFs (5613)

infix notation (5689)

input and output to screen and keyboard (6046)

interface between DB2 and a UDF (5748)

invoking

examples of invocations (5670)

parameter markers in functions (5677)

qualified function reference (5680)

unqualified function reference (5683)

Japanese and Traditional-Chinese EUC code sets (6248)

Java consideration (5752)

list of types and their representations in UDFs (5839)

LOB locator usage scenarios (6023)

LOB types (5691)

NOT DETERMINISTIC (5992)

NOT DETERMINISTIC option (6029)

NOT FENCED (6064)

NOT NULL CALL (6063)

NOT NULL CALL option (6028)

OLE automation UDFs (5886)

output and input to screen and keyboard (6047)

overloaded function names (5623)

passing arguments from DB2 to a UDF (5751)

process of implementation (5646)

re-entrant UDFs (5987)

referring to functions (5672)

registering UDFs (5649)

examples of registering (5648)

restrictions and caveats (6043)

save state in function (5991)

schema-name and UDFs (5625)

SCRATCHPAD (5994)

scratchpad considerations (5986)

shared memory size (6044)

sourced (5722)

SQL data types, how they are passed (5838)

SQLUDF include file (5749), (5881)

SQL_API_FN (6062)

SUBSTR built-in function (6072)

summary of function references (5686)

synergy with triggers, UDTs, and LOBs (6154)

synergy with UDTs and LOBs

examples of complex applications (5736)

system configuration parameter for shared memory size (6045)

table functions (5997)

type of functions (5632)

unqualified reference (5621)

using LOB locators (6006)

why use UDFs (5612)

writing UDFs (5647)

writing your own UDF (5746)

UDFs and LOB types (5692)

UDFs(User-defined Functions)

Java interpreter (7263)

Java support (7260)

UDTs (User-defined Types)

UDTs (User-defined types)

and DB2 object extensions (5532)

defining a UDT (5702)

defining tables (5710)

manipulating

examples of (5716)

resolving unqualified UDTs (5704)

strong typing (5717)

synergy with triggers, UDFs, and LOBs (6153)

synergy with UDFs and LOBs

examples of complex applications (5735)

why use UDTs (5695)

unambiguous cursors (7489)

unequal code pages (6264), (6269)

unique key violation

buffered insert (6448)

unit of work

inflight, defined (5231)

completing (5000)

cursor considerations (4994)

definition of (5220)

distributed (6309)

remote (6311)

unit of work, distributed (6315)

unqualified function reference example (5685)

unqualified reference (5629)

unqualified table names

resolving (4854)

UPDAT.CMD REXX program listing (5054)

UPDAT.SQB COBOL program listing (5050)

UPDAT.SQC C program listing (5048)

UPDAT.SQF FORTRAN program listing (5052)

updatable cursor

uncommitted read (5210)

update operation (6106)

update operation and triggers (6110)

UPDATE statement

DB2 Connect support (7443)

USAGE clause in COBOL types (6906)

use of UDTs in UNION example (5734)

user updatable catalog statistics

prototyping tool (4905)

user-defined collating sequence (7510), (7565)

user-defined function, application logic consideration (4798)

user-defined sourced functions on UDTs example (5726)

using

Java stored procedures (7399)

Java UDFs (7376)

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

using qualified function reference example (5682)

UTIL.C program listing (5082)

UTIL.F program listing (5086)

utility APIs

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

include file for COBOL applications (6781), (6808), (6811), (6814)

include file for FORTRAN applications (7007)

VALIDATE RUN

DB2 Connect support (7486)

VALUES clause

on INSERT statement (6420)

VARCHAR (5780), (5783), (5786), (6745)

VARCHAR FOR BIT DATA parameter to UDF (5862)

VARCHAR SQL data type (4954), (5931), (6667), (6879), (7054) , (7184), (7322)

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

VARGRAPHIC data (6739)

VARGRAPHIC parameter to UDF (5867)

VARGRAPHIC SQL data type (4956), (5933), (6669), (6881), (7056) , (7186), (7324)

variable-length strings (7455)

variables

SQLCODE (6748), (6937), (7109)

SQLSTATE (6747), (6936), (7108)

variables, declaring (4679)

variables, predefined in REXX (7150)

VARINP.SQB COBOL program listing (5167)

VARINP.SQC C program listing (5165)

VARINP.SQF FORTRAN program listing (5169)

view

data value control consideration (4779)

DB2 Connect support (7525)

warning message, truncation (4939)

wchar_t C/C++ type (6701)

wchar_t data type (5866), (5869), (5872), (5880)

WCHARTYPE

guidelines (6646)

in stored procedures (5411)

WCHARTYPE precompiler option (5463), (6644)

wchar_t and sqldbchar, selecting data types (6639)

wchar_t data type (6641)

weight, definition of (6164)

WHENEVER SQLERROR CONTINUE statement (4709)

WHENEVER statement

caution in using with SQL statements (4708)

error indicators with SQLCA (4706)

in error handling (5069)

wild moves, DB2 checking of (6092)

Windows 95 code pages (6181)

DB2CODEPAGE environment variable (6184)

supported code pages (6185)

Windows NT code pages (6180)

DB2CODEPAGE environment variable (6182)

supported code pages (6183)

Windows registration database

for OLE automation UDFs (5892)

work environment

setting up (4888)

test databases, guidelines for creating (4889)

X/Open XA programming considerations (6382)

API restrictions (6396)

characteristics of transaction processing (6383)

CICS environment (6384)

COMMIT and ROLLBACK (6388)

cursors declared WITH HOLD (6391)

DISCONNECT (6386)

multi-threaded application (6399)

SET CONNECTION (6387)

single-threaded application (6398)

SQL CONNECT (6389)

transactions (6385)

XA environment (6394)

XA two-phase commit (6393)

XASerialize (6400)

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

[ DB2 List of Books | Search the DB2 Books ]