Call Level Interface Guide and Reference

SQLSetConnectAttr - Set Connection Attributes

Purpose

Specification: DB2 CLI 5.0 ODBC 3.0 ISO CLI

SQLSetConnectAttr() sets attributes that govern aspects of connections.

Syntax

SQLRETURN   SQLSetConnectAttr(SQLHDBC           ConnectionHandle,
                              SQLINTEGER        Attribute,
                              SQLPOINTER        ValuePtr,
                              SQLINTEGER        StringLength);

Function Arguments

Table 148. SQLSetConnectAttr Arguments

Data Type Argument Use Description
SQLHDBC ConnectionHandle input Connection handle.
SQLINTEGER Attribute input Attribute to set, listed in Attribute Values.
SQLPOINTER ValuePtr input Pointer to the value to be associated with Attribute. Depending on the value of Attribute, *ValuePtr will be a 32-bit unsigned integer value or point to a null-terminated character string. Note that if the Attribute argument is a driver-specific value, the value in *ValuePtr may be a signed integer.
SQLINTEGER StringLength input If Attribute is an ODBC-defined attribute and ValuePtr points to a character string or a binary buffer, this argument should be the length of *ValuePtr. If Attribute is an ODBC-defined attribute and ValuePtr is an integer, StringLength is ignored.
If Attribute is a DB2 CLI attribute, the application indicates the nature of the attribute by setting the StringLength argument. StringLength can have the following values:

If ValuePtr is a pointer to a character string, then StringLength is the length of the string or SQL_NTS.
If ValuePtr is a pointer to a binary buffer, then the application places the result of the SQL_LEN_BINARY_ATTR(length) macro in StringLength. This places a negative value in StringLength.
If ValuePtr is a pointer to a value other than a character string or a binary string, then StringLength should have the value SQL_IS_POINTER.
If ValuePtr contains a fixed-length value, then StringLength is either SQL_IS_INTEGER or SQL_IS_UINTEGER, as appropriate.

Data Type	Argument	Use	Description
SQLHDBC	ConnectionHandle	input	Connection handle.
SQLINTEGER	`Attribute`	input	Attribute to set, listed in Attribute Values.
SQLPOINTER	ValuePtr	input	Pointer to the value to be associated with `Attribute`. Depending on the value of `Attribute`, `ValuePtr` will be a 32-bit unsigned integer value or point to a null-terminated character string. Note that if the `Attribute` argument is a driver-specific value, the value in `ValuePtr` may be a signed integer.
SQLINTEGER	`StringLength`	input	If `Attribute` is an ODBC-defined attribute and `ValuePtr` points to a character string or a binary buffer, this argument should be the length of `*ValuePtr`. If `Attribute` is an ODBC-defined attribute and `ValuePtr` is an integer, `StringLength` is ignored. If `Attribute` is a DB2 CLI attribute, the application indicates the nature of the attribute by setting the `StringLength` argument. `StringLength` can have the following values: If `ValuePtr` is a pointer to a character string, then `StringLength` is the length of the string or SQL_NTS. If `ValuePtr` is a pointer to a binary buffer, then the application places the result of the SQL_LEN_BINARY_ATTR(length) macro in `StringLength`. This places a negative value in `StringLength`. If `ValuePtr` is a pointer to a value other than a character string or a binary string, then `StringLength` should have the value SQL_IS_POINTER. If `ValuePtr` contains a fixed-length value, then `StringLength` is either SQL_IS_INTEGER or SQL_IS_UINTEGER, as appropriate.

Usage

Setting Statement Attributes using SQLSetConnectAttr() no Longer Supported

The ability to set statement attributes using SQLSetConnectAttr() is no longer supported. To support applications written before version 5, some statement attributes can be set using SQLSetConnectAttr() in this release of DB2 CLI. All applications that rely on this behavior, however, should be updated to use SQLSetStmtAttr() instead. See Setting a Subset of Statement Attributes using SQLSetConnectAttr() for more information.

For version 2 applications that continue to set statement attributes using SQLSetConnectAttr(), if an error is returned when a statement attribute is set on one of multiple active statements, the statement attribute is established as the default for statements later allocated on the connection, but it is undefined whether statement attributes previously set on the same call to SQLSetConnectAttr() remain set after the function is aborted and the error is returned. This is one reason why SQLSetConnectAttr() should not be used to set statement attributes.

If SQLSetConnectAttr() is called to set a statement attribute that sets the header field of a descriptor, the descriptor field is set for the application descriptors currently associated with all statements on the connection. However, the attribute setting does not affect any descriptors that may be associated with the statements on that connection in the future.

Connection Attributes

The currently defined attributes and the version of DB2 CLI in which they were introduced are shown below; it is expected that more will be defined to take advantage of different data sources.

An application can call SQLSetConnectAttr() at any time between the time the connection is allocated or freed. All connection and statement attributes successfully set by the application for the connection persist until SQLFreeHandle() is called on the connection.

Some connection attributes can be set only before a connection has been made; others can be set only after a connection has been made, while some cannot be set once a statement is allocated. The following table indicates when each of the connection attributes can be set.

Table 149. When Connection Attributes can be Set

Attribute Before connection After connection After statements allocated
SQL_ATTR_ACCESS_MODE Yes Yes Yes ^a
SQL_ATTR_ASYNC_ENABLE Yes Yes No ^b
SQL_ATTR_AUTO_IPD (read only) No Yes Yes
SQL_ATTR_AUTOCOMMIT Yes Yes Yes ^c
SQL_ATTR_CLISCHEMA Yes Yes Yes
SQL_ATTR_CLOSE_BEHAVIOR No Yes Yes ^c
SQL_ATTR_CONN_CONTEXT Yes No No
SQL_ATTR_CONNECT_NODE Yes No No
SQL_ATTR_CONNECTTYPE Yes No No
SQL_ATTR_CURRENT_SCHEMA Yes Yes Yes
SQL_ATTR_DB2_SQLERRP (read only) No Yes Yes
SQL_ATTR_DB2ESTIMATE No Yes Yes
SQL_ATTR_DB2EXPLAIN No Yes Yes
SQL_ATTR_ENLIST_IN_DTC No Yes Yes
SQL_ATTR_INFO_ACCTSTR No Yes Yes
SQL_ATTR_INFO_APPLNAME No Yes Yes
SQL_ATTR_INFO_USERID No Yes Yes
SQL_ATTR_INFO_WRKSTNNAME No Yes Yes
SQL_ATTR_LOGIN_TIMEOUT Yes No No
SQL_ATTR_LONGDATA_COMPAT Yes Yes Yes
SQL_ATTR_MAXCONN Yes No No
SQL_ATTR_OPTIMIZESQLCOLUMNS Yes Yes Yes
SQL_ATTR_QUIET_MODE Yes Yes Yes
SQL_ATTR_SYNC_POINT Yes No No
SQL_ATTR_TRANSLATE_OPTION Yes Yes Yes
SQL_ATTR_TXN_ISOLATION No Yes ^c Yes ^a
SQL_ATTR_WCHARTYPE Yes Yes ^c Yes ^c

