This document contains several sections:

• A security vulnerability notice
• A change report description
• A listing of changes with possible compatibility issues
• A listing of changes without compatibility issues

Caché and write permissions on UNIX systems

Present Status

The installation defaults have been changed for Caché 4.1.16 and 5.0.3. For more information, please contact the InterSystems Worldwide Response Center.

Workaround for earlier releases

Log on as "root", change to the directory where Caché is installed, and issue the command:

chmod go-w bin

If Caché is not being used for CSP programming, and is not running in conjunction with a local Apache web server, issue the command:

chmod -R go-w csp

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.

PLEASE EXAMINE THE REFERENCES IN THIS SECTION CAREFULLY.

• Installation.Unix
  • Change permissions on csp and bin subdirectories
• Object.Activate
  • Introduce AsStream() methods on %Activate.IDispatch to cope with strings > 32KB
• Object.Java
  • Profiling added to the Java binding
  • Deprecate use of proprietary Java collection classes
  • Remove "standard" classes from the generated dependencies
  • Don't project superclasses that are not registered and have all methods server-only
  • Support Java generator on OpenVMS
  • Unexpected 'ResultSet closed'
• Object.LanguageBindings
  • Project methods with conflicting signatures as comments in generated code
  • Don't allow projection when properties have conflicting declarations
  • Don't project certain sorts of classes
  • Don't allow projection of not up-to-date classes
• Object.Soap
  • For SOAP allow types in a different namespace than methods
• Object.XML
  • Address issues with handling of xsi:nil attribute in XML import
• SQL
  • Address calculation of {fn WEEK(...)} function
  • %SQL.Manager.CatalogPriv.UserNamespace query lists all namespaces instead of "<ALL NAMESPACES>"
• SQL.DDL
  • SQL DROP TABLE referenced by Foreign Key prohibited
  • Drop FKey should rebuild the Primary Key Index if collation changes
• System.I/O
  • Address read terminator handling for OpenVMS stream mode

A new script is distributed with Caché, CSP_protect. This script, located in the <cachesys>/csp directory, allows you to disable or enable write access to the CSP directory and files after installation. For a description of the issues, please see the "Security Vulnerability Notice - 27 June 2003" that appears earlier in this document. The issues are a consequence of the permissions on directories created by the installation scripts for the Caché engine, and for the CSP network daemon, browser, and other files. Prior to this release, the installation used to create

• <cachesys>/bin with default -rwxrwxrwx
• <cachesys>/csp with -rwxrwxrwx (0777)
• csp subdirectories and files with -rwxrwxr-x (0775)

The script does change the groupid and permissions on various scripts and executables that are intended for use only by the Caché manager, but has not previously restricted directory access. The CSP_protect script is meant to be run at any time, for any UNIX version of Caché.

If you disable write access, for security purposes, currently available CSP applications and pages may be used, but no modifications are permitted. For this to be effective, you should start Caché as a non-root user but start the CSP Network Services Daemon as root.

Improved security on UNIX systems.

Java Binding Profiling allows a user to count the number of calls to Caché Server and total time spent while waiting for server response.

There are 2 ways to use it:

1. The user can always get the total number of calls to Caché Server and total time spent while waiting for server response with methods com.intersys.objects.Database.getNumberOfServerCalls() and com.intersys.objects.Database.getServerTime().
2. It is possible use partial profiling. If the user desires to count calls and time only for particular segments of the program he should first call com.intersys.objects.Database.setProfileOn(i) method. Then, until com.intersys.objects.Database.setProfileOff(i) is called, the number of calls and time will be added to data for segment "i". At any time the user can retrieve this information by calling com.intersys.objects.Database.getNumberOfServerCalls(i) and com.intersys.objects.Database.getServerTime(i) methods.

By default there are two segments available for profiling. This number can be changed either by setting the system property com.intersys.profile.segments to the desired number. For example, the command line option -Dcom.intersys.profile.segments=5 will set this number to 5. Alternatively, the user may call the com.intersys.objects.CacheDatabase.setNumberOfProfiles(n) method before initializing the Database connection. System property value takes precedence over programmatic call.

Also, the method com.intersys.objects.DatabaseUtilities.importClass() previously loaded a file from the machine on which Caché Server was running, not the Java client. Now it is loaded from a client machine. There is another method com.intersys.objects.DatabaseUtilities.loadLocalFile() that loads file from the machine on which Caché is running. If user is certain that client and server are running on the same machine it may be preferable to use loadLocalFile() to avoid overhead of transporting file from one machine to another.

Improved profiling and debugging information is now available.

The following classes are now deprecated:

• Use java.util.Map instead of:
  • com.intersys.classes.AbstractCacheArray
  • com.intersys.classes.ArrayOfDataTypes
  • com.intersys.classes.ArrayOfObjects
  • com.intersys.classes.ArrayOfObjectsWithClassName
  
  
• Use java.util.List instead of:
  • com.intersys.classes.AbstractCacheList
  • com.intersys.classes.ListOfDataTypes
  • com.intersys.classes.ListOfObjects
  • com.intersys.classes.ListOfObjectsWithClassName

Applications using these classes should be re-worked to use java.Util.Map and Java.Util.List instead.

Additional methods have been added to the class %Activate.IDispatch to handle character strings greater than 32KB. These methods have names that end in "AsStream" and return their values as instances of %GlobalCharacterStream.

Applications can now be extended to process more than 32KB with %activate.IDispatch.

When the user requests generation with the "r" flag, we generate dependencies for a Class. For instance, for Sample.Person, Sample.Address is a generated dependency since Home is an attribute of Person with type Sample.Address. We generate supporting C++ or Java code for all generated dependencies. This change excludes classes whose package is "%Library" or "%XML".

Prevents generation of superfluous client bindings for library classes.

Here is the algorithm we use:

We have a class

     A extends B

Here is how we determine "not projected" for B. Normally we project the superclass, so this is an algorithm for not-projecting the superclass.

B is not projected if and only if all the methods and properties in "B" are marked as server-only and "B" is not a subclass of %Registered.

We are then saying that if A extends such a class B, then we only project A if all of A's methods are class methods.

We also implement the following: we return a message if a class in the class list or the dependencies has a superclass which is not a registered object and this server has all methods flagged as serveronly and the class which has this superclass has a method which is not a class method. There is a new "not projectible" error message for this case.

Here is the error message:

ERROR #6626: Class <classname> is not projectible. Projection is aborting. If the superclass of a class is not a %RegisteredObject and all the methods of the superclass are server-only and the class has some methods that are not class methods then it is not projectible. If the superclass of a class is null then the class must contain only class methods.

Unusable superclasses will be removed from projections.

On OpenVMS we generate files with names in OpenVMS format.

If the ROOTDIR is [MyRootDir] and the package is Sample.Person then the files generated are:

• [MyRootDir.Sample]Person.java
• [MyRootDir.Sample]Address.java

The Java interface now works on OpenVMS.

This happened when CacheQuery object was garbage collected while ResultSet was still in use. Code similar to:

ResultSet result =
	((new CacheQuery(login, "Sample.Person", "ByName")).execute());

resulted in the CacheQuery object being destroyed as soon as it was executed. This no longer occurs.

A spurious error has been eliminated.

Suppose we have a Class A extends B, C, etc.

For such a class B is the primary superclass.

Suppose there are methods in the primary superclass (B) which have a different signature than methods in the compiled methods of A (these are methods with conflicting signatures due to multiple inheritance) then for each such method <M> in class <C> with primary superclass <S> in the generated code we will issue a comment:

   // In Class <C> method <M> not generated because
   // conflict with its signature in left-most super <S>.

We will not generate further code for such a method.

The attempt at projection will fail. The class implementor will have to re-write one or more of the classes involved to resolve the conflict.

If a property is defined one way in its class but another way in its primary superclass, then don't allow projection.

The attempt at projection will fail. The class implementor will have to re-write one or more of the classes involved to resolve the conflict.

Caché will now allow projection if a class is "static" and if it contains only class methods and no properties or instance methods.

There have been deficiencies in the Language bindings where the customer has been allowed to project certain class definitions that result in code that either does not compile or does not work.

Since the Caché projection mechanism is based on deriving information about a class from its primary superclass and it is extending this superclass in Java or C++ that provides so much functionality, we have to insist that this primary superclass be a %RegisteredObject. We deny projection if the class has a primary superclass that is NOT a %RegisteredObject and it is not "static." A "static" class has only class methods and no properties or instance methods.

In other words, if A extends B,C and B is not a %RegisteredObject and A is not "static" then A is not projectible and we cannot generate code for A in Java or C++.

Also, if a class is persistent then in Java the class must extend Persistent. There is a similar rule for C++ (d_persistent). So if a class is persistent, its primary superclass must be persistent.

So if A extends B,C and A is persistent, then B must be persistent for A to be projectible. Otherwise, we will refuse to project B with an error message.

Some prior restrictions on class projections have been lifted.

In C++, Java and EJB bindings make a class not up-to-date by editing it but not compiling it. Users should compile the class before projecting it.

The possibility of projecting an out-of-date class definition has been closed.

Add new TYPENAMESPACE class parameter for %SOAP.WebService and %SOAP.WebClient to control XML namespace of types used by SOAP Web methods. This new parameter works with the existing NAMESPACE class parameter and SoapNameSpace method keyword to determine the XML namespaces for the Web service or client.

NAMESPACE is the default XML namespace for the client or service.

SoapNameSpace is the XML namespace for the method definition in the WSDL. If SoapNameSpace is not specified for a method, then NAMESPACE is used as the method namespace.

TYPENAMESPACE is the XML namespace for the types used in the method arguments and return types in this Web client or Web service. If TYPENAMESPACE is not specified or is "", then the default namespace used for the types is from the NAMESPACE parameter.

The handling of types and namespaces in SOAP has been improved.

The following changes were made:

1. xsi:nil on a element that maps to a property that is an object reference currently sets the property to "". This is not correct, since the XML schema standard requires that any attributes be imported. Therefore, XMLImport now creates an object with default values and sets any specified attributes.
2. Treat xsi:nil="1" the same as xsi:nil="true" per schema standard.
3. Support xsi:null="1" for SOAP-encoded XML documents.
4. Add namespace test for xsi:nil to correct errors during XML import.

XMLImport now conforms more closely to the XML Schema standard.

Caché and SQL now use the same underlying algorithm to calculate WEEK. SQL was changed to use the Caché calculation.

SQL applications using WEEK may get different (but now correct) results.

The %SQL.Manager.CatalogPriv.UserNamespace query used to return a single row of "<ALL NAMESPACES>" if a user had access to all namespaces. Now it actually lists all the namespaces that the user has access to.

Applications which looked for the string "<ALL NAMESPACES>" will have to be re-coded.

A change has been made to SQL DDL DROP TABLE to not allow the DROP of the table if any external (defined on another table) Foreign Key constraints are defined which reference the table being dropped. This behavior is consistent with the RESTRICT form of DROP TABLE. At this time, Caché does not support the CASCADE behavior of DROP TABLE. This change in behavior might cause some applications to return an error on a DROP TABLE where the DROP TABLE used to succeed. Applications must now DROP all referencing Foreign Key constraints before dropping the table they reference. This avoids dangling Foreign Key constraints.

There is a new SQLCODE error.

If you attempt to drop a table which has a foreign key referencing the table from another table, the following error will be returned:

SQLCODE: -320
Cannot DROP table - One or more Foreign Key constraints reference this table

A loophole which would allow DROP TABLE to create dangling foreign key references has been closed.

Prior to this change, when a Foreign Key is added to a table through DDL and the Foreign Key constraint references a key in the referenced table which is also the IDKEY, Caché turned the field specified in the Foreign Key constraint into a reference to the referenced table. Now Caché will no longer turn the field into a reference if there is already data in the table when the foreign key is added through DDL.

Also, when a Foreign Key is dropped from a table through DDL and the Foreign Key constraint references a key in the referenced table which is also the IDKEY, Caché turned the field specified in the Foreign Key constraint into a regular field, not a reference to the referenced table. In the case where the field was a %Library.String type, this might result in the field suddenly getting a new collation. This occurred because the default collation for a string field is SQLUpper, but the collation of an IDKEY string field is always EXACT. Now, if this reference is dropped because the foreign key is dropped through DDL and there is data in the table, Caché SQL retains the EXACT collation setting for the field.

Changes which affect index ordering now cause indexes to be rebuilt.

When reading sequential files in OpenVMS where the file open options are "WUN", Caché now correctly sets $XB with the record terminator.

Applications reading from stream files on OpenVMS systems may experience different behavior at EOF.

• Control Panel
  • List more than 1000 processes in Control Panel
  • Inadvertent deletion of locks via the Control Panel is now more difficult.
• CSP
  • Error in CSP if attribute name is very long
• CSP.Compiler
  • Address issue in usage of #()# in href attribute of <a> tag
• CSP.Net
  • Change %Net.POP3 and %Net.SMTP to handle non-ASCII mail attachment filename
• CSP.Web Server
  • Built in Web server returns text fields incorrectly
• Explorer
  • Prevent endless loop in Explorer (rtn compare)
• Installation
  • Load Caché Basic Tutorial into SAMPLES database
• Installation.UNIX
  • Address platform detection issue on ppc systems that have CPU names different from proc[0-3]
• Installation.Upgrade
  • Address issue with merging old .def files into a new .cpf file
• Installation.VMS
  • Check if CSP is already configured for Caché and allow users to reconfigure it for new Caché installation
• Installation.Windows
  • Japanese error messages are now available on localized systems
  • Localize CSP Gateway upon installation
  • Do not try to register ODBC driver when it is not selected to be installed
  • Update description for ODBC component
  • Address an issue with install not detecting IIS Scripts directory
  • Install all files required for ActiveX connectivity when it is selected to be installed
• Languages
  • <NOLINE> compile error will not overlay previous error
  • Support Caché Basic Copy/Merge for multidimensional properties
• Languages.Cache Basic
  • Support Caché Basic Erase of multidimensional properties
  • Allow Caché Basic label and code on same line
  • Generate debug map for Caché Basic in debug mode
  • Address Caché Basic compilation errors with labels on IF
  • Disallow bad assignment syntax
  • Caché Basic allows external procedures to be called even though label is a Caché Basic reserved word
• Networking
  • Big Unicode strings over ECP cause access violation
  • Addressed ECP transaction bitmap array size.
  • Sometimes, rollback over ECP would cause ECP activity to hang.
  • Linux write daemon attaches network SHM at wrong address
  • Added multiple NIC support for clusters using DCP
  • Replication over DCP with Caching turned off now really turns off caching
  • Address "If $D(^gvn)" when mapped via subscript-level mapping to legacy DCP server such as DSM
• Object
  • Do not export time modified or checksum in XML format
  • $SYSTEM.OBJ.Export returns error if item not found
  • $system.OBJ.Export of global modifying CR/LF characters
  • Prevent unexpected Studio shutdown when there are circular dependencies
  • Correct %ClassDefinition to not lose Storage definitions
  • Support more than three status parameters in DecomposeStatus
• Object.Activate
  • Detect when an WSDL message definition has an empty complex type
  • Support Streams for Method Arguments/Properties > 32KB
• Object.Class Compiler
  • Change property superclass order
  • Support list of items to import as subscripted array
  • Report all signature errors at once
  • Do not count errors in class projection compiles
  • Add %Extends to %RegisteredObject
  • Only allow subclasses of %RegisteredObject to be instantiated
  • Method and property of the same name causes compiler to generate wrong syntax
  • Allow language of code generated code to be specified
  • Allow some huge classes to compile
  • Swizzling an object in a collection would set parent as modified erroneously
  • Address issue with parsing instance variables with '%' in their name
• Object.C++
  • Generate code for a dynamic C++ binding
  • In dynamic C++ binding generate code for %Oid and %Save
• Object.Java
  • Enhance dynamic C++ support
  • Addressed issues in SysList
  • Bulk load and create in Java Binding
  • SList#clear() and #remove() implemented
  • Correct Java projection generation on the client side in 5.0
  • generateClassLocal() and generateClassRemote() behavior is opposite to expected
  • Support queries and stored procedures in Java binding
  • Make classLoader variable local to routine
  • Add Stream interface to ExportJava
  • Don't automatically project new collection types that appear in properties
  • New Java Generator collection support
• Object.LanguageBindings
  • Export Stub Methods of the form <XXX>Open and <XXX>Exists
  • Don't generate get method or set method for property if private
  • Package of classname is used for classes in CLASSLIST In EJB projection
  • Produce clearer error message when APPSERVERHOME is not specified
  • Allow sqlproc to compile even if method does not return a value
  • Address calculation of principal and index fields in EJB when dealing with child tables
  • Create right serial constructor when serial only appears in child tables
  • Let DATASOURCENAME override res-ref-name
  • Don't generate import of the superclass since the superclass is fully qualified
  • Allow CMP projection to happen even if superclass does not have primary key
  • Address <METHOD DOES NOT EXIST> error when a class was not %RegisteredObject
  • Correct Java code generation for method with output parameter type
  • Change how getClassProperties and getClassMethods are called in Java binding
  • If a property is not "insertable", it should not be present in CMP create
  • Add "public" to list of Java reserved words used by the Java generator
  • Don't project "set" methods for read only properties
  • Don't allow property name case to affect CMP compilation adversely
  • Restore old-style Java collection projection in 5.0.3
  • Allow exists(...oid...) method to generate in 5.0.3
  • Protect conflicting signature test against a null superclass
  • Set appropriate package for superclass
  • Do not allow projection to EJB when child tables are invalid
  • Allow pathological case of serial with no properties to project in EJB
  • Don't add classes in methods to dependencies in EJB projection
• Object.Library
  • Prevent infinite loop in %ClassDefinition:SubclassOf query
  • Change error message if a class lock in %Routine fails.
  • Prevent potential looping in MSM-Activate server when socket closes executing a command
  • %Dictionary.PackageDefinitionQuery:SubPackage query not working correctly
• Object.Relationships
  • %IsModifed is set because of Relate code
• Object.Soap
  • Properly report unable to create stream error in SOAP Web client
• Object.XML
  • Schema change for CSP file exported as XML
  • XML export of a class definition must export all defined items
  • Address XML import issues
  • XMLExport all keys for a relationship
• SQL
  • Prevent $system.SQL.TuneTable() from failing with <NOROUTINE> error
  • Add ROWID_FIELD column to %Library.SQLCatalog.SQLFields query
  • Add support for ODBC Scalar functions {fn USER()} and {fn DATABASE()}
  • Don't output error message in Query Processor if displaylog is disabled
  • DDL API: Return error properly if BuildExtRoutine fails
  • SQL Enhancement - Add support for {fn CONVERT(value, SQL_DOUBLE) }
  • UPDATE with unbalanced quotes not rejected
• SQL.GateWay
  • Only try DSNConnect if user and password are empty
• SQL.JDBC
  • JDBC: Remove support for get/setUnicodeStream
  • XDBC: Use ^CacheTemp instead of local variables for bulk operations
  • Address <UNDEFINED>SPFetch2+1^%qserver> error
  • Leading zero in ResultSet.getString() with DOUBLE
• SQL.ODBC
  • Changes for WTS (Windows Terminal Server) licensing in ODBC
  • Use input buffer length when calculating number of Unicode characters
• SQL.Query Processing
  • An IN clause with one parameter causes multiple CachedQuery entries
  • Push conditions into UNION subqueries
• Studio
  • File -> Open URL gets "Unable to connect" message
  • Initialize document if default is missing
  • Support for XML, JS and CCS files
  • Do not lock class if user clicks on inspector's left column
  • Make connection string compliance case insensitive
  • Issues with 'Windows' window in Studio
  • Rename "Project" window to "Workspace"
• System
  • HALT command within $ZTRAP will execute $HALT routine
  • Address issues with auto recompile
  • Prevent <SYNTAX> error in $TEXT()
  • Avoid invalid NEW frame following a <STORE> error
  • Ignore partial Write Image Journal (SFFORCEIMJ flag) and always use "full" mode
  • Caché generates a console log entry with an error when it sets wdstop
  • Automatically raise max database size to prevent a <FILEFULL> from hanging the system
  • Update Caché to add to (not replace) the existing write daemon queue
  • Address display for 4 digit years in showdata and test for starting journal file in findfiles
  • Add access mode so Caché can use the correct exit handler
  • Add "resjob" code to exit handler to shut down process when its invoked
  • Correct string stack discipline in Caché
  • Address system interruption from starting PATROL after %MONLBL is started/stopped
  • Add performance warning to ^%MONLBL
  • Address possible access violations from interaction of ^%MONLBL and ^PERFMON
  • Address issue with journaling $BIT sets
  • Pass smaller convert count to client if necessary to improve network lock fairness.
  • Prevent cluster slave job's $INCR blocking ENQ10 or ENQ13 on backup operation.
  • Prevent DDP Daemon crash over DCP cluster connection when the cluster DCP connection is down.
  • Journal $INCR on ECP server if in transaction.
  • Address possible stranded lock in DELOCK_NEED state.
• System.Cluster Specific
  • Track which system set a switch in a cluster so we can clear it during failover
• System.I/O
  • Allow entry into environment when terminal is held by a ghost job.
• System.Journaling
  • Address an issue with cluster journal sequence numbers on network server and client
• System.Licensing
  • Un-deprecate $$inquire^LMFCLI
• System.Shutdown
  • Cstop.exe on windows encounters Run-time error '62' with UNIX format key
• Utilities
  • GBLOCKCOPY translates collation into an subscript-level-mapped destination (such as ROUTINE global)
  • Create /raw mnemonic for %CHARWIN

Previously, the Control Panel displayed only approximately the first 1000 processes. It nows displays all of them.

The entire list of processes is visible from the control panel.

Caché now prompts for when a request is made to delete a lock from the Control Panel.

Inadvertent deletion of locks via the Control Panel is a little harder.

If you pass in a URL with an attribute name that is very long, then it would cause an error in CSP. We do not support attributes longer than 254 characters, so now it ignores this request to set a long attribute name.

Error checking on attribute names in CSP is improved.

Correct a deficiency introduced in 5.0.1 where usage of #()# in href attribute of <a> tag no longer generates ..Link as needed. The ..Link is now produced as in 5.0 release version for #()# in href.

The use of #()# in href attribute of <a> tag now works again.

Address issue where attachment names which are not ASCII are being improperly decoded when downloaded using %Net.POP3, even though content-disposition properly returns the filename, that is msg.Filename was not converted correctly and now is.

Also change %Net.SMTP to properly encode non-ASCII filename.

Non-ASCII filenames in attachments are now handled correctly.

An <input type=text name="txtName"> field in a form with ENCTYPE="multipart/form-data" is returned by the built in Web server in %request.MimeData("txtName",1) stream. It should be return in %request.Data("txtName",1) which is the way CSP Gateway works.

Web server now returns proper datatype.

An issue has been addressed that caused an endless loop in Explorer when comparing a routine from a sequential file with the one in the database.

Explorer now operates properly.

Bastutorial.xml is now loaded into SAMPLES database so users don't need to import this XML file to run the tutorial.

No special action is needed by users to run the Caché Basic tutorial.

We now obtain correctly identify the platform type as a PPC when processor names are not of the form, "proc0" to "proc3".

Caché correctly identifies multiCPU systems.

Caché sometimes failed to recognize old platform names when using the configuration file converter utility. This would only affect upgrades from Caché 2.1.9 or earlier versions. This now works properly.

Upgrades from older versions are easier.

CSP install script now checks if Apache configuration files have a CSP section and, if so, asks if the user wants to update it for new Caché installation.

Upgrades to Apache CSP on OpenVMS are now automatic.

There are 2 things you need to do in order to see the Japanese error message:

1. Load the Japanese error messages. The command is:

   Do Import^%occMessages("c:\cachesys\bin\errors_ja.xml")

2. Set the default locale of the server to be Japanese. The command is:

   Set ^%SYS("LANGUAGE","CURRENT")="ja"

After these 2 steps, you will be able to see error messages in Japanese.

Users of Japanese systems now can see error messages in that language.

Perviously, the CSP Gateway was not localized by default on non-English locale systems. In order to localize it, for example for Japanese, a user needed to perform manual operations.

This process is now done automatically upon installation.

CSP recognizes locales and configures itself accordingly.

When any component under SQL Tools was selected, install erroneously detected ODBC components as selected (even if it was not).

Install now checks only for conflicts with the software to be installed.

Description for ODBC driver component was incorrect, there is actually no dependency on Caché Direct.

An erroneous conflict message has been corrected.

Address an issue with install not detecting IIS Scripts directory which resulted in WebLink IIS module not being installed.

Install properly handles IIS detection.

Some files required for ActiveX connectivity were not installed when this component was selected to be installed and Cache Tools was not selected. Also addressed another issue - shortcut to SQL Manager was not created when it was installed without Cache Tools.

Improved install selection of components.

An issue in the ObjectScript compiler could prevent the proper splitting of large object routines into proper-sized smaller routines. This has been corrected.

Some large routines that failed to compile now do so.

The Caché Basic COPY and MERGE commands now take multidimensional property references as operands.

Caché Basic now works better with multidimensional data.

The Caché Basic ERASE commands now take a multidimensional property reference as an operand.

Caché Basic now works better with multidimensional data.

A restriction in the Caché Basic compiler prevented a label and executable code from appearing on the same line. This has been removed.

Caché Basic syntax processing for labels is improved.

When Caché Basic code was generated and compiled in debug/line mode a debug map was not being generated. If an error occurred when executing a line of Caché Basic code in debug mode, then the caret pointer would just point to the beginning of the line and not the command which caused the error. This is changed.

Debugging Caché Basic programs is improved.

Previously, if the program had a label and then the next line was an IF block, the compiler would give an error. This has been changed.

Easier compilation of Caché Basic programs.

This syntax was currently allowed by the Caché Basic parser:

   #classcontext a
   call ME.PROPERTY = a
   #endclasscontext a

which is obviously incorrect. This syntax is now reported as an appropriate syntax error.

Better syntax checking for Caché Basic.

In code such as this:

   ...
   target="Demo.DTL.ExampleOutput".%New()
   If target="" Then
      tSC=Error@%apiOBJ(5761,"Demo.DTL.ExampleOutput")
   Exit Do
   End If
   ...

The call to Error@%apiOBJ() was flagged as invalid use of a reserved word. The Caché Basic compiler/syntax checker now checks to see if the token following the presumed reserved word is an @sign. If so it goes on to validate an external call rather than just raising an invalid use of reserved word exception.

Improved syntax checking in Caché Basic.

64KB uncompressed Unicode big-string may cause a SEGV ECP in the client job. The string length was not maintained properly. This has been corrected.

More reliable operation in the presence of long Unicode string usage.

The initial ECP pending transaction bitmap length wasn't calculated correctly. It corrupted data causing an error in the ECP client read daemon. In rare cases, ECP would fail. This has been corrected.

Improved ECP reliability.

This change addresses an issue with ECP server hanging. There was an ordering issue with rollback across the network and ECP server pre-fetching. The ordering has been corrected.

Improved ECP reliability.

The write daemon method for allocating shared memory has been changed so it now works the same on Linux and other UNIX systems.

improved reliability on Linux.

This changes solves two issues with multiple NICs.

1. A cluster member may not register a proper IP and port in the PIJ file, and slaves cannot locate/ communicate with the master.
2. Slaves may not locate a correct net port to communicate with the master, and may not join the cluster.

It is recommended to define and use this when the cluster node has multiple/ambiguous local addresses.

Improved reliability of cluster failover with multiple NICs.

Corrected an issue with DCP that prevented the EnableCaching=0 operation from working properly on SET command references.

DCP caching now performs as specified.

Corrected an issue that could cause incorrect results for $DATA in the case where the data is accessed over DCP through a namespace that makes use of subscript-level mapping and the destination of the reference is a DSM system or other kind of older system using the backwards compatibility features of DCP.

Specifically, when the data server is a DSM system, and ^Global uses subscript-level mapping, and $Data(^Global(1)) would return 10 (children but no data node), then:

   If $Data(^Global(1)) DO STUFF

would skip doing the STUFF that follows the "if", even though it should succeed.

Improved reliability using DCP.

When exporting classes to XML format no longer put the checksum in the file to detect when the file is modified by an external editor. Now the checksum is put in the class definition inside Cache. This also allows us to remove the time modified field from the XML export format. The logic is

• On export, the classes that are exported are updated with the checksum of the file created after the export is complete.
• On import, if importing a class and the checksum in the class matches the one in the file, then the definition must be the same so the time changed in the class is kept.

If the checksum does not match then this is a different version so the modified date in the class is updated.

Improved detection of class modification.

When exporting items with $system.OBJ.Export, if an item was not found it would report this to the terminal, but it would not return an error code. Now it returns a suitable error code you can detect if the export worked correctly.

Improved error reporting.

The export and subsequent import of a global via the $system.OBJ.Export function would change CR/LF into just LF and CR into LF. This is caused by SAX normalizing CR/LF and CR to LF as it should. To avoid changing the structure of the global we now base64 encode any global that contains CR characters ($char(13)).

Correct handling of special characters in GLOBAL export / import.

A Studio issue when there are circular dependencies, such as two classes extending each other, has been addressed.

Studio no longer fails in the presence of this situation.

When using %ClassDefinition to edit storage, some parts of the storage definition were lost. This change addresses that.

Improved reliability for application development.

Currently the $$$ERROR() macro and the method it resolves to, $$Error^%apiOBJ(), only support 3 arguments. This has been extended.

Improved application error reporting.

WSDL containing a snippet such as

   <s:element name="About">
        <s:complexType />
    </s:element>

was not handled correctly. The assumption was that a complex type would always have children. This is not the case so the code now guards against this condition.

Improved WSDL reliability

Previously, streams could not be passed to Activate Methods or Set as Activate properties. This new functionality provides the ability to pass a character stream to an ActiveX object via the %Activate.GenericObject existing methods. The implementation detects if a Caché character-stream object has been passed and informs the underlying Activate DLL that it should treat the parameter as a stream rather than a string. At that point the DLL calls back to read the entire stream into a string before passing it to the ActiveX object. In this way strings of any size can be passed to ActiveX objects.

Passing these streams BY REFERENCE is NOT supported at this time.

Improved stream handling as arguments to ActiveX

Properties have a superclass of the property class, %CacheProperty. By default, this is the type class, if it is a datatype. The order in which these classes are specified causes like-named parameters and methods in the type class to be overridden by the property class. Users cannot change property class behavior easily so that means no property class methods or parameters can be easily changed.

The order of the superclasses has been changed so the type class is second in the list which causes type class parameters and methods to override their property class counterpart.

Improved flexibility and ease in class hierarchy design.

In the XML, the import function accepts the list of items to import as a subscripted array as well as a comma-separated list. This allows the list to be over 32KB in size.

Also modify the CDL load to support subscripted array and the Load^%apiOBJ function as well.

Improved handling of class imports.

When checking the class signature against the superclass to make sure it matches, if an error was found it would report that error and stop checking at that point. This meant that if a subclass had multiple signature errors then you would only see one at a time. This would slow down the process of addressing these. Now we report all the signature errors in one go, so they can be addressed at once.