Skip to main content

Caché 2014.1

This chapter provides the following information for Caché 2014.1:

New and Enhanced Features for Caché 2014.1

The following major, new features have been added to Caché for this release:

Furthermore, this version of Caché has been improved and enhanced in the following areas:

In addition, many more localized improvements and corrections are also included. In particular, if you are upgrading an existing installation, please review the detailed list of changes in the Upgrade Checklist.

Major New Features

Support For REST

This version introduces support for handling REST requests, routing them to a given namespace, and processing them. This support is at the level of the CSP Gateway.

This feature is predicated on providing a Web application that routes all requests to a given handler class that, based on a URL mapping facility, then dispatches the calls to the correct class and method implementation. With this feature, Caché can now handle any REST interface; for data transport, Caché supports XML or JSON.


This feature is not available on OpenVMS systems.

See Creating REST Services in Caché.

Rapid Application Development

64-bit Version of Activate

Caché applications on 64-bit systems can now take advantage of the new 64-bit version of Activate on all supported platforms and use 64-bit ActiveX objects.


While the client technology that communicates over a protocol can be 32-bit or 64-bit, the server technology must consist entirely of only 32–bit or only 64-bit modules.

Support for Websocket Protocol RFC6455

In this release, InterSystems introduces support for WebSocket connections. Application developers may access to this technology via the class, %CSP.WebSocketOpens in a new tab which provides a protocol to build richer web applications, and a more lively user experience. WebSockets form a TCP connection between the server and the client over port number 80, and the protocol is supported by Google Chrome, Internet Explorer, Firefox, Safari and Opera.

Cube Manager for DeepSee

DeepSee previously included methods to build and synchronize cubes. With this release, DeepSee now includes the Cube Manager which provides a user interface for scheduling when to build and synchronize cubes. The Cube Manager is available from the DeepSee Admin menu, and allows you to define groups of cubes and the update frequency for these cubes.

The DeepSee Tools menu also includes the Model Browser which displays a diagram showing the relationships between cubes. This high-level diagram helps you understand how cubes are related.

Domain Definition Infrastructure

This new feature is of interest to all users that want to integrate the creation of iKnow Domains in a regular class-based implementation. It allows an application to specify an iKnow domain definition as part of a user class that inherits from %iKnow.DomainDefinitionOpens in a new tab. When the class is compiled, the compiler will create an iKnow domain corresponding to the settings specified in the Domain XData XML. All “static” settings defined for the domain will be set at compile-time through calls to the underlying APIs.

The application can also define sources of text data to be loaded into the domain. This data becomes part of a generated %Build() method in a new class named [classname].Domain. When invoked, the method loads all data from the defined locations into the domain. Matching and metrics elements can be associated with the domain; these will be applied on all sources added to the domain.

Framework for Text Categorization

This new feature is a framework for categorizing text indexed by iKnow. Classification takes place in two different steps: building a classification model, and running the classification model against text to be categorized.

A classification model is defined through an XML structure (XData block) in a subclass of %iKnow.Classification.ClassifierOpens in a new tab. A classification model can be run on random input text or on an existing iKnow source by using its %CategorizeText() or %Categorize() methods. This will return an ordered array with the categories associated with the text sorted according to their “score”.

Globals C API

The C version of the Globals API provides an extremely fast, flexible persistence model that can be used to implement a wide variety of storage paradigms. It provides the same functionality as the Java, .NET, and Node.js Globals APIs, for developers working in C, C++, or any language that supports the C calling conventions. It can be used directly by application developers, and can also be used to implement versions of the Globals API in other languages such as Ruby.

UDP Socket Support

In this version, Caché introduces a new class, %NET.UDP which enables application developers to use UDP packets for communication. UDP is a connectionless way to communicate, and is often used for broadcasting or multicasting. For additional information and examples, please refer to the class documentation for %NET.UDP.

Unified Trigger Support for Objects and SQL

In this version, Caché adds support for triggers in Objects that equate exactly to SQL Triggers. In addition to the various %OnXXXX callback methods (which continue to be supported), you can now define a trigger that will fire for INSERT/UPDATE/DELETE events whether they are done via Object or SQL access. This change provides a consistent behavior regardless of whether data is manipulated as class instances or SQL tables. See the Caché Objectscript Reference for further details.


In this release, the SQL parser now accepts the “Insert OR Update” syntax. The statement executes just like an INSERT; but when Unique constraints are encountered, it assumes you want to overwrite that record instead of inserting a new row. This syntax is very useful in the case where you want to see if a record exists in the database before deciding to do an insert or update. Now you can manage this in one execution.


If SQL matches on a Unique check but the UPDATE would change the IDKEY value, the UPDATE will fail as this is an illegal operation.

64-bit Versions CacheActiveX and ConnectionGUI

Caché nows supports 64-bit versions of CacheActiveX and ConnectionGUI. Their connection info continues to be taken from the 32-bit registry.

ZEN Reports Generate HTML5 in HTML Mode

Beginning with this release, the HTML output of Zen Reports has changed. Caché will now have the HTML generator create a valid HTML DOCTYPE in the output, and the generated code generated will match the standard as well. This should result in optimal rendering for modern browsers that support the HTML5 standard.

Performance and Scalability

MDX Performance Diagnostic

The new utility class %DeepSee.Diagnostics.MDXUtils collects performance diagnostic information for MDX queries. The utility records, for a given MDX query, such information as cube statistics, query path, query statistics, and system resource usage. If an MDX query appears to have a performance problem, this utility provides information that can help diagnose the problem.

Reduce Memory Allocation in the iKnow Engine

This release optimizes the way in which dynamic memory is allocated and deallocated in the iKnow Engine. It improves the throughput speed of the iKnow Engine by 15% to 25%, depending on the platform. The change is active on all platforms except Solaris where the performance remains as it was in previous releases.

8-way Interleaved AES-NI CBC Decryption

Processor vendors continue to improve the hardware acceleration support for AES encryption. In this release, Caché now detects if the processor supports eight-way pipelines. By taking advantage of this enhancement, the performance of AES-NI further increases.

Push Subquery Conditions into UNION Legs

The Caché release includes an optimization for SQL performance involving sub queries. In prior versions, when a UNION query included a conditional expression on a sub query, the entire result set would be executed and then reprocessed to apply the conditional check. With this optimization, the conditional check is applied on the first pass through the data greatly enhancing the performance of the operation.

No code change is required other than purging cached queries to take advantage of this feature.

Support Separate Selectivity for Frequent Outlier Values

In this version, TuneTable includes an additional feature. Certain outlier values, where conditions on these values sometimes result in decreased performance, have now been coded to produce inflated selectivity values. The intent of the change is that these values will result in queries that avoid using indices containing these outliers. This change should result in greater likelihood of queries using the best possible index.

For an application to benefit from this change, TuneTable must be used, and any existing cached queries purged, so the optimizer will take advantage of the new selectivity values.

ROLLBACK Performance

ROLLBACK performance has been improved in this release by roughly 20%-40% over previous versions. This improvement was measured while rolling back single (large) transactions, as well as bulk rollback (as would occur during startup recovery).

Database Defragmentation And Compaction

This release reintroduces two database management capabilities:

  1. Compact a database.

    This feature moves free space distributed throughout the database to its end. You can then return the free space to the underlying file system by truncating the database (the truncation feature was already available in previous versions)

  2. Defragment globals in a database.

    This feature rearranges global blocks within the database so that all of the blocks containing data for a given global are in consecutive sequence.

While these capabilities are not needed for day-to-day operation, and most systems may never need them, they can make certain special operations easier. In prior versions, when the type of database reorganization described above was needed, it required downtime while using the ^GBLOCKCOPY utility to migrate the data to a new database.

Details on these and related capabilities are described in the System Administrator documentation.


Both of these capabilities had appeared in certain previous releases and both had been removed in the more recent releases. These features should not be used in any version prior to 2014.1. These capabilities have been revised and are available for use again now in 2014.1.

Reliability, Availability, Maintainability, Monitoring

License Registration in Cloud Environment

When an InterSystems license key is activated on a Caché, Ensemble, or HealthShare instance in the Public Cloud (for example, Amazon EC2), InterSystems may collect system information (# of processors, OS type, license key ID, etc.), and send this information to a secure server in the InterSystems network. The scope of the information collected is limited to that needed for an audit of InterSystems license usage in the Public Cloud.


Implement a Secure Shell for Debugging

Administrators may now provide users terminal access with a secure debug shell to better control access to sensitive data. This new shell protects against malicious role escalation and the injection of code to run with higher privileges.

Delegated Authentication Now Supports Two-Factor Authentication

With the release, application developers can now use the built-in mechanism for two-factor authentication from their custom authentication mechanism(s).

Technology Preview

This category is new with this release. It is intended as a way of introducing and providing access to new software capabilities that InterSystems believes will be useful in enhancing the effectiveness of existing and future applications.

The capabilities listed here are ready for use by customers, but they are not yet complete in functionality and design. Customers who take advantage of these capabilities must understand:

  • InterSystems makes no backward compatibility guarantee with future updates;

  • Customers may incorporate these capabilities in deployed applications, but must first check with InterSystems to determine best course of action;

  • Customers who deploy these capabilities in their applications must commit to upgrading to the final released version.

InterSystems strongly encourages those who incorporate these items in their software to provide feedback on their experiences.

iKnow Negation

InterSystems introduced this feature as experimental in Caché 2013.1 with focus on the English language. As of this release, negation is no longer experimental and iKnow Negation functionality is available for all iKnow supported languages (Dutch, English, French, German, Spanish, Portuguese).

The uniqueness of iKnow negation detection rests on the fact that not only linguistic markers of negation in a sentence (such as “not”, “no” and “didn't”) are detected, but that iKnow also marks their semantic scope and span. In the sentence, “John has no signs of headache but has a fever.”, the linguistic negation marker is “no”. The iKnow negation detection will not only detect the marker but also its extent. iKnow will establish that “John has no signs of headache” is the negative part of the sentence. An important aspect of this is that the span of a negation is limited to the length of the semantic pathway of which the negation is a part.

Studio Refactoring

This release InterSystems includes support for the refactoring of code in the Studio. Initially, the available options will be:

  • Change Class Name

  • Change Property Name

  • Change Method Name

Additional options will be incorporated in future releases.

In this release, refactoring is only available when Studio is connected to a Windows server.

iKnow Customized Summaries

This feature was introduced in experimental form in Caché 2013.1 for those who desire to tune the content of iKnow generated summaries to their specific needs. This feature is now stabilized, it can now be used for all languages supported by iKnow (Dutch, English, French, German, Spanish, Portuguese) and the feature is ready for generalized usage.

Main parameters for tuning the summaries remain as they were:

  • force sentences to be included in the custom summary, e. g. when summarizing a newspaper article it can be beneficial to always include the first two sentences.

  • force inclusion or exclusions of sentences by listing words and/or word groups. If a sentence contains one of the elements in the list it will be included in the summary (or excluded from the summary).

  • overweighting or underweighting certain words and/or sentence parts. In this case the weight of sentences containing one of the elements in the list will be adapted in accordance with the weight instructions specified by the user. These adaptations will influence the sentence rankings used in the summarization and include or exclude the elements specified by the user if the context of the text allows to do so.

The listed options can be set by means of an extra parameter in the SourceAPI.GetSummary method.

New Zen Support For Mobile Development

The version of Caché introduces a new helper page to aid mobile support in existing Zen applications. This new base page provides support for mobile specific notions such as multi touch events, geometry changes, rotation, and so on with appropriate callback support to enable users to handle these events programmatically. Some new widgets designed specifically for mobile devices like scribbleArea have been added to the Zen Component Library as well with matching samples.

Support For XSLT2

This version of Caché now provides support for XSLT Version 2, a significant advance in capability over XSLT Version 1. Among the new features Version 2 provides are:

  • A more convenient and expressive transformation language plus support for XPath 2.0 and the new XDM (XPath Data Model).

  • Strong typing, support for XSL schema types, and the ability to define your own (schema) types. XPath 2.0 also includes a new sequence type not present in Version 1.

  • A much more powerful functional language with improved string processing, date and time handling, node-set manipulation, and boolean operators.

  • The ability to define and write functions in pure XSLT via the xsl:function instruction.

These, and many other improvements/new features significantly increase the productivity of any XSLT programmer. Strong typing allows many errors to be caught at compile time and to be corrected immediately.

XSLT Version 2 functionality is available via the classes in the %XML.XSLT2 package.


XSLT2 functionality is not available on the OpenVMS platform.

Caché 2014.1 Upgrade Checklist


The purpose of this section is to highlight those features of Caché 2014.1 that, because of their difference in this version, affect the administration, operation, or development activities of existing systems.

Those customers upgrading their applications from earlier releases are strongly urged to read the upgrade checklist for the intervening versions as well. This document addresses only the differences between 2013.1 and 2014.1.

The upgrade instructions listed at the beginning of this document apply to this version.


This section contains information of interest to those who are familiar with administering prior versions of Caché and wish to learn what is new or different in this area for version 2014.1. The items listed here are brief descriptions. In most cases, more complete descriptions are available elsewhere in the documentation.

Version Interoperability

A table showing the interoperability of recent releases is now part of the Supported Platforms document.

Management Portal Changes

Numerous changes have been made in the Management Portal for this release both to accommodate new features and to reorganize the existing material to make it easier to use. Among the more prominent changes are the addition of pages to assist with database mirroring and the separation of roles.

Operational Changes

This section details changes that have an effect on the way the system operates.

Extent Support Removed

In version 2010.1, InterSystems announced that support for database extents was deprecated. In this version, support for extents has been removed altogether.

Those customers who still have systems employing database extents and who wish to upgrade to this release, must consolidate their existing databases down to a single cache.dat file. There are two options for this:

  1. Before upgrading to this release, run the GBLOCKCOPY routine to copy the data from the database and its extents into a single new database.

    In this case, the database can be converted and used to replace the existing database. It can be configured and tested prior to the upgrade. This is especially helpful if the database is to be mounted at system startup.

  2. After upgrade, manually consolidate the database using the cdbmerge utility program.

    In this instance, Caché will refuse to mount the database, even if it configured for mount-at-startup. Only after conversion will it be in a format suitable for use.

Option 1 allows for advance preparation and testing prior to the upgrading to this version. Option 2 is provided in case older databases need to be accessed after the system is upgraded.

Support For 2KB Databases Removed

Over the last several releases, support for 2KB databases has been incrementally restricted. InterSystems urged users with 2KB database to convert them to 8KB databases.

Beginning with this release, 2KB databases can no longer be mounted at all, and are therefore no longer supported. If you have 2KB databases that need to be converted, you may do so using Caché version 2011.1 or earlier; the conversion can be performed prior to upgrading from these versions, or using a separately installed Caché instance.

Cannot Move Security Exports To Earlier Releases

User security exports from 2014.1 are incompatible with 2013.1 due to the introduction of the "AccountNeverExpires" and "PasswordNeverExpires" fields. If an import to 2013.1 is attempted, the user records are skipped. Deleting these fields in the security export will allow the import of the XML into 2013. The user data will have to be manually transferred.

Change In Memory Usage For XML Processing

In this release, the XML reader now uses local variables for storing its information; previously, it used process-private globals. This results in both a performance improvement and an additional demand on memory. Depending on the sizes of XML documents read, the maximum process private memory may need to be increased to avoid fatal errors.

The current suggested per-process memory is 256MB (it may be set to less than this is upgrading from much earlier releases). See the information accompanying the configuration file parameter, bbsiz, the $ZSTORAGE special variable, and the technical article on Caché Process Virtual Memory for further information.

%SYS.System.WriteToConsoleLog() Defaults To UTF-8

String messages sent to cconsole.log via %SYS.System.WriteToConsoleLog() are now encoded in UTF-8. This applies to all systems, 8-bit and Unicode. Customers who have applications that parse cconsole.log need to modify those application to account for the multi-byte possibilities.

Messages containing only ASCII characters ($CODE < 128) are not affected. Characters with $CODE >= 128 (even those from Latin1, such as “é”) are translated to a sequence of 2 or more bytes. The file, cconsole.log, is still byte-oriented, but in order to correctly display UTF-8 encoded characters, a suitable text editor or terminal emulator should be used.

%SYS.System.WriteToConsoleLog() is the method replacement for $ZU(9, "", message).

Error In Saving SQL Persistent Data Containing Collections Of Objects

Beginning with version 2011.1, if an SQL-enabled class had a property which was a collection (list or array) of objects, the collection was saved in an incorrect format. It must be corrected before the object can be opened successfully.

To permit access the collection in this version of Caché,

  • Access the stored data directly (for example, via a global reference), and remove the outermost $LISTBUILD(...) from the data representation, or

  • Edit the class definition to modify the collection property and specify “CLASSNAME=1” as part of its definition. This tells Caché to use the oid format as was done prior to version 2011.1.

Added Scripting Restrictions

This version of Caché imposes additional requirements on user scripts. First, you can no longer specify an implied namespace on the command line when running a routine in application mode using the -U switch. If you wish to specify a namespace, it must be defined in the CPF file.

Second, Caché now checks the startup code so that, if the user is trying to execute a routine in application mode, the user must have USE access to the service they are trying to run under. The service is one of: %Service_Console, %Service_Terminal, %Service_Telnet, or %Service_ComPort.


The roles %Developer and %Manager have all these resources defined as part of the role. In a locked down installation, the %Operator role does not have these services defined.

If the user has created custom roles which do not include these services, and the services are not public, the user must make these services Public, or add them to the individual roles.

Debugging Requires Write Access

A user who wishes to debug routines or methods originating in the CACHESYS database must have write access to the database. Otherwise, stepping, breakpoints, and watchpoints will be disabled while execution is in the routine.

Behavioral Changes For ccontrol stop

Beginning in this release, a command of “ccontrol stop –nofailover” issued to a non-primary mirror member will be ignored. In prior releases, it would cancel any pending shutdown of that member.

Terminal IO Escape Processing Change

The low-level processing for terminal input examines one character at a time. This processing has been changed so that it will no longer terminate input if a character designated as an input-terminator characters occurs as part of a terminal escape sequence.

Disallow //page.csp As Valid Application

In the CSP application matching code the URL format:


allows one to specify a virtual server using the “//servername” format. In pror releases, this also matched a URL such as “//page.csp”. This is incorrect and has been fixed in this version. The “/page.csp” is valid and can match the “/” application (if one is defined) but “//page.csp” will no longer produce a valid match.

Correct Error In Global Mapping

A re-work of the global mapping routines in 2011.1 introduced an error which allowed a user to enter global mapping ranges in the management portal that overlapped. For example, the following mappings try to map part of the ^X global out of the USER namespace into the SAMPLES database; but they are illegal because they overlap

^X(1):(10) --->SAMPLES
^X(5):(20) --->SAMPLES

When the illegal mapping was activated, the first mapping was ignored, and the second mapping used. In the example, only ^X(5):(20) would be mapped, and ^X(1):(5) would remain in the default database for the namespace, USER. In this case, Caché would write an error message to the cconsole.log file:

09/16/13-10:23:22:195 (9664) 2 Discarding subscript mapping (1):(10) mapping overlaps
                               with a prior mapping global ^X namespace USER

Those customers upgrading from a version after 2011.1 and who map globals or routines should check the cconsole.log for the given message. You can also verify that there are no global mapping overlaps by executing:

Set Status=##Class(Config.CPF).Validate(<CPFFile>)

on the CPF file of the system they are going to upgrade. They should check using this version of the system when they perform the validation. Alternatively, you can use the CPF validator in the WRC. If there are overlapping mappings in the CPF file, they will be displayed.

The actual mapping being activated and used by the system can be show by using this routine entry point in the %SYS namespace on your existing system:


If you have detected that you have one or more overlapping mappings, you must remove the mappings which overlap (and are discarded) before you upgrade. If you do not do this, the upgrade will fail, and you will see the overlap messages in the cconsole.log file.

If this happens, you can simply edit the cache.cpf file, remove the duplicate mappings, and then re-install. After the installation finishes, you can adjust any data locations or mappings desired.

Added Prompts In ^SECURITY

When using ^SECURITY to create a new application in the security tables, two new prompts have been added:

  • CSP/ZEN Enabled? No =>

  • Inbound Web Services Enabled? No =>

These prompts already existed in the management portal, but were missing from the routine. If there are any customer scripts which call ^SECURITY and feed it input, the customer will have to update the script.

Change Default Character Set For 8–Bit Installations

Unicode installations of Caché use UTF-8 encoding for their default page responses while 8–bit Caché installations previously defaulted to using the current locale encoding for CSP pages, e.g. iso-8859-1. As of this release, the default for 8–bit Caché installations will also be UTF-8.

The reason for changing this is due to how CSP form POST and URL encoding works in browsers: all URLs are expected to be UTF-8 encoded and then URL encoded. The server cannot determine if the data comes from a CSP form POST or from a URL link so it cannot correctly convert the data back into characters.

Change Default for CSP Parameter: GZIP Compression

In this version, the default setting for the “GZIP Compression” parameter is now set to “Enabled” for all Application Paths.

Enforce Naming Of All File Types Or Paths Served By CSP

By default, the current CSP Gateway, in the absence of any other configuration directives, will automatically recognize and process files of the following types: “csp”, “cls”, “zen”, “cxw”.

This change enforces a configuration policy through which all files processed by CSP must either be listed in a “CSPFileTypes” directive, or the hosting path enabled using a “CSP On” statement. In previous versions, the above file types were recognized for all web server paths and, as a result, could result in incorrect requests being routed to the CSP engine.


This applies to Apache v2.0 and later.

Add Specific Permission Requirements For CSP Pages

Using the newly added security parameter, SECURITYRESOURCE, you will need to hold specific permissions to view or execute some system classes, namely:

Class Name Permissions
%Studio.SourceControl.UIOpens in a new tab %Development:USE
%CSP.StudioTemplateInsertOpens in a new tab %Development:USE
%CSP.StudioTemplateSuperOpens in a new tab %Development:USE
%Monitor.AdaptorOpens in a new tab <empty>; supplied in subclasses
%Monitor.System %Admin_Manage:USE, %Admin_Operate:USE, %Developer:USE
%BI_AnalyzerGrid %BI_LegacyAccess:USE
%BI_CSPsuper %BI_LegacyAccess:USE
%BI_Chart %BI_LegacyAccess:USE
%BI_ChartCus %BI_LegacyAccess:USE
%BI_ChartLgnd %BI_LegacyAccess:USE
%BI_DashboardGrid %BI_LegacyAccess:USE
%BI_EchoClass %BI_LegacyAccess:USE
%BI_ExcelExport %BI_LegacyAccess:USE
%BI_SMSmsg %BI_LegacyAccess:USE
%BI_SVGCtxtMenu %BI_LegacyAccess:USE
%BI_TestSVG %BI_LegacyAccess:USE
%BI_VennSVG %BI_LegacyAccess:USE
%BI_WebChartList %BI_LegacyAccess:USE
%BI_WebCtxtMenu %BI_LegacyAccess:USE
%BI_WebDashboardE %BI_LegacyAccess:USE
%BI_WebEditQueryCom %BI_LegacyAccess:USE
%BI_WebList %BI_LegacyAccess:USE
%BI_WebReporter2 %BI_LegacyAccess:USE
%BI_WebRoleMtns %BI_LegacyAccess:USE
%BI_WebSCMod %BI_LegacyAccess:USE
%BI_WebTranslation %BI_LegacyAccess:USE
%BI_WordExport %BI_LegacyAccess:USE
%BI_webPreference %BI_LegacyAccess:USE

Platform-specific Items

This section holds items of interest to users of specific platforms.

8–Bit Caché Systems Default To UTF8

Previously, all Unicode Caché installations had the default CSP page use UTF-8 encoding, but 8-bit Caché installations used a default of the current locale encoding, for example, ISO-8859-1. In this release, 8-bit Caché installs also use UTF-8.

The reason for changing this is how form POST and URLl encoding works in browsers; all URLs are expected to be UTF-8 encoded and then URLurl encoded. But form POST will encode using the charset of the page before URL encoding the data.

This means the server cannot determine if the data comes from a form POST or from a URL link (at least not consistently due to things like form POST that uses method="get"), so it cannot correctly convert the data back into characters.


Sites where this is not an issue can restore the previous behavior by issuing the command

Set ^%SYS("CSP", "8BitLocaleCharset") = 1
  • Changes To Callin Kernel

    If you are upgrading to this version, and have an application that depends on your own linking of the callin kernel, you must change the file, shdir.c, recompile it, and then relink callin in order for that application to execute. Specifically, you must add the statement

    const char exeinfo[]="User";

    before recompiling. Failure to do so will result in an unresolved symbol, _exeinfo, at link time.

  • Launcher Now Automatically Starts At End Of Unattended Install

    In this release, the “launcher”, csystray.exe (also known as the “cube”) will be started automatically at the end of an unattended installation process. In preceding releases, it had to be started manually.

    The old behavior can be restored by setting the newly-added property, ISCSTARTLAUNCHER, to "0" in the unattended install.

  • CSP Gateway Change

    The CSP Gateway installation for Apache on UNIX® now uses the “CSPFileTypes” directive instead of “AddHandler csp-handler-sa” in all places AddHandler was used before. This affects regular UNIX®, CSP Gateway standalone, RPM and DMG installs.

  • cstat Options Change

    Beginning with this release, only the owner of the instance may run cstat specifying -u[1, 2, 4, 8].

SUSE Linux 12 Linker Change Affects Light C++ Binding

A change in the linker on SUSE 12 systems prevents Light C++ binding applications from building. The SUSE 12 linker now requires application makefiles to explicitly specify dependent libraries of other libraries with which they link, even if those other libraries specified the dependent libraries when they were linked. In this case, depends on, so starting with SUSE 12 Linux, both libraries must be explicitly specified. Therefore, one of the following changes is needed to successfully build the application:

  1. Add –lpthread to the library specifications in the ld or g++ command line in the makefile used to build the application. For example, if using a makefile based on one of the Master.mak files installed with Light C++ Binding sample applications, change the line:

    CACHETLIB = -L$(CACHETPATH) -lcachet 


    CACHETLIB = -L$(CACHETPATH) -lcachet –lpthread
  2. Set the environment variable MULTITHREADED to 1 in the environment in which make is invoked. In the Bourne shell, the syntax is:

    export MULTITHREADED=1

Either option resolves the issue; they do not conflict with each other, so both options can be used together.


In this release, the support for REST Services announced in the Release Notes is unavailable on OpenVMS. Attempts to use it will result in <UNIMPLEMENTED> errors.


This section contains information of interest to those who have designed, developed and maintained applications running on prior versions of Caché.

The items listed here are brief descriptions. In most cases, more complete descriptions are available elsewhere in the documentation.

Routine Changes

^MIRROR Interface And Behavioral Changes

Option 2 (“Mirror Management”) of the top-level selections has been enhanced. The new menu choices are:

  1. Add mirrored database

  2. Remove mirrored database

  3. Activate or Catchup mirrored database

  4. Change No Failover State

  5. Try to make this the primary

  6. Connect to Mirror

  7. Disconnect from Mirror

  8. Modify Database Size Field(s)

  9. Force this node to become the primary

  10. Promote Async DR member to Failover member

  11. Demote Backup member to Async DR member

  12. Mark an inactive database as caught up

  13. n/a

  14. Pause dejournaling for a database

Items #1, #2, #3, and #14 now include a multi-selection feature and filtered displays. Items #8 and #12 are enhanced with filtered display only.

The multi-selection feature allows you to select multiple databases from the given list. With a filtered display, only databases that are appropriate for the specified task are displayed, when the user presses “?”. For example, when the user chooses to “add mirrored database”, only journaled and non-mirrored databases are displayed.

^PROFILE Permission Requirements Added

Beginning with this release, any user who desires to run ^PROFILE must be a member of the %All role.

Class Changes

Class Deletions

The following classes were present in the previous version and have been removed in this release

  • %CSP — WebLink

  • %CSP.UI — DocLocalize

  • %CSP.UI.Portal — AdvancedSettingsTemplate, Applications, ApplicationsClient, ApplicationsPrivRoutine, ColumnPriv, ISQL, ManageDBActions, RemoteDatabase, Service, ShadowPopup, ZenReportServer, ZenReportServers

  • %CSP.UI.Portal.Config — Network, ZenReport

  • %CSP.UI.Portal.Dialog — MgrDBActions, ZenReportServerAction

  • %CSP.UI.SQL — FormPane, USER, UserPrivPane

  • %CSP.UI.System — ApplicationPane, ApplicationTablePane, BroadcastPane, DatabasePane, DbRoutinesPane, JobInfoForm, LicenseKeyForm, LicensePane, LockForm, NamespaceForm, RemoteDatabasePane, SchemaListPane, SourceControlPane, SystemPane, TaskEditForm, TaskPane

  • %DeepSee.ComputedDimension — iKnow

  • %DeepSee.UI.Dialog — DashboardEditControl

  • %Identity — API, Exception, Link1ResultSet

  • %Identity.Data — Audithist, Classified, Comment, JoinIndex, LinkDefaults, LinkParameter, Linkage, MPI, SpecialAddr, Unclassified

  • %Identity.EntityTypes — CategoricalName, CompoundName, CompoundNameAustralia, CompoundNameFrance, CompoundNameGermany, CompoundNameSpain, EntityAttribute, EntityAttributeFreq, Femalename, FemalenameAustralia, FemalenameFrance, FemalenameGermany, FemalenameSpain, Gender, GenderAustralia, GenderFrance, GenderGermany, GenderSpain, Givenname, GivennameAustralia, GivennameFrance, GivennameGermany, GivennameSpain, Malename, MalenameAustralia, MalenameFrance, MalenameGermany, MalenameSpain, MedicalTerm, Nickname, NicknameAustralia, NicknameFrance, NicknameGermany, NicknameSpain, StatesGermany, StatesUSA, StreetAddress, StreetAddressAustralia, StreetAddressFrance, StreetAddressGermany, StreetAddressSpain, Surname, SurnameAustralia, SurnameFrance, SurnameGermany, SurnameSpain, Text, TitlesUSA

  • %Identity.Util — CopyFrom

  • %SQL — CustomQuery

  • %SQL.DICT — QueryTypeCustom

  • %SYS.EMS — Install, InstallInfo, Utils

  • %iFind — Index

  • %iFind.Index — Find

  • %iKnow.Objects.dd — IndexBuilder, PTask

  • %iKnow.Queries.SentenceWSAPI — GetHighlighted

  • Config — ExtendedHost

  • EMS — Users

  • Ens.Util — IO, PortalModelBase

Class Component Deletions

The following class components have been moved or removed in this version from the class where they were previously found.

Class Type Name(s)
%CSP.UI.Portal.Config.Advanced method DrawAfterCreatePage, DrawLocatorExtra, doBrowse, doRemoteBrowse, onPopupAction
parameter PAGENAME
property LocatorParent
%CSP.UI.Portal.Config.AdvancedTable method DrawAfterCreatePage, UpdateDetails, burstUpdateHandler, clearMessage, updateMsg
property ConfigTypes, ConfigValues, SelectedType, SingleSubject
%CSP.UI.Portal.Config.Cluster property Category
%CSP.UI.Portal.Config.Compatibility property Category
%CSP.UI.Portal.Config.Device method DrawAfterCreatePage, GetPropertyList, cancelItem, saveItem
%CSP.UI.Portal.Config.Devices method DrawAfterCreatePage, GetPropertyList, SaveData, UpdateDetails
property SingleSubject
%CSP.UI.Portal.Config.Memory property Category
%CSP.UI.Portal.Config.SQLDataType method UpdateDetails, saveItem
%CSP.UI.Portal.Config.SQLDataTypes method DrawAfterCreatePage
%CSP.UI.Portal.Config.Startup property Category
%CSP.UI.Portal.Config.ValueEditor method saveItem
property pValue
%CSP.UI.Portal.DatabaseTemplate method DisplayError, doClose
%CSP.UI.Portal.Databases method Dismount
%CSP.UI.Portal.Dialog.Compile method updateoptFlags
%CSP.UI.Portal.Dialog.EncAddAdmin method isValid
%CSP.UI.Portal.Dialog.Resource property HasSecurity
%CSP.UI.Portal.Dialog.Service property CSPLink, SERVICENAME, ServicesLink
%CSP.UI.Portal.Dialog.ServiceConnections property SERVICENAME
%CSP.UI.Portal.EncryptionCreate method isValid
%CSP.UI.Portal.EncryptionDatabase method isValid
%CSP.UI.Portal.EncryptionManage property lblClose
%CSP.UI.Portal.EncryptionManaged method isValid
%CSP.UI.Portal.GlobalList property EditGlobalURL
%CSP.UI.Portal.JDBCGatewayServer property LogFile, Port
%CSP.UI.Portal.Journal method cancelItem, doRemoteBrowse, saveItem, valueChanged
property valueModified
%CSP.UI.Portal.License.Utils method EvalResult
%CSP.UI.Portal.Mappings method CreateRS, ExecuteRS, ResetRows, SetTempRow, cancelMapping, editMappingD, editMappingE, saveMapping
property ID1, ID2, changesMade, msgLeavingPage
%CSP.UI.Portal.MemoryStartup property AutoRtnMem, OldAutoMode, OldRtnMem
%CSP.UI.Portal.Mirror.Dialog.SSL method saveSetting
property msgPassword
%CSP.UI.Portal.Mirror.Utils method doClose, onPopupAction, onloadHandler, resetMsg, showMsg
%CSP.UI.Portal.NLS method CopyDescription, ExportDescription
property EditURL, msgConfirmDelete, msgConfirmInstall, msgExportFileName, msgSelectLocale, msgSelectTable, msgSelectTableName
%CSP.UI.Portal.NLSEdit method AddIOTable, DrawHelpText
%CSP.UI.Portal.ObjectGateway method cancelSetting, saveSetting
%CSP.UI.Portal.ObjectGatewayStart method doDone
%CSP.UI.Portal.ObjectGatewayStop method doDone
%CSP.UI.Portal.ObjectSettings method doClose, validate
%CSP.UI.Portal.PKI method doClose, showErrMsg
%CSP.UI.Portal.ProcessDetails property DashboardPage
%CSP.UI.Portal.RemoteDatabases method doNew
%CSP.UI.Portal.SQL.Home method DrawStatementCell
%CSP.UI.Portal.SQL.QButtons.IndexAnalyzer method doGather
%CSP.UI.Portal.SSL method cancelSetting, saveSetting
property msgPage2, msgPage3, msgPassword, msgType0, msgType1
%CSP.UI.Portal.Shadow method cancelItem, doRemoteBrowse, editMapping, saveItem
%CSP.UI.Portal.Shadows property HideColumns
%CSP.UI.Portal.TaskInfo property DashboardPage, currTab
%CSP.UI.Portal.ViewLog property pageURL
%CSP.UI.Portal.X509Credential method cancelSetting, saveSetting
%CSP.UI.Portal.iKnow.Dialog.AddDomainConfig property MaxJobsAllowed
%CSP.UI.Portal.iKnow.Settings property MaxJobsAllowed
%CSP.UI.System.ExpResultPage method MirrorDB
%CSP.UI.System.ExpResultPane method DrawMirrorDB
%CSP.UI.System.SecurityAdvisorPane property ISREADONLY
%CSP.Util.AutoPage method GetEMSDetailPane, GetEMSServerDetailPane, GetEMSTitlePane, GetReadOnlyEMSDetailPane, GetReadOnlyEMSServerDetailPane
%DeepSee.UI.Architect method HasOwner, LastSavedTime
property SavedTime, isLocked, msgLock, msgLock1
%DeepSee.UI.Dialog.PivotEditRule property defRange
%DeepSee.UI.standardPage property isModified
%DeepSee.UserPortal.DashboardViewer property isModified
%FileMan.MappedField property FILE
%FileMan.MappedFile property Classname, FIELDS, FKeys, Indices, MapTimestamp, Maps, SOCClasses, Tablename, Triggers
%SQL.Manager.Catalog method GetCachedQueryInfo, GetCalcTableExtentSize, GetCurrentTableExtentSize, GetTableInfo, SetFieldSelectivity, SetTableExtentSize
property CachedQueryInfo, CachedQueryTable, CachedQueryTree, Constraints, FieldCalcSelectivity, FieldCurrentSelectivity, Fields, Indices, NamespacesWithXdbcErrors, ProcedureInfo, Procedures, ProceduresTree, QueryHistory, RWList, SQLCODEList, Schemas, SchemasOnly, Tables, TablesOnly, TablesTree, Triggers, ViewFields, ViewInfo, ViewInfo2, ViewsOnly, ViewsTree, XdbcErrors
%WebStress.Machines.Generators property SecurityCheck
%ZEN.Component.abstractPage method fireOnLoadEvent
%ZEN.Report.RenderServer method RenderServerExists
property ByRenderServer
%ZEN.Report.reportPage method GenerateStream
%ZEN.SVGComponent.chart method addCommas
%iKnow.Configuration property MaxConceptLength
%iKnow.Queries.SentenceQAPI method GetHighlighted
%iKnow.Queries.SentenceWSAPI method GetHighlighted
%iKnow.UI.AbstractPortal method GetUrlForDomain, updateDomainClient
%iKnow.ont.TableManager method findSUI
Config.Cluster parameter EMSCHANGEBIT
Config.ComPorts parameter EMSCHANGEBIT
Config.ConfigFile parameter EMSCHANGEBIT
Config.Conversions parameter EMSCHANGEBIT
Config.Databases parameter EMSCHANGEBIT
Config.Debug parameter EMSCHANGEBIT
Config.DeviceSubTypes parameter EMSCHANGEBIT
Config.Devices parameter EMSCHANGEBIT
Config.ECP parameter EMSCHANGEBIT
Config.ECPServers parameter EMSCHANGEBIT
Config.IO parameter EMSCHANGEBIT
Config.Journal parameter EMSCHANGEBIT
Config.LicenseServers parameter EMSCHANGEBIT
Config.MagTapes parameter EMSCHANGEBIT
Config.MapGlobals parameter EMSCHANGEBIT
Config.MapMirrors parameter EMSCHANGEBIT
Config.MapPackages parameter EMSCHANGEBIT
Config.MapRoutines parameter EMSCHANGEBIT
Config.MapShadows parameter EMSCHANGEBIT
Config.MirrorAsyncMemberAuthorizedIDs parameter EMSCHANGEBIT
Config.MirrorAsyncMemberSources parameter EMSCHANGEBIT
Config.MirrorMember parameter EMSCHANGEBIT
Config.Mirrors parameter EMSCHANGEBIT
Config.Miscellaneous parameter EMSCHANGEBIT
Config.Monitor parameter EMSCHANGEBIT
Config.NLS.Locales parameter EMSCHANGEBIT
Config.NLS.SubTables parameter EMSCHANGEBIT
Config.NLS.Tables parameter EMSCHANGEBIT
Config.Namespaces parameter EMSCHANGEBIT
Config.SQL parameter EMSCHANGEBIT
Config.Shadows parameter EMSCHANGEBIT
Config.SqlSysDatatypes parameter EMSCHANGEBIT
Config.SqlUserDatatypes parameter EMSCHANGEBIT
Config.Startup parameter EMSCHANGEBIT
Config.Telnet parameter EMSCHANGEBIT
Config.config parameter EMSCHANGEBIT
Ens.Enterprise.Portal.MsgBankViewer parameter SessionTraceColumn
Journal.Restore method Monitor
SYS.Database method FileCompactUpdateBSB, IntegrityClose, IntegrityExecute, IntegrityFetch
SYS.Mirror method GetFailoverMemberStatusEMS
Security.SSLConfigs property ListEMS
Method Return Changes

The following methods have different return values in this version of Caché:

  • %CSP.UI.Portal.Config.ValueEditor — DrawAfterCreatePage, SaveData

  • %CSP.UI.Portal.Dialog.Resource — SaveData

  • %CSP.UI.Portal.Dialog.Service — SaveData

  • %CSP.UI.Portal.Journal — SaveData

  • %CSP.UI.Portal.MemoryStartup — SaveData

  • %CSP.UI.Portal.Mirror.JoinAsync — validateConnect

  • %CSP.UI.Portal.Mirror.JoinFailover — validateConnect

  • %CSP.UI.Portal.NLS — GetLocaleDesc, ReloadDefault

  • %CSP.UI.Portal.SQL.QButtons.IndexAnalyzer — GatherStatements, PrepareAnalysis

  • %CSP.UI.Portal.Shadow — SaveData

  • %CSP.UI.Portal.X509Credential — UpdateDetails

  • %DeepSee.UI.Dialog.CubeCompile — ondialogFinish

  • %DeepSee.UI.Dialog.FieldList — GetSQLNames

  • %DeepSee.Utils — %GetBaseCube

Method Signature Changes

The following methods have different signatures in this version of Caché:

Class Name Method Name(s)
%CPT.JS.BuildCPT %OnNew
%CSP.Page EscapeURL, UnescapeURL
%CSP.UI.Portal.Config.ValueEditor DrawAfterCreatePage, SaveData
%CSP.UI.Portal.DatabaseFreespaceCompact GetFreeSpace, validate
%CSP.UI.Portal.Databases filterChanged
%CSP.UI.Portal.Dialog.Compile updateFlags
%CSP.UI.Portal.Dialog.DBActions Mount
%CSP.UI.Portal.Dialog.DBMirrorAdd SaveDataMulti
%CSP.UI.Portal.Dialog.LicenseActivate Activate, DrawCurrent, PrepareActivate
%CSP.UI.Portal.Dialog.Resource SaveData
%CSP.UI.Portal.Dialog.SQLView SaveData
%CSP.UI.Portal.Dialog.Service SaveData
%CSP.UI.Portal.Dialog.ServiceConnections AddIP
%CSP.UI.Portal.EMS InitializeForm
%CSP.UI.Portal.EncryptionCreate SaveData
%CSP.UI.Portal.EncryptionDatabase ActivateKey, DeactivateKey, SaveStartup, doDeactivate
%CSP.UI.Portal.JDBCGatewayServer SaveJDBCSettings
%CSP.UI.Portal.Journal SaveData, doBrowse
%CSP.UI.Portal.License.Utils DrawLicense
%CSP.UI.Portal.Mappings CancelChanges, DeleteItem, Init, SaveChanges, editMapping
%CSP.UI.Portal.Mirror.JoinAsync validateConnect
%CSP.UI.Portal.Mirror.JoinFailover validateConnect
%CSP.UI.Portal.NLS CopyNow, DeleteNow, GetLocaleDesc, GetLocaleDescription, ReloadDefault, changedDefault, changedLocale, tablenameChanged, tabletypeChanged
%CSP.UI.Portal.NLSEdit ArrayToString, DrawIntTables, RemoveIOTables, SaveBasics, SaveFormats, SaveIODefaults, SaveIOTables, SaveIntTables, SaveInternalDefaults, SaveStrings
%CSP.UI.Portal.Resources Delete
%CSP.UI.Portal.SQL.Home GetCQs, SaveFilter, prepareProp
%CSP.UI.Portal.SQL.QButtons.IndexAnalyzer PrepareAnalysis
%CSP.UI.Portal.SQL.QButtons.RuntimeStats PrepareShowPlan
%CSP.UI.Portal.SQL.Utils SQLExecuteQuery
%CSP.UI.Portal.Shadow DeleteMap, SaveData
%CSP.UI.Portal.Shadows DeleteData, deleteItem
%CSP.UI.Portal.Template showMsg, validateRequired
%CSP.UI.Portal.X509Credential SaveData
%CSP.UI.Portal.iKnow.Dialog.AddDomainConfig SaveDomain
%CSP.UI.System.ExpResultPage CopyMapsFrom
%Collection.ListOfDT DisplayToLogical, LogicalToDisplay
%Collection.MV.ListOfDT DisplayToLogical, LogicalToDisplay
%DeepSee.Component.pivotTable %CreateResultSet, GetItemSpec, allClick, allClickPivot, cbClick, cbClickPivot, getFilterForCells, getLabel, startQueryTimer
%DeepSee.Component.searchBox dateFromHorolog
%DeepSee.Dashboard.Utils %GetMemberDimensionType
%DeepSee.Query.query %LookupCalculatedMember
%DeepSee.Report.UI.reportPreviewer GenerateDataSet, GeneratePresentationReport
%DeepSee.ResultSet %PrepareMDX
%DeepSee.TaskMaster %DequeueTask, %ExecuteTask, %QueueTask
%DeepSee.UI.Dialog.CubeBuild BuildCube
%DeepSee.UI.Dialog.FieldList GetSQLNames
%DeepSee.UserLibrary.Utils %Import
%DeepSee.UserPortal.DashboardViewer dashboardEventHandler
%DeepSee.UserPortal.standardPage updateCompanyCell
%DeepSee.Utils %ProcessFact
%Library.CacheCollection CollectionToDisplay, DisplayToCollection
%Library.IProcedureContext %Next
%Library.Persistent %OnBeforeBuildIndices, %OnBeforePurgeIndices
%Library.RoutineMgr getUserDocument
%SYS.Journal.File GetPrev
%SYSTEM.iKnow CreateDomainTables
%Studio.SourceControl.ISC BaselineExport, BaselineExportItem
%Studio.SourceControl.Interface SourceControlClassGet, SourceControlClassSet, SourceControlCreate
%WebStress.Record Run
%XML.Node ReplaceElement
%XML.SAX.Parser ParseStream
%ZEN.Auxiliary.jsonProvider submitContent
%ZEN.Component.tablePane showDateSelector
%ZEN.Report.Display.COSChart.cchart getSelectedStyle, getXLabelText, getYLabelText DumpCalls, GetXMLFromCall
%ZEN.SVGComponent.chart getSelectedStyle, getXLabelText, getYLabelText, setProperty
%ZEN.Utils %GetIncludeDirectory, %GetPhysicalIncludeDirectory, %GetUserIncludeDirectory
%iKnow.DeepSee.BaseKPI BuildCurrentFilter, BuildCurrentFilterStatic
%iKnow.Matching.DictionaryAPI GetItemCount
%iKnow.Metrics.MetricAPI GetValue
%iKnow.Metrics.MetricQAPI GetValue
%iKnow.Metrics.MetricWSAPI GetValue
%iKnow.Queries.EntityQAPI GetOccurrenceCountByDomain, IsAttributed
%iKnow.Queries.MetadataQAPI GetMetaSpreadByEntities, GetMetaSpreadByEntityIds, GetMetaSpreadInternal
%iKnow.UI.LoadingWizard CreateConfig
%iKnow.ont.Matcher BestMatch, getSynonyms
%iKnow.ont.Matcher2 findPartialMatch
Ens.Host OnGetConnections
Ens.Rule.Upgrade ConvertOne
Ens.Rule.Utils GetPropertyTree
Security.Users Create
%Library.Persistent Defines New Trigger Names

The class, %Library.PersistentOpens in a new tab, now defines three new trigger names: %OBJJRNIU, %OBJJRND, and %OBJGUID.

Previously, these triggers were generated during class compilation and were similarly named, but the compiler took steps to avoid name collisions. Now, the new trigger names are statically defined; if they conflict with user-defined names, the names in the applications must be changed.

Single-Property Key Index Correction

A change introduced in version 2011.1 caused the value stored in a key index to contain only the ID value; the value should have contained the ID value and the value of %%CLASSNAME. In this release, the error is now fixed, but all affected classes must be recompiled and their indexes rebuilt.

The list of indexes impacted by this bug can be produced by running this query:

    %Dictionary.CompiledIndex AS ci
    %Dictionary.CompiledIndex AS oi
        oi.idkey <> 1
        ci.type = 'key'
            (oi.parent->final = 1 AND oi.parent->super %STARTSWITH '%Library.Persistent')
                SELECT count(*)
                FROM %Dictionary.CompiledIndexProperty
                WHERE parent = oi.%ID
            = 1

This query will produce one row for each index in each of the classes where it is inherited, starting with the first class that extends %Library.Persistent. It is only necessary to rebuild the index in the first class in a class hierarchy as that will automatically force rebuilding in subclasses.

Add Certificate And DNS Name Checking To %Net.HttpRequest

In this version, when connecting to a SSL/TLS secured web server, the %Net.HttpRequestOpens in a new tab class will default to checking that the certificate server name matches the DNS name. This is part of RFC 2818, and is used to prevent “man-in-the-middle” attacks. This change can, however, result in a situation where the connection attempt reports errors connecting to a server that previously had been accessed successfully.


This checking can be disabled by setting the SSLCheckServerIdentity property to zero.

%SYS.PTools.SQLStats.Export() Changes

In this release, the format of the file written by this class has changed, specifically,

  • The file is now tab-delimited instead of comma-delimited. This avoids formatting problems with SQL statements that have commas, and can contain double quotes (delimited Identifiers).

  • The blank line first line of the file has been removed.

  • The first line contains only the file name and version.

  • The data exported comes only from current namespace.

Update %SYS.Task To Permit Activity By Async Mirror Members

In prior releases, the MirrorStatus property in %SYS.TaskOpens in a new tab did not allow async mirror members to run Tasks. In this release, the meaning of the 3 status options has been changed to:

  1. Primary

  2. Non-Primary

  3. Any

This allows async (and backup) members to run tasks under option 2 or 3.

Change To Interpretation of REQUIRED & IDENTITY

In previous versions, an attempt to store a class with a property whose definition included both REQUIRED and IDENTITY would not succeed if the user did not define a value for the property. This is no longer true beginning with this release.

Now, Caché will assign a value automatically if no value is provided. The assignment happens during INSERT and the IDENTITY property cannot be changed after that time. This automatic value assignment satisfies the REQUIRED constraint so the compiler will no longer check the REQUIRED (NOT NULL) constraint for the IDENTITY property.

It is unusual for both IDENTITY and REQUIRED to be true for the same property but some SQL migrations include a NOT NULL constraint on the IDENTITY property. In this case, the new behavior now allows objects whose IDENTITY property has not yet been assigned to pass validation successfully; the old behavior would cause %ValidateObject to fail, even though a valid value would be assigned when the object is saved.

Journal.Restore.Monitor() Removed

The Monitor method of the Journal.RestoreOpens in a new tab class should no longer be used. Instead, applications should call MONITOR^JRNRESTF() instead.

Class Compiler Changes

This version of Caché continues the work begun in earlier releases of improving the class compiler. The changes that may require changes to applications are detailed in this section.

REQUIRED Constraint Now Fully Enforced

REQUIRED constraints on serial objects are now enforced. Any property whose type class is a %Library.SerialObjectOpens in a new tab and is defined as REQUIRED will fail to save if that property is null. Prior to this change REQUIRED constraints on such properties were not enforced.

This change can also cause objects that once saved to no longer save without error if the referenced serial object is modified or swizzled.

New Class Parameter Added

Beginning with this release, Caché will add a new class property when a class is compiled. The parameter is named %RandomSig and consists of a 20-byte random value recomputed on every class compile.

Always Rerun Parameter Generator Methods In Subclasses

You can define a parameter to be an expression evaluated at compile time of the class using syntax like this:

Parameter CompileTime = { $HOROLOG };

This will insert the $HOROLOG value into the parameter when the class is compiled. However, if you create a subclass and compile this, Caché was just inheriting the superclasses parameter value rather than rerunning the expression generator code and inserting the $HOROLOG value of the subclass compile. Method generators are always rerun on subclasses and now expression generators are as well.

Maximum Limit On Index Name

Beginning in this release, the maximum length of an index name is 170 minus the length of the fully-qualified class name.

Language Binding Changes

Add Support For Named Parameters In .NET CacheProvider

This release adds support for the use of named parameters in SQL statements SELECT, INSERT, UPDATE and DELETE. Named parameters are now identified by having “@” as a prefix for the parameter name. The “@” is used in both the statement and to create the named parameter.

Named parameters do not need to be added to the CacheParameterCollection in any particular order. When a Prepare(), ExecuteReader(), ExecuteNonQuery(), the @Parameternames in the statement are identified. They must be defined by the time the statement is executed. For example,

Set FROM = "FROM Sample.Person"
Set WHERE = "WHERE  id<@highnumber and id>@lownumber and id=@number"
CacheCommand cmd = new CacheCommand((SELECT _ FROM _ WHERE), conn);

 cmd.Parameters.Add(new CacheParameter("@LowNumber", 2));
 cmd.Parameters.Add(new CacheParameter("@Number", 6));
 cmd.Parameters.Add(new CacheParameter("@HighNumber", 9));

 CacheDataReader reader = cmd.ExecuteReader();


This change should have no effect on applications unless they were using an “@” parameter name in their queries; these are now reserved for named parameter use.

CacheActiveX Uses Server Locale For BSTR Conversions

In prior releases, conversions involving BSTRs (Basic, or Binary STRings) used the locale of the thread doing the conversion. Now it uses the locale of the server.

TCP/IP Connections Now Uses Connection Timeout

In prior versions, the initial attempt to establish a TCP/IP connection used a timeout of 30 seconds, regardless of the value of ConnectionTimeout. This release changes that behavior to use the value specified by ConnectionTimeout.

SQL Changes

Change Handling Of SQLCODE And %msg In Dynamic SQL

The local variable, SQLCODE, is used to report the status of executing an SQL statement. When a dynamic statement is prepared, this local variable was inadvertently being set by %Prepare. The correct way for %Prepare is to report its result is to return a %Status value. In this release, SQLCODE is not changed by %Prepare and the only indication of success or failure is the returned %Status value.


In addition to %Prepare, %SQL.Statement supports prepare(). The prepare() method can be called directly by the user. It accepts the same arguments as %Prepare but instead of reporting a %Status value, prepare() will throw an exception if an error is encountered. The exception object can report the status as an SQLCODE value.

Changes To SQL Privilege Handling For Mapped Tables (Classes)

When an SQL table is created, the owner is automatically granted all permissions on the table. Previously, however, if that table was mapped to multiple namespaces those permissions were not propagated to the other namespaces. Similarly, the deletion of a table did not remove the permissions in the other namespaces where the table was mapped.

This release corrects both of those issues: the owner has all SQL permissions in each namespace to which the table is mapped; and, those permissions are removed in each namespace when the table is deleted.

Change To Calling SQL Function In SQL Statement

User-defined SQL functions called from SQL statements are now executed from within try/catch constructs. If the function encounters an error, it will reported as the new SQL error code: -149, “SQL Function encountered an error”. In this instance, the variable %msg will contain information regarding the error encountered in the SQL Function.

Changes To Selectivity Processing To Handle Outliers

Tunetable now looks for the case where a field value occurs much more frequently than other field values. In such cases, a separate selectivity will be computed for this value, along with a selectivity for “typical” values.

The default selectivity is always used for construction of the query plan unless consideration of the outlier value is requested. If the outlier value is not NULL, (for example, a Massachusetts company with many records containing 'MA'), then in some cases it will be necessary to suppress literal substitution to inform the query processor that the outlier value should be considered. To do this, put the outlier value in double parentheses (('MA')) when used in the Where clause. This syntax is necessary for Dynamic Queries, and for queries written outside of Caché that are sent in using ODBC/JDBC. It is not necessary for class queries, embedded SQL, or queries in a view.


There may be some significant changes in selectivity, producing changes in plans. Despite this net benefit, some applications may need to override the default plans or use hints to get desired plans.

Corrections To ROUND With Scaling Factor Of Zero

In prior versions, SQL columns computing the ROUND function with a SCALE of 0 would not produce the correct SCALE value when the ROUND column came from a subquery or view and the query was run in DISPLAY mode. For example,

SELECT a FROM (SELECT {fn ROUND(Age, 0)} a FROM Sample.Person)

would return a value with a scale of 2 instead of 0 when selected in DISPLAY mode.

Change To LISTBUILD Function

The SQL $LISTBUILD function has been changed so it is now compatible with the Objectscript $LISTBUILD function, especially where null arguments are involved. For example, the SQL phrase

SELECT $LISTBUILD('a',,,,) ...

where the last element was empty previously produced a list of 4 elements. Now it correctly results ina 5-element list. Similarly, the phrase


previously produced a 2-element list equivalent to the Objectscript function


while now it correctly results in a list with a NULL second element.


Applications that depend on the specific formats of lists with missing or null elements may have to be changed.

Dynamic SQL Now Updates %SQLCODE

The result of successfully executing a CALL statement is a special dynamic statement result object referred to as the “context object”. The context object has two implicit properties: one is the result set sequence (RSS); the other is the implied cursor.

If the called procedure did not return any result sets, then the RSS is empty; invoking %Next() will simply return 0. If there is at least one result set in the RSS, the first call to %Next() will cause the first result set in the RSS to be bound to the implied cursor and the first row from that result set will be retrieved. If no rows are found then %Next() simply returns 0 and %SQLCODE will be 100.

Since accessing the implied procedure cursor sets the value of %SQLCODE and %Message it is important that the caller check %SQLCODE for an error condition after executing the call statement and before accessing the RSS. If an error is reported by the CALL then it is up to the user to decide whether or not to continue processing any result sets that might be in the RSS.

%TSQL.Manager Deprecated

Beginning with this version, %TSQL.ManagerOpens in a new tab is deprecated, and will be removed in some future release. Files containing TSQL statements can be run using DDLImport() method of the %SYSTEM.SQLOpens in a new tab class or the SQL Shell.

iKnow Changes

Move System-Level Defaults To Namespace Level

From this release onward, the scope of system-level defaults move to the namespace level. “System-wide” parameters defined in prior releases will be re-registered in all namespaces containing iKnow data when upgraded to this release. Namespaces without iKnow data at the time of upgrade and namespaces created afterwards now need parameter defaults set manually (see %iKnow.Domain.SetParameter and %iKnow.Domain.GetParameter).


An upgrade overwrites the SAMPLES namespace which by default does not contain iKnow domains. Therefore, former system-level defaults will not be registered as namespace-level defaults in SAMPLES.

Standardize Case-Sensitivity Of Element Names

This release makes most of the element names used by iKnow case-insensitive. In previous releases, the names used for Domains, Configurations, and User Dictionaries were insensitive to case. Now the names for Matching Dictionaries, Metrics, Blacklists, and Metadata fields are also.

This leaves only “external” references – Dictionary Item URIs and external ID components (group name and local reference) – as the only "names" still case-sensitive. This is because these names may be driven by external naming conventions.

Compatibility with prior versions and upgrading from these should not result in any issues, unless multiple elements within the same domain had names that only differed in capitalization.

Web Services And SOAP Changes

Web Service Test Page Requires %Development Resource

Beginning in this release, the web service test page requires %Development:Use resource to run.

XML Schema Reader And WSDL Reader Support 189-Character Properties

In this release, the maximum length of property name supported by Caché is extended to 180 characters; preiously, it had been 32. This means that running the wizard for an XSD with type and/or element names longer than 32 characters will result in different property names than the earlier run.


Note that property names used as arguments are still restricted to 31 characters because of the Caché limit of 31 characters for variable names.

Changes In Handling Aggregates in DeepSee and Zen Reporting

In previous releases, when the runtime mode was “display” (the default), the XML data returned from a query would be formatted according to the locale. However, when a Zen or DeepSee Report employed aggregates, the calculation of these aggregates used operators that assumed the data was in US-English format. This produced unexpected results. For example, 1,23 and 1,31 when summed in a European locale would produce 2.

Now the calculation of aggregates is locale-sensitive. Assume the locale is a European one; when the run time mode is display, the "numbers" will first be translated to "US-English" format, so they will work in the arithmetic calculations that use Caché arithmetic operators. When the calculations complete, the results will be translated back to the European format.


Only aggregates, their display and calculation are affected by this change. It is highly unlikely that applications exist which depend on the previous behavior. Nonetheless, it is an incompatible change.

MultiValue Changes

Improved Management Of CHAINed Stack

In prior versions, procs that called MVBasic programs that themselves CHAINed procs would leave the prior proc context on the stack. This was an incompatibility with legacy systems. If the call tree was deep enough, this would eventually cause an abort with a stack full. This version detects that condition and removes the prior proc context.

The goal is to allow only one level of proc execution at each execute level to replicate the behavior on legacy systems. However, there are situations when procs are mixed with paragraphs were this is not practical and the layer will not be removed.

Customer who have written their applications to take advantage of the previous behavior will see failures in this version.

MV Spooler Change For SP-FQDELETE And SP-START

If you run SP-FQDELETE or SP-START on a printer form queue, and that form queue already has a lock on it (implying a despool process is active), then the new message will be similar to

[882] Error. Unable to take a lock on form queue 'QNAME'.
There appears to be a lock already set by process id 14032.
You need to stop the form queue before you can perform this operation.

So if you are testing for the success or failure of SP-START or SP-FQDELETE by doing EXECUTE ... CAPTURING, then the screen output that is captured might differ from what was presented in prior releases.


$DEFINE And EQUATE No Longer Apply To Global Names

The preprocessor can not distinguish between a global name and an exponentiation operator with no white space before the exponent. Thus, beginning in this release, no substitution will be done for the exponent local variable in this example:


To get substitution, there must be white space after the operator, such as in



An alternaitve is to use the “**” operator for exponentiation instead of the “^” operator.

SELECT File With FSELECT Copies File

Anyone using UniData emulation or the FSELECT option who also depends on the

SELECT <filevar>

statement NOT copying the <filevar> contents when the Select List is created will see a change in behavior.

Previously, when the MVBasic compiler translates a “SELECT <filevar>” statement, the newly created Select List is a direct reference to the file variable and does not contain a copy of the file contents. Any write to <filevar> will immediately change the contents of the previously selected Select List. This does not happen for a “SSELECT <filevar>” where the newly created, sorted Select List contains a copy of the indices from the file referenced by <filevar>.

In this new release, a “SELECT <filevar>” statement with $OPTIONS FSELECT turned on will create a Select List containing a copy of indices in the referenced file. Change to the <filevar> file contents will not affect a previously selected Select List of that file providing $OPTIONS FSELECT was enabled when the SELECT statement was compiled. The UniData emulation mode enables FSELECT by default, but all other emulations default to FSELECT being disabled.

To restore the previous behavior, execute a “$OPTIONS -FSELECT” statement in the routine containing the SELECT statement.

Check For Duplicate GLOBAL Symbols

Previously, the MVBasic compiler allowed a name to be defined more than once in the same DIM statement. Now such statement will generate a compile-time error message and the redundant symbol definition must be removed from the DIM statement.


The compiler does allow a name to be defined more than once in separate DIM statements providing the name as never been defined in a global scope (such as a COMMON name.)

Additional Error Return: <ROUTINE TOO COMPLEX>

It is possible that complexity of the source program exceeds the space in preallocated stacks internal to the compiler. Previously, these compilations gave a <STACK> error. In order to better explain these compilation failures the compiler will now give the <ROUTINE TOO COMPLEX> error and it will also report the source line being processed when the excessive complexity was detected.

Anyone who might be detecting the ERASTACK value in the error parameter returned from $COMPILE may now have to instead look for the ERTOOCOMPLEX value in order to detect a too complex compilation. If $COMPILE is called without an error parameter then ERASTACK is still signaled.

xDBC Changes

Null Columns Now Report Length And Precision As 1 Instead of 0

Caché now reports a precision and length of 1 for a NULL literal column to xDBC for the column metadata. Previously, Caché reported the length/precision as 0, but that caused issues with at least one client application.

Automatic Conversion Of Long Strings To Streams Removed

It previous versions, applications could ask that literal strings longer than 16K to be automatically converted to character streams. While this supported INSERTs and UPDATEs, queries never supported streams in this way for literal values.

Now that Caché supports long strings in ODBC, the previous functionality is no longer needed. Applications that need to support huge literal string values in SQL statements should make sure that Caché has long strings turned on.

DeepSee Changes

Change to MDX Functions When Referring to Date-Part-Based Levels

This release changes the behavior of PREVMEMBER, NEXTMEMBER, and other functions when they are used with members of levels that are based on date parts. As background, there are two general kinds of time levels:

  • Timeline-based time levels. This kind of time level divides the timeline into adjacent blocks of time. Any given member (such as January 2011) refers to a single block of time.

  • Date-part-based time levels. This kind of time level considers only part of the date value and ignores the timeline. Any given member (such as January) refers to multiple blocks of time from different parts of the timeline.

For date-part-based levels, the level has a fixed number of members (January to December, for example). When used with a member at the start or end of this set, a function such as PREVMEMBER now returns null. For example:

SELECT [BirthD].[January].PREVMEMBER ON 1 FROM patients


This result is correct, because the January member refers to records related to January in all years, and it is not meaningful to access records “earlier” than that.

In previous releases, the engine would have returned the records for December.

Change to PREVMEMBER and NEXTMEMBER Functions When Referring to Null Members

This release changes the behavior of PREVMEMBER and NEXTMEMBER so that these functions now return null when used with the null member of a level.

In previous releases, in both cases, the engine would have returned the records for the first non-null member of the same parent.

Editing Quality Measure Requires IE9

Beginning with this release, if the user chooses to edit the Quality Measures of DeepSee Tools using Internet Explorer, a version at or above IE9 is required.

Cube Manager Package Name Changed

This release changes the package name of the DeepSee cube manager from DeepSee.CubeMgr to DeepSee.CubeManager. Existing applications that reference classes in this package will need to be changed.

Visual Report Security Checks

In this version, specifying data sources now requires both the proper license and %Development:USE privilege. In addition, formating a DeepSee Visual Report requires both the proper license and %Deepsee_ReportBuilder:USE privilege.

Import Restriction On Legacy Zen Reports

In this release, you can only import data schema from a legacy Zen Report if that reportdefinition section <group> definition tags. Report definitions lacking <group> tags (such as those that use <call> or COS callbacks to gather their data) do not provide the information needed for DeepSee Visual Report to interface properly to the report, and are not suitable sources for this particular data collection builder screen.

Zen Report Variable Substitution Disallowed

Zen reports follows the convention of question marks used as placeholders in SQL WHERE clauses for parameters to be mapped later. DeepSee Visual Report uses #(expression)# syntax to inject the parameters directly into the clause (this is done to simplify the visual editor and hide the syntax structure of the underlying XData).

Starting in this release, DeepSee Visual Report both blocks the entry of the question mark as a keystroke as it is being entered and pops up an alert box suggesting the use of the #( )# syntax.

CSP Changes

CSP Session Support For REST

By default, the REST support introduced in this version takes out a license slot per request. This means that if you have a low license count (or no license), you are limited by the CSP grace period of 5 seconds. If you run out of license units, you will get a 503 HTTP response. You can avoid this by using CSP sessions, even though this (strictly speaking) violates the spirit of REST.

You enable CSP sessions by setting the UseSession parameter to 1 in your class definition and recompiling. The server will generate the CSPSESSION cookie and expects it to be returned in subsequent requests. This means you have to manage the CSPSESSION cookie manually if not using a browser. Tools such as CURL provide that facility with command line parameters but its also manageable in code.


The name of the parameter which affects CSP session use has changed from EndSession to UseSession and its sense has changed as well; specify 1 to use sessions, and 0 to not.


In this release, the %CSP.PageOpens in a new tab class defines a new parameter called SECURITYRESOURCE. This is a comma-delimited list of system resources and associated permissions. A user must hold the specified permissions on all of the specified resources in order to view this page or invoke any of its server-side methods from the client. The format of each item in the list is:


Permission is optional, and defaults to USE if not supplied. If it is supplied, it should be one of USE, READ or WRITE.

You can also specify OR grouping using the “|”character, so “R1,R2|R3,R3|R4” means you must have resource R1, and one of R2 or R3, and one of R3 or R4. So if you have R1,R3 it will pass, if you have R1,R4 it will not as it does not meet the R2|R3 condition. (The “|” (or) condition takes precedence over the “,” (and) condition.

Do Not Store Cookies With Long Names

If the browser sends over an invalid cookie value where the key name is longer than 510 characters, Caché will skip attempting to set this into the %request.Cookies array because the array cannot handle subscript lengths this long.

Variables Used In OnSessionStart CSP Session Event Callback

In a prior release, the CSP event callback logic was changed and all session event callbacks protected any variables the user created in the callback were cleaned up to avoid exposing them in the main page logic. This change of behavior on OnStartSession callback affected several existing applications.

In this release, the previous behavior can be enabled by

Do $SYSTEM.CSP.SetConfig("ProtectOnStartSessionCallback", 0)

which will turn off the exclusive NEW in the OnStartSession event callback so public variables set here can be seen in the CSP page code.

Zen Changes

Changes To tablePane Component Functionality

If your application uses Zen components that generate queries (anything that inherits from querySource, such as tablePane) and you have not set up SQL privileges on your system, then it is possible for a client application to generate a query from the wrong table. This is now prevented by setting ZENENCRYPT=1 for the tableName property of the querySource class. This causes the table name to be encrypted when shipped to the client and prevents the client from modifying it.

Applications that rely on setting the tableName property in JavaScript will no longer work and will throw an <ENCRYPT> or similar error. The showQuery property, a diagnostic aid for displaying the current query, in tablePane and dataCombo is also now encrypted.

Additional Zen Component Security Changes

To further secure the queries automatically generated by Zen components, such as tablePane and dataCombo, Zen now prevents client logic from modifying generated queries in undesirable ways.

  • In the %ZEN.Auxiliary.columnOpens in a new tab class, used by tablePane, the colExpression property is now encrypted. This means that this property can only be set on the server.

  • In the %ZEN.Auxiliary.QueryInfoOpens in a new tab class, used by many components to generate SQL statements, the columns and columnName properties are now required to be valid SQL property names, not expressions. This means that in the cases where an SQL statement is automatically created, the column names must not be expressions or subqueries. For cases where an expression is needed, the application should already be using colExpression.

  • In the %ZEN.Component.querySourceOpens in a new tab class, the queryClass property is now encrypted to prevent the client from modifying this.

Empty Cell Values No Longer Show Default Value

Cells that have no value no longer default to using the ChoiceColumn value; empty fields are now left blank. Their display is controlled by the value of the Zen dataCombo attribute, “showEmpty”.

Zen Reports Changes

Class Attributes Inherited By Child Table Elements

In this release, table elements such as <tr>, <th> and <td> now inherit the class attribute values from their containing element. In previous release, the attribute values were ignored.

FeedbackOpens in a new tab