The current maintenance kits are Caché and Ensemble 2010.1.6. 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.1.6: <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.1: <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.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é 2010.1:

This corrects a situation where Caché would report an error when changing the CSP password when there was none.

Also in the password change page, Caché will now display an error message so if the user enters a password that is too short:

ERROR #845: Password does not match length or pattern requirements

This change corrects a situation where changing the CSP password was handled differently depending which CSP page was used to effect the change. Pasword changes are now done the same way for all code paths.

This change now makes the 'Event Log File' directive works as described in the documentation. In previous Gateway builds, the original (default) log file name and location would continue to be used until the Gateway had fully initialized itself.

This correction resolves an access violation that can occur in state-aware mode if a queued thread was forcefully interrupted by the hosting web server. The CSP Gateway clean-up functionality has been improved such that these error conditions will be avoided in future.

This correction fixes an error in the code responsible for identifying web files indicating a URL requesting Gateway Management forms.

This change ensures that Ensemble will not be in a state where messages are partially processed if a production is not shut down properly.

This corrects a situtaion where an application was experiencing disconnection errors in a production that uses the Java Gateway. This change improves handling of the TCP device when reconnecting.

This change causes the Windows installation process to display a service credentials dialog when upgrading 2010.1.0 and 2010.1.1 builds.

This change modifies Caché to track the journal position while a transaction is rolling back.

Prior to this change, if there was a write daemon pass and then a system failure before an ECP transaction rollback was complete, there was a small chance of losing that active open transaction; also if journal-purge could not see the active transaction, the system might delete the journal while it was being rolled back.

In very rare conditions, if ECP received a request that named an invalid database (because, for example, it had been dismounted), the request may leave an error frame un-popped. After many of these frames the error frame may overflow with unpredictable side effects.

This is now corrected.

This correction fixes a security hole in the $SYSTEM.Security.AddRoles() method. Previously, a user could ZLOAD a privileged routine, ZINSERT some XECUTE code into it, then execute the ZINSERTed code which would leave the user with the %All role when execution finishes.

This change corrects a problem where

CAST(value AS NUMERIC(5,2))

would return incorrect results in display mode when using European-style "," as the numeric decimal separator.

This change fixes a potential problem in cluster failover where:

• if the WIJ of a failed system had blocks to be recovered, and
• if there was only a single block for a given database, and
• that block was the last block listed in the WIJ,

then that block would not be recovered.

The possibility of this set of circumstances occurring is rare, but if it does happen, database degradation could result.

After truncation, the maximum number of maps may be less than shown in the incremental bit maps. This change limits backup processing to the actual number of maps present.

This changes corrects a problem obtaining a license for a WebLink connection when the system WebLink routines are remapped from CacheLib.

This change corrects an issue of "dangling transaction" on ECP server. In this situation, the journal was missing the TCOMMIT record for the transaction after the transaction failed to roll back ("ROLLFAIL") and the system continued from that point because it was NOT set to freeze on such errors.

Prior to this change, when a CPF file was edited Caché did not remove older versions of the file. With this correction, only the most recent version of the file is present; older versions are removed.

This change fixes two issues:

1. If a user changed the location of system databases (CACHE, CACHELIB, CACHEAUDIT or CACHETEMP) by editing the CPF file or by using the Management Portal, the %SYS namespace mapping would not get updated.
2. If a user changed the location of a non-system database using the Management Portal, the namespace mapping associated with this database would not get updated. (If the database location was changed by editing the CPF file, the mapping would be updated.)

This corrects a situation where a routine mapping with type other than ALL would be ignored.

This corrects a situation where Caché would report an error when changing the CSP password when there was none.

Also in the password change page, Caché will now display an error message so if the user enters a password that is too short:

ERROR #845: Password does not match length or pattern requirements

This change corrects a situation where changing the CSP password was handled differently depending which CSP page was used to effect the change. Pasword changes are now done the same way for allcode paths.

This change now makes the 'Event Log File' directive works as described in the documentation. In previous Gateway builds, the original (default) log file name and location would continue to be used until the Gateway had fully initialized itself.

