These release notes contain a summary of new features and enhancements, late-breaking product issues, migration guides, and bug fixes. This document covers changes to the product since the SourcePro 2018 release.
For change logs or other information on previous releases, please contact Technical Support.
Rogue Wave products may contain undocumented interfaces. These interfaces are not supported for general use and may be changed or removed from release to release.
The version of this document in the product distribution is a snapshot at the time the product distribution was created. Additional information may be added after that time because of issues found during distribution testing or after the product is released. To be sure you have the most up-to-date information, see the version of this document on the Rogue Wave web site: https://docs.roguewave.com/en/sourcepro/current/.
Support for Intel C++ is deprecated and may be removed in a future release. For questions about the future of Intel C++ support in SourcePro, please contact technical support.
RW_END_STREAM_CONTENTS has been split into two macros, RW_END_STREAM_CONTENTS and RW_END_EXTERNAL_STREAM_CONTENTS. This provides symmetry with the existing RW_BEGIN_STREAM_CONTENTS and RW_BEGIN_EXTERNAL_STREAM_CONTENTS, and allows these macros to diverge in the future. Users are encouraged to update their code to close RW_BEGIN_EXTERNAL_STREAM_CONTENTS blocks with RW_END_EXTERNAL_STREAM_CONTENTS instead of RW_END_STREAM_CONTENTS. (SP-28027)Improved performance when inserting RWCString, RWDBBlob, RWDate, RWDateTime, and RWTimeTuple values. (SP-27347, SP-27351)
Improved performance when fetching double values. (SP-27351)
Improved RWDBBulkInserter performance. (SP-28017)
Fixed a performance regression when inserting values. (SP-27357)
Fixed a performance regression when executing SQL that does not contain bound parameters. (SP-27351)
Fixed a performance regression when inserting/fetching date/time values. (SP-27347)
Changed the default binding type for binary collated string columns from RWDBBlob to RWCString. (SP-27969)
Updated MySQL connections to derive their character set from the operating system locale. (SP-27966)
Fixed error handling when retrieving affected row count after a query. (SP-27962)
Fixed the way RWDBConnection::executeSql() handles multiple result sets from queries when executing a stored procedure. (SP-27967)
Updated the MySQL client library used for linking on Unix to libmysqlclient (SP-28013)
Fixed error handling related to calls to mysql_stmt_store_result. (SP-27938)
Fixed cleanup of previous result sets before statement execution. (SP-28002)
Implemented the tracing of RWDBStoredProc::drop() so that SQL is output to the tracer when a stored procedure is dropped. (SP-27400)
Fixed RWDBTable and RWDBStoredProc to search schemas listed in search_path for unqualified identifiers when querying for object information from the server. (SP-27231)
Fixed RWDBStoredProc to utilize object identifier (OID) when fetching metadata from the server. (SP-27231)
Fixed command-line interface to correctly handle -D arguments that contain more than one '=' character. (SP-28032)
Fixed command-line interface to correctly handle -D arguments that contain spaces. (SP-28034)
Each SourcePro release is a replacement for, not an upgrade to, the previous version. Always perform an installation into a new area, and not into the same install directory as a previous version.
If you don't have administrator privileges, the installer will prompt you to enter the administrator's password.
For network installs on Windows, using a UNC path to specify the installation location is not supported. The problem is actually in RCB which, in such installs, is unable to create valid makefiles. So instead, create a mapped network drive to the desired network location. For the mapped network drive, be sure to check "Reconnect at Logon" checkbox. If this option is not selected, the mapped network drive will not appear when browsing for an install location.
Whenever you invoke RCB to build some set of libraries, there should be a build results HTML page at <buildspace>/records/results/index.html. However, this occurs only the first time you invoke RCB; for subsequent builds, this file is missing. You can, however, find the same information by looking in the subdirectory for the buildtype of the build just performed. For example, the results for a 12d build would be found at <buildspace>/records/results/12d/index.html. (SP-15699)
RCB-generated makefiles do not put quotes around include path strings. If the path to the installation directory (local buildspace), export buildspace, or a user-provided third party library contains spaces, then compile failures will result. One way to prevent these failures is to ensure that the paths for the locations in question don't contain spaces. However, this may not be possible in some environments. If it isn't possible to remove all spaces from the paths, select the build action of "just generate makefiles" and then perform the build through RCB. Once RCB has generated the required makefiles, alter the makefiles to quote the path(s) which contain spaces, then execute the relevant makeall_<buildtype> script (located in the root of the buildspace) to perform your build manually. (SP-15689)
Numerous optimization issues have been noted when compiling with -xO4 with Oracle Developer Studio 12.6 on Linux and Solaris/SPARC.
To avoid these issues, we've reduced the optimization level from -xO4 to -xO3 for all SourcePro modules. (SP-25946)
Optimization issues have been noted when using Oracle Developer Studio 12.6 to build 64-bit binaries on x86 platforms.
To avoid these issues, we've changed the compiler target architecture from -xarch=sse3 to -xarch=sse2 for the Essential Math, Linear Algebra, and Business Analysis modules. (SP-24293, SP-25937, SP-25507)
Multiplication where the result contains insignificant trailing zeros may cause an inexact exception to be thrown, even if the result is represented exactly. In the following example, in which the class RWDecimal<RWMultiPrecisionInt<2>> can represent numbers with 18 decimal digits, an inexact exception will be generated:
RWDecimal< RWMultiPrecisionInt<2> > valA = "5282.80977864";
RWDecimal< RWMultiPrecisionInt<2> > valB = "1000000000";
RWDecimal< RWMultiPrecisionInt<2> > valMul = valA * valB;
cout << "valA : " << valA << endl;
cout << "valB : " << valB << endl;
cout << "valMul: " << valMul << endl;The program creates the following output:
[MULINEXACT] RWDecimal: inexact result in multiplication
valA : 5282.80977864
valB : 1000000000
valMul : 5282809778640.00000 // 18 digit result still exact
In one sense, the inexact exception is correct, since a certain number of significant digits are lost in the calculation. It just happens that those digits are all zeros. (SP-10262)
-fp-model precise recommended when compiling with Intel C++Intel C++ compiler optimizations include storing floating point variables in registers. On some machines this results in greater precision than a double should have.
According to the Intel C++ compiler User's Guide:
-fp-model option or /fp:precise (Windows) Tells the compiler to
strictly adhere to value-safe optimization when implementing
floating-point calculations. It disables optimizations that can
change the result of floating-point calculations, which is required
for strict ANSI conformance
This advice applies to portions of the Currency Module code.
We strongly recommend that you add -fp-model precise (Linux) or /fp:precise (Windows) to the command line of any non-debug programs built using the Currency Module and the Intel C++ compiler.
-ffloat-store recommended when compiling with GCCGCC compiler optimizations include storing floating point variables in registers. On some machines this results in greater precision than a double should have.
According to the GCC man page:
"For most programs, the excess precision does only good, but a few
programs rely on the precise definition of IEEE floating point. Use
'-ffloat-store' for such programs."
This advice applies to portions of the Currency Module code, and we have disabled this particular optimization for non-debug library builds and example-program builds by adding the -ffloat-store option to the compiler command line.
We strongly recommend that you add -ffloat-store to the command line of any non-debug programs built using the Currency Module and the GCC compiler.
When using the Solaris SunPro compiler and the native C++ Standard Library, the number of bytes counted by an RWAuditStreamBuffer cannot be printed without forcing the compiler to invoke the member conversion operator. The following code demonstrates the issue:
This problem affects the Essential Tools examples manual/auditbuf and manual/auditbufx. The problem is not observed when using the GCC C++ Standard Library. (SP-9247)
The C++ Standard Library that comes with the HP aC++ compiler has problems with locales other than the "C" locale. This can cause failures in RWAnsiLocale::stringToDate(). (SP-10843 / HP CR# QXCR1000990079)
ICU binaries built with Oracle Developer Studio and the GCC C++ Standard Library will have a runtime dependency on the GCC libraries bundled with the compiler. The runtime shared library path must be set to include the GCC libraries. (SP-24358)
The Threads Platform Guide documents that user-defined stack attributes are supported on Linux. This is not currently the case. We continue to investigate providing stack attribute support on this platform; however, we are unable to do so at this time. (SP-13419)
const in copy constructor and assignment operatorThe RWTOnlyPointer copy constructor and assignment operator take const RWTOnlyPointer references, but casts away const on the parameter in order to invalidate it.
The parameters should be changed to non-const references to be correct, but this could potentially break user code which depends on being able to pass a const parameter. This issue will be fixed in the future.
Do not use RWTOnlyPointer instances in containers that expect assignability and copy constructability. This could cause issues because the value passed to the copy constructor or assignment operator will be invalidated. (SP-10222)
Oracle Solaris 11 changed the behavior of various functions related to setting and retrieving thread attributes. These changes are incompatible with assumptions the SourcePro Threads Module makes and may lead to unexpected exceptions, silent failures, or other errors. For this release, it is recommended that users avoid thread attributes related to priority, scheduling or inheritance on Solaris 11. This behavior will be reviewed in a future release. (SP-14298)
-lsocketThe DB2 client library is unable to load the socket library on Solaris. When this happens the database returns:
SQL1042C An unexpected system error occurred. SQLSTATE=58004
The workaround is to add -lsocket to the link line of the executable. (SP-21466)
In multithreaded applications, producing RWDBDatabase objects using an RWDBManager::database() call in each thread simultaneously results in a segmentation fault. This is due to a MySQL native call that is not multithread-safe.
To work around this problem, serialize the production of the first RWDBDatabase object. Alternatively, call MySQL native API mysql_server_init() (mysql_library_init() for MySQL 5.x) before accessing the DB Access Module for MySQL. (SP-8553)
ODBC allows the driver implementer to decide how to handle return values from stored procedures. A common convention is to support a bound return value. In this scenario, SourcePro DB allows retrieving the return value in the following manner:
RWDBDatabase db = ...
RWDBConnection conn = db.getConnection();
RWDBStoredProc sproc = db.storedProc("procedurename", conn);
// execute the stored procedure
sproc.execute(conn);
// retrieve the return value
RWDBValue val = sproc.returnValue();The Informix ODBC driver supports multiple return values, and as a result follows an alternate convention, in which the return values are returned as a result set for the function. In that scenario, the return value can be retrieved from the result set, like so:
// execute the stored procedure
RWDBResult res = sproc.execute(conn);
// create a reader for the result set.
RWDBReader reader = res.table().reader();
RWDBValue val;
reader() >> val; // retrieve the return valueThis behavior is consistent with the legacy Informix Access Module.
ODBC defines the call semantics for a stored procedure with no parameters as:
Informix does not support this syntax and instead uses an alternate syntax in this scenario:
The Informix syntax is interpreted by conforming ODBC implementations as calling the procedure procedurename with one argument, where that argument has a default value.
The ODBC Access Module's RWDBStoredProcedure implementation uses the first calling convention when invoking a stored procedure with no parameters. In order to call an Informix stored procedure with no parameters, use the RWDBOSql interface instead. For example:
RWDBDatabase db = /* ... */
RWDBConnection conn = db.getConnection();
const RWCString callStmt = "{ call procedurename() }";
RWDBOSql osql(callStmt, RWDBOSql::Procedure);
osql.execute(conn);The SQL syntax for dropping a column allows for an optional COLUMN keyword. The syntax is:
Some databases require the optional COLUMN keyword, others allow it, and Informix prohibits it. The ODBC Access Module emits the COLUMN keyword, causing a conflict when connecting to Informix. To resolve this, use the RWDBOSql interface. For example:
RWDBDatabase db = /* ... */
RWDBTable table = db.table("table");
// ...
RWDBColumn col;
col.type(RWDBValue::Int).name("col");
// ...
table.dropColumn(col);This last line could be rewritten to use RWDBOSql as:
char buf [1024];
snprintf(buf, sizeof buf, "ALTER TABLE %s DROP %s",
table.name().data(), col.name().data());
RWDBOSql osql(buf);
osql.execute(con);If you use RWDBBulkInserter to insert an array of strings with a length of 255 or less into a TEXT column, the insertion will fail and the Informix Database will return the error:
HY000 Illegal attempt to convert Text/Byte blob type.
Resolve this by specifying the width parameter while constructing the RWDBTBuffer that is bound against the TEXT column. For example:
// Bulk inserting 100 rows of strings with width of 256
RWDBTBuffer<RWCString> buff(100, 256);
buff[0] = "abc";
// ...If you encounter the same Informix database error from any other operation, use the RWDBOSql interface along with RWDBTBuffer. For example:
RWDBDatabase db = /* ... */
RWDBInserter inserter = db.inserter("table");
RWCString str1;
RWDBBoundExpr expr1(&str1, &nullIndicator1);
inserter << expr1;
str1 = "abc";
inserter.execute();Here's an example using RWDBOSql and specifying the width parameter of the RWDBTBuffer with the SQL statement obtained by using the RWDBTracer interface:
RWDBDatabase db = /* ... */
RWDBOSql sql("INSERT INTO table VALUES (?)");
RWDBTBuffer<RWCString> str1(1, 256);
sql << str1;
str1[0] = "abc";
sql.execute();The SQL syntax for creating a clustered index is slightly different for Informix than other databases. The normal syntax is:
Informix uses CLUSTER instead of CLUSTERED. The ODBC Access Module emits CLUSTERED, causing a conflict when connecting to Informix. Resolve this using the RWDBOSql interface. For example:
RWDBDatabase db = /* ... */
RWDBTable table = db.table("table");
// ...
RWDBColumn col;
col.type(RWDBValue::Int).name("col");
// ...
table.createIndex("index", schema, conn, true, true);Rewrite the last line to use RWDBOSql as:
char buf [1024];
snprintf(buf, sizeof buf, "CREATE UNIQUE CLUSTERED INDEX %s ON %s(%s)",
"index", table.name().data(), col.name().data());
RWDBOSql osql(buf);
osql.execute(con);Informix does not correctly handle inserting multibyte string literal values. Attempted insertions may result in either data corruption or an application crash, in some cases. Inserting multibyte strings via bound values works correctly. (SP-16804, IT02280)
RWDBOSql::rowsAffected() may return an incorrect value when a row is inserted using data-at-execution. Inserting a single row at a time avoids this issue. (SP-16579, IT02184)
On some platforms, reading BIGINT data in to a long long datatype may result in the return of an incorrect value in which the upper and lower 32-bit values are swapped in the resulting output. This issue was observed with 32-bit Solaris x86 builds, but may affect other platforms as well. To ensure portability, it is recommended that values not be read in to the long long or unsigned long long datatypes. (SP-17188, IT02278)
Attempting to describe a column that has a default value may result in incorrect or incomplete information. This issue affects only describing a column with a default value, creating a column with a default value and leveraging default values when inserting data are unaffected. (SP-16582, IT02230)
Binding a 64-bit integral type as an input parameter results in incorrect data being passed to the database. This affects only bound values; literal values are unaffected. (SP-17293, IT02552)
When strings are inserted into a VARCHAR column, trailing whitespace is removed. This behavior is not observed when inserting strings into a TEXT column. (SP-17187, IT01262)
On Linux, setting the login timeout (RWDBODBCLibEnvironmentHandle::timeout) has no effect. This is caused by a conflict in the handling of this value between unixODBC and the Informix driver. (SP-17187, IT02279)
Informix requires delimited table names to be quoted when passed to ODBC API functions such as SQLColumns and SQLProcedures. This conflicts with the ODBC Access Module and other ODBC drivers that expect those names to be unquoted. Due to this limitation, delimited names are not currently supported with Informix. (SP-16743, IT01153)
The Sybase Client-Library CS_INT datatype is strictly 4 bytes, even on 64-bit platforms. Binding a long or unsigned long on a platform with an 8-byte long results in data truncation. Use the int datatype instead. (SP-14608)
This library has problems handling decimal columns with NULL values through cursors. On some platforms, deleting a row with null values in decimal columns through a cursor causes a core dump. In some platforms, it returns non-null values for NULL columns. Sybase has identified this as a bug. (Sybase #94310 / SP-7765)
If a user attempts to bind RWCString data having length greater than 16384 bytes into a column of type TEXT, the data gets truncated to 16384 bytes. This is due to the page-size limitation in Sybase.
A workaround is to insert the data as a literal rather than a placeholder. All DB Data Manipulation Classes will put RWCString data greater than 16384 bytes as literal in the SQL sent for execution. However, while using class RWDBOSql, the user must perform this before passing the statement to the RWDBOSql instance. (Sybase case #10832821 / SP-7789)
The DB Access Module for Sybase supports bulk writing through the array interface provided by the Sybase Bulk-Library function blk_bind(), which is part of the Open Client and Open Server common libraries. However, Sybase Bulk-Library does not support insertion with column-list. Here are some other specifics on using bulk insertion with SourcePro DB and Sybase:
The RWDBBulkInserter associated with the DB Access Module for Sybase can accept RWDBTBuffer
Bulk insertion is implemented based on the Sybase Bulk-Library, which may impact the recoverability of the database in case of failures. See the Sybase documentation on "Bulk-Library client programming" for full details.
The Sybase Bulk-Library call blk_bind() doesn't report errors when NULLS are inserted into a column that doesn't accept NULL values.
Executables using Sybase Access Module multithreaded dynamic libraries on Solaris and Linux need to link the Sybase vendor libraries. Not linking the Sybase vendor libraries to the executable has been observed to produce intermittent segmentation faults. The Sybase vendor libraries can be linked directly or by linking the Sybase Access Module library to the executable. The Sybase Access module examples link the Sybase Access Module library.
As these failures are intermittent, if you do not observe these failures, you do not need to link these libraries to your executables. (SP-8505/SP-9426/SP-9472)
When using Oracle Heterogeneous Services for SQL execution, you need to use explicit Transaction Management using beginTransaction() and commitTransaction(). By default, this module uses OCI_COMMIT_ON_SUCCESS, whereas heterogeneous services require transactions.
When a result set fetched from Oracle has a LONG column in it and no buffer is bound for the LONG column, then Oracle returns either ORA-03106: fatal two-task communication protocol or ORA-00127 dispatcher %s does not exist. (Oracle bug #4919068 / SP-8671)
Calling OCIBreak to terminate polling operations doesn't work. This results in ORA-03127 when the next operation is attempted on the connection. OCIBreak is called when:
Reading into a RWDBTBuffer
Returning false or throwing an exception from RWDBDataCallback::onFetch(). This has been identified as Oracle bug #10606993.
The Oracle datatypes SYS.XMLTYPE is supported by SourcePro DB, but extra steps are required in some cases. When inserting data using RWDBInserter, to use the best transfer mechanism the DB Interface Module needs to know that the underlying table has a SYS.XMLTYPE column. The easiest way to do this is by calling the RWDBTable::fetchSchema() method before creating your RWDBInserter instance. Here's an example that demonstrates this:
// CREATE TABLE foo(c NUMBER(9), xmlcol SYS.XMLTYPE);
RWDBTable foo = myDb.table("foo");
foo.fetchSchema(myConn);
RWDBInserter ins = foo.inserter();
int c;
RWCString xml;
// fill in data ...
ins << c << xml;
ins.execute(myConn);Applications using the Oracle Access Module on HP-UX 11i v3 crash with a bus error if the first connection established by the application is inside a child thread. Increasing the thread stack size using thread_attr_setstacksize() resolves the issue. (SP-9006)
Using the Intel C++ compiler may result in unresolved symbols errors. Supplying the path to the lib subdirectory of the compiler installation as the first path for the linker to search for libraries (for example: -L<path to compiler>/lib) resolves the errors. (SP-8484)
In addition, the path to the Intel libraries should also appear before the path to the Oracle libraries in the LD_LIBRARY_PATH environment variable. (SP-8585)
Clients using SSLv2 may no longer be able to connect to servers using TLSv1WithFallback. This is because the default cipher list used by OpenSSL 1.0.0 and later no longer includes the necessary ciphers for this fallback to work. While it is strongly encouraged to avoid using SSLv2, fallback support for SSLv2 can be enabled by enabling the necessary ciphers on a context. The following code snippet demonstrates.
The PDF documents shipped with SourcePro are provided so customers can print the documents if they wish. These documents are not intended as primary access to the product documentation, and may not be as fully functional as the HTML documentation. One known issue is that hyperlinks between these documents do not work, and other issues may exist.
The native Windows 8 PDF Reader may behave inconsistently; it has been observed that hypertext links are not processed correctly. Instead, use Adobe's free Acrobat Reader.