The current maintenance kits are Caché and Ensemble 2010.2.4. 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 or <install-dir>\docs\cache\en-us\relnotes\ensemble\readme.1st
• Release notes for 2010.2.4: <install-dir>\docs\cache\en-us\relnotes\cache\relnotes.htm or <install-dir>\docs\cache\en-us\relnotes\ensemble\relnotes.htm
• Release notes for the previous maintenance kits since 2010.2: <install-dir>\docs\cache\en-us\relnotes\cache\prenotes.htm or <install-dir>\docs\cache\en-us\relnotes\ensemble\prenotes.htm (this document)

This document is a historical archive of changes since the original 2010.2 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é 2010.2:

These changes will allow proper usage of filenames with Japanese characters.

Pages with non-ASCII characters in the URL aren't served when cache un+pass is specified in the URL.

This change fixes a problem that could result in an access violation if state-aware mode (preserve mode 1) is used with the new multi-process Apache Unix DSOs (CSPa[n][Sys].so).

This change provides support for European number format based on Site Configuration > Number Format setting.

This change corrects an issue where, if there is no command on a line that starts with an entry point with formal parameters, and there is a ;; comment on a following line before any other command, $TEXT of the entry point line will return the line with the ;; comment instead of the entry point line.

This change forces a compaction of a local array when it detects that the array is becoming fragmented with redundant space.

This correction prevents a situation where an access violation could occur when Caché is running on systems which very large memory systems.

Due to a very rare circumstance involving the order in the database mount timing, the ECP server may lose the knowledge of blocks cached on the app-server, and the app-server may not see the latest changes on the server. This is now fixed.

This change corrects a situation where ECP Recovery may not register transactions properly, and if there is another server failover/restart before the transaction is closed, it may lose tracking of the open transaction.

For $ORDER or $DATA of a subscript mapped global, if the global value was requested and the value was a long string, ECP did not handle the returned value properly. This caused unexpected behavior (for example, the requesting application may crash, or return an incorrect value)

This change prevents that possibility..

If cachetemp is full, ECP may fail to mount any unmounted or new remote DB and may leave the internal structures in a partially mounted state. Leaving the structures in a partially mounted state may cause access violations or an incorrect DB mount if the connection is dropped and the ECP client has to go through recovery.

Note, if cachetemp is full the ECP client may fail to allocate the blocks required for internal cache tracking, drop the connection, and go through recovery; the app-server would be exposed to this.

This change corrects that circumstance.

This change corrects a rare situation where a $DATA of a value accessed via ECP may return a 0 or a 1 when it should return a 10 or 11.

This change corrects a situation where a client program that tries to access runtime meta information on the same server in different threads can cause random errors inside the provider.

If a routine is too big to save, Caché attempts to split this, the splitting code needed to have a little more dummy space allocated to avoid a situation where a block appears to fit but, in fact, when the final fixup is done it is very slightly too big.

If a Caché Exception occurs in an isc:extension() handling function, Xalan would crash the cache process. This is now fixed.

This corrects a situation where a user can get escalated to the cacheusr groupid, while validating against his own database's security.

When using the LDAP server to authenticate, several LDAP variables were left in the processes partition after the user logged in, including variables which held the users username and password. These variables could be examined from another job using ^JOBEXAM. This problem has been fixed such that these variables are no longer left in the user's partition.

This change corrects a situation that could lead to an incorrect classpath parameter being generated.

This change improves the inserting, updating or selecting fields where the field type is %Library.FilemanDate, %Library.FilemanTimeStamp, or %MV.Date, and the insert value or comparison value against these fields is CURRENT_DATE or CURRENT_TIMESTAMP.

For example, suppose you have the query:

SELECT DOB, %ID FROM MyTable WHERE DOB = CURRENT_DATE

where DOB is of type %Library.FilemanDate and there is an index on DOB. Prior to this change, the index would get chosen by the query optimizer, but the entire index would have been traversed looking for the row(s) that matched. Now, the index will be chosen using the given value of CURRENT_DATE for DOB.

A bug in dynamic SQL SELECT processing caused a stream column value to be retained from one row to the next. This bug is now fixed.