^a
Will only affect subsequently allocated statements.
^b
Attribute must be set before there is an active statement.
^c
Attribute can be set only if there are no open transactions on the connection.

Attribute	Before connection	After connection	After statements allocated
SQL_ATTR_ACCESS_MODE	Yes	Yes	Yes ^a
SQL_ATTR_ASYNC_ENABLE	Yes	Yes	No ^b
SQL_ATTR_AUTO_IPD (read only)	No	Yes	Yes
SQL_ATTR_AUTOCOMMIT	Yes	Yes	Yes ^c
SQL_ATTR_CLISCHEMA	Yes	Yes	Yes
SQL_ATTR_CLOSE_BEHAVIOR	No	Yes	Yes ^c
SQL_ATTR_CONN_CONTEXT	Yes	No	No
SQL_ATTR_CONNECT_NODE	Yes	No	No
SQL_ATTR_CONNECTTYPE	Yes	No	No
SQL_ATTR_CURRENT_SCHEMA	Yes	Yes	Yes
SQL_ATTR_DB2_SQLERRP (read only)	No	Yes	Yes
SQL_ATTR_DB2ESTIMATE	No	Yes	Yes
SQL_ATTR_DB2EXPLAIN	No	Yes	Yes
SQL_ATTR_ENLIST_IN_DTC	No	Yes	Yes
SQL_ATTR_INFO_ACCTSTR	No	Yes	Yes
SQL_ATTR_INFO_APPLNAME	No	Yes	Yes
SQL_ATTR_INFO_USERID	No	Yes	Yes
SQL_ATTR_INFO_WRKSTNNAME	No	Yes	Yes
SQL_ATTR_LOGIN_TIMEOUT	Yes	No	No
SQL_ATTR_LONGDATA_COMPAT	Yes	Yes	Yes
SQL_ATTR_MAXCONN	Yes	No	No
SQL_ATTR_OPTIMIZESQLCOLUMNS	Yes	Yes	Yes
SQL_ATTR_QUIET_MODE	Yes	Yes	Yes
SQL_ATTR_SYNC_POINT	Yes	No	No
SQL_ATTR_TRANSLATE_OPTION	Yes	Yes	Yes
SQL_ATTR_TXN_ISOLATION	No	Yes ^c	Yes ^a
SQL_ATTR_WCHARTYPE	Yes	Yes ^c	Yes ^c
^a Will only affect subsequently allocated statements. ^b Attribute must be set before there is an active statement. ^c Attribute can be set only if there are no open transactions on the connection.

Some connection attributes support substitution of a similar value if the data source does not support the value specified in *ValuePtr. In such cases, DB2 CLI returns SQL_SUCCESS_WITH_INFO and SQLSTATE 01S02 (Option value changed.). For example, if the application attempts to set SQL_ATTR_ASYNC_ENABLE to SQL_ASYNC_ENABLE_ON and the server does not support this then DB2 CLI substitutes the value SQL_ASYNC_ENABLE_OFF instead. To determine the substituted value, an application calls SQLGetConnectAttr().

The format of information set through *ValuePtr depends on the specified Attribute. SQLSetConnectAttr() will accept attribute information in one of two different formats: a null-terminated character string or a 32-bit integer value. The format of each is noted in the attribute's description. Character strings pointed to by the ValuePtr argument of SQLSetConnectAttr() have a length of StringLength bytes.

The StringLength argument is ignored if the length is defined by the attribute, as is the case for all attributes introduced before DB2 CLI Version 5.2.

Attribute Values

The following version 2 connection attributes (that were set using SQLSetConnectOption()) have been renamed for version 5:

Table 150. Renamed Connection Attributes

Version 2 name Version 5 and later name
SQL_ACCESS_MODE SQL_ATTR_ACCESS_MODE
SQL_AUTOCOMMIT SQL_ATTR_AUTOCOMMIT
SQL_CONNECTTYPE SQL_ATTR_CONNECTTYPE
SQL_CURRENT_SCHEMA SQL_ATTR_CURRENT_SCHEMA
SQL_DB2ESTIMATE SQL_ATTR_DB2ESTIMATE
SQL_DB2EXPLAIN SQL_ATTR_DB2EXPLAIN
SQL_LOGIN_TIMEOUT SQL_ATTR_LOGIN_TIMEOUT
SQL_LONGDATA_COMPAT SQL_ATTR_LONGDATA_COMPAT
SQL_MAXCONN SQL_ATTR_MAXCONN
SQL_QUIET_MODE SQL_ATTR_QUIET_MODE
SQL_SCHEMA SQL_ATTR_SCHEMA
SQL_SYNC_POINT SQL_ATTR_SYNC_POINT
SQL_TXN_ISOLATION SQL_ATTR_TXN_ISOLATION
SQL_WCHARTYPE SQL_ATTR_WCHARTYPE

Version 2 name	Version 5 and later name
SQL_ACCESS_MODE	SQL_ATTR_ACCESS_MODE
SQL_AUTOCOMMIT	SQL_ATTR_AUTOCOMMIT
SQL_CONNECTTYPE	SQL_ATTR_CONNECTTYPE
SQL_CURRENT_SCHEMA	SQL_ATTR_CURRENT_SCHEMA
SQL_DB2ESTIMATE	SQL_ATTR_DB2ESTIMATE
SQL_DB2EXPLAIN	SQL_ATTR_DB2EXPLAIN
SQL_LOGIN_TIMEOUT	SQL_ATTR_LOGIN_TIMEOUT
SQL_LONGDATA_COMPAT	SQL_ATTR_LONGDATA_COMPAT
SQL_MAXCONN	SQL_ATTR_MAXCONN
SQL_QUIET_MODE	SQL_ATTR_QUIET_MODE
SQL_SCHEMA	SQL_ATTR_SCHEMA
SQL_SYNC_POINT	SQL_ATTR_SYNC_POINT
SQL_TXN_ISOLATION	SQL_ATTR_TXN_ISOLATION
SQL_WCHARTYPE	SQL_ATTR_WCHARTYPE

