HPCC-19424 Switch over to using WuAttr in code generator

Signed-off-by: Gavin Halliday <gavin.halliday@lexisnexis.com>

common/workunit/workunit.cpp

@@ -1294,13 +1294,13 @@ public:
         {
             if (whichProperties & PTattributes)
             {
-                playAttribute(visitor, WALabel);
+                playAttribute(visitor, WaLabel);
                 Owned<IPropertyTreeIterator> attrs = cur.getElements("att");
                 ForEach(*attrs)
                 {
                     IPropertyTree & cur = attrs->query();
                     WuAttr attr = queryGraphChildAttToWuAttr(cur.queryProp("@name"));
-                    if (attr != WANone)
+                    if (attr != WaNone)
                         visitor.noteAttribute(attr, cur.queryProp("@value"));
                 }
             }
@@ -1320,12 +1320,12 @@ public:
             {
                 //MORE This will eventually need to walk the attributes and map the names.
                 //Need to be careful if they need to be mapped differently depending on the context.
-                playAttribute(visitor, WALabel);
-                playAttribute(visitor, WAIdSource);
-                playAttribute(visitor, WAIdTarget);
-                playAttribute(visitor, WASourceIndex);
-                playAttribute(visitor, WATargetIndex);
-                playAttribute(visitor, WAIsDependency);
+                playAttribute(visitor, WaLabel);
+                playAttribute(visitor, WaIdSource);
+                playAttribute(visitor, WaIdTarget);
+                playAttribute(visitor, WaSourceIndex);
+                playAttribute(visitor, WaTargetIndex);
+                playAttribute(visitor, WaIsDependency);
             }
             break;
         }
@@ -2412,7 +2412,7 @@ WuScopeFilter & WuScopeFilter::addOutput(const char * prop)
 {
     if (queryStatisticKind(prop, StMax) != StMax)
         addOutputStatistic(prop);
-    else if (queryWuAttribute(prop, WAMax) != WAMax)
+    else if (queryWuAttribute(prop, WaMax) != WaMax)
         addOutputAttribute(prop);
     else
         addOutputHint(prop);
@@ -2451,8 +2451,8 @@ WuScopeFilter & WuScopeFilter::addOutputAttribute(const char * prop)
     if (!prop)
         return *this;
 
-    WuAttr attr = queryWuAttribute(prop, WAMax);
-    if (attr == WAMax)
+    WuAttr attr = queryWuAttribute(prop, WaMax);
+    if (attr == WaMax)
         throw makeStringExceptionV(0, "Unrecognised attribute '%s'", prop);
 
     return addOutputAttribute(attr);
@@ -2460,9 +2460,9 @@ WuScopeFilter & WuScopeFilter::addOutputAttribute(const char * prop)
 
 WuScopeFilter & WuScopeFilter::addOutputAttribute(WuAttr attr)
 {
-    if (attr != WANone)
+    if (attr != WaNone)
     {
-        if (attr != WAAll)
+        if (attr != WaAll)
             desiredAttrs.append(attr);
         else
             desiredAttrs.kill();

common/workunit/wuattr.cpp

@@ -17,6 +17,7 @@
 
 #include "wuattr.hpp"
 #include "jptree.hpp"
+#include "jstats.h"
 
 struct WuAttrInfo
 {
@@ -32,16 +33,16 @@ public:
 
 #define CHILDPATH(x) "att[@name='" x "']/@value"
 #define CHILDMPATH(x) "att[@name='" x "'][1]/@value"
-#define ATTR(kind, measure, path)           { WA ## kind, measure, #kind, path, nullptr, nullptr, nullptr }
-#define ALTATTR(kind, measure, path, alt)   { WA ## kind, measure, #kind, path, alt, nullptr }
-#define CHILD(kind, measure, path)          { WA ## kind, measure, #kind, CHILDPATH(path), nullptr, path, nullptr }
-#define CHILD_MULTI(kind, measure, path)    { WA ## kind, measure, #kind, CHILDMPATH(path), nullptr, path, nullptr }
-#define CHILD_D(kind, measure, path, dft)   { WA ## kind, measure, #kind, CHILDPATH(path), nullptr, path, dft }
+#define ATTR(kind, measure, path)           { Wa ## kind, measure, #kind, path, nullptr, nullptr, nullptr }
+#define ALTATTR(kind, measure, path, alt)   { Wa ## kind, measure, #kind, path, alt, nullptr }
+#define CHILD(kind, measure, path)          { Wa ## kind, measure, #kind, CHILDPATH(path), nullptr, path, nullptr }
+#define CHILD_MULTI(kind, measure, path)    { Wa ## kind, measure, #kind, CHILDMPATH(path), nullptr, path, nullptr }
+#define CHILD_D(kind, measure, path, dft)   { Wa ## kind, measure, #kind, CHILDPATH(path), nullptr, path, dft }
 
 
 const static WuAttrInfo attrInfo[] = {
-    { WANone, SMeasureNone, "none", nullptr, nullptr, nullptr },
-    { WAAll, SMeasureNone, "all", nullptr, nullptr, nullptr },
+    { WaNone, SMeasureNone, "none", nullptr, nullptr, nullptr },
+    { WaAll, SMeasureNone, "all", nullptr, nullptr, nullptr },
     CHILD(Kind, SMeasureEnum, "_kind"),
     ALTATTR(IdSource, SMeasureId, "@source", "att[@name='_sourceActivity']/@value"),
     ALTATTR(IdTarget, SMeasureId, "@target", "att[@name='_targetActivity']/@value"),
@@ -55,18 +56,118 @@ const static WuAttrInfo attrInfo[] = {
     CHILD(EclText, SMeasureText, "ecl"),
     CHILD(RecordSize, SMeasureText, "recordSize"),
     CHILD(PredictedCount, SMeasureText, "predictedCount"),
-    CHILD(Filename, SMeasureText, "_fileName"),
-    { WAMax, SMeasureNone, nullptr, nullptr, nullptr, nullptr }
+    CHILD(IsGrouped, SMeasureBool, "grouped"),
+    CHILD(IsLocal, SMeasureBool, "local"),
+    CHILD(IsCoLocal, SMeasureBool, "coLocal"),
+    CHILD(IsOrdered, SMeasureBool, "ordered"),
+    CHILD(IsInternal, SMeasureBool, "_internal"),
+    CHILD(IsNoAccess, SMeasureBool, "noAccess"),
+    CHILD(IsGraphIndependent, SMeasureBool, "_graphIndependent"),
+    CHILD(IsUpdateIfChanged, SMeasureBool, "_updateIfChanged"),
+    CHILD(IsKeyed, SMeasureBool, "_isKeyed"),
+    CHILD(IsPreload, SMeasureBool, "preload"),
+    CHILD(IsDiskAccessRequired, SMeasureBool, "_diskAccessRequired"),
+    CHILD(IsFileOpt, SMeasureBool, "_isOpt"),
+    CHILD(IsIndexOpt, SMeasureBool, "_isIndexOpt"),
+    CHILD(IsPatchOpt, SMeasureBool, "_isPatchOpt"),
+    CHILD(Filename, SMeasureFilename, "_fileName"),
+    CHILD(Indexname, SMeasureFilename, "_indexFileName"),
+    CHILD(PatchFilename, SMeasureFilename, "_patchName"),
+    CHILD(IsFilenameDynamic, SMeasureBool, "_file_dynamic"),
+    CHILD(IsIndexnameDynamic, SMeasureBool, "_indexFile_dynamic"),
+    CHILD(IsPatchFilenameDynamic, SMeasureBool, "_patch_dynamic"),
+    CHILD(IsEmbedded, SMeasureBool, "embedded"),
+    CHILD(IsSpill, SMeasureBool, "_isSpill"),
+    CHILD(IsGlobalSpill, SMeasureBool, "_isSpillGlobal"),
+    CHILD(IsAccessedFromChild, SMeasureBool, "_fromChild"),
+    CHILD(IsTransformSpill, SMeasureBool, "_isTransformSpill"),
+    CHILD(OriginalFilename, SMeasureFilename, "_originalName"),
+    CHILD(OutputFilename, SMeasureFilename, "_outputName"),
+    CHILD(UpdatedFilename, SMeasureFilename, "_updatedName"),
+    CHILD(DistributeIndexname, SMeasureFilename, "_distributeIndexName"),
+    CHILD(IsOriginalFilenameDynamic, SMeasureBool, "_originalName_dynamic"),
+    CHILD(IsOutputFilenameDynamic, SMeasureBool, "_outputName_dynamic"),
+    CHILD(IsUpdatedFilenameDynamic, SMeasureBool, "_updatedName_dynamic"),
+    CHILD(IsDistributeIndexnameDynamic, SMeasureBool, "_distributeIndexName_dynamic"),
+    CHILD(SignedBy, SMeasureText, "signedBy"),
+    CHILD(MetaDistribution, SMeasureText, "metaDistribution"),
+    CHILD(MetaGrouping, SMeasureText, "metaGrouping"),
+    CHILD(MetaGlobalSortOrder, SMeasureText, "metaGlobalSortOrder"),
+    CHILD(MetaLocalSortOrder, SMeasureText, "metaLocalSortOrder"),
+    CHILD(MetaGroupSortOrder, SMeasureText, "metaGroupSortOrder"),
+    CHILD_MULTI(Section, SMeasureText, "section"),
+    CHILD(LibraryName, SMeasureText, "libname"),
+    CHILD(MatchLikelihood, SMeasureText, "matchLikelihood"),
+    CHILD(SpillReason, SMeasureText, "spillReason"),
+    CHILD(NumChildQueries, SMeasureCount, "childQueries"),
+    CHILD(SizeClassApprox, SMeasureSize, "approxClassSize"),
+    CHILD(IdParentActivity, SMeasureId, "_parentActivity"),
+    CHILD(NumParallel, SMeasureCount, "parallel"),
+    CHILD(Algorithm, SMeasureText, "algorithm"),
+    CHILD(SizePreload, SMeasureSize, "_preloadSize"),
+    CHILD(IdLoop, SMeasureId, "_loopid"),
+    CHILD(IdSubGraph, SMeasureId, "_subgraph"),
+    CHILD(IdGraph, SMeasureId, "graph"),
+    CHILD(IdChildGraph, SMeasureId, "_graphId"),
+    CHILD(IdAmbiguousGraph, SMeasureId, "_graphid"),
+    CHILD(IdLibraryGraph, SMeasureId, "_libraryGraphId"),
+    CHILD(IdRemoteSubGraph, SMeasureId, "_remoteSubGraph"),
+    CHILD(InterfaceHash, SMeasureText, "_interfaceHash"),
+    CHILD(NumMaxOutputs, SMeasureCount, "_maxOutputs"),
+    CHILD(IsRootGraph, SMeasureBool, "rootGraph"),
+    ATTR(IsNWay, SMeasureBool, "@nWay"),
+    CHILD(IsCosort, SMeasureBool, "cosort"),
+    CHILD(NumGlobalUses, SMeasureCount, "_globalUsageCount"),
+    ATTR(IsMultiInstance, SMeasureBool, "@multiInstance"),
+    ATTR(IsDelayed, SMeasureBool, "@delayed"),
+    ATTR(IsChild, SMeasureBool, "@child"),
+    ATTR(IsSequential, SMeasureBool, "@sequential"),
+    ATTR(IsLoopBody, SMeasureBool, "@loopBody"),
+    CHILD(NumResults, SMeasureCount, "_numResults"),
+    CHILD(WhenIndex, SMeasureText, "_when"),
+    { WaMax, SMeasureNone, nullptr, nullptr, nullptr, nullptr }
 };
 
+static MapConstStringTo<WuAttr, WuAttr> nameToWa(true);        // Names are case insensitive
+static MapConstStringTo<WuAttr, WuAttr> graphAttrToWa(false);  // paths and attrs are cases sensitive
+static MapConstStringTo<WuAttr, WuAttr> childAttrToWa(false);
 
 MODULE_INIT(INIT_PRIORITY_STANDARD)
 {
-    static_assert(_elements_in(attrInfo) >= (WAMax-WANone)+1, "Elements missing from attrInfo[]");
-    static_assert(_elements_in(attrInfo) <= (WAMax-WANone)+1, "Extra elements in attrInfo[]");
+    static_assert(_elements_in(attrInfo) >= (WaMax-WaNone)+1, "Elements missing from attrInfo[]");
+    static_assert(_elements_in(attrInfo) <= (WaMax-WaNone)+1, "Extra elements in attrInfo[]");
     for (unsigned i=0; i < _elements_in(attrInfo); i++)
     {
-        assertex(attrInfo[i].kind == WANone + i);
+        const WuAttrInfo & info = attrInfo[i];
+        WuAttr attr = (WuAttr)(WaNone + i);
+        assertex(info.kind == attr);
+        if (info.name)
+            nameToWa.setValue(info.name, attr); // cannot clash since derived from a unique name
+
+#ifdef _DEBUG
+        const char * prefix = queryMeasurePrefix(info.measure);
+        if (info.name && prefix && *prefix)
+        {
+            if (!startsWith(info.name, prefix))
+                printf("Mismatched prefix %s %s\n", info.name, prefix);
+        }
+#endif
+
+        const char * path = info.graphPath;
+        if (path && path[0] == '@')
+        {
+            if (graphAttrToWa.getValue(path+1))
+                throwUnexpectedX("Duplicate Graph Attr");
+            graphAttrToWa.setValue(path+1, attr);
+        }
+
+        const char * childPath = info.childPath;
+        if (childPath)
+        {
+            if (childAttrToWa.getValue(childPath))
+                throwUnexpectedX("Duplicate Child Attr");
+            childAttrToWa.setValue(childPath, attr);
+        }
     }
     return true;
 }
@@ -74,28 +175,25 @@ MODULE_INIT(INIT_PRIORITY_STANDARD)
 
 const char * queryWuAttributeName(WuAttr kind)
 {
-    if ((kind >= WANone) && (kind < WAMax))
-        return attrInfo[kind-WANone].name;
+    if ((kind >= WaNone) && (kind < WaMax))
+        return attrInfo[kind-WaNone].name;
     return nullptr;
 }
 
 WuAttr queryWuAttribute(const char * kind, WuAttr dft)
 {
-    //MORE: This needs to use a hash table
-    for (unsigned i=WANone; i < WAMax; i++)
-    {
-        if (strieq(kind, attrInfo[i-WANone].name))
-            return (WuAttr)i;
-    }
+    WuAttr * match = nameToWa.getValue(kind);
+    if (match)
+        return *match;
     return dft;
 }
 
 extern WORKUNIT_API const char * queryAttributeValue(IPropertyTree & src, WuAttr kind, StringBuffer & scratchpad)
 {
-    if ((kind <= WANone) || (kind >= WAMax))
+    if ((kind <= WaNone) || (kind >= WaMax))
         return nullptr;
 
-    const WuAttrInfo & info = attrInfo[kind-WANone];
+    const WuAttrInfo & info = attrInfo[kind-WaNone];
     const char * path = info.graphPath;
     const char * altpath = info.overridePath;
     const char * value = altpath ? src.queryProp(altpath) : nullptr;
@@ -107,11 +205,23 @@ extern WORKUNIT_API const char * queryAttributeValue(IPropertyTree & src, WuAttr
     //The following switch statement allows the value returned to be transformed from the value stored.
     switch (kind)
     {
-    case WAIdSource:
-    case WAIdTarget:
-        //A bit of a hack - source and target for edges are activity ids.  Return a computed string.
+    case WaIdSource:
+    case WaIdTarget:
+    case WaIdParentActivity:
         value = scratchpad.clear().append(ActivityScopePrefix).append(value).str();
         break;
+    case WaIdLibraryGraph:
+        value = scratchpad.clear().append(GraphScopePrefix).append(value).str();
+        break;
+//    case WaIdLoop:
+        //?Prefix with the graph id?
+        //value = scratchpad.clear().append(ChildGraphScopePrefix).append(value).str();
+        break;
+    case WaIdLoop:
+    case WaIdSubGraph:
+    case WaIdRemoteSubGraph:
+        value = scratchpad.clear().append(ChildGraphScopePrefix).append(value).str();
+        break;
     }
 
     return value;
@@ -119,28 +229,18 @@ extern WORKUNIT_API const char * queryAttributeValue(IPropertyTree & src, WuAttr
 
 extern WORKUNIT_API WuAttr queryGraphAttrToWuAttr(const char * name)
 {
-    //MORE: Create a hash table to implement this mapping efficiently
-    for(unsigned i=1; i < WAMax-WANone; i++)
-    {
-        const WuAttrInfo & info = attrInfo[i];
-        const char * path = info.graphPath;
-        if (path[0] == '@' && strieq(name, path+1))
-            return (WuAttr)(i+WANone);
-    }
-    return WANone;
+    WuAttr * match = graphAttrToWa.getValue(name);
+    if (match)
+        return *match;
+    return WaNone;
 }
 
 extern WORKUNIT_API WuAttr queryGraphChildAttToWuAttr(const char * name)
 {
-    //MORE: Create a hash table to implement this mapping efficiently
-    for(unsigned i=1; i < WAMax-WANone; i++)
-    {
-        const WuAttrInfo & info = attrInfo[i];
-        const char * childPath = info.childPath;
-        if (childPath && strieq(name, childPath))
-            return (WuAttr)(i+WANone);
-    }
-    return WANone;
+    WuAttr * match = childAttrToWa.getValue(name);
+    if (match)
+        return *match;
+    return WaNone;
 }
 
 
@@ -151,12 +251,35 @@ static IPropertyTree * addGraphAttribute(IPropertyTree * node, const char * name
     return node->addPropTree("att", att);
 }
 
-extern WORKUNIT_API void setAttributeValue(IPropertyTree & tgt, WuAttr kind, const char * value)
+void setAttributeValue(IPropertyTree & tgt, WuAttr kind, const char * value)
 {
-    const WuAttrInfo & info = attrInfo[kind-WANone];
+    const WuAttrInfo & info = attrInfo[kind-WaNone];
     const char * path = info.graphPath;
     if (path[0] == '@')
         tgt.setProp(path, value);
     else
         addGraphAttribute(&tgt, info.childPath)->setProp("@value", value);
 }
+
+void setAttributeValueBool(IPropertyTree & tgt, WuAttr kind, bool value, bool alwaysAdd)
+{
+    const WuAttrInfo & info = attrInfo[kind-WaNone];
+    const char * path = info.graphPath;
+    if (value || alwaysAdd)
+    {
+        if (path[0] == '@')
+            tgt.setPropBool(path, value);
+        else
+            addGraphAttribute(&tgt, info.childPath)->setPropBool("@value", value);
+    }
+}
+
+void setAttributeValueInt(IPropertyTree & tgt, WuAttr kind, __int64 value)
+{
+    const WuAttrInfo & info = attrInfo[kind-WaNone];
+    const char * path = info.graphPath;
+    if (path[0] == '@')
+        tgt.setPropInt64(path, value);
+    else
+        addGraphAttribute(&tgt, info.childPath)->setPropInt64("@value", value);
+}

common/workunit/wuattr.hpp

@@ -30,23 +30,91 @@
 //The wuattribute values start from a high value - so that they do not overlap with StXXX
 enum WuAttr : unsigned
 {
-    WANone = 0x80000000,
-    WAAll,
-    WAKind,
-    WAIdSource,
-    WAIdTarget,
-    WASourceIndex,
-    WATargetIndex,
-    WALabel,
-    WAIsDependency,
-    WAIsChildGraph,
-    WADefinition,
-    WAEclName,
-    WAEclText,
-    WARecordSize,
-    WAPredictedCount,
-    WAFilename,
-    WAMax
+    WaNone = 0x80000000,
+    WaAll,
+    WaKind,
+    WaIdSource,
+    WaIdTarget,
+    WaSourceIndex,
+    WaTargetIndex,
+    WaLabel,
+    WaIsDependency,
+    WaIsChildGraph,
+    WaDefinition,
+    WaEclName,
+    WaEclText,
+    WaRecordSize,
+    WaPredictedCount,
+    WaIsGrouped,
+    WaIsLocal,
+    WaIsCoLocal,
+    WaIsOrdered,
+    WaIsInternal,
+    WaIsNoAccess,
+    WaIsGraphIndependent,
+    WaIsUpdateIfChanged,
+    WaIsKeyed,
+    WaIsPreload,
+    WaIsDiskAccessRequired,
+    WaIsFileOpt,
+    WaIsIndexOpt,
+    WaIsPatchOpt,
+    WaFilename,
+    WaIndexname,
+    WaPatchFilename,
+    WaIsFilenameDynamic,
+    WaIsIndexnameDynamic,
+    WaIsPatchFilenameDynamic,
+    WaIsEmbedded,
+    WaIsSpill,
+    WaIsGlobalSpill,
+    WaIsAccessedFromChild,
+    WaIsTransformSpill,
+    WaOriginalFilename,
+    WaOutputFilename,
+    WaUpdatedFilename,
+    WaDistributeIndexname,
+    WaIsOriginalFilenameDynamic,
+    WaIsOutputFilenameDynamic,
+    WaIsUpdatedFilenameDynamic,
+    WaIsDistributeIndexnameDynamic,
+    WaSignedBy,
+    WaMetaDistribution,
+    WaMetaGrouping,
+    WaMetaGlobalSortOrder,
+    WaMetaLocalSortOrder,
+    WaMetaGroupSortOrder,
+    WaSection,
+    WaLibraryName,
+    WaMatchLikelihood,
+    WaSpillReason,
+    WaNumChildQueries,
+    WaSizeClassApprox,
+    WaIdParentActivity,
+    WaNumParallel,
+    WaAlgorithm,
+    WaSizePreload,
+    WaIdLoop,
+    WaIdSubGraph,
+    WaIdGraph,
+    WaIdChildGraph,
+    WaIdAmbiguousGraph,      // unfortunately used for global graphs (library) and child graphs (remote), change in another PR
+    WaIdLibraryGraph,
+    WaIdRemoteSubGraph,
+    WaInterfaceHash,
+    WaNumMaxOutputs,
+    WaIsRootGraph,
+    WaIsNWay,
+    WaIsCosort,
+    WaNumGlobalUses,
+    WaIsMultiInstance,
+    WaIsDelayed,
+    WaIsChild,
+    WaIsSequential,
+    WaIsLoopBody,
+    WaNumResults,
+    WaWhenIndex,
+    WaMax
 };
 
 extern WORKUNIT_API const char * queryWuAttributeName(WuAttr kind);
@@ -56,5 +124,7 @@ extern WORKUNIT_API WuAttr queryGraphAttrToWuAttr(const char * name);
 extern WORKUNIT_API WuAttr queryGraphChildAttToWuAttr(const char * name);
 
 extern WORKUNIT_API void setAttributeValue(IPropertyTree & tgt, WuAttr kind, const char * value);
+extern WORKUNIT_API void setAttributeValueBool(IPropertyTree & tgt, WuAttr kind, bool value, bool alwaysAdd = false);
+extern WORKUNIT_API void setAttributeValueInt(IPropertyTree & tgt, WuAttr kind, __int64 value);
 
 #endif

ecl/hqlcpp/hqlckey.cpp

@@ -1262,7 +1262,7 @@ void HqlCppTranslator::buildKeyedJoinExtra(ActivityInstance & instance, IHqlExpr
 
     //virtual const char * getFileName() = 0;                   // Returns filename of raw file fpos'es refer into
     if (info->isFullJoin())
-        buildFilenameFunction(instance, instance.createctx, "getFileName", info->queryFileFilename(), hasDynamicFilename(info->queryFile()));
+        buildFilenameFunction(instance, instance.createctx, WaFilename, "getFileName", info->queryFileFilename(), hasDynamicFilename(info->queryFile()));
 
     //virtual bool diskAccessRequired() = 0;
     if (info->isFullJoin())
@@ -1299,7 +1299,7 @@ void HqlCppTranslator::buildKeyJoinIndexReadHelper(ActivityInstance & instance,
     info->buildExtractIndexReadFields(instance.startctx);
 
     //virtual const char * getIndexFileName() = 0;
-    buildFilenameFunction(instance, instance.startctx, "getIndexFileName", info->queryKeyFilename(), hasDynamicFilename(info->queryKey()));
+    buildFilenameFunction(instance, instance.startctx, WaIndexname, "getIndexFileName", info->queryKeyFilename(), hasDynamicFilename(info->queryKey()));
 
     //virtual IOutputMetaData * queryIndexRecordSize() = 0;
     LinkedHqlExpr indexExpr = info->queryOriginalKey();
@@ -1490,9 +1490,9 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyedJoinOrDenormalize(BuildCt
 
     if (targetRoxie())
     {
-        instance->addAttributeBool("_diskAccessRequired", info.isFullJoin());
-        instance->addAttributeBool("_isIndexOpt", info.isKeyOpt());
-        instance->addAttributeBool("_isOpt", info.isFileOpt());
+        instance->addAttributeBool(WaIsDiskAccessRequired, info.isFullJoin());
+        instance->addAttributeBool(WaIsIndexOpt, info.isKeyOpt());
+        instance->addAttributeBool(WaIsFileOpt, info.isFileOpt());
     }
 
     buildInstanceSuffix(instance);
@@ -1556,7 +1556,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyedDistribute(BuildCtx & ctx
         doBuildUnsignedFunction(instance->classctx, "getFlags", flags.str()+1);
 
     //virtual const char * getIndexFileName() = 0;
-    buildFilenameFunction(*instance, instance->startctx, "getIndexFileName", keyFilename, dynamic);
+    buildFilenameFunction(*instance, instance->startctx, WaIndexname, "getIndexFileName", keyFilename, dynamic);
 
     //virtual IOutputMetaData * queryIndexRecordSize() = 0;
     LinkedHqlExpr indexExpr = info.queryRawKey();
@@ -1642,15 +1642,15 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyDiff(BuildCtx & ctx, IHqlEx
         doBuildUnsignedFunction(instance->classctx, "getFlags", flags.str()+1);
 
     //virtual const char * getOriginalName() = 0;         // may be null
-    buildRefFilenameFunction(*instance, instance->startctx, "getOriginalName", original);
+    buildRefFilenameFunction(*instance, instance->startctx, WaOriginalFilename, "getOriginalName", original);
     noteAllFieldsUsed(original);
 
     //virtual const char * getUpdatedName() = 0;
-    buildRefFilenameFunction(*instance, instance->startctx, "getUpdatedName", updated);
+    buildRefFilenameFunction(*instance, instance->startctx, WaUpdatedFilename, "getUpdatedName", updated);
     noteAllFieldsUsed(updated);
 
     //virtual const char * getOutputName() = 0;
-    buildFilenameFunction(*instance, instance->startctx, "getOutputName", output, hasDynamicFilename(expr));
+    buildFilenameFunction(*instance, instance->startctx, WaOutputFilename, "getOutputName", output, hasDynamicFilename(expr));
 
     //virtual int getSequence() = 0;
     doBuildSequenceFunc(instance->classctx, querySequence(expr), false);
@@ -1689,14 +1689,14 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyPatch(BuildCtx & ctx, IHqlE
         doBuildUnsignedFunction(instance->classctx, "getFlags", flags.str()+1);
 
     //virtual const char * getOriginalName() = 0;
-    buildRefFilenameFunction(*instance, instance->startctx, "getOriginalName", original);
+    buildRefFilenameFunction(*instance, instance->startctx, WaOriginalFilename, "getOriginalName", original);
     noteAllFieldsUsed(original);
 
     //virtual const char * getPatchName() = 0;
-    buildFilenameFunction(*instance, instance->startctx, "getPatchName", patch, true);
+    buildFilenameFunction(*instance, instance->startctx, WaPatchFilename, "getPatchName", patch, true);
 
     //virtual const char * getOutputName() = 0;
-    buildFilenameFunction(*instance, instance->startctx, "getOutputName", output, hasDynamicFilename(expr));
+    buildFilenameFunction(*instance, instance->startctx, WaOutputFilename, "getOutputName", output, hasDynamicFilename(expr));
 
     //virtual int getSequence() = 0;
     doBuildSequenceFunc(instance->classctx, querySequence(expr), false);

ecl/hqlcpp/hqlcpp.ipp

@@ -1817,9 +1817,9 @@ public:
     void doBuildFunctionReturn(BuildCtx & ctx, ITypeInfo * type, IHqlExpression * value);
     void doBuildUserFunctionReturn(BuildCtx & ctx, ITypeInfo * type, IHqlExpression * value);
 
-    void addFilenameConstructorParameter(ActivityInstance & instance, const char * name, IHqlExpression * expr);
-    void buildFilenameFunction(ActivityInstance & instance, BuildCtx & classctx, const char * name, IHqlExpression * expr, bool isDynamic);
-    void buildRefFilenameFunction(ActivityInstance & instance, BuildCtx & classctx, const char * name, IHqlExpression * dataset);
+    void addFilenameConstructorParameter(ActivityInstance & instance, WuAttr attr, IHqlExpression * expr);
+    void buildFilenameFunction(ActivityInstance & instance, BuildCtx & classctx, WuAttr attr, const char * name, IHqlExpression * expr, bool isDynamic);
+    void buildRefFilenameFunction(ActivityInstance & instance, BuildCtx & classctx, WuAttr attr, const char * name, IHqlExpression * dataset);
     void createAccessFunctions(StringBuffer & helperFunc, BuildCtx & declarectx, unsigned prio, const char * interfaceName, const char * object);
 
     IHqlStmt * beginNestedClass(BuildCtx & classctx, const char * member, const char * bases, const char * memberExtra = NULL, ParentExtract * extract = NULL);
@@ -1840,7 +1840,7 @@ protected:
     void buildIteratorNext(BuildCtx & ctx, IHqlExpression * iter, IHqlExpression * row);
     bool shouldEvaluateSelectAsAlias(BuildCtx & ctx, IHqlExpression * expr);
     IWUResult * createWorkunitResult(int sequence, IHqlExpression * nameExpr);
-    void noteFilename(ActivityInstance & instance, const char * name, IHqlExpression * expr, bool isDynamic);
+    void noteFilename(ActivityInstance & instance, WuAttr attr, IHqlExpression * expr, bool isDynamic);
     bool checkGetResultContext(BuildCtx & ctx, IHqlExpression * expr, CHqlBoundExpr & tgt);
     void buildGetResultInfo(BuildCtx & ctx, IHqlExpression * expr, CHqlBoundExpr * boundTarget, const CHqlBoundTarget * targetAssign);
     void buildGetResultSetInfo(BuildCtx & ctx, IHqlExpression * expr, CHqlBoundExpr * boundTarget, const CHqlBoundTarget * targetAssign);

ecl/hqlcpp/hqlcppds.cpp

@@ -63,7 +63,7 @@ void addGraphIdAttribute(ActivityInstance * instance, BuildCtx & ctx, IHqlExpres
         graphname.append(graphId->queryChild(0)->querySequenceExtra());
         throwError1(HQLERR_AccessUnavailableGraph, graphname.str());
     }
-    instance->addAttributeInt("_graphId", match->graphId);
+    instance->addAttributeInt(WaIdChildGraph, match->graphId);
 }
 
 //===========================================================================
@@ -5376,7 +5376,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivitySetGraphDictionaryResult(Build
 
     buildDictionaryHashMember(instance->createctx, dictionary, "queryHashLookupInfo");
 
-    instance->addAttributeBool("_isSpill", isSpill);
+    instance->addAttributeBool(WaIsSpill, isSpill);
     if (targetRoxie())
         addGraphIdAttribute(instance, ctx, graphId);
 
@@ -5445,8 +5445,8 @@ ABoundActivity * HqlCppTranslator::doBuildActivitySetGraphResult(BuildCtx & ctx,
         addDependency(ctx, instance->queryBoundActivity(), parentActivity, childAtom, relationship);
     }
 
-    instance->addAttributeBool("_isSpill", isSpill);
-    instance->addAttributeBool("_fromChild", expr->hasAttribute(_accessedFromChild_Atom));
+    instance->addAttributeBool(WaIsSpill, isSpill);
+    instance->addAttributeBool(WaIsAccessedFromChild, expr->hasAttribute(_accessedFromChild_Atom));
     if (targetRoxie())
         addGraphIdAttribute(instance, ctx, graphId);
 
@@ -5600,7 +5600,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityForceLocal(BuildCtx & ctx, IHq
     buildActivityFramework(instance);
 
     buildInstancePrefix(instance);
-    instance->addAttributeInt("_subgraph", localId);
+    instance->addAttributeInt(WaIdSubGraph, localId);
 
     ActivityAssociation * match = static_cast<ActivityAssociation *>(ctx.queryAssociation(queryResultExpr(remote), AssocActivity, NULL));
     assertex(match);

ecl/hqlcpp/hqlgraph.cpp

@@ -93,15 +93,15 @@ IPropertyTree * addInterGraphEdge(IPropertyTree * graph, unsigned __int64 source
 void setEdgeAttributes(IPropertyTree * edge, unsigned outputIndex, unsigned inputIndex, IAtom * kind, const char * label, bool nWay)
 {
     if (outputIndex != 0)
-        addGraphAttributeInt(edge, "_sourceIndex", outputIndex);
+        setAttributeValueInt(*edge, WaSourceIndex, outputIndex);
     if (inputIndex != 0)
-        addGraphAttributeInt(edge, "_targetIndex", inputIndex);
+        setAttributeValueInt(*edge, WaTargetIndex, inputIndex);
     if (label)
-        edge->setProp("@label", label);
+        setAttributeValue(*edge, WaLabel, label);
     if (kind == dependencyAtom)
-        addGraphAttributeBool(edge, "_dependsOn", true);
+        setAttributeValueBool(*edge, WaIsDependency, true);
     if (nWay)
-        edge->setPropBool("@nWay", true);
+        setAttributeValueBool(*edge, WaIsNWay, true);
 }
 
 

ecl/hqlcpp/hqlhtcpp.cpp

@@ -133,7 +133,7 @@ inline bool isInternalSeq(IHqlExpression * seq)
 static void markSubGraphAsRoot(IPropertyTree * tree)
 {
     if (!tree->hasProp("att[@name=\"rootGraph\"]"))
-        addGraphAttributeBool(tree, "rootGraph", true);
+        setAttributeValueBool(*tree, WaIsRootGraph, true, false);
 }
 
 SubGraphInfo * matchActiveGraph(BuildCtx & ctx, IHqlExpression * graphTag)
@@ -1648,7 +1648,7 @@ bool GlobalFileTracker::checkMatch(IHqlExpression * searchFilename)
 void GlobalFileTracker::writeToGraph()
 {
     if (usageCount && graphNode)
-        addGraphAttributeInt(graphNode, "_globalUsageCount", usageCount);
+        setAttributeValueInt(*graphNode, WaNumGlobalUses, usageCount);
 }
 
 //---------------------------------------------------------------------------
@@ -1866,6 +1866,25 @@ void ActivityInstance::addAttribute(WuAttr attr, const char * value)
     setAttributeValue(*graphNode, attr, value);
 }
 
+void ActivityInstance::addAttributeBool(WuAttr attr, bool value, bool alwaysAdd)
+{
+    setAttributeValueBool(*graphNode, attr, value, alwaysAdd);
+}
+
+void ActivityInstance::addAttributeInt(WuAttr attr, __int64 value)
+{
+    setAttributeValueInt(*graphNode, attr, value);
+}
+
+void ActivityInstance::addAttribute(WuAttr attr, IHqlExpression * expr)
+{
+    StringBuffer temp;
+    IValue * value = expr->queryValue();
+    assertex(value);
+    value->getStringValue(temp);
+    setAttributeValue(*graphNode, attr, temp);
+}
+
 void ActivityInstance::addAttribute(const char * name, const char * value)
 {
     addGraphAttribute(graphNode, name, value);
@@ -1881,22 +1900,13 @@ void ActivityInstance::addAttributeBool(const char * name, bool value, bool alwa
     addGraphAttributeBool(graphNode, name, value, alwaysAdd);
 }
 
-void ActivityInstance::addAttribute(const char * name, IHqlExpression * expr)
-{
-    StringBuffer temp;
-    IValue * value = expr->queryValue();
-    assertex(value);
-    value->getStringValue(temp);
-    addGraphAttribute(graphNode, name, temp);
-}
-
 void ActivityInstance::addSignedAttribute(IHqlExpression * signedAttr)
 {
     if (signedAttr)
     {
         StringBuffer buf;
         getStringValue(buf, signedAttr->queryChild(0));
-        addAttribute("signedBy", buf.str());
+        addAttribute(WaSignedBy, buf.str());
     }
 }
 
@@ -1919,7 +1929,7 @@ void ActivityInstance::addLocationAttribute(IHqlExpression * location)
     if (column)
         s.append(",").append(column);
     s.append(")");
-    addAttribute(WADefinition, s.str());
+    addAttribute(WaDefinition, s.str());
 }
 
 
@@ -1942,7 +1952,7 @@ void ActivityInstance::addNameAttribute(IHqlExpression * symbol)
             return;
     }
     names.append(*symbol);
-    addAttribute("name", str(name));
+    addAttribute(WaEclName, str(name));
 }
 
 void ActivityInstance::removeAttribute(const char * name)
@@ -2008,7 +2018,7 @@ void ActivityInstance::processSection(IHqlExpression * section)
     {
         StringBuffer sectionName;
         getStringValue(sectionName, section->queryChild(0));
-        addAttribute("section", sectionName);
+        addAttribute(WaSection, sectionName);
     }
 }
 
@@ -2025,8 +2035,8 @@ void ActivityInstance::changeActivityKind(ThorActivityKind newKind)
     kind = newKind;
     if (graphNode)
     {
+        addAttributeInt(WaKind, kind);
         removeGraphAttribute(graphNode, "_kind");
-        addAttributeInt("_kind", kind);
     }
     if (table)
         table->updateActivityKind(kind);
@@ -2036,7 +2046,7 @@ void ActivityInstance::changeActivityKind(ThorActivityKind newKind)
 void ActivityInstance::setInternalSink(bool value)
 {
     if (value)
-        addAttributeBool("_internal", true);
+        addAttributeBool(WaIsInternal, true);
     else
         removeAttribute("_internal");
 }
@@ -2101,9 +2111,9 @@ void ActivityInstance::createGraphNode(IPropertyTree * defaultSubGraph, bool alw
         cur = body;
     }
 
-    addAttributeInt("_kind", kind);
-    addAttributeBool("grouped", isGrouped);
-    addAttributeBool("local", isLocal);
+    addAttributeInt(WaKind, kind);
+    addAttributeBool(WaIsGrouped, isGrouped);
+    addAttributeBool(WaIsLocal, isLocal);
 
 #ifdef _DEBUG
 //    assertex(dataset->isAction() == isActivitySink(kind));
@@ -2113,21 +2123,21 @@ void ActivityInstance::createGraphNode(IPropertyTree * defaultSubGraph, bool alw
         if (alwaysExecuted)
             markSubGraphAsRoot(parentGraphNode);
         else
-            addAttributeBool("_internal", true);
+            addAttributeBool(WaIsInternal, true);
     }
 
     if (containerActivity)
-        addAttributeInt("_parentActivity", containerActivity->activityId);
+        addAttributeInt(WaIdParentActivity, containerActivity->activityId);
     if (parentExtract && isCoLocal)
-        addAttributeBool("coLocal", true);
+        addAttributeBool(WaIsCoLocal, true);
     if (isNoAccess)
-        addAttributeBool("noAccess", true);
+        addAttributeBool(WaIsNoAccess, true);
     if (activityExpr->hasAttribute(parallelAtom))
-        addAttributeInt("parallel", getIntValue(queryAttributeChild(activityExpr, parallelAtom, 0), -1));
+        addAttributeInt(WaNumParallel, getIntValue(queryAttributeChild(activityExpr, parallelAtom, 0), -1));
     if (hasOrderedAttribute(activityExpr))
-        addAttributeBool("ordered", isOrdered(activityExpr), true);
+        addAttributeBool(WaIsOrdered, isOrdered(activityExpr), true);
     if (activityExpr->hasAttribute(algorithmAtom))
-        addAttribute("algorithm", queryAttributeChild(activityExpr, algorithmAtom, 0));
+        addAttribute(WaAlgorithm, queryAttributeChild(activityExpr, algorithmAtom, 0));
 
     if (!options.obfuscateOutput)
     {
@@ -2138,14 +2148,14 @@ void ActivityInstance::createGraphNode(IPropertyTree * defaultSubGraph, bool alw
         if (options.showEclInGraph)
         {
             if (strcmp(graphEclText.str(), "<>") != 0)
-                addAttribute("ecl", graphEclText.str());
+                addAttribute(WaEclText, graphEclText.str());
         }
 
         if (options.showSeqInGraph)
         {
             IHqlExpression * selSeq = querySelSeq(activityExpr);
             if (selSeq)
-                addAttributeInt("selSeq", selSeq->querySequenceExtra());
+                addAttributeInt("debuggingSelSeq", selSeq->querySequenceExtra());
         }
 
         if (options.showMetaInGraph || generateMetaFromInput)
@@ -2156,28 +2166,28 @@ void ActivityInstance::createGraphNode(IPropertyTree * defaultSubGraph, bool alw
             {
                 IHqlExpression * distribution = queryDistribution(source);
                 if (distribution && distribution->queryName() != localAtom)
-                    addAttribute("metaDistribution", getExprECL(distribution, s.clear(), true).str());
+                    addAttribute(WaMetaDistribution, getExprECL(distribution, s.clear(), true).str());
             }
 
             IHqlExpression * grouping = queryGrouping(source);
             assertex((grouping != nullptr) == ::isGrouped(source));
             if (grouping)
-                addAttribute("metaGrouping", getExprECL(grouping, s.clear(), true).str());
+                addAttribute(WaMetaGrouping, getExprECL(grouping, s.clear(), true).str());
 
             if (translator.targetThor())
             {
                 IHqlExpression * globalSortOrder = queryGlobalSortOrder(source);
                 if (globalSortOrder)
-                    addAttribute("metaGlobalSortOrder", getExprECL(globalSortOrder, s.clear(), true).str());
+                    addAttribute(WaMetaGlobalSortOrder, getExprECL(globalSortOrder, s.clear(), true).str());
             }
 
             IHqlExpression * localSortOrder = queryLocalUngroupedSortOrder(source);
             if (localSortOrder)
-                addAttribute("metaLocalSortOrder", getExprECL(localSortOrder, s.clear(), true).str());
+                addAttribute(WaMetaLocalSortOrder, getExprECL(localSortOrder, s.clear(), true).str());
 
             IHqlExpression * groupSortOrder = queryGroupSortOrder(source);
             if (groupSortOrder)
-                addAttribute("metaGroupSortOrder", getExprECL(groupSortOrder, s.clear(), true).str());
+                addAttribute(WaMetaGroupSortOrder, getExprECL(groupSortOrder, s.clear(), true).str());
         }
 
         if (options.noteRecordSizeInGraph)
@@ -2192,7 +2202,7 @@ void ActivityInstance::createGraphNode(IPropertyTree * defaultSubGraph, bool alw
                     record.setown(getSerializedForm(record, diskAtom));
                 StringBuffer temp;
                 getRecordSizeText(temp, record);
-                addAttribute("recordSize", temp.str());
+                addAttribute(WaRecordSize, temp.str());
             }
         }
 
@@ -2200,7 +2210,7 @@ void ActivityInstance::createGraphNode(IPropertyTree * defaultSubGraph, bool alw
         {
             StringBuffer text;
             getRecordCountText(text, activityExpr);
-            addAttribute("predictedCount", text);
+            addAttribute(WaPredictedCount, text);
         }
     }
 
@@ -2214,6 +2224,8 @@ void ActivityInstance::moveDefinitionToHeader()
         //remove this class from the c++ file and include it in the header file instead
         includedInHeader = true;
         classGroupStmt->setIncluded(false);
+
+        //Following is only to aid debugging a work unit, not accessed via wudetails
         addAttributeBool("helperinheader", true);
 
         BuildCtx headerctx(*translator.code, parentHelpersAtom);
@@ -2340,7 +2352,7 @@ void ActivityInstance::buildPrefix()
 void ActivityInstance::buildSuffix()
 {
     if (numChildQueries)
-        addAttributeInt("childQueries", numChildQueries);
+        addAttributeInt(WaNumChildQueries, numChildQueries);
 
     //Paranoid check to ensure that library classes aren't used when member functions were required
     if (implementationClassName && (initialGroupMarker != classGroup->numChildren()))
@@ -2357,7 +2369,7 @@ void ActivityInstance::buildSuffix()
                 translator.WARNING2(CategoryEfficiency, HQLWRN_ComplexHelperClass, activityId, approxSize);
         }
         if (!options.obfuscateOutput && options.showActivitySizeInGraph)
-            addAttributeInt("approxClassSize", approxSize);
+            addAttributeInt(WaSizeClassApprox, approxSize);
     }
 
     if (options.generateActivityThresholdCycles != 0)
@@ -2380,7 +2392,7 @@ void ActivityInstance::buildSuffix()
 
     unsigned __int64 searchDistance = querySearchDistance() - startDistance;
     if (searchDistance > options.searchDistanceThreshold)
-        addAttributeInt("searchDistance", searchDistance);
+        addAttributeInt("debuggingSearchDistance", searchDistance);
 
 //  if (!isMember)
 //      classGroupStmt->setIncomplete(false);
@@ -3266,32 +3278,24 @@ void HqlCppTranslator::doBuildFunction(BuildCtx & ctx, ITypeInfo * type, const c
     }
 }
 
-void HqlCppTranslator::addFilenameConstructorParameter(ActivityInstance & instance, const char * name, IHqlExpression * expr)
+void HqlCppTranslator::addFilenameConstructorParameter(ActivityInstance & instance, WuAttr attr, IHqlExpression * expr)
 {
     OwnedHqlExpr folded = foldHqlExpression(expr);
     instance.addConstructorParameter(folded);
-    noteFilename(instance, name, folded, false);
+    noteFilename(instance, attr, folded, false);
 }
 
-void HqlCppTranslator::buildFilenameFunction(ActivityInstance & instance, BuildCtx & classctx, const char * name, IHqlExpression * expr, bool isDynamic)
+void HqlCppTranslator::buildFilenameFunction(ActivityInstance & instance, BuildCtx & classctx, WuAttr attr, const char * name, IHqlExpression * expr, bool isDynamic)
 {
     OwnedHqlExpr folded = foldHqlExpression(expr);
     doBuildVarStringFunction(classctx, name, folded);
-    noteFilename(instance, name, folded, isDynamic);
+    noteFilename(instance, attr, folded, isDynamic);
 }
 
-void HqlCppTranslator::noteFilename(ActivityInstance & instance, const char * name, IHqlExpression * expr, bool isDynamic)
+void HqlCppTranslator::noteFilename(ActivityInstance & instance, WuAttr attr, IHqlExpression * expr, bool isDynamic)
 {
     if (options.addFilesnamesToGraph)
     {
-        StringBuffer propName;
-        const char * propNameBase = name;
-        if (memicmp(propNameBase, "get", 3) == 0)
-            propNameBase += 3;
-        else if (memicmp(propNameBase, "query", 3) == 0)
-            propNameBase += 5;
-        propName.append("_").append((char)tolower(*propNameBase)).append(propNameBase+1);
-
         OwnedHqlExpr folded = foldHqlExpression(expr);
         if (folded)
         {
@@ -3308,21 +3312,44 @@ void HqlCppTranslator::noteFilename(ActivityInstance & instance, const char * na
             {
                 StringBuffer propValue;
                 folded->queryValue()->getStringValue(propValue);
-                instance.addAttribute(propName, propValue);
+                instance.addAttribute(attr, propValue);
             }
         }
         if (isDynamic)
         {
-            unsigned len = propName.length();
-            if ((len > 4) && (memicmp(propName.str() + len-4, "name", 4) == 0))
-                propName.setLength(len-4);
-            propName.append("_dynamic");
-            instance.addAttributeBool(propName.str(), true);
+            WuAttr dynamicAttr;
+            switch (attr)
+            {
+            case WaFilename:
+                dynamicAttr = WaIsFilenameDynamic;
+                break;
+            case WaIndexname:
+                dynamicAttr = WaIsIndexnameDynamic;
+                break;
+            case WaPatchFilename:
+                dynamicAttr = WaIsPatchFilenameDynamic;
+                break;
+            case WaDistributeIndexname:
+                dynamicAttr = WaIsDistributeIndexnameDynamic;
+                break;
+            case WaOriginalFilename:
+                dynamicAttr = WaIsOriginalFilenameDynamic;
+                break;
+            case WaOutputFilename:
+                dynamicAttr = WaIsOutputFilenameDynamic;
+                break;
+            case WaUpdatedFilename:
+                dynamicAttr = WaIsUpdatedFilenameDynamic;
+                break;
+            default:
+                throwUnexpected();
+            }
+            instance.addAttributeBool(dynamicAttr, true);
         }
     }
 }
 
-void HqlCppTranslator::buildRefFilenameFunction(ActivityInstance & instance, BuildCtx & classctx, const char * name, IHqlExpression * expr)
+void HqlCppTranslator::buildRefFilenameFunction(ActivityInstance & instance, BuildCtx & classctx, WuAttr attr, const char * name, IHqlExpression * expr)
 {
     IHqlExpression * table = queryPhysicalRootTable(expr);
     assertex(table);
@@ -3341,7 +3368,7 @@ void HqlCppTranslator::buildRefFilenameFunction(ActivityInstance & instance, Bui
         break;
     }
 
-    buildFilenameFunction(instance, classctx, name, filename, hasDynamicFilename(table));
+    buildFilenameFunction(instance, classctx, attr, name, filename, hasDynamicFilename(table));
 }
 
 void HqlCppTranslator::buildConnectInputOutput(BuildCtx & ctx, ActivityInstance * instance, ABoundActivity * table, unsigned outputIndex, unsigned inputIndex, const char * label, bool nWay)
@@ -7296,7 +7323,7 @@ void HqlCppTranslator::addDependency(BuildCtx & ctx, ABoundActivity * sourceActi
     IPropertyTree *edge = createPTree();
     edge->setProp("@id", idText.str());
     if (label)
-        edge->setProp("@label", label);
+        setAttributeValue(*edge, WaLabel, label);
     if (targetRoxie())
     {
         if (outputIndex)
@@ -7307,20 +7334,20 @@ void HqlCppTranslator::addDependency(BuildCtx & ctx, ABoundActivity * sourceActi
 
     if (kind == childAtom)
     {
-        addGraphAttributeBool(edge, "_childGraph", true);
+        setAttributeValueBool(*edge, WaIsChildGraph, true);
     }
     else if (kind == dependencyAtom)
     {
-        addGraphAttributeBool(edge, "_dependsOn", true);
+        setAttributeValueBool(*edge, WaIsDependency, true);
     }
     else if (sourceActivity->queryContainerId() != sinkActivity->queryContainerId())
     {
         //mark as a dependency if the source and target aren't at the same depth
-        addGraphAttributeBool(edge, "_dependsOn", true);
+        setAttributeValueBool(*edge, WaIsDependency, true);
     }
 
     if (whenId)
-        addGraphAttributeInt(edge, "_when", whenId);
+        setAttributeValueInt(*edge, WaWhenIndex, whenId);
 
 
     if (graphTree)
@@ -8728,7 +8755,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityLoop(BuildCtx & ctx, IHqlExpre
 
         ChildGraphBuilder builder(*this, childquery);
         unique_id_t loopId = builder.buildLoopBody(func.ctx, (parallel != NULL), getBoolAttribute(expr, fewAtom));
-        instance->addAttributeInt("_loopid", loopId);
+        instance->addAttributeInt(WaIdLoop, loopId);
 
         if (loopAgainResult)
             doBuildUnsignedFunction(instance->startctx, "loopAgainResult", loopAgainResult);
@@ -8781,7 +8808,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityGraphLoop(BuildCtx & ctx, IHql
         //input dataset is fed in using result 1
         //counter (if required) is fed in using result 2[0].counter;
         unique_id_t loopId = buildGraphLoopSubgraph(func.ctx, dataset, selSeq, rowsid, body->queryChild(0), counter, (parallel != NULL), getBoolAttribute(expr, fewAtom));
-        instance->addAttributeInt("_loopid", loopId);
+        instance->addAttributeInt(WaIdLoop, loopId);
     }
 
     buildInstanceSuffix(instance);
@@ -8828,7 +8855,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityRemote(BuildCtx & ctx, IHqlExp
 
         //output dataset is result 0
         unique_id_t remoteId = buildRemoteSubgraph(func.ctx, dataset);
-        instance->addAttributeInt("_graphid", remoteId);
+        instance->addAttributeInt(WaIdAmbiguousGraph, remoteId);
     }
 
     buildInstanceSuffix(instance);
@@ -9261,26 +9288,27 @@ unsigned HqlCppTranslator::doBuildThorChildSubGraph(BuildCtx & ctx, IHqlExpressi
 
     IHqlExpression * numResultsAttr = expr->queryAttribute(numResultsAtom);
     if (numResultsAttr)
-        addGraphAttributeInt(subGraph, "_numResults", getIntValue(numResultsAttr->queryChild(0), 0));
+        setAttributeValueInt(*subGraph, WaNumResults, getIntValue(numResultsAttr->queryChild(0), 0));
     if (expr->hasAttribute(multiInstanceAtom))
-        subGraph->setPropBool("@multiInstance", true);
+        setAttributeValueBool(*subGraph, WaIsMultiInstance, true);
     if (expr->hasAttribute(delayedAtom))
-        subGraph->setPropBool("@delayed", true);
+        setAttributeValueBool(*subGraph, WaIsDelayed, true);
     if (expr->queryAttribute(childAtom))
-        subGraph->setPropBool("@child", true);
+        setAttributeValueBool(*subGraph, WaIsChild, true);
     if (expr->hasAttribute(sequentialAtom))
-        subGraph->setPropBool("@sequential", true);
+        setAttributeValueBool(*subGraph, WaIsSequential, true);
     if (kind == SubGraphLoop)
-        subGraph->setPropBool("@loopBody", true);
+        setAttributeValueBool(*subGraph, WaIsLoopBody, true);
 
     if (insideChildOrLoopGraph(ctx))
     {
+        //Do not use setAttributeValueInt since the child <att> has already been created
         graphAttr->setProp("@name", "_kind");
         graphAttr->setPropInt("@value", TAKsubgraph);
 
         ActivityInstance * curActivityInstance = queryCurrentActivity(ctx);
         if (curActivityInstance)
-            addGraphAttributeInt(node, "_parentActivity", curActivityInstance->activityId);
+            setAttributeValueInt(*node, WaIdParentActivity, curActivityInstance->activityId);
     }
 
     OwnedHqlExpr idExpr = createConstant((__int64)thisId);
@@ -9957,7 +9985,7 @@ void HqlCppTranslator::buildUpdateHelper(BuildCtx & ctx, ActivityInstance & inst
         buildAssignToTemp(func.ctx, totalCrcVar, crcExpr);
 
         if (!updateAttr->hasAttribute(alwaysAtom))
-            instance.addAttributeBool("_updateIfChanged", true);
+            instance.addAttributeBool(WaIsUpdateIfChanged, true);
     }
 }
 
@@ -10354,7 +10382,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityOutputIndex(BuildCtx & ctx, IH
     buildInstancePrefix(instance);
 
     //virtual const char * getFileName() { return "x.d00"; }
-    buildFilenameFunction(*instance, instance->startctx, "getFileName", filename, hasDynamicFilename(expr));
+    buildFilenameFunction(*instance, instance->startctx, WaFilename, "getFileName", filename, hasDynamicFilename(expr));
 
     //virtual unsigned getFlags() = 0;
     IHqlExpression * updateAttr = expr->queryAttribute(updateAtom);
@@ -10394,7 +10422,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityOutputIndex(BuildCtx & ctx, IH
 
     IHqlExpression * indexNameAttr = expr->queryAttribute(indexAtom);
     if (indexNameAttr)
-        buildFilenameFunction(*instance, instance->startctx, "getDistributeIndexName", indexNameAttr->queryChild(0), hasDynamicFilename(expr));
+        buildFilenameFunction(*instance, instance->startctx, WaDistributeIndexname, "getDistributeIndexName", indexNameAttr->queryChild(0), hasDynamicFilename(expr));
 
     buildExpiryHelper(instance->createctx, expr->queryAttribute(expireAtom));
     buildUpdateHelper(instance->createctx, *instance, dataset, updateAttr);
@@ -10690,7 +10718,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityOutput(BuildCtx & ctx, IHqlExp
             if (filename && filename->getOperator() != no_pipe)
             {
                 bool isDynamic = expr->hasAttribute(resultAtom) || hasDynamicFilename(expr);
-                buildFilenameFunction(*instance, instance->startctx, "getFileName", filename, isDynamic);
+                buildFilenameFunction(*instance, instance->startctx, WaFilename, "getFileName", filename, isDynamic);
                 if (!filename->isConstant())
                     constFilename = false;
             }
@@ -10789,14 +10817,14 @@ ABoundActivity * HqlCppTranslator::doBuildActivityOutput(BuildCtx & ctx, IHqlExp
     {
         assertex(tempCount.get() && !hasDynamic(expr));
         instance->addConstructorParameter(tempCount);
-        addFilenameConstructorParameter(*instance, "getFileName", filename);
+        addFilenameConstructorParameter(*instance, WaFilename, filename);
     }
 
     instance->addSignedAttribute(expr->queryAttribute(_signed_Atom));
 
-    instance->addAttributeBool("_isSpill", expr->hasAttribute(_spill_Atom));
+    instance->addAttributeBool(WaIsSpill, expr->hasAttribute(_spill_Atom));
     if (targetRoxie())
-        instance->addAttributeBool("_isSpillGlobal", expr->hasAttribute(jobTempAtom));
+        instance->addAttributeBool(WaIsGlobalSpill, expr->hasAttribute(jobTempAtom));
 
     buildInstanceSuffix(instance);
     if (boundDataset)
@@ -15475,7 +15503,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityFilter(BuildCtx & ctx, IHqlExp
                 StringBuffer text;
                 likelihood *= 100;
                 text.setf("%3.2f%%", likelihood);
-                instance->addAttribute("matchLikelihood", text);
+                instance->addAttribute(WaMatchLikelihood, text);
             }
         }
     }
@@ -16345,7 +16373,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityIf(BuildCtx & ctx, IHqlExpress
             buildReturn(getcond.ctx, cseCond);
         }
         if (isGraphIndependent(cseCond, activeGraph) && !instance->hasChildActivity)
-            instance->addAttributeBool("_graphIndependent", true);
+            instance->addAttributeBool(WaIsGraphIndependent, true);
 
         buildConnectInputOutput(ctx, instance, boundTrue, 0, 0, firstLabel);
         if (boundFalse)
@@ -16370,7 +16398,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityIf(BuildCtx & ctx, IHqlExpress
         }
 
         if (isGraphIndependent(cseCond, activeGraph) && !instance->hasChildActivity)
-            instance->addAttributeBool("_graphIndependent", true);
+            instance->addAttributeBool(WaIsGraphIndependent, true);
 
         if (expr->isAction())
         {
@@ -16467,7 +16495,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityChoose(BuildCtx & ctx, IHqlExp
     bool graphIndependent = isGraphIndependent(fullCond, activeGraph);
 
     if (graphIndependent && !instance->hasChildActivity)
-        instance->addAttributeBool("_graphIndependent", true);
+        instance->addAttributeBool(WaIsGraphIndependent, true);
 
     buildConnectInputOutput(ctx, instance, boundDefault, 0, inputs.ordinality(), "default");
 
@@ -16553,7 +16581,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityCase(BuildCtx & ctx, IHqlExpre
     bool graphIndependent = isGraphIndependent(fullCond, activeGraph);
 
     if (graphIndependent && !instance->hasChildActivity)
-        instance->addAttributeBool("_graphIndependent", true);
+        instance->addAttributeBool(WaIsGraphIndependent, true);
 
     buildConnectInputOutput(ctx, instance, boundDefault, 0, max-1-first, "default");
 
@@ -18786,9 +18814,9 @@ void HqlCppTranslator::buildConnectOrders(BuildCtx & ctx, ABoundActivity * slave
     if (targetThor())
     {
         IPropertyTree *edge = createPTree();
-        edge->setPropInt64("@target", slaveActivity->queryActivityId());
-        edge->setPropInt64("@source", masterActivity->queryActivityId());
-        addGraphAttributeBool(edge, "cosort", true);
+        setAttributeValueInt(*edge, WaIdTarget, slaveActivity->queryActivityId());
+        setAttributeValueInt(*edge, WaIdSource, masterActivity->queryActivityId());
+        setAttributeValueBool(*edge, WaIsCosort, true);
 
         SubGraphInfo * activeSubgraph = queryActiveSubGraph(ctx);
         assertex(activeSubgraph);

ecl/hqlcpp/hqlhtcpp.ipp

@@ -149,8 +149,11 @@ public:
     void getScope(StringBuffer & scope) const; // return the full scope name of this activity
 
     void addAttribute(WuAttr attr, const char * value);
+    void addAttributeBool(WuAttr attr, bool value, bool alwaysAdd=false);
+    void addAttributeInt(WuAttr attr, __int64 value);
+    void addAttribute(WuAttr attr, IHqlExpression * expr);
+
     void addAttribute(const char * name, const char * value);
-    void addAttribute(const char * name, IHqlExpression * expr);
     void addAttributeInt(const char * name, __int64 value);
     void addAttributeBool(const char * name, bool value, bool alwaysAdd=false);
     void addSignedAttribute(IHqlExpression * signedAttr);

ecl/hqlcpp/hqllib.cpp

@@ -553,18 +553,18 @@ ABoundActivity * HqlCppTranslator::doBuildActivityLibraryInstance(BuildCtx & ctx
 
     if (nameValue)
     {
-        instance->addAttribute("libname", libraryName.str());
+        instance->addAttribute(WaLibraryName, libraryName.str());
         Owned<IWULibrary> wulib = wu()->updateLibraryByName(libraryName.str());
     }
 
 
-    instance->addAttributeInt("_interfaceHash", library->getInterfaceHash());
-    instance->addAttributeBool("embedded", (embeddedAttr != NULL));
-    instance->addAttributeInt("_maxOutputs", library->outputs.ordinality());
+    instance->addAttributeInt(WaInterfaceHash, library->getInterfaceHash());
+    instance->addAttributeBool(WaIsEmbedded, (embeddedAttr != NULL));
+    instance->addAttributeInt(WaNumMaxOutputs, library->outputs.ordinality());
     if (embeddedAttr)
-        instance->addAttribute("graph", embeddedAttr->queryChild(0));
+        instance->addAttribute(WaIdGraph, embeddedAttr->queryChild(0));
     if (!targetHThor())
-        instance->addAttributeInt("_graphid", nextActivityId());            // reserve an id...
+        instance->addAttributeInt(WaIdAmbiguousGraph, nextActivityId());            // reserve an id...
 
     // A debugging option to make it clearer how a library is being called.
     if (options.addLibraryInputsToGraph)
@@ -575,7 +575,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityLibraryInstance(BuildCtx & ctx
             IHqlExpression * parameter = libraryInstance->queryParameter(iIn);
             StringBuffer paramName;
             StringBuffer paramEcl;
-            paramName.append("input").append(iIn).append("__").append(parameter->queryName());
+            paramName.append("debuggingInput").append(iIn).append("__").append(parameter->queryName());
             toECL(libraryInstance->queryActual(iIn), paramEcl, false, true);
             instance->addAttribute(paramName, paramEcl);
         }

ecl/hqlcpp/hqlsource.cpp

@@ -1123,7 +1123,7 @@ void SourceBuilder::rebindFilepositons(BuildCtx & ctx, IHqlExpression * dataset,
 void SourceBuilder::buildFilenameMember()
 {
     //---- virtual const char * getFileName() { return "x.d00"; } ----
-    translator.buildFilenameFunction(*instance, instance->startctx, "getFileName", nameExpr, translator.hasDynamicFilename(tableExpr));
+    translator.buildFilenameFunction(*instance, instance->startctx, WaFilename, "getFileName", nameExpr, translator.hasDynamicFilename(tableExpr));
 }
 
 void SourceBuilder::buildReadMembers(IHqlExpression * expr)
@@ -2036,18 +2036,18 @@ ABoundActivity * SourceBuilder::buildActivity(BuildCtx & ctx, IHqlExpression * e
             else
                 throwError1(HQLERR_ReadSpillBeforeWrite, spillName.str());
         }
-        translator.addFilenameConstructorParameter(*instance, "getFileName", nameExpr);
+        translator.addFilenameConstructorParameter(*instance, WaFilename, nameExpr);
     }
 
     if (steppedExpr)
         buildSteppedHelpers();
 
     if (translator.targetRoxie())
-        instance->addAttributeBool("_isSpill", isSpill);
+        instance->addAttributeBool(WaIsSpill, isSpill);
     else if (needToCallTransform || transformCanFilter)
-        instance->addAttributeBool("_isTransformSpill", isSpill);
+        instance->addAttributeBool(WaIsTransformSpill, isSpill);
     else
-        instance->addAttributeBool("_isSpill", isSpill);
+        instance->addAttributeBool(WaIsSpill, isSpill);
     if (isFiltered)
     {
         if (isKnownLikelihood(filterLikelihood))
@@ -2055,7 +2055,7 @@ ABoundActivity * SourceBuilder::buildActivity(BuildCtx & ctx, IHqlExpression * e
             StringBuffer text;
             filterLikelihood *= 100;
             text.setf("%3.2f%%", filterLikelihood);
-            instance->addAttribute("matchLikelihood", text);
+            instance->addAttribute(WaMatchLikelihood, text);
         }
     }
     IHqlExpression * spillReason = tableExpr ? queryAttributeChild(tableExpr, _spillReason_Atom, 0) : NULL;
@@ -2064,7 +2064,7 @@ ABoundActivity * SourceBuilder::buildActivity(BuildCtx & ctx, IHqlExpression * e
     {
         StringBuffer text;
         getStringValue(text, spillReason);
-        instance->addAttribute("spillReason", text.str());
+        instance->addAttribute(WaSpillReason, text.str());
     }
 
     if (tableExpr)
@@ -2714,16 +2714,16 @@ void DiskReadBuilderBase::buildMembers(IHqlExpression * expr)
         MemberFunction func(translator, instance->startctx, "virtual void createSegmentMonitors(IIndexReadContext *irc) override");
         monitors.buildSegments(func.ctx, "irc", true);
     }
-    instance->addAttributeBool("_isKeyed", monitors.isKeyed());
+    instance->addAttributeBool(WaIsKeyed, monitors.isKeyed());
 
     //---- virtual unsigned getFlags()
-    instance->addAttributeBool("preload", isPreloaded);
+    instance->addAttributeBool(WaIsPreload, isPreloaded);
 
     bool matched = translator.registerGlobalUsage(tableExpr->queryChild(0));
     if (translator.getTargetClusterType() == RoxieCluster)
     {
-        instance->addAttributeBool("_isOpt", tableExpr->hasAttribute(optAtom));
-        instance->addAttributeBool("_isSpillGlobal", tableExpr->hasAttribute(jobTempAtom));
+        instance->addAttributeBool(WaIsFileOpt, tableExpr->hasAttribute(optAtom));
+        instance->addAttributeBool(WaIsGlobalSpill, tableExpr->hasAttribute(jobTempAtom));
         if (tableExpr->hasAttribute(jobTempAtom) && !matched)
             throwUnexpected();
     }
@@ -2749,7 +2749,7 @@ void DiskReadBuilderBase::buildMembers(IHqlExpression * expr)
     //---- preloadSize is passed via the xgmml, not via a member
     if (preloadSize)
     {
-        instance->addAttributeInt("_preloadSize", preloadSize->queryValue()->getIntValue());
+        instance->addAttributeInt(WaSizePreload, preloadSize->queryValue()->getIntValue());
     }
 
     if (includeFormatCrc)
@@ -3672,9 +3672,9 @@ void IndexReadBuilderBase::buildMembers(IHqlExpression * expr)
         }
     }
 
-    instance->addAttributeBool("preload", isPreloaded);
+    instance->addAttributeBool(WaIsPreload, isPreloaded);
     if (translator.getTargetClusterType() == RoxieCluster)
-        instance->addAttributeBool("_isIndexOpt", tableExpr->hasAttribute(optAtom));
+        instance->addAttributeBool(WaIsIndexOpt, tableExpr->hasAttribute(optAtom));
 
     if (monitors.queryGlobalGuard())
         translator.doBuildBoolFunction(instance->startctx, "canMatchAny", monitors.queryGlobalGuard());
@@ -4464,7 +4464,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityXmlRead(BuildCtx & ctx, IHqlEx
         fieldUsage->noteAll();
 
     //---- virtual const char * getFileName() { return "x.d00"; } ----
-    buildFilenameFunction(*instance, instance->startctx, "getFileName", filename, hasDynamicFilename(tableExpr));
+    buildFilenameFunction(*instance, instance->startctx, WaFilename, "getFileName", filename, hasDynamicFilename(tableExpr));
     buildEncryptHelper(instance->startctx, tableExpr->queryAttribute(encryptAtom));
 
     bool usesContents = false;
@@ -4577,7 +4577,7 @@ void FetchBuilder::buildMembers(IHqlExpression * expr)
         translator.doBuildUnsignedFunction(instance->classctx, "getFetchFlags", flags.str()+1);
 
     if (tableExpr->hasAttribute(optAtom) && translator.targetRoxie())
-        instance->addAttributeBool("_isOpt", true);
+        instance->addAttributeBool(WaIsFileOpt, true);
 
     buildLimits(instance->startctx, expr, instance->activityId);
 

esp/services/ws_workunits/ws_workunitsService.cpp

@@ -4254,7 +4254,7 @@ bool CWsWorkunitsEx::onWUDetailsMeta(IEspContext &context, IEspWUDetailsMetaRequ
         resp.setStatistics(statistics);
 
         StringArray attributes;
-        for (unsigned i=WuAttr::WAAll+1; i<WuAttr::WAMax; ++i)
+        for (unsigned i=WuAttr::WaAll+1; i<WuAttr::WaMax; ++i)
         {
             const char * s = queryWuAttributeName((WuAttr)i);
             if (s && *s)

esp/services/ws_workunits/ws_wudetails.cpp

@@ -39,7 +39,7 @@ public:
 
 private:
     static const unsigned StatisticFilterMaskSize = StatisticKind::StMax;
-    static const unsigned AttributeFilterMaskSize = WuAttr::WAMax-WANone;
+    static const unsigned AttributeFilterMaskSize = WuAttr::WaMax-WaNone;
 
     bool includeName = false;
     bool includeRawValue = false;
@@ -126,7 +126,7 @@ void WUDetailsVisitor::noteAttribute(WuAttr attr, const char * value)
     {
         // If the Attribute is not in the standard return statistic list,
         // then check if it's in the additional attribute list
-        if ((returnAttributeSpecified && !returnAttributeList->test(attr-WANone)))
+        if ((returnAttributeSpecified && !returnAttributeList->test(attr-WaNone)))
         {
             if (additionalAttribsForCurScope==nullptr ||
                 additionalAttribsForCurScope->find(attr)==additionalAttribsForCurScope->end())
@@ -196,8 +196,8 @@ void WUDetailsVisitor::buildAttribListToReturn(IConstWUPropertiesToReturn & prop
             }
             else
             {
-                const WuAttr wa = queryWuAttribute(props[idx2], WAMax);
-                if (wa==WAMax)
+                const WuAttr wa = queryWuAttribute(props[idx2], WaMax);
+                if (wa==WaMax)
                     throw MakeStringException(ECLWATCH_INVALID_INPUT, "Invalid property name (%s) in ExtraProperties",props[idx2]);
                 if (!allProperties)
                 {
@@ -232,15 +232,15 @@ void WUDetailsVisitor::buildAttribListToReturn(IConstWUPropertiesToReturn & prop
             }
             else
             {
-              const WuAttr wa = queryWuAttribute(attributeName, WAMax);
-              if (wa!=WAMax)
+              const WuAttr wa = queryWuAttribute(attributeName, WaMax);
+              if (wa!=WaMax)
               {
                   if (!returnAttributeSpecified)
                   {
                       returnAttributeList.set(createBitSet(AttributeFilterMaskSize));
                       returnAttributeSpecified=true;
                   }
-                  returnAttributeList->set(wa-WANone,true);
+                  returnAttributeList->set(wa-WaNone,true);
               }
               else
                   throw MakeStringException(ECLWATCH_INVALID_INPUT, "Invalid Attribute name in AttributeToReturn(%s)", attributeName);

system/jlib/jstats.cpp

@@ -582,7 +582,7 @@ const char * queryMeasurePrefix(StatisticMeasure measure)
 {
     switch (measure)
     {
-    case SMeasureAll:           return NULL;
+    case SMeasureAll:           return nullptr;
     case SMeasureTimeNs:        return "Time";
     case SMeasureTimestampUs:   return "When";
     case SMeasureCount:         return "Num";
@@ -598,6 +598,7 @@ const char * queryMeasurePrefix(StatisticMeasure measure)
     case SMeasureBool:          return "Is";
     case SMeasureId:            return "Id";
     case SMeasureFilename:      return "";
+    case SMeasureNone:          return nullptr;
     default:
         return "Unknown";
     }

system/jlib/jstats.h

@@ -685,6 +685,7 @@ extern jlib_decl const char * queryTreeTag(StatisticKind kind);
 extern jlib_decl const char * queryCreatorTypeName(StatisticCreatorType sct);
 extern jlib_decl const char * queryScopeTypeName(StatisticScopeType sst);
 extern jlib_decl const char * queryMeasureName(StatisticMeasure measure);
+extern jlib_decl const char * queryMeasurePrefix(StatisticMeasure measure);
 extern jlib_decl StatsMergeAction queryMergeMode(StatisticMeasure measure);
 extern jlib_decl StatsMergeAction queryMergeMode(StatisticKind kind);
 

system/jlib/jstring.cpp

@@ -2486,16 +2486,16 @@ StringBuffer & ncnameUnescape(char const * in, StringBuffer & out)
 
 
 
-bool startsWith(const char* src, const char* dst)
+bool startsWith(const char* src, const char* prefix)
 {
-    while (*dst && *dst == *src) { src++; dst++; }
-    return *dst==0;
+    while (*prefix && *prefix == *src) { src++; prefix++; }
+    return *prefix==0;
 }
 
-bool startsWithIgnoreCase(const char* src, const char* dst)
+bool startsWithIgnoreCase(const char* src, const char* prefix)
 {
-    while (*dst && tolower(*dst) == tolower(*src)) { src++; dst++; }
-    return *dst==0;
+    while (*prefix && tolower(*prefix) == tolower(*src)) { src++; prefix++; }
+    return *prefix==0;
 }
 
 bool endsWith(const char* src, const char* dst)

system/jlib/jstring.hpp

@@ -564,10 +564,10 @@ extern jlib_decl StringBuffer & ncnameEscape(char const * in, StringBuffer & out
 extern jlib_decl StringBuffer & ncnameUnescape(char const * in, StringBuffer & out);
 extern jlib_decl StringBuffer & elideString(StringBuffer & s, unsigned maxLength);
 
-extern jlib_decl bool startsWith(const char* src, const char* dst);
+extern jlib_decl bool startsWith(const char* src, const char* prefix);
 extern jlib_decl bool endsWith(const char* src, const char* dst);
 
-extern jlib_decl bool startsWithIgnoreCase(const char* src, const char* dst);
+extern jlib_decl bool startsWithIgnoreCase(const char* src, const char* prefix);
 extern jlib_decl bool endsWithIgnoreCase(const char* src, const char* dst);
 
 inline bool strieq(const char* s, const char* t) { return stricmp(s,t)==0; }