There is no section for 5.0.6.

This section provides a listing of changes between Caché 5.0.11 and Caché 5.0.12.

This document contains several sections:

• Important Caché News, Alerts and Advisories
• A change report description
• A list of changes considered critical for this release
• A summary of changes to the documentation for this release

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 releases of Caché.

The most current list can be obtained from the InterSystems Website.

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 versions of Caché at the InterSystems Website.

From the home page choose the "Caché" tab, and on the "Downloads" menu, select "Documentation and Help Updates" or follow this link.

To help you assess the impact of these changes on your applications, each change description contains a more detailed explanation of the modification.

All changes include a table giving pertinent information on the issue's likelihood, impact of the change, and whether this has already been used successfully in production by other customers. In order to make the information easy to assimilate visually, the tabular information has been simplified to a keyword or two and a value. The full explanation of the keyword meanings are:

• Likelihood - The probability that a user on the affected platform will encounter this issue.

• Risks - An assessment of how likely this change is to introduce additional issues into the application environment.

• Ad Hoc - This item indicates whether this change has previously been deployed in an ad hoc release and successfully used by customers in production.

• Enhancement - This notes whether this change provides new features or capabilities.

Make sure that %CSP.SysConnection (which is used to test connectivity from the CSP gateway to the Caché server) can only be called from the gateway. If it is called from somewhere other than the gateway, it returns an HTTP error - Page Not Found.

If a CSP page specifies a 'ContentType' and also a 'CharSet' then Caché always outputs the 'charset=<charset>' header and uses the requested charset to write the page out.

%CSP.Page does not define a CharSet by default. So this change will only effect pages where ContentType and a CharSet are explicitly defined.

Prior to this change, CSP would only write the 'charset' header out if the ContentType contained 'text/'.

This change corrects a situation where state-aware sessions (preserve mode 1) would occasionally lock-up, especially on Linux systems. In extreme cases, the Gateway could become unresponsive to other users. The cause was an internal memory access violation when responding to a session close or timeout event.

The integrity checking for state-aware connections has been improved and the logic for detecting and responding to closed sessions has been reworked.

Since Release 4.1, Caché has allowed the exponent designator for a number in scientific notation to be either upper or lower case, 'E' or 'e'. However, this is not compatible with some programs written in other dialects of the M language, which recognize only upper case 'E'. Those programs use lower case 'e' as a string delimiter. This change provides a switch which restores the behavior of recognizing only upper case 'E' as the exponent designator. The default behavior will continue to allow lower case 'e'.

To change the value of the switch for the current process, issue

SET oldvalue=$ZUTIL(68,63,newvalue)

To change the default value of the switch for all processes which start after this command is executed, issue

SET oldvalue=$ZUTIL(69,63,newvalue)

If newvalue is 1, both uppercase 'E' and lower case 'e' will be recognized as the exponent designator. If newvalue is 0, only uppercase 'E' will be recognized.

During ECP recovery, all ECP sessions should be reset. This change fixes a problem where some of the previous sessions would not be correctly identified and therefore not reset upon recovery.

In prior versions, ECP client shutdown didn't wait for all connections to drop, and it didn't handle free nodes properly. This change causes client shutdown to scan for all allocated slots.

ECP recovery didn't remove ECP sessions info if the session didn't have any open transactions. Because the session slot was not cleared, on the next system restart it would wait unnecessarily for that client to reconnect.

Prior to this change, on slow machines, the write daemon might not join the cluster failover promptly which caused the failover to hang forever.

This was due to intercluster synchronization overwriting the write daemon recovery state, which prevented the new cluster master from resuming the recovery. This now operates properly.

This change corrects a circumstance where unexpected database errors that occured during ECP client recovery could cause the recovery to hang.

This change corrects the way ECP handles connection states. Prior to this, unexpected errors could result in ECP being hung waiting for a re-connect and the only way to clear it was to restart Caché.

If a job exited unexpectedly (for example, with an access violation), ECP did not clear the pending open transactions for that client. The next job that got assigned to the same process slot inherited these transactions, causing confusion between the client and server states. This change correctly handles the cleanup.

%HALT didn't rollback ECP open transactions when the client journaling was disabled. This change corrects the behavior to rollback ECP open transactions.

If you run $SYSTEM.SQL.TuneTable("Schema.Table",1,1) the Selectivity was not getting saved as part of the Class definition. This has been fixed.

In some rare cases, "method does not exist" errors would be reported when compiling classes. This was caused by an error in determining which methods are inherited from the superclasses. It is now fixed.

When importing a class from an XML file into Caché with a very long implementation (over 64k of data), it was possible to get a MAXSTRING error. The import routine tried to concatenate the beginning of the last line from the first 32k block with the next block and this pushed it just over the 32k limit. Now it keeps the beginning of the last line in a separate buffer and only concatenates this with the rest of the first line from the next 32k block rather than the entire block.

When a reference is swizzled, the modbit for that property is not supposed to change. This changes corrects the behavior; the value of the modbit is unchanged for simple swizzling.

The bitmap extent index for a class is automatically built whenever any index is built and the bitmap extent has never been built. When all instances are deleted from an extent there was a situation that caused the system to incorrectly assume that the bitmap extent index was already built.

This has been fixed by assuring that indices are purged whenever extents are removed. If any instances fail to be deleted successfully, the indices remain.

The SAX parser caches the XML parser it uses for performance reasons. During entity resolution, CacheStreams may be created via callbacks to %XML.SAX.EntityResolver and its subclasses. As a side effect of parser caching, the OREFS of these stream objects are also cached. (They are eventually garbage collected, but in a non-deterministic manner). This causes a problem if the user of the parser were to change namespaces before garbage collection of the stream occurs.

This modification corrects the error by reclaiming the streams as soon as the parse is completed.

When the XML Reader NodeType was 'endelement', the LocalName property returned empty string. This correction makes it return the proper value.

An enhancement has been made to the calculation of a Map's estimated block usage to include information about the fields in map subscripts for the map. Now an index of the form:

^glo("index",Field1,Field2,ID)=""

will have a higher "cost" than an index of the form:

^glo("index",Field1,ID)=""

If the query optimizer can use an index on Field1, the second index should now be chosen.

An oversight has been corrected where a table's query optimizer information was not fully updated until the class was recompiled. This was missed when the extentsize of the table was calculated through SQL Manager's tuning facility.

In the situation where the last subscript defined in a storagemap for %CacheSQLStorage was a constant, attempts to execute a runtime query against this table could result in an <UNDEFINED> error. Whether the error occurred or not depended on the details of the global structure for the storage.

The possibility of this error has now been removed.

Prior to this change, a query that JOINs two tables in a WHERE condition and has an ORDER BY <f1> DESC, <f2> ASC might not return the rows in the correct order. This has now been corrected.

In prior versions, Caché might fail to display the text of a cached query when listing the queries of a namespace. This change corrects that error.

This change corrects a situation where a table which uses %CacheSQLStorage and specifies its own Map RowID Specifications might generate improper map definition code. This causes improperly generated query code for queries against the table.

This change corrects an error in constraint checking. Under some circumstances, the checking of a unique constraint or a foreign key referential integrity check by SQL might produce an <UNDEFINED> error. This happened when an SQL query was needed to check the constraint, and the constraint was on the IDKey field.

Under some circumstances, Caché processes could generate a high CPU load after the user has closed them. The symptom was caused by an infinite loop in the process disconnect logic. This change eliminates that circumstance.

A new checkbox has been added to the DSN configuration screen: "Use Locale Decimal Symbol". By default, CacheODBC sets the default decimal separator to "." to provide legacy support for some customers. Unfortunately, this causes some difficulties with applications like PowerBuilder that prefer to use the decimal separator as defined for the current locale.

Checking the checkbox "Use Locale Decimal Symbol" will use the decimal separator in process and leave its value unchanged. Leaving this unchecked will give the old default behavior of setting the decimal separator in the process to "." regardless of the locale.

This setting is defined for all DSNs on a system as it is a property of the driver when it is loaded. On Unix, setting the environment variable CACHEODBCLOCALEDECIMAL = 1 lets the driver use the Locale's decimal separator value.

Under some circumstances, an SQL query might generate code in a single line which is too long (longer than 4095 characters). This can happen when there are many subscript levels (greater than 15) in the map definition and overriding data access expressions are used in the map definition.

This change corrects the problem.

An error has been fixed where conditions (especially JOINs) on single column idkey columns did not behave properly if the SELECT clause were 'SELECT *'. The suspect behavior could be poorly performing plans or SQLCODE= -400 when the query executes.

In prior versions, choosing to execute a query from SQL Manager, but selecting an option from the menu after the query had been typed but not run, would not execute the query. The option choice and query execution would run properly, however, if you used the keyboard shortcuts to execute it instead.

This circumstance has been corrected.

This corrects a problem that would cause an error handler to be skipped when a lower level error handler issued

ZQUIT 1 GOTO @$ZTRAP.

The problem happened when the lower level error handler set $ZT="". This would cause the ZQUIT 1 command to bypass the next error handler.

The code which cleans up after dead jobs in Caché will now check to see if the job has retained a global buffer and if so, it will free it.

The write image restore program will now refuse to run if Caché appears to be running from the manager's directory specified as part of the restore. A message noting this will be logged in the console log.

A bug in timeout handling for TCP read requests under Caché/Unix has been corrected. It could cause the READ to continue waiting past the specified timeout if the process were probed by ^%SS, ^JOBEXAM, or similar interrupting utility programs.

On Windows systems, Caché processes running in a Windows Command Prompt window or running from a local Caché terminal (the title bar will contain Caché TRM:processId) will be improperly terminated when the user who started them logs out of the Windows Workstation. This improper termination also occurs in Caché processes started via the job command from these processes. This problem has existed since Caché 4.0.

This change corrects this problem by establishing a console control handler to catch the Windows Logoff event and exit Caché normally. It also changes the way processes started by the job command are created so they will persist following logout from the Windows Console.

Users may encounter one different behavior in processes started by the job command. Since the process is started by the Caché control process at the request of the Caché foreground process, the jobbed process no longer runs in the login session of the user at the console who created the process with the job command. This means that on Windows XP, the process created by the job command will not be able to access network devices using the drive letter mappings defined for the user logged into the Windows console. You should use the UNC naming convention (that is \\server\share...) instead of the local drive mapping (eg. w:\...) in your code to access network shares from processes started by the job command.

This corrects a rarely occurring situation where using JOBEXAM to view a process could cause that process to crash and get an access violation. This happened in the case where the examined process was completely out of process-private memory.

When an MSM job with a large internal job number accesses a remote Caché system using DDP, it may get <DSTDB> error.

This change fixes this problem.

This change corrects a problem with cluster failover failure when the master node is shut down. The source of the issue is that write daemon failed to notify the shutdown requestor when it finished causing a long delay. Also, the ENQ daemon has to be forced down when the cluster node is shutdown.

On a cluster platform, a situation may occur during backup if the procedure to block and quiesce updates/accesses gets an error or fails to quiesce. The problem is that switches set locally but outside the backup program may get cleared during backup.

This change corrects the issue.

This change eliminates a small timing window where a ^LOCKTAB or ^$LOCK SSVN could get an access violations when there is a large volume of lock table activity.

CLU^SWSET, ENQ10^DBACK and ENQ13^DBACK have been enhanced so that timed locks will not time out while switch 10 or 13 is set in a cluster.

This change eliminates potential <SUBSCRIPT> errors during journal restore and transaction rollback.

In interactive mode, journal restore prompts for transaction rollback if some transactions remain incomplete at the end of restore. This happens even if the current journal file is not involved in the restore.

This change addresses a problem with locating the next journal file. In earlier versions, Caché could incorrectly compute the next journal file name. This has now been corrected.

Cluster journal files are logged in cachejrn.log in the pij directory of a Caché cluster. This log, cachejrn.log, is used by cluster journal restore and cluster shadowing to locate every journal file used by any past or present node of a Caché cluster.

This change causes failures in logging the journal file name in cachejrn.log to be reported in cconsole.log.

On VMS, updating cachejrn.log allows read sharing, eliminating a potential cause of update failure in lieu of cluster shadowing.

This change corrects a circumstance where the beginning offset of an open transaction was set to a value smaller than it should be. This did not affect transaction rollback but could affect those applications that assume the return value points to a valid journal record.

This corrects an issue on OpenVMS that may cause a copier on the source side of fast-mode shadowing to get occasional <ENDOFFILE> errors when reading a very small journal file.

This corrects an issue that could result in unnecessarily many small journal files when the amount of free space on the journal disk is less than the expansion size of the journal file.

Fast-mode (aka "block-mode") shadows are now transaction aware and maintain a list of incomplete transactions that are applied on the shadow. To roll back incomplete transactions, stop shadowing and execute

SET rc=$$ROLLBACK^SHDWCBLK(ShadowID)

where ShadowID is the name of the shadow, and "rc" is the result code for the operation: 1 = success and 0 = failure.

This corrects an instance where choosing "this system as source" in control panel may not show any server info (and may get an <UNDEFINED> error) even if there is a running server servicing a shadow.

This change improves the error recovery processing in shadowing by addressing an issue affecting how stack was unwound when errors are passed on to upper level routines.

This change does two things:

1. It prevents occasional <NOTOPEN> errors (generated from updjrninfo^JRNINFO) on the cluster data server ("source") of shadowing.
   
   
2. It allows multiple jobs on the source to open CACHEJRN.LOG file for READ simultaneously, resulting in some degree of performance improvement on journaling and shadowing.

This change corrects a problem where the source of fast-mode shadowing (i.e., data server) on OpenVMS might get occasional <ENDOFFILE> errors.

This change corrects an issue that some component of cluster shadowing might use more process memory than specified in Caché configuration.

Updates to ^%SYS("JRNINFO") by JRNINFO server are no longer journaled.

This addresses an issue of cluster shadowing where the shadow of a source server with no user activity is constantly seen as busy if ^%SYS("JRNINFO") is marked journaled (or "journal all globals" is set in 5.0.x).

This change corrects a performance issue where each cluster shadow request resulted in a JRNINFO server being jobbed off. Now, JRNINFO servers corresponding to a cluster shadow stay around whenever possible.

This change corrects a situation where the control panel could report an <UNDEFINED> error when attempting to manage a cluster shadow, if the system running the shadow was different different in kind from the system running the cluster. An example of this would be a Windows system shadowing a VMS cluster.

A correction to compatible-mode (record-mode) shadowing has been made to prevent the source of shadowing from sending journal records to the shadow destination which have not yet been written to the current journal file

This corrects a problem where the source of shadowing could get transient <FUNCTION> (or other error) while processing the current journal file during a journal switch. It also corrects an issue where, if the source of compatible-mode shadowing crashes, the shadow destination may have more recent completed transactions than what is available on the source after recovery.

Shutting down Caché on a Windows Terminal Server system can leave a cache.exe process attached to the shared memory object if ^SHUTDOWN takes more than about 3 minutes. This residual cache.exe process prevents the configuration shared memory from being destroyed at shutdown. This prevents Caché from being restarted without either rebooting Windows or terminating the residual process with the Windows task manager.

This change properly shuts down all the processes.

Prior to this change, Caché would refuse an attempt to define the shadow for a cluster to be a machine type that did not itself support clustering. This has been corrected.

This fixes a problem in integrity checking of very old ISM databases. Running INTEGRIT would give false errors when global name is not in the top pointer block.

This corrects the issue so that the error is only given when there really are duplicate pointers in the global directory.

In prior versions, when saving MAC/INC from Studio, the data stored in ^rMACSAVE or ^rINCSAVE had the root node incorrectly formatted. This should be the $horolog value of the time this MAC/INC was last changed.

This change sets the proper value in place.

The content of the Caché documentation evolves from release to release in response to editorial improvements, updates to existing material, and addition of new information. The following is a summary of the most noteworthy changes to the Caché documentation since the previous release:

• Caché I/O Device Guide
  • Added further explanation of RMS file open mode parameter restrictions
  
  
  
• Caché ObjectScript Reference
  • OPEN command: removed the RMS file subsection
  • $ZSEARCH function: Windows-specific behavior
  
  
  
• Caché SQL Reference
  • Corrected NULL and empty string usage/representation throughout
    • CAST
    • CHAR_LENGTH
    • CHARACTER_LENGTH
    • LTRIM
    • RTRIM
  • Clarified case-conversion functions functionality and use throughout
  • %ALPHAUP: added Unicode and cautionary examples
  • ALTER TABLE - added 5 restrictions:
    • alter column with streams data
    • add primary key constraints for IDKey and index
    • drop constraints for foreign key and IDKey
  • ALTER VIEW:
    • added WITH READ ONLY and WITH CHECK OPTION to syntax
    • explained privileges requirements
  • CALL: added embedded SQL support
  • CHAR: corrected for Unicode characters, non-numerics
  • COALESCE: clarified string and number handling
  • CONCAT: replaced the prior description with a new one
  • CONVERT:
    • added second syntactical form
    • added description for SQL_DOUBLE data type
  • CREATE INDEX, DROP INDEX: added descriptions of the restrictions when there is existing data
  • CREATE FUNCTION, CREATE METHOD, CREATE PROCEDURE, CREATE QUERY: detailed description of SELECTMODE and RESULTS clauses, when PROCEDURE keyword unnecessary
  • CREATE TABLE: added all 9 collations, more no-op keywords, and security configuration
  • CREATE TRIGGER: updated the description of the ORDER algorithm
  • CREATE VIEW:
    • fixed WITH CHECK OPTION error in syntax
    • added privileges requirements and security configuration
  • DROP TABLE: added privileges requirements and foreign key restriction
  • DROP VIEW: documented the restriction when the view is non-existent
  • GRANT: SQL security configuration options added
  • INSERT: RowID restriction described
  • LENGTH: added second syntactical form
  • ROLLBACK: Cached Query exception explained
  • SELECT: expanded extrinsic functions description; reworded SELECT * note
  • TRUNCATE: documented the handling of numeric literals that represent numbers too large or too small
  • WEEK: fixed the algorithm for calculating the week of the year
  • SQL Concepts:
    • Comments: added the list of variables in .INT code
    • Data Types: added BIGINT and notes on streams
    • Host Variables: added notes on undefined variables, OREF dot syntax, and listings in .INT code comments
    • Identifiers: Added the description of the IsValidRegularIdentifier method and its invocation as procedure call
    • Literals: Completely rewrote the material
    • NULL: added new page on NULL and empty string usage
    • Reserved Words: documented the $SYSTEM.SQL.IsReservedWord method as procedure call
    • Transaction: described the conditions under which cached queries are excluded; described the uniqueness lock
    • Error Codes:
      • added 16 new code values to list and to descriptions of commands
      • added $SYSTEM.SQL.SQLCODE() method and procedure call

These are in addition to minor enhancements in examples, as well as corrections and improvements to grammar and spelling.

This section provides a listing of changes between Caché 5.0.10 and Caché 5.0.11.

This document contains several sections:

• Important Caché News, Alerts and Advisories
• A change report description
• A list of changes considered critical for this release
• A summary of changes to the documentation for this release

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 releases of Caché.

The most current list can be obtained from the InterSystems Website.

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 versions of Caché at the InterSystems Website.

From the home page choose the "Caché" tab, and on the "Downloads" menu, select "Documentation and Help Updates" or follow this link.

To help you assess the impact of these changes on your applications, each change description contains a more detailed explanation of the modification.

All changes include a table giving pertinent information on the issue's likelihood, impact of the change, and whether this has already been used successfully in production by other customers. In order to make the information easy to assimilate visually, the tabular information has been simplified to a keyword or two and a value. The full explanation of the keyword meanings are:

• Likelihood - The probability that a user on the affected platform will encounter this issue.

• Risks - An assessment of how likely this change is to introduce additional issues into the application environment.

• Ad Hoc - This item indicates whether this change has previously been deployed in an ad hoc release and successfully used by customers in production.

• Enhancement - This notes whether this change provides new features or capabilities.

A new CSP parameter, Hyperevent Implementation, has been added.

New CSP Applications will be created with the Hyperevent Implementation parameter equal to "Select on server". On upgrade, existing CSP Applications whose Hyperevent Implementation parameter is missing will have it created with the value "Use Java applet".

This change introduces the optional use of the XMLHttpRequest Javascript object to implement #server. The actual method used to implement #server is determined by a new Configuration Manager parameter for CSP applications, called "Hyperevent Implementation". "Hyperevent Implementation" has four possible values that determine how #server is implemented:

• Use Java applet for #server
• Use XMLHttpRequest Javascript object for #server
• Select implementation using browser Javascript
• Select implemetation using HTTP_USER_AGENT on server

where:

• "Select on server" means CSP pages that use #server will include either an applet tag OR Javascript to use the XMLHttpRequest object; the selection will depend on the server HTTP_USER_AGENT CGI variable. This option, "Select on server", is the default.
  
  
• "Use Java applet" states CSP pages using #server will always supply an applet tag identifying the CSP Java broker applet; #server will always use this applet.
  
  
• "Use XMLHttpRequest object" indicates CSP pages that use #server will always include Javascript that uses the XMLHttpRequest object to implement #server.
  
  
• "Select in browser" means CSP pages that use #server will include BOTH an applet tag and Javascript to use XMLHttpRequest. The method used will be chosen based on the availability of the XMLHttpRequest object to the Javascript code in the browser.

In &html 3.2 compatibility mode, CSP will ignore < or > within <% ... %>. This is meant to handle constructs like

&html< <% w "first->last" %> >

which are encountered in Cache 3.2 WebLink applications.

This change improves the validation of the session token's fields after a failover (or web server/NSD restart) situation.

Previously, a request could be directed to an incorrect (or unexpected) Caché server after a web server/NSD restart. This issue could also result in requests in Virtual Host configurations being directed to incorrect (or unexpected) Caché servers. The term, 'unexpected' Caché servers, means a Caché server configured as an alternative to the main (or default) server).

Editing the Gateway's server and/or application configuration on web server/NSD startup would make problems of this nature more likely to occur.

This change corrects an issue in the transmission of form data in which CSP* variables (e.g. CSPToken) were placed at the end of a form posting more than 8K of data. The problem manifested itself as such forms failing validation checks on submission ('Illegal CSP Request' errors).

This change ensures that Gateway error messages sent in response to SOAP-based requests are formatted as SOAP fault messages (as opposed to HTML).

For example, if the Gateway is unable to connect to the Caché server for the purpose of servicing a SOAP request, the following SOAP fault will be returned:

HTTP/1.1 200 OK
Content-type: text/xml
Connection: close
Expires: Thu, 29 Oct 1998 17:04:19 GMT
Cache-Control: no-cache
Pragma: no-cache

<?xml version='1.0' encoding='UTF-8' standalone='no' ?>
<SOAP-ENV:Envelope
   xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
   xmlns:s='http://www.w3.org/2001/XMLSchema'
   SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
<SOAP-ENV:Body>
<SOAP-ENV:Fault>
<faultcode>SOAP-ENV:Server</faultcode>
<faultstring>CSP Gateway Error (version:5.1.0.423.0 build:663.775)</faultstring>
<detail>
<error xmlns='http://tempuri.org' >
<special>
Server Availability Error
</special>
<text>
Server is currently unavailable
</text>
</error>
</detail>
</SOAP-ENV:Fault>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

It should be noted that this facility can only work if the Gateway can identify the incoming HTTP request as a SOAP-based request for information. This may not be possible if a request for a SOAP-based response is made via the HTTP GET method. It is, however, recommended that requests for SOAP-based services be made through HTTP POST (or related) methods. If the HTTP POST method is used, the Gateway can identify SOAP-based requests by the associated content type.

A message is displayed when a HyperEvent method's argument length is > 32000 characters. With this change, the argument will not be displayed since it detracts from the clarity of the error message.

This changes corrects a situation where the packet-driver for Windows 2000/XP and 2003 Server did not properly report all the network cards it had bound to.

When $ORDER didn't find an answer across ECP, it sometimes left the global vector naked reference invalid. This caused a subsequent $ZREFERENCE to fail with wide character error.

This change prevents that from happening.

Prior to this change, the Caché packet driver would cause a fatal Windows error when invoked on systems containing more the two processors. This no longer happens.

This change corrects a problem where attempting to define an index involving the %ID token would fail.

The maximum routine size has been changed from 40k to 32k. This will result in smaller OBJ routines and, for large source files, more routines generated. This adjustment was necessary in order to load files with methods with more than 32k of source code.

This corrects an oversight where the status code from the compile was only being returned if the compiler flag to display errors was set. Now the status code is always returned.

If you write a generator method the compiler was not making sure that any variables you create in this generator do not end up in the partition. Now an exclusive new is done before running generators for a class to prevent this possibility.

If you open an existing file stream stored in a directory other than the current default directory (the one with the CACHE.DAT file in it for this namespace) then the MoveToEnd method would fail to work correctly. This change corrects the problem.

The default global name generator used by the default storage class has been improved.

• First, the package definition 'package prefix' is retrieved. If it is empty then the package name is used for the package prefix. A default global name is generated by taking the package prefix, class name and adding a suffix character.

  If the resulting string is less than the maximum global name length then it is used.
  
  

• Otherwise, the class name is hashed into a string that is one half the maximum global name length. The package prefix is hashed into a string that is one character shorter (to allow for a '.') than the remaining maximum global name length.

This change corrects an issue in the class compiler. In constructing the initial expression for stream properties, it did not properly handle values that contained quote characters. This has been corrected.

This change corrects a problem in the FindAt method in %Stream.Object. The method would not calculate the correct position when it had read in two or more 20,000-byte chunks of data.

If the global ^%SYS("TempDir") is defined, this is now used as the temporary location for stream data.

If this is not defined, then Caché will use "" as the directory. This puts the stream data in the current directory which is normally the location of the CACHE.DAT file.

This change introduces a new class %GTWConnection. Its %OnClose method disconnects an active connection if the gateway is terminated.

The Caché ODBC driver has been externally thread-safe for quite some time now. For example, if two threads were simultaneously operating on the same statement object, Caché ODBC driver guarantees there will be no conflicts.

This change fixes the instances internally where there were thread-related issues that could result in "message sequence errors".

This change improves error handling in cases where ODBC terminates abnormally and error recovery actions by the application override the default actions taken by the operating system.

A problem has been fixed in ODBC/JDBC. The first time a query is Prepared, if

• a Cached Query exists for the statement, and
  
  
• the user is privileged for the statement,

an <UNKNOWN ERR> would get passed back to the client under some conditions.

This changes corrects a situation where a decimal literal in the first column of a SELECT statement, for example,

SELECT 0.1, F1  FROM TESTCASE1234

would prevent parameter replacements from being made.

This change corrects an error that caused compile-time <UNDEFINED> errors in SELECT statements with OUTER JOINs when certain CacheSqlStorage "general mapping" features were used.

This change optimizes streamless (sub)expressions (i.e. expressions without any fields) in SELECTs and a few other places by evaluating them only once at the beginning of the query.

This change corrects an error in optimization where certain query conditions were "pushed down" and applied within the evaluation of a view that has a GROUP BY clause. This occurred in cases where the condition included a unary operator or a {d ...} date expression.

This change remedies a situation which caused incorrect processing or a likely run-time <UNDEFINED> error when

• there were a large (more than 250) number of expressions, and
  
  
• these expressions had to be evaluated at the beginning of the query.

An example of this is an IN condition on a collated field with more than 250 constants.

Caché SQL now supports a datepart of "ms" or "milliseconds" for the DATEADD and DATEDIFF functions.

We also now support SQL_TSI_FRAC_SECOND for the ODBC Scalar functions

• {fn TIMESTAMPADD()},
  
  
• {fn TIMESTAMPDIFF()}.

This corrects an instance where a query can return incorrect results when

• there is a WHERE clause condition selecting attribute values less than a negative value, for example, f < -5,
  
  
• there is an index on that column, and
  
  
• some of the rows are null in that column.

An error has been corrected where a field value that used the SPACE collation compared against NULL was not returning the correct results. For example, a query like:

SELECT count(*) FROM SQLUser.MyTable WHERE MyField IS NULL

return the incorrect results if MyField's collation was SPACE.

This change adds a new feature. Previously, you could never use <viewcolumn>->x syntax. Now, if view column maps to a base table column that supports arrow syntax, the view column will support it as well. Note that arrow syntax referring to a child table from a parent table is still not supported for views because there is no way to specify whether the child table pseudo column is 'selected' by the view. In addition, this new feature will not work for views defined by SELECT DISTINCT, or aggregated views, or UNION views.

Another new feature is that special columns %ID, %CLASSNAME, %TABLENAME now work with arrow syntax. Thus ref->%CLASSNAME will return the name of the referenced class.

Addressed a problem where $SORTEND may generate a <STRINGSTACK> error when there are many SETs (hundreds of thousands of, or even millions) to sort.

Under some circumstances $SORTEND would generate an access violation or <SYSTEM> error.

A problem has been resolved which could cause access violations on OpenVMS from certain block split operations in 8KB databases when more than 2GB of global buffers have been allocated.

A small problem in the internal mailbox code on VMS systems has been corrected. This could have caused corruption of data being returned on Caché's internal string stack in certain rare circumstances, particularly during reads from TCP/IP devices.

Under some circumstances, when a sufficient number of KILLs have been done to reduce the number of global directory blocks needed by 1, the consolidation of directory blocks can cause a <DATABASE> error during dismount.

ECP is more likely to provoke this rare problem but it can occur without any ECP.

This change rectifies that possibility.

This change addresses a situation with journal restore when using a journal filter where SETs may not get applied to the destination databases.

the wait time in Caché backup, and other places where the system waits for quiescence, has been extended. If, after the timeout period has expired, the system is quiet except for the write daemon, the timeout is extended for up to 2 minutes to wait for the write daemon to finish its current pass.

Previously on systems where the write daemon routinely took more than the allowed timeout, a backup might never succeed.

This change corrects a situation where Wndows startup would take a long time whenever

• the Caché configuration was marked as automatically starting service in the system, and
  
  
• a recent (i.e. after TTS031) packet-driver had been installed.

^%GCMP didn't work across ECP. It was looking for a legacy net connection id

NET(1,"ACTIVE","CPNU",<connection name>)

which wasn't set.

This change corrects a problem where globals in the ISM pre-6.2 collation that had a particular data pattern (final subscript of any global node ending with $C(1)) could cause problems. The particular symptom that was reported is a failure to convert the node properly when using GBLOCKCOPY.

The content of the Caché documentation evolves from release to release in response to editorial improvements, updates to existing material, and addition of new information. The following is a summary of the most noteworthy changes to the Caché documentation since the previous release:

• High Availability Guide
  • Reorganized the material and added a chapter called "Cluster Journaling" which covers cluster restore, recovery, and shadowing
  • Reorganized ECP information by removing a large amount of material from the GHA ECP chapter and moving it to the Distributed Data Management book, including a new appendix of guarantees and limitations
  
  
• Supported Platforms and Windows Installation
  • Added SP2 for XP
  
  
• Cache ObjectScript Reference
  • Added time formats 5, 6, 7, & 8 to $ZDATETIME, $ZDATETIMEH
  • Rewrote $ZTIMESTAMP special variable for local time variants (Daylight Savings, etc.) and Time/Date interactions.
  • Added class info section to $JOB special variable
  
  
• Cache SQL Reference
  • Rewrote and expanded CREATE TRIGGER, DROP TRIGGER, Triggered Action pages
  • Rewrote and expanded UNION page
  • Rewrote Identifiers page, with updated character & length restrictions
  • Added naming conventions/name conversions sections to CREATE TABLE (table name & field name), CREATE VIEW, CREATE INDEX, CREATE TRIGGER
  • In SELECT specified naming conventions for AS clause values
  • Added features to GRANT command
  • Added note to SELECT on use of asterisk option
  • Expanded the material on the UPDATE command, the Symbols table, and the SQLCODE error code list
  • Documented schema names, package names, and Configuration Manager schema default in CREATE TABLE and CREATE VIEW.
  • Completely rewrote Table page, renamed as Table Reference with new syntax and description.
  • Improved the clarity of the examples illustrating the difference between the HAVING and WHERE clauses.
  
  
• Cache Class Reference
  • Corrected EXTENTQUERYSIZE and EXTENTSIZE
  
  
• Organizational Changes
  • Re-ordered the sequence of book collections on the documentation home page and also re-ordered the sequence of books with each group. Prior to this, they had been sorted alphabetically; now they appear with the more important topics first.
  • Changed the title of the short articles section from "Caché Knowledge Base" to "Technical Articles" to make it more explanatory.
  • Reworded the page headers to say "InterSystems Online Documentation" instead of "Caché Online Documentation".
  • Added a new home page item called "Documentation List" which provides a list of the titles for all the books and all technical articles sorted alphabetically.

These are in addition to minor enhancements in examples, as well as corrections and improvements to grammar and spelling.

This section provides a listing of changes between Caché 5.0.9 and Caché 5.0.10.

This document contains several sections:

• Important Caché News, Alerts and Advisories
• A change report description
• A list of changes considered critical for this release
• A summary of changes to the documentation for this release

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 releases of Caché.

The most current list can be obtained from the InterSystems Website.

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 versions of Caché at the InterSystems Website.

From the home page choose the "Caché" tab, and on the "Downloads" menu, select "Documentation and Help Updates".

To help you assess the impact of these changes on your applications, each change description contains a more detailed explanation of the modification.

All changes include a table giving pertinent information on the issue's likelihood, impact of the change, and whether this has already been used successfully in production by other customers. In order to make the information easy to assimilate visually, the tabular information has been simplified to a keyword or two and a value. The full explanation of the keyword meanings are:

• Likelihood - The probability that a user on the affected platform will encounter this issue.

• Risks - An assessment of how likely this change is to introduce additional issues into the application environment.

• Ad Hoc - This item indicates whether this change has previously been deployed in an ad hoc release and successfully used by customers in production.

• Enhancement - This notes whether this change provides new features or capabilities.

ECP can survive server restarts and crashes without any client application involvement. During startup, if there were any ECP client open transactions, the open transaction journal offset got stored in the ^%SYS("ECPDELAYTR") global in case the system crashed again. The global was never killed after successful ECP recovery.

So after many hours or days, if the system is restarted (for any reason) it scanned from that remembered journal offset, which could be many journal records. This would cause the next system restart to take a long time, and some of the journal files may possibly have been deleted, which will abort the rollback because of missing journal file.

With this change, the information will be maintained in the WIJ file.

An XML file such as this example

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE note [
 <!ELEMENT note (to, from, heading, body)>
 <!ELEMENT to (#PCDATA)>
 <!ELEMENT from (#PCDATA)>
 <!ELEMENT heading (#PCDATA)>
 <!ELEMENT body (#PCDATA)>
]>
<note>
 <to>Tova</to>
 <from>Bill</from>
 <heading>Reminder</heading>
 <body>Don't forget the party this weekend!</body>
</note>

containing a DOCTYPE but no SYSTEM or PUBLICID caused

ERROR #6301: SAX XMLParser Error: Unknown Error.

This change accommodates the missing information.

An error has been fixed which prevented the creation of a view against a table linked via the SQL Gateway. With this change, SQL can now create such a VIEW. Previously, this operation would report that the table had no Master Map definition.

A deficiency has been fixed in which the insert/update of a serial field's values through SQL might not be stored properly in the database. The error occurred when the serial field was stored in a global node by itself (without any other fields stored in the same node).

In previous versions of Caché, fields using a Space collation in a CacheSQLStorage subscript expression of the form " "_{FieldName} were treated as expressions rather than collated field values. This made the SQL Query Optimizer less likely to use the index.

This is now corrected.

A problem was fixed where an OUTER JOIN could sometimes behave like an INNER JOIN. This occurred when the join column of the left side of the left join is an IDKEY, while the join column from the right side is an indexed column that has a collation different from EXACT.

This change corrects a problem in SQL Manager's export and import class methods, %SQL.Export.Mgr.DeleteExportRoutine and SQL.Import.Mgr.DeleteImportRoutine, that prevented generated routines from being later deleted.

This change resolves a problem that could cause access violations in OpenVMS during certain block split operations in 8KB databases. The problem occurred when more than 2GB of global buffers had been allocated.

This fixes an error in $BITLOGIC where empty strings would not get negated correctly if there were a length present and only one argument, i.e. $BITLOGIC(~x,len).

This fixes a problem with $BITLOGIC(X) for certain values of X. A spurious error would be reported when the following conditions were met:

• X was stored as a bitmap whose last byte was 1
  
  
• (($BITCOUNT(X)-1)/8+5)=$LENGTH(X)

This change corrects a condition that resulted in the generation of an invalid bit string from $BITLOGIC(u ^ v) (i.e. XOR operation). The error occurred on Unicode databases when one of the operands was compressed and the other was not.

This change corrects an error where, under circumstances requiring conversion from bitlist to bitmap, an incorrect result could occur using the & (AND) $BITLOGIC operator. This only occurred on Unicode installations.

When the DCP daemon is shut down, it will roll back all opened transactions by remote client jobs. However, it intermittently failed to record the restored globals into journal file. This caused the globals set be back to the pre-rollback value when the server is restarted.

This change corrects that occurrence.

This change addresses a problem with journal restore involving a CACHETEMP database of specified max size (i.e., max explicitly set to a value greater than zero). Under some circumstances, users could experience a <SUBSCRIPT> or <UNDEFINED> error during journal restore.

This change corrects the following problems with cluster failover (after a node crash) or cluster recovery at startup (after cluster crash):

• <NOTOPEN>main+1^JRNCLFOR, an error that would result in cluster hanging (in the case of cluster failover) or startup aborting (in the case of cluster recovery);
  
  
• incorrect data, as the result of journal records being restored in the wrong order.

A problem which could cause a pause in the write daemon cycle on a Tru64 cluster system has been resolved. Since global updates are locked out during this phase of the write daemon cycle, this appeared to an application as a global module pause.

A problem with clusters where the write daemon would get stuck in an infinite loop if it encountered a problem completing its portion of cluster startup has been resolved.

This was found during internal testing, it has never been seen in the field.

A problem has been fixed that could lead to file handle and memory leaks with JOB servers, mostly on Windows platforms.

Journal start used to abort when the name for the new journal file was taken by an existing file other than a valid journal file. The new behavior of is to skip the non-journal file and use the next available name for the new journal file.

A warning message is also displayed in cconsole.log.

In previous versions, some settings affecting globals may not have taken immediate effect in existing processes. This was due to the fact that global vectors were cached locally in the process.

The system setting that dictates whether all or selected globals are journaled fell into this category.

This change enables the change of the system setting of journaling to take immediate effect, even in existing processes.

This change corrects a problem where incomplete transactions involving databases redirected elsewhere in the journal restore were not rolled back properly.

The problem is present in all Caché releases.

There was a problem introduced by a change to version 5.0.5.

If a clustered system crashes shortly after journaling switches/rolls-over to a new file, open transactions may not be properly rolled back during the subsequent cluster recovery or failover.

This change corrects that circumstance.

This changes corrects a problem in 5.0 where the descendants of a KILL of a global node are journaled if the global is marked for journaling, even though the KILL is NOT part of a transaction. It would be the correct behavior if the KILL is part of a transaction, but in this case it is not.

Cstat has been enhanced with the “-j16” option to display jobs, if any, queued for synchronous journal I/O. For example,

Sync I/O queue (job:iowake:nextjob): 16
   15:0:   13,   16:0:   15

The job # at the end of the line "Sync I/O queue" is the head of the queue. It is followed by a list of jobs on the queue (not necessarily in their order on the queue) that are NOT the last entry on the queue. The nextjob field is the job # following this entry. In the example above, the actual queue is:

head = job #16 -> job #15 -> job #13 = tail

Job #13 is not shown in cstat because it is the last entry on the queue.

This addresses a potential problem that might cause jobs to hang while waiting for journal I/O to complete.

This correction prevents the journal daemon from hanging in an infinite loop in some situations involving a job (or jobs) waiting in a synchronous journal operation (e.g., synchronous TCOMMIT).

Under some circumstances an attempt to manually switch the journal file via ^JRNSWTCH or the GUI equivalent could hang indefinitely. This has been corrected.

In previous versions, the journal info in the wij was not updated when there was no database update. This could become a problem in some situations where the journal grew indefinitely (e.g., with TS/TC or NN records) without any database update, resulting in stale journal info in the wij. If Caché aborted while in this state, users would see a time-consuming journal restore and transaction rollback at startup.

With this change, the journal info is updated in the wij as long as journal has grown, even if there is no database update.

Under some conditions, jobs in synchronous journal operations (e.g., synchronous TCOMMIT) could hang if killed while the journal daemon is retrying a failed I/O operation.

This change prevents that from happening.

This change eliminates a sporadic access violation error in dejournaling.

If for some reason journaling failed to start at Caché startup, the journal info in the wij would remain stale even if databases are subsequently updated (without journaling). At the next startup, the stale journal info in the wij could cause the previous database updates (when journaling was off) to be overwritten by the stale data from the journal.

This has been corrected.

In an NWDS configuration, some globals were not properly mapped. This resulted in the SourceControl class being unaccessible from the client.

In Caché version 5, fast mode shadowing may suffer a performance degradation if journal file grows substantially. This change addresses this issue.

When the packet-driver service is configured to start automatically, Caché could take a long time to start. This has been corrected.

This change corrects a problem where the DCP server may fail to roll back open transactions under certain circumstances. One such situation, for example, occurs when a DCP server terminated involuntarily at OS level. In this case, it left some incomplete transactions behind, which the succeeding DCP server would failed to roll back.

When error occurs in TROLLBACK, <ROLLFAIL> is now generated and an error message is logged in the cconsole.log.

GBLOCKCOPY was using a subdirectory called "old" for saving temporary data. This changes that to be called "pre-gbcopy", so that it will not duplicate a commonly used name like "old".

The content of the Caché documentation evolves from release to release in response to editorial improvements, updates to existing material, and addition of new information. The following is a summary of the most noteworthy changes to the Caché documentation since the previous release:

• ObjectScript
  • Added the description of the "*variable" usage to the $ZTRAP special variable.
  • Rewrote descriptions of HALT and ZTRAP commands, $HALT special variable.
  • Rewrote LOCK command description for multiple locks and subscripted arrays and updated ^$LOCK and ^$ROUTINE structured system variables.
  • Added TROLLBACK 1 option and other changes to TROLLBACK and TSTART commands.
  • Made a number of corrections to the $ISOBJECT and $ZCONVERT functions,
    and to the special variables: $HOROLOG, $STACK, $ESTACK, $ZTRAP, $X, $Y, and $ZA.
  • Revised the logical operators section, & and &%amp;, precedence and nesting, and '= operator for the “Operators and Expressions” chapter of Using Caché ObjectScript.
  
  
  
• IO Device Guide
  • Rewrote Open command mode options for Interprocess Communication.
  • Added material describing the differences in printer handling on UNIX and Windows.
  
  
  
• High Availability Guide
  • Updated the material on Backup, Failover, and Journaling.

These are in addition to numerous, minor enhancements in examples, and corrections to grammar and spelling.

This section provides a listing of changes between Caché 5.0.8 and Caché 5.0.9.

This document contains several sections:

• Important Caché News, Alerts and Advisories
• A change report description
• A list of changes considered critical for this release
• A summary of changes to the documentation for this release

As necessary, InterSystems publishes items of immediate importance to users of our software. These include alerts, mission critical issues, important updates, fixes, and releases of Caché.

The most current list can be obtained from the InterSystems Website.

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

This Cache version adds support for the following new platform:

• Windows Server 2003 for 64-Bit Itanium-Based Systems

As a convenience to our users, InterSystems provides online access to documentation for recent versions of Caché at the InterSystems Website.

Once there, choose the "Caché" tab, and on the "Downloads" menu, select "Documentation and Help Updates".

To help you assess the impact of these changes on your applications, each change description contains a more detailed explanation of the modification.

All changes include a table giving pertinent information on the issue's likelihood, impact of the change, and whether this has already been used successfully in production by other customers. In order to make the information easy to assimilate visually, the tabular information has been simplified to a keyword or two and a value. The full explanation of the keyword meanings are:

• Likelihood - The probability that a user on the affected platform will encounter this issue.

• Risks - An assessment of how likely this change is to introduce additional issues into the application environment.

• Ad Hoc - This item indicates whether this change has previously been deployed in an ad hoc release and successfully used by customers in production.

• Enhancement - This notes whether this change provides new features or capabilities.

This change corrects a circumstance where the Config Manager would set the wrong value for the JournalZGlob parameter. This would cause globals beginning with "Z" or "z" not to be journaled when the user intent was the opposite.

For a CSP page logged in with a new named user license and '%session.EndSession=1', the license associated with the most recent CSP session was not released. This has been corrected; the named user license for a CSP session is decremented correctly if its session ends immediately.

Under some circumstances, the ObjectScript compiler generated incorrect object code at the end of a procedure. This could result in various errors at the end of the procedure, such as <SYSTEM> or <NO CURRENT OBJECT>.

This only happened if all the following conditions were met:

• the procedure ends with an IF statement;
  
  
• the last command of the IF statement is QUIT;
  
  
• the last line of the procedure contains all of -
  • the QUIT,
  • the closing brace for the IF,
  • and the closing brace for the procedure.

If the FTP connection times out, the Connected property of the %Net.FtpSession object was still true. With this correction, it is now correctly reset to false.

Delphi has Edit/Text box windows with a 'Text' property. The windows do not support OLE Automation, so the SetOutput() method of CacheObject.Factory is unable to access them.

DelphiCallback is a new component. It is an ActiveX control that can be placed on a visual programming environment form. To use it, call the CacheObject.Factory.SetOutput() method, passing in the name of the DelphiCallback control. At runtime, the control is invisible but will trigger a 'TextChanged' event when its Text property is set. This event receives the Text written out by Cache.

1. Create a Delphi 7 Windows Forms Project
2. From the Project menu, select Import Type Library. Scroll through the list and select CacheObject, select the Install button, and follow the prompts.
3. From the Components menu, select Import ActiveX Control. Scroll through the list and select DelphiCallback. Then, select the Install button and follow the prompts.
4. Add a TEdit box, a TButton , a TCallback, and any other components to the form.
5. Doubleclick the form to enter code for the form's creation, button press, etc.
6. Click the TCallback. From the Object Inspector window, select events, and create an event for OnTextChange. This will tie the callback to the TEdit box.

Here is sample code assuming a TextBox called Edit1 on a Form called TForm1 with the OnTextChange event called TextChanged. Text shown in boldface was added to the code generated by Delphi.

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics,
  Controls, Forms, Dialogs, OleCtrls, DELPHICALLBACKLib_TLB,
  StdCtrls, CacheObject_TLB;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Button1: TButton;
    Callback1: TCallback;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure TextChanged(ASender: TObject; const p_bstrText: WideString);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;
  Factory : IFactory;
  Connected : Boolean;
  ConnectString : string;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
var
  Dispatch: IDispatch;
begin

  Factory := CoFactory.Create;
  ConnectString := Factory.ConnectDlg('Connect to Cache');
  Connected := Factory.Connect(ConnectString);

  If Connected = False Then
    Begin
      ShowMessage('Could Not Connect');
    End
  else
    Begin
      Dispatch := Callback1.DefaultInterface;
      Factory.SetOutput(Dispatch);
  End
end;

procedure TForm1.Button1Click(Sender: TObject);
var Person: Variant;
begin

  Person := Factory.New('Sample.Person', 1);
  If VarIsNull(Person) or VarIsClear(Person) then
    Begin
      ShowMessage('Could not create person');
    End
  Else
    Begin
    Person.Name := 'Test Person';
    Person.PrintPerson;
  End

end;

procedure TForm1.TextChanged(ASender: TObject; const p_bstrText:
WideString);
begin
  Edit1.Text := Edit1.Text + p_bstrText;
end;

end.

1. Create a new VB standard executable.
2. From the Project Menu, select Components. Scroll through the list and select a checkmark next to "DelphiCallback 1.0 Type Library." This will add a Component on the Components Tab.
3. From the Project Menu, select References. Scroll through the list and select a checkmark next to "CacheObject".
4. Add a TextBox, Callback (added from above), and other controls to the form.
5. Hook up the text of the Textbox to the Callback. Double-click the Callback object. In this TextChanged method, set the text to the desired text. The output from the Factory's SetOutput() method is contained in the string passed to this method.

This is sample code assuming a Textbox called Text1 and CommandButton Command1:

Private Sub Callback1_TextChanged(ByVal p_bstrText As String)
Text1.Text = Text1.Text & p_bstrText ' Add the Text to the TextBox
End Sub

Private Sub Command1_Click()
Dim F As New CacheObject.Factory
Dim C As String
Dim P As Object

C = F.ConnectDlg("Connect Me to the Samples Namespace Please")
If F.Connect(C) = False Then
    Exit Sub
End If

F.SetOutput Callback1 ' Hook up the Callback Control to CacheObject Factory

Set P = F.New("Sample.Person")
P.Name = "Jamie"
P.PrintPerson ' Output should appear in the TextBox
End Sub

The %String MAXLEN parameter must be a positive integer. Prior versions of Caché did not check MAXLEN for validity. This corrects the oversight in this class.

The ftp client provided by %Net.FtpSession now supports both PASV and non-PASV mode for transferring data. Change the default PASV mode by setting the property UsePASV to 0.

Use the ChangeUser method to modify the current user logged in.

Sending LIST plus a space character even when there was no pattern caused a problem. This has been corrected.

If you removed an item from a relationship with the Remove method, and then you inserted the same item back into the relationship, the insertion operation was not restoring the connection between the two objects properly. The referred-to object was thus not being saved when its referrer was saved.

This is now fixed.

When an application calls the NameList method in %Net.FtpSession, that method issued a read without a timeout on it. The lack of the timeout could cause a hang in the presence of a bad network connection. The read has been changed to honor the same timeout as all the other reads.

As an enhancement to Cache 5.0.5, URL parsing was removed from Caché code. Instead, Caché used the facilities of the underlying Xerces parser to process URLs.

On OpenVMS, this caused an opcode fault. The change rebuilds the Xerces parser properly for OpenVMS.

Saving the object instance of a parent in a parent-child relationship now succeeds when the reference to the child is removed from the relationship.

In some more complex transactions, a child object could both be modified (requiring it to be saved), and removed from its relationship to its parent. This would result in validation failures when the save of the (previous) parent object was attempted.

This correction changes the behavior. Any objects deleted from relationships are removed from the save set so that they do not cause validation errors in saving the parent. These objects are examined after the save set is constructed.

When a relationship is severed between two objects, a record of that is kept in the relationship object. Prior to this change, under some circumstances Caché might miss this fact and not save the new relationship state. With this change, the new state is properly saved.

The XML parser used by %XML.TextReader uses a length value to indicate how much data it has room for in its buffer. Due to an oversight, one part of the routine was treating it as bytes and another as characters. This caused buffer overrun conditions when Unicode characters were read and could result in fatal errors on some systems.

This change makes the length interpretation uniform, and eliminates the error.

Prior to this change, when TuneTable had been run, all classes were marked as modified and requiring recompilation. This happened regardless of the setting of the "KeepClassUpToDate" argument to TuneTable. Now, only the tuned tables are marked as being updated.

The number of properties in a class has been increased from 430 to about 800 mapped to a single node.

The lock escalation is now performed on a per-table basis.

Caché has had the concept of lock escalation for some time. This is when "X" number of INSERT/UPDATE/DELETE/Saves occur within a single transaction, the next lock acquired for the table is a table-level lock. This prevents the Caché system lock table from filing up too quickly.

But, if an application inserted 1000 rows into table A and then 1 row into table B, table B would acquire a table-level lock. This is because the lock escalation threshold counter was incremented for each save in all tables.

With this change, there is a separate counter for each table. Therefore, the lock escalation only occurs on a table when that table reaches the lock escalation limit within a transaction (the default limit is 1000).

This change corrects an instance where an <UNDEFINED> error may occur during the table compilation phase of the class compiler. Caché reports the error

• if a property in the class uses a datatype with StorageToLogical and LogicalToStorage methods,
  
  
• and the property is in the IDKEY index,
  
  
• and the table is a child table.

When Caché detected a stored procedure parameter mismatch error, it immediately raised an exception. In some instances, this leaves the input buffer with data that was supposed to be consumed. The subsequent call would then fail with a message sequencing error.

This change clears the buffer so sequencing errors do not result from the exception being reported.

This change improves the speed of certain queries with GROUP BY or DISTINCT, especially when these operations can be assisted by an index. If a query has DISTINCT or GROUP BY and no aggregates need to be processed by the query, execution terminates as soon as all the DISTINCT field values become known.

Note: the optimization will not be evident in Show Plan.

This correction changes the SQL CASE statement to return its result as the datatype of the result of the first CASE condition.

All the values returned by CASE are supposed to be of the same datatype, but Caché does not enforce this. So if the first condition returns a DATE, the column will be of datatype DATE. If a later condition returns an INTEGER, the value will be treated as a DATE value.

A query such as

SELECT a.spouse->name FROM sample.person a,
       (SELECT contact FROM sample.vendor) b

containing a sub-query of an unrelated table would fail with an SQL erroe code of -29.

This change allows Caché to properly handle this case.

This change corrects an error where Caché would report a <MAXSTRING> error during the table compilation phase of the class compiler if %CacheSQLStorage is used, and more than 200 fields are stored in a single node using a delimited string storage structure.

Delimited String storage simply means:

^glo(id)=field1^field2^field3^...^fieldN

where each field in this example is delimited by "^".

The performance of the Studio New Query Wizard could be poor in a namespace that contained many classes with many relationships among the classes. The performance has been improved. The Query Wizard is initializes only the data for the levels the user actually explores.

The class syntax checker has been fixed to correctly report an error when the final closing brace of a class definition is missing. In previous versions, this invalid syntax was unreported.

In previous versions, Caché failed to set UTF8 mode for devices used in debugging. This resulted in non-Latin characters (for example, Japanese) being displayed incorrectly.

This change rectifies that situation.

This change addresses a issue with sorting (started and ended via $SortBegin and $SortEnd, resp.) on 64-bit platforms. Global nodes that are set to values of double type may attain incorrect values after sorting. Since sorting is enabled in journal restore in 5.0.5 and later, journal restore was affected by the problem too.

This change corrects an error that caused an <INVALID TYPE> error when comparing an OREF to a non-null string. Now this comparison returns 0 (false).

This change corrects the calculation for $NORMALIZE(<number>,-1) that could incorrectly return zero in some circumstances. For example, prior to this change, the sequence

Set x = 3.5
Write $NORMALIZE(x, -1)

would correctly return the value 3. However, the sequence

Set x = 7 / 2
Write $NORMALIZE(x, -1)

would return the value 0. Now it returns 3 as it should.

There is a small chance that ^LOCKTAB or ^$LOCK SSVN could get an access violation when there is heavy lock table activity. This change prevents that from occurring.

Under certain circumstances, an attempt to restore a saved database file into a bigger existing database can cause data corruption resulting in <DATABASES MAP LABEL> errors and system hangs.

With this change, the data corruption no longer occurs.

An error in the non-interactive API for restoring backups, $$EXTSELCT^DBREST, has been fixed. The result of the error is that the manager's database could be inadvertently restored. This would happen even if it was not specified in the restore list. If it were present in the backup archive and the file containing the restore list contained a blank line, the manager's database would be overwritten.

This could also happen if the calling process had enabled $ZEOF handling.

In previous versions, a process would crash if it attempted to open a Windows printer device with a name longer than 69 characters (including the "|PRN|" prefix). Now, length of up to 256 characters is supported with a <NOTOPEN> error occurring for a length greater than 256.

If a lock is held by a remote DTM client, the LOCKTAB and Control Panel display will now append a "/" followed by the process ID of the owner on the remote DTM system to the lock display as a monitoring aid.

On earlier versions of Caché, it was possible for the statement

For i=1:1 ZA ^a(i)

to get a <COMMAND> error when $ZU(69, 8) is set. When it is not set, it should not get this error because ZA works like the LOCK command. This change fixes this issue.

Prior to this change, the %CSP.Daemon process was getting started in the implied namespace because this is the namespace the startup code is in before it calls the function to start the daemon. Now the daemon swaps to %SYS namespace.

The content of the Caché documentation evolves from release to release in response to editorial improvements, updates to existing material, and addition of new information. The following is a summary of the most noteworthy changes to the Caché documentation since the previous release:

• In the Caché I/O device guide:
  
  • Added the OPEN and USE options (positional and keyword) for the COM port
  • Fixed and updated the UNC section for printer names
  
  
  
• In the Caché SQL Reference book:
  
  • Added new pages for
    
    • %CHECKPRIV,
    • GROUP BY,
    • HAVING,
    • the new date and time constructs {d ...}, {t ...}, and {ts ...},
    • and variables includiing %msql, %ROWCOUNT, and SQLCODE
  • Added %msql information to the material on CREATE TABLE, CREATE VIEW, GRANT, and REVOKE
  • Updated the information on CREATE TABLE %Description adding explanations of the %FILE, %NUMROWS, and %ROUTINE options
  • Reworked and expanded the material on dates and time including: CURRENT_TIME, CURTIME, HOUR, MINUTE, SECOND, CURRENT_TIMESTAMP, GETDATE, NOW, TO_DATE and TO_CHAR
  • Added descriptions of the %DELDATA and %NODELDATA options for DROP TABLE
  • Clarified the explanations of %DB_OBJECT_DEFINITON and added cross-references to %CHECKPRIV for GRANT and REVOKE.
  • Improved and expanded the examples showing SELECT usage with more varied option combinations and more explanatory information on each example.

• Changed the browser stylesheets to remove excess leading spaces from lists appearing inside table cells
  
  
• Added the lead items from the Glossary of Terms to the word index
  
  
• Added Itanium as a supported platform for Windows

These are in addition to numerous, minor enhancements in examples, and corrections to grammar and spelling.

This section provides a listing of changes between Caché 5.0.7 and Caché 5.0.8.

This document contains several sections:

• Important Caché News, Alerts, and Advisories
• A change report description
• A list of changes considered critical for this release
• A summary of changes to the documentation for this release

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 releases of Caché.

The most current list can be obtained from the InterSystems Website.

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 versions of Caché at the InterSystems Website.

From the home page choose the "Caché" tab, and on the "Downloads" menu, select "Documentation and Help Updates".

To help you assess the impact of these changes on your applications, each change description contains a more detailed explanation of the modification.

All changes include a table giving pertinent information on the issue's likelihood, impact of the change, and whether this has already been used successfully in production by other customers. In order to make the information easy to assimilate visually, the tabular information has been simplified to a keyword or two and a value. The full explanation of the keyword meanings are:

• Likelihood - The probability that a user on the affected platform will encounter this issue.

• Risks - An assessment of how likely this change is to introduce additional issues into the application environment.

• Ad Hoc - This item indicates whether this change has previously been deployed in an ad hoc release and successfully used by customers in production.

• Enhancement - This notes whether this change provides new features or capabilities.

If you have a form in a CSP page with a textarea, and the submitted data in the textarea is longer than 32K characters, the CSP server now automatically creates a stream to hold the data and returns the stream OREF as the result of %request.Data("txt",1).

This means that for any fields that could be larger than 32k you should code something like:

Set value=%request.Data("fieldname",1)
If $isobject(value) {
  ; Treat this as a stream
} Else {
  ; Treat this as a regular string
}

Under some circumstances, closing the status window of a GUI backup could result in the system hanging. This change corrects that.

If a request for a new CSP page comes in which causes a new session to be created, and a serious error occurs before the request is complete, there are situations where the %cspServer process may HALT after allocating a license but before storing the session information in ^%cspSession.

Should this occur, the license will never get released because the %CSP.Daemon process will never detect this session timeout (there is no entry in ^%cspSession).

With this change, the %cspServer process inserts an entry in ^%cspSession before allocating a license. Should the new process terminate abnormally, this license will still get released by the %CSP.Daemon process.

This change removes support for URL and FILE query parameters of %XML.Utils.SchemaServer so that arbitrary file viewing is no longer possible.

This change closes a %CSP.DwxUtils security hole that allows running of an arbitrary classmethod.

Dreamweaver MX2004 changed the mechanism needed for installing plugins. This change contains the modifications to the Caché plugin necessary for it to work with MX2004 as it has with earlier Dreamweaver versions. Corrections were made to fix uninstall problems uncovered in earlier releases.

This change corrects a problem where attempting to post small binary files as multi-part MIME attachments could result in an error return. This issue was particularly relevant to files containing the NULL (ASCII 0) character in the first few bytes. This location, for example, is usually reserved for header information in image and zip files.

This change corrects an error in the Caché Version 5 communications protocol between the Gateway and Caché. Prior to this, 'textarea' submissions greater than 32K could fail.

Hyperevents may fail in non-cookie, session-management mode if the session token (CSPCHD) was not passed as the first hidden field in the form's posted data. This could also happen in regular CSP forms, but more rarely. This changes corrects this situation.

This change corrects an issue involving a POST of a textarea element containing more than 32K characters. Under some circumstances, the textarea content could be silently truncated.

Sun has changed the default behavior of the Sun ONE (formerly iPlanet) v6.1 server. The change mainly involves requests processed through NSAPI extensions.

The effect of the change is that the server now assumes responsibility for formulating and dispatching HTTP response headers. Previous versions would allow NSAPI extensions to stream their own headers back to the client and wouldn't intervene in this process unless the module explicitly called the NSAPI header formulation and dispatch functions.

This change includes essential modifications to ensure that the Gateway works with the latest iPlanet/Sun ONE web servers under Linux.

The I/O keyword table was inadvertently truncated in Release 5.0.5. The keywords /WRI, /WRITE, /XYT, and /XYTABLE were not recognized as valid and attempts to use them resulted in <SYNTAX> errors on Windows systems.

On UNIX and VMS systems, only the last entry, /XYTABLE, was truncated with similar effect.

This change corrects both errors.

This change updates the InterSystems packet driver to correct issues with Windows "Plug-n-Play". Prior to this change problems during install or uninstall could sometimes cause a Windows system failure.

The driver also now processes properly many dynamic operations via packet-driver handles allowing the system to proceed more gracefully.

The internal version number of the driver has been updated to reflect the change.

Under some circumstances, class instances were being marked as modified when Count() or %GetNext() were invoked, and more than one instance of the object was stored in the database. An example is a "parent" object instance with multiple "children". This change properly preserves the modification state of the object.