The current maintenance kit is Caché 2011.1.3. This document is only part of the available maintenance kit documentation. The full set of documents is available in the docs subdirectory of the product installation directory. Release notes and related material are available as follows:

• Late-breaking information about the release: <install-dir>\docs\cache\en-us\relnotes\cache\readme.1st
• Release notes for 2011.1.3: <install-dir>\docs\cache\en-us\relnotes\cache\relnotes.htm
• Release notes for the previous maintenance kit since 2011.1: <install-dir>\docs\cache\en-us\relnotes\cache\prenotes.htm (this document)

This document is a historical archive of changes since the original 2011.1 release, but prior to the current maintenance kit. Changes unique to the current maintenance kit are described in relnotes.htm.

This document includes the following sections:

• General Announcements
• InterSystems News, Alerts, and Advisories
• Online Documentation
• Change Reports for Previous Maintenance Kits

InterSystems advises all users to recompile their application classes as part of the upgrade process so as to take advantage of all the performance improvements as well as other changes that may affect them in this release.

Anyone upgrading from a Caché release at or before 5.0 will need a new license key.

From time to time, InterSystems publishes items of immediate importance to users of our software. These include alerts, mission critical issues, important updates, fixes, and release announcements.

The most current list can be obtained from the InterSystems Web site.

Users should check this list periodically to obtain the latest information on issues that may have an effect on the operation of their site.

As a convenience to our users, InterSystems provides online access to documentation for recent product versions at the InterSystems documentation Web site.

The following are the previous maintenance releases of Caché 2011.1:

This change allows the listing of namespaces to include those on accessible remote systems.

This change reoves a debugging call that was inadvertently included in the product release.

In order to ensure consistency of the routine and class index, Caché sometimes locks ^rINDEX and ^rINDEXCLASS. With this change, when those locks are released, Caché uses immediate mode to ensure they are released straight away even if the release takes place in a transaction.

Due to a problem caused by a previous change, when checking if a MAC routine was current, the absence of a corresponding INT routine, would return true. This is incorect and is fixed by this change.

SQL standards suggest that simple constants inside of double parathensis should be sent as literals, however, Caché should continue to substitute constants in more complex situations. With this change, in the query

select COUNT ((1)), fCQname from QueryTest

the value "1" should be sent to Cachél as is. However,

SELECT count(*)
    FROM SAMPLE.PERSON
    WHERE ((Age = 20 and Name='A') or Age=30)

would be sent as the following:

SELECT count ( * )
    FROM SAMPLE.PERSON
    WHERE ( ( Age = ? and Name = ? ) or Age = ? )

using parameter substitution.

If a .NET client stopped redirecting input from the server, this could turn off output redirection in a future connection that had the same process id or in a connection that was reused via connection pooling. This change corrects both problems.

This change adds timeout guards to the OPEN commands used by %Net.Remote.Gateway to prevent hangs.

this change updates libssh2 to version 1.3.0 to correct issues seen in 2010.2.x installations in the field involving SSH packet handling and socket I/O in earlier versions.

When using %Net.FtpSession to send or receive data, Caché uses a stream on its side to put/receive the data. However, this process was not checking for errors from the stream class such as it running out of disk space for a file stream.

With this change, Caché will detect this error and report an error code from the %Net.FtpSession class with the error information from the stream embedded.

A bug that caused a foreign key constraint failure to be ignored when deleting an object is now fixed. This bug occurred when deleting an instance of a class that is targeted by a foreign key constraint and also contains streams. If the foreign key referential action fails, then that failure status was not honored and the delete was allowed to proceed.

This change corrects a problem where compiling an SQL statement will encounter an <UNDEFINED> error when the SQL LockTimeout is set to 0.

Using long property names within an XECUTE could cause an access violation on x64 platforms. This is now fixed.

This change corrects a rare race condition in the class loader where recompilation could leave invalidated heap segments exposed and cause them to be corrupted.

A large object hierarchy destruction may take some time to finish, and moreover if there is any retained block, the system may hang. This change alters the way this situation is handled to release the retain block if there are any jobs waiting for it

When using ^NLS to edit the replacement string from a modal translation table (such as JIS), the mode byte was being lost. This would cause an access violation when the replacement string was needed in case of a translation error. The mode byte is now preserved.