On keyboards with AltGr key, it can't be distinguished from Ctrl/Alt key combinations; Windows doesn't make the distinction. These key combinations have been removed from Studio.

From a method, control flows via a goto to another routine or tag in the method procedure block, the object context was getting popped to the previous level, and if the tag was in the same method the context was not correctly set. This is now corrected.

In some rare cases, if the class method was invalidated, the dispatcher did not detect the change on the next reference, but it did on the following reference after that. Also if a super class was invalidated, private method context validation did not detect the invalidated super class, and could raise <PRIVATE METHOD> error. Both of these situations are now fixed.

This change corrects a situation where an error massage longer than 255 characters could cause an error message buffer overflow with unpredictable side-effects.

The 8-bit Thai locales (tha8 and thw8) were missing the descriptors for the Caché standard collation, which prevented them from being installed. This is now fixed.

This change corrects a rare circumstance where opening a file may experience a noticeable performance delay.

This change corrects an error where a Caché process crashes when it is the target of multiple processes making JOBEXAM requests.

This change fixed a circumstance where a system may generate a core dump when more than 2 GB memory is configured for gmheap in CPF file. The job will get core dump when it calls $System.Config.SharedMemoryHeap.GetConfigSize() or $System.Config.SharedMemoryHeap.MaxCount().

This change corrects a situation where a lack of available pagable memory could result in a deadlock among jobs.

This change fixes a problem introduced in Caché 2010.2.3 on HP/UX can cause an exception when Caché is started with I/O indirection. The problem is present only on HP/UX.

This change addresses an issue that resulted in the "<UNDEFINED>FULLPATH+3^JRNRESTB" error during journal restore after one answered "No" to the question "Check for missing journal files?" (default is "Yes") at journal restore setup.

This change corrects a situation where Caché startup would abort if recovery failed to mount a database that is specified as "mount required" in cache.cpf.

This change addresses potential issues (such as access violations) in dejournaling (including journal restore, shadowing and mirroring) when the allocated amount of Caché generic memory heap exceeds 2GB.

This correction addresses an issue of journal restore when a user-specified filter is used that could result in target databases missing the last few updates selected by the filter. The problem is present in 2009.1 and later.

This change addresses a situation when memory available for locks is low due to locks being held in other processes. The lock will wait for sufficient memory to become available.

This change fixes circumstance where a per-process global (PPG) lock with lock mode specified could turn into a regular global lock instead of a no-op.

In rare circumstances, a mirror member could think a journal file was required for transaction rollback when it was not. The result is that purging the journal file would be unnecessarily delayed. This is now fixed.

A problem where the mirror journal purge code might purge files before they "expire" according to the local journal file retention policy has been resolved. The problem occurred when ##class(SYS.Mirror).PurgeJournalFiles() was called with a "StartFile" that did not exist.

A problem with mirroring has been resolved where rollback would fail if there were two mirror failover events since the transaction was opened.

Previously, if a mirror member failed to complete ECP Recovery it would retry over and over, creating a series of mirror journal files until either it succeeded or it was shut down.

As these problems are fairly rare, and since the process is not likely to succeed on retry without some other intervention, this has been changed so that if ECP Recovery fails, the instance reports the failure and then waits until either the other failover member becomes the primary, at which point the current instance becomes the backup, or until it is shut down.

If the trouble with ECP recovery is resolved the instance can be restarted and it will attempt to become the primary again.

In the future this may be revised to wait for the trouble with ECP recovery to be resolved so the node can become the primary in that situation without being restarted. If the current instance does become the backup, it will retry the ECP recovery should the primary terminate.

This correction fixes a situation where an async member might fall behind the primary's journal point, and when no journal activity on primary the async member could still slowly catch up.

This change corrects an error in shadowing that could cause shadow to get stuck with a persistent <ZFILE> error.

This correction addresses an issue that could cause a cluster shadow to abort when a copying process disconnected (for example, due to network problem) and reconnected.

In the case of a non-cluster shadow, the issue was a performance one -- although it didn't abort, the shadow had to wait until the copying process re-copied everything in the file it was working on when it disconnected.