Attribute

*ValuePtr Contents

SQL_ATTR_ACCESS_MODE (DB2 CLI v2)

A 32-bit integer value which can be either:

SQL_MODE_READ_ONLY: the application is indicating that it will not be performing any updates on data from this point on. Therefore, a less restrictive isolation level and locking can be used on transactions; that is uncommitted read (SQL_TXN_READ_UNCOMMITTED).
DB2 CLI does not ensure that requests to the database are read-only. If an update request is issued, DB2 CLI will process it using the transaction isolation level it has selected as a result of the SQL_MODE_READ_ONLY setting.
SQL_MODE_READ_WRITE: the application is indicating that it will be making updates on data from this point on. DB2 CLI will go back to using the default transaction isolation level for this connection.
SQL_MODE_READ_WRITE is the default.

There must not be any outstanding transactions on this connection.

SQL_ATTR_ASYNC_ENABLE (DB2 CLI v5)

A 32-bit integer value that specifies whether a function called with a statement on the specified connection is executed asynchronously:

SQL_ASYNC_ENABLE_OFF = Off (the default)
SQL_ASYNC_ENABLE_ON = On

Setting SQL_ASYNC_ENABLE_ON enables asynchronous execution for all future statement handles allocated on this connection. This also enables asynchronous execution for existing statement handles associated with this connection. An error is returned if asynchronous execution is turned on while there is an active statement on the connection.

This attribute can be set whether SQLGetInfo(), called with the InfoType SQL_ASYNC_MODE, returns SQL_AM_CONNECTION or SQL_AM_STATEMENT.

Once a function has been called asynchronously, only the original function, SQLAllocHandle(), SQLCancel(), SQLGetDiagField(), or SQLGetDiagRec() can be called on the statement or the connection associated with StatementHandle, until the original function returns a code other than SQL_STILL_EXECUTING. Any other function called on StatementHandle or the connection associated with StatementHandle returns SQL_ERROR with an SQLSTATE of HY010 (Function sequence error). Functions can be called on other statements.

In general, applications should execute functions asynchronously only on single-threaded operating systems. On multi-threaded operating systems, applications should execute functions on separate threads, rather than executing them asynchronously on the same thread. Applications that only operate on multi-threaded operating systems do not need to support asynchronous execution. For more information, see Writing Multi-Threaded Applications and Asynchronous Execution of CLI.

The following functions can be executed asynchronously:

 
    SQLColAttribute()        SQLGetTypeInfo()
    SQLColumnPrivileges()    SQLMoreResults()
    SQLColumns()             SQLNumParams()
    SQLCopyDesc()            SQLNumResultCols()
    SQLDescribeCol()         SQLParamData()
    SQLDescribeParam()       SQLPrepare()
    SQLExecDirect()          SQLPrimaryKeys()
    SQLExecute()             SQLProcedureColumns()
    SQLFetch()               SQLProcedures()
    SQLFetchScroll()         SQLPutData()
    SQLForeignKeys()         SQLSetPos()
    SQLGetData()             SQLSpecialColumns()
    SQLGetDescField() 1*     SQLStatistics()
    SQLGetDescRec() 1*       SQLTablePrivileges()
    SQLGetDiagField()        SQLTables()
    SQLGetDiagRec()
 
1* These functions can be called asynchronously only if the descriptor
   is an implementation descriptor, not an application descriptor.

SQL_ATTR_AUTO_IPD (DB2 CLI v5)

A read-only 32-bit integer value that specifies whether automatic population of the IPD after a call to SQLPrepare() is supported:

SQL_TRUE = Automatic population of the IPD after a call to SQLPrepare() is supported by the server.
SQL_FALSE = Automatic population of the IPD after a call to SQLPrepare() is not supported by the server. Servers that do not support prepared statements will not be able to populate the IPD automatically.

If SQL_TRUE is returned for the SQL_ATTR_AUTO_IPD connection attribute, the statement attribute SQL_ATTR_ENABLE_AUTO_IPD can be set to turn automatic population of the IPD on or off. If SQL_ATTR_AUTO_IPD is SQL_FALSE, SQL_ATTR_ENABLE_AUTO_IPD cannot be set to SQL_TRUE.

The default value of SQL_ATTR_ENABLE_AUTO_IPD is equal to the value of SQL_ATTR_AUTO_IPD.

This connection attribute can be returned by SQLGetConnectAttr(), but cannot be set by SQLSetConnectAttr().

SQL_ATTR_AUTOCOMMIT (DB2 CLI v2)

A 32-bit integer value that specifies whether to use auto-commit or manual commit mode:

SQL_AUTOCOMMIT_OFF: the application must manually, explicitly commit or rollback transactions with SQLTransact() calls.
SQL_AUTOCOMMIT_ON: DB2 CLI operates in auto-commit mode. Each statement is implicitly committed. Each statement, that is not a query, is committed immediately after it has been executed. Each query is committed immediately after the associated cursor is closed.
SQL_AUTOCOMMIT_ON is the default.
Note: If this is a coordinated distributed unit of work connection, then the default is SQL_AUTOCOMMIT_OFF

Since in many DB2 environments, the execution of the SQL statements and the commit may be flowed separately to the database server, autocommit can be expensive. It is recommended that the application developer take this into consideration when selecting the auto-commit mode.
Note: Changing from manual commit to auto-commit mode will commit any open transaction on the connection.

DB2 CLI Version 1 applications assume the default is manual commit mode. Refer to Incompatibilities.

SQL_ATTR_CLISCHEMA (DB2 CLI v6)

A null-terminated character string containing the name of the DB2 ODBC catalog view stored on the host DBMS to use.

The DB2 ODBC catalog is designed to improve the performance of schema calls for lists of tables in ODBC applications that connect to host DBMSs through DB2 Connect.

The DB2 ODBC catalog, created and maintained on the host DBMS, contains rows representing objects defined in the real DB2 catalog, but these rows include only the columns necessary to support ODBC operations. The tables in the DB2 ODBC catalog are pre-joined and specifically indexed to support fast catalog access for ODBC applications.