This change corrects a situation when, under some circumstances, successive callins would allocate space without freeing it upon return which would lead to memory exhaustion.

This change corrects a situation similar to JLC1544 but involving job servers and callin clients. The memory exhaustion issue is now avoided.

A problem where database expansion of a database which is being compacted or defragmented could result in database degradation has been resolved. The problem occurs when a database is expanded while the defragment/compaction process is in the process of reading blocks from the database. The most likely occurrence of this is on UNIX® systems during a defragment operation which triggers expansions in order to complete. Windows and OpenVMS systems are less likely to experience this problem when the defragment process triggers the expansion as the expansion occurs in a single operation. On UNIX® the expansion request triggers a series of smaller operations.

This corrects an issues where the handling of disk i/o in processing database expansion could hang the process.

When more than two databases are expanding, the expansion daemon writes multiple messages to cconsole.log.

With this change, expansions will get at least 2 messages per database, and at most 3.

Limited read-only support for 2KB datasets is still needed in 2011.1, this change puts back some code needed for SYS.Database.Copy

A problem introduced in 2011.1 where transactions would not be properly rolled back during cluster recovery at startup has been resolved. The problem could also occur during cluster failover if the master node has to mount a database during the journal roll forward phase. This is an unusual situation because the slaves cannot take out locks in a cluster mounted database which is not mounted on the master so this (generally) only would occur if the master has some database mounted which is not mounted by a slave and then the master fails and the slave performs cluster recovery.

This change addresses an situation on Windows and OpenVMS that a journaling issue may take 60 seconds for the control process to detect before it freezes the system as opposed to the advertised 10 seconds.

It also addresses an issue (mostly on Windows and OpenVMS, less likely on Unix) that could cause the control process to freeze system on something that does not warrant the freeze (for example, a false journaling issue), although the control process would unfreeze the system in 60 seconds. The behavior may result in unnecessary interruption of system availability or failovers of mirror servers.

This change corrects an issue that resulted in a corrupted journal.log when there is no more space in the manager directory.

This change corrects a situation where, during backup, the system may pause users due to journal daemon inactivity in certain circumstances such as the journal files are in the same filesystem as databases and the filesystem is frozen as part of the backup procedure.

This action reverts a prior change that changed the control process monitoring rule such that it did not freeze a system that is set to freeze on journal error if journaling is stopped (as opposed to retrying a failed journal I/O operation or stuck in somewhere).

On a system set to freeze on journal error (FreezeOnError=1 in cache.cpf), stopping journaling, although risking loss of journal data, is allowed and does NOT cause the system to freeze thereafter.

This corrects an issue that caused the write daemon to consume 100% of the CPU when the system was frozen on journal I/O issues.

This change corrects several issues with mirroring where

• a backup would sometimes report the journal file was invalid and fail to shutdown cleanly after getting disconnected, or
• spurious invalid journal file errors might get logged during shutdown.

  The journal files were not actually corrupt in either case and apart from failing to exit cleanly, these do not cause issues with the mirrored databases.

This change corrects a possible failure caused when a failover member removed itself, and then add itself back into the mirror set as failover member.

Spurious SYSLOG entries are produced by %MONAPP every 5 minutes if there are remote (ECP) databases mounted.

This change addresses an issue in shadowing where a source journal file name prefix specified is different from the "canonical" one on the platform (lowercase on Windows and uppercase on OpenVMS) could cause shadowing to take up unnecessary network bandwidth between the source and the shadow.

This corrects a problem where using the memlock config option on AIX, the lock always fails with the message:

*** Warning - Cache was unable to lock shared memory ***

If LibPath is missing in the .cpf file, startup fails immediately. With this fix, a missing LibPath entry is treated as a null entry, and startup continues.

This fix changes the way retrying is done in Integrity checking when blocks are being changed while the global is being checked. Checking should now give similar numbers of errors found as in previous versions, but also identify them as possibly being due to blocks being changed.

Normally, Integrity checking should be done on quiescent globals.

This change will ensure that HTTP POST request messages containing zero-length XML-based payloads are correctly processed. It corrects a fault introduced in a previous version that resulted in requests of this type not being processed and eventually timing-out.