This correction addresses an issue that caused a %Save() of a shadow object to return <ENDOFFILE> error.

The maximum number of jobservers is limited to the initial pidtab size on OpenVMS. This change increased that number.

Windows failover clusters cannot get the same shared memory allocation on failover node as was running on the main node. This change allows unlimited small page allocations on Windows Version 6 (2008) and above.

This fixes a problem in $System.Encryption.Base64Decode() where a process could get into an infinite loop and hang.

This change adds a new utility to display the per-process globals (PPG) variables on the system. It has the added benefit of writing the output to a specified CSV so that the application may use other tools to display the data. The routine name is ^GETPPGINFO and it is called with 3 optional parameters as follows :

do ^GETPPGINFO([inpid] , [options] , [outputfile] )

where:

This utility must be run from the %SYS namespace.

For example ...

%SYS> do ^GETPPGINFO("*" , "STM1000" , "/home/myspace/ppgout")

displays all processes on this Caché system. The output is in CSV format to file /home/myspace/ppgout. The output is restricted to only those jobs whose total PPG block count is 1000 blocks or more. The "T" option further specifies to output only the process totals, and the "S" option means there is no screen output.

This change fixes a regression 2010.2 that incorrectly generated the entity reference for a non-breaking space which caused unusual characters to appear in the HTML version of a report.

This change modifies the control block to align data items so that references to them do not cause bus errors on 64-bit systems.

This corrects a serious situation that occurs during shutdown. At this time, all outstanding alarm requests are lost. On subsequent startup and resumption of the production, the processes that are waiting on their alarm requests will not receive them.

The change is to save the alarms, preserving them across the shutdown/startup and make them available to the applications when they resume operation.

This change causes the class EnsLib.SQL.GatewayResultSet used by the SQL Adapters to write only complete LOB chunks to the underlying stream global rather than storing each sub-chunk as it arrives over the xDBC channel. This prevents journaling of the partially completed chunk multiple times which reduces the total amount of journaled data to the minimum necessary.

This change increases the TOP clause in the SQL used to purge messages from 1,000,000 to 100,000,000.

When the JDBC Gateway's JVM is restarted while a Production is running and SQL Adapter activity is in progress, it can happen that the Adapter has an open connection instance that is no longer viable. In this case, when the Adapter attempts to prepare a statement, the prepareStatement() command to the JVM will fail. The adapter needs to interpret this as a disconnect event so that it will jettison its connection instance and establish a new one.

This change makes the Adapter detect the failure and interpret it as a disconnect event.

This changes adds support for versioning of CPA instances. CPA instances are now stored using an IDKEY of the CPAId and the Version property. A new instance method BumpVersion() will find the next highest Version number for the specified CPAId. CPA instances can also be "disabled" by setting the new Status property to disabled. A new helper method has been added:

    CPAForCPAId(<cpaid>)

This will locate the CPA instance by CPAId and find the highest version that is marked as active.

Some external situations require that additional XML tags be present in the ebXML Manifest, in this specific case, it is a Payload tag. The existing implementation allowed for this, but would capture the XML as a string in an "any" property. However, this turns out to be useless because the original namespace information was included in the SOAP envelope and unavailable to the user.

This change captures the Payload tag properly.

This change modifies the TimeToLive property of the CPA so it is treated as a string, in an XSD duration format.

Not all users will track messages or associate a deferred response with a message in the message tracker. In this case, where tracking is needed, but responses are not pre-fetched, this modification ensures that Ensemble does not call SendDeferredResponse() unnecessarily.

Some DICOM client software sends empty instances of DICOM transfer syntax specification in the association negotiation phase. While this is confusing, it is not specifically prohibited in the standard. This correction changes the TCP adapter to just ignore the irrelevant data.

The "time created" timestamp was needed for auditing purposes, which was in fact present in the implementation, but wasn't visible to DTL. This change makes it visible.

This corrects a situation where $ORDER or $QUERY would return incorrect results under certain boundary conditions, for example, finding the first item in a newly created local array.

This correction fixes an error where a class load or save across ECP may raise an unexpected error (<ROUTINELOAD> or <STORE>), when the routine object global cache is empty and the load/save references a routine > 32656 chars.

This change redefines /checkuptodate qualifier in Export group to make it compatible with that of the Compiler group, but still accepts the older values of 0 and 1.

This change fixes two problems with the the projection class for the Cache %Time datatype in the C++ binding and Light C++ Binding.

The first problem was that d_time::operator!=(const d_time&) always returned true. The second problem (in Light C++ Binding only) was that it stored d_time in a different format ("hh:mm:ss") from the format used by SQL and other object APIs (which store time as a string representation of the number of seconds elapsed since midnite).

Thus, times stored by LCB could not be correctly read by SQL, and vice-versa. With this change, times are stored in the same format used by SQL, and can correctly read times that were stored in either format.

This change causes MDS to correctly ignore object fields which are defined as interfaces, and do not have any actual type specified. Prior to this change, MDS got an access violation within MDSNodeReference.setTypeInfo if called for a class containing such a field.

The Remote Gateway has a Closed flag that indicates whether its TCP connection to the JVM is open or not. This change ensures that, in disconnecting or failing to connect the Gateway when the connection is unexpectedly lost, the Closed flag is correctly updated.

The SELECTMODE parameter can now be specified for class queries of type %Library.Query. For these queries, SELECTMODE is declarative and it is the responsibility of the query author to properly format the column values according to the SELECTMODE parameter setting. If that setting is RUNTIME, then the current runtime SELECTMODE can be retrieved from $system.SQL.GetSelectMode().

The default value for SELECTMODE for queries of type %Library.Query is LOGICAL. If existing queries are having problems with client software and data formats then the existing query might have to be updated to specify a different SELECTMODE value so that the values as formatted by the query are properly recognized.

This change avoids a situation where an attempt to restart the JDBC Gateway could result in a <SUBSCRIPT> being generated.

This change fixes two problems with the d_time class (the projection class for the Cache %Time datatype) in C++ binding and Light C++ Binding. The first problem was that d_time::operator!=(const d_time&) always returned true. The second problem (in Light C++ Binding only) was that Light C++ Binding stored d_time in a different format (a string in "hh:mm:ss" format) from the format used by SQL and other object APIs (which store time as a string representation of the number of seconds elapsed since midnite). Therefore, times stored by LCB could not be correctly read by SQL, and vice-versa. With this change, LCB now stores times in the same format used by SQL, and can correctly read times that were stored in either format.

This change makes the SQL Adapter JDBC LOB logic ignore $C(0) (Ascii NUL) if it appears as the sole content of a block of data that is not the first block. This works around an error in the lower levels of the JDBC Gateway that causes such a NUL character to be returned if there is no more data after retrieving a full chunk.

This change corrects a situation in SQLServer on 64-bit Windows where different code pages could be used for character translations by the kernel and the ODBC driver resulting in "?" being displayed for unrecogniized characters.

The change causes the regional setting defined as the code page for character trranslations.

This change modifies the Studio client to support loading package information by explicitly specifying the package name when using %Dictionary.PackagDefinition.

This change corrects a memory leak that occurred when importing a large number of files in one operation.

When using private variables within a procedure, a <SUBSCRIPT> or <UNDEFINED> error could be reported as <WIDE CHAR> or could show an incorrect variable name in the error text.

This situation is now corrected.

This change modifies Caché to load the routine and object components in batch mode; after being loaded they are cached in routine buffers and not used again. It also modifies Caché to release the retained buffers after loading a routine.

This modification fixes a problem that could cause an access violation on 64-bit Windows if an application tried to submit a string with surrogate pairs for output translation with a table that does not support this feature (for example, JIS instead of JIS2004).

This change causes the clean daemon to free gfowner resource properly. Previously, the resource was not properly returned.

SIGUSR2 appears blocked on DECUNIX clusters. This change restores its functionality.

This change corrects a timing issue which prevents a single kill command from killing both ISCAgent processes on HP-UX when sent a SIGTERM. The remaining process was preventing the ISCAgent from being upgraded.

This change corrects several known problems that occurred if the backup ran out of space to store a journal file from the primary system.

When the system is configured to do so, mirroring generates the following email level alerts (severe log messages) for:

1. a node becomes the primary (In the future this could be modified to exclude situations where the backup becomes the primary after the primary is shut down gracefully, but for now Caché generates an alert any time a node becomes the primary.)
2. backup disconnects from primary and fails to either become the primary or reconnect as a backup
3. system starts up and fails to become the primary or a backup. This includes async members which fail to connect to the primary at startup.

In addition there are less severe cconsole messages for:

• backup disconnects (warning)
• backup connects (info)
• backup demoted from active (warning)
• backup promoted to active (info)

A problem has been resolved where a backup might fail to take over when agent contact required is set to no and the mirror is idle at the time of the failover.

This change fixes a situation where when the backup node has been down more than 14 days, the primary node might purge the journal files needed by the backup node to catchup.

This change corrects a problem in adding and deleting VIP scripts on SunOS where the check for running as root was improperly done.

When modifying the LockSharedMemory or LockTextSegment parameters in the management portal and setting the value to True, the values written to the memlock= parameter in the CPF file were incorrect. This could cause the memory to not be locked upon a subsequent restart of the system. This has been corrected.

This correction resolves a potential buffer overrun in the function responsible for deriving the path to the Gateway documentation files and templates.

This issue only affects installations with long paths to the Gateway configuration file. Specifically, it applies to installations with paths greater than 64 characters long.

A particular windows DICOM testing tool IQTEST.exe, sends AET names padded with $C(0), which is not recognized by the InterSystems DICOM Adapter. This change corrects this issue.

Note: The problem can be worked around by making both local and remote AET names 16 characters long. This eliminates the padding and allows successful matching

A prior change fixed the logic of replaceSeparators. This correction changes the internal logic in replaceSeparators and replaceArrayLeftToRight to improve the efficiency of the replacement.

The HL7 Message and other EDI VDoc classes have several standard computed properties whose values are drawn from the document content: [type] Name, Identifier, and TypeVersion. This change modifies the way these values are calculated to bypass the ReplaceSeparators() method that was used to normalize the internal structure of these values; instead it uses a simple local $TRANSLATE function call.

This change also reconciled the separators normalization done for Identifier values between SQL and object getter implementations. Formerly the reconciliation was done only in the object getter.

This change corrects errors in the links present on the message resend page in Ensemble.

This change modifies methods CopyFile() and CopyDir() of class %File to take a new (optional) parameter indicating if the file(s) being copied should be deleted (on OpenVMS all versions will be purged) prior to the copy, and makes %EnsembleMgr use this new parameter.

When attempting to run on Windows 2000 or below, the installer now displays an error message and exits.

This change corrects a problem when doing a reverse search using $ORDER in local arrays when the subscript value being searched for does not exist in the array because it was never used or has been deleted.

This change improves the performance of MV BASIC assignments of the form V<-1>=E; by recognizing and treating them as special cases.

In a very rare condition on UNIX® platforms, when

• a job is doing TCP write or send, and
  
  
• at the same time, the connection is in the middle being dropped, and
  
  
• the job doing the TCP operation is being poked by some other process (for example, to get the job state and etc),

when the connection is dropped, Caché may not detect the connection failure and wait forever for the write completion.

Thic change adds support for unicode files in FileRead() and FileWrite() in CharStream and BinaryStream.

This change allows the D_timestamp to be initialized with a string containing only the date part of the timestamp.

This change enables Java applications using callin-based eXTreme APIs (XEP, MDS, eXTreme JDBC or eXTreme Dynamic Objects) to be interrupted/terminated using SIGINT (i.e. control C) or SIGTERM (kill -15) on UNIX® platforms, without risk of hanging the Caché instance. This change applies only to the non-threaded versions of the eXTreme APIs, and only to UNIX® platforms.

A previous change to the server-side code changed callin so that it does not block these signals, and allows users to set their own handlers for them. However, it required application-level code to explicitly block these signals in any threads that call into Caché (which is not actually possible to do at the Java level); to supply a handler which would call CacheEnd(), in a way guaranteed to be synchronized so that no callin calls were in progress in other threads; and to ensure that there was at least one thread that never called into Caché and didn't block these signals, so that the user-supplied handler would be caught in that thread. If an application did not fulfill these requirements, interrupting it could cause the Caché instance to hang, so that it needed to be shut down, or in worse cases, forced to shut down, or even required to be reinstalled.

The present change transparently implements these requirements within the eXTreme APIs, so that application code is not required to do any signal management, define any signal handlers, or do any explicit cleanup of the Caché connection when one of these signals is caught.

Details of behavior: If the application does supply its own handler for either of these signals, the application's handler will be invoked after the eXTreme handler has terminated the Caché connection. If the application has set either of these signals to be ignored (i.e., to set its action to SIG_IGN or the Java equivalent), eXTreme will not set up a handler, and will leave the signal set to be ignored (in which case, it cannot be used to interrupt the application, and there is no risk that its use will hang Caché). When the application disconnects from Caché, the actions for these signals are returned to their state prior to connecting to Caché; if the application then re-connects to Caché, the actions are again set to the eXTreme handlers.

Note that eXTreme sets SIGINT and SIGTERM to be blocked in any thread that calls into Caché, to ensure that these signals are caught in a thread that is not inside a call into Caché. Once eXTreme blocks these signals in a given thread, it never unblocks them, so it is up to the application to unblock them if it has a reason to do so. The application can safely do so, because eXTreme will re-block these signals in a given thread before each call into Caché. This is probably moot, since Java does not currently provide any API for blocking/unblocking signals in individual threads.

If a transaction is in progress when the application is interrupted, an attempt is made to roll back the transaction. However, it is not possible to guarantee that this attempt will succeed. If it fails, a message is posted to cconsole.log, and the transaction is closed.

NOTE: We do not recommend using Control-C or kill -15 as preferred ways of shutting down production applications, especially not while a transaction is in progress. This change is introduced to allow interrupting applications as a convenience during development and testing, or as a fallback approach if they are hung or sluggish, preventing use of the designed approaches to terminating them. Also note that this change does not make it ever safe or advisable to use kill -9 to terminate any eXTreme application. Signal 9 cannot be caught, ignored, or blocked, so there is no possible way of ensuring that an application can clean up its state properly when killed with signal 9. Because eXTreme APIs connect to Caché within the same process, it is essential to interrupt them, if at all, using signals that can be cleanly caught and handled.

This change corrects an issue introduced in 2010.2 that caused %Delete to fail when the class contained a collection of objects stored in a subnode structure (array collections are stored in a subnode structure by default).

This issue affected only persistent classes using default storage that also contained a collection of objects stored in a subnode structure.

This fixes a problem in $SYSTEM.Encryption.Base64Decode where the process could abort if the string being decoded was at the edge of an internal memory boundary.

This change allows multicore UNIX® systems to use master and slave write daemons to encrypt global buffers from encrypted databases in the WIJ image buffer(s) in parallel. Several slave write daemons will be used so the task can be completed in minimum clock time independent of process scheduling.

This currently is enabled on PowerPC and RedHat Linux 64-bit systems only.

This change resolves a problem where $System.SQL.QueryToTable() could falsely report an erroneous line tag.

This change corrects a defect introduced in 2010.2 that made all the character parameters in linked tables (SQLGateway) fail on 8-bit Caché on Windows.

This corrects an error that reported the value incorrectly for SQLGetInfo option 36, SQL_MULT_RESULT_SETS.

Previously, fixes were made for a special condition in RDO where an EOF (End of File) was not being detected properly when RDO was looking for a single character of data from a column. While this is a defect in RDO, it is a heavily-used application, so a special condition was added to support this situation.

This change consolidates the previous changes to make sure all supported releases have the correct behavior. A request for one character of data with a buffer size of one character will not be null terminated and will not return a truncation error. This only applies to numeric data, and is a work around for RDO EOF issues.

Studio would unexpectedly exit when getting selected text. This has been corrected.

Under certain conditions when available partition memory is low, there could be an error in the symbol table leading to a <SYSTEM> error. This change prevents that situation.

This change corrects an issue in isolated cases whereby $ORDER with a reverse search could occasionally return an incorrect subscript key if the subscript key in the $ORDER function did not exist.

This change corrects a situation where, in an attempt to set the priority of a job that did not supply the priority value, the null argument would be interpreted as an argument of zero.

This corrects a situation where an attempt to use FileCompact would fail if the last allocated block of the file matched the number of blocks in the file.

This corrects a situation where attempting to run FileCompact on mirrored databases would sometimes cause an exit with an access violation, thereby producing a core file.

This corrects a situation where a failed attempt to allocate memory for the subscript-level map table was incorrectly handled.

This change avoids a clean daemon access violation while cleaning dead job. This prevents the clean daemon from being terminated by the <ACCVIO>.

This change fixes a problem that occurs when the lock memory is seriously defragmented. Under this condition, it might take a long time to complete the defragmentation and his could hang the system because some some global cache block might be owned by the job doing the defragmentation.

This change corrects a data corruption issue resulting from writing to a file with compression enabled (/GZIP[=1]) on UNIX® platforms.

A necessary condition for the problem to occur is that the file is opened in stream mode explicitly or implicitly. This means that it was NOT opened explicitly in a format that is mutually exclusive to stream mode, such as fixed-length (/FIXED), undefined (/UNDEFINED), variable record (/VARIABLE), and so on.

Under these conditions, there is an approximately 40% possibility that a 32K output (compressed) file will be corrupted.

This change addresses an issue that could cause unexpected behavior from a process switching journal files. The situation is rare and involves journaling being disabled at a certain stage while the journal switch is being done.

This change addresses an issue on Windows and OpenVMS that could cause the current journal file to expand by a fraction of 64KB (a partial journal block) under conditions of disk space shortage. Consequences of this issue include journal daemon spinning on a CPU lock, and/or the system not recovering from the frozen state, when system is set to freeze on errors.

This fixes a problem in ECP lock recovery when server restart or mirror failover. Some lock nodes might still exist in server's lock table while they don't exist in the clients' lock table.

This change addresses timing issues related to the startup of mirrored systems. Under some circumstances, a mirror configuration failed to recover properly if the backup failed to create the ack channel to the primary and the backup restarted before it could join the mirror.

Under others, the MIRRORMGR job on the primary might exit with a <SUBSCRIPT> error due to a timing issue when a backup connects. The primary would need to be restarted before it would accept any subsequent connections.

A problem has been fixed with instances configured with a journal file prefix where a system which failed to become the primary mirror member after switching to a mirror journal file would switch back to a non-mirror journal file which did not include the configured journal file prefix.

A problem has been resolved where the mirror journal log could get out of sync with the actual journal files on disk. This can happen if a journal file is retrieved but the disk becomes full and because of this the file ends up getting stored in the alternate journal location.

This corrects an issue where, in some instances, a failover attempt could transmit an incorrect SuperServer to its partner.

This fixed a problem on mirror failover while an ECP client connected to the mirror and mounted non- mirrored DBs (e.g. :ds:DBNAME or cachetemp directory path) on the mirror primary. If the two mirror members happened to be in the same machine, then the other member might not be restarted if the cachetemp was mounted.

On a Caché system used as source of shadow data, if the total length of the mounted database paths is near or over 16KB, the shadow copy of a source journal file would miss the path of any source database mounted after the shadow copy is created.

This change addresses that issue. The source of shadowing will be updated with subsequent changes.

During a system shutdown, if any process is "jammed", so that it does not shutdown normally, cforce is supposed to be called to clean up the process. This was not happening, so that the process that was "jammed" was left behind after a shutdown. If the process is one of the WD or JD, restart will fail; but in any case, it could cause shared memory to not be released, so that there is not sufficient shared memory to restart at the desired level.

This change prevents that situation.

This change corrects an error in the cstat self-diagnostic facility. If TRACEPGSHARED was enabled, the cstat self-diagnosis for system hangs (cstat -S option) may falsely detect a job as one of the shared owners of a buffer that the job does not actually own.

A change has been made so that on OpenVMS, multiple versions Caché only preserves one version of the file.

© 2011, InterSystems Corporation. All rights reserved.