Step 3: Accessing Data Directly

Rogue Wave DB Link Tutorial > Rogue Wave DB Link Optimization Techniques > Step 3: Accessing Data Directly

This step shows how to use external binding, as well as the advantage of using it. The external binding feature (as opposed to internal binding) is first presented.

Binding is the process of sending and receiving RDBMS data directly to and from the application memory.

In previous steps, the Rogue Wave DB Link default mode was used. This mode is called internal binding. With internal binding, Rogue Wave DB Link automatically allocates the memory where data is stored. Then, the data must be copied from the application memory to the memory allocated by Rogue Wave DB Link. For example, in Step 1, the IldRequest::setParamValue method is used to copy the value needed to the buffer allocated by Rogue Wave DB Link.

This is the easiest method since the application does not need to do an explicit binding— Rogue Wave DB Link does it by itself. However, this method is less efficient since the value has to be copied from the application memory area to the area allocated by Rogue Wave DB Link.

With external binding, the application allocates the memory and tells Rogue Wave DB Link to use this area directly. This is done using one of the binding methods, bindCol and bindParam. The bindCol method is used when retrieving column data from the RDBMS. The bindParam method is used to bind application memory to the array of value arguments for a query with parameters.

To see how this works from the input side (writing data to the RDBMS), the memory to be used is first allocated. An array of parameters is used, as described in the previous step, to run only one execute call. This is done as follows:

static const IldUShort nbParam = 5 ;

// strBuf will be used to store an array of 5 string values.

char strBuf[nbParam][strLen + 1] ;

IldInt intBuf[nbParam] ;

short strNulls[nbParam], intNulls[nbParam] ;

This declares an array of five strBuf strings where string parameter values are stored.

Then, the intBuf array records the integer parameter values.

The strBuf array is used with strNulls, and the intBuf array is used with intNulls. These arrays record the NULL indicators. They are initialized with zeros to specify that the parameters are not NULL.

A null indicator is required to specify that the value is NULL. In the context of an RDBMS, a null value means that there is no value at all. For instance, for an integer column, a null value is NULL, not zero.


Note: The null indicators are not required when you do not have to handle a null value.

Then, the parameter array size is set as described in the previous step, and the query is parsed.

The intBuf and strBuf buffers are given as arguments to the IldRequest::bindParam method. The use of external binding requires nothing more.

if (!request->bindParam((IldUShort)0,

IldIntegerType,

sizeof(IldInt),

intBuf,

intNulls)) {

IldDisplayError("Bind first parameter failed : ", request) ;

Ending(dbms) ;

exit(1) ;

}

if (!request->bindParam((IldUShort)1,

IldStringType,

strLen + 1,

strBuf,

strNulls)) {

IldDisplayError("Bind second parameter failed : ", request) ;

Ending(dbms) ;

exit(1) ;

}

Now you work directly with the buffers. They are used to send data to the RDBMS.

IldUShort i, j ;

IldInt nbRows ;

for (i = 0 ; i < nbParam ; i++) {

intBuf[i] = i ;

// Build a new string value for this set of parameters.

for (j = 0 ; j < strLen ; ++j)

strBuf[i][j] = 'a' + i ;

}

if (!request->execute(&nbRows, nbParam)) {

IldDisplayError("Insertion failed : ", request) ;

Ending(dbms) ;

exit(1) ;

}

else cout << "\t" << nbRows << " row inserted." << endl ;

Conclusion

This step demonstrates how to bind Rogue Wave DB Link directly to application memory. This is an efficient way of exchanging data with the RDBMS.

See source code.

Version 5.8