This change now correctly displays the number of facts for 1 core.

This change corrects errors that occurred when changing to a new namespace using the Switch dialog.

1. If the user selects a namespace that is appropriate, the UI page can be refreshed for the newly selected namespace (previously user was returned to the Home page).
2. If the user selects a namespace that is not appropriate, for example %SYS, then the Home page is displayed.
3. In rare cases, if a namespace is selected but the web application is disabled, or for some other reason the URL for the new namespace could not be prepared, the user is returned to the Home page.

With this change, scripts used to create a new group or user in Mac OS X install (by default cacheusr) will now call "dscacheutil -flushcache" to ensure new user and group are available for use in Unix utilities such as "chown" immediately.

This additions updates the DMG installer engine postinstall script to use the same logic to start control process as regular UNIX® install does and it will pass all recently added variables to ^INSTALL.

A $CASE with many cases could cause a compiler error "Expression object code is too big". This has now been fixed.

There could be <SYSTEM> errors or memory access violations when compiling a routine with syntax errors in a TRY statement, such as a missing CATCH clause. This correction eliminates the error.

Under some conditions nested $SELECTs could throw a <SYSTEM> error when the routine is compiled. This is now fixed.

When a merge command is executed, there is a chance that subsequent kill operations on a single subscript in the updated array would kill the entire array instead of just the intended single subscript.

This change corrects that.

This change fixes a circumstance where Caché could produce a <SYSTEM> abort or a segmentation violation when the application attempts to KILL an array or executing a $ORDER on an array.

This change fixes a rare problem which could cause the JOB command to fail while passing an open socket to the child process. This usually occurred when also passing the symbol table or a large amount of argument data, although neither of these conditions guaranteed the JOB command fail.

This change corrects errors in F/Acorr summation operations in MultiValue.

This change fixes a problem where a URL may not be constructed correctly if there are multiple Web Applications defined for the same namespace.

This change inserts code into the GetNewURL method in %ZEN.Portal.standardPage to compensate for a browser error that occasionally loses the value for a defaulted argument.

When a user selects a new namespace from the Home page, the URL is not changed until the user selects Go to actually go to that page. At that time, the new namespace becomes part of the URL.

If the user clicks the Add Favorite before selecting Go, the URL that is saved for future use does not contain the new namespace. This causes a "Page does not exist" error when it is later used.

This change correct that situation.

This change fixes the "Help" links in the table for each item in the row so selecting them goes to their help page.

This corrects a situiation where attempting to navigate to the Management Portal from the SAMPLES could fail on OpenVMS due to a malformed URL.

When Save is pressed, the page should return to the Home page. But on an OpenVMS system, the URL built for the Home page may be missing the instance name.

This is now fixed.

Tbis change now allows the TSQL DDL CREATE INDEX statement to be executed as a dynamic statement when the statement dialect is Sybase or MSSQL.

This fixes a problem where in very rare cases,

• when a long string cannot be compacted, and
• the global is subscript mapped, and
• the global value is accessed using 2 argument $DATA (to get the value during the operation),

the value returned by the server might be corrupted.

This is described as rare because, in production systems, most unicode strings get compacted.

In rare conditions, when an ECP request SET is partially processed before the server is shutdown or fails, and then the server is restarted, some application server sessions might be rejected and not recovered.

This is now fixed in all ECP servers

In the infrequent case where a reverse $ORDER is being pre-fetched by the worker daemon while the previous block is being modified by the ECP daemon, the server may report a deadlock condition and hang the ECP daemon and possibly the system. This change avoids that situation.

This change marks the %DeleteOID method in the %Library.Persistent class as procedureblock so the 'oid' variable does not leak out.

The newly implmented support for large routines does not allow routines with over 64k of lines. With this change, the class compiler will keep track of the number of COS lines and will split the generated COS code at a little less than the 64k line limit and then generate another COS routine with the rest of the code in it.

If %Concurrency is true, then locks are acquired and released to guarantee consistent reads of objects during a transaction. All write operations are also guaranteed to be consistent. For %Concurrency values greater than 2, locks are acquired and not released until the object is destructed.