This correction resolves an access violation that can occur in state-aware mode if a queued thread was forcefully interrupted by the hosting web server. The CSP Gateway clean-up functionality has been improved such that these error conditions will be avoided in future.

This correction fixes an error in the code responsible for identifying web files indicating a URL requesting Gateway Management forms.

This change causes the Windows installation process to display a service credentials dialog when upgrading 2010.1.0 and 2010.1.1 builds.

This change corrects a problem where

CAST(value AS NUMERIC(5,2))

would return incorrect results in display mode when using European-style "," as the numeric decimal separator.

This change fixes a potential problem in cluster failover where:

• if the WIJ of a failed system had blocks to be recovered, and
• if there was only a single block for a given database, and
• that block was the last block listed in the WIJ,

then that block would not be recovered.

The possibility of this set of circumstances occurring is rare, but if it does happen, database degradation could result.

This change fixes two issues:

1. If a user changed the location of system databases (CACHE, CACHELIB, CACHEAUDIT or CACHETEMP) by editing the CPF file or throughby using the Management Portal, the %SYS namespace mapping would not get updated.
2. If a user changed the location of a non-system database using the Management Portal, the namespace mapping associated with this database would not get updated. (If the database location was changed by editing the CPF file, the mapping would be updated.)

This corrects a situation where a routine mapping with type other than ALL would be ignored.

This change corrects a situation that could lead to the Gateway Management form for Application Access not displaying properly.

A change has been applied to correct a situation that prevented a cached CSP page from being displayed as the first page in an application.

This change corrects a problem that prevented the gateway from responding to interrupts in IIS version 7 native modules.

The problem addressed by this change only affects users who have user-defined functions in their Rules. In this case, such Rules would not be properly recompiled during an in-place upgrade; in an upgraded system, "Unknown Function" errors would be seen in all Rules that made use of custom functions. This change modifies the way that the functions are retrieved at compile time, fixing this problem.

This change corrects a minor regression introduced in a prior version. The issue involves queries and stored procedures with input parameters where the Execute[Operation]ParmArray() methods are used to allow for detailed specification of the expected input parameters, and either the "SqlType" subscripts or both the "SqlType" and "CType" subscripts were not being populated.

This change adds support to the SQL Adapters in JDBC mode for the methods SetAutoCommit(), Commit() and Rollback(). Formerly these methods were not implemented for JDBC mode.

This change allows setting a segment into an HL7 message by path where the path uses a wildcard. Formerly an error would result because the name of the segment being set did not exactly match the DocType name corresponding to the path- specified segment position. It could not match because of the wildcard segment name. Supported wildcard segment names are 'Any', 'Zxx' or 'Hxx'.

This change resolves a bug in the Message Resend which is triggered by a list of IDs to resend which exceeds 32K in lengthy. Arbitrarily long lists of IDs are now accepted.

This change addresses a problem whereby some search restrictions applied in the Message Search page would not be passed through to the message resend page. The problem would only occur if the search terms were added using the dynamic terms interface and results not present on the page are selected for resend.

This change allows elements in a custom HL7 schema to be used without specifying explicitly that they refer to elements from the declared base schema. If they are found in the custom schema they will be automatically enriched to refer to it; if they are found in the base schema they will be automatically enriched to refer to it. If they are not found at all, that remains an error.

Since Business Rules were introduced in Ensemble, users were allowed to extend the built-in set of functions, creating their own user-defined custom functions that can be used in Rules or Transformations. However, users were never warned about duplicate function names existing in more than one class. The behavior so far has been to silently ignore the duplicates and select the first definition found.

Starting with this change, Ensemble now reports errors in upgrades within file ensinstall.log, and offer a method that users can invoke to check for such duplicates so they can resolve these conflicts: >Write $SYSTEM.OBJ.DisplayError(##class(Ens.Rule.Utils).GetAllFunctions(.func))

After an upgrade, users should now check inside file ensinstall.log, under subdirectory mgr, and ensure that the Rules upgrade went well without any errors.

This corrects a circumstance where, if GCOMPACT was run on a database while it was experiencing <FILEFULL> errors, the resulting database had a corrupted bottom pointer block with loss of data.

Class parameters are now dynamic elements of a class. $$$Text("Text") can only accept string literals as an argument. This meant that the class changes in 2010.1 prevented the following from working anymore:

Parameter PAGETITLE As STRING = "Page Title"; Property PageTitle As
%String [ InitialExpression = {$$$Text(..#PAGETITLE)} ];

Because the ..#PAGETITLE was resolved to $parameter(,"PAGETITLE") and $$$Text did not allow an expression here. This caused an <OBJECT DISPATCH> error at compile time.

Now Caché detects the reference to a class parameter inside a $$$Text macro and replaces the parameter with the current classes value for this and also marks this method as needing to be recompiled in every subclass so they will also get the correct parameter value if the subclass has modified the class parameter.

This change fixes a problem with accessing inherited properties in generated proxy classes.

Linked tables with stream columns use stream OREFS for transporting the stream value. When using %Library.ResultSet to query linked tables, a bug caused the stream OREF to be converted to a string value that effectively caused the stream value to be lost. This bug is now fixed.

This corrects a problem where IN lists were not properly accessing their parameters when they occurred in OR clauses.

When using Source Control for checkout Studio never locked the document for editing, instead relying on the checkout mechanism to lock as needed. This change will execute a Lock after checkout succeeds.

A routine invocation allocated and left the frame stack uninitialized, and if there was an error which required cleanup during the current namespace search, the result was unpredictable. This has been corrected.

In very rare conditions, during the method cache resolution, a class cache definition reference count might not be tracked accurately and the system may release the object definition while it is still in use. This change makes the reference count accurate.

This change corrects an error in handling journal files that had a specified prefix. Under some conditions, the prefix was erroneously treated as the name of a directory. This is now fixed.

This change corrects a problem where supplying a quoted string value of zero ("0") when signalling an event caused the process to crash.

This corrects a problem that occurred when a lock was not taken out while editing a CSP page. If two people were editing the same page, then when one user changed it, the other user would immediately be presented with a message:

'***.csp' has changed, would you like to reload it?

This no longer will happen, the second user will now be notified that someone else is editing it and that they can open it up read only.

This change corrects a problem during the upgrade that caused an < ILLEGAL VALUE> error when converting the journal history global to a journal log.

This correction addresses an issue where journaling would fail if there was a blank line anywhere in journal.log (journal history log file).

This change fixes a situation on OpenVMS where a journal switch might hang. The issue has been identified as a OpenVMS bug, for which HP has produced a patch (unofficial at the time of writing). This change bypasses the OpenVMS issue without requiring customers to have the HP patch install.

This fix corrects issues of converting journal history global to journal history log ("journal.log") during Caché upgrade that could cause journal files created by automatic journal switches or task manager to be missing from the newly created journal log.

This avoids a potential exception that could occur if $SYSTEM.License.Login($SYSTEM.License.GetUserId()) was called repeatedly.

This change corrects a problem which caused a process jobbed from a CSP page not to share a license unit with the CSP session.

Using the "zero statistics" option in ^GLOSTAT can cause the status of databases to become "read-only", and the Caché instance must be restarted to restore them to the original status. This is now fixed.

There is a new section in the CPF file,

[Shadows]
<SystemName>=<Value>

where <Value> can be 0 (stop) or 1 (start). Upon startup, if set to 0, the shadow will not start; if 1, the shadow will start.

The MONAPP process always remains after system shutdown. This is now corrected.

This corrects the checking for whether a [Shadows] section exists in the CPF file, and will prevent a duplicate section from being added.

This change corrects a situation where the copying of a global with a different collation would not always properly resolve whether the global should be skipped or not. Now, it batch mode, it is always skipped; in interactive mode, the user is queried to decide if it should be skipped.

This change ensures that the values assigned to configuration parameters in CSP.ini are always expressed in 7-bit ASCII range. It has always been the convention that text held in the Gateway configuration file should be in English, even though the corresponding text in the Management forms may be localized in some other language. Recent changes had resulted in this discipline not always being followed.

This change makes the Gateway respond gracefully to cases where access to further memory is denied by the operating system. This scenario occurs particularly when buffering huge amounts of response data in order to generate a HTTP content-length header field. Previous versions did not always handle this event cleanly, and an access violation followed by memory leakage could occur.

This change protects against a problem in the IIS v7 Native Modules interface that could cause a memory access violation to occur if an invalid query string was submitted.

This change automatically corrects the session status information in the Gateway connection table where state-changes are made in the form footers and, as a result, are not projected through to the form content. This problem only affects applications that are configured to not use cookies to project the session token.

This correction fixes a mis-routing issue with state-aware applications. This fault would be provoked by the following chain of events:

1. A request from browser A is assigned to Cache process X and marks the session as state-aware (sets Preserve=1).
2. Browser A then issues a new request which terminates the state-aware session (by calling EndSession()). This action sets Preserve=0 and ends the session on the server. However, browser A still has a session cookie marked as state-aware.
3. Browser B issues a request which is assigned to Cache process X (since this has been returned to the pool of state-less connections) and marks the session as state-aware.
4. Finally, browser A (which was left open) issues a request which is erroneously routed to Cache process X (which is now exclusively owned by browser B). Cache responds to this security violation by halting process X.

Under these conditions, the Gateway then records the following error in its event log:

===
Error Condition
CSP application closed the connection before sending a complete response
===

with the end results that the request from browser A fails and browser B is unable to continue.

This modification protects against a potential memory violation in the function responsible for reading data block headers from Cache.

This change allows setting a segment into an HL7 message by path where the path uses a wildcard. Formerly, an error would result because the name of the segment being set did not exactly match the DocType name corresponding to the path- specified segment position. It could not match because of the wildcard segment name. Supported wildcard segment names are 'Any', 'Zxx' or 'Hxx'.

This change makes sure the Windows service will not be deleted when running uninstall sequence on upgrade.

A problem has been fixed that could lead to an invalid name in the global directory. The specific case is using indirection for the global name with the same local variable that is also set in a subscript expression using $DATA, $ORDER, or $QUERY. For example,

SET ^X(3)=4, n="^MyGlobal", @n@($DATA(^X(3),n))="data"

This changes corrects a problem where the %Dictionary.CompiledClass:%ExistsId method would return true for a class that exists but is not compiled yet.

This changes corrects a problem where a stale version of a class could be used when connecting to a version of Caché 2008.2 or older. Now the class is always refreshed for thse versions.

This change corrects a situation where a class method that exited with

Quit (1)

could end up returning the value -1 instead.

If you have a macro definition like this inside an INC file:

#define createNewInstanceExt(%ClassName) ##class(%ClassName).%New()

the the macro compiler attempted to normalize the ##class classname in the precompiled information associated with this INC file.

However, this is context-sensitive and in this class '%ClassName' is just the argument to the macro as well so it is not valid to expand this inside an INC file.

Caché now detects this and avoids expanding this until an application invokes this macro.

This change corrects a situation where a method that just returns the value of one of its arguments could get a <PARAMETER> error when there were two arguments to the method.

This change corrects a problem with method overriding. Suppose an application defined a method, X(), in a superclass, and another method, Y(), that was marked as "codemode=call", and method Y just calls method X.

If the application was changed so that a subclass overrode method, X, the class compiler was not detecting this and calling the wrong method. It now properly invokes the overriding method.

This change fixes an error in the validation of meta information when a class has more than one calculated property that could result in an application crash.

This change corrects a memory leak in the JDBC gateway.

A problem has been corrected where a view would not compile even when the owner of the view has all the necessary privileges on the view query's table(s) granted to the owner via a role.

This corrects a problem where class compilation had been moved to a secondary thread, but the source control informtaion for that thread had not been initialized.

This change modifies the release for cached routines to be more aggressive when the system is out of routine buffers. If a process attempts to allocate another routine buf but all system routine buffers are in-use, the algorithm reduces its own cached routines up to max allowed - 10%. If still no routine buffer is available, then it drops the system wide number of routines cached per process.

While waiting for a job to start, this change alters Caché to handle various cleanup work to prevent possible deadlock, for example, to release some routine buffers for the child process to use.

In a rare condition, if the superclass fails to load because the database is unexpectedly not reachable, it may leave that superclass in a partially loaded state. This blocks loading any derived classes of that same superclass. (They end up waiting forever for the superclass to load).

This has now been corrected.

In cases where CacheIDS<device #>.<inode #> has same value on both nodes accessing a shared disk, confusion can arise. One symptom of this was false status messages being sent which caused the partner node to crash.

This change hardens startup of an instance on a cluster node when the instance is already running on another node.

A message transmission that requires a reply (such as JOBEXAM) may hang forever if the target of the message exits after receiving the message but before responding to the request. This has now been fixed.

This correction addresses a situation where, if the system fails on journal error and FreezeOnError is set, MONITOR does not report the error via email.

This correction fixes a situation where this function returns null even though the underlying operating system services return the actual system name.

This change fixes a situation where the cleanup daemon might failed to clean up a dead job if its resource is used by the cleanup daemon.

This changes corrects an error where, when a job server process was started to perform a database backup it could get access violation.

When the parameter JoinCluster was set to 1 in the CPF file, Caché would increase the parameter MaxServerConn to 14 so other cluster members would be able to connect. This change restores that behavior; it had been removed in version 2009.1,

The inter-cluster ECP session activity is not a regular session, and the journal position is not tracked. This change corrects a situation where if the slave didn't stay idle for > 60 seconds (enough time to clear the old journal position), it prevented purging the old journal files.

The ^DATABASE routine gives an option for File Compaction. This change disables the feature in 2010.1.

This change addresses an issue that could cause, among other problems, journal recovery to fail at Cache startup with a <VALUE OUT OF RANGE> error. In general, the more frequent the journal switches, the more likely this error would occur.

This change fixed a transaction rollback problem when there are BITSET and Global SET journal records on the same global node. Under some circumstances, the SET journal record might not be rolled back when it should be.

This change corrects an error that could insert trailing null characters into the license identifier of a jobbed process that called $SYSTEM.License.Login() if it's parent had also called $SYSTEM.License.Login().

Beginning in Cache 2010.1, a process started by the job command from a CSP page when a user is logged in does not have the correct license Id. Its license Id is the user name instead of username@clientIPaddress. Consequently, it does not share a license unit with the CSP session. This problem does not occur with anonymous CSP connections. This change corrects the problem.

This corrects a problem where, under some rare circumstances, expired CSP sessions may remain in the license "grace period" longer than the expected 5 minutes. This occurs only for Single Server license keys if the interval between the expiration of a single page CSP session and the next license login exceeds 17 minutes.

This changes corrects a situation where cleanup algorithms for processing dead jobs did not properly update the system monitoring counters and statstics.

In previously releases, when a new global subscript-level mapping was detected at startup, Caché validated that the collation of the physical global in the database matched the collation, if the global was populated with data. If the collation did not match, Caché reported an error, and did not save the global SLM mapping.

If the configuration file was edited by hand, this could cause problems at startup when Caché attempted to mount the database.

This has been changed so that Caché only checks the collation when it is entered via the Management Portal. Furthermore, it only checks the collation of the physical global when the mapping entered is a subscript-level mapping.

This corrects a design shortcoming where zenThreadId values were based on server $JOB values instead of logical threads.

If two independent events cause conflicting DOM updates, then the user may be presented with an inconsistent user interface. The $JOB value on the server does not guarantee that threads will not be processed out of order and can lead to false thread assertion problems depending on how requests are processed.

This change uses a unique value generated on the client browser to identify logical threads instead of using the $JOB value from the server.

This change ensures that the terminating CRLF is discarded from the final output stream where response chunking is in operation between CSPnsd and mod_csp, but a chunked response is not expected by the client.

For cases where the client is not expecting a chunked response, the final closing CRLF (after the optional message trailers) will be discarded and not sent to the client.

This change resolves an access violation that could occur if a connection reserved for a state-aware session closed unexpectedly.

This change corrects an issue that prevented DeepSee from exporting data to Microsoft Excel spreadsheets.

This change fixes an erroneous but syntactically legal construction in the getReplyCode() method of the class EnsLib.HL7.Service.Standard. This bug resulted in an <ILLEGAL VALUE> error when an HL7 service is configured with NakErrorCode=ContentE.

When the execution stack is shown for a program that has NEW $NAMESPACE, the NEW was shown as Unknown. This has been corrected.

This item corrects a situation where a terminating quote character was always being appended when building a query string, even if it was not needed. The quote is now added only if needed.

A problem has been corrected where a DELETE trigger could return SQLCODE = -29, field not found under the following circumstance:

• a row was deleted from a table with a statement level AFTER DELETE trigger containing TSQL code
• the trigger code deleted a row in other table which did not have a TSQL statement AFTER DELETE trigger
• the trigger code did have a TSQL statement level AFTER UPDATE trigger

This correction fixes a situation where the ECP server could hang. The circumstance is that a block appears to be queued up to be read by another requestor when, in fact, there is no requestor and the read will never be completed.

This change addresses two issues with Caché routine and class handling:

1. If the class was created from a CSP compile, Caché did not detect that the routines generated were derived from the class created by the CSP compile; this prevented the class descriptor from automatically being regenerated when the class was saved in Studio.
2. If a generated class routine was renamed, Studio would still think it was part of this class and so could attempt to lock the class when editing this routine even though it was not totally separate.

You can not override a calculated property in a serial or a persistent class because it breaks assumptions about storage for this class. This attempt now results in an error message during compilation.

This change corrects a situation where an attempt to unlock object locks could result in some of them being removed from the lock table while still locking the object they refer to.

Streams are queued for deletion when their container object is deleted. The queue of streams to be deleted is maintained in a global. If the stream OID was long, a <SUBSCRIPT> error would be generated. This structure now uses a simple integer subscript to prevent <SUBSCRIPT> errors.

This change corrects a situation where %XML.TextReader failed to read a very long CDATA value. This will also apply to any character, comment or CDATA value.

When using %XML.TextReader with the remove whitespace option (the default) leading and trailing whitespace is removed. However, in certain circumstances, whitespace which was interior to the string could also be removed. This has been corrected.

This corrects an error that could occur when searching a string for a matching substring and using default boundaries as limits for the search.

This change rectifies a defect where mismanagement of static cursors could result in a <STORE> error.

A bug in %ResultSet.SQL processing caused random failures when a SELECT statement invoked a computed column that also used %ResultSet.SQL for its calculation. The defect caused the value of a public variable, %objqacn, to be inadvertently updated by nested statements. The error is now fixed.

This corrects an error where, if the user kept the Find dialog open but closed all document windows, clicking "Find" would cause Studio to fail.

Due to a change in the Windows SDK for Vista and Windows 7 64-bit, the GetPixel and SetPixel functions makes response very slow when a user is entering code that temporarily has a lot of errors. This change mitigates that problem.

If a TRY/CATCH catches an error in a subroutine or method that is called as an argument for another subroutine or method, there would be a <SYSTEM> error when the subroutine with the CATCH quit. This change corrects that error.

A rare problem on Windows systems has been fixed. The circumstances are that the control process resumes a system that had been suspended due to lack of write daemon activity (such as occurs during a long backup), but never wakes up a small number of the jobs that were waiting.

A problem existed where calling $zu(163) to increase the symbol table size following a <STORE> error did not increase the memory ($Storage) available to the process. The problem occurred because a table of internal pointers to available memory segments was exhausted.

The problem is mitigated by reserving one element of the table to insure that $zu(163) is able to increase memory available to the process following a <STORE> error.

In cases where CacheIDS<device #>.<inode #> has same value on both nodes using a shared disk, confusion can arise and a false status indicating a crash can be sent to the other node. This is now fixed.

This change fixes a problem where INTEGRIT did not detect the case where a lower block did not have a right link, even though the upper pointer blocks showed that more data followed. A new error (36) will be reported by INTEGRIT in this case.

A problem affecting OpenVMS Clusters and cluster mounted encrypted databases has been resolved which would have resulted in database degradation if blocks from an encrypted database were recovered from the pij during cluster failover or during cluster recovery at startup.

This change is compatible with the existing cluster code so that a running cluster can be upgraded one node at a time without shutting down the entire cluster. However, it is crucial that encrypted databases must not not be cluster mounted until ALL of clustered instances (for that Caché cluster) have been updated to this version.

This change addresses an issue where journaling would fail to start during Caché startup if the journal.log (journal history log file) contained only a log header, that is, without any journal file entries. In this case, the only message on cconsole.log would be, "Journaling NOT started."

This change corrects an error that could occur during a journal restore of an ECP cluster. Under some circumstances, the last journal records in the restore would not be posted to the database because of an error in waiting for all the records to be written to disk.

A change to the way licenses were reported in 2010.1.0 by $System.License.Login() interfered with license acquisition by Weblink. This is now corrected.

This corrects an issue that caused cluster shadows with a filter to apply an update twice in a row. This unnecessarily inflated the journal files on the shadow side and degraded shadowing performance. It did not affect data integrity, however, as the duplicate followed the original record immediately.

This corrects a defect that could cause a shadow to create a corrupted copy of source journal file and hang in certain circumstances involving stopping and starting journaling on the source side.

A previous change caused %SYS.Namespaces.GetGlobalDest() to fail if a single-level subscript was used as the third argument, and it was not enclosed in quotes. This change restores the previous capability.

This change fixes a mapping error with %-global and an overlap between two range such as:

%Z:%ZeUTT -> DBA
%ZeUTT -> DBB
%ZeUTTX:%a ->DBA

The mapping of %ZeUTT global would be mapped to %SYS instead of DBB.

The ZAUTHENTICATE routine has been updated with information regarding how to change passwords when using Delegated Authentication. A new entry point has been added to the ZAUTHENTICATE routine which handles changing passwords. See the updated ZAUTHENTICATE routine in the SAMPLES namespace for this information.

The "locksiz" entry in the CPF file contains the size (in bytes) of memory allocated for locks. The startup activity rounds up the value to the next multiple of 64 kilobytes. The default is 1,179,648 bytes. On the HP platform, the default is four times the usual default or 4,718,592 bytes.

The range is 65536 bytes up to the gmheap size. If a system needs more room for the lock table, increase the gmheap parameter as well.

The change takes effect immediately without the need for a restart.

When using LDAP for user authentication, if a user entered a username, with a null password, they would always be authenticated and allowed into the system. This is because the operating system LDAP libraries treat this as an "anonymous" bind, and uses the LDAP simple_bind_s function to succeed with a null password.

With this change, Caché tests to see if a null password has been entered, and reject the attempt.

This is a problem only on the following client to server connections:

• Unix or OpenVMS client to any LDAP server
• Windows client to non active directory LDAP server

It is not a problem on a Windows client to a Windows Active Directory LDAP server connection.

Other changes in Caché modified the way events are routed to the zenPageEventHandler, specifically by defining window level on{event} functions. This means that, under Internet Explorer, keyboard events do not propagate up to the window level; any unhandled events that make it past the <body> level of the DOM are discarded from a JScript perspective.

The result is that the default keyboard handler that would be routing keystrokes to individual onkeydownHandler() methods is, itself, never seeing the keyboard events. This is does not happen when using FireFox, but the W3C specification about what is to be done is ambiguous in this area.

This fix modifies the initialization code for Zen Windows to detect the case where Internet Explorer is in use and installs the keyboard event trap at the level of window.document.body so that it is within the chain of handling the raw events.

This changes corrects the problem of improperly displayed characters by always using National Language support for character display.

© 2010, InterSystems Corporation. All rights reserved.