System administrators can create multiple DB2 ODBC catalog views, each containing only the rows that are needed by a particular user group. Each end user can then select the DB2 ODBC catalog view they wish to use (by setting this attribute).

While this attribute has some similar effects as the SYSSCHEMA keyword, SQL_ATTR_CLISCHEMA should be used instead (where applicable). SQL_ATTR_CLISCHEMA improves data access efficiency: The user-defined tables used with SYSSCHEMA were mirror images of the DB2 catalog tables, and the ODBC driver still had to join rows from multiple tables to produce the information required by the ODBC user. Using SQL_ATTR_CLISCHEMA also results in less contention on the catalog tables.

There is also a corresponding DB2 CLI/ODBC Driver configuration keyword; CLISCHEMA

SQL_ATTR_CLOSE_BEHAVIOR (DB2 CLI v6)

A 32-bit integer that specifies whether the DB2 server should attempt to release read locks acquired during a cursor's operation when the cursor is closed. It can be set to either:

SQL_CC_NO_RELEASE - read locks are not released. This is the default.
SQL_CC_RELEASE - read locks are released.

For cursors opened with isolation UR or CS, read locks are not held after a cursor moves off a row. For cursors opened with isolation RS or RR, SQL_ATTR_CLOSE_BEHAVIOR modifies some of those isolation levels, and an RR cursor may experience nonrepeatable reads or phantom reads.

If a cursor that is originally RR or RS is reopened after being closed with SQL_ATTR_CLOSE_BEHAVIOR then new read locks will be acquired.

For more information see SQLCloseCursor - Close Cursor and Discard Pending Results.

SQL_ATTR_CONN_CONTEXT (DB2 CLI v5)

Indicates which context the connection should use. An SQLPOINTER to either:

a valid context (allocated by the sqleBeginCtx() DB2 API) to set the context
a NULL pointer to reset the context

This attribute can only be used when the application is using the DB2 context APIs to manage multi-threaded applications. By default, DB2 CLI manages contexts by allocating one context per connection handle, and ensuring that any executing thread is attached to the correct context.

For more information about when an application may have to manage contexts, refer to Writing Multi-Threaded Applications.

For more information about contexts, refer to the sqleBeginCtx() API in the Administrative API Reference.

SQL_ATTR_CONNECT_NODE (DB2 CLI v6)

This attribute is used to specify the target logical node of a DB2 Extended Enterprise Edition database partition server that you want to connect to. This setting overrides the value of the environment variable DB2NODE. It can be set to:

an integer between 0 and 999
SQL_CONN_CATALOG_NODE

If this variable is not set, the target logical node defaults to the logical node which is defined with port 0 on the machine.

There is also a corresponding DB2 CLI/ODBC Driver configuration keyword; CONNECTTYPE.

SQL_ATTR_CONNECTION_DEAD (DB2 CLI v6)

A READ ONLY 32-bit integer value that indicates whether or not the connection is still active. DB2 CLI will return one of the following values:

SQL_CD_FALSE - the conneciton is still active.
SQL_CD_TRUE - an error has already happend and caused the connection to the server to be disconnected. The user should still perform a disconnect and to cleanup the DB2CLI resources.

This attribute is used mainly by the Microsoft ODBC Driver Manager 3.5x before pooling the connection.

SQL_ATTR_CONNECTION_TIMEOUT (DB2 CLI v5)

This connection attribute is defined by ODBC, but is not supported by DB2 CLI. Any attempt to set or get this attribute will result in an SQLSTATE of HYC00 (Driver not capable).

A 32-bit integer value corresponding to the number of seconds to wait for any request on the connection to complete before returning to the application.

DB2 CLI always behaves as if ValuePtr was set to 0 (the default); there is no time out.

SQL_ATTR_CONNECTTYPE (DB2 CLI v2)

A 32-bit integer value that specifies whether this application is to operate in a coordinated or uncoordinated distributed environment. If the processing needs to be coordinated, then this option must be considered in conjunction with the SQL_ATTR_SYNC_POINT connection option. The possible values are:

SQL_CONCURRENT_TRANS: The application can have concurrent multiple connections to any one database or to multiple databases. Each connection has its own commit scope. No effort is made to enforce coordination of transaction. If an application issues a commit using the environment handle on SQLTransact() and not all of the connections commit successfully, the application is responsible for recovery.
The current setting of the SQL_ATTR_SYNC_POINT option is ignored.
This is the default.
SQL_COORDINATED_TRANS: The application wishes to have commit and rollbacks coordinated among multiple database connections. This option setting corresponds to the specification of the Type 2 CONNECT in embedded SQL and must be considered in conjunction with the SQL_ATTR_SYNC_POINT connection option. In contrast to the SQL_CONCURRENT_TRANS setting described above, the application is permitted only one open connection per database.
Note: This connection type results in the default for SQL_ATTR_AUTOCOMMIT connection option to be SQL_AUTOCOMMIT_OFF.

This option must be set before making a connect request; otherwise, the SQLSetConnectOption() call will be rejected.

All the connections within an application must have the same SQL_ATTR_CONNECTTYPE and SQL_ATTR_SYNC_POINT values. The first connection determines the acceptable attributes for the subsequent connections. We recommend that the application set the SQL_ATTR_CONNECTTYPE attribute at the environment level rather than on a per connection basis. ODBC applications written to take advantage of coordinated DB2 transactions must set these attributes at the connection level for each connection as SQLSetEnvAttr() is not supported in ODBC.

The default connect type can also be set using the CONNECTTYPE DB2 CLI/ODBC configuration keyword. See Configuring db2cli.ini for more information.
Note: This is an IBM defined extension.

SQL_ATTR_CURRENT_CATALOG (DB2 CLI v5)

This connection attribute is defined by ODBC, but is not supported by DB2 CLI. Any attempt to set or get this attribute will result in an SQLSTATE of HYC00 (Driver not capable).

A null-terminated character string containing the name of the catalog to be used by the data source.

SQL_ATTR_CURRENT_SCHEMA (DB2 CLI v2)

A null-terminated character string containing the name of the schema to be used by DB2 CLI for the SQLColumns() call if the szSchemaName pointer is set to null.

To reset this option, specify this option with a zero length or a null pointer for the ValuePtr argument.

This option is useful when the application developer has coded a generic call to SQLColumns() that does not restrict the result set by schema name, but needs to constrain the result set at isolated places in the code.

This option can be set at any time and will be effective on the next SQLColumns() call where the szSchemaName pointer is null.
Note: This is an IBM defined extension.

SQL_ATTR_DB2_SQLERRP (DB2 CLI v6)

A read-only, null-terminated string containing the sqlerrp field of the sqlca.

Begins with a three-letter identifier indicating the product, followed by five digits indicating the version, release, and modification level of the product. For example, SQL05000 means DB2 Universal Database versions for Version 5 Release 0 Modification level 0.

If SQLCODE indicates an error condition, then this field identifies the module that returned the error.

This field is also used when a successful connection is completed.

See the SQL Reference for more information on the sqlca and this particular field.

SQL_ATTR_DB2ESTIMATE (DB2 CLI v2)

A 32-bit integer that specified whether DB2 CLI will display a dialog window to report estimates returned by the optimizer at the end of SQL query preparation.

0 : Estimates are not returned.
This is the default.
very large positive integer: The threshold above which DB2 CLI will pop up a window to report estimates. This positive integer value is compared against the SQLERRD(4) field in the SQLCA associated with the PREPARE. If the DB2ESTIMATE value is greater, the estimates window will appear.
The graphical window will display optimizer estimates, along with push buttons to allow the user to choose whether they wish to continue with subsequent execution of this query or to cancel it.
The recommended value for this option is 60000.

This option is used in conjunction with SQL_ATTR_QUIET_MODE and is applicable only to applications with graphical user interfaces. The application can implement this feature directly without using this option by calling SQLGetSQLCA() after an SQLPrepare() for a query and then displaying the appropriate information, thus allowing a more integrated overall interface.

The new SQL_ATTR_DB2ESTIMATE setting is effective on the next statement preparation for this connection.
Note: This is an IBM defined extension.

SQL_ATTR_DB2EXPLAIN (DB2 CLI v2)

A 32-bit integer that specifies whether Explain snapshot and/or Explain mode information should be generated by the server:

SQL_DB2EXPLAIN_OFF: Both the Explain Snapshot and the Explain table option facilities are disabled (a SET CURRENT EXPLAIN SNAPSHOT=NO and a SET CURRENT EXPLAIN MODE=NO are sent to the server).
SQL_DB2EXPLAIN_SNAPSHOT_ON: The Explain Snapshot facility is enabled, and the Explain table option facility is disabled (a SET CURRENT EXPLAIN SNAPSHOT=YES and a SET CURRENT EXPLAIN MODE=NO are sent to the server).
SQL_DB2EXPLAIN_MODE_ON: The Explain Snapshot facility is disabled, and the Explain table option facility is enabled (a SET CURRENT EXPLAIN SNAPSHOT=NO and a SET CURRENT EXPLAIN MODE=YES are sent to the server).
SQL_DB2EXPLAIN_SNAPSHOT_MODE_ON: Both the Explain Snapshot and the Explain table option facilities are enabled (a SET CURRENT EXPLAIN SNAPSHOT=YES and a SET CURRENT EXPLAIN MODE=YES are sent to the server).

Before the explain information can be generated, the explain tables must be created. See the SQL Reference for additional information.

This statement is not under transaction control and is not affected by a ROLLBACK. The new SQL_ATTR_DB2EXPLAIN setting is effective on the next statement preparation for this connection.

The current authorization ID must have INSERT privilege for the Explain tables.

This value can also be set using the DB2EXPLAIN DB2 CLI/ODBC configuration keyword. See Configuring db2cli.ini for more information.
Note: This is an IBM defined extension.

SQL_ATTR_ENLIST_IN_DTC (DB2 CLI v5.2)

An SQLPOINTER which can be either:

non-null transaction pointer:
The application is asking the DB2 CLI/ODBC driver to change the state of the connection from non-distributed transaction state to distributed state. The connection will be enlisted with the Distributed Transaction Coordinator (DTC).
null:
The application is asking the DB2 CLI/ODBC driver to change the state of the connection from distributed transaction state to a non-distributed transaction state.

This attribute is only used in a Microsoft Transaction Server (MTS) environment to enlist or un-enlist a connection with MTS.

Each time this attribute is used with a non-null transaction pointer, the previous transaction is assumed to be ended and a new transaction is initiated. The application must call the ITransaction member function Endtransaction before calling this API with a non-null pointer. Otherwise the previous transaction will be aborted. The application can enlist mutiple connections with the same transaction pointer.
Note: This connection attribute is specified by MTS automatically for each transaction and is not coded by the user application.
It is imperative for CLI/ODBC applications that there will be no concurrent SQL statements executing on 2 different connections into the same database that are enlisted in the same transaction.

SQL_ATTR_INFO_ACCTSTR (DB2 CLI v6)

A null-terminated character string used to identify the client accounting string sent to the host database server when using DB2 Connect. Please note:

When the value is being set, some servers may not handle the entire length provided and may truncate the value.
DB2 for OS/390 servers support up to a length of 200 characters.
To ensure that the data is converted correctly when transmitted to a DRDA server, use only the characters A to Z, 0 to 9, and the underscore(_) or period (.).

Note:

This is an IBM defined extension.

SQL_ATTR_INFO_APPLNAME (DB2 CLI v6)

A null-terminated character string used to identify the client application name sent to the host database server when using DB2 Connect. Please note:

When the value is being set, some servers may not handle the entire length provided and may truncate the value.
DB2 for OS/390 servers support up to a length of 32 characters.
To ensure that the data is converted correctly when transmitted to a DRDA server, use only the characters A to Z, 0 to 9, and the underscore(_) or period (.).

Note:

This is an IBM defined extension.

SQL_ATTR_INFO_USERID (DB2 CLI v6)

A null-terminated character string used to identify the client user ID sent to the host database server when using DB2 Connect. Please note:

When the value is being set, some servers may not handle the entire length provided and may truncate the value.
DB2 for OS/390 servers support up to a length of 16 characters.
This user-id is not to be confused with the authentication user-id. This user-id is for identification purposes only and is not used for any authorization.
To ensure that the data is converted correctly when transmitted to a DRDA server, use only the characters A to Z, 0 to 9, and the underscore(_) or period (.).

Note:

This is an IBM defined extension.

SQL_ATTR_INFO_WRKSTNNAME (DB2 CLI v6)

A null-terminated character string used to identify the client workstation name sent to the host database server when using DB2 Connect. Please note:

When the value is being set, some servers may not handle the entire length provided and may truncate the value.
DB2 for OS/390 servers support up to a length of 18 characters.
To ensure that the data is converted correctly when transmitted to a DRDA server, use only the characters A to Z, 0 to 9, and the underscore(_) or period (.).

Note:

This is an IBM defined extension.

SQL_ATTR_LOGIN_TIMEOUT (DB2 CLI v2)

This connection attribute is defined by ODBC, but is not supported by DB2 CLI. Any attempt to set or get this attribute will result in an SQLSTATE of HYC00 (Driver not capable).

A 32-bit integer value corresponding to the number of seconds to wait for a login request to complete before returning to the application. The only permitted value for the ValuePtr argument is 0, which means the connection attempt will wait until either a connection is established or the underlying communication layer times out.

SQL_ATTR_LONGDATA_COMPAT (DB2 CLI v2)

A 32-bit integer value indicating whether the character, double byte character and binary large object data types should be reported respectively as SQL_LONGVARCHAR, SQL_LONGVARGRAPHIC or SQL_LONGBINARY, enabling existing applications to access large object data types seamlessly. The option values are:

SQL_LD_COMPAT_NO: The large object data types are reported as themselves (SQL_BLOB, SQL_CLOB, SQL_DBCLOB). This is the default.
SQL_LD_COMPAT_YES: The large object data types (BLOB, CLOB and DBCLOB) are mapped to SQL_LONGVARBINARY, SQL_LONGVARCHAR and SQL_LONVARGRAPHIC; SQLGetTypeInfo() returns one entry each for SQL_LONGVARBINARY SQL_LONGVARCHAR.

Note: This is an IBM defined extension.

SQL_ATTR_MAXCONN (DB2 CLI v2)

A 32-bit integer value corresponding to the maximum concurrent connections that an application may desire to set up. The default value is 0, which means no maximum - the application is allowed to set up as many connections as the system resources permit. The integer value must be 0 or a positive number.

This can be used as a governor for the maximum number of connections on a per application basis.

On OS/2, Windows 95, and Windows NT, if the NetBIOS protocol is in use, this value corresponds to the number of connections (NetBIOS sessions) that will be concurrently set up by the application. The range of values for OS/2 NetBIOS is 1 to 254. Specifying 0 (the default) will result in 5 reserved connections. Reserved NetBIOS sessions cannot be used by other applications. The number of connections specified by this parameter will be applied to any adaptor that the DB2 NetBIOS protocol uses to connect to the remote server (adapter number is specified in the node directory for a NetBIOS node).

The value that is in effect when the first connection is established is the value that will be used. Once the first connection has been established, attempts to change this value will be rejected. We recommended that the application set SQL_ATTR_MAXCONN at the environment level rather then on a connection basis. ODBC applications must set this attribute at the connection level since SQLSetEnvAttr() is not supported in ODBC.

The maximum concurrent connections can also be set using the MAXCONN DB2 CLI/ODBC configuration keyword. See Configuring db2cli.ini for more information.
Note: This is an IBM defined extension.

SQL_ATTR_METADATA_ID (DB2 CLI v5)

This connection attribute is defined by ODBC, but is not supported by DB2 CLI. Any attempt to set or get this attribute will result in an SQLSTATE of HYC00 (Driver not capable).

An SQLUINTEGER value that determines how the string arguments of catalog functions are treated.

SQL_ATTR_ODBC_CURSORS (DB2 CLI v5)

This connection attribute is defined by ODBC, but is not supported by DB2 CLI. Any attempt to set or get this attribute will result in an SQLSTATE of HYC00 (Driver not capable).

A 32-bit option specifying how the Driver Manager uses the ODBC cursor library.

SQL_ATTR_PACKET_SIZE (DB2 CLI v5)

This connection attribute is defined by ODBC, but is not supported by DB2 CLI. Any attempt to set or get this attribute will result in an SQLSTATE of HYC00 (Driver not capable).

A 32-bit integer value specifying the network packet size in bytes.

SQL_ATTR_QUIET_MODE (DB2 CLI v2)

A 32-bit platform specific window handle.

If the application has never made a call to SQLSetConnectOption() with this option, then DB2 CLI would return a null parent window handle on SQLGetConnectOption() for this option and use a null parent window handle to display dialogue boxes. For example, if the end user has asked for (via an entry in the DB2 CLI initialization file) optimizer information to be displayed, DB2 CLI would display the dialogue box containing this information using a null window handle. (For some platforms, this means the dialogue box would be centered in the middle of the screen.)

If ValuePtr is a null pointer, then DB2 CLI does not display any dialogue boxes. In the above example where the end user has asked for the optimizer estimates to be displayed, DB2 CLI would not display these estimates because the application explicitly wants to suppress all such dialogue boxes.

If ValuePtr is not a null pointer, then it should be the parent window handle of the application. DB2 CLI uses this handle to display dialogue boxes. (For some platforms, this means the dialogue box would be centered with respect to the active window of the application.)
Note: This connection option cannot be used to suppress the SQLDriverConnect() dialogue box (which can be suppressed by setting the fDriverCompletion argument to SQL_DRIVER_NOPROMPT).

SQL_ATTR_SYNC_POINT (DB2 CLI v2)

A 32-bit integer value that allows the application to choose between one-phase coordinated transactions and two-phase coordinated transactions. The possible values are:

SQL_ONEPHASE: One-phase commit is used to commit the work done by each database in a multiple database transaction. To ensure data integrity, each transaction must not have more than one database updated. The first database that has updates performed in a transaction becomes the only updater in that transaction, all other databases accessed are treated as read-only. Any update attempts to these read-only database within this transaction are rejected. This is the default.
SQL_TWOPHASE: Two-phase commit is used to commit the work done by each database in a multiple database transaction. This requires the use of a Transaction Manager to coordinate two phase commits amongst the databases that support this protocol. Multiple readers and multiple updaters are allowed within a transaction.

Refer to the SQL Reference for more information on distributed unit of work (transactions).

All the connections within an application must have the same SQL_ATTR_CONNECTTYPE and SQL_SYNCPOINT values. The first connection determines the acceptable attributes for the subsequent connections. We recommend that the application set the SQL_ATTR_CONNECTTYPE attribute at the environment level rather than on a per connection basis. ODBC applications written to take advantage of coordinated DB2 transactions must set these attributes at the connection level as SQLSetEnvAttr() is not supported in ODBC.

The type of coordinated transaction can also be set using the SYNCPOINT DB2 CLI/ODBC configuration keyword. See Configuring db2cli.ini for more information.
Note: This is an IBM extension. In embedded SQL, there is an additional sync point setting called SYNCPOINT NONE. This is more restrictive than the SQL_CONCURRENT_TRANS setting of the SQL_ATTR_CONNECTTYPE option because SYNCPOINT NONE does not allow for multiple connections to the same database. As a result, it is not necessary for DB2 CLI to support SYNCPOINT NONE.

SQL_ATTR_TRACE (DB2 CLI v5)

This connection attribute is defined by ODBC, but is not supported by DB2 CLI. Any attempt to set or get this attribute will result in an SQLSTATE of HYC00 (Driver not capable).

A 32-bit integer value telling DB2 CLI whether to perform tracing.

Instead of using the attribute, the DB2 CLI trace facility can be set using the TRACE DB2 CLI/ODBC configuration keyword. See Configuring db2cli.ini for more information.

SQL_ATTR_TRACEFILE (DB2 CLI v5)

This connection attribute is defined by ODBC, but is not supported by DB2 CLI. Any attempt to set or get this attribute will result in an SQLSTATE of HYC00 (Driver not capable).

A null-terminated character string containing the name of the trace file.

Instead of using this attribute, the DB2 CLI trace file name is set using the TRACEFILENAME DB2 CLI/ODBC configuration keyword. See Configuring db2cli.ini for more information.

SQL_ATTR_TRANSLATE_LIB (DB2 CLI v5)

This connection attribute is defined by ODBC, but is only supported by DB2 CLI on Windows 3.1. Any attempt to set or get this attribute on other platforms will result in an SQLSTATE of HYC00 (Driver not capable).

Indicate the directory where the DB2 Client Application Enabler for Windows or the Software Developers Kit for Windows has been installed. DB2TRANS.DLL is the DLL that contains codepage mapping tables.

This option is used on 16-bit versions of Windows when connecting to DB2 for OS/2 Version 1, or when using a version of DDCS for OS/2 prior to Version 2.3 in conjunction with the TRANSLATEOPTION, to provide proper mapping of NLS SBCS characters (such as the umlaut character in German) to the corresponding characters in the Windows codepage 1004.
Note: This option is useful when a Windows application connects to a downlevel server that does not support unequal codepage conversion (such as DB2 Version 1).

SQL_ATTR_TRANSLATE_OPTION (DB2 CLI v5)

Defines the codepage number of the database in DB2 Version 1 (it can be obtained by querying the database configuration parameters). Specifying TRANSLATEDLL and TRANSLATEOPTION enables the translation of characters from codepage number database codepage number to the Windows 1004 codepage.

There are two supported values for database codepage number: 437 and 850. If you specify any other values, a warning is returned on the connect request indicating that translation is not possible.
Note: This option is useful when a Windows application connects to a downlevel server that does not support unequal codepage conversion (such as DB2 Version 1).

SQL_ATTR_TXN_ISOLATION (DB2 CLI v2)

A 32-bit bitmask that sets the transaction isolation level for the current connection referenced by ConnectionHandle. The valid values for ValuePtr can be determined at runtime by calling SQLGetInfo() with fInfoType set to SQL_TXN_ISOLATION_OPTIONS. The following values are accepted by DB2 CLI, but each server may only support a subset of these isolation levels:

SQL_TXN_READ_UNCOMMITTED - Dirty reads, reads that cannot be repeated, and phantoms are possible.
SQL_TXN_READ_COMMITTED - Dirty reads are not possible. Reads that cannot be repeated, and phantoms are possible.
This is the default.
SQL_TXN_REPEATABLE_READ - Dirty reads and reads that cannot be repeated are not possible. Phantoms are possible.
SQL_TXN_SERIALIZABLE - Transactions can be serialized. Dirty reads, non-repeatable reads, and phantoms are not possible.
SQL_TXN_NOCOMMIT - Any changes are effectively committed at the end of a successful operation; no explicit commit or rollback is allowed. This is analogous to autocommit. This is not an SQL92 isolation level, but an IBM defined extension, supported only by DB2 Universal Database for AS/400.

In IBM terminology,

SQL_TXN_READ_UNCOMMITTED is Uncommitted Read;
SQL_TXN_READ_COMMITTED is Cursor Stability;
SQL_TXN_REPEATABLE_READ is Read Stability;
SQL_TXN_SERIALIZABLE is Repeatable Read.

For a detailed explanation of Isolation Levels, refer to the SQL Reference.

This option cannot be specified while there is an open cursor on any hstmt, or an outstanding transaction for this connection; otherwise, SQL_ERROR is returned on the function call (SQLSTATE S1011).

This attribute (or corresponding keyword) is only applicable if the default isolation level is used. If the application has specifically set the isolation level then this attribute will have no effect.
Note: There is an IBM extension that permits the setting of transaction isolation levels on a per statement handle basis. See the SQL_STMTTXN_ISOLATION option in the function description for SQLSetStmtOption().

SQL_ATTR_WCHARTYPE (DB2 CLI v2)

A 32-bit integer that specifies, in a double-byte environment, which wchar_t (SQLDBCHAR) character format you want to use in your application. This option provides you the flexibility to choose between having your wchar_t data in multi-byte format or in wide-character format. There two possible values for this option:

SQL_WCHARTYPE_CONVERT: character codes are converted between the graphic SQL data in the database and the application application variable. This allows your application to fully exploit the ANSI C mechanisms for dealing with wide character strings (L-literals, 'wc' string functions, etc.) without having to explicitly convert the data to multi-byte format before communicating with the database. The disadvantage is that the implicit conversions may have an impact on the runtime performance of your application, and may increase memory requirements. If you want WCHARTYPE CONVERT behavior then define the C preprocessor macro SQL_WCHART_CONVERT at compile time. This ensures that certain definitions in the DB2 header files use the data type wchar_t instead of sqldbchar.
SQL_WCHARTYPE_NOCONVERT: no implicit character code conversion occurs between the application and the database. Data in the application variable is sent to and received from the database as unaltered DBCS characters. This allows the application to have improved performance, but the disadvantage is that the application must either refrain from using wide-character data in wchar_t (SQLDBCHAR) application variables, or it must explicitly call the wcstombs() and mbstowcs() ANSI C functions to convert the data to and from multi-byte format when exchanging data with the database.
This is the default.

For additional information on the use of multi-byte application variables, refer to the Application Development Guide
Note: This is an IBM defined extension.

Return Codes

SQL_SUCCESS
SQL_SUCCESS_WITH_INFO
SQL_ERROR
SQL_INVALID_HANDLE

Diagnostics

DB2 CLI can return SQL_SUCCESS_WITH_INFO to provide information about the result of setting an option.

When Attribute is a statement attribute, SQLSetConnectAttr() can return any SQLSTATEs returned by SQLSetStmtAttr().

Table 151. SQLSetConnectAttr SQLSTATEs

SQLSTATE Description Explanation
01000 General error. Informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
01S02 Option value changed. DB2 CLI did not support the value specified in *ValuePtr and substituted a similar value. (Function returns SQL_SUCCESS_WITH_INFO.)
08002 Connection in use. The argument Attribute was SQL_ATTR_ODBC_CURSORS and DB2 CLI was already connected to the data source.
08003 Connection is closed. An Attribute value was specified that required an open connection, but the ConnectionHandle was not in a connected state.
08S01 Communication link failure. The communication link between DB2 CLI and the data source to which it was connected failed before the function completed processing.
24000 Invalid cursor state. The argument Attribute was SQL_ATTR_CURRENT_QUALIFIER and a result set was pending.
HY000 General error. An error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by SQLGetDiagRec() in the *MessageText buffer describes the error and its cause.
HY001 Memory allocation failure. DB2 CLI was unable to allocate memory required to support execution or completion of the function.
HY009 Invalid argument value. A null pointer was passed for ValuePtr and the value in *ValuePtr was a string value.
HY010 Function sequence error. An asynchronously executing function was called for a StatementHandle associated with the ConnectionHandle and was still executing when SQLSetConnectAttr() was called.
SQLExecute() or SQLExecDirect()was called for a StatementHandle associated with the ConnectionHandle and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns.
SQLBrowseConnect() was called for the ConnectionHandle and returned SQL_NEED_DATA. This function was called before SQLBrowseConnect() returned SQL_SUCCESS_WITH_INFO orSQL_SUCCESS.
HY011 Operation invalid at this time. The argument Attribute was SQL_ATTR_TXN_ISOLATION and a transaction was open.
HY024 Invalid attribute value. Given the specified Attribute value, an invalid value was specified in *ValuePtr. (DB2 CLI returns this SQLSTATE only for connection and statement attributes that accept a discrete set of values, such as SQL_ATTR_ACCESS_MODE or SQL_ATTR_ASYNC_ENABLE. For all other connection and statement attributes, DB2 CLI must verify the value specified in ValuePtr.)
The Attribute argument was SQL_ATTR_TRACEFILE or SQL_ATTR_TRANSLATE_LIB, and *ValuePtr was an empty string.
HY090 Invalid string or buffer length. The StringLength argument was less than 0, but was not SQL_NTS.
HY092 Option type out of range. The value specified for the argument Attribute was not valid for this version of DB2 CLI.
HYC00 Driver not capable. The value specified for the argument Attribute was a valid connection or statement attribute for the version of the DB2 CLI driver, but was not supported by the data source.

SQLSTATE	Description	Explanation
01000	General error.	Informational message. (Function returns SQL_SUCCESS_WITH_INFO.)
01S02	Option value changed.	DB2 CLI did not support the value specified in *`ValuePtr` and substituted a similar value. (Function returns SQL_SUCCESS_WITH_INFO.)
08002	Connection in use.	The argument `Attribute` was SQL_ATTR_ODBC_CURSORS and DB2 CLI was already connected to the data source.
08003	Connection is closed.	An `Attribute` value was specified that required an open connection, but the `ConnectionHandle` was not in a connected state.
08S01	Communication link failure.	The communication link between DB2 CLI and the data source to which it was connected failed before the function completed processing.
24000	Invalid cursor state.	The argument `Attribute` was SQL_ATTR_CURRENT_QUALIFIER and a result set was pending.
HY000	General error.	An error occurred for which there was no specific SQLSTATE and for which no implementation-specific SQLSTATE was defined. The error message returned by `SQLGetDiagRec()` in the *MessageText buffer describes the error and its cause.
HY001	Memory allocation failure.	DB2 CLI was unable to allocate memory required to support execution or completion of the function.
HY009	Invalid argument value.	A null pointer was passed for `ValuePtr` and the value in *`ValuePtr` was a string value.
HY010	Function sequence error.	An asynchronously executing function was called for a `StatementHandle` associated with the `ConnectionHandle` and was still executing when `SQLSetConnectAttr()` was called. `SQLExecute()` or `SQLExecDirect()`was called for a `StatementHandle` associated with the `ConnectionHandle` and returned SQL_NEED_DATA. This function was called before data was sent for all data-at-execution parameters or columns. `SQLBrowseConnect()` was called for the `ConnectionHandle` and returned SQL_NEED_DATA. This function was called before `SQLBrowseConnect()` returned SQL_SUCCESS_WITH_INFO orSQL_SUCCESS.
HY011	Operation invalid at this time.	The argument `Attribute` was SQL_ATTR_TXN_ISOLATION and a transaction was open.
HY024	Invalid attribute value.	Given the specified `Attribute` value, an invalid value was specified in `ValuePtr`. (DB2 CLI returns this SQLSTATE only for connection and statement attributes that accept a discrete set of values, such as SQL_ATTR_ACCESS_MODE or SQL_ATTR_ASYNC_ENABLE. For all other connection and statement attributes, DB2 CLI must verify the value specified in `ValuePtr`.) The `Attribute` argument was SQL_ATTR_TRACEFILE or SQL_ATTR_TRANSLATE_LIB, and `ValuePtr` was an empty string.
HY090	Invalid string or buffer length.	The `StringLength` argument was less than 0, but was not SQL_NTS.
HY092	Option type out of range.	The value specified for the argument `Attribute` was not valid for this version of DB2 CLI.
HYC00	Driver not capable.	The value specified for the argument `Attribute` was a valid connection or statement attribute for the version of the DB2 CLI driver, but was not supported by the data source.

Restrictions

None.

Example

See the CLI sample samputil.c .

References

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

[ DB2 List of Books | Search the DB2 Books ]