This change corrects a concurrency hole where an atomic object (one that occupies a single global node on disk) is inserted inside of a transaction. In this case, the atomic write was not protected by a lock and a competing process could update the newly inserted object. This is only an issue when the transaction containing the original insert is rolled back. In that case, an error is reported by the rollback.

An exclusive lock is now taken out on all objects during insert as long as %Concurrency is true and, if the object is atomic, the insert occurs within a transaction.

This change corrects an error introduced in 2011.1.0 that caused the default global location for counters to be incorrectly generated. If the storage definition specified a COUNTERLOCATION, then that value was incorrectly ignored. This value is now properly used for the default counter location.

This change corrects the method signature on SHA-2 functions.

This change corrects an incorrect character conversion by big-endian Unicode systems that caused errors when processing encrypted keys.

When the user definition has "Change password on next login:" checked, the next time the user logs in a prompt to change the password appears. This change corrects a situation where, under some circumstances, that prompt could result in an <undefined> error.

This corrects an error in U2 where, after issuing $ZU(11,2), a subsequent GOTO to an entry point with a formal parameter list could get an access violation.

This change correct an error that mishandled arguments during a call.

This change corrects a situation where a deferred SQL statement that included a host variable reference of the form oref.prop was improperly translated into generated code.

Modifications made to cursor recycling to prevent store errors on the server side introduced new problems for statements containing multiple streams using a forward moving cursor. This is now fixed.

Default options on the compiler have changed causing unaligned access errors on decunix5 platform. This explicitly sets the options on the compiler which resolves the problem.

Calls to SQLFetch could return SQL_ERROR(-1) in the case where:

• a query returns 32K of data to the client,
• the last row of data is complete,
• and no more data is present on the server.

This change handles the status return of 100 on the attempt to fetch the next chunk of data, and return SUCCESS to SQLFetch. The next call to SQLFetch will detect there is no more data and return SQL_NO_DATA_FOUND.

A bug that caused an error when executing dynamic statements via JDBC and ODBC has been corrected. The issue was caused by a flush message sent from the server. The most common symptom of this error was a message count mismatch.

A problem has been corrected where a class that used %CacheSqlStorage with a single property IDKEY index and a data map defined as a $PIECE map could have a syntax error reported when the class was compiled.

This change fixes an error that caused a result set returned by a CALL <class_query> SQL statement to fail to send its content to an xDBC client.

When using Internet Explorer, after the user unchecks the Copy Data checkboxes and hits Finish (without hitting Next) then Data Migration succeeds. However, if the user hits Next and hits Finish on the next page, the Copy Data checkboxes become checked again and the result is that the data is copied.

This is a problem for Internet Explorer only and has been fixed.

When searching for schema prefixes, an unsigned integer could be decremented past zero resulting in a very large integer which exceeded the subscript range permitted for an internal vector class leading to a crash. This change corrects the search algorithm so the error does not occur.

A <STORE> error may show the routine name but not the line location in the routine. If the error happens in a procedure, private variables would not be visible to the debugger. This has been corrected.

The internal function used by Weblink Developer, could overlay memory and cause access violations in the process.

This has been corrected.

This changes fixes a vulnerability for sites that use legacy commands like ZLOAD and ZINSERT to edit large routines.

Reading from a sequential file with format "U", using a very large fixed length READ, could cause an access violation on Windows systems.

This has been corrected.

This changes fixes a problem where %OnNew() returned an OREF and the returned value was from a derived class. In this case, the OREF was not properly accounted for and may have been released while it was still "live" resulting in an access violation.

Caché clears $this in data-typed property methods to prevent unintentional access to the subclass members.

If the data-type method is invoked from the same type of method as the method of the subclass, clearing $this cleared the caller's context. This change pushes the caller context on the frame stack, and on return from the data-type method it will restore the original context.

When a large number of routines are loaded as part of an object instantiation, the system may run out of string stack.

This change now properly preserves the string stack contents.

Mac OS X 10.7 (a.k.a "Lion") introduced a new shared library called libcache.dylib. In order to avoid the name conflict, Caché's callin library was renamed as libisccache.dylib.

Any Mac OS X program that links with the InterSystems older libcache.dylib will have to be changed to use the new name, libisccache.dylib.

This change fixes an issue where a JOB command using jobservers will sometimes hang and time out. A dump analysis shows the two processes (parent and child) both waiting in the job putsym and getsym (symbol passing) code.

This entry corrects a situation where repeated use of $VIEW(-1,pid) causes process to hang.

This chage corrects a situation that could cause the shutdown process to provoke a core dump.

Under some circumstances a jobserver that receives a sigusr1 signal while in the process of halting can generate an <ACCVIO>. This change prevents that from happening.

This change corrects a situation where cluster recovery may be initiated after the cluster is up.

Stopping journaling via ^JRNSTOP is NOT allowed when the system is set to freeze on journal error (that is, FreezeOnError=1 in Config.Journal or the "Journal" section of cpf etc.), as the system is going to freeze shortly after journaling is stopped.

This change will disallow any attempts to stop journaling in those conditions.

This fix addresses an issue that could cause journal switch to hang after an error in purging the journal log, for example, an error resulting from insufficient disk space in the manager directory (where journal.log resides).

This change corrects a problem that would cause too many license units to be consumed by SOAP requests when SOAPSESSION=0 and a username/password login was performed.

This correction addresses a circumstance where CacheODBC resources were not being loaded in 64-bit Windows environments, but worked OK on 32-bit systems.

The process of removing a mirrored database on a non-mirror member has been updated so that a restart is no longer required before the database can be mounted read/write.

When an async mirror member stops tracking a mirror, it is now removed from the active configuration on the primary so that it will no longer remain in the mirror monitor. This change has both server and client components so it only takes effect when both the primary and the async member are running a version which includes this change.

A problem which prevented a mirror member from recovering when it failed to become the primary and the system was configured with a journal file prefix has been resolved. If, for example, $$CheckBecomePrimaryOK^ZMIRROR() returned 0 and the system was configured with a journal file prefix, it would fail to recover properly and shut down. The console log would contain a series of error messages ending with "PrimaryAbort failed, shutting down instance".

This change prevents a rare situation where the write daemon and the journal daemon may find themselves in a deadly embrace during the interval a system is in the process of establishing itself as the primary mirror member.

This change corrects a situation where a backup member failed to reconnect to primary if the journal file pointed to by the system had been purged.

This change corrects a circumstance where a backup member might fail to reconnect to the primary after upgrade killed ^MIRROR global.

This change allows an async member to keep the mirror journal file for days configured by users. The ^MIRROR routine could configure the 'days' before the mirror journal file be purged. When it is zero, then it will be purged after the journal file is fetched from server and restored to databases.

This change fixes a problem where the backup node reconnect to a primary member could fail when the value in ^MIRROR(mirname,"LastJrnfileValidated") points to a purged journal file.

This change adds support for users to activate/deactivate (start/stop) specific mirror set on backup or async members.

It adds the SYS.Mirror.IsMirrorStarted() method to detect whether the specific mirror set is started or not; and adds 'Activate Mirror' to the menu option in ^MIRROR routine.

This change addresses an issue of cluster shadowing in certain rare circumstances (such as CPU shortage) where multiple jobs might get JOBbed off to copy journal files from one source cluster node, (over)writing to the same destination file and causing cluster shadow dejournaling job to get an error such as <ZQUIT> ExitOnErrorGetRec+3^SHDWX.

This change fixes an issue that could cause TROLLBACK to fail with the (false) error "journaling is disabled" in certain rare circumstance involving an ongoing journal switch.

This change fixes a problem where, if the lock table is full, a new user cannot log in.

This change fixes a possible stale SLM mapping when the destination database location is updated in the CPF file before Caché is started.

This corrects an error that caused a <INVALID OREF> error when drawing a ZEN Table Pane that uses dynamic SQL.

A previous enhancement enabled the user to unselect the current row by clicking on it, making the row click option effectively a toggle and allowing the user to 'select nothing' without having to reload the page. This was a departure from the prior behavior where subsequent clicks on the selected row were ignored and the only way to clear the current selection was to either select something else or go through the API.

This fix adds a flag to tablePane, effectively making the previous enhancement optional.

© 2011, InterSystems Corporation. All rights reserved.