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 problem 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.

PLEASE EXAMINE THE REFERENCES IN THIS SECTION CAREFULLY.

This fixes a problem with object reference counting which allowed an object to stay active even though its system reference count was zero. This condition happened when the object reference was stored in an object property that was declared as a non-object data type, such as %String or %Integer.

Application error

Previously, if two objects contained a relationship to each other, and one of the objects was subsequently changed to delete its side of the relationship, that deletion may have failed to propagate to disk. This resulted in the referenced object still being present in the relationship.

This has been fixed for "cardinality = many" and "cardinality = children". The possibility of error still exists for 1:1 and M:N relationships.

Application error

The method for generating the shared memory section names on OpenVMS has been changed to avoid problems when OpenVMS allows multiple processes to have the same process name. The prior method used the conflict in process names to detect that another instance of Caché was running. A limitation which arises from this change is that the name of the device which Caché is installed on (for example, where the manager directory resides) cannot be longer than 16 bytes (excluding the trailing ":" but including a leading "_"). This should not pose a problem for any sites, but Caché will refuse to start up after displaying an error message if this is the case.

Production hang

This Caché maintenance kit includes a revision in the backup utility that significantly improves performance for certain tape devices on Windows platforms. This may, however, render Caché unable to read backups from previous maintenance kits and versions.

For tape drives such as a DLT4, the backup block was being written out as a series of much smaller blocks. This revision significantly improves performance by ensuring that a single contiguous block is written, but it also means that a backup generated on the same hardware before this fix cannot be restored by a version of Caché with this fix.

Backup runs slowly

A bug that caused the $ZHorolog special variable to return negative values on a Windows machine with a 2.1GHz processor or faster has been fixed.

$ZHOROLOG is generally used in internal application timing. It is unlikely this will affect a production application.

If you define a class as abstract, Caché now generates all instance methods as well as class methods. Previously it only generated class methods. The instance methods are needed so Caché can call these via ##super from a subclass.

##super now works with abstract superclasses

Certain CDL files that loaded and compiled correctly in Cache 4.1.9 failed to compile in Cache 5.0.1. This is due to the table compiler adding an "=" at the end of a line. This has been fixed.

CDL files that did not compile now will.

In Caché 4.x, it was valid to call the class methods of a data type class using the syntax:

   Write ##class(=datatype).Method(args)

In Caché 5.0, this results in a class not found error. This is because we support this syntax at the system level now and the class descriptor that allows the system code to find where to call was not generated for data type classes. We now generate the class descriptor for data type classes so you can call these class methods.

Note that calling a class method of a data type class is different from calling the generated method when you use this data type as the type of a property because this has a different set of parameters. For instance, as a property of a class you can specify that a string has a maximum length of 50 characters but in the data type class itself it may default to 100 characters. When you call this data type class directly you need to be aware that this is a different context.

Application error

Nested serial columns should be hidden if their properties are also projected to SQL. This logic existed in the serial property projector but was setting the 'hidden' flag too late in the process. It now determines correctly when the projection of serial columns should be avoided.

Little; projection of nested serial objects is a new feature.

When saving an empty element value (<tag />) to a character stream property, we now store "" in the stream object rather than $c(0). When no element is present, we still store no stream element.

Empty streams are now exported to XML in a better way.

XMLExport was changed to treat references to serial objects as null if all values in the serial object are "". A serial object with no value set will now export without any tags. This uses the SQL test for NULL object.

Serial (embedded) object are not included within an XML projection if the object is NULL (i.e., all of its fields are missing).

The performance of $INCREMENT in a cluster-mounted database from a machine other than the cluster master has been dramatically improved. This is for ECP cluster configurations.

Note: although the risk of this happening as noted below is high, this is not a compatibility issue. It is a performance one.

Customers are unlikely to see any impact, because $INCREMENT on clusters was fast enough to support thousands of users already.

Code generated by csp:search CSP tag included a ..QuoteJS(...) method call for pages written in basic. This is a syntax error. The generated code for a basic page now generates me.QuoteJS(...).

Previously, CSP applications developed using BASIC would have failed during compilation.

Add support for ascending (ASC) or descending (DESC) sort to the csp:search tag as follows:

The format of ORDER attribute is now comma separated list of fields of the format

   propname | direction

where propname is the name of the property and direction is optionally ASC or DESC. If direction is not specified then the default from the SELECT or WHERE attribute is used.

The format of the WHERE and SELECT attributes is now a comma separated list of fields of the format

   propname alias | direction

where propname is the name of the property, alias is the optional SQL alias to be used and direction is the default direction (ASC or DESC) to be used for this property in the ORDER attribute if not specified there.

Improved performance

The following fixes related to the use of alias in the SELECT and WHERE lists were made:

1. For each of the comma separated properties, treat everything following the first space after the property name as the alias. Ignore the optional "AS" separator between the property name and the alias. "name alias" is equivalent to "name As alias".
   
2. No longer use the alias in the generated SQL statement, since it is not needed. This change removes any problems with the use of delimited identifiers in an alias. Delimited identifiers in the field name already work.
   
3. Change to passing the order property using the property name rather than the alias. This change fixes the problem with highlighting of the sort column and removes the only use of the alias in the SQL statement.
   

The CSP Search page now uses column aliases correctly.

When importing CSP files, if the application does not match because it came from another namespace but there was a '/csp/namespace' application defined for the current namespace, it was imported there.

This is now extended so even if there is no '/csp/namespace' it will pick the first alphabetically collating application that maps to this namespace.

Import of CSP files is improved when importing into a different namespace.

If a Preserve=1 process terminated unexpectedly, the license that it owned would never be released because there was no record of the license number that it obtained.

This has been corrected.

Gradual reduction of license capacity

A page with a long URL could cause a <SUBSCRIPT> error in the CSP engine at GetCSPClassName+3^%cspServer when it was attempting to look this page up in a cache of page-to-class translations. This was due to faulty logic in detecting when the subscript was too long to use this global cache lookup.

CSP application users would receive an error.

Netscape 7.0.2 with Java plug-in 1.4.0_03 treats the return of a Java method (that was called using LiveConnect) as an object rather than as a string. JavaScript for #server is modified to concatenate "" to the return value (which converts it to a string) in case of object return from a Java method.

CSP #server calls now work better with NetScape v7.0.2.

A bug has been fixed where a 5.0 or later Configuration Manager was localizing the Yes/No strings when editing a 4.1 configuration file. Such unwanted localization prevented recognizing the expected Yes/No attributes.

The Configuration Manager user interface would display inappropriate characters in non-English locales. There was no risk to production.

This fix corrects the display of long namespace names which were previously truncated.

Cosmetic improvement

The undocumented global, ^%SYS("DOCBOOK","SOURCE"), previously held the default location where the documentation sources could be found. This has been generalized to include a list of such directories. Its use in loading documentation is also now described.

Users who are loading their own content into the DOCBOOK namespace will see load failures until they re-arrange their global structures describing the source directories.

This corrects two errors found while attempting to use the XMLExport method of DocBook.Utils.

First, an incorrect reference to a property in one of the DocBook classes (refentry) was corrected. Prior to this, attempts to export reference material as XML would result in a <PROPERTY DOES NOT EXIST> error.

Second, XMLExport used to generate a reference to the XML stylesheet provided by SoftQuad for DocBook. This is vestigial since the application no longer uses this facility. It has been removed.

Attempts to export documentation as XML files will now worked where previously they had failed.

A problem involving the import and compile of a large number of classes has been fixed. Previously, this could result in the error

   Run-time error '91':  Object variable or With block variable is not set

Developers importing XML might receive an error.

This change corrects a situation involving resetting of certain component selections during installation. This affected Pentium 4 specific components as well as CSP and WebLink Web server specific modules. Prior to this change, the installation program ignored the user's choice to install or not install web server specific modules. It allowed a user to select or deselect these modules, but it installed modules for all detected Web servers regardless of the user's selection. Furthermore, when the Web server was not detected, install didn't try to install these components even when they were selected by the user.

This change does not allow users to select components for web server modules if the corresponding web server is not detected. Users still can deselect a particular CSP/weblink module, which can be useful if there are two or more web servers installed and users don't want to install CSP/Weblink for all of them.

Install now honors the users wishes more closely.

The default configuration name for kits downloaded from our Web site is CACHEWEB, but the shortcuts created referred to CacheWeb instead. Caché Control Panel and Explorer could not be started because the Windows Start menu is case-sensitive in this area.

This is fixed.

Minimal: The Cube still works in the presence of this fault.

When proceeding with a client-only installation of Cache 5.0.1 on Windows 2000, the server side components were also installed. This has been fixed.

Increased disk usage and access on a client PC, as well as possibly having unauthorized Caché servers deployed.

Install now checks for presence of file "cbootuser.rsa" on the installation media in the same directory as cboot (NT\Install in case of Windows). If this file exists, install loads it and executes routine "cbootuser". This allows customers to execute code for such things as creating databases, loading globals/routines, and so on every time Caché is installed from this media.

Please note that at the time this routine is executed no namespaces are defined yet and no object code can be used. $zutil(5) can be used to switch between implied namespaces.

None

Reverse $order over ECP could return a <DATABASE> error.

An application user may receive a false <DATABASE> error.

Previously, the default packet size on OpenVMS and UNIX systems was set to 3600 to improve performance. Because some networks do not perform fragmentation and re-assembly of packets, this causes DCP clients to timeout and display the <Server... is down...> message. The fragmentation problem may be due to an operating system or router setting.

To correct this problem, the default maxudppktsiz parameter on all platforms is now 1468, which is the maximum packet size sent by Caché. This obviates the previous need to fragment packets. Note that the Caché Configuration Manager allows you to increase the maxudppktsiz to a maximum of 3600, which provides a small performance improvement on networks which know how to perform fragmentation properly.

The application user may see an annoying, yet benign, message <Server is Down>.

This change prevents a possible race condition in between DB state changes (such as dismount) and client cache cleanup.

ECP may fail.

In certain rare circumstances, ECP referenced an array out of bounds. On all platforms this array is padded by the platform compiler, and the problem wasn't exposed unless things were relocated in memory.

Now if things are relocated in memory this will not cause a problem.

ECP may fail.

When the network takes too long to initialize, the write daemon could fail to start on a system with a lot of buffers configured. This has been corrected.

Caché may fail to start.

This change corrects the spelling of EXTERNALSQLNAME everywhere it is used. This property parameter is used to define the name of a column projected to an external SQL DB.

An ODBC query may fail.

When a persistent class contains a property whose type class is a serial class (embedded object), the properties of the property's type class are projected to SQL as columns. The name of the projected column is the <container column>_<serial column>.

In versions prior to 5.0.1 this projection is restricted to one level of embedding. In 5.0.1 multiple levels of embedding are projected to SQL. The name of the projected column follows the same form as before but the <container column> can also be a column projected from a serial class.

For example, Class City is serial with properties City, State, Country, and PostalCode. Class Address is serial with properties Street (type %String) and City (type City). Class Person has a property, Home as Address.

Prior to this change, only Home_Street and Home_City would be projected as columns to SQL. Now Home_Street, Home_City (hidden), Home_City_City, Home_City_State, Home_City_Country and Home_City_PostalCode are projected.

Enhance the projection of multi-level embedded object properties.

Old CDL files may have an extra '()' around the formal specification of methods due to an error in a previous version of Caché. These CDLs were not compiling because of the extra '()' in the formal spec. We now strip the extra '()' when the CDL is loaded to avoid this issue.

Impedes a developer from loading certain CDL files

This change makes the class compiler use the same flag to decide if it wants to retain SQL source in the INT code as the standard MAC compiler.

Debugging object applications which use Query methods would be a bit more difficult

If you create a class with the following properties:

   Property Array As %String [ Collection = array ];

   Property Index As %Integer;

Then create a method:

Method Test()
 {
   Write ..Array.GetAt(..Index)
 }

If you compile this with full optimizations on, then the code generated from this Test method will be incorrect. The generated code attempts to find the '..Index' inside the '..Array' object rather than in the current object. Now Caché inserts the optimization correctly.

Class compiler optimizer now generates correct code for collections.

If an expression method looked like '(a=1)||(a=2)' then the class compiler would substitute it without adding any additional brackets, so if the code was:

   Write '..Expr(var)

It ended up looking like:

   Write '(var=1)||(var=2)

It was not detecting that even though this expression starts and ends with a bracket. It needs an additional bracket so now it will substitute the expression:

   Write '((var=1)||(var=2))

Application error

When you use '##super' the first thing it does is find where this method was originally implemented and looks for the superclass to this class. However, if the method is a generator method then the class is 'implemented' at every level so just look for the superclass to the current class.

##super directive now works with method generator methods.

We deleted the jar from the JBoss deployment directory. This allows CMP deployment to follow BMP deployment.

You can now use CMP EJB deployment after using BMP deployment.

When CMP generation generates support for a Caché serial class, if the serial class has a "persistent" (a reference), the JNDI name of that reference is generated incorrectly. This changes the generation of the JNDI name to prefix BEANNAME before it.

EJB CMP generation is improved for serial classes.

Opening and closing Java Binding connection using method CacheDatabase.getDatabase(java.sql.Connection) caused memory leaks. This is fixed now.

Java-based applications may crash due to insufficient memory.

We now support nested serials.

Suppose we have P (persistent) containing S1 (serial) containing S2 (serial). Let's suppose they are all in package Pack1. You might think that you access S2 from S1 but you access it from P. For instance, you will have a dependent object Pack1.EJBS2. The values in this dependent object for remote EJB object p that is a proxy for Pack1.EJBP can be obtained and modified through:

P.get_S1_S2()

P1.set_S1_S2(s2)

in the above s2 is a dependent object instantiating Pack1.EJBS2.

You can also use the following:

P.get_S1().get_S2()

and

s1 =P.get_S1();
s1.set_S2(s2); // change is only in memory
P.set_S1(s1); // change is now in the database

Remember, you must always go through proxy for a persistent (projection of a persistent) to actually set value on Caché. Just working with serials alone is just an in memory operation.

EJB projection now works with nested serial objects.

Nested serials need to be loaded in serial constructor even though they may be marked as "hidden". Also the logic for projecting fields does not properly set the fields of a serial set accessor.

Users should take note of the fact that changing a field from hidden to non-hidden or vice-versa requires the EBJ code to be regenerated and recompiled. In general, if you change any characteristics of your classes you should regenerate EJB support. Though it seems as if changing a field from hidden to non-hidden, or vice-versa, will have no affect on your EJB code working, Caché relies on the fact that changes in the description of the class require it to be fully regenerated.

Application error

In %Net.FTPSession in the method readResponse(), if an error condition occurred, then the current device was not reset. This left it as the TCP/IP device to the ftp server.

Application error.

Calling the Compile method on %Routine class with the '-d' flag to prevent anything from being displayed to the current device was not working. If there were errors with the routine it was still displaying them. This change now honors the '-d' flag.

None

This change adds two class methods to %File:

• GetDirectoryLength(dirname), which returns the number of pieces in this directory name, for example 'c:\temp\mysub' has three pieces on a Windows environment.
  
• GetDirectoryPiece(dirname,piece,.fullpath,.isdirectory), which returns the asked for piece from the directory name.
  

For example, using the 'c:\temp\mysub' example it will return:

 Piece Return FullPath       IsDirectory
 1     c:     c:             1
 2     temp   c:\temp\       0
 3     mysub  c:\temp\mysub  0

None

A restriction on the use of Webmethod as a keyword of a class method only has been introduced, but the Reader had not been updated to reflect this change. The reader now generates class methods instead of instance methods properly.

None

The keyword WebMethod is now supported in queries specified in a subclass of %SOAP.WebService.

A Web method, callable via SOAP, will be created that has the same input arguments as the query that returns the typed dataset associated with the query.

In addition, if the Web service is pkg.class and the query is named QueryName, then the class pkg.class.QueryName is created as a subclass of %XML.DataSet that is typed and represents the query.

An example of the use of WebMethod for a query has been added to the SOAP.Demo Web service sample.

None

The SoapBindingStyle and SoapBodyUse property keywords are now supported. They will work just like these keywords for methods with WebMethod keyword.

The SoapNameSpace property parameter may only be used for Web clients.

None

This change improves error messages for SoapBodyUse, SoapBindingStyle and SoapNameSpace method/query keywords by adding the method or query name to message.

Cosmetic change

Now we give an error if LOCATION does not begin with http:// or https://. Note that the use of https still requires an external tunnel.

Debugging becomes easier with the added information.

An attempt to compile a subclass of %XML.Adaptor was leaving defined variables behind. Appropriate New commands were added to the method generator code so that variables are cleaned up properly.

Extra variable are no longer left after XML export.

Previously, under rare circumstances, compiling an internal "virtual" class could cause a child table to be projected to SQL. This has been corrected.

None

When a bitmap index is added to a table, the results of subsequent queries would often be incorrect. The bitmap extent index is not automatically built when the first bitmap index is added to a table.

%BuildIndices has been updated so that anytime a bitmap index is built and no data exists in the bitmap extent index then the bitmap extent index for that class is automatically built along with the bitmap extent index for each subclass.

The SQL query may return incorrect results.

This corrects a problem that occurs when a property is stored by itself in a global node ('node' structure). This commonly occurs when a collection is stored in a subnode structure and the resulting structure is projected to SQL as a child table. The error reported is

   ERROR #5502: Error compiling SQL Table ...

The application will not compile.

On OpenVMS, remotely exporting XML files via Caché Studio and reimporting them caused routines to be stored all on one line, and then fail to compile. This is corrected.

Annoys developers

If you exported a global using the $system.OBJ.Export entry point that was 32767 characters in size or near to this limit, and then you subsequently imported it you may get the error message:

   <MAXSTRING>characters^%occSAX in c:\test.xml at line 581 offset 1

This was because a variable was not cleared correctly after a global node was imported. This is now fixed.

Annoys developers

When exporting an expression method, export-to-XML formats it on a single line rather than inserting a Cr/Lf after the start of the CDATA for the method body code before the first line of code. This is so classes exported on Caché 5.0.1 will import correctly on Caché 5.0.0.

Class definitions exported from v5.0.1 can be loaded onto v5.0

When a %XML.DataSet is returned from a Web service, it projects as a Microsoft .Net dataset. Previously, only untyped datasets were supported. This change adds support for .Net typed datasets which include type information in the WSDL file for a Web service. This additional information allows Visual Studio .Net to create a typed dataset that supports IntelliSense.

A subclass of %XML.DataSet will produce a typed dataset if the NAMESPACE parameter is specified, and the CLASS and QUERY parameters are overridden to specify the query underlying the dataset.

An example of the return of a typed dataset was added to SOAP.Demo sample.

Allows Visual Studio .Net to create a typed dataset that supports IntelliSense

A class that is referenced by a property in an XML enabled class must be XML enabled. Previously, if the referenced class was not XML enabled, then an unclear <METHOD NOT FOUND> error was given. This was replaced by an error message stating the problem more clearly.

None

When mapping Caché simple types to XML schema types in "literal", use the enumeration facet to represent the Caché VALUELIST datatype parameter. XMLImport already supports type checking based on the VALUELIST. This change modifies XMLSchema to output the enumeration facet to represent the VALUELIST.

Enumerations are not supported in schemas that are in "encoded" format, since Microsoft Web services do not support enumerations for BodyUse="encoded".

Classes now produce XML Schemas containing more information.

Support optional indentation of XMLExport output as determined by the format argument of the XMLExport call. The default indentation behavior is the current behavior of outputting the XML as one line with no added whitespace.

Adding "indent" to the format argument causes the XMLExport output to be indented. "indent" should be separated by a comma from literal/encoded part of the format. The indentation characters to be used can be specified by enclosing the indentation string to be used in parentheses following the "indent" in the format argument. If not specified, the default indentation characters string is two spaces.

Examples: To output the object referenced by oref with the default two space indentation:

   set sc=oref.XMLExport(,",indent")

To output the object referenced by oref with three space indentation:

   set sc=oref.XMLExport(,",indent($c(32))")

Note that passing the space ($c(32)) as the argument increments the size of the indentation; it does not specify the size of the indentation.

To output the object referenced by oref with tab indentation:

   set sc=oref.XMLExport(,",indent("_$c(9)_")")

Cosmetic improvement to generated XML.

Add a Rewind method to %XML.Reader that when called will clear correlates and restart reading from the beginning of the XML document. Correlate must be called again after the Rewind.

%XML.Reader is easier to use.

When you load an XML file, the current device was changed to the $PRINCIPAL device rather than keeping the device that the user specified. This now remembers the correct device.

Class import restores the principal device correctly.

Class Query definitions now have the same SOAP-related keywords as do methods. This allows you to control the SOAP-binding of class queries.

Class queries support more SOAP options.

Dropping a Foreign Key that points to a mapped table failed with following error message:

[SQLCODE: <-400>:<Fatal error occurred>]
[Cache Error: <<LIST>AlterColumn+66^%apiDDL>]
[Details: <Serverr>]

This has been corrected.

D