HPCC-8312 Rationalise the use of property and attribute

Attribute refers to an option explicitly added by the user

Property refers to something that can be derived from an
expression including explicit attributes.

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

common/fileview2/fvsource.cpp

@@ -348,11 +348,11 @@ void DataSourceMetaData::gatherFields(IHqlExpression * expr, bool isConditional)
         }
     case no_field:
         {
-            if (expr->hasProperty(__ifblockAtom))
+            if (expr->hasAttribute(__ifblockAtom))
                 break;
             Linked<ITypeInfo> type = expr->queryType();
             IAtom * name = expr->queryName();
-            IHqlExpression * nameAttr = expr->queryProperty(namedAtom);
+            IHqlExpression * nameAttr = expr->queryAttribute(namedAtom);
             StringBuffer outname;
             if (nameAttr && nameAttr->queryChild(0)->queryValue())
                 nameAttr->queryChild(0)->queryValue()->getStringValue(outname);
@@ -361,11 +361,11 @@ void DataSourceMetaData::gatherFields(IHqlExpression * expr, bool isConditional)
 
             StringBuffer xpathtext;
             const char * xpath = NULL;
-            IHqlExpression * xpathAttr = expr->queryProperty(xpathAtom);
+            IHqlExpression * xpathAttr = expr->queryAttribute(xpathAtom);
             if (xpathAttr && xpathAttr->queryChild(0)->queryValue())
                 xpath = xpathAttr->queryChild(0)->queryValue()->getStringValue(xpathtext);
 
-            if (isKey() && expr->hasProperty(blobAtom))
+            if (isKey() && expr->hasAttribute(blobAtom))
                 type.setown(makeIntType(8, false));
             type_t tc = type->getTypeCode();
             if (tc == type_row)

common/fileview2/fvtransform.cpp

@@ -374,16 +374,16 @@ ViewFieldTransformer * ViewTransformerRegistry::createTransformer(IHqlExpression
     if ((entry.length() == 0) || (lib.length() == 0))
         return NULL;
 
-    if(!body->hasProperty(pureAtom) && !body->hasProperty(templateAtom))
+    if(!body->hasAttribute(pureAtom) && !body->hasAttribute(templateAtom))
         return NULL;
 
-    if(!body->hasProperty(cAtom)) 
+    if(!body->hasAttribute(cAtom))
         return NULL;
 
-    if(body->hasProperty(gctxmethodAtom) || body->hasProperty(ctxmethodAtom) || body->hasProperty(omethodAtom)) 
+    if(body->hasAttribute(gctxmethodAtom) || body->hasAttribute(ctxmethodAtom) || body->hasAttribute(omethodAtom))
         return NULL;
 
-    if(body->hasProperty(contextAtom) || body->hasProperty(globalContextAtom)) 
+    if(body->hasAttribute(contextAtom) || body->hasAttribute(globalContextAtom))
         return NULL;
 
     //Special case string->string mapping (e.g., uppercase)

common/fileview2/fvwugen.cpp

@@ -178,7 +178,7 @@ IHqlExpression * PositionTransformer::createTransformed(IHqlExpression * _expr)
             ForEachChild(idx, inRecord)
             {
                 IHqlExpression * child = inRecord->queryChild(idx);
-                if (child->hasProperty(insertedAtom))
+                if (child->hasAttribute(insertedAtom))
                 {
                     IHqlExpression * newTarget = createField(child->queryId(), child->getType(), LINK(child), insertedAttr.getLink());
                     fields.append(*newTarget);
@@ -209,7 +209,7 @@ IHqlExpression * PositionTransformer::createTransformed(IHqlExpression * _expr)
             ForEachChild(idx, record)
             {
                 IHqlExpression * child = record->queryChild(idx);
-                if (child->hasProperty(insertedAtom))
+                if (child->hasAttribute(insertedAtom))
                     fields.append(*createField(child->queryId(), child->getType(), LINK(child), insertedAttr.getLink()));
             }
 
@@ -238,7 +238,7 @@ IHqlExpression * PositionTransformer::createTransformed(IHqlExpression * _expr)
                     ForEachChild(idx, record)
                     {
                         IHqlExpression * child = record->queryChild(idx);
-                        if (!child->hasProperty(insertedAtom))
+                        if (!child->hasAttribute(insertedAtom))
                             fields.append(*createField(child->queryId(), child->getType(), LINK(child)));
                     }
                 }
@@ -247,7 +247,7 @@ IHqlExpression * PositionTransformer::createTransformed(IHqlExpression * _expr)
                     ForEachChild(idx, record)
                     {
                         IHqlExpression * child = record->queryChild(idx);
-                        if (!child->hasProperty(insertedAtom))
+                        if (!child->hasAttribute(insertedAtom))
                             fields.append(*LINK(child));
                     }
                 }

ecl/hql/hqlattr.cpp

@@ -37,19 +37,19 @@
 #include "hqlattr.hpp"
 #include "hqlmeta.hpp"
 
-static CriticalSection * attributeCS;
+static CriticalSection * propertyCS;
 
 MODULE_INIT(INIT_PRIORITY_HQLINTERNAL)
 {
-    attributeCS = new CriticalSection;
+    propertyCS = new CriticalSection;
     return true;
 }
 MODULE_EXIT()
 {
-    delete attributeCS;
+    delete propertyCS;
 }
 
-// This file should contain most of the derived attribute calculation for nodes in the expression tree,
+// This file should contain most of the derived property calculation for nodes in the expression tree,
 // Other candidates are
 // checkConstant, getChilddatasetType(), getNumChildTables
 // queryHasRows, definesColumnList(), queryTransformIndex
@@ -57,8 +57,8 @@ MODULE_EXIT()
 // getCachedEclCRC(), cacheTablesUsed(), isIndependentOfScope()
 // logic inside createDataset
 
-//Originally the idea was to have a class instance for each kind of opcode, and to call opcode[op]->evaluateAttrXXXXXX(this);
-//to evaluate the attribute.  However because there are so many opcodes I'm not convinced this is the best way.
+//Originally the idea was to have a class instance for each kind of opcode, and to call opcode[op]->evalautePropXXXXXX(this);
+//to evaluate the property.  However because there are so many opcodes I'm not convinced this is the best way.
 //Better may be to model it more on the way queryRecordCount() is implemented.
 
 //This switch statement provides an entry of each opcode grouped according to its function.
@@ -677,9 +677,9 @@ static unsigned getMaxSize(ITypeInfo * type, IHqlExpression * maxLength, IHqlExp
     if (size != UNKNOWN_LENGTH)
         return size;
 
-    if (!maxLength) maxLength = queryPropertyChild(type, maxLengthAtom, 0);
-    if (!maxSize) maxSize = queryPropertyChild(type, maxSizeAtom, 0);
-    if (!maxCount) maxCount = queryPropertyChild(type, maxCountAtom, 0);
+    if (!maxLength) maxLength = queryAttributeChild(type, maxLengthAtom, 0);
+    if (!maxSize) maxSize = queryAttributeChild(type, maxSizeAtom, 0);
+    if (!maxCount) maxCount = queryAttributeChild(type, maxCountAtom, 0);
 
     if (maxSize)
         return (unsigned)getIntValue(maxSize, 0);
@@ -739,9 +739,9 @@ static unsigned getMaxSize(IHqlExpression * field)
     }
 
     ITypeInfo * type = field->queryType();
-    IHqlExpression * maxLength = queryPropertyChild(field, maxLengthAtom, 0);
-    IHqlExpression * maxSize = queryPropertyChild(field, maxSizeAtom, 0);
-    IHqlExpression * maxCount = queryPropertyChild(field, maxCountAtom, 0);
+    IHqlExpression * maxLength = queryAttributeChild(field, maxLengthAtom, 0);
+    IHqlExpression * maxSize = queryAttributeChild(field, maxSizeAtom, 0);
+    IHqlExpression * maxCount = queryAttributeChild(field, maxCountAtom, 0);
     unsigned max = getMaxSize(type, maxLength, maxSize, maxCount);
     if (max != UNKNOWN_LENGTH)
         return max;
@@ -779,7 +779,7 @@ static IHqlExpression * querySerializedForm(IHqlExpression * expr, IAtom * varia
         else
             throwUnexpected();
 
-        IHqlExpression * attr = expr->queryAttribute(kind);
+        IHqlExpression * attr = expr->queryProperty(kind);
         if (attr)
             return attr;
     }
@@ -799,7 +799,7 @@ public:
         {
         case no_field:
             {
-                if (expr->hasProperty(_linkCounted_Atom))
+                if (expr->hasAttribute(_linkCounted_Atom))
                 {
                     OwnedHqlExpr transformed = QuickHqlTransformer::createTransformedBody(expr);
                     return removeProperty(transformed, _linkCounted_Atom);
@@ -831,22 +831,22 @@ static IHqlExpression * evaluateSerializedRecord(IHqlExpression * expr, IAtom *
 class CHqlExprMeta
 {
 public:
-    static inline IHqlExpression * addAttribute(IHqlExpression * expr, ExprPropKind kind, IHqlExpression * value)
+    static inline IHqlExpression * addProperty(IHqlExpression * expr, ExprPropKind kind, IHqlExpression * value)
     {
         CHqlExpression * cexpr = static_cast<CHqlExpression *>(expr);
-        cexpr->addAttribute(kind, value);
+        cexpr->addProperty(kind, value);
         return value;
     }
-    static inline IHqlExpression * queryExistingAttribute(IHqlExpression * expr, ExprPropKind kind)
+    static inline IHqlExpression * queryExistingProperty(IHqlExpression * expr, ExprPropKind kind)
     {
         CHqlExpression * cexpr = static_cast<CHqlExpression *>(expr);
-        return cexpr->queryExistingAttribute(kind);
+        return cexpr->queryExistingProperty(kind);
     }
 } meta;
 
 //-- Attribute: serialized form -------------------------------------------------------------------------------
 
-static IHqlExpression * evaluateAttrSerializedForm(IHqlExpression * expr, ExprPropKind kind, IAtom * variation)
+static IHqlExpression * evaluatePropSerializedForm(IHqlExpression * expr, ExprPropKind kind, IAtom * variation)
 {
     if (expr->getOperator() == no_record || expr->getOperator() == no_field)
     {
@@ -854,9 +854,9 @@ static IHqlExpression * evaluateAttrSerializedForm(IHqlExpression * expr, ExprPr
         if (serialized != expr)
         {
             //Tag serialized form so don't re-evaluated
-            meta.addAttribute(serialized, kind, serialized);
+            meta.addProperty(serialized, kind, serialized);
         }
-        return meta.addAttribute(expr, kind, serialized);
+        return meta.addProperty(expr, kind, serialized);
     }
     return NULL;
 }
@@ -872,7 +872,7 @@ static IHqlExpression * evaluateFieldAttrSize(IHqlExpression * expr)
     unsigned thisSize = type->getSize();
     OwnedHqlExpr thisMaxSizeExpr;
 
-    if (expr->hasProperty(_isBlobInIndex_Atom))
+    if (expr->hasAttribute(_isBlobInIndex_Atom))
     {
         thisSize = sizeof(unsigned __int64);
     }
@@ -892,8 +892,8 @@ static IHqlExpression * evaluateFieldAttrSize(IHqlExpression * expr)
                     thisSize = sizeof(void *);
                 else
                 {
-                    IHqlExpression * ret = expr->queryRecord()->queryAttribute(EPsize);
-                    return meta.addAttribute(expr, EPsize, ret);
+                    IHqlExpression * ret = expr->queryRecord()->queryProperty(EPsize);
+                    return meta.addProperty(expr, EPsize, ret);
                 }
                 break;
             }
@@ -901,7 +901,7 @@ static IHqlExpression * evaluateFieldAttrSize(IHqlExpression * expr)
         case type_groupedtable:
         case type_table:
             {
-                if (expr->hasProperty(_linkCounted_Atom))
+                if (expr->hasAttribute(_linkCounted_Atom))
                 {
                     thisSize = sizeof(size32_t) + sizeof(byte * *);
                     break;
@@ -933,7 +933,7 @@ static IHqlExpression * evaluateFieldAttrSize(IHqlExpression * expr)
                 }
 
                 IHqlExpression * record = expr->queryRecord();
-                IHqlExpression * childRecordSizeExpr = record->queryAttribute(EPsize);
+                IHqlExpression * childRecordSizeExpr = record->queryProperty(EPsize);
                 unsigned childExpectedSize = (unsigned)getIntValue(childRecordSizeExpr->queryChild(0));
                 unsigned childMinimumSize = (unsigned)getIntValue(childRecordSizeExpr->queryChild(1));
                 IHqlExpression * childMaximumSizeExpr = childRecordSizeExpr->queryChild(2);
@@ -1038,9 +1038,9 @@ static IHqlExpression * evaluateFieldAttrSize(IHqlExpression * expr)
                 if (thisSize == UNKNOWN_LENGTH)
                 {
                     minSize = 0;
-                    IHqlExpression * maxSizeExpr = expr->queryProperty(maxSizeAtom);
+                    IHqlExpression * maxSizeExpr = expr->queryAttribute(maxSizeAtom);
                     if (!maxSizeExpr)
-                        maxSizeExpr = expr->queryProperty(maxLengthAtom);
+                        maxSizeExpr = expr->queryAttribute(maxLengthAtom);
 
                     if (maxSizeExpr)
                         maxSize = (unsigned)getIntValue(maxSizeExpr->queryChild(0));
@@ -1077,22 +1077,22 @@ static IHqlExpression * evaluateFieldAttrSize(IHqlExpression * expr)
     if ((thisSize == minSize) && (minSize == maxSize))
     {
         OwnedHqlExpr attr = getFixedSizeAttr(thisSize);
-        return meta.addAttribute(expr, EPsize, attr);
+        return meta.addProperty(expr, EPsize, attr);
     }
 
     if (!thisMaxSizeExpr)
         thisMaxSizeExpr.setown((maxSize == UNKNOWN_LENGTH) ? createAttribute(unknownSizeFieldAtom) : getSizetConstant(maxSize));
     OwnedHqlExpr attr = createExprAttribute(_propSize_Atom, getSizetConstant(thisSize), getSizetConstant(minSize), thisMaxSizeExpr.getClear());
-    return meta.addAttribute(expr, EPsize, attr);
+    return meta.addProperty(expr, EPsize, attr);
 }
 
 //no_ifblock
 static IHqlExpression * evaluateIfBlockAttrSize(IHqlExpression * expr) 
 { 
-    IHqlExpression * size = expr->queryChild(1)->queryAttribute(EPsize);
+    IHqlExpression * size = expr->queryChild(1)->queryProperty(EPsize);
     unsigned averageSize = (unsigned)getIntValue(size->queryChild(0), 0)/2;
     OwnedHqlExpr attr = createExprAttribute(_propSize_Atom, getSizetConstant(averageSize), getSizetConstant(0), LINK(size->queryChild(2)));
-    return meta.addAttribute(expr, EPsize, attr);
+    return meta.addProperty(expr, EPsize, attr);
 }
 
 //no_record
@@ -1124,7 +1124,7 @@ static IHqlExpression * evaluateRecordAttrSize(IHqlExpression * expr)
         else
         {
             packer.reset();
-            IHqlExpression * size = cur->queryAttribute(EPsize);
+            IHqlExpression * size = cur->queryProperty(EPsize);
             if (size)
             {
                 expectedSize += (size32_t)getIntValue(size->queryChild(0));
@@ -1145,7 +1145,7 @@ static IHqlExpression * evaluateRecordAttrSize(IHqlExpression * expr)
 
     if ((minimumSize != maximumSize) || maximumSizeExpr || hasUnknownMaxSizeField)
     {
-        IHqlExpression * maxLength = queryPropertyChild(expr, maxLengthAtom, 0);
+        IHqlExpression * maxLength = queryAttributeChild(expr, maxLengthAtom, 0);
         if (maxLength)
         {
             if (!hasUnknownMaxSizeField)
@@ -1191,7 +1191,7 @@ static IHqlExpression * evaluateRecordAttrSize(IHqlExpression * expr)
         }
     }
 
-    if ((maximumSize == 0) && expr->hasProperty(_nonEmpty_Atom))
+    if ((maximumSize == 0) && expr->hasAttribute(_nonEmpty_Atom))
     {
         expectedSize = 1;
         minimumSize = 1;
@@ -1212,11 +1212,11 @@ static IHqlExpression * evaluateRecordAttrSize(IHqlExpression * expr)
         args.append(*LINK(derivedSizeExpr));
 
     OwnedHqlExpr sizeAttr = createExprAttribute(_propSize_Atom, args);
-    return meta.addAttribute(expr, EPsize, sizeAttr);
+    return meta.addProperty(expr, EPsize, sizeAttr);
 }
 
 
-static IHqlExpression * evaluateAttrSize(IHqlExpression * expr)
+static IHqlExpression * evalautePropSize(IHqlExpression * expr)
 {
     switch (expr->getOperator())
     {
@@ -1231,13 +1231,13 @@ static IHqlExpression * evaluateAttrSize(IHqlExpression * expr)
         {
             //MORE: This could calculate a better estimate for the size of the record by taking into account any constant values or datasets that are assigned.
             IHqlExpression * record = expr->queryRecord();
-            IHqlExpression * recordSize = record->queryAttribute(EPsize);
-            return meta.addAttribute(expr, EPsize, recordSize);
+            IHqlExpression * recordSize = record->queryProperty(EPsize);
+            return meta.addProperty(expr, EPsize, recordSize);
         }
     }
     IHqlExpression * record = expr->queryRecord();
     if (record)
-        return record->queryAttribute(EPsize);
+        return record->queryProperty(EPsize);
     return NULL;
 }
 
@@ -1292,10 +1292,10 @@ ITypeInfo * getSerializedForm(ITypeInfo * type, IAtom * variation)
 
 //Use a transformer to implement the mapping - since it contains the logic for processing types etc, but use the attributes as an extra cache.
 
-class HqlCachedAttributeTransformer : public QuickHqlTransformer
+class HqlCachedPropertyTransformer : public QuickHqlTransformer
 {
 public:
-    HqlCachedAttributeTransformer(HqlTransformerInfo & _transformInfo, ExprPropKind _propKind);
+    HqlCachedPropertyTransformer(HqlTransformerInfo & _transformInfo, ExprPropKind _propKind);
 
     virtual IHqlExpression * transform(IHqlExpression * expr);
 
@@ -1303,15 +1303,15 @@ protected:
     ExprPropKind propKind;
 };
 
-HqlCachedAttributeTransformer::HqlCachedAttributeTransformer(HqlTransformerInfo & _transformInfo, ExprPropKind _propKind)
+HqlCachedPropertyTransformer::HqlCachedPropertyTransformer(HqlTransformerInfo & _transformInfo, ExprPropKind _propKind)
 : QuickHqlTransformer(_transformInfo, NULL), propKind(_propKind)
 {
 }
 
 
-IHqlExpression * HqlCachedAttributeTransformer::transform(IHqlExpression * expr)
+IHqlExpression * HqlCachedPropertyTransformer::transform(IHqlExpression * expr)
 {
-    IHqlExpression * match = meta.queryExistingAttribute(expr, propKind);
+    IHqlExpression * match = meta.queryExistingProperty(expr, propKind);
     if (match)
         return LINK(match);
 
@@ -1320,16 +1320,16 @@ IHqlExpression * HqlCachedAttributeTransformer::transform(IHqlExpression * expr)
     if (transformed != expr)
     {
         //Tag serialized form so don't re-evaluate
-        meta.addAttribute(transformed, propKind, transformed);
+        meta.addProperty(transformed, propKind, transformed);
     }
 
-    meta.addAttribute(expr, propKind, transformed);
+    meta.addProperty(expr, propKind, transformed);
 
     return transformed.getClear();
 }
 
 
-class HqlUnadornedNormalizer : public HqlCachedAttributeTransformer
+class HqlUnadornedNormalizer : public HqlCachedPropertyTransformer
 {
 public:
     HqlUnadornedNormalizer();
@@ -1339,13 +1339,13 @@ public:
 };
 
 static HqlTransformerInfo hqlUnadornedInfo("HqlUnadornedNormalizer");
-HqlUnadornedNormalizer::HqlUnadornedNormalizer() : HqlCachedAttributeTransformer(hqlUnadornedInfo, EPunadorned)
+HqlUnadornedNormalizer::HqlUnadornedNormalizer() : HqlCachedPropertyTransformer(hqlUnadornedInfo, EPunadorned)
 {
 }
 
 ITypeInfo * HqlUnadornedNormalizer::transformType(ITypeInfo * type)
 {
-    return HqlCachedAttributeTransformer::transformType(queryUnqualifiedType(type));
+    return HqlCachedPropertyTransformer::transformType(queryUnqualifiedType(type));
 }
 
 IHqlExpression * HqlUnadornedNormalizer::createTransformed(IHqlExpression * expr)
@@ -1399,15 +1399,15 @@ IHqlExpression * HqlUnadornedNormalizer::createTransformed(IHqlExpression * expr
         }
     }
 
-    return HqlCachedAttributeTransformer::createTransformed(expr);
+    return HqlCachedPropertyTransformer::createTransformed(expr);
 }
 
-static IHqlExpression * evaluateAttrUnadorned(IHqlExpression * expr)
+static IHqlExpression * evalautePropUnadorned(IHqlExpression * expr)
 {
     HqlUnadornedNormalizer normalizer;
     //NB: Also has the side-effect of adding any missing attributes
     OwnedHqlExpr dummy = normalizer.transform(expr);
-    return meta.queryExistingAttribute(expr, EPunadorned);
+    return meta.queryExistingProperty(expr, EPunadorned);
 }
 
 //---------------------------------------------------------------------------------
@@ -1484,8 +1484,8 @@ public:
         IInterface * pright = (IInterface *)(inright);
         IHqlExpression * left = static_cast<IHqlExpression *>(pleft);
         IHqlExpression * right = static_cast<IHqlExpression *>(pright);
-        IHqlExpression * leftSizeAttr = left->queryAttribute(EPsize);
-        IHqlExpression * rightSizeAttr = right->queryAttribute(EPsize);
+        IHqlExpression * leftSizeAttr = left->queryProperty(EPsize);
+        IHqlExpression * rightSizeAttr = right->queryProperty(EPsize);
 
         bool leftIsFixedSize = leftSizeAttr->queryChild(1) == leftSizeAttr->queryChild(2);
         bool rightIsFixedSize = rightSizeAttr->queryChild(1) == rightSizeAttr->queryChild(2);
@@ -1549,7 +1549,7 @@ static bool optimizeFieldOrder(HqlExprArray & out, const HqlExprCopyArray & in)
     return true;
 }
 
-static IHqlExpression * evaluateAttrAligned(IHqlExpression * expr)
+static IHqlExpression * evalautePropAligned(IHqlExpression * expr)
 {
     bool same = true;
     HqlExprArray result;
@@ -1577,11 +1577,11 @@ static IHqlExpression * evaluateAttrAligned(IHqlExpression * expr)
         same = false;
     OwnedHqlExpr newRecord = same ? LINK(expr) : expr->clone(result);
     if (expr == newRecord)
-        return meta.addAttribute(expr, EPaligned, queryAlignedAttr());
-    meta.addAttribute(newRecord, EPaligned, queryAlignedAttr());
+        return meta.addProperty(expr, EPaligned, queryAlignedAttr());
+    meta.addProperty(newRecord, EPaligned, queryAlignedAttr());
     
     OwnedHqlExpr alignAttr = createExprAttribute(_propAligned_Atom, newRecord.getClear());
-    return meta.addAttribute(expr, EPaligned, alignAttr);
+    return meta.addProperty(expr, EPaligned, alignAttr);
 }
 
 //---------------------------------------------------------------------------------
@@ -1649,14 +1649,14 @@ bool isLocalActivity(IHqlExpression * expr)
     case no_aggregate:
     case no_combine:
         assertex(localChangesActivity(expr));
-        return expr->hasProperty(localAtom);
+        return expr->hasAttribute(localAtom);
     case no_newusertable:
         if (isAggregateDataset(expr))
-            return expr->hasProperty(localAtom);
+            return expr->hasAttribute(localAtom);
         return false;
     case no_hqlproject:                 // count project may result in distributed output, but not be local(!)
-        if (expr->hasProperty(_countProject_Atom))
-            return expr->hasProperty(localAtom);
+        if (expr->hasAttribute(_countProject_Atom))
+            return expr->hasAttribute(localAtom);
         return false;
     case no_denormalize:
     case no_denormalizegroup:
@@ -1667,7 +1667,7 @@ bool isLocalActivity(IHqlExpression * expr)
     case no_selfjoin:
     case no_joincount:
         assertex(localChangesActivity(expr));
-        return expr->hasProperty(localAtom);
+        return expr->hasAttribute(localAtom);
     case no_compound:
         return isLocalActivity(expr->queryChild(1));
     case no_compound_diskread:
@@ -1681,7 +1681,7 @@ bool isLocalActivity(IHqlExpression * expr)
     case no_compound_indexcount:
     case no_compound_indexgroupaggregate:
         {
-            if (expr->hasProperty(localAtom))
+            if (expr->hasAttribute(localAtom))
                 return true;
             IHqlExpression * root = queryRoot(expr);
             while (root->getOperator() == no_select)
@@ -1716,7 +1716,7 @@ bool isLocalActivity(IHqlExpression * expr)
 bool isGroupedAggregateActivity(IHqlExpression * expr, IHqlExpression * grouping)
 {
     if (grouping && !grouping->isAttribute())
-        return expr->hasProperty(groupedAtom);
+        return expr->hasAttribute(groupedAtom);
 
     return isGrouped(expr->queryChild(0));
 }
@@ -1784,7 +1784,7 @@ bool isGroupedActivity(IHqlExpression * expr)
     case no_compound:
         return isGroupedActivity(expr->queryChild(1));
     case no_output:
-        return expr->hasProperty(groupedAtom) && isGroupedActivity(expr->queryChild(0));
+        return expr->hasAttribute(groupedAtom) && isGroupedActivity(expr->queryChild(0));
     default:
         if (getNumChildTables(expr) == 1)
             return isGrouped(expr->queryChild(0));
@@ -1857,7 +1857,7 @@ bool localChangesActivityAction(IHqlExpression * expr)
     case no_combine:
         return true;
     case no_hqlproject:
-        return expr->hasProperty(_countProject_Atom);
+        return expr->hasAttribute(_countProject_Atom);
     case no_newusertable:
         return isAggregateDataset(expr);
     case no_denormalize:
@@ -1891,7 +1891,7 @@ unsigned isStreamingActivity(IHqlExpression * expr)
     case no_denormalize:
         if (isKeyedJoin(expr))
             return 0;
-        if (expr->hasProperty(lookupAtom))
+        if (expr->hasAttribute(lookupAtom))
             return 2;
         return 3;       // ok if lhs/rhs are sorted...
     case no_selfjoin:
@@ -1899,7 +1899,7 @@ unsigned isStreamingActivity(IHqlExpression * expr)
     case no_dedup:
         if (isGrouped(expr))
             return 0;
-        if (expr->hasProperty(hashAtom) || expr->hasProperty(allAtom))
+        if (expr->hasAttribute(hashAtom) || expr->hasAttribute(allAtom))
             return false;
         break;
     case no_addfiles:
@@ -1941,7 +1941,7 @@ bool isInlineTrivialDataset(IHqlExpression * expr)
         case no_null:
             return true;
         case no_getgraphresult:
-            return !expr->hasProperty(_distributed_Atom);
+            return !expr->hasAttribute(_distributed_Atom);
         default:
             return false;
         }
@@ -2003,7 +2003,7 @@ bool isTrivialDataset(IHqlExpression * expr)
 
 static unsigned estimateRowSize(IHqlExpression * record)
 {
-    IHqlExpression * size = record->queryAttribute(EPsize);
+    IHqlExpression * size = record->queryProperty(EPsize);
     if (!size || !size->queryChild(2)->queryValue())
         return UNKNOWN_LENGTH;
     return (unsigned)getIntValue(size->queryChild(0));
@@ -2045,7 +2045,7 @@ bool isLimitedDataset(IHqlExpression * expr, bool onFailOnly)
 {
     loop
     {
-        if (expr->hasProperty(limitAtom))
+        if (expr->hasAttribute(limitAtom))
             return true;
 
         switch (expr->getOperator())
@@ -2053,7 +2053,7 @@ bool isLimitedDataset(IHqlExpression * expr, bool onFailOnly)
         case no_choosen:
         case no_limit:
 //      case no_keyedlimit: // not included because it is done before everything else, so filters can be merged in
-            if (!onFailOnly || expr->hasProperty(onFailAtom))
+            if (!onFailOnly || expr->hasAttribute(onFailAtom))
                 return true;
             break;
         case no_table:
@@ -2105,7 +2105,7 @@ unsigned getCardinality(IHqlExpression * expr)
             return 1;
         case no_field:
             {
-                IHqlExpression * cardinality = queryPropertyChild(expr, cardinalityAtom, 0);
+                IHqlExpression * cardinality = queryAttributeChild(expr, cardinalityAtom, 0);
                 if (cardinality)
                     return (unsigned)getIntValue(cardinality);
             }
@@ -2407,7 +2407,7 @@ void HqlRowCountInfo::setUnknown(RowCountMagnitude _magnitude)
 //MORE: This information should be cached in an attribute, once it is working, and used in more than one place.
 void retrieveRowInformation(HqlRowCountInfo & info, IHqlExpression * expr)
 {
-    IHqlExpression * attr = expr->queryAttribute(EPrecordCount);
+    IHqlExpression * attr = expr->queryProperty(EPrecordCount);
     info.extract(attr);
 }
 
@@ -2570,7 +2570,7 @@ IHqlExpression * calcRowInformation(IHqlExpression * expr)
                     //Either aggregate grouped dataset, or grouping supplied.  Similar semantics.
                     //minimum is 1 unless inputs has minimum of 0
                     info.limitMin(1);
-                    if (expr->hasProperty(fewAtom))
+                    if (expr->hasAttribute(fewAtom))
                         info.setMaxMagnitude(RCMfew);
                     else if (isSmallGrouping(grouping))
                         info.setMaxMagnitude(RCMfew);
@@ -2612,16 +2612,16 @@ IHqlExpression * calcRowInformation(IHqlExpression * expr)
     case no_getgraphloopresult:
     case no_getresult:
         {
-            IHqlExpression * attr = expr->queryProperty(_propRecordCount_Atom);
+            IHqlExpression * attr = expr->queryAttribute(_propRecordCount_Atom);
             if (attr)
                 return LINK(attr);
-            if (expr->isDatarow() || expr->hasProperty(rowAtom))
+            if (expr->isDatarow() || expr->hasAttribute(rowAtom))
             {
                 info.setSingleRow();
             }
             else
             {
-                if (expr->hasProperty(_distributed_Atom))
+                if (expr->hasAttribute(_distributed_Atom))
                     info.setUnknown(RCMdisk);
                 else
                     info.setUnknown(RCMfew);
@@ -2632,10 +2632,10 @@ IHqlExpression * calcRowInformation(IHqlExpression * expr)
     case no_keyindex:
     case no_newkeyindex:
         {
-            IHqlExpression * attr = expr->queryProperty(_propRecordCount_Atom);
+            IHqlExpression * attr = expr->queryAttribute(_propRecordCount_Atom);
             if (attr)
                 return LINK(attr);
-            if (expr->isDatarow() || expr->hasProperty(rowAtom))
+            if (expr->isDatarow() || expr->hasAttribute(rowAtom))
             {
                 info.setSingleRow();
             }
@@ -2643,9 +2643,9 @@ IHqlExpression * calcRowInformation(IHqlExpression * expr)
             {
                 info.setUnknown(RCMdisk);
                 //Allow an annotation on a dataset to specify exact and ranges of counts.
-                IHqlExpression * count = queryPropertyChild(expr, countAtom, 0);
-                IHqlExpression * maxCount = queryPropertyChild(expr, maxCountAtom, 0);
-                IHqlExpression * aveCount = queryPropertyChild(expr, aveAtom, 0);
+                IHqlExpression * count = queryAttributeChild(expr, countAtom, 0);
+                IHqlExpression * maxCount = queryAttributeChild(expr, maxCountAtom, 0);
+                IHqlExpression * aveCount = queryAttributeChild(expr, aveAtom, 0);
                 if (count)
                     info.setN(getIntValue(count));
                 else if (maxCount)
@@ -2793,8 +2793,8 @@ IHqlExpression * calcRowInformation(IHqlExpression * expr)
             if (!expr->isDatarow())
             {
                 IHqlExpression * field = expr->queryChild(1);
-                __int64 count = getIntValue(queryPropertyChild(field, countAtom, 0), 0);
-                __int64 maxcount = getIntValue(queryPropertyChild(field, maxCountAtom, 0), 0);
+                __int64 count = getIntValue(queryAttributeChild(field, countAtom, 0), 0);
+                __int64 maxcount = getIntValue(queryAttributeChild(field, maxCountAtom, 0), 0);
                 if (count)
                     info.scaleFixed(count);
                 else if (maxcount)
@@ -2830,18 +2830,18 @@ IHqlExpression * calcRowInformation(IHqlExpression * expr)
     case no_selfjoin:
         {
             bool maxSingleRowOut = false;
-            if (expr->hasProperty(leftonlyAtom))
+            if (expr->hasAttribute(leftonlyAtom))
                 maxSingleRowOut = true;
             else if (isLeftJoin(expr) || isInnerJoin(expr))
             {
-                IHqlExpression * keep = queryPropertyChild(expr, keepAtom, 0);
+                IHqlExpression * keep = queryAttributeChild(expr, keepAtom, 0);
                 if (matchesConstantValue(keep, 1))
                     maxSingleRowOut = true;
             }
             if (maxSingleRowOut)
             {
                 retrieveRowInformation(info, ds);
-                if (!expr->hasProperty(leftouterAtom) || containsSkip(expr->queryChild(3)))
+                if (!expr->hasAttribute(leftouterAtom) || containsSkip(expr->queryChild(3)))
                     info.limitMin(0);
             }
             else
@@ -2965,10 +2965,10 @@ IHqlExpression * calcRowInformation(IHqlExpression * expr)
     return info.createRecordCountAttr();
 }
 
-static IHqlExpression * evaluateAttrRecordCount(IHqlExpression * expr) 
+static IHqlExpression * evalautePropRecordCount(IHqlExpression * expr)
 {
     OwnedHqlExpr info = calcRowInformation(expr);
-    return meta.addAttribute(expr, EPrecordCount, info);
+    return meta.addProperty(expr, EPrecordCount, info);
 }
 
 
@@ -3023,7 +3023,7 @@ bool hasNoMoreRowsThan(IHqlExpression * expr, __int64 limit)
 
 // Functions for accessing attributes from types etc.
 
-IHqlExpression * queryProperty(ITypeInfo * type, IAtom * search)
+IHqlExpression * queryAttribute(ITypeInfo * type, IAtom * search)
 {
     loop
     {
@@ -3042,7 +3042,7 @@ IHqlExpression * queryProperty(ITypeInfo * type, IAtom * search)
         case typemod_original:
             {
                 IHqlExpression * original = static_cast<IHqlExpression *>(type->queryModifierExtra());
-                IHqlExpression * match = original->queryProperty(search);
+                IHqlExpression * match = original->queryAttribute(search);
                 if (match)
                     return match;
                 break;
@@ -3052,9 +3052,9 @@ IHqlExpression * queryProperty(ITypeInfo * type, IAtom * search)
     }
 }
 
-IHqlExpression * queryPropertyChild(ITypeInfo * type, IAtom * search, unsigned idx)
+IHqlExpression * queryAttributeChild(ITypeInfo * type, IAtom * search, unsigned idx)
 {
-    IHqlExpression * match = queryProperty(type, search);
+    IHqlExpression * match = queryAttribute(type, search);
     if (match)
         return match->queryChild(idx);
     return NULL;
@@ -3065,10 +3065,10 @@ IHqlExpression * queryPropertyChild(ITypeInfo * type, IAtom * search, unsigned i
 
 void cloneFieldModifier(Shared<ITypeInfo> & type, ITypeInfo * donorType, IAtom * attr)
 {
-    IHqlExpression * match = queryProperty(donorType, attr);
+    IHqlExpression * match = queryAttribute(donorType, attr);
     if (!match)
         return;
-    IHqlExpression * existing = queryProperty(type, attr);
+    IHqlExpression * existing = queryAttribute(type, attr);
     if (match == existing)
         return;
     type.setown(makeAttributeModifier(type.getClear(), LINK(match)));
@@ -3171,7 +3171,7 @@ ITypeInfo * getPromotedECLCompareType(ITypeInfo * lType, ITypeInfo * rType)
 
 unsigned getMaxRecordSize(IHqlExpression * record, unsigned defaultMaxRecordSize, bool & hasKnownSize, bool & usedDefault)
 {
-    IHqlExpression * size = record->queryAttribute(EPsize);
+    IHqlExpression * size = record->queryProperty(EPsize);
     IHqlExpression * minSizeExpr = size->queryChild(1);
     IHqlExpression * maxSizeExpr = size->queryChild(2);
     unsigned maxSize = (unsigned)getIntValue(maxSizeExpr, UNKNOWN_LENGTH);
@@ -3195,13 +3195,13 @@ unsigned getMaxRecordSize(IHqlExpression * record, unsigned defaultMaxRecordSize
 
 size32_t getExpectedRecordSize(IHqlExpression * record)
 {
-    IHqlExpression * size = record->queryAttribute(EPsize);
+    IHqlExpression * size = record->queryProperty(EPsize);
     return size ? (size32_t)getIntValue(size->queryChild(0)) : 0;
 }
 
 size32_t getMinRecordSize(IHqlExpression * record)
 {
-    IHqlExpression * size = record->queryAttribute(EPsize);
+    IHqlExpression * size = record->queryProperty(EPsize);
     return size ? (size32_t)getIntValue(size->queryChild(1)) : 0;
 }
 
@@ -3213,19 +3213,19 @@ unsigned getMaxRecordSize(IHqlExpression * record, unsigned defaultMaxRecordSize
 
 bool maxRecordSizeUsesDefault(IHqlExpression * record)
 {
-    IHqlExpression * maxSize = record->queryAttribute(EPsize)->queryChild(2);
+    IHqlExpression * maxSize = record->queryProperty(EPsize)->queryChild(2);
     return (maxSize->queryValue() == NULL);
 }
 
 bool isVariableSizeRecord(IHqlExpression * record)
 {
-    IHqlExpression * sizeAttr = record->queryAttribute(EPsize);
+    IHqlExpression * sizeAttr = record->queryProperty(EPsize);
     return sizeAttr->queryChild(1) != sizeAttr->queryChild(2);
 }
 
 bool maxRecordSizeIsAmbiguous(IHqlExpression * record, size32_t & specifiedSize, size32_t & derivedSize)
 {
-    IHqlExpression * sizeAttr = record->queryAttribute(EPsize);
+    IHqlExpression * sizeAttr = record->queryProperty(EPsize);
     IHqlExpression * derivedSizeExpr = sizeAttr->queryChild(3);
     if (!derivedSizeExpr || !derivedSizeExpr->isConstant())
         return false;
@@ -3247,9 +3247,9 @@ bool maxRecordSizeCanBeDerived(IHqlExpression * record)
 {
     if (!isVariableSizeRecord(record))
         return true;
-    if (record->hasProperty(maxLengthAtom))
+    if (record->hasAttribute(maxLengthAtom))
     {
-        IHqlExpression * sizeAttr = record->queryAttribute(EPsize);
+        IHqlExpression * sizeAttr = record->queryProperty(EPsize);
         IHqlExpression * derivedSizeExpr = sizeAttr->queryChild(3);
         return (derivedSizeExpr != NULL);
     }
@@ -3320,23 +3320,23 @@ extern HQL_API bool typeRequiresDeserialization(ITypeInfo * type, IAtom * serial
 
 IHqlExpression * queryRecordCountInfo(IHqlExpression * expr)
 {
-    return expr->queryAttribute(EPrecordCount);
+    return expr->queryProperty(EPrecordCount);
 }
 
 IHqlExpression * getRecordCountInfo(IHqlExpression * expr)
 {
-    return LINK(expr->queryAttribute(EPrecordCount));
+    return LINK(expr->queryProperty(EPrecordCount));
 }
 
 IHqlExpression * queryExpectedRecordCount(IHqlExpression * expr)
 {
-    IHqlExpression * attr = expr->queryAttribute(EPrecordCount);
+    IHqlExpression * attr = expr->queryProperty(EPrecordCount);
     return attr ? attr->queryChild(0) : NULL;
 }
 
 IHqlExpression * getPackedRecord(IHqlExpression * expr)
 {
-    IHqlExpression * attr = expr->queryAttribute(EPaligned);
+    IHqlExpression * attr = expr->queryProperty(EPaligned);
     IHqlExpression * packed = attr->queryChild(0);
     if (!packed) packed = expr;
     return LINK(packed);
@@ -3351,7 +3351,7 @@ IHqlExpression * getUnadornedRecordOrField(IHqlExpression * expr)
 {
     if (!expr)
         return NULL;
-    IHqlExpression * attr = expr->queryAttribute(EPunadorned);
+    IHqlExpression * attr = expr->queryProperty(EPunadorned);
     return LINK(attr);
 }
 
@@ -3470,18 +3470,18 @@ IHqlExpression * HqlLocationIndependentNormalizer::createTransformed(IHqlExpress
     if (isAlwaysLocationIndependent(expr))
         return LINK(expr);
 
-    IHqlExpression * match = meta.queryExistingAttribute(expr, EPlocationIndependent);
+    IHqlExpression * match = meta.queryExistingProperty(expr, EPlocationIndependent);
     if (match)
         return LINK(match);
 
     OwnedHqlExpr transformed = doCreateTransformed(expr);
 
-    meta.addAttribute(expr, EPlocationIndependent, transformed);
+    meta.addProperty(expr, EPlocationIndependent, transformed);
 
     return transformed.getClear();
 }
 
-IHqlExpression * evaluateAttrLocationIndependent(IHqlExpression * expr)
+IHqlExpression * evalautePropLocationIndependent(IHqlExpression * expr)
 {
     if (isAlwaysLocationIndependent(expr))
         return expr->queryBody();
@@ -3496,7 +3496,7 @@ IHqlExpression * evaluateAttrLocationIndependent(IHqlExpression * expr)
 
 IHqlExpression * queryLocationIndependent(IHqlExpression * expr)
 {
-    IHqlExpression * match = expr->queryAttribute(EPlocationIndependent);
+    IHqlExpression * match = expr->queryProperty(EPlocationIndependent);
     if (match)
         return match;
     return expr;
@@ -3505,9 +3505,9 @@ IHqlExpression * queryLocationIndependent(IHqlExpression * expr)
 
 static void clonePropertyAsModifier(Owned<ITypeInfo> & type, IHqlExpression * donor, IAtom * attr)
 {
-    if (queryProperty(type, attr))
+    if (queryAttribute(type, attr))
         return;
-    IHqlExpression * match = donor->queryProperty(attr);
+    IHqlExpression * match = donor->queryAttribute(attr);
     if (!match)
         return;
     type.setown(makeAttributeModifier(type.getClear(), LINK(match)));
@@ -3540,10 +3540,10 @@ ITypeInfo * preserveTypeQualifiers(ITypeInfo * ownedType, IHqlExpression * donor
 
 static bool cloneModifierAsProperty(HqlExprArray & args, ITypeInfo * donor, IAtom * attr)
 {
-    IHqlExpression * match = queryProperty(donor, attr);
+    IHqlExpression * match = queryAttribute(donor, attr);
     if (!match)
         return true;
-    if (queryProperty(attr, args))
+    if (queryAttribute(attr, args))
         return true;
     args.append(*LINK(match));
     return false;
@@ -3693,10 +3693,10 @@ ITypeInfo * setStreamedAttr(ITypeInfo * _type, bool setValue)
 
 //---------------------------------------------------------------------------------------------------------------------
 
-IHqlExpression * CHqlExpression::queryExistingAttribute(ExprPropKind propKind) const
+IHqlExpression * CHqlExpression::queryExistingProperty(ExprPropKind propKind) const
 {
-    CriticalBlock block(*attributeCS);
-    CHqlDynamicAttribute * cur = attributes;
+    CriticalBlock block(*propertyCS);
+    CHqlDynamicProperty * cur = attributes;
     while (cur)
     {
         if (cur->kind == propKind)
@@ -3711,42 +3711,42 @@ IHqlExpression * CHqlExpression::queryExistingAttribute(ExprPropKind propKind) c
     return NULL;
 }
 
-void CHqlExpression::addAttribute(ExprPropKind kind, IHqlExpression * value)
+void CHqlExpression::addProperty(ExprPropKind kind, IHqlExpression * value)
 {
     if (value == this)
         value = NULL;
 
-    CriticalBlock block(*attributeCS);
+    CriticalBlock block(*propertyCS);
     //theoretically we should test if the attribute has already been added by another thread, but in practice there is no
     //problem if the attribute is present twice.
-    CHqlDynamicAttribute * attr = new CHqlDynamicAttribute(kind, value);
+    CHqlDynamicProperty * attr = new CHqlDynamicProperty(kind, value);
     attr->next = attributes;
     attributes = attr;
 }
 
 
-IHqlExpression * CHqlExpression::queryAttribute(ExprPropKind kind)
+IHqlExpression * CHqlExpression::queryProperty(ExprPropKind kind)
 {
-    IHqlExpression * match = queryExistingAttribute(kind);
+    IHqlExpression * match = queryExistingProperty(kind);
     if (match)
         return match;
 
     switch (kind)
     {
     case EPrecordCount:
-        return evaluateAttrRecordCount(this);
+        return evalautePropRecordCount(this);
     case EPdiskserializedForm:
-        return evaluateAttrSerializedForm(this, kind, diskAtom);
+        return evaluatePropSerializedForm(this, kind, diskAtom);
     case EPinternalserializedForm:
-        return evaluateAttrSerializedForm(this, kind, internalAtom);
+        return evaluatePropSerializedForm(this, kind, internalAtom);
     case EPsize:
-        return evaluateAttrSize(this);
+        return evalautePropSize(this);
     case EPaligned:
-        return evaluateAttrAligned(this);
+        return evalautePropAligned(this);
     case EPunadorned:
-        return evaluateAttrUnadorned(this);
+        return evalautePropUnadorned(this);
     case EPlocationIndependent:
-        return evaluateAttrLocationIndependent(this);
+        return evalautePropLocationIndependent(this);
     }
     return NULL;
 }

ecl/hql/hqlattr.hpp

@@ -22,8 +22,8 @@
 
 #define MAX_MAXLENGTH (INFINITE_LENGTH-1)
 
-extern HQL_API IHqlExpression * queryProperty(ITypeInfo * type, IAtom * search);
-extern HQL_API IHqlExpression * queryPropertyChild(ITypeInfo * type, IAtom * search, unsigned idx);
+extern HQL_API IHqlExpression * queryAttribute(ITypeInfo * type, IAtom * search);
+extern HQL_API IHqlExpression * queryAttributeChild(ITypeInfo * type, IAtom * search, unsigned idx);
 extern HQL_API void cloneFieldModifier(Owned<ITypeInfo> & type, ITypeInfo * donorType, IAtom * attr);
 extern HQL_API ITypeInfo * cloneEssentialFieldModifiers(ITypeInfo * donor, ITypeInfo * rawtype);
 extern HQL_API ITypeInfo * removeProperty(ITypeInfo * type, IAtom * search);
@@ -66,10 +66,10 @@ extern HQL_API bool isLinkedRowset(ITypeInfo * t);
 extern HQL_API bool isArrayRowset(ITypeInfo * t);
 extern HQL_API bool hasLinkedRow(ITypeInfo * t);
 
-inline bool hasLinkCountedModifier(ITypeInfo * t)    { return queryProperty(t, _linkCounted_Atom) != NULL; }
+inline bool hasLinkCountedModifier(ITypeInfo * t)    { return queryAttribute(t, _linkCounted_Atom) != NULL; }
 inline bool hasOutOfLineRows(ITypeInfo * type) { return (hasOutOfLineModifier(type) || hasLinkCountedModifier(type)); }
 inline bool hasLinkCountedModifier(IHqlExpression * expr)    { return hasLinkCountedModifier(expr->queryType()); }
-inline bool hasStreamedModifier(ITypeInfo * t)   { return queryProperty(t, streamedAtom) != NULL; }
+inline bool hasStreamedModifier(ITypeInfo * t)   { return queryAttribute(t, streamedAtom) != NULL; }
 
 extern HQL_API ITypeInfo * setLinkCountedAttr(ITypeInfo * _type, bool setValue);
 extern HQL_API ITypeInfo * setStreamedAttr(ITypeInfo * _type, bool setValue);

ecl/hql/hqlexpr.hpp

@@ -1131,8 +1131,8 @@ interface IHqlExpression : public IInterface
     virtual IHqlExpression *queryExternalDefinition() const = 0;
     virtual IHqlExpression *queryNormalizedSelector(bool skipIndex=false) = 0;
 
-    virtual IHqlExpression *queryProperty(IAtom * propName) const = 0;
-    virtual IHqlExpression *queryAttribute(ExprPropKind kind) = 0;
+    virtual IHqlExpression *queryAttribute(IAtom * propName) const = 0;
+    virtual IHqlExpression *queryProperty(ExprPropKind kind) = 0;
 
     virtual ITypeInfo *queryRecordType() = 0;
     virtual IHqlExpression *queryRecord() = 0;
@@ -1175,7 +1175,7 @@ interface IHqlExpression : public IInterface
     inline bool isAnnotation() const { return getAnnotationKind() != annotate_none; }
     inline bool isNamedSymbol() const { return getAnnotationKind() == annotate_symbol; }
     inline bool isFunctionDefinition() const { return getOperator() == no_funcdef; }
-    inline bool hasProperty(IAtom * propName) const { return queryProperty(propName) != NULL; }
+    inline bool hasAttribute(IAtom * propName) const { return queryAttribute(propName) != NULL; }
     inline bool hasText() const 
     { 
         IFileContents * contents = queryDefinitionText();
@@ -1460,15 +1460,15 @@ extern HQL_API IHqlExpression *doInstantEclTransformations(IHqlExpression *qquer
 //extern HQL_API void loadImplicitScopes(IEclRepository &dataServer, HqlScopeArray &defualtScopes, int suppress, IIdAtom * suppressName);
 
 extern HQL_API unsigned getExpressionCRC(IHqlExpression * expr);
-extern HQL_API IHqlExpression * queryPropertyInList(IAtom * search, IHqlExpression * cur);
-extern HQL_API IHqlExpression * queryProperty(IAtom * search, const HqlExprArray & exprs);
+extern HQL_API IHqlExpression * queryAttributeInList(IAtom * search, IHqlExpression * cur);
+extern HQL_API IHqlExpression * queryAttribute(IAtom * search, const HqlExprArray & exprs);
 extern HQL_API IHqlExpression * queryAnnotation(IHqlExpression * expr, annotate_kind search);       // return first match
 extern HQL_API IHqlNamedAnnotation * queryNameAnnotation(IHqlExpression * expr);
 
 inline bool hasAnnotation(IHqlExpression * expr, annotate_kind search){ return queryAnnotation(expr, search) != NULL; }
 inline IHqlExpression * queryNamedSymbol(IHqlExpression * expr) { return queryAnnotation(expr, annotate_symbol); }
 inline bool hasNamedSymbol(IHqlExpression * expr) { return hasAnnotation(expr, annotate_symbol); }
-inline bool hasProperty(IAtom * search, HqlExprArray & exprs) { return queryProperty(search, exprs) != NULL; }
+inline bool hasAttribute(IAtom * search, HqlExprArray & exprs) { return queryAttribute(search, exprs) != NULL; }
 
 extern HQL_API IHqlExpression * queryAnnotationProperty(IAtom * search, IHqlExpression * annotation);
 extern HQL_API IHqlExpression * queryMetaProperty(IAtom * search, IHqlExpression * expr);
@@ -1662,7 +1662,7 @@ extern HQL_API IHqlExpression * queryFunctionDefaults(IHqlExpression * expr);
 
 inline IHqlExpression * querySelSeq(IHqlExpression * expr)
 {
-    return expr->queryProperty(_selectorSequence_Atom);
+    return expr->queryAttribute(_selectorSequence_Atom);
 }
 extern HQL_API IHqlExpression * createGroupedAttribute(ITypeInfo * type);
 extern HQL_API bool isSameUnqualifiedType(ITypeInfo * l, ITypeInfo * r);
@@ -1685,7 +1685,7 @@ inline bool containsNonGlobalAlias(IHqlExpression * expr)
 inline bool containsAssertKeyed(IHqlExpression * expr)  { return (expr->getInfoFlags() & HEFassertkeyed) != 0; }
 inline bool containsAssertStepped(IHqlExpression * expr){ return (expr->getInfoFlags2() & HEF2assertstepped) != 0; }
 inline bool containsCounter(IHqlExpression * expr)      { return (expr->getInfoFlags() & HEFcontainsCounter) != 0; }
-inline bool isCountProject(IHqlExpression * expr)       { return expr->hasProperty(_countProject_Atom); }
+inline bool isCountProject(IHqlExpression * expr)       { return expr->hasAttribute(_countProject_Atom); }
 inline bool containsSkip(IHqlExpression * expr)         { return (expr->getInfoFlags() & (HEFcontainsSkip)) != 0; }
 inline bool containsSelf(IHqlExpression * expr)         { return (expr->getInfoFlags2() & (HEF2containsSelf)) != 0; }
 inline bool isContextDependentExceptGraph(IHqlExpression * expr)    
@@ -1705,11 +1705,11 @@ inline bool containsCall(IHqlExpression * expr, bool includeOutOfLine)
     return (expr->getInfoFlags2() & mask) != 0;
 }
 
-inline bool hasDynamic(IHqlExpression * expr)           { return expr->hasProperty(dynamicAtom); }
+inline bool hasDynamic(IHqlExpression * expr)           { return expr->hasAttribute(dynamicAtom); }
 inline bool isAbstractDataset(IHqlExpression * expr)    
 { 
     IHqlExpression * record = expr->queryRecord();
-    return record && record->hasProperty(abstractAtom);
+    return record && record->hasAttribute(abstractAtom);
 }
 inline IHqlExpression * queryRecord(IHqlExpression * expr)
 {

ecl/hql/hqlexpr.ipp

@@ -43,19 +43,19 @@ typedef byte transformdepth_t;
 
 class CHqlExprMeta;
 
-class HQL_API CHqlDynamicAttribute
+class HQL_API CHqlDynamicProperty
 {
     friend class CHqlExpression;
 public:
-    inline CHqlDynamicAttribute(ExprPropKind _kind, IHqlExpression *_value)
+    inline CHqlDynamicProperty(ExprPropKind _kind, IHqlExpression *_value)
         : kind(_kind), value(_value)
     {
         next = NULL;
     }
-    ~CHqlDynamicAttribute() { delete next; }
+    ~CHqlDynamicProperty() { delete next; }
 
 protected:
-    CHqlDynamicAttribute * next;
+    CHqlDynamicProperty * next;
     LinkedHqlExpr value;
     ExprPropKind kind;
 };
@@ -127,7 +127,7 @@ protected:
     unsigned short infoFlags2;
     transformdepth_t transformDepth[NUM_PARALLEL_TRANSFORMS];           // 1 byte
 
-    CHqlDynamicAttribute * attributes;
+    CHqlDynamicProperty * attributes;
     HqlExprArray operands;
 
 protected:
@@ -148,7 +148,7 @@ protected:
     //Used for determining how a no_select should be interpreted e.g., in table gathering. 
     inline bool isSelectRootAndActive() const
     {
-        if (hasProperty(newAtom))
+        if (hasAttribute(newAtom))
             return false;
         IHqlExpression * ds = queryChild(0);
         if ((ds->getOperator() == no_select) && ds->isDatarow())
@@ -166,7 +166,7 @@ protected:
         operands.append(child);
         onAppendOperand(child, which);
     }
-    IHqlExpression * queryExistingAttribute(ExprPropKind kind) const;
+    IHqlExpression * queryExistingProperty(ExprPropKind kind) const;
 
     void initFlagsBeforeOperands();
     void updateFlagsAfterOperands();
@@ -176,7 +176,7 @@ protected:
     virtual unsigned getCachedEclCRC();
     void setInitialHash(unsigned typeHash);
 
-    void addAttribute(ExprPropKind kind, IHqlExpression * value);
+    void addProperty(ExprPropKind kind, IHqlExpression * value);
 
 public:
     virtual void Link(void) const;
@@ -192,8 +192,8 @@ public:
     virtual IHqlDataset *queryDataset() { return NULL; };
     virtual IHqlScope *queryScope();
     virtual IHqlSimpleScope *querySimpleScope();
-    virtual IHqlExpression *queryProperty(IAtom * propName) const;
-    virtual IHqlExpression *queryAttribute(ExprPropKind kind);
+    virtual IHqlExpression *queryAttribute(IAtom * propName) const;
+    virtual IHqlExpression *queryProperty(ExprPropKind kind);
     virtual IHqlExpression *queryFunctionDefinition() const { return NULL; };
     virtual IHqlExpression *queryExternalDefinition() const { return NULL; };
     virtual unsigned getInfoFlags() const { return infoFlags; }
@@ -502,8 +502,8 @@ public:
     virtual IHqlExpression *queryFunctionDefinition() const;
     virtual IHqlExpression *queryExternalDefinition() const;
     virtual IHqlExpression *queryNormalizedSelector(bool skipIndex=false);
-    virtual IHqlExpression *queryProperty(IAtom * propName) const;
-    virtual IHqlExpression *queryAttribute(ExprPropKind kind);
+    virtual IHqlExpression *queryAttribute(IAtom * propName) const;
+    virtual IHqlExpression *queryProperty(ExprPropKind kind);
     virtual IHqlExpression * clone(HqlExprArray &);
     virtual IHqlExpression * cloneAnnotation(IHqlExpression * body) = 0;
     virtual IHqlExpression * cloneAllAnnotations(IHqlExpression * body);

ecl/hql/hqlfold.cpp

@@ -618,14 +618,14 @@ IValue * foldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplateC
 
     const char * entrypoint = entry.toCharArray();
     const char * library = lib.toCharArray();
-    if(!body->hasProperty(pureAtom) && !body->hasProperty(templateAtom) && !(foldOptions & (HFOfoldimpure|HFOforcefold)))
+    if(!body->hasAttribute(pureAtom) && !body->hasAttribute(templateAtom) && !(foldOptions & (HFOfoldimpure|HFOforcefold)))
     {
         if (foldOptions & HFOthrowerror)
             throw MakeStringException(ERR_TMPLT_NONPUREFUNC, "%s/%s is not a pure function, can't constant fold it", library, entrypoint);
         return NULL;
     }
 
-    if(!body->hasProperty(cAtom)) 
+    if(!body->hasAttribute(cAtom))
     {
         if (!createMangledFunctionName(mangledEntry, funcdef))
         {
@@ -636,8 +636,8 @@ IValue * foldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplateC
         entrypoint = mangledEntry.str();
     }
 
-    if(body->hasProperty(contextAtom) || body->hasProperty(globalContextAtom) ||
-       body->hasProperty(gctxmethodAtom) || body->hasProperty(ctxmethodAtom) || body->hasProperty(omethodAtom)) 
+    if(body->hasAttribute(contextAtom) || body->hasAttribute(globalContextAtom) ||
+       body->hasAttribute(gctxmethodAtom) || body->hasAttribute(ctxmethodAtom) || body->hasAttribute(omethodAtom))
     {
         if (foldOptions & HFOthrowerror)
             throw MakeStringException(ERR_TMPLT_NONEXTERNCFUNC, "%s/%s requires a runtime context to be executed, can't constant fold it", library, entrypoint);
@@ -648,7 +648,7 @@ IValue * foldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplateC
     HINSTANCE hDLL=LoadSharedObject(library, false, false);
     if (!LoadSucceeded(hDLL))
     {
-        if (body->hasProperty(templateAtom))
+        if (body->hasAttribute(templateAtom))
             throw MakeStringException(ERR_SVC_LOADLIBFAILED, "Error happened when trying to load library %s for template helper function", library);
         if (foldOptions & HFOthrowerror)
             throw MakeStringException(ERR_SVC_LOADLIBFAILED, "Error happened when trying to load library %s", library);
@@ -667,11 +667,11 @@ IValue * foldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplateC
     // the called function
     FuncCallStack fstack;
     
-    if(body->hasProperty(templateAtom)) 
+    if(body->hasAttribute(templateAtom))
         fstack.pushPtr(templateContext);
 
     //if these were allowed to be optional - then the following code would be needed
-    if(body->hasProperty(contextAtom) || body->hasProperty(globalContextAtom)) 
+    if(body->hasAttribute(contextAtom) || body->hasAttribute(globalContextAtom))
         fstack.pushPtr(NULL);
 
     bool retCharStar = false;
@@ -1631,15 +1631,15 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
     {
     case no_assertkeyed:
         {
-            assertex(expr->hasProperty(_selectors_Atom));
+            assertex(expr->hasAttribute(_selectors_Atom));
             IHqlExpression * child = expr->queryChild(0);
             IValue * value = child->queryValue();
             if (value)
             {
                 if (!value->getBoolValue())
                     return LINK(child);
-                IHqlExpression * opt = expr->queryProperty(extendAtom);
-                IHqlExpression * selectors = expr->queryProperty(_selectors_Atom);
+                IHqlExpression * opt = expr->queryAttribute(extendAtom);
+                IHqlExpression * selectors = expr->queryAttribute(_selectors_Atom);
                 return createValue(no_assertwild, makeBoolType(), createValue(no_all), LINK(selectors), LINK(opt));
             }
             break;
@@ -1837,7 +1837,7 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
                     UChar * search = (UChar *)malloc((slen)*2);
                     t0->getUCharStringValue(plen+1, pattern); //plen+1 so get null-terminated
                     t1->getUCharStringValue(slen, search);
-                    ICompiledUStrRegExpr * compiled = rtlCreateCompiledUStrRegExpr(pattern, !expr->hasProperty(noCaseAtom));
+                    ICompiledUStrRegExpr * compiled = rtlCreateCompiledUStrRegExpr(pattern, !expr->hasAttribute(noCaseAtom));
                     IUStrRegExprFindInstance * match = compiled->find(search, 0, slen);
                     ITypeInfo * type = expr->queryType();
                     if(type->getTypeCode() == type_boolean)
@@ -1861,7 +1861,7 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
                     t0->getStringValue(pattern);
                     t1->getStringValue(search);
                     rtlCompiledStrRegex compiled;
-                    compiled.setPattern(pattern.str(), !expr->hasProperty(noCaseAtom));
+                    compiled.setPattern(pattern.str(), !expr->hasAttribute(noCaseAtom));
                     IStrRegExprFindInstance * match = compiled->find(search.str(), 0, search.length(), false);
                     ITypeInfo * type = expr->queryType();
                     if(type->getTypeCode() == type_boolean)
@@ -1902,7 +1902,7 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
                     t2->getUCharStringValue(rlen, replace);
                     size32_t outlen;
                     UChar * out;
-                    ICompiledUStrRegExpr * compiled = rtlCreateCompiledUStrRegExpr(pattern, !expr->hasProperty(noCaseAtom));
+                    ICompiledUStrRegExpr * compiled = rtlCreateCompiledUStrRegExpr(pattern, !expr->hasAttribute(noCaseAtom));
                     compiled->replace(outlen, out, slen, search, rlen, replace);
                     result = createUnicodeValue(outlen, out, expr->getType());
                     rtlFree(out);
@@ -1920,7 +1920,7 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
                     size32_t outlen;
                     char * out;
                     rtlCompiledStrRegex compiled;
-                    compiled.setPattern(pattern.str(), !expr->hasProperty(noCaseAtom));
+                    compiled.setPattern(pattern.str(), !expr->hasAttribute(noCaseAtom));
                     compiled->replace(outlen, out, search.length(), search.str(), replace.length(), replace.str());
                     result = createStringValue(out, outlen);
                     rtlFree(out);
@@ -2879,11 +2879,11 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
 
             // 'R' - trim right, 'L' - Left, 'B' - Left and Right, 'A' - All
             char typecode = 'R';
-            if(expr->hasProperty(allAtom))
+            if(expr->hasAttribute(allAtom))
                 typecode = 'A';
-            else if(expr->hasProperty(leftAtom) && expr->hasProperty(rightAtom))
+            else if(expr->hasAttribute(leftAtom) && expr->hasAttribute(rightAtom))
                 typecode = 'B';
-            else if(expr->hasProperty(leftAtom))
+            else if(expr->hasAttribute(leftAtom))
                 typecode = 'L';
 
             IValue * constValue = child->queryValue();
@@ -3284,12 +3284,12 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
             {
                 //Need to be careful to use the serialized record - otherwise record size can be inconsistent
                 OwnedHqlExpr record = getSerializedForm(child, diskAtom);
-                if (expr->hasProperty(maxAtom))
+                if (expr->hasAttribute(maxAtom))
                 {
                     if (maxRecordSizeCanBeDerived(record))
                         return getSizetConstant(getMaxRecordSize(record, 0));
                 }
-                else if (expr->hasProperty(minAtom))
+                else if (expr->hasAttribute(minAtom))
                 {
                     return getSizetConstant(getMinRecordSize(record));
                 }
@@ -3379,7 +3379,7 @@ IHqlExpression * NullFolderMixin::foldNullDataset(IHqlExpression * expr)
         {
             if (isNull(child) || isFail(child))
                 return removeParentNode(expr);
-            if (expr->hasProperty(skewAtom))
+            if (expr->hasAttribute(skewAtom))
             	break;
             //Careful - distribute also destroys grouping, so don't remove if input is grouped.
             if ((expr->queryType()->queryDistributeInfo() == child->queryType()->queryDistributeInfo()) && !isGrouped(child))
@@ -3489,9 +3489,9 @@ IHqlExpression * NullFolderMixin::foldNullDataset(IHqlExpression * expr)
                 const char * potentialLeftProjectReason = NULL;
                 if (isSpecificJoin(expr, leftouterAtom))
                 {
-                    if (matchesConstantValue(queryPropertyChild(expr, keepAtom, 0), 1))
+                    if (matchesConstantValue(queryAttributeChild(expr, keepAtom, 0), 1))
                         potentialLeftProjectReason = "JOIN(,LEFT OUTER,KEEP(1))";
-                    else if (expr->hasProperty(lookupAtom) && !expr->hasProperty(manyAtom))
+                    else if (expr->hasAttribute(lookupAtom) && !expr->hasAttribute(manyAtom))
                         potentialLeftProjectReason = "JOIN(,LEFT OUTER,SINGLE LOOKUP)";
                     else if (hasNoMoreRowsThan(expr, 1))
                         potentialLeftProjectReason = "JOIN(<single-row>,LEFT OUTER)";
@@ -3526,7 +3526,7 @@ IHqlExpression * NullFolderMixin::foldNullDataset(IHqlExpression * expr)
                 OwnedHqlExpr newTransform = replaceSelector(expr->queryChild(3), right, null);
                 if (op == no_denormalizegroup)
                 {
-                    IHqlExpression * rowsid = expr->queryProperty(_rowsid_Atom);
+                    IHqlExpression * rowsid = expr->queryAttribute(_rowsid_Atom);
                     OwnedHqlExpr rowsExpr = createDataset(no_rows, LINK(right), LINK(rowsid));
                     OwnedHqlExpr nullExpr = createDataset(no_null, LINK(rhs->queryRecord()));
                     newTransform.setown(replaceExpression(newTransform, rowsExpr, nullExpr));
@@ -3600,7 +3600,7 @@ IHqlExpression * NullFolderMixin::foldNullDataset(IHqlExpression * expr)
                     if (op == no_cogroup)
                     {
                         DBGLOG("Folder: Replace %s with group", getOpString(op));
-                        IHqlExpression * grouping = queryPropertyChild(expr, groupAtom, 0);
+                        IHqlExpression * grouping = queryAttributeChild(expr, groupAtom, 0);
                         IHqlExpression * mappedGrouping = replaceSelector(grouping, queryActiveTableSelector(), lastInput);
                         OwnedHqlExpr group = createDataset(no_group, LINK(lastInput), mappedGrouping);
                         return expr->cloneAllAnnotations(group);
@@ -3831,7 +3831,7 @@ IHqlExpression * NullFolderMixin::foldNullDataset(IHqlExpression * expr)
             return replaceWithNullRow(child);
         break;  
     case no_select:
-        if (isNull(child) && expr->hasProperty(newAtom))
+        if (isNull(child) && expr->hasAttribute(newAtom))
             return replaceWithNull(expr);
         break;
     case no_createset:
@@ -3850,7 +3850,7 @@ IHqlExpression * NullFolderMixin::foldNullDataset(IHqlExpression * expr)
     case no_output:
         {
             //Appending a null dataset to an output does nothing (sometimes occurs as a kind of nop)
-            if (!queryRealChild(expr, 1) && expr->hasProperty(extendAtom))
+            if (!queryRealChild(expr, 1) && expr->hasAttribute(extendAtom))
             {
                 if (isNull(child) && child->isDataset())
                     return replaceWithNull(expr);
@@ -4670,7 +4670,7 @@ IHqlExpression * CExprFolderTransformer::doFoldTransformed(IHqlExpression * unfo
         {
             //Don't fold dataset references that are in scope, 
             //otherwise the dataset will fail to match...
-            if (expr->hasProperty(newAtom))
+            if (expr->hasAttribute(newAtom))
             {
                 IHqlExpression * left = expr->queryChild(0);
                 switch (left->getOperator())
@@ -4778,7 +4778,7 @@ IHqlExpression * CExprFolderTransformer::doFoldTransformed(IHqlExpression * unfo
         if (expr != original)
         {
             //Could have removed whether or not somethin needs to be a count project
-            IHqlExpression * counter = queryPropertyChild(expr, _countProject_Atom, 0);
+            IHqlExpression * counter = queryAttributeChild(expr, _countProject_Atom, 0);
             if (counter && !transformContainsCounter(expr->queryChild(1), counter))
                 return removeProperty(expr, _countProject_Atom);
         }
@@ -5013,7 +5013,7 @@ IHqlExpression * CExprFolderTransformer::percolateConstants(IHqlExpression * exp
             IAtom * joinKind = queryJoinKind(expr);
             IHqlExpression * rhs = expr->queryChild(1);
             IHqlExpression * oldCond = updated->queryChild(2);
-            IHqlExpression * atmost = updated->queryProperty(atmostAtom);
+            IHqlExpression * atmost = updated->queryAttribute(atmostAtom);
             switch (op)
             {
             case no_denormalize:
@@ -5115,7 +5115,7 @@ IHqlExpression * CExprFolderTransformer::percolateConstants(IHqlExpression * exp
             HqlConstantPercolator * mapping = gatherConstants(expr);
             if (mapping)
             {
-                IHqlExpression * sorted = expr->queryProperty(sortedAtom);
+                IHqlExpression * sorted = expr->queryAttribute(sortedAtom);
                 assertex(sorted);
                 OwnedHqlExpr newSorted = percolateConstants(mapping, sorted, child, no_activetable);
                 updated.setown(replaceOwnedProperty(updated, newSorted.getClear()));
@@ -5133,7 +5133,7 @@ IHqlExpression * CExprFolderTransformer::percolateConstants(IHqlExpression * exp
             //unusual guard condition.
             //MORE: This needs more work to allow ds[1].x.y to be substituted, but that is very unusual
             //simplest would be to recurse, build up for a list of fields, and then pass to resolveFields()
-            if (expr->hasProperty(newAtom))
+            if (expr->hasAttribute(newAtom))
             {
                 IHqlExpression * field = expr->queryChild(1);
                 OwnedHqlExpr transformedDs = transform(expr->queryChild(0));
@@ -5597,7 +5597,7 @@ HqlConstantPercolator * CExprFolderTransformer::gatherConstants(IHqlExpression *
         }
     case no_aggregate:
         {
-            if (expr->hasProperty(mergeTransformAtom))
+            if (expr->hasAttribute(mergeTransformAtom))
                 break;
             IHqlExpression * transform = queryNewColumnProvider(expr);
             exprMapping.setown(HqlConstantPercolator::extractConstantMapping(transform));
@@ -5702,7 +5702,7 @@ HqlConstantPercolator * CExprFolderTransformer::gatherConstants(IHqlExpression *
         {
             //Careful - this can create a null row if it is out of range.
             bool inherit = false;
-            if (expr->hasProperty(noBoundCheckAtom))
+            if (expr->hasAttribute(noBoundCheckAtom))
                 inherit = true;
             else if (matchesConstantValue(expr->queryChild(1), 1) && hasSingleRow(expr->queryChild(0)))
                 inherit = true;
@@ -5824,7 +5824,7 @@ HqlConstantPercolator * CExprFolderTransformer::gatherConstants(IHqlExpression *
     }
     if (exprMapping)
     {
-        IHqlExpression * onFail = expr->queryProperty(onFailAtom);
+        IHqlExpression * onFail = expr->queryAttribute(onFailAtom);
         if (onFail)
         {
             HqlConstantPercolator * onFailMapping = gatherConstants(onFail->queryChild(0));

ecl/hql/hqlgram.y

@@ -2260,12 +2260,12 @@ actionStmt
                             IHqlExpression * filename = options.ordinality() ? &options.item(0) : NULL;
                             if (!filename || filename->isAttribute())
                             {
-                                if (queryProperty(extendAtom, options) && !queryProperty(namedAtom, options))
+                                if (queryAttribute(extendAtom, options) && !queryAttribute(namedAtom, options))
                                     parser->reportError(ERR_EXTEND_NOT_VALID, $7, "EXTEND is only valid on NAMED outputs");
                             }
                             else
                             {
-                                if (queryProperty(extendAtom, options))
+                                if (queryAttribute(extendAtom, options))
                                     parser->reportError(ERR_NOLONGER_SUPPORTED,$7,"EXTEND is no longer supported on OUTPUT to file");
 
                                 if (filename->isPure())
@@ -2310,13 +2310,13 @@ actionStmt
                             }
                             pipe->unwindList(args, no_comma);
                             $9.unwindCommaList(args);
-                            IHqlExpression * output = queryProperty(outputAtom, args);
+                            IHqlExpression * output = queryAttribute(outputAtom, args);
                             if (output)
                             {
                                 unwindChildren(args, output);
                                 args.zap(*output);
                             }
-                            if (queryProperty(csvAtom, args))
+                            if (queryAttribute(csvAtom, args))
                                 parser->checkValidCsvRecord($3, args.item(0).queryRecord());
 
                             parser->warnIfRecordPacked(&args.item(0), $1);
@@ -2329,7 +2329,7 @@ actionStmt
                             OwnedHqlExpr select = createDatasetF(no_selectfields, dataset, record, NULL); //createUniqueId(), NULL);
                             OwnedHqlExpr flags = $4.getExpr();
 
-                            if (queryPropertyInList(extendAtom, flags) && !queryPropertyInList(namedAtom, flags))
+                            if (queryAttributeInList(extendAtom, flags) && !queryAttributeInList(namedAtom, flags))
                                 parser->reportError(ERR_EXTEND_NOT_VALID, $4, "EXTEND is only valid on NAMED outputs");
 
                             HqlExprArray args;
@@ -2343,7 +2343,7 @@ actionStmt
                         {
                             parser->normalizeExpression($3);
                             OwnedHqlExpr flags = $4.getExpr();
-                            if (queryPropertyInList(extendAtom, flags))
+                            if (queryAttributeInList(extendAtom, flags))
                                 parser->reportError(ERR_EXTEND_NOT_VALID, $4, "EXTEND is only valid on a dataset");
                             HqlExprArray args;
                             args.append(*$3.getExpr());
@@ -2355,7 +2355,7 @@ actionStmt
                         {
                             parser->normalizeExpression($3);
                             OwnedHqlExpr flags = $4.getExpr();
-                            if (queryPropertyInList(extendAtom, flags))
+                            if (queryAttributeInList(extendAtom, flags))
                                 parser->reportError(ERR_EXTEND_NOT_VALID, $4, "EXTEND is only valid on a dataset");
                             HqlExprArray args;
                             args.append(*createDataset(no_datasetfromdictionary, $3.getExpr()));
@@ -2367,7 +2367,7 @@ actionStmt
     | OUTPUT '(' dataRow optOutputWuFlags ')'
                         {
                             OwnedHqlExpr flags = $4.getExpr();
-                            if (queryPropertyInList(extendAtom, flags))
+                            if (queryAttributeInList(extendAtom, flags))
                                 parser->reportError(ERR_EXTEND_NOT_VALID, $4, "EXTEND is only valid on a dataset");
                             HqlExprArray args;
                             args.append(*$3.getExpr());
@@ -7577,16 +7577,16 @@ simpleDataSet
                             OwnedHqlExpr dedup = createDataset(no_dedup, ds, createComma(flags, $7.getExpr()));
 
                             parser->checkDistribution($3, dedup, false);
-                            bool hasHash = dedup->hasProperty(hashAtom);
-                            if (hasHash || dedup->hasProperty(allAtom))
+                            bool hasHash = dedup->hasAttribute(hashAtom);
+                            if (hasHash || dedup->hasAttribute(allAtom))
                             {
-                                IHqlExpression * keep = dedup->queryProperty(keepAtom);
+                                IHqlExpression * keep = dedup->queryAttribute(keepAtom);
                                 if (keep && !matchesConstantValue(keep->queryChild(0), 1))
                                     parser->reportError(ERR_DEDUP_ALL_KEEP, $4, "KEEP is not supported for DEDUP(ALL)");
                             }
                             if (hasHash)
                             {
-                                if (dedup->hasProperty(rightAtom))
+                                if (dedup->hasAttribute(rightAtom))
                                     parser->reportError(ERR_DEDUP_ALL_KEEP, $4, "RIGHT is not supported for DEDUP(HASH)");
                             }
 
@@ -7644,7 +7644,7 @@ simpleDataSet
                             bool isLimitedSubstringJoin;
                             OwnedHqlExpr match = findJoinSortOrders(cond, NULL, NULL, NULL, leftSorts, rightSorts, isLimitedSubstringJoin, NULL);
                             unsigned numUnsortedFields = numPayloadFields(right);
-                            if (match || (!ds->hasProperty(firstAtom) && (leftSorts.ordinality() != getFieldCount(right->queryRecord())-numUnsortedFields)))
+                            if (match || (!ds->hasAttribute(firstAtom) && (leftSorts.ordinality() != getFieldCount(right->queryRecord())-numUnsortedFields)))
                                 parser->reportError(ERR_MATCH_KEY_EXACTLY,$9,"Condition on DISTRIBUTE must match the key exactly");
                             if (isLimitedSubstringJoin)
                                 parser->reportError(ERR_MATCH_KEY_EXACTLY,$9,"field[1..*] is not supported for a keyed distribute");
@@ -7723,13 +7723,13 @@ simpleDataSet
 
                             IHqlExpression *join = createDataset(no_join, left, createComma(right, cond, createComma(transform.getClear(), flags.getClear(), $10.getExpr())));
 
-                            bool isLocal = join->hasProperty(localAtom);
+                            bool isLocal = join->hasAttribute(localAtom);
                             parser->checkDistribution($3, left, isLocal, true);
                             parser->checkDistribution($5, right, isLocal, true);
                             parser->checkJoinFlags($1, join);
                             parser->checkOnFailRecord(join, $1);
 
-                            if (!join->hasProperty(allAtom))
+                            if (!join->hasAttribute(allAtom))
                                 parser->warnIfFoldsToConstant(cond, $7);
 
                             $$.setExpr(join, $1);
@@ -7754,7 +7754,7 @@ simpleDataSet
                             IHqlExpression * ds = $3.getExpr();
                             IHqlExpression * cond = $6.getExpr();
                             IHqlExpression * tform = $8.getExpr();
-                            if (!queryPropertyInList(sortedAtom, $10.queryExpr()))
+                            if (!queryAttributeInList(sortedAtom, $10.queryExpr()))
                                 parser->reportError(ERR_EXPECTED, $10, "SORTED() is required for STEPPED join");
 
                             OwnedHqlExpr flags;
@@ -7770,7 +7770,7 @@ simpleDataSet
                         {
                             HqlExprArray sortItems;
                             parser->endList(sortItems);
-                            if (!queryProperty(sortedAtom, sortItems))
+                            if (!queryAttribute(sortedAtom, sortItems))
                                 parser->reportWarning(WRN_MERGE_RECOMMEND_SORTED, $1.pos, "MERGE without an explicit SORTED() attribute is deprecated");
 
                             IHqlExpression * ds = $3.getExpr();
@@ -7967,8 +7967,8 @@ simpleDataSet
                             args.append(*LINK(ds));
                             args.append(*$5.getExpr());
                             $6.unwindCommaList(args);
-                            node_operator op = queryProperty(keyedAtom, args) || queryProperty(countAtom, args) ? no_keyedlimit : no_limit;
-                            IHqlExpression * onFail = queryProperty(onFailAtom, args);
+                            node_operator op = queryAttribute(keyedAtom, args) || queryAttribute(countAtom, args) ? no_keyedlimit : no_limit;
+                            IHqlExpression * onFail = queryAttribute(onFailAtom, args);
                             if (onFail && !parser->checkTransformTypeMatch($6, ds, onFail->queryChild(0)))
                                 args.zap(*onFail);
                             $$.setExpr(createDataset(op, args));
@@ -7981,7 +7981,7 @@ simpleDataSet
                             args.append(*LINK(ds));
                             args.append(*$5.getExpr());
                             $6.unwindCommaList(args);
-                            IHqlExpression * onFail = queryProperty(onFailAtom, args);
+                            IHqlExpression * onFail = queryAttribute(onFailAtom, args);
                             if (onFail && !parser->checkTransformTypeMatch($4, ds, onFail->queryChild(0)))
                                 args.zap(*onFail);
                             $$.setExpr(createDataset(no_catchds, args));
@@ -7997,7 +7997,7 @@ simpleDataSet
                             args.append(*$5.getExpr());
                             args.append(*$7.getExpr());
                             $8.unwindCommaList(args);
-                            IHqlExpression * onFail = queryProperty(onFailAtom, args);
+                            IHqlExpression * onFail = queryAttribute(onFailAtom, args);
                             if (onFail && !parser->checkTransformTypeMatch($4, ds, onFail->queryChild(0)))
                                 args.zap(*onFail);
                             $$.setExpr(createDataset(no_catchds, args));
@@ -8006,7 +8006,7 @@ simpleDataSet
 */
     | MERGE '(' startTopFilter ',' mergeDataSetList ')' endTopFilter
                         {
-                            bool isLocal = queryPropertyInList(localAtom, $5.queryExpr()) != NULL;
+                            bool isLocal = queryAttributeInList(localAtom, $5.queryExpr()) != NULL;
                             parser->checkMergeInputSorted($3, isLocal);
                             OwnedHqlExpr ds = $3.getExpr();
 
@@ -8016,7 +8016,7 @@ simpleDataSet
                             if (rest)
                                 rest->unwindList(args, no_comma);
 
-                            IHqlExpression * sorted = queryProperty(sortedAtom, args);
+                            IHqlExpression * sorted = queryAttribute(sortedAtom, args);
                             OwnedHqlExpr newSorted;
                             if (!sorted)
                             {
@@ -8058,7 +8058,7 @@ simpleDataSet
                             args.append(*LINK(ds));
                             if (rest)
                                 rest->unwindList(args, no_comma);
-                            IHqlExpression * group = queryProperty(groupAtom, args);
+                            IHqlExpression * group = queryAttribute(groupAtom, args);
                             if (!group)
                             {
                                 parser->reportError(ERR_COGROUP_NO_GROUP, $1, "COGROUP requires a GROUP() parameter");
@@ -8197,8 +8197,8 @@ simpleDataSet
                             
                             //Non-all Group only make sense if the rows are together.  This can occur if
                             //the dataset is sorted, or if previous operation was a grouped aggregate
-                            bool isLocal = queryPropertyInList(localAtom, attrs) != NULL;
-                            if (groupOrder && !queryPropertyInList(allAtom, attrs) && !appearsToBeSorted(input->queryType(), isLocal, true))
+                            bool isLocal = queryAttributeInList(localAtom, attrs) != NULL;
+                            if (groupOrder && !queryAttributeInList(allAtom, attrs) && !appearsToBeSorted(input->queryType(), isLocal, true))
                             {
                                 bool ok = (input->getOperator() == no_usertable) &&
                                           (datasetHasGroupBy(input));// || isGrouped(input->queryChild(0)));
@@ -8273,7 +8273,7 @@ simpleDataSet
                             OwnedHqlExpr attrs;
                             OwnedHqlExpr grouping = parser->processSortList($7, no_usertable, dataset, sortItems, NULL, &attrs);
 
-                            if (grouping && !queryPropertyInList(groupedAtom, attrs))
+                            if (grouping && !queryAttributeInList(groupedAtom, attrs))
                             {
                                 parser->checkGrouping($7, dataset,record,grouping);
                                 if (dataset->getOperator() == no_group && dataset->queryType()->queryGroupInfo())
@@ -8589,7 +8589,7 @@ simpleDataSet
 
                             OwnedHqlExpr attrs = $6.getExpr();
                             parser->checkValidPipeRecord($3, $3.queryExpr()->queryRecord(), attrs, NULL);
-                            parser->checkValidPipeRecord($3, $3.queryExpr()->queryRecord(), NULL, queryPropertyInList(outputAtom, attrs));
+                            parser->checkValidPipeRecord($3, $3.queryExpr()->queryRecord(), NULL, queryAttributeInList(outputAtom, attrs));
 
                             $$.setExpr(createDataset(no_pipe, $3.getExpr(), createComma($5.getExpr(), LINK(attrs))));
                             $$.setPosition($1);
@@ -8599,7 +8599,7 @@ simpleDataSet
                             parser->normalizeExpression($5, type_string, false);
 
                             OwnedHqlExpr attrs = $8.getExpr();
-                            parser->checkValidPipeRecord($3, $3.queryExpr()->queryRecord(), NULL, queryPropertyInList(outputAtom, attrs));
+                            parser->checkValidPipeRecord($3, $3.queryExpr()->queryRecord(), NULL, queryAttributeInList(outputAtom, attrs));
                             parser->checkValidPipeRecord($7, $7.queryExpr()->queryRecord(), attrs, NULL);
 
                             $$.setExpr(createDataset(no_pipe, $3.getExpr(), createComma($5.getExpr(), $7.getExpr(), LINK(attrs))));
@@ -8636,10 +8636,10 @@ simpleDataSet
                             }
                             else
                             {
-                                IHqlExpression * best = queryPropertyInList(bestAtom, attrs);
+                                IHqlExpression * best = queryAttributeInList(bestAtom, attrs);
                                 if (best)
                                     parser->checkMaxCompatible(sortOrder, best, $9);
-                                bool isLocal = (queryPropertyInList(localAtom, attrs)!=NULL);
+                                bool isLocal = (queryAttributeInList(localAtom, attrs)!=NULL);
                                 parser->checkDistribution($3, input, isLocal, false);
                                 attrs.setown(createComma(sortOrder, $5.getExpr(), LINK(attrs)));
                                 $$.setExpr(createDataset(no_topn, input, attrs.getClear()));
@@ -8819,7 +8819,7 @@ simpleDataSet
                             parser->normalizeExpression($5, type_stringorunicode, false);
                             parser->checkOutputRecord($9, false);
                             IHqlExpression * ds = createDataset(no_parse, $3.getExpr(), createComma($5.getExpr(), $7.getExpr(), $9.getExpr(), createComma($12.getExpr(), $14.getExpr())));
-                            if (ds->hasProperty(tomitaAtom) && (ds->queryChild(2)->queryType()->getTypeCode() == type_pattern))
+                            if (ds->hasAttribute(tomitaAtom) && (ds->queryChild(2)->queryType()->getTypeCode() == type_pattern))
                                 parser->reportError(ERR_EXPECTED_RULE, $7, "Expected a rule as parameter to PARSE");
                             $$.setExpr(ds);
                             $$.setPosition($1);
@@ -8829,7 +8829,7 @@ simpleDataSet
                             parser->normalizeExpression($5, type_stringorunicode, false);
                             IHqlExpression * record = $9.queryExpr()->queryRecord();
                             IHqlExpression * ds = createDataset(no_newparse, $3.getExpr(), createComma($5.getExpr(), $7.getExpr(), LINK(record), createComma($9.getExpr(), $12.getExpr(), $14.getExpr())));
-                            if (ds->hasProperty(tomitaAtom) && (ds->queryChild(2)->queryType()->getTypeCode() == type_pattern))
+                            if (ds->hasAttribute(tomitaAtom) && (ds->queryChild(2)->queryType()->getTypeCode() == type_pattern))
                                 parser->reportError(ERR_EXPECTED_RULE, $7, "Expected a rule as parameter to PARSE");
                             $$.setExpr(ds);
                             $$.setPosition($1);
@@ -8973,7 +8973,7 @@ simpleDataSet
                             HqlExprArray args;
                             args.append(*LINK(ds));
                             $6.unwindCommaList(args);
-                            IHqlExpression * onFail = queryProperty(onFailAtom, args);
+                            IHqlExpression * onFail = queryAttribute(onFailAtom, args);
                             if (onFail && !parser->checkTransformTypeMatch($4, ds, onFail->queryChild(0)))
                                 args.zap(*onFail);
                             $$.setExpr(createDataset(no_allnodes, args));
@@ -9555,7 +9555,7 @@ mode
                             $3.unwindCommaList(args);
 
                             //Create expression in a form that is backward compatible
-                            IHqlExpression * name = queryProperty(rowAtom, args);
+                            IHqlExpression * name = queryAttribute(rowAtom, args);
                             if (name)
                             {
                                 args.add(*LINK(name->queryChild(0)), 0);
@@ -10083,7 +10083,7 @@ JoinFlag
                             args.append(*$3.getExpr());
                             $4.unwindCommaList(args);
 
-                            IHqlExpression * onFail = queryProperty(onFailAtom, args);
+                            IHqlExpression * onFail = queryAttribute(onFailAtom, args);
                             if (onFail)
                             {
                                 onFail->Link();
@@ -11688,7 +11688,7 @@ pattern0
     | pattern0 '?'      {
                             parser->checkPattern($1, true);
                             IHqlExpression * pattern = $1.getExpr();
-                            if ((pattern->getOperator() == no_pat_repeat) && (!pattern->hasProperty(minimalAtom)))
+                            if ((pattern->getOperator() == no_pat_repeat) && (!pattern->hasAttribute(minimalAtom)))
                             {
                                 HqlExprArray args;
                                 unwindChildren(args, pattern);

ecl/hql/hqlgram2.cpp

@@ -845,7 +845,7 @@ IHqlExpression * HqlGram::processEmbedBody(const attribute & errpos, IHqlExpress
             moduleId = unnamedId;
         if (!getEmbedContextFunc)
             reportError(ERR_PluginNoScripting, errpos, "Module %s does not export getEmbedContext() function", moduleId->getAtomNamePtr());
-        bool isImport = queryPropertyInList(importAtom, attribs) != NULL;
+        bool isImport = queryAttributeInList(importAtom, attribs) != NULL;
         OwnedHqlExpr checkSupport = pluginScope->lookupSymbol(isImport ? supportsImportId : supportsScriptId, LSFpublic, lookupCtx);
         if (!matchesBoolean(checkSupport, true))
             reportError(ERR_PluginNoScripting, errpos, "Module %s does not support %s", moduleId->getAtomNamePtr(), isImport ? "import" : "script");
@@ -1059,7 +1059,7 @@ IHqlExpression * HqlGram::processModuleDefinition(const attribute & errpos)
 
     //Implements projects the module down to the implementation type.
     //It should also check the parameters match when a symbol is defined.
-    IHqlExpression * libraryInterface = newScope->queryProperty(libraryAtom);
+    IHqlExpression * libraryInterface = newScope->queryAttribute(libraryAtom);
     if (libraryInterface)
         newScope.setown(implementInterfaceFromModule(errpos, errpos, newScope, libraryInterface->queryChild(0), libraryInterface));
     return newScope.getClear();
@@ -1102,7 +1102,7 @@ void HqlGram::processServiceFunction(const attribute & idAttr, IIdAtom * name, I
     setParametered(true);
     IHqlExpression *attrs = createComma(LINK(thisAttrs), LINK(defaultServiceAttrs));
     attrs = checkServiceDef(serviceScope,name,attrs,idAttr);
-    bool oldSetFormat = queryPropertyInList(oldSetFormatAtom, attrs) != NULL;
+    bool oldSetFormat = queryAttributeInList(oldSetFormatAtom, attrs) != NULL;
     IHqlExpression *call = createExternalReference(name, LINK(type), attrs);
     IHqlExpression * formals = defineScopes.tos().createFormals(oldSetFormat);
     IHqlExpression * defaults = defineScopes.tos().createDefaults();
@@ -1981,7 +1981,7 @@ void HqlGram::doCheckAssignedNormalizeTransform(HqlExprArray * assigns, IHqlExpr
                         getFldName(selected,fldName);
 
                         //Not very nice - only ok in some situations....
-                        if (cur->hasProperty(virtualAtom))
+                        if (cur->hasAttribute(virtualAtom))
                         {
                             reportWarning(ERR_TRANS_NOVALUE4FIELD, errpos.pos, "Transform does not supply a value for field \"%s\"", fldName.str());
                             OwnedHqlExpr null = createNullExpr(cur);
@@ -2301,7 +2301,7 @@ void HqlGram::addField(const attribute &errpos, IIdAtom * name, ITypeInfo *_type
         }
     }
 
-    IHqlExpression * defaultAttr = queryPropertyInList(defaultAtom, attrs);
+    IHqlExpression * defaultAttr = queryAttributeInList(defaultAtom, attrs);
     if (defaultAttr)
     {
         IHqlExpression * defaultValue = defaultAttr->queryChild(0);
@@ -2348,7 +2348,7 @@ void HqlGram::addField(const attribute &errpos, IIdAtom * name, ITypeInfo *_type
         break;
     }
 
-    if (queryPropertyInList(virtualAtom, attrs) && !fieldType->isScalar())
+    if (queryAttributeInList(virtualAtom, attrs) && !fieldType->isScalar())
         reportError(ERR_BAD_FIELD_ATTR, errpos, "Virtual can only be specified on a scalar field");
 
     if (!name)
@@ -2391,7 +2391,7 @@ void HqlGram::addDatasetField(const attribute &errpos, IIdAtom * name, ITypeInfo
 
     if (fieldType)
     {
-        IHqlExpression * childAttrs = queryProperty(fieldType, _childAttr_Atom);
+        IHqlExpression * childAttrs = queryAttribute(fieldType, _childAttr_Atom);
         if (childAttrs)
             attrs = createComma(LINK(childAttrs->queryChild(0)), attrs);
     }
@@ -2418,7 +2418,7 @@ void HqlGram::addDatasetField(const attribute &errpos, IIdAtom * name, ITypeInfo
         checkRecordIsValid(errpos, queryRecord(dsType));
     }
 
-    if (queryPropertyInList(virtualAtom, attrs))
+    if (queryAttributeInList(virtualAtom, attrs))
         reportError(ERR_BAD_FIELD_ATTR, errpos, "Virtual can only be specified on a scalar field");
     if (!attrs)
         attrs = extractAttrsFromExpr(value);
@@ -2446,7 +2446,7 @@ void HqlGram::addDictionaryField(const attribute &errpos, IIdAtom * name, ITypeI
              value = NULL;
          }
     }
-    if (queryPropertyInList(virtualAtom, attrs))
+    if (queryAttributeInList(virtualAtom, attrs))
         reportError(ERR_BAD_FIELD_ATTR, errpos, "Virtual can only be specified on a scalar field");
     if (!attrs)
         attrs = extractAttrsFromExpr(value);
@@ -2736,7 +2736,7 @@ void HqlGram::processForwardModuleDefinition(const attribute & errpos)
         return;
 
     IHqlExpression * scopeExpr = queryExpression(scope);
-    if (scopeExpr->hasProperty(_virtualSeq_Atom))
+    if (scopeExpr->hasAttribute(_virtualSeq_Atom))
     {
         reportError(ERR_NO_FORWARD_VIRTUAL, errpos, "Cannot use FORWARD in combination with a VIRTUAL module ");
         return;
@@ -3009,7 +3009,7 @@ IHqlExpression * HqlGram::implementInterfaceFromModule(const attribute & modpos,
     {
         flags->unwindList(selectedFields, no_comma);
 
-        IHqlExpression * optionalAttr = queryProperty(optAtom, selectedFields);
+        IHqlExpression * optionalAttr = queryAttribute(optAtom, selectedFields);
         if (optionalAttr)
         {
             optional = true;
@@ -3017,7 +3017,7 @@ IHqlExpression * HqlGram::implementInterfaceFromModule(const attribute & modpos,
         }
     }
 
-    IHqlExpression * libraryAttr = queryProperty(libraryAtom, selectedFields);
+    IHqlExpression * libraryAttr = queryAttribute(libraryAtom, selectedFields);
     if (libraryAttr)
         selectedFields.zap(*libraryAttr);
 
@@ -3826,7 +3826,7 @@ void HqlGram::checkAggregateRecords(IHqlExpression * expr, IHqlExpression * reco
     if (containsIfBlock(record))
         reportError(ERR_NO_IFBLOCKS, errpos, "IFBLOCKS not supported in the aggregate target record");
 
-    IHqlExpression * mergeTransform = queryPropertyChild(expr, mergeTransformAtom, 0);
+    IHqlExpression * mergeTransform = queryAttributeChild(expr, mergeTransformAtom, 0);
     if (mergeTransform)
     {
         if (!recordTypesMatch(mergeTransform, expr))
@@ -3836,7 +3836,7 @@ void HqlGram::checkAggregateRecords(IHqlExpression * expr, IHqlExpression * reco
 
 void HqlGram::checkOnFailRecord(IHqlExpression * expr, attribute & errpos)
 {
-    IHqlExpression * onFail = expr->queryProperty(onFailAtom);
+    IHqlExpression * onFail = expr->queryAttribute(onFailAtom);
     if (onFail)
     {
         IHqlExpression * transform = onFail->queryChild(0);
@@ -4058,7 +4058,7 @@ IHqlExpression * HqlGram::createIndirectSelect(IHqlExpression * lhs, IHqlExpress
         return createNullExpr(rhs);
     }
 
-    if (record->hasProperty(abstractAtom) || (field->getOperator() != no_field))
+    if (record->hasAttribute(abstractAtom) || (field->getOperator() != no_field))
         return ::createSelectExpr(lhs, createValue(no_indirect, field->getType(), LINK(field)));
 
     OwnedHqlExpr match = record->querySimpleScope()->lookupSymbol(field->queryId());
@@ -4128,7 +4128,7 @@ IHqlExpression * HqlGram::createSortExpr(node_operator op, attribute & dsAttr, c
         return input;
     }
 
-    bool isLocal = (queryPropertyInList(localAtom, attrs)!=NULL);
+    bool isLocal = (queryAttributeInList(localAtom, attrs)!=NULL);
     checkDistribution(dsAttr, input, isLocal, false);
 
     if (joinedClause)
@@ -4872,7 +4872,7 @@ void HqlGram::warnIfFoldsToConstant(IHqlExpression * expr, const attribute & err
 void HqlGram::warnIfRecordPacked(IHqlExpression * expr, const attribute & errpos)
 {
     IHqlExpression * record = expr->queryRecord();
-    if (record && record->hasProperty(packedAtom))
+    if (record && record->hasAttribute(packedAtom))
         reportWarning(WRN_PACKED_MAY_CHANGE, errpos.pos, "Packed record used for external input or output, packed formats may change");
 }
 
@@ -5442,7 +5442,7 @@ void HqlGram::expandWholeAndExcept(IHqlExpression * dataset, attribute & a)
 
 void HqlGram::expandSortedAsList(HqlExprArray & args)
 {
-    LinkedHqlExpr sorted = queryProperty(sortedAtom, args);
+    LinkedHqlExpr sorted = queryAttribute(sortedAtom, args);
     if (!sorted)
         return;
 
@@ -5453,7 +5453,7 @@ void HqlGram::expandSortedAsList(HqlExprArray & args)
 
 IHqlExpression * HqlGram::createAssert(attribute & condAttr, attribute * msgAttr, attribute & flagsAttr)
 {
-    if (queryPropertyInList(constAtom, flagsAttr.queryExpr()))
+    if (queryAttributeInList(constAtom, flagsAttr.queryExpr()))
     {
         checkConstant(condAttr);
         if (msgAttr)
@@ -5866,7 +5866,7 @@ void HqlGram::checkFormals(IIdAtom * name, HqlExprArray& parms, HqlExprArray& de
     {
         IHqlExpression* parm = (IHqlExpression*)&parms.item(idx);
 
-        if (isMacro && !parm->hasProperty(noTypeAtom))
+        if (isMacro && !parm->hasAttribute(noTypeAtom))
             reportError(ERR_MACRO_NOPARAMTYPE, object, "Type is not allowed for macro: parameter %d of %s", idx+1, name->str());
 
         //
@@ -5888,10 +5888,10 @@ void HqlGram::addParameter(const attribute & errpos, IIdAtom * name, ITypeInfo*
 {
     HqlExprArray attrs;
     endList(attrs);
-    if (hasProperty(fieldsAtom, attrs))
+    if (hasAttribute(fieldsAtom, attrs))
     {
         type = makeSortListType(type);
-        if (!defValue && hasProperty(optAtom, attrs))
+        if (!defValue && hasAttribute(optAtom, attrs))
             defValue = createValue(no_sortlist, LINK(type));
     }
     addActiveParameterOwn(errpos, createParameter(name, nextParameterIndex(), type, attrs), defValue);
@@ -6094,7 +6094,7 @@ FunctionCallInfo::FunctionCallInfo(IHqlExpression * _funcdef)
         IHqlExpression * formals = queryFunctionParameters(funcdef);
         numFormals = formals->numChildren();
         //Don't allow implicit hidden parameters to be specified
-        while (numFormals && formals->queryChild(numFormals-1)->hasProperty(_hidden_Atom))
+        while (numFormals && formals->queryChild(numFormals-1)->hasAttribute(_hidden_Atom))
             numFormals--;
     }
 }
@@ -6118,7 +6118,7 @@ void FunctionCallInfo::flushPendingComponents()
     {
         IHqlExpression * formals = queryFunctionParameters(funcdef);
         IHqlExpression * formal = formals->queryChild(actuals.ordinality());
-        assertex(formal && formal->hasProperty(fieldsAtom));
+        assertex(formal && formal->hasAttribute(fieldsAtom));
         actuals.append(*createValue(no_sortlist, formal->getType(), pendingComponents));
         pendingComponents.kill();
     }
@@ -6243,11 +6243,11 @@ IHqlExpression * HqlGram::checkParameter(const attribute * errpos, IHqlExpressio
         break;
     }
 
-//  if (formal->hasProperty(constAtom) && funcdef && !isExternalFunction(funcdef))
-    if (errpos && formal->hasProperty(assertConstAtom))
+//  if (formal->hasAttribute(constAtom) && funcdef && !isExternalFunction(funcdef))
+    if (errpos && formal->hasAttribute(assertConstAtom))
         ret.setown(checkConstant(*errpos, ret));
 
-    if (formal->hasProperty(fieldAtom))
+    if (formal->hasAttribute(fieldAtom))
     {
         if (!isValidFieldReference(actual))
         {
@@ -6264,7 +6264,7 @@ IHqlExpression * HqlGram::checkParameter(const attribute * errpos, IHqlExpressio
                 reportError(ERR_EXPECTED, *errpos, "Expression expected for parameter %s.  Fields from records can only be passed to field references", formalName->str());
     }
 
-    if (formal->hasProperty(fieldsAtom))
+    if (formal->hasAttribute(fieldsAtom))
     {
         if (!isValidFieldReference(actual) && actualTC != type_sortlist)
         {
@@ -6353,10 +6353,10 @@ bool HqlGram::processParameter(FunctionCallInfo & call, IIdAtom * name, IHqlExpr
         while (targetActual < call.numFormals)
         {
             IHqlExpression * formal = formals->queryChild(targetActual);
-            if (!formal->hasProperty(optAtom))
+            if (!formal->hasAttribute(optAtom))
             {
                 //Non opt <?> may skip this argument if we have already had one that is compatible
-                if (!formal->hasProperty(fieldsAtom))
+                if (!formal->hasAttribute(fieldsAtom))
                     break;
                 if (call.pendingComponents.ordinality() == 0)
                     break;
@@ -6387,7 +6387,7 @@ bool HqlGram::processParameter(FunctionCallInfo & call, IIdAtom * name, IHqlExpr
     call.fillWithOmitted(targetActual);
 
     //Process <??>.  Append to a pending list as many actual parameters as we can that are compatible, and later create a no_sortlist in its place.
-    if (!name && formal->hasProperty(fieldsAtom) && (checked->queryType()->getTypeCode() != type_sortlist))
+    if (!name && formal->hasAttribute(fieldsAtom) && (checked->queryType()->getTypeCode() != type_sortlist))
     {
         call.pendingComponents.append(*LINK(checked));
         return true;
@@ -6446,7 +6446,7 @@ void HqlGram::addActiveParameterOwn(const attribute & errpos, IHqlExpression * p
     activeScope.activeParameters.append(*param);
     activeScope.activeDefaults.append(*ensureNormalizedDefaultValue(defaultValue));
 
-    if (defaultValue && !param->hasProperty(noTypeAtom))
+    if (defaultValue && !param->hasAttribute(noTypeAtom))
     {
         OwnedHqlExpr newActual = checkParameter(&errpos, defaultValue, param, true, NULL);
     }
@@ -6481,7 +6481,7 @@ void HqlGram::checkBuildIndexFilenameFlags(IHqlExpression * dataset, attribute &
 
 IHqlExpression * HqlGram::createBuildFileFromTable(IHqlExpression * table, attribute & flagsAttr, IHqlExpression * filename, attribute & errpos)
 {
-    IHqlExpression * originAttr = table->queryProperty(_origin_Atom);
+    IHqlExpression * originAttr = table->queryAttribute(_origin_Atom);
     IHqlExpression * ds = originAttr->queryChild(0);
     IHqlExpression * mode = table->queryChild(2);
     OwnedHqlExpr flags=flagsAttr.getExpr();
@@ -6532,7 +6532,7 @@ IHqlExpression * HqlGram::createBuildIndexFromIndex(attribute & indexAttr, attri
 
     if (!isKey(index))
     {
-        if (index->getOperator() == no_table && index->hasProperty(_origin_Atom))
+        if (index->getOperator() == no_table && index->hasAttribute(_origin_Atom))
             return createBuildFileFromTable(index, flagsAttr, filename, errpos);
         flagsAttr.release();
         reportError(ERR_EXPECTED_INDEX,indexAttr,"Expected an index as the first parameter");
@@ -6622,7 +6622,7 @@ IHqlExpression * HqlGram::createBuildIndexFromIndex(attribute & indexAttr, attri
             }
         }
     }
-    IHqlExpression * payload = index->queryProperty(_payload_Atom);
+    IHqlExpression * payload = index->queryAttribute(_payload_Atom);
     if (payload)
         args.append(*LINK(payload));
     if (distribution)
@@ -6755,7 +6755,7 @@ void HqlGram::processUpdateAttr(attribute & attr)
     HqlExprArray args;
     unwindChildren(args, expr);
 
-    if (expr->queryProperty(updateAtom))
+    if (expr->queryAttribute(updateAtom))
     {
         removeProperty(args, updateAtom);
         args.append(*createAttribute(updateAtom, createConstant((__int64)getExpressionCRC(expr))));
@@ -7149,7 +7149,7 @@ static void unwindExtraFields(HqlExprArray & fields, IHqlExpression * expr)
         case no_attr:
         case no_attr_link:
         case no_attr_expr:
-            if (!queryProperty(cur->queryName(), fields))
+            if (!queryAttribute(cur->queryName(), fields))
                 fields.append(*LINK(cur));
             break;
         case no_record:
@@ -7280,7 +7280,7 @@ public:
         case no_cluster:
             return LINK(expr);
         case no_globalscope:
-            if (!expr->hasProperty(optAtom))
+            if (!expr->hasAttribute(optAtom))
                 return LINK(expr);
             break;
         case NO_AGGREGATE:
@@ -7584,7 +7584,7 @@ void HqlGram::checkDistribution(attribute &errpos, IHqlExpression *input, bool l
 
 void HqlGram::checkDistribution(attribute &errpos, IHqlExpression * newExpr, bool ignoreGrouping)
 {
-    checkDistribution(errpos, newExpr->queryChild(0), newExpr->hasProperty(localAtom), ignoreGrouping);
+    checkDistribution(errpos, newExpr->queryChild(0), newExpr->hasAttribute(localAtom), ignoreGrouping);
 }
 
 bool HqlGram::isDiskFile(IHqlExpression * expr)
@@ -7594,7 +7594,7 @@ bool HqlGram::isDiskFile(IHqlExpression * expr)
     case no_table:
         return true;
     case no_cluster:
-        return !expr->hasProperty(fewAtom);
+        return !expr->hasAttribute(fewAtom);
     case no_colon:
         {
             ForEachChild(i, expr)
@@ -7627,19 +7627,19 @@ bool HqlGram::isFilteredDiskFile(IHqlExpression * expr)
 
 void HqlGram::checkJoinFlags(const attribute &err, IHqlExpression * join)
 {
-    bool lonly = join->hasProperty(leftonlyAtom);
-    bool ronly = join->hasProperty(rightonlyAtom);
-    bool fonly = join->hasProperty(fullonlyAtom);
-    bool lo = join->hasProperty(leftouterAtom) || lonly;
-    bool ro = join->hasProperty(rightouterAtom) || ronly;
-    bool fo = join->hasProperty(fullouterAtom) || fonly;
-    bool keep = join->hasProperty(keepAtom);
-    IHqlExpression * rowLimit = join->queryProperty(rowLimitAtom);
+    bool lonly = join->hasAttribute(leftonlyAtom);
+    bool ronly = join->hasAttribute(rightonlyAtom);
+    bool fonly = join->hasAttribute(fullonlyAtom);
+    bool lo = join->hasAttribute(leftouterAtom) || lonly;
+    bool ro = join->hasAttribute(rightouterAtom) || ronly;
+    bool fo = join->hasAttribute(fullouterAtom) || fonly;
+    bool keep = join->hasAttribute(keepAtom);
+    IHqlExpression * rowLimit = join->queryAttribute(rowLimitAtom);
 
-    IHqlExpression * keyed = join->queryProperty(keyedAtom);
+    IHqlExpression * keyed = join->queryAttribute(keyedAtom);
     if (keyed)
     {
-        if (join->hasProperty(allAtom) || join->hasProperty(lookupAtom))
+        if (join->hasAttribute(allAtom) || join->hasAttribute(lookupAtom))
             reportError(ERR_KEYEDINDEXINVALID, err, "LOOKUP/ALL not compatible with KEYED");
 
         IHqlExpression * index = keyed->queryChild(0);
@@ -7685,16 +7685,16 @@ void HqlGram::checkJoinFlags(const attribute &err, IHqlExpression * join)
             }
         }
     }
-    if (join->hasProperty(lookupAtom))
+    if (join->hasAttribute(lookupAtom))
     {
-        bool isMany = join->hasProperty(manyAtom);
+        bool isMany = join->hasAttribute(manyAtom);
         if (ro || fo)
             reportError(ERR_BADKIND_LOOKUPJOIN, err, "JOIN(LOOKUP) only supports INNER, LEFT OUTER, and LEFT ONLY joins");
-        if (join->hasProperty(partitionRightAtom))
+        if (join->hasAttribute(partitionRightAtom))
             reportError(ERR_BADKIND_LOOKUPJOIN, err, "Lookup joins do not support PARTITION RIGHT");
         if (keep && !isMany)
             reportError(ERR_BADKIND_LOOKUPJOIN, err, "Lookup joins do not support KEEP");
-        if (join->hasProperty(atmostAtom) && !isMany)
+        if (join->hasAttribute(atmostAtom) && !isMany)
             reportError(ERR_BADKIND_LOOKUPJOIN, err, "Lookup joins do not support ATMOST");
         if (rowLimit && !isMany)
             reportError(ERR_BADKIND_LOOKUPJOIN, err, "Lookup joins do not support LIMIT (they can only match 1 entry)");
@@ -7705,21 +7705,21 @@ void HqlGram::checkJoinFlags(const attribute &err, IHqlExpression * join)
     {
         if (ro || fo)
             reportError(ERR_INVALIDKEYEDJOIN, err, "Keyed joins only support LEFT OUTER/ONLY");
-        if (join->hasProperty(partitionRightAtom))
+        if (join->hasAttribute(partitionRightAtom))
             reportError(ERR_INVALIDKEYEDJOIN, err, "Keyed joins do not support PARTITION RIGHT");
     }
-    if (join->hasProperty(allAtom))
+    if (join->hasAttribute(allAtom))
     {
-        if (join->hasProperty(partitionRightAtom))
+        if (join->hasAttribute(partitionRightAtom))
             reportError(ERR_INVALIDALLJOIN, err, "JOIN(,ALL) does not support PARTITION RIGHT");
         if (ro || fo)
             reportError(ERR_INVALIDALLJOIN, err, "JOIN(ALL) only supports INNER, LEFT OUTER, and LEFT ONLY joins");
-        if (join->hasProperty(atmostAtom))
+        if (join->hasAttribute(atmostAtom))
             reportError(ERR_INVALIDALLJOIN, err, "JOIN(ALL) does not support ATMOST");
         if (rowLimit)
             reportError(ERR_INVALIDALLJOIN, err, "JOIN(ALL) does not support LIMIT");
     }
-    if (join->hasProperty(atmostAtom))
+    if (join->hasAttribute(atmostAtom))
     {
         if (fo || ro)
             reportError(ERR_BAD_JOINFLAG, err, "ATMOST cannot be used with FULL or RIGHT ONLY/OUTER");
@@ -7736,7 +7736,7 @@ void HqlGram::checkJoinFlags(const attribute &err, IHqlExpression * join)
     {
         if (rowLimit)
             reportError(ERR_BAD_JOINFLAG, err, "LIMIT cannot be used in combination ONLY");
-        if (join->hasProperty(onFailAtom))
+        if (join->hasAttribute(onFailAtom))
             reportError(ERR_BAD_JOINFLAG, err, "ONFAIL cannot be used in combination ONLY");
     }
 
@@ -7754,7 +7754,7 @@ void HqlGram::checkJoinFlags(const attribute &err, IHqlExpression * join)
 
 void HqlGram::checkLoopFlags(const attribute &err, IHqlExpression * loopExpr)
 {
-    if (loopExpr->hasProperty(parallelAtom))
+    if (loopExpr->hasAttribute(parallelAtom))
     {
         unsigned base = (loopExpr->getOperator() == no_loop ? 1 : 2);
         if (!queryRealChild(loopExpr, base))
@@ -7948,7 +7948,7 @@ void HqlGram::extractIndexRecordAndExtra(SharedHqlExpr & record, SharedHqlExpr &
         extra.setown(createComma(LINK(record->queryChild(1)), extra.getClear()));
         record.set(record->queryChild(0));
     }
-    IHqlExpression *payload = record->queryProperty(_payload_Atom);
+    IHqlExpression *payload = record->queryAttribute(_payload_Atom);
     if (payload)
     {
         extra.setown(createComma(extra.getClear(), LINK(payload)));
@@ -8063,7 +8063,7 @@ void HqlGram::checkDedup(IHqlExpression *ds, IHqlExpression *flags, attribute &a
 void HqlGram::checkDistributer(attribute & err, HqlExprArray & args)
 {
     IHqlExpression * input = &args.item(0);
-    IHqlExpression * inputPayload = queryProperty(_payload_Atom, args);
+    IHqlExpression * inputPayload = queryAttribute(_payload_Atom, args);
     ForEachItemIn(idx, args)
     {
         IHqlExpression & cur = args.item(idx);
@@ -8118,7 +8118,7 @@ void HqlGram::checkValidCsvRecord(const attribute & errpos, IHqlExpression * rec
 
 void HqlGram::checkValidPipeRecord(const attribute & errpos, IHqlExpression * record, IHqlExpression * attrs, IHqlExpression * expr)
 {
-    if (queryPropertyInList(csvAtom, attrs) || (expr && expr->hasProperty(csvAtom)))
+    if (queryAttributeInList(csvAtom, attrs) || (expr && expr->hasAttribute(csvAtom)))
         checkValidCsvRecord(errpos, record);
 }
 
@@ -8652,7 +8652,7 @@ bool HqlGram::isVirtualFunction(DefineIdSt * defineid, const attribute & errpos)
         if (scope)
         {
             IHqlExpression * scopeExpr = scope->queryExpression();
-            if (scopeExpr->hasProperty(interfaceAtom) || scopeExpr->hasProperty(virtualAtom))
+            if (scopeExpr->hasAttribute(interfaceAtom) || scopeExpr->hasAttribute(virtualAtom))
                 return true;
         }
     }
@@ -9040,7 +9040,7 @@ void HqlGram::defineSymbolProduction(attribute & nameattr, attribute & paramattr
 
     case no_virtualscope:
         {
-            IHqlExpression * libraryInterface = queryPropertyChild(base, libraryAtom, 0);
+            IHqlExpression * libraryInterface = queryAttributeChild(base, libraryAtom, 0);
             if (libraryInterface)
             {
                 //check the parameters for this symbol match the parameters on the library attribute
@@ -9064,7 +9064,7 @@ void HqlGram::defineSymbolProduction(attribute & nameattr, attribute & paramattr
         OwnedHqlExpr anyMatch = localScope->lookupSymbol(name, LSFsharedOK, lookupCtx);
         OwnedHqlExpr localMatch  = localScope->lookupSymbol(name, LSFsharedOK|LSFignoreBase, lookupCtx);
 
-        if (localScopeExpr->hasProperty(virtualAtom) || localScopeExpr->hasProperty(interfaceAtom))
+        if (localScopeExpr->hasAttribute(virtualAtom) || localScopeExpr->hasAttribute(interfaceAtom))
         {
             if (canBeVirtual(expr))
                 defineid->scope |= VIRTUAL_FLAG;
@@ -9079,7 +9079,7 @@ void HqlGram::defineSymbolProduction(attribute & nameattr, attribute & paramattr
                     reportError(ERR_SHOULD_BE_EXPORTED, nameattr, "Private symbol %s clashes with public symbol in base module", name->str());
             }
 
-            if (localScopeExpr->hasProperty(interfaceAtom))
+            if (localScopeExpr->hasAttribute(interfaceAtom))
             {
 //              defineid->scope |= EXPORT_FLAG;
                 reportError(ERR_SHOULD_BE_EXPORTED, nameattr, "Symbol %s in INTERFACE should be EXPORTed or SHARED", name->str());
@@ -9087,7 +9087,7 @@ void HqlGram::defineSymbolProduction(attribute & nameattr, attribute & paramattr
         }
         else
         {
-            if (anyMatch && !localScopeExpr->hasProperty(_virtualSeq_Atom))
+            if (anyMatch && !localScopeExpr->hasAttribute(_virtualSeq_Atom))
             {
                 //Not quite right - it is a problem if the place it is defined in isn't virtual
                 reportError(ERR_CANNOT_REDEFINE, nameattr, "Cannot redefine definition %s from a non-virtual MODULE", name->str());
@@ -9371,14 +9371,14 @@ void HqlGram::cloneInheritedAttributes(IHqlScope * scope, const attribute & errp
 {
     IHqlExpression * scopeExpr = queryExpression(scope);
     AtomArray inherited;
-    IHqlExpression * virtualSeqAttr = scopeExpr->queryProperty(_virtualSeq_Atom);
+    IHqlExpression * virtualSeqAttr = scopeExpr->queryAttribute(_virtualSeq_Atom);
     ForEachChild(i, scopeExpr)
     {
         IHqlExpression * cur = scopeExpr->queryChild(i);
         IHqlScope * curBase = cur->queryScope();
         if (curBase)
         {
-            IHqlExpression * baseVirtualAttr = cur->queryProperty(_virtualSeq_Atom);
+            IHqlExpression * baseVirtualAttr = cur->queryAttribute(_virtualSeq_Atom);
             bool baseIsLibrary = cur->getOperator() == no_libraryscopeinstance;
 
             //Find all the symbols exported by this base module
@@ -9535,14 +9535,14 @@ IHqlExpression * HqlGram::createLibraryInstance(const attribute & errpos, IHqlEx
         }
     }
 
-    if (body->hasProperty(libraryAtom))
+    if (body->hasAttribute(libraryAtom))
         reportWarning(WRN_NOT_INTERFACE, errpos.pos, "LIBRARY() seems to reference an implementation rather than the interface definition");
-    IHqlExpression * internalAttr = queryPropertyInList(internalAtom,name);
+    IHqlExpression * internalAttr = queryAttributeInList(internalAtom,name);
     if (internalAttr)
     {
         IHqlExpression * internalFunc = internalAttr->queryChild(0);
         IHqlExpression * internalModule = internalFunc->queryChild(0);
-        IHqlExpression * libraryAttr = internalModule->queryProperty(libraryAtom);
+        IHqlExpression * libraryAttr = internalModule->queryAttribute(libraryAtom);
         if (!libraryAttr || func != libraryAttr->queryChild(0))
             reportError(ERR_PROTOTYPE_MISMATCH, errpos, "Module referenced in INTERNAL() doesn't implement the required library interface");
     }
@@ -9638,7 +9638,7 @@ IHqlExpression * HqlGram::createEvaluateOutputModule(const attribute & errpos, I
 
 IHqlExpression * HqlGram::createStoredModule(const attribute & errpos, IHqlExpression * scopeExpr)
 {
-    if (!scopeExpr->queryProperty(_virtualSeq_Atom))
+    if (!scopeExpr->queryAttribute(_virtualSeq_Atom))
         reportError(ERR_NOT_INTERFACE, errpos, "Argument must be an interface or virtual module");
     return ::createStoredModule(scopeExpr);
 }
@@ -10861,7 +10861,7 @@ static void expandDefJoinAttrs(IHqlExpression * newRec, IHqlExpression * record)
         case no_attr:
         case no_attr_link:
         case no_attr_expr:
-            if (!newRec->hasProperty(cur->queryName()))
+            if (!newRec->hasAttribute(cur->queryName()))
                 newRec->addOperand(LINK(cur));
             break;
         }
@@ -10995,7 +10995,7 @@ IHqlExpression* HqlGram::createDefJoinTransform(IHqlExpression* left,IHqlExpress
     OwnedHqlExpr leftSelect = createSelector(no_left, left, seq);
     OwnedHqlExpr rightSelect = createSelector(no_right, right, seq);
 
-    if (queryPropertyInList(fullouterAtom, flags) || queryPropertyInList(fullonlyAtom, flags))
+    if (queryAttributeInList(fullouterAtom, flags) || queryAttributeInList(fullonlyAtom, flags))
     {
         ForEachItemIn(i, commonFields)
         {
@@ -11004,7 +11004,7 @@ IHqlExpression* HqlGram::createDefJoinTransform(IHqlExpression* left,IHqlExpress
         }
     }
 
-    if (queryPropertyInList(rightouterAtom, flags) || queryPropertyInList(rightonlyAtom, flags))
+    if (queryAttributeInList(rightouterAtom, flags) || queryAttributeInList(rightonlyAtom, flags))
     {
         addAssignall(LINK(self), LINK(rightSelect), errpos);
         addAssignall(LINK(self), LINK(leftSelect), errpos);

ecl/hql/hqllex.l

@@ -211,7 +211,7 @@ int HqlLex::lookupIdentifierToken(YYSTYPE & returnToken, HqlLex * lexer, bool lo
         }
     }
 
-    if (((op == no_param) && expr->hasProperty(fieldAtom)) || (op == no_indirect))
+    if (((op == no_param) && expr->hasAttribute(fieldAtom)) || (op == no_indirect))
     {
         switch (token)
         {

ecl/hql/hqlmeta.cpp

@@ -1111,7 +1111,7 @@ static bool includesFieldsOutsideGrouping(IHqlExpression * distribution, const H
     case no_constant:
         return false;
     case no_trim:
-        if (distribution->hasProperty(leftAtom) || distribution->hasProperty(allAtom))
+        if (distribution->hasAttribute(leftAtom) || distribution->hasAttribute(allAtom))
             return false;
         return includesFieldsOutsideGrouping(distribution->queryChild(0), groups);
     case no_attr:
@@ -1341,7 +1341,7 @@ IHqlExpression * convertSubSortToGroupedSort(IHqlExpression * expr)
     IHqlExpression * newOrder = expr->queryChild(1);
     IHqlExpression * grouping = expr->queryChild(2);
 
-    assertex(!isGrouped(dataset) || expr->hasProperty(globalAtom));
+    assertex(!isGrouped(dataset) || expr->hasAttribute(globalAtom));
     OwnedHqlExpr attr = isLocalActivity(expr) ? createLocalAttribute() : NULL;
     OwnedHqlExpr grouped = createDatasetF(no_group, LINK(dataset), LINK(grouping), LINK(attr), NULL);
 

ecl/hql/hqlopt.cpp

@@ -309,7 +309,7 @@ IHqlExpression * CTreeOptimizer::swapIntoIf(IHqlExpression * expr, bool force)
 {
     IHqlExpression * child = expr->queryChild(0);
     //Can't optimize over a condition once a graph has been resourced, otherwise the activities aren't found.
-    if (child->hasProperty(_resourced_Atom))
+    if (child->hasAttribute(_resourced_Atom))
         return LINK(expr);
 
     IHqlExpression * body = expr->queryBody();
@@ -497,7 +497,7 @@ IHqlExpression * CTreeOptimizer::optimizeAggregateUnsharedDataset(IHqlExpression
     case no_keyedlimit:
         break;
     case no_limit:
-        if (expr->hasProperty(onFailAtom))
+        if (expr->hasAttribute(onFailAtom))
             return LINK(expr);
         //fall through
     case no_choosen:
@@ -533,7 +533,7 @@ IHqlExpression * CTreeOptimizer::optimizeAggregateUnsharedDataset(IHqlExpression
     case no_newusertable:
         if (isSimpleCount && (options & HOOinsidecompound))
         {
-            if (expr->hasProperty(_countProject_Atom) || expr->hasProperty(prefetchAtom))
+            if (expr->hasAttribute(_countProject_Atom) || expr->hasAttribute(prefetchAtom))
                 break;
             if (isPureActivity(expr) && !isAggregateDataset(expr))
             {
@@ -573,14 +573,14 @@ IHqlExpression * CTreeOptimizer::optimizeAggregateDataset(IHqlExpression * trans
         {
         case no_hqlproject:
         case no_newusertable:
-            if (ds->hasProperty(prefetchAtom))
+            if (ds->hasAttribute(prefetchAtom))
                 break;
 
             //MORE: If the record is empty then either remove the project if no SKIP, or convert the SKIP to a filter
 
             //Don't remove projects for the moment because they can make counts of disk reads much less
             //efficient.  Delete the following lines once we have a count-diskread activity
-            if (!isScalarAggregate && !(options & (HOOcompoundproject|HOOinsidecompound)) && !ds->hasProperty(_countProject_Atom) )
+            if (!isScalarAggregate && !(options & (HOOcompoundproject|HOOinsidecompound)) && !ds->hasAttribute(_countProject_Atom) )
                 break;
             if (isPureActivity(ds) && !isAggregateDataset(ds))
             {
@@ -947,7 +947,7 @@ IHqlExpression * CTreeOptimizer::hoistFilterOverProject(IHqlExpression * transfo
     //Should be able to move filters over count projects, as long as not filtering on the count fields.  
     //Would need to add a containsCounter() test in the expandFields code - cannot just test filterExpr
     //because counter may be there (e.g., countindex3.hql)
-    if (child->hasProperty(_countProject_Atom) || child->hasProperty(prefetchAtom) || isAggregateDataset(child))
+    if (child->hasAttribute(_countProject_Atom) || child->hasAttribute(prefetchAtom) || isAggregateDataset(child))
         return NULL;
     if (hasUnknownTransform(child))
         return NULL;
@@ -1307,7 +1307,7 @@ IHqlExpression * CTreeOptimizer::optimizeJoinCondition(IHqlExpression * expr)
 {
     //Look at the join condition and move any conditions just on left/right further up the tree
     //can help after other constant folding....
-    if (!isSimpleInnerJoin(expr) || expr->hasProperty(keyedAtom) || expr->hasProperty(atmostAtom))
+    if (!isSimpleInnerJoin(expr) || expr->hasAttribute(keyedAtom) || expr->hasAttribute(atmostAtom))
         return NULL;
 
     IHqlExpression * cond = expr->queryChild(2);
@@ -1345,7 +1345,7 @@ IHqlExpression * CTreeOptimizer::optimizeJoinCondition(IHqlExpression * expr)
     if (!newCond)
         newCond.setown(createConstant(true));
 
-    if (!queryProperty(_conditionFolded_Atom, args))
+    if (!queryAttribute(_conditionFolded_Atom, args))
         args.append(*createAttribute(_conditionFolded_Atom));
     args.replace(*newCond.getClear(), 2);
     return expr->clone(args);
@@ -1359,7 +1359,7 @@ IHqlExpression * CTreeOptimizer::optimizeDistributeDedup(IHqlExpression * expr)
 {
     IHqlExpression * child = expr->queryChild(0);
 
-    if (!child->hasProperty(allAtom) || child->hasProperty(localAtom) || isGrouped(child))
+    if (!child->hasAttribute(allAtom) || child->hasAttribute(localAtom) || isGrouped(child))
         return NULL;
 
     DedupInfoExtractor info(child);
@@ -1374,7 +1374,7 @@ IHqlExpression * CTreeOptimizer::optimizeDistributeDedup(IHqlExpression * expr)
     
     
     OwnedHqlExpr distn;
-    if (expr->hasProperty(manyAtom))
+    if (expr->hasAttribute(manyAtom))
     {
         //DEDUP(DISTRIBUTE(DEDUP(ds, x, y, all, local), hash(trim(x))), x, y, all, LOCAL)
 
@@ -1411,7 +1411,7 @@ IHqlExpression * CTreeOptimizer::optimizeProjectInlineTable(IHqlExpression * tra
     IHqlExpression * child = transformed->queryChild(0);
     IHqlExpression * values = child->queryChild(0);
     //MORE If trivial projection then might be worth merging with multiple items, but unlikely to occur in practice
-    if (!isPureInlineDataset(child) || transformed->hasProperty(prefetchAtom))
+    if (!isPureInlineDataset(child) || transformed->hasAttribute(prefetchAtom))
         return NULL;
 
     bool onlyFoldConstant = false;
@@ -1434,7 +1434,7 @@ IHqlExpression * CTreeOptimizer::optimizeProjectInlineTable(IHqlExpression * tra
     }
 
 
-    IHqlExpression * transformedCountProject = transformed->queryProperty(_countProject_Atom);
+    IHqlExpression * transformedCountProject = transformed->queryAttribute(_countProject_Atom);
     IHqlExpression * seq = querySelSeq(transformed);
     node_operator projectOp = transformed->getOperator();
     OwnedHqlExpr oldSelector = (projectOp == no_hqlproject) ? createSelector(no_left, child, seq) : LINK(child->queryNormalizedSelector());
@@ -1568,7 +1568,7 @@ IHqlExpression * CTreeOptimizer::expandProjectedDataset(IHqlExpression * child,
     OwnedMapper mapper = getMapper(child);
     ExpandSelectorMonitor monitor(*this);
     OwnedHqlExpr expandedTransform = expandFields(mapper, transform, childSelector, NULL, &monitor);
-    IHqlExpression * onFail = child->queryProperty(onFailAtom);
+    IHqlExpression * onFail = child->queryAttribute(onFailAtom);
     OwnedHqlExpr newOnFail;
     if (onFail)
     {
@@ -1715,7 +1715,7 @@ bool CTreeOptimizer::childrenAreShared(IHqlExpression * expr)
 
 bool CTreeOptimizer::isWorthMovingProjectOverLimit(IHqlExpression * project)
 {
-    if (noHoistAttr && project->queryProperty(_noHoist_Atom) == noHoistAttr)
+    if (noHoistAttr && project->queryAttribute(_noHoist_Atom) == noHoistAttr)
         return false;
 
     IHqlExpression * expr = project->queryChild(0);
@@ -1754,7 +1754,7 @@ bool CTreeOptimizer::isWorthMovingProjectOverLimit(IHqlExpression * project)
                 return false;
             //fallthrough.
         case no_hqlproject:
-            if (!isPureActivity(expr) || expr->hasProperty(_countProject_Atom) || expr->hasProperty(prefetchAtom))
+            if (!isPureActivity(expr) || expr->hasAttribute(_countProject_Atom) || expr->hasAttribute(prefetchAtom))
                 return false;
             return true;
         default:
@@ -2139,13 +2139,13 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
         break;
     case no_hqlproject:
         {
-            IHqlExpression * counterAttr = transformed->queryProperty(_countProject_Atom);
+            IHqlExpression * counterAttr = transformed->queryAttribute(_countProject_Atom);
             if (counterAttr && !transformContainsCounter(transformed->queryChild(1), counterAttr->queryChild(0)))
                 return removeProperty(transformed, _countProject_Atom);
             //fallthrough
         }
     case no_newusertable:
-        if (transformed->hasProperty(keyedAtom))
+        if (transformed->hasAttribute(keyedAtom))
         {
             IHqlExpression * ret = queryMoveKeyedExpr(transformed);
             if (ret)
@@ -2195,7 +2195,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
     case no_newaggregate:
         {
             node_operator childOp = child->getOperator();
-            if (transformed->hasProperty(keyedAtom))
+            if (transformed->hasAttribute(keyedAtom))
             {
                 IHqlExpression * moved = NULL;
                 switch(childOp)
@@ -2307,7 +2307,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
         }
     case no_select:
         {
-            if (transformed->hasProperty(newAtom))
+            if (transformed->hasAttribute(newAtom))
             {
                 node_operator childOp = child->getOperator();
                 switch (childOp)
@@ -2427,7 +2427,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
     case no_keyeddistribute:
     case no_distribute:
         {
-            if (transformed->hasProperty(skewAtom))
+            if (transformed->hasAttribute(skewAtom))
                 break;
             //If distribution matches existing and grouped then don't distribute, but still remove grouping.
             IHqlExpression * distn = queryDistribution(transformed);
@@ -2595,7 +2595,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                     if (isPureActivity(child) && !isAggregateDataset(child))
                     {
                         //Don't move a choosen with a start value over a count project - we could if we also adjust the counter
-                        if (!child->queryProperty(_countProject_Atom) || !queryRealChild(transformed, 2))
+                        if (!child->queryAttribute(_countProject_Atom) || !queryRealChild(transformed, 2))
                             return forceSwapNodeWithChild(transformed);
                     }
                     break;
@@ -2633,7 +2633,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
             case no_hqlproject:
             case no_newusertable:
                 {
-                    if (isPureActivity(child) && !isAggregateDataset(child) && !transformed->hasProperty(onFailAtom))
+                    if (isPureActivity(child) && !isAggregateDataset(child) && !transformed->hasAttribute(onFailAtom))
                         return forceSwapNodeWithChild(transformed);
                     break;
                 }
@@ -2651,9 +2651,9 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
             case no_limit:
                 {
                     //Could be cleverer... but this is safer
-                    if (transformed->queryProperty(skipAtom) != child->queryProperty(skipAtom))
+                    if (transformed->queryAttribute(skipAtom) != child->queryAttribute(skipAtom))
                         break;
-                    if (transformed->queryProperty(onFailAtom) != child->queryProperty(onFailAtom))
+                    if (transformed->queryAttribute(onFailAtom) != child->queryAttribute(onFailAtom))
                         break;
                     OwnedHqlExpr parentLimit = foldHqlExpression(transformed->queryChild(1));
                     OwnedHqlExpr childLimit = foldHqlExpression(child->queryChild(1));
@@ -2673,7 +2673,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
             case no_compound_diskread:
                 if (!isLimitedDataset(child))
                 {
-                    if (transformed->hasProperty(skipAtom) || transformed->hasProperty(onFailAtom))
+                    if (transformed->hasAttribute(skipAtom) || transformed->hasAttribute(onFailAtom))
                     {
                         //only merge if roxie
                     }
@@ -2786,7 +2786,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                     OwnedHqlExpr ret = swapNodeWithChild(transformed);
 
                     //Need to add the filter as a skip on the onFail() transform
-                    IHqlExpression * onFail = ret->queryProperty(onFailAtom);
+                    IHqlExpression * onFail = ret->queryAttribute(onFailAtom);
                     if (!onFail)
                         return ret.getClear();
 
@@ -2843,12 +2843,12 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
 #endif
                 break;
             case no_selfjoin:
-                if (isPureActivity(child) && !hasUnknownTransform(child) && !isLimitedJoin(child) && !child->hasProperty(fullouterAtom) && !child->hasProperty(fullonlyAtom))
+                if (isPureActivity(child) && !hasUnknownTransform(child) && !isLimitedJoin(child) && !child->hasAttribute(fullouterAtom) && !child->hasAttribute(fullonlyAtom))
                 {
                     //Strictly speaking, we could hoist conditions that can be hoisted for left only (or even full) joins etc. if the fields that are filtered
                     //are based on equalities in the join condition.  However, that can wait....  (same for join below...)
-                    bool canHoistLeft = !child->hasProperty(rightouterAtom) && !child->hasProperty(rightonlyAtom) &&
-                                        !child->hasProperty(leftouterAtom) && !child->hasProperty(leftonlyAtom);
+                    bool canHoistLeft = !child->hasAttribute(rightouterAtom) && !child->hasAttribute(rightonlyAtom) &&
+                                        !child->hasAttribute(leftouterAtom) && !child->hasAttribute(leftonlyAtom);
                     bool canMergeLeft = isInnerJoin(child);
                     bool canHoistRight = false;
                     bool canMergeRight = canMergeLeft;
@@ -2859,11 +2859,11 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                 }
                 break;
             case no_join:
-                if (isPureActivity(child) && !hasUnknownTransform(child) && !isLimitedJoin(child) && !child->hasProperty(fullouterAtom) && !child->hasProperty(fullonlyAtom))
+                if (isPureActivity(child) && !hasUnknownTransform(child) && !isLimitedJoin(child) && !child->hasAttribute(fullouterAtom) && !child->hasAttribute(fullonlyAtom))
                 {
-                    bool canHoistLeft = !child->hasProperty(rightouterAtom) && !child->hasProperty(rightonlyAtom);
+                    bool canHoistLeft = !child->hasAttribute(rightouterAtom) && !child->hasAttribute(rightonlyAtom);
                     bool canMergeLeft = isInnerJoin(child);
-                    bool canHoistRight = !child->hasProperty(leftouterAtom) && !child->hasProperty(leftonlyAtom) && !isKeyedJoin(child);
+                    bool canHoistRight = !child->hasAttribute(leftouterAtom) && !child->hasAttribute(leftonlyAtom) && !isKeyedJoin(child);
                     bool canMergeRight = canMergeLeft;
 
                     IHqlExpression * ret = getHoistedFilter(transformed, canHoistLeft, canMergeLeft, canHoistRight, canMergeRight, 2);
@@ -2968,10 +2968,10 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
     case no_hqlproject:
         {
             node_operator childOp = child->getOperator();
-            IHqlExpression * transformedCountProject = transformed->queryProperty(_countProject_Atom);
-            if (transformed->hasProperty(prefetchAtom))
+            IHqlExpression * transformedCountProject = transformed->queryAttribute(_countProject_Atom);
+            if (transformed->hasAttribute(prefetchAtom))
                 break;      // play safe
-            IHqlExpression * transformKeyed = transformed->queryProperty(keyedAtom);
+            IHqlExpression * transformKeyed = transformed->queryAttribute(keyedAtom);
             IHqlExpression * transform = transformed->queryChild(1);
             switch(childOp)
             {
@@ -2992,11 +2992,11 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                     if (!isPureActivityIgnoringSkip(child) || hasUnknownTransform(child))
                         break;
 
-                    IHqlExpression * childCountProject = child->queryProperty(_countProject_Atom);
+                    IHqlExpression * childCountProject = child->queryAttribute(_countProject_Atom);
                     //Don't merge two count projects - unless we go through and replace counter instances.
                     if (transformedCountProject && childCountProject)
                         break;
-                    IHqlExpression * childKeyed = child->queryProperty(keyedAtom);
+                    IHqlExpression * childKeyed = child->queryAttribute(keyedAtom);
                     if (childKeyed && !transformKeyed)
                         break;
 
@@ -3081,7 +3081,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
             case no_keyedlimit:
                 if (isWorthMovingProjectOverLimit(transformed))
                 {
-                    if (child->hasProperty(onFailAtom))
+                    if (child->hasAttribute(onFailAtom))
                         return moveProjectionOverLimit(transformed);
                     return swapNodeWithChild(transformed);
                 }
@@ -3096,7 +3096,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                     //MORE: Later this is going to be worth moving aggregates.... when we have a compound aggregates.
                     if (isPureActivity(transformed) && !isAggregateDataset(transformed) && !transformedCountProject)
                     {
-                        if (child->hasProperty(onFailAtom))
+                        if (child->hasAttribute(onFailAtom))
                             return moveProjectionOverLimit(transformed);
                         return swapNodeWithChild(transformed);
                     }
@@ -3191,11 +3191,11 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                     if (!isPureActivity(child) || hasUnknownTransform(child))
                         break;
 
-                    if (child->hasProperty(_countProject_Atom) || child->hasProperty(prefetchAtom))
+                    if (child->hasAttribute(_countProject_Atom) || child->hasAttribute(prefetchAtom))
                         break;
     
-                    IHqlExpression * transformKeyed = transformed->queryProperty(keyedAtom);
-                    IHqlExpression * childKeyed = child->queryProperty(keyedAtom);
+                    IHqlExpression * transformKeyed = transformed->queryAttribute(keyedAtom);
+                    IHqlExpression * childKeyed = child->queryAttribute(keyedAtom);
                     if (childKeyed && !transformKeyed)
                         break;
 
@@ -3273,7 +3273,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                 {
                     if (isPureActivity(transformed) && !isAggregateDataset(transformed))
                     {
-                        if (child->hasProperty(onFailAtom))
+                        if (child->hasAttribute(onFailAtom))
                             return moveProjectionOverLimit(transformed);
                         return swapNodeWithChild(transformed);
                     }
@@ -3311,16 +3311,16 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
             case no_group:
                 {
                     IHqlExpression * newChild = child;
-                    bool isLocal = transformed->hasProperty(localAtom);
+                    bool isLocal = transformed->hasAttribute(localAtom);
                     while (newChild->getOperator() == no_group)
                     {
-                        if (newChild->queryProperty(allAtom))
+                        if (newChild->queryAttribute(allAtom))
                             break;
 
                         if (queryRealChild(newChild, 1))
                         {
                             //Don't allow local groups to remove non-local groups.
-                            if (isLocal && !newChild->hasProperty(localAtom))
+                            if (isLocal && !newChild->hasAttribute(localAtom))
                                 break;
                         }
                         noteUnused(newChild);
@@ -3339,7 +3339,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
             case no_hqlproject:
             case no_newusertable:
                 //Move ungroups() over projects to increase the likely hood of combining projects and removing groups
-//              if (!queryRealChild(transformed, 1) && !child->hasProperty(_countProject_Atom) && !isAggregateDataset(child))
+//              if (!queryRealChild(transformed, 1) && !child->hasAttribute(_countProject_Atom) && !isAggregateDataset(child))
 //                  return swapNodeWithChild(transformed);
                 break;
             }
@@ -3360,7 +3360,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                 {
                 case no_hqlproject:
                 case no_newusertable:
-                    if (isPureActivity(child) && !child->hasProperty(_countProject_Atom) && !child->hasProperty(prefetchAtom) && !isAggregateDataset(child))
+                    if (isPureActivity(child) && !child->hasAttribute(_countProject_Atom) && !child->hasAttribute(prefetchAtom) && !isAggregateDataset(child))
                         return swapNodeWithChild(transformed);
                     break;
                 }
@@ -3415,7 +3415,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
     case no_keyeddistribute:
     case no_distribute:
         {
-            if (transformed->hasProperty(skewAtom))
+            if (transformed->hasAttribute(skewAtom))
                 break;
             //If distribution matches existing and grouped then don't distribute, but still remove grouping.
             IHqlExpression * distn = queryDistribution(transformed);
@@ -3426,7 +3426,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
             case no_keyeddistribute:
             case no_sort:
             case no_subsort:
-                if (!transformed->hasProperty(mergeAtom))
+                if (!transformed->hasAttribute(mergeAtom))
                     return removeChildNode(transformed);
                 break;
             case no_dedup:
@@ -3490,7 +3490,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
             case no_compound_indexnormalize:
             case no_compound_childread:
             case no_compound_childnormalize:
-                if (!isGrouped(child) && (options & HOOhascompoundaggregate) && !transformed->hasProperty(localAtom))
+                if (!isGrouped(child) && (options & HOOhascompoundaggregate) && !transformed->hasAttribute(localAtom))
                 {
                     IHqlExpression * ret = optimizeAggregateCompound(transformed);
                     if (ret)
@@ -3585,7 +3585,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
 #if 0
         //Something like the following might theoretically be useful, but seems to cause problems not commoning up
     case no_select:
-        if (transformed->hasProperty(newAtom) && !childrenAreShared(child))
+        if (transformed->hasAttribute(newAtom) && !childrenAreShared(child))
         {
             OwnedHqlExpr ret = transformTrivialSelectProject(transformed);
             if (ret)
@@ -3628,7 +3628,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
         }
     case no_join:
         {
-            if (isKeyedJoin(transformed) || transformed->hasProperty(lookupAtom))
+            if (isKeyedJoin(transformed) || transformed->hasAttribute(lookupAtom))
             {
                 node_operator childOp = child->getOperator();
                 switch (childOp)
@@ -3636,7 +3636,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                 case no_newusertable:
                 case no_hqlproject:
                     {
-                        if (!isPureActivity(child) || child->queryProperty(_countProject_Atom) || child->hasProperty(prefetchAtom))
+                        if (!isPureActivity(child) || child->queryAttribute(_countProject_Atom) || child->hasAttribute(prefetchAtom))
                             break;
                         IHqlExpression * transform = queryNewColumnProvider(child);
                         if (transformContainsSkip(transform) || !isSimpleTransformToMergeWith(transform))
@@ -3670,7 +3670,7 @@ IHqlExpression * CTreeOptimizer::doCreateTransformed(IHqlExpression * transforme
                         if (ok)
                         {
                             //If expanding the project removed all references to left (very silly join....) make it an all join
-                            if (transformed->hasProperty(lookupAtom) && !exprReferencesDataset(&args.item(2), newLeft))
+                            if (transformed->hasAttribute(lookupAtom) && !exprReferencesDataset(&args.item(2), newLeft))
                                 args.append(*createAttribute(allAtom));
                             DBGLOG("Optimizer: Merge %s and %s", queryNode0Text(transformed), queryNode1Text(child));
                             noteUnused(child);

ecl/hql/hqlpmap.cpp

@@ -52,7 +52,7 @@ static IHqlExpression * optimizedReplaceSelector(IHqlExpression * expr, IHqlExpr
             IHqlExpression * lhs = expr->queryChild(0);
             IHqlExpression * field = expr->queryChild(1);
             OwnedHqlExpr newLhs;
-            if (expr->hasProperty(newAtom))
+            if (expr->hasAttribute(newAtom))
             {
                 newLhs.setown(optimizedReplaceSelector(lhs, oldDataset, newDataset));
             }
@@ -1155,7 +1155,7 @@ static IHqlExpression * getTrivialSelect(IHqlExpression * expr, IHqlExpression *
 
 IHqlExpression * transformTrivialSelectProject(IHqlExpression * select)
 {
-    IHqlExpression * newAttr = select->queryProperty(newAtom);
+    IHqlExpression * newAttr = select->queryAttribute(newAtom);
     if (!newAttr)
         return NULL;
 

ecl/hql/hqlthql.cpp

@@ -57,7 +57,7 @@ inline bool isInternalAttribute(IHqlExpression * e)
         IAtom * name= e->queryName();
         if ((name == sequenceAtom) || isInternalAttributeName(name))
             return true;
-        if ((name == updateAtom) && e->hasProperty(alwaysAtom))
+        if ((name == updateAtom) && e->hasAttribute(alwaysAtom))
             return true;
     }
     return false;
@@ -1160,7 +1160,7 @@ void HqltHql::toECL(IHqlExpression *expr, StringBuffer &s, bool paren, bool inTy
         }
         case no_assignall:
         {
-            IHqlExpression * original = expr->queryProperty(_original_Atom);
+            IHqlExpression * original = expr->queryAttribute(_original_Atom);
             if (original)
             {
                 toECL(original->queryChild(0), s, false, inType);
@@ -1255,9 +1255,9 @@ void HqltHql::toECL(IHqlExpression *expr, StringBuffer &s, bool paren, bool inTy
             const char * opText = getEclOpString(no);
             if ((no == no_div) && expr->queryType()->isInteger())
                 opText = "DIV";
-            if ((no == no_addfiles) && expr->hasProperty(_ordered_Atom))
+            if ((no == no_addfiles) && expr->hasAttribute(_ordered_Atom))
                 opText = "&";
-            if ((no == no_addfiles) && expr->hasProperty(_orderedPull_Atom))
+            if ((no == no_addfiles) && expr->hasAttribute(_orderedPull_Atom))
                 opText = "&&";
             unsigned num = expr->numChildren();
             for (unsigned i=1; i < num; i++)
@@ -1323,9 +1323,9 @@ void HqltHql::toECL(IHqlExpression *expr, StringBuffer &s, bool paren, bool inTy
 
                 {
                     lparen = needParen(expr, child0);
-                    if (expandProcessed && !expr->hasProperty(newAtom) && child0->queryName())
+                    if (expandProcessed && !expr->hasAttribute(newAtom) && child0->queryName())
                         s.append("<").append(child0->queryName()).append(">");
-                    if (xgmmlGraphText && expr->hasProperty(newAtom))
+                    if (xgmmlGraphText && expr->hasAttribute(newAtom))
                         s.append("<...>");
                     else
                         toECL(child0, s, lparen, inType);
@@ -1607,7 +1607,7 @@ void HqltHql::toECL(IHqlExpression *expr, StringBuffer &s, bool paren, bool inTy
                         else
                             s.append(high);
                     }
-                    if (expr->hasProperty(minimalAtom))
+                    if (expr->hasAttribute(minimalAtom))
                         s.append(",MINIMAL");
                     s.append(")");
                 }
@@ -2427,8 +2427,8 @@ void HqltHql::toECL(IHqlExpression *expr, StringBuffer &s, bool paren, bool inTy
             break;
         case no_getresult:
             {
-                IHqlExpression * name = queryPropertyChild(expr, namedAtom, 0);
-                switch (getIntValue(queryPropertyChild(expr, sequenceAtom, 0)))
+                IHqlExpression * name = queryAttributeChild(expr, namedAtom, 0);
+                switch (getIntValue(queryAttributeChild(expr, sequenceAtom, 0)))
                 {
                 case ResultSequencePersist: 
                     s.append("PERSIST(");
@@ -2442,7 +2442,7 @@ void HqltHql::toECL(IHqlExpression *expr, StringBuffer &s, bool paren, bool inTy
                 default:
                     s.append("RESULT(");
                     if (!name)
-                        s.append(getIntValue(queryPropertyChild(expr, sequenceAtom, 0)+1));
+                        s.append(getIntValue(queryAttributeChild(expr, sequenceAtom, 0)+1));
                     break;
                 }
                 if (name)
@@ -2451,7 +2451,7 @@ void HqltHql::toECL(IHqlExpression *expr, StringBuffer &s, bool paren, bool inTy
                 break;
             }
         case no_metaactivity:
-            if (expr->hasProperty(pullAtom))
+            if (expr->hasAttribute(pullAtom))
                 s.append("PULL");
             else
                 s.append("no_metaactivity:unknown");
@@ -2564,7 +2564,7 @@ void HqltHql::toECL(IHqlExpression *expr, StringBuffer &s, bool paren, bool inTy
             {
                 IHqlExpression * module = expr->queryDefinition()->queryChild(0);
                 s.append("LIBRARY(");
-                toECL(module->queryProperty(nameAtom)->queryChild(0), s, false, inType);
+                toECL(module->queryAttribute(nameAtom)->queryChild(0), s, false, inType);
                 s.append(')');
             }
             else

ecl/hql/hqltrans.cpp

@@ -950,7 +950,7 @@ IHqlExpression * QuickHqlTransformer::createTransformedBody(IHqlExpression * exp
                 HqlDummyLookupContext dummyctx(errors);
                 IHqlScope * newScope = newModule->queryScope();
                 if (newScope)
-                    return newScope->lookupSymbol(selectedName, makeLookupFlags(true, expr->hasProperty(ignoreBaseAtom), false), dummyctx);
+                    return newScope->lookupSymbol(selectedName, makeLookupFlags(true, expr->hasAttribute(ignoreBaseAtom), false), dummyctx);
             }
             break;
         }
@@ -1307,7 +1307,7 @@ void NewHqlTransformer::analyseAssign(IHqlExpression * expr)
 
 void NewHqlTransformer::analyseSelector(IHqlExpression * expr)
 {
-    if ((expr->getOperator() == no_select) && !expr->hasProperty(newAtom))
+    if ((expr->getOperator() == no_select) && !expr->hasAttribute(newAtom))
         analyseSelector(expr->queryChild(0));
 }
 
@@ -1435,7 +1435,7 @@ IHqlExpression * NewHqlTransformer::createTransformed(IHqlExpression * expr)
                 children.replace(*LINK(ds.queryChild(0)), 0);
                 removeProperty(children, newAtom);
             }
-            else if (!expr->hasProperty(newAtom))
+            else if (!expr->hasAttribute(newAtom))
             {
                 //unusual situation x.a<new>.b; x.a<new> is converted to d, but d.b is not right, it should now be d.b<new>
                 assertex(ds.isDatarow());
@@ -1741,7 +1741,7 @@ void NewHqlTransformer::setTransformedSelector(IHqlExpression * expr, IHqlExpres
 {
     assertex(expr == expr->queryNormalizedSelector());
     //in rare situations a selector could get converted to a non-selector e.g, when replace self-ref with a new dataset.
-    assertex(!transformed || transformed == transformed->queryNormalizedSelector() || transformed->hasProperty(newAtom));
+    assertex(!transformed || transformed == transformed->queryNormalizedSelector() || transformed->hasAttribute(newAtom));
     queryTransformExtra(expr)->setTransformedSelector(transformed);
 }
 
@@ -2199,7 +2199,7 @@ void ConditionalHqlTransformer::doAnalyseExpr(IHqlExpression * expr)
             return;
         break;
     case no_globalscope:
-        if (!expr->hasProperty(localAtom))
+        if (!expr->hasAttribute(localAtom))
         {
             unsigned savedDepth = conditionDepth;
             conditionDepth = 0;
@@ -3562,7 +3562,7 @@ void ScopedTransformer::analyseChildren(IHqlExpression * expr)
         }
     case no_select:
         {
-            if (expr->hasProperty(newAtom))
+            if (expr->hasAttribute(newAtom))
             {
                 IHqlExpression * dataset = expr->queryChild(0);
                 pushScope();
@@ -3577,7 +3577,7 @@ void ScopedTransformer::analyseChildren(IHqlExpression * expr)
             break;
         }
     case no_globalscope:
-        if (expr->hasProperty(optAtom))
+        if (expr->hasAttribute(optAtom))
         {
             NewHqlTransformer::analyseChildren(expr);
             break;
@@ -3957,7 +3957,7 @@ IHqlExpression * ScopedTransformer::createTransformed(IHqlExpression * expr)
     case no_select:
         {
             IHqlExpression * dataset = expr->queryChild(0);
-            if (expr->hasProperty(newAtom))
+            if (expr->hasAttribute(newAtom))
             {
                 pushScope();
                 IHqlExpression * transformedDs = transform(dataset);
@@ -3978,7 +3978,7 @@ IHqlExpression * ScopedTransformer::createTransformed(IHqlExpression * expr)
             break;
         }
     case no_globalscope:
-        if (expr->hasProperty(optAtom))
+        if (expr->hasAttribute(optAtom))
             return NewHqlTransformer::createTransformed(expr);
         //fall through
     case no_colon:
@@ -4272,7 +4272,7 @@ bool ScopedTransformer::checkInScope(IHqlExpression * selector, bool allowCreate
             break;
         return checkInScope(selector->queryChild(0), allowCreate);
     case no_globalscope:
-        if (selector->hasProperty(optAtom))
+        if (selector->hasAttribute(optAtom))
             break;
         //fall through
     case no_colon:
@@ -4586,7 +4586,7 @@ void SplitterVerifier::analyseExpr(IHqlExpression * expr)
         if (extra->useCount++)
         {
 #ifdef _DEBUG
-            IHqlExpression * id = expr->queryProperty(_uid_Atom);
+            IHqlExpression * id = expr->queryAttribute(_uid_Atom);
             unsigned idValue = (id ? (unsigned)getIntValue(id->queryChild(0)) : 0);
 #endif
             unsigned splitSize = (unsigned)getIntValue(expr->queryChild(1), 0);
@@ -4656,7 +4656,7 @@ public:
     {
         OwnedHqlExpr transformed = NewHqlTransformer::createTransformed(expr);
 
-        if ((transformed->getOperator() == no_select) && transformed->hasProperty(newAtom))
+        if ((transformed->getOperator() == no_select) && transformed->hasAttribute(newAtom))
         {
             IHqlExpression * child = transformed->queryChild(0);
             node_operator childOp = child->getOperator();

ecl/hql/hqlusage.cpp

@@ -424,11 +424,11 @@ IPropertyTree * SourceFieldUsage::createReport(bool includeFieldDetail, const IP
     expandSelects(entry, source->queryRecord(), queryActiveTableSelector(), usedAll, includeFieldDetail, numFields, numFieldsUsed);
     if (isKey(source))
     {
-        IHqlExpression * original = queryPropertyChild(source, _original_Atom, 0);
+        IHqlExpression * original = queryAttributeChild(source, _original_Atom, 0);
         if (!original)
             original = source;
         IHqlExpression * lastField = queryLastField(original->queryRecord());
-        if (usedFilepos || !lastField->hasProperty(_implicitFpos_Atom))
+        if (usedFilepos || !lastField->hasAttribute(_implicitFpos_Atom))
         {
             numFields++;
             if (usedFilepos || usedAll)

ecl/hql/hqlutil.cpp

@@ -472,7 +472,7 @@ bool recordContainsBlobs(IHqlExpression * record)
         {
         case no_field:
             {
-                if (cur->hasProperty(blobAtom))
+                if (cur->hasAttribute(blobAtom))
                     return true;
                 IHqlExpression * childRecord = cur->queryRecord();
                 if (childRecord && recordContainsBlobs(childRecord))
@@ -504,7 +504,7 @@ IHqlExpression * queryVirtualFileposField(IHqlExpression * record)
     ForEachChild(idx, record)
     {
         IHqlExpression * cur = record->queryChild(idx);
-        IHqlExpression * attr = cur->queryProperty(virtualAtom);
+        IHqlExpression * attr = cur->queryAttribute(virtualAtom);
         if (attr)
             return cur;
     }
@@ -653,7 +653,7 @@ IHqlExpression * JoinOrderSpotter::doTraverseStripSelect(IHqlExpression * expr,
         IHqlExpression * table = expr->queryChild(0);
 
         node_operator curKind = table->getOperator();
-        if (curKind == no_select || expr->hasProperty(newAtom))
+        if (curKind == no_select || expr->hasAttribute(newAtom))
         {
             //I'm not sure this is a good idea for elements with newAtom - can end up with weird join conditions
             HqlExprArray args;
@@ -965,12 +965,12 @@ IHqlExpression * getNormalizedFilename(IHqlExpression * filename)
 
 bool canBeSlidingJoin(IHqlExpression * expr)
 {
-    if (expr->hasProperty(hashAtom) || expr->hasProperty(lookupAtom) || expr->hasProperty(allAtom))
+    if (expr->hasAttribute(hashAtom) || expr->hasAttribute(lookupAtom) || expr->hasAttribute(allAtom))
         return false;
-    if (expr->hasProperty(rightouterAtom) || expr->hasProperty(fullouterAtom) ||
-        expr->hasProperty(leftonlyAtom) || expr->hasProperty(rightonlyAtom) || expr->hasProperty(fullonlyAtom))
+    if (expr->hasAttribute(rightouterAtom) || expr->hasAttribute(fullouterAtom) ||
+        expr->hasAttribute(leftonlyAtom) || expr->hasAttribute(rightonlyAtom) || expr->hasAttribute(fullonlyAtom))
         return false;
-    if (expr->hasProperty(atmostAtom))
+    if (expr->hasAttribute(atmostAtom))
         return false;
     return true;
 }
@@ -1331,7 +1331,7 @@ public:
 
     virtual IHqlExpression * visit(IHqlExpression * hint) 
     {
-        return hint->queryProperty(name);
+        return hint->queryAttribute(name);
     }
 
     IAtom * name;
@@ -1565,7 +1565,7 @@ unsigned getNumActivityArguments(IHqlExpression * expr)
             //no_libraryscopeinstance I guess.
             IHqlExpression * libraryFuncDef = expr->queryDefinition();
             IHqlExpression * library = libraryFuncDef->queryChild(0);
-            if (library->hasProperty(_noStreaming_Atom))
+            if (library->hasAttribute(_noStreaming_Atom))
                 return 0;
             IHqlExpression * libraryFormals = libraryFuncDef->queryChild(1);
             unsigned numStreaming = 0;
@@ -1624,7 +1624,7 @@ unsigned getNumActivityArguments(IHqlExpression * expr)
     case no_denormalizegroup:
     case no_join:
     case no_joincount:
-        if (isKeyedJoin(expr) && !expr->hasProperty(_complexKeyed_Atom))
+        if (isKeyedJoin(expr) && !expr->hasAttribute(_complexKeyed_Atom))
             return 1;
         return 2;
     case no_combine:
@@ -1672,7 +1672,7 @@ bool isDistributedSourceActivity(IHqlExpression * expr)
     case no_compound_indexgroupaggregate:
         return true;
     case no_getgraphresult:
-        return expr->hasProperty(_distributed_Atom);
+        return expr->hasAttribute(_distributed_Atom);
     case no_workunit_dataset:
     case no_getgraphloopresult:
     case no_temptable:
@@ -1924,9 +1924,9 @@ bool isTrivialSelectN(IHqlExpression * expr)
     return false;
 }
 
-IHqlExpression * queryPropertyChild(IHqlExpression * expr, IAtom * name, unsigned idx)
+IHqlExpression * queryAttributeChild(IHqlExpression * expr, IAtom * name, unsigned idx)
 {
-    IHqlExpression * match = expr->queryProperty(name);
+    IHqlExpression * match = expr->queryAttribute(name);
     if (match)
         return match->queryChild(idx);
     return NULL;
@@ -1940,7 +1940,7 @@ int getResultSequenceValue(IHqlExpression * set)
     case no_ensureresult:
     case no_extractresult:
     case no_output:
-        return (int)getIntValue(queryPropertyChild(set, sequenceAtom, 0), 0);
+        return (int)getIntValue(queryAttributeChild(set, sequenceAtom, 0), 0);
     }
     return 0;
 }
@@ -1948,7 +1948,7 @@ int getResultSequenceValue(IHqlExpression * set)
 
 IHqlExpression * querySequence(IHqlExpression * expr)
 {
-    IHqlExpression * seq = expr->queryProperty(sequenceAtom);
+    IHqlExpression * seq = expr->queryAttribute(sequenceAtom);
     if (seq)
         return seq->queryChild(0);
     if (expr->queryValue())
@@ -1958,7 +1958,7 @@ IHqlExpression * querySequence(IHqlExpression * expr)
 
 IHqlExpression * queryResultName(IHqlExpression * expr)
 {
-    IHqlExpression * name = expr->queryProperty(namedAtom);
+    IHqlExpression * name = expr->queryAttribute(namedAtom);
     if (name)
         return name->queryChild(0);
     return NULL;
@@ -1977,7 +1977,7 @@ IHqlExpression * queryConvertChoosenNSort(IHqlExpression * expr, unsigned __int6
         return NULL;
     
     //grouped sort->choosen.  Don't convert unless choosen preserves grouping
-    if (isGrouped(child) && !expr->hasProperty(groupedAtom))
+    if (isGrouped(child) && !expr->hasAttribute(groupedAtom))
         return NULL;
 
     OwnedHqlExpr count = foldHqlExpression(expr->queryChild(1));
@@ -1998,19 +1998,19 @@ IHqlExpression * queryConvertChoosenNSort(IHqlExpression * expr, unsigned __int6
     }
     else 
     {
-        if (!expr->hasProperty(fewAtom) || first)
+        if (!expr->hasAttribute(fewAtom) || first)
             return NULL;
     }
 
     //choosen(sort(x,a,local),n) -> do the topn local, but need to reapply the global choosen
-    if (expr->hasProperty(localAtom))
+    if (expr->hasAttribute(localAtom))
     {
-        if (!child->hasProperty(localAtom))
+        if (!child->hasAttribute(localAtom))
             return NULL;
     }
     else
     {
-        if (child->hasProperty(localAtom))
+        if (child->hasAttribute(localAtom))
             clone = true;
     }
     HqlExprArray args;
@@ -2220,8 +2220,8 @@ void DependenciesUsed::extractDependencies(IHqlExpression * expr, unsigned flags
     case no_workunit_dataset:
         if (flags & GatherResultRead)
         {
-            IHqlExpression * sequence = queryPropertyChild(expr, sequenceAtom, 0);
-            IHqlExpression * name = queryPropertyChild(expr, nameAtom, 0);
+            IHqlExpression * sequence = queryAttributeChild(expr, sequenceAtom, 0);
+            IHqlExpression * name = queryAttributeChild(expr, nameAtom, 0);
             addResultRead(sequence, name, false);
         }
         break;
@@ -2236,8 +2236,8 @@ void DependenciesUsed::extractDependencies(IHqlExpression * expr, unsigned flags
     case no_getresult:
         if (flags & GatherResultRead)
         {
-            IHqlExpression * sequence = queryPropertyChild(expr, sequenceAtom, 0);
-            IHqlExpression * name = queryPropertyChild(expr, namedAtom, 0);
+            IHqlExpression * sequence = queryAttributeChild(expr, sequenceAtom, 0);
+            IHqlExpression * name = queryAttributeChild(expr, namedAtom, 0);
             addResultRead(sequence, name, false);
         }
         break;
@@ -2246,21 +2246,21 @@ void DependenciesUsed::extractDependencies(IHqlExpression * expr, unsigned flags
     case no_extractresult:
         if (flags & GatherResultWrite)
         {
-            IHqlExpression * sequence = queryPropertyChild(expr, sequenceAtom, 0);
-            IHqlExpression * name = queryPropertyChild(expr, namedAtom, 0);
+            IHqlExpression * sequence = queryAttributeChild(expr, sequenceAtom, 0);
+            IHqlExpression * name = queryAttributeChild(expr, namedAtom, 0);
             addResultWrite(sequence, name, false);
         }
         break;
     case no_definesideeffect:
         if (flags & GatherResultWrite)
         {
-            addResultWrite(expr->queryProperty(_uid_Atom), NULL, false);
+            addResultWrite(expr->queryAttribute(_uid_Atom), NULL, false);
         }
         break;
     case no_callsideeffect:
         if (flags & GatherResultRead)
         {
-            addResultRead(expr->queryProperty(_uid_Atom), NULL, false);
+            addResultRead(expr->queryAttribute(_uid_Atom), NULL, false);
         }
         break;
     }
@@ -2416,7 +2416,7 @@ void DependencyGatherer::doGatherDependencies(IHqlExpression * expr)
         first = 3;
         break;
     case no_executewhen:
-        if (expr->hasProperty(beforeAtom))
+        if (expr->hasAttribute(beforeAtom))
         {
             for (unsigned i=max; i-- != 0; )
                 doGatherDependencies(expr->queryChild(i));
@@ -2600,7 +2600,7 @@ unsigned countTotalFields(IHqlExpression * record, bool includeVirtual)
                 count += countTotalFields(expr->queryRecord(), includeVirtual);
                 break;
             default:
-                if (includeVirtual || !expr->hasProperty(virtualAtom))
+                if (includeVirtual || !expr->hasAttribute(virtualAtom))
                     count++;
                 break;
             }
@@ -3298,8 +3298,8 @@ unsigned numAttributes(const IHqlExpression * expr)
 
 IHqlExpression * createGetResultFromSetResult(IHqlExpression * setResult, ITypeInfo * type)
 {
-    IHqlExpression * seqAttr = setResult->queryProperty(sequenceAtom);
-    IHqlExpression * aliasAttr = setResult->queryProperty(namedAtom);
+    IHqlExpression * seqAttr = setResult->queryAttribute(sequenceAtom);
+    IHqlExpression * aliasAttr = setResult->queryAttribute(namedAtom);
     Linked<ITypeInfo> valueType = type;
     if (!valueType)
     {
@@ -3360,11 +3360,11 @@ IAtom * queryCsvEncoding(IHqlExpression * mode)
 {
     if (mode)
     {
-        if (mode->queryProperty(asciiAtom))
+        if (mode->queryAttribute(asciiAtom))
             return asciiAtom;
-        if (mode->queryProperty(ebcdicAtom))
+        if (mode->queryAttribute(ebcdicAtom))
             return ebcdicAtom;
-        if (mode->queryProperty(unicodeAtom))
+        if (mode->queryAttribute(unicodeAtom))
             return unicodeAtom;
     }
     return NULL;
@@ -3661,7 +3661,7 @@ IDefRecordElement * RecordMetaCreator::createField(IHqlExpression * cur, IHqlExp
     }
     size32_t maxSize = 0;
     Owned<IDefRecordElement> elem = createDEfield(cur->queryName(), defType, childDefRecord, maxSize);
-    if (cur->hasProperty(blobAtom))
+    if (cur->hasAttribute(blobAtom))
     {
         Owned<ITypeInfo> blobType = makeBlobType();
         return createDEfield(cur->queryName(), blobType, elem, 0);
@@ -4103,8 +4103,8 @@ extern HQL_API IHqlExpression * convertScalarAggregateToDataset(IHqlExpression *
         field.setown(createField(valueId, expr->getType(), NULL));
 
     IHqlExpression * aggregateRecord = createRecord(field);
-    IHqlExpression * keyedAttr = expr->queryProperty(keyedAtom);
-    IHqlExpression * prefetchAttr = expr->queryProperty(prefetchAtom);
+    IHqlExpression * keyedAttr = expr->queryAttribute(keyedAtom);
+    IHqlExpression * prefetchAttr = expr->queryAttribute(prefetchAtom);
 
     HqlExprArray valueArgs;
     unwindChildren(valueArgs, expr, 1);
@@ -4260,14 +4260,14 @@ IHqlExpression * appendOwnedOperandsF(IHqlExpression * expr, ...)
 
 extern HQL_API void inheritAttribute(HqlExprArray & attrs, IHqlExpression * donor, IAtom * name)
 {
-    IHqlExpression * match = donor->queryProperty(name);
+    IHqlExpression * match = donor->queryAttribute(name);
     if (match)
         attrs.append(*LINK(match));
 }
 
 IHqlExpression * inheritAttribute(IHqlExpression * expr, IHqlExpression * donor, IAtom * name)
 {
-    return appendOwnedOperand(expr, LINK(donor->queryProperty(name)));
+    return appendOwnedOperand(expr, LINK(donor->queryAttribute(name)));
 }
 
 IHqlExpression * appendAttribute(IHqlExpression * expr, IAtom * attr)
@@ -4422,7 +4422,7 @@ void SplitDatasetAttributeTransformer::analyseExpr(IHqlExpression * expr)
 void SplitDatasetAttributeTransformer::doAnalyseSelect(IHqlExpression * expr)
 {
     IHqlExpression * ds = expr->queryChild(0);
-    if (expr->hasProperty(newAtom))
+    if (expr->hasAttribute(newAtom))
     {
         if (!datasets.contains(*ds))
         {
@@ -4445,7 +4445,7 @@ IHqlExpression * SplitDatasetAttributeTransformer::createTransformed(IHqlExpress
     switch (expr->getOperator())
     {
     case no_select:
-        if (expr->hasProperty(newAtom))
+        if (expr->hasAttribute(newAtom))
             return doTransformSelect(expr);
         break;
     case no_colon:
@@ -4488,7 +4488,7 @@ bool SplitDatasetAttributeTransformer::split(SharedHqlExpr & dataset, SharedHqlE
             switch (cur->getOperator())
             {
             case no_getgraphresult:
-                remove = !expr->hasProperty(_distributed_Atom);
+                remove = !expr->hasAttribute(_distributed_Atom);
                 break;
             case no_workunit_dataset:
             case no_getgraphloopresult:
@@ -4639,14 +4639,14 @@ static bool splitDatasetAttribute(SharedHqlExpr & dataset, SharedHqlExpr & attri
 #endif
 
     node_operator leftOp = left->getOperator();
-    if ((leftOp !=no_select) || expr->hasProperty(newAtom))
+    if ((leftOp !=no_select) || expr->hasAttribute(newAtom))
     {
         //Ensure selections from dictionaries do not have a separate activity for the row lookup.
         if (leftOp == no_selectmap)
             return false;
 
         //If this is a selection from an inscope dataset then this must not be assumed to be an input dataset.
-        if (expr->isDataset() && !expr->hasProperty(newAtom))
+        if (expr->isDataset() && !expr->hasAttribute(newAtom))
             return false;
 
         IHqlExpression * lhs = LINK(left);
@@ -4749,7 +4749,7 @@ bool containsVirtualFields(IHqlExpression * record)
         switch (cur->getOperator())
         {
         case no_field:
-            if (cur->hasProperty(virtualAtom))
+            if (cur->hasAttribute(virtualAtom))
                 return true;
             //does not walk into nested records
             break;
@@ -4776,7 +4776,7 @@ IHqlExpression * removeVirtualFields(IHqlExpression * record)
         switch (cur->getOperator())
         {
         case no_field:
-            if (!cur->hasProperty(virtualAtom))
+            if (!cur->hasAttribute(virtualAtom))
                 args.append(*LINK(cur));
             //does not walk into nested records
             break;
@@ -4818,7 +4818,7 @@ public:
         case no_field:
             {
                 OwnedHqlExpr transformed = transformField(expr);
-                while (transformed->hasProperty(name))
+                while (transformed->hasAttribute(name))
                     transformed.setown(removeProperty(transformed, name));
                 return transformed.getClear();
             }
@@ -4856,8 +4856,8 @@ void VirtualReplacer::createProjectAssignments(HqlExprArray & assigns, IHqlExpre
         {
             OwnedHqlExpr target = createSelectExpr(LINK(tgtSelector), LINK(expr));
             IHqlExpression * newValue;
-            if (expr->hasProperty(virtualAtom))
-                newValue = getVirtualReplacement(expr, expr->queryProperty(virtualAtom)->queryChild(0), dataset);
+            if (expr->hasAttribute(virtualAtom))
+                newValue = getVirtualReplacement(expr, expr->queryAttribute(virtualAtom)->queryChild(0), dataset);
             else
                 newValue = createSelectExpr(LINK(srcSelector), LINK(expr));
             assigns.append(*createAssign(target.getClear(), newValue));
@@ -5224,8 +5224,8 @@ IHqlExpression * TempTableTransformer::createTempTableTransform(IHqlExpression *
     OwnedHqlExpr self = getSelf(record);
     HqlMapTransformer mapping;
     unsigned col = 0;
-    IHqlExpression * rowPayloadAttr = curRow->queryProperty(_payload_Atom);
-    IHqlExpression * recordPayloadAttr = record->queryProperty(_payload_Atom);
+    IHqlExpression * rowPayloadAttr = curRow->queryAttribute(_payload_Atom);
+    IHqlExpression * recordPayloadAttr = record->queryAttribute(_payload_Atom);
     if (rowPayloadAttr)
     {
         unsigned rowPayload =  (unsigned) getIntValue(rowPayloadAttr->queryChild(0));
@@ -5234,20 +5234,20 @@ IHqlExpression * TempTableTransformer::createTempTableTransform(IHqlExpression *
         {
             unsigned recordPayload =  (unsigned) getIntValue(recordPayloadAttr->queryChild(0));
             if (rowPayload != recordPayload)
-                ERRORAT(curRow->queryProperty(_location_Atom), HQLERR_PayloadMismatch);
+                ERRORAT(curRow->queryAttribute(_location_Atom), HQLERR_PayloadMismatch);
         }
         else
-            ERRORAT(curRow->queryProperty(_location_Atom), HQLERR_PayloadMismatch);
+            ERRORAT(curRow->queryAttribute(_location_Atom), HQLERR_PayloadMismatch);
     }
     else if (recordPayloadAttr)
-        ERRORAT(curRow->queryProperty(_location_Atom), HQLERR_PayloadMismatch);
+        ERRORAT(curRow->queryAttribute(_location_Atom), HQLERR_PayloadMismatch);
 
     OwnedHqlExpr ret = createTempTableTransform(self, curRow, record, col, self, mapping, true);
     if (queryRealChild(curRow, col))
     {
         StringBuffer s;
         getExprECL(curRow->queryChild(col), s);
-        ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_TooManyInitializers, s.str());
+        ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_TooManyInitializers, s.str());
     }
     return ret.getClear();
 }
@@ -5278,7 +5278,7 @@ void TempTableTransformer::createTempTableAssign(HqlExprArray & assigns, IHqlExp
                             src.set(expr->queryChild(0));
                             if (!src || src->isAttribute())
                             {
-                                ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_NoDefaultProvided, expr->queryName()->str());
+                                ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_NoDefaultProvided, expr->queryName()->str());
                                 return;
                             }
                         }
@@ -5308,7 +5308,7 @@ void TempTableTransformer::createTempTableAssign(HqlExprArray & assigns, IHqlExp
                         {
                             if (!recordTypesMatch(src, target))
                             {
-                                ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
+                                ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
                                 return;
                             }
                             if (isGrouped(src))
@@ -5319,7 +5319,7 @@ void TempTableTransformer::createTempTableAssign(HqlExprArray & assigns, IHqlExp
                         }
                         else
                         {
-                            ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
+                            ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
                             return;
                         }
                     }
@@ -5329,7 +5329,7 @@ void TempTableTransformer::createTempTableAssign(HqlExprArray & assigns, IHqlExp
                         {
                             if (!recordTypesMatch(src, target))
                             {
-                                ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
+                                ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
                                 return;
                             }
                             castValue.set(src);
@@ -5382,25 +5382,25 @@ void TempTableTransformer::createTempTableAssign(HqlExprArray & assigns, IHqlExp
 
                     if (!src || src->isAttribute())
                     {
-                        if (expr->hasProperty(virtualAtom))
-                            ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_VirtualFieldInTempTable, expr->queryName()->str());
+                        if (expr->hasAttribute(virtualAtom))
+                            ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_VirtualFieldInTempTable, expr->queryName()->str());
                         else
-                            ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_NoDefaultProvided, expr->queryName()->str());
+                            ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_NoDefaultProvided, expr->queryName()->str());
                         return;
                     }
                     if (src->getOperator() == no_recordlist)
                     {
-                        ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_IncompatiableInitailiser, expr->queryName()->str());
+                        ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_IncompatiableInitailiser, expr->queryName()->str());
                         return;
                     }
                     else if (type->isScalar() != src->queryType()->isScalar())
                     {
-                        ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
+                        ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
                         return;
                     }
                     else if (strictTypeChecking && !type->assignableFrom(src->queryType()))
                     {
-                        ERRORAT1(curRow->queryProperty(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
+                        ERRORAT1(curRow->queryAttribute(_location_Atom), HQLERR_IncompatibleTypesForField, expr->queryName()->str());
                     }
                     castValue.setown(ensureExprType(src, type));
                 }
@@ -5485,7 +5485,7 @@ void TempTableTransformer::reportWarning(IHqlExpression * location, int code,con
 
 IHqlExpression *getDictionaryKeyRecord(IHqlExpression *record)
 {
-    IHqlExpression * payload = record->queryProperty(_payload_Atom);
+    IHqlExpression * payload = record->queryAttribute(_payload_Atom);
     unsigned payloadSize = payload ? getIntValue(payload->queryChild(0)) : 0;
     unsigned max = record->numChildren() - payloadSize;
     IHqlExpression *newrec = createRecord();
@@ -5809,12 +5809,12 @@ void gatherIndexBuildSortOrder(HqlExprArray & sorts, IHqlExpression * expr, bool
     //Option to not sort by fields that aren't part of the sorted key.
     unsigned indexFirstPayload = firstPayloadField(buildRecord, payloadCount);
     unsigned max;
-    bool sortPayload = sortIndexPayload ? !expr->hasProperty(sort_KeyedAtom) : expr->hasProperty(sort_AllAtom);
+    bool sortPayload = sortIndexPayload ? !expr->hasAttribute(sort_KeyedAtom) : expr->hasAttribute(sort_AllAtom);
     if (sortPayload)
     {
         max = buildRecord->numChildren();
         //If the last field is an implicit fpos, then they will all have the same value, so no point sorting.
-        if (queryLastField(buildRecord)->hasProperty(_implicitFpos_Atom))
+        if (queryLastField(buildRecord)->hasAttribute(_implicitFpos_Atom))
             max--;
     }
     else
@@ -5878,7 +5878,7 @@ LibraryInputMapper::LibraryInputMapper(IHqlExpression * _libraryInterface)
 {
     assertex(libraryInterface->getOperator() == no_funcdef);
     scopeExpr.set(libraryInterface->queryChild(0));
-    streamingAllowed = !scopeExpr->hasProperty(_noStreaming_Atom);  // ?? is this in the correct place, probably, just nasty
+    streamingAllowed = !scopeExpr->hasAttribute(_noStreaming_Atom);  // ?? is this in the correct place, probably, just nasty
 
     expandParameters();
 }
@@ -6128,7 +6128,7 @@ void GraphIdCollector::analyseExpr(IHqlExpression * expr)
     case no_getgraphresult:
         if (externalIds)
         {
-            IHqlExpression * id = queryPropertyChild(expr, externalAtom, 0);
+            IHqlExpression * id = queryAttributeChild(expr, externalAtom, 0);
             if (id)
                 graphs.append(*id);
         }
@@ -6378,7 +6378,7 @@ extern HQL_API bool isKeyedDataset(IHqlExpression * expr)
     case no_newusertable:
     case no_aggregate:
     case no_newaggregate:
-        return expr->hasProperty(keyedAtom);
+        return expr->hasAttribute(keyedAtom);
     }
     return false;
 }
@@ -6433,7 +6433,7 @@ extern HQL_API bool isValidFieldReference(IHqlExpression * expr)
     case no_indirect:
         return true;
     case no_param:
-        return expr->hasProperty(fieldAtom);
+        return expr->hasAttribute(fieldAtom);
     }
     return false;
 }
@@ -6572,13 +6572,13 @@ public:
         ITypeInfo * retType = funcdef->queryType()->queryChildType();
 
         enum { ServiceApi, RtlApi, BcdApi, CApi, LocalApi } api = ServiceApi;
-        if (body->hasProperty(eclrtlAtom))
+        if (body->hasAttribute(eclrtlAtom))
             api = RtlApi;
-        else if (body->hasProperty(bcdAtom))
+        else if (body->hasAttribute(bcdAtom))
             api = BcdApi;
-        else if (body->hasProperty(cAtom))
+        else if (body->hasAttribute(cAtom))
             api = CApi;
-        else if (body->hasProperty(localAtom))
+        else if (body->hasAttribute(localAtom))
             api = LocalApi;
 
         StringBuffer entrypoint;
@@ -6592,7 +6592,7 @@ public:
             return true;
         }
 
-        if (body->hasProperty(oldSetFormatAtom))
+        if (body->hasAttribute(oldSetFormatAtom))
             return false;
 
         mangled.append("_Z").append(entrypoint.length()).append(entrypoint);
@@ -6601,11 +6601,11 @@ public:
         StringBuffer mangledReturnParameters;
         mangleFunctionReturnType(mangledReturn, mangledReturnParameters, retType);
 
-        if (body->hasProperty(contextAtom))
+        if (body->hasAttribute(contextAtom))
             mangled.append("P12ICodeContext");
-        else if (body->hasProperty(globalContextAtom) )
+        else if (body->hasAttribute(globalContextAtom) )
             mangled.append("P18IGlobalCodeContext");
-        else if (body->hasProperty(userMatchFunctionAtom))
+        else if (body->hasAttribute(userMatchFunctionAtom))
             mangled.append("P12IMatchWalker");
 
         mangled.append(mangledReturnParameters);
@@ -6615,8 +6615,8 @@ public:
             IHqlExpression * param = formals->queryChild(i);
             ITypeInfo *paramType = param->queryType();
 
-            bool isOut = param->hasProperty(outAtom);
-            bool isConst = param->hasProperty(constAtom);
+            bool isOut = param->hasAttribute(outAtom);
+            bool isConst = param->hasAttribute(constAtom);
 
             if (isOut)
                 mangled.append("R");
@@ -6802,13 +6802,13 @@ public:
         IHqlExpression *formals = funcdef->queryChild(1);
 
         enum { ServiceApi, RtlApi, BcdApi, CApi, LocalApi } api = ServiceApi;
-        if (body->hasProperty(eclrtlAtom))
+        if (body->hasAttribute(eclrtlAtom))
             api = RtlApi;
-        else if (body->hasProperty(bcdAtom))
+        else if (body->hasAttribute(bcdAtom))
             api = BcdApi;
-        else if (body->hasProperty(cAtom))
+        else if (body->hasAttribute(cAtom))
             api = CApi;
-        else if (body->hasProperty(localAtom))
+        else if (body->hasAttribute(localAtom))
             api = LocalApi;
 
         StringBuffer entrypoint;
@@ -6822,7 +6822,7 @@ public:
             return true;
         }
 
-        if (body->hasProperty(oldSetFormatAtom))
+        if (body->hasAttribute(oldSetFormatAtom))
             return false;
 
         mangled.append("?").append(entrypoint).append("@@").append("Y");
@@ -6847,11 +6847,11 @@ public:
 
         mangled.append(mangledReturn);
 
-        if (body->hasProperty(contextAtom))
+        if (body->hasAttribute(contextAtom))
             mangled.append("PVICodeContext@@");
-        else if (body->hasProperty(globalContextAtom) )
+        else if (body->hasAttribute(globalContextAtom) )
             mangled.append("PVIGlobalCodeContext@@");
-        else if (body->hasProperty(userMatchFunctionAtom))
+        else if (body->hasAttribute(userMatchFunctionAtom))
             mangled.append("PVIMatchWalker@@");
 
         if (mangledReturnParameters.length())
@@ -6862,8 +6862,8 @@ public:
             IHqlExpression * param = formals->queryChild(i);
             ITypeInfo *paramType = param->queryType();
 
-            bool isOut = param->hasProperty(outAtom);
-            bool isConst = param->hasProperty(constAtom);
+            bool isOut = param->hasAttribute(outAtom);
+            bool isConst = param->hasAttribute(constAtom);
 
             if (isOut)
                 appendRef(mangled, false);
@@ -7084,7 +7084,7 @@ static void trimSlash(StringBuffer & name)
 
 void extractXmlName(StringBuffer & name, StringBuffer * itemName, StringBuffer * valueName, IHqlExpression * field, const char * defaultItemName, bool reading)
 {
-    IHqlExpression * xpathAttr = field->queryProperty(xpathAtom);
+    IHqlExpression * xpathAttr = field->queryAttribute(xpathAtom);
     if (xpathAttr)
     {
         StringBuffer tagName;
@@ -7144,7 +7144,7 @@ void extractXmlName(StringBuffer & name, StringBuffer * itemName, StringBuffer *
     }
     else
     {
-        IHqlExpression * namedAttr = field->queryProperty(namedAtom);
+        IHqlExpression * namedAttr = field->queryAttribute(namedAtom);
         if (namedAttr)
             namedAttr->queryChild(0)->queryValue()->getStringValue(name);
     }
@@ -7207,7 +7207,7 @@ static ITypeInfo * containsSingleSimpleFieldBlankXPath(IHqlExpression * record)
     if (field->getOperator() != no_field)
         return NULL;
 
-    IHqlExpression * xpath = field->queryProperty(xpathAtom);
+    IHqlExpression * xpath = field->queryAttribute(xpathAtom);
     if (!xpath)
         return NULL;
 
@@ -7606,11 +7606,11 @@ bool ConstantRowCreator::processFieldValue(IHqlExpression * optLhs, ITypeInfo *
         {
             assertex(optLhs);
             IHqlExpression * field = optLhs->queryChild(1);
-            if (!field->hasProperty(countAtom) && !field->hasProperty(sizeofAtom))
+            if (!field->hasAttribute(countAtom) && !field->hasAttribute(sizeofAtom))
             {
                 if (rhsOp == no_null)
                 {
-                    if (field->hasProperty(_linkCounted_Atom))
+                    if (field->hasAttribute(_linkCounted_Atom))
                     {
                         rtlWriteSize32t(out.reserve(sizeof(size32_t)), 0);
                         memset(out.reserve(sizeof(byte * *)), 0, sizeof(byte * *));
@@ -8079,7 +8079,7 @@ IHqlExpression * queryTableOrSplitter(IHqlExpression * expr)
 //Convert no_dataset_alias(expr, uid) to expr'
 IHqlExpression * normalizeDatasetAlias(IHqlExpression * expr)
 {
-    IHqlExpression * uid = expr->queryProperty(_uid_Atom);
+    IHqlExpression * uid = expr->queryAttribute(_uid_Atom);
     assertex(uid);
     IHqlExpression * dataset = expr->queryChild(0);
     IHqlExpression * table = queryTableOrSplitter(dataset);
@@ -8156,7 +8156,7 @@ IHqlExpression * normalizeAnyDatasetAliases(IHqlExpression * expr)
         transformed.setown(expr->clone(args));
     }
 
-    if ((op == no_dataset_alias) && !transformed->hasProperty(_normalized_Atom))
+    if ((op == no_dataset_alias) && !transformed->hasAttribute(_normalized_Atom))
         return normalizeDatasetAlias(transformed);
     return transformed.getClear();
 }

ecl/hql/hqlutil.hpp

@@ -92,7 +92,7 @@ extern HQL_API unsigned isEmptyRecord(IHqlExpression * record);
 extern HQL_API bool isTrivialSelectN(IHqlExpression * expr);
 extern HQL_API IHqlExpression * queryConvertChoosenNSort(IHqlExpression * expr, unsigned __int64 topNlimit);
 
-extern HQL_API IHqlExpression * queryPropertyChild(IHqlExpression * expr, IAtom * name, unsigned idx);
+extern HQL_API IHqlExpression * queryAttributeChild(IHqlExpression * expr, IAtom * name, unsigned idx);
 extern HQL_API IHqlExpression * querySequence(IHqlExpression * expr);
 extern HQL_API IHqlExpression * queryResultName(IHqlExpression * expr);
 extern HQL_API int getResultSequenceValue(IHqlExpression * expr);

ecl/hql/hqlvalid.cpp

@@ -152,7 +152,7 @@ void reportAbstractModule(IErrorReceiver * errors, IHqlExpression * expr, const
 
     if (fieldText.length())
         reportError(errors, ERR_ABSTRACT_MODULE, errpos, "Cannot use an abstract MODULE in this context (%s undefined)", fieldText.str());
-    else if (expr->hasProperty(interfaceAtom))
+    else if (expr->hasAttribute(interfaceAtom))
         reportError(errors, ERR_ABSTRACT_MODULE, errpos, "Cannot use an abstract MODULE in this context (INTERFACE must be instantiated)");
     else
         reportError(errors, ERR_ABSTRACT_MODULE, errpos, "Cannot use an abstract MODULE in this context");

ecl/hqlcpp/hqlckey.cpp

@@ -155,7 +155,7 @@ IHqlExpression * getHozedKeyValue(IHqlExpression * _value)
 
 IHqlExpression * convertIndexPhysical2LogicalValue(IHqlExpression * cur, IHqlExpression * physicalSelect, bool allowTranslate)
 {
-    if (cur->hasProperty(blobAtom))
+    if (cur->hasAttribute(blobAtom))
     {
         if (cur->isDataset())
             return createDataset(no_id2blob, LINK(physicalSelect), LINK(cur->queryRecord()));
@@ -240,8 +240,8 @@ public:
     IHqlExpression * queryFileFilename()                    { return file->queryChild(0); }
     IHqlExpression * queryRawKey()                          { return rawKey; }
     IHqlExpression * queryRawRhs()                          { return rawRhs; }
-    bool isKeyOpt()                                         { return key->hasProperty(optAtom); }
-    bool isFileOpt()                                        { return file && file->hasProperty(optAtom); }
+    bool isKeyOpt()                                         { return key->hasAttribute(optAtom); }
+    bool isFileOpt()                                        { return file && file->hasAttribute(optAtom); }
     bool needToExtractJoinFields() const                    { return extractJoinFieldsTransform != NULL; }
     bool hasPostFilter() const                              { return monitors->queryExtraFilter() || fileFilter; }
     bool requireActivityForKey() const                      { return hasComplexIndex; }
@@ -293,7 +293,7 @@ KeyedJoinInfo::KeyedJoinInfo(HqlCppTranslator & _translator, IHqlExpression * _e
     hasComplexIndex = false;
 
     IHqlExpression * right = expr->queryChild(1);
-    IHqlExpression * keyed = expr->queryProperty(keyedAtom);
+    IHqlExpression * keyed = expr->queryAttribute(keyedAtom);
     if (keyed && keyed->queryChild(0))
     {
         key.set(keyed->queryChild(0));
@@ -330,7 +330,7 @@ KeyedJoinInfo::KeyedJoinInfo(HqlCppTranslator & _translator, IHqlExpression * _e
     rawKey.set(queryPhysicalRootTable(expandedKey));
     canOptimizeTransfer = _canOptimizeTransfer; 
     monitors = NULL;
-    counter.set(queryPropertyChild(expr, _countProject_Atom, 0));
+    counter.set(queryAttributeChild(expr, _countProject_Atom, 0));
 
     if (isFullJoin())
         rawRhs.set(rawFile);
@@ -653,7 +653,7 @@ void KeyedJoinInfo::buildTransformBody(BuildCtx & ctx, IHqlExpression * transfor
 {
     IHqlExpression * rhs = expr->queryChild(1);
     IHqlExpression * rhsRecord = rhs->queryRecord();
-    IHqlExpression * rowsid = expr->queryProperty(_rowsid_Atom);
+    IHqlExpression * rowsid = expr->queryAttribute(_rowsid_Atom);
 
     OwnedHqlExpr originalRight = createSelector(no_right, rhsRecord, joinSeq);
     OwnedHqlExpr serializedRhsRecord = getSerializedForm(rhsRecord, diskAtom);
@@ -984,7 +984,7 @@ void KeyedJoinInfo::optimizeExtractJoinFields()
     {
         //Version1: Don't remove any fields
         doExtract = true;
-        OwnedHqlExpr rows = createDataset(no_rows, LINK(right), LINK(expr->queryProperty(_rowsid_Atom)));
+        OwnedHqlExpr rows = createDataset(no_rows, LINK(right), LINK(expr->queryAttribute(_rowsid_Atom)));
         if (isFullJoin())
         {
             //unwindFields(fieldsAccessed, file->queryRecord());
@@ -1101,7 +1101,7 @@ void KeyedJoinInfo::optimizeExtractJoinFields()
 bool KeyedJoinInfo::processFilter()
 {
     OwnedHqlExpr atmostCond, atmostLimit;
-    IHqlExpression * atmost = expr->queryProperty(atmostAtom);
+    IHqlExpression * atmost = expr->queryAttribute(atmostAtom);
     extractAtmostArgs(atmost, atmostCond, atmostLimit);
 
     IHqlExpression * cond = expr->queryChild(2);
@@ -1264,7 +1264,7 @@ void HqlCppTranslator::buildKeyedJoinExtra(ActivityInstance & instance, IHqlExpr
 
     //virtual size32_t transform(ARowBuilder & crSelf, const void * _left, const void * _right) = 0;
     info->buildTransform(instance.startctx);
-    IHqlExpression * onFail = expr->queryProperty(onFailAtom);
+    IHqlExpression * onFail = expr->queryAttribute(onFailAtom);
     if (onFail)
     {
         //virtual size32_t onFailTransform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned __int64 _filepos, IException * except)
@@ -1272,10 +1272,10 @@ void HqlCppTranslator::buildKeyedJoinExtra(ActivityInstance & instance, IHqlExpr
     }
 
     //limit helpers...
-    IHqlExpression * limit = expr->queryProperty(limitAtom);
+    IHqlExpression * limit = expr->queryAttribute(limitAtom);
     if (limit)
     {
-        if (limit->hasProperty(skipAtom))
+        if (limit->hasAttribute(skipAtom))
         {
             BuildCtx ctx1(instance.startctx);
             ctx1.addQuotedCompound("virtual unsigned __int64 getSkipLimit()");
@@ -1371,37 +1371,37 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyedJoinOrDenormalize(BuildCt
         }
     }
     buildActivityFramework(instance);
-    IHqlExpression * rowlimit = expr->queryProperty(rowLimitAtom);
+    IHqlExpression * rowlimit = expr->queryAttribute(rowLimitAtom);
 
     StringBuffer s;
     buildInstancePrefix(instance);
 
     OwnedHqlExpr atmostCond, atmostLimit;
-    IHqlExpression * atmost = expr->queryProperty(atmostAtom);
+    IHqlExpression * atmost = expr->queryAttribute(atmostAtom);
     extractAtmostArgs(atmost, atmostCond, atmostLimit);
 
     //virtual unsigned getJoinFlags()
     StringBuffer flags;
-    bool isLeftOuter = (expr->hasProperty(leftonlyAtom) || expr->hasProperty(leftouterAtom));
-    if (expr->hasProperty(leftonlyAtom)) flags.append("|JFexclude");
+    bool isLeftOuter = (expr->hasAttribute(leftonlyAtom) || expr->hasAttribute(leftouterAtom));
+    if (expr->hasAttribute(leftonlyAtom)) flags.append("|JFexclude");
     if (isLeftOuter) flags.append("|JFleftouter");
-    if (expr->hasProperty(firstAtom)) flags.append("|JFfirst");
-    if (expr->hasProperty(firstLeftAtom)) flags.append("|JFfirstleft");
+    if (expr->hasAttribute(firstAtom)) flags.append("|JFfirst");
+    if (expr->hasAttribute(firstLeftAtom)) flags.append("|JFfirstleft");
     if (transformContainsSkip(expr->queryChild(3)))
         flags.append("|JFtransformMaySkip");
     if (info.isFetchFiltered())
         flags.append("|JFfetchMayFilter");
-    if (rowlimit && rowlimit->hasProperty(skipAtom))
+    if (rowlimit && rowlimit->hasAttribute(skipAtom))
         flags.append("|JFmatchAbortLimitSkips");
-    if (rowlimit && rowlimit->hasProperty(countAtom))
+    if (rowlimit && rowlimit->hasAttribute(countAtom))
         flags.append("|JFcountmatchabortlimit");
-    if (expr->hasProperty(onFailAtom))
+    if (expr->hasAttribute(onFailAtom))
         flags.append("|JFonfail");
     if (info.isKeyOpt())
         flags.append("|JFindexoptional");
     if (info.needToExtractJoinFields())
         flags.append("|JFextractjoinfields");
-    if (expr->hasProperty(unorderedAtom))
+    if (expr->hasAttribute(unorderedAtom))
         flags.append("|JFreorderable");
     if (transformReturnsSide(expr, no_left, 0))
         flags.append("|JFtransformmatchesleft");
@@ -1435,13 +1435,13 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyedJoinOrDenormalize(BuildCt
         doBuildUnsignedFunction(instance->startctx, "getJoinLimit", atmostLimit);
 
     //virtual unsigned getKeepLimit()
-    LinkedHqlExpr keepLimit = queryPropertyChild(expr, keepAtom, 0);
+    LinkedHqlExpr keepLimit = queryAttributeChild(expr, keepAtom, 0);
     if (keepLimit)
         doBuildUnsignedFunction(instance->startctx, "getKeepLimit", keepLimit);
 
     bool implicitLimit = !rowlimit && !atmost &&
                         (!keepLimit || info.hasPostFilter()) &&
-                        !expr->hasProperty(leftonlyAtom);
+                        !expr->hasAttribute(leftonlyAtom);
 
     //virtual unsigned getKeepLimit()
     doBuildJoinRowLimitHelper(*instance, rowlimit, info.queryKeyFilename(), implicitLimit);
@@ -1450,14 +1450,14 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyedJoinOrDenormalize(BuildCt
     if (info.isFullJoin())
     {
         buildFormatCrcFunction(instance->classctx, "getDiskFormatCrc", info.queryRawRhs(), NULL, 0);
-        buildEncryptHelper(instance->startctx, info.queryFile()->queryProperty(encryptAtom), "getFileEncryptKey");
+        buildEncryptHelper(instance->startctx, info.queryFile()->queryAttribute(encryptAtom), "getFileEncryptKey");
     }
 
     IHqlExpression * key = info.queryKey();
     buildSerializedLayoutMember(instance->classctx, key->queryRecord(), "getIndexLayout", numKeyedFields(key));
 
     //--function to clear right, used for left outer join
-    if (isLeftOuter || expr->hasProperty(onFailAtom))
+    if (isLeftOuter || expr->hasAttribute(onFailAtom))
         info.buildClearRightFunction(instance->createctx);
 
     buildKeyedJoinExtra(*instance, expr, &info);
@@ -1507,7 +1507,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyedDistribute(BuildCtx & ctx
 
     unsigned numUnsortedFields = numPayloadFields(right);
     unsigned numKeyedFields = getFlatFieldCount(indexRecord)-numUnsortedFields;
-    if (match || (!expr->hasProperty(firstAtom) && (leftSorts.ordinality() != numKeyedFields)))
+    if (match || (!expr->hasAttribute(firstAtom) && (leftSorts.ordinality() != numKeyedFields)))
         throwError(HQLERR_MustMatchExactly);    //Should already be caught in parser
 
     KeyedJoinInfo info(*this, expr, false);
@@ -1595,9 +1595,9 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyDiff(BuildCtx & ctx, IHqlEx
 
     //virtual unsigned getFlags() = 0;
     StringBuffer flags;
-    if (expr->hasProperty(overwriteAtom))
+    if (expr->hasAttribute(overwriteAtom))
         flags.append("|KDPoverwrite");
-    else if (expr->hasProperty(noOverwriteAtom))
+    else if (expr->hasAttribute(noOverwriteAtom))
         flags.append("|KDPnooverwrite");
     if (!output->isConstant())
         flags.append("|KDPvaroutputname");
@@ -1619,7 +1619,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyDiff(BuildCtx & ctx, IHqlEx
     //virtual int getSequence() = 0;
     doBuildSequenceFunc(instance->classctx, querySequence(expr), false);
 
-    buildExpiryHelper(instance->createctx, expr->queryProperty(expireAtom));
+    buildExpiryHelper(instance->createctx, expr->queryAttribute(expireAtom));
 
     buildInstanceSuffix(instance);
     return instance->getBoundActivity();
@@ -1640,9 +1640,9 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyPatch(BuildCtx & ctx, IHqlE
 
     //virtual unsigned getFlags() = 0;
     StringBuffer flags;
-    if (expr->hasProperty(overwriteAtom))
+    if (expr->hasAttribute(overwriteAtom))
         flags.append("|KDPoverwrite");
-    else if (expr->hasProperty(noOverwriteAtom))
+    else if (expr->hasAttribute(noOverwriteAtom))
         flags.append("|KDPnooverwrite");
     if (!output->isConstant())
         flags.append("|KDPvaroutputname");
@@ -1662,7 +1662,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityKeyPatch(BuildCtx & ctx, IHqlE
     //virtual int getSequence() = 0;
     doBuildSequenceFunc(instance->classctx, querySequence(expr), false);
 
-    buildExpiryHelper(instance->createctx, expr->queryProperty(expireAtom));
+    buildExpiryHelper(instance->createctx, expr->queryAttribute(expireAtom));
 
     buildInstanceSuffix(instance);
     return instance->getBoundActivity();

ecl/hqlcpp/hqlcpp.cpp

@@ -1212,7 +1212,7 @@ bool HqlCppInstance::useFunction(IHqlExpression * func)
 
         ctx.addQuoted(init.append("(wuid);"));
     }
-    IHqlExpression *pluginAttr = funcDef->queryProperty(pluginAtom);
+    IHqlExpression *pluginAttr = funcDef->queryAttribute(pluginAtom);
     if (pluginAttr)
     {
         StringBuffer plugin, version;
@@ -1225,7 +1225,7 @@ bool HqlCppInstance::useFunction(IHqlExpression * func)
             getFullFileName(libname, true);
         }
     }
-    if (!funcDef->hasProperty(ctxmethodAtom) && !funcDef->hasProperty(gctxmethodAtom) && !funcDef->hasProperty(methodAtom))
+    if (!funcDef->hasAttribute(ctxmethodAtom) && !funcDef->hasAttribute(gctxmethodAtom) && !funcDef->hasAttribute(methodAtom))
     {
         if (libname.length())
             useLibrary(libname.str());
@@ -1858,7 +1858,7 @@ bool HqlCppTranslator::needToSerializeToSlave(IHqlExpression * expr) const
     {
     case no_getresult:
     case no_workunit_dataset:
-        return !matchesConstantValue(queryPropertyChild(expr, sequenceAtom, 0), ResultSequenceOnce);
+        return !matchesConstantValue(queryAttributeChild(expr, sequenceAtom, 0), ResultSequenceOnce);
     default:
         return true;
     }
@@ -3686,7 +3686,7 @@ void HqlCppTranslator::doExpandAliases(BuildCtx & ctx, IHqlExpression * expr, Al
             IHqlExpression * value = expr->queryChild(0);
             if ((commonPath == NULL) && !ctx.queryMatchExpr(value))
             {
-                if (containsAliasLocally(value) && !expr->hasProperty(globalAtom))
+                if (containsAliasLocally(value) && !expr->hasAttribute(globalAtom))
                     doExpandAliases(ctx, value, info);
                 doBuildExprAlias(ctx, expr, NULL);
             }
@@ -3980,7 +3980,7 @@ void HqlCppTranslator::buildSimpleExpr(BuildCtx & ctx, IHqlExpression * expr, CH
     case no_substring:
         {
             SubStringInfo info(expr);
-            if (info.canGenerateInline() || expr->hasProperty(quickAtom))
+            if (info.canGenerateInline() || expr->hasAttribute(quickAtom))
                 simple = true;
             break;
         }
@@ -4410,7 +4410,7 @@ void HqlCppTranslator::doBuildExprAlias(BuildCtx & ctx, IHqlExpression * expr, C
 
     //The second half of this test could cause aliases to be duplicated, but has the significant effect of reducing the amount of data that is serialised.
     //so far on my examples it does the latter, but doesn't seem to cause the former
-    if (expr->hasProperty(localAtom) || (insideOnCreate(ctx) && !expr->hasProperty(globalAtom)))
+    if (expr->hasAttribute(localAtom) || (insideOnCreate(ctx) && !expr->hasAttribute(globalAtom)))
     {
         expandAliases(ctx, value);
         if (tgt)
@@ -5554,9 +5554,9 @@ void HqlCppTranslator::doBuildCall(BuildCtx & ctx, const CHqlBoundTarget * tgt,
 
     IHqlExpression * external = funcdef->queryChild(0);
     IHqlExpression * formals = funcdef->queryChild(1);
-    if (external->hasProperty(ctxmethodAtom))
+    if (external->hasAttribute(ctxmethodAtom))
         ensureContextAvailable(ctx);
-    if (external->hasProperty(gctxmethodAtom) || external->hasProperty(globalContextAtom))
+    if (external->hasAttribute(gctxmethodAtom) || external->hasAttribute(globalContextAtom))
     {
         if (!ctx.queryMatchExpr(globalContextMarkerExpr))
             throwError1(HQLERR_FuncNotInGlobalContext, external->queryName()->str());
@@ -5571,8 +5571,8 @@ void HqlCppTranslator::doBuildCall(BuildCtx & ctx, const CHqlBoundTarget * tgt,
     unsigned param;
 
     unsigned firstParam = 0;
-    bool isMethod = external->hasProperty(methodAtom) || external->hasProperty(omethodAtom) ;
-    bool newFormatSet = !external->hasProperty(oldSetFormatAtom);
+    bool isMethod = external->hasAttribute(methodAtom) || external->hasAttribute(omethodAtom) ;
+    bool newFormatSet = !external->hasAttribute(oldSetFormatAtom);
     bool translateSetReturn = false;
     if (isMethod)
     {
@@ -5580,12 +5580,12 @@ void HqlCppTranslator::doBuildCall(BuildCtx & ctx, const CHqlBoundTarget * tgt,
         buildExpr(ctx, expr->queryChild(firstParam++), bound);
         args.append(*bound.expr.getClear());
     }
-    if (external->hasProperty(userMatchFunctionAtom))
+    if (external->hasAttribute(userMatchFunctionAtom))
     {
         //MORE: Test valid in this location...
         args.append(*createVariable("walker", makeBoolType()));
     }
-    IHqlExpression * extendAttr = external->queryProperty(extendAtom);
+    IHqlExpression * extendAttr = external->queryAttribute(extendAtom);
 
     bool doneAssign = false;
     CHqlBoundExpr localBound;
@@ -5892,7 +5892,7 @@ void HqlCppTranslator::doBuildCall(BuildCtx & ctx, const CHqlBoundTarget * tgt,
                 args.append(*getBoundLength(bound));
             /*
             Ensure parameter is passed as non-const if the argument does not have const.
-            if (!curArg->hasProperty(constAtom))//!argType->isConstantType())// && bound.queryType()->isConstantType())
+            if (!curArg->hasAttribute(constAtom))//!argType->isConstantType())// && bound.queryType()->isConstantType())
                 bound.expr.setown(createValue(no_cast, LINK(argType), LINK(bound.expr)));
                 */
             break;
@@ -6038,7 +6038,7 @@ void HqlCppTranslator::doBuildXmlEncode(BuildCtx & ctx, const CHqlBoundTarget *
     {
         func = isUnicode ? xmlEncodeUStrId : xmlEncodeStrId;
         __int64 flags = 0;
-        if (expr->hasProperty(allAtom))
+        if (expr->hasAttribute(allAtom))
             flags = ENCODE_WHITESPACE;
         args.append(*createConstant(flags));
     }
@@ -7272,7 +7272,7 @@ void HqlCppTranslator::doBuildExprEmbedBody(BuildCtx & ctx, IHqlExpression * exp
         throwError(HQLERR_EmbeddedCppNotAllowed);
 
     processCppBodyDirectives(expr);
-    IHqlExpression *languageAttr = expr->queryProperty(languageAtom);
+    IHqlExpression *languageAttr = expr->queryAttribute(languageAtom);
     if (languageAttr)
     {
         UNIMPLEMENTED;  // It's not clear if this can ever happen - perhaps a parameterless function that used EMBED ?
@@ -8613,7 +8613,7 @@ void HqlCppTranslator::doBuildAssignHashCrc(BuildCtx & ctx, const CHqlBoundTarge
     else if (op == no_hash64)
         initialValue.setown(createConstant(createIntValue(HASH64_INIT, 8, false)));
 
-    HashCodeCreator creator(*this, target, op, expr->hasProperty(internalAtom));
+    HashCodeCreator creator(*this, target, op, expr->hasAttribute(internalAtom));
     creator.setInitialValue(initialValue);
     if (child->getOperator() != no_sortlist)
         doBuildAssignHashElement(ctx, creator, child);
@@ -8699,7 +8699,7 @@ void HqlCppTranslator::doBuildAssignHashElement(BuildCtx & ctx, HashCodeCreator
     CHqlBoundExpr bound;
     OwnedHqlExpr length;
     OwnedHqlExpr ptr;
-    bool alreadyTrimmedRight = (elem->getOperator() == no_trim) && (elem->hasProperty(rightAtom) || !elem->hasProperty(leftAtom));
+    bool alreadyTrimmedRight = (elem->getOperator() == no_trim) && (elem->hasAttribute(rightAtom) || !elem->hasAttribute(leftAtom));
     //If this hash is generated internally (e.g., for a dedup) and fixed length, then can simplify the hash calculation
     bool canOptimizeHash = (creator.optimize() && isFixedSize(type));
     bool optimizeTrim = alreadyTrimmedRight || canOptimizeHash;
@@ -9161,8 +9161,8 @@ void checkRankRange(IHqlExpression * index, IHqlExpression * list)
     if (list->getOperator() == no_getresult)
     {
         StringBuffer s;
-        IHqlExpression * sequence = queryPropertyChild(list, sequenceAtom, 0);
-        IHqlExpression * name = queryPropertyChild(list, namedAtom, 0);
+        IHqlExpression * sequence = queryAttributeChild(list, sequenceAtom, 0);
+        IHqlExpression * name = queryAttributeChild(list, namedAtom, 0);
         getStoredDescription(s, sequence, name, true);
         throwError1(HQLERR_RankOnStored, s.str());
     }
@@ -9220,7 +9220,7 @@ void HqlCppTranslator::doBuildStmtFail(BuildCtx & ctx, IHqlExpression * expr)
     HqlExprArray args;
     args.append(*getFailCode(expr));
     args.append(*getFailMessage(expr, false));
-    IIdAtom * func = expr->hasProperty(defaultAtom) ? sysFailId : _failId;
+    IIdAtom * func = expr->hasAttribute(defaultAtom) ? sysFailId : _failId;
     OwnedHqlExpr call = bindFunctionCall(func, args);
     buildStmt(ctx, call);
 }
@@ -9616,7 +9616,7 @@ void HqlCppTranslator::doBuildExprSubString(BuildCtx & ctx, IHqlExpression * exp
         if (doBuildExprInfiniteSubString(ctx, info, tgt))
             return;
 
-    if (expr->hasProperty(quickAtom))
+    if (expr->hasAttribute(quickAtom))
     {
         doBuildExprAnySubString(ctx, info, tgt);
         return;
@@ -9631,9 +9631,9 @@ void HqlCppTranslator::doBuildAssignTrim(BuildCtx & ctx, const CHqlBoundTarget &
 {
     IHqlExpression * str = expr->queryChild(0);
     IIdAtom * func;
-    bool hasAll = expr->hasProperty(allAtom);
-    bool hasLeft = expr->hasProperty(leftAtom);
-    bool hasRight = expr->hasProperty(rightAtom);
+    bool hasAll = expr->hasAttribute(allAtom);
+    bool hasLeft = expr->hasAttribute(leftAtom);
+    bool hasRight = expr->hasAttribute(rightAtom);
 
     if (str->queryType()->getTypeCode() == type_varstring)
     {
@@ -9708,9 +9708,9 @@ void HqlCppTranslator::doBuildExprTrim(BuildCtx & ctx, IHqlExpression * expr, CH
     IIdAtom * func;
     OwnedHqlExpr str = getElementPointer(bound.expr);
     
-    bool hasAll = expr->hasProperty(allAtom);
-    bool hasLeft = expr->hasProperty(leftAtom);
-    bool hasRight = expr->hasProperty(rightAtom);
+    bool hasAll = expr->hasAttribute(allAtom);
+    bool hasLeft = expr->hasAttribute(leftAtom);
+    bool hasRight = expr->hasAttribute(rightAtom);
     
     type_t btc = bound.expr->queryType()->getTypeCode();
     if(hasAll || hasLeft) 
@@ -11287,7 +11287,7 @@ void HqlCppTranslator::expandFunctionPrototype(BuildCtx & ctx, IHqlExpression *
     {
         s.append(";");
         IHqlExpression *body = funcdef->queryChild(0);
-        IHqlExpression *namespaceAttr = body->queryProperty(namespaceAtom);
+        IHqlExpression *namespaceAttr = body->queryAttribute(namespaceAtom);
         if (namespaceAttr)
         {
             StringBuffer ns;
@@ -11351,7 +11351,7 @@ static IHqlExpression *createActualFromFormal(IHqlExpression *param)
 static IHqlExpression * replaceInlineParameters(IHqlExpression * funcdef, IHqlExpression * expr)
 {
     IHqlExpression * body = funcdef->queryChild(0);
-    assertex(!body->hasProperty(oldSetFormatAtom));
+    assertex(!body->hasAttribute(oldSetFormatAtom));
     IHqlExpression * formals = funcdef->queryChild(1);
 
     HqlMapTransformer simpleTransformer;
@@ -11459,8 +11459,8 @@ void HqlCppTranslator::buildScriptFunctionDefinition(BuildCtx &funcctx, IHqlExpr
     IHqlExpression * outofline = funcdef->queryChild(0);
     assertex(outofline->getOperator() == no_outofline);
     IHqlExpression * bodyCode = outofline->queryChild(0);
-    IHqlExpression *language = queryPropertyChild(bodyCode, languageAtom, 0);
-    bool isImport = bodyCode->hasProperty(importAtom);
+    IHqlExpression *language = queryAttributeChild(bodyCode, languageAtom, 0);
+    bool isImport = bodyCode->hasAttribute(importAtom);
 
     funcctx.addQuotedCompound(proto);
 
@@ -11626,7 +11626,7 @@ void HqlCppTranslator::buildFunctionDefinition(IHqlExpression * funcdef)
         if (!allowEmbeddedCpp())
             throwError(HQLERR_EmbeddedCppNotAllowed);
 
-        IHqlExpression *languageAttr = bodyCode->queryProperty(languageAtom);
+        IHqlExpression *languageAttr = bodyCode->queryAttribute(languageAtom);
         if (languageAttr)
             buildScriptFunctionDefinition(funcctx, funcdef, proto);
         else
@@ -11637,7 +11637,7 @@ void HqlCppTranslator::buildFunctionDefinition(IHqlExpression * funcdef)
         funcctx.addQuotedCompound(proto);
         //MORE: Need to work out how to handle functions that require the context.
         //Need to create a class instead.
-        assertex(!outofline->hasProperty(contextAtom));
+        assertex(!outofline->hasAttribute(contextAtom));
 
         OwnedHqlExpr newCode = replaceInlineParameters(funcdef, bodyCode);
         newCode.setown(foldHqlExpression(newCode));
@@ -11989,7 +11989,7 @@ bool HqlCppTranslator::requiresTemp(BuildCtx & ctx, IHqlExpression * expr, bool
             return true;
         }
     case no_select:
-        if (expr->hasProperty(newAtom))
+        if (expr->hasAttribute(newAtom))
         {
             IHqlExpression * ds= expr->queryChild(0);
             if (!ds->isPure() || !ds->isDatarow())
@@ -12019,7 +12019,7 @@ bool HqlCppTranslator::requiresTemp(BuildCtx & ctx, IHqlExpression * expr, bool
     case no_substring:
         {
             SubStringInfo info(expr);
-            if (!info.canGenerateInline() && !expr->hasProperty(quickAtom))
+            if (!info.canGenerateInline() && !expr->hasAttribute(quickAtom))
                 return true;
             break;
         }

ecl/hqlcpp/hqlcppds.cpp

@@ -355,7 +355,7 @@ IReferenceSelector * HqlCppTranslator::doBuildRowFromXML(BuildCtx & ctx, IHqlExp
     args.append(*createRowAllocator(ctx, record));
     args.append(*ensureExprType(expr->queryChild(1), utf8Type));
     args.append(*createQuoted(xmlInstanceName, makeBoolType()));
-    args.append(*createConstant(expr->hasProperty(trimAtom)));
+    args.append(*createConstant(expr->hasAttribute(trimAtom)));
     OwnedHqlExpr function = bindFunctionCall(createRowFromXmlId, args, overrideType);
 
     CHqlBoundExpr bound;
@@ -473,8 +473,8 @@ IReferenceSelector * HqlCppTranslator::buildNewRow(BuildCtx & ctx, IHqlExpressio
     case no_getresult:
         {
             IAtom * serializeForm = diskAtom;  // What if we start using internal in the engines?
-            IHqlExpression * seqAttr = expr->queryProperty(sequenceAtom);
-            IHqlExpression * nameAttr = expr->queryProperty(namedAtom);
+            IHqlExpression * seqAttr = expr->queryAttribute(sequenceAtom);
+            IHqlExpression * nameAttr = expr->queryAttribute(namedAtom);
             IHqlExpression * record = expr->queryRecord();
             OwnedHqlExpr serializedRecord = getSerializedForm(record, serializeForm);
 
@@ -507,7 +507,7 @@ IReferenceSelector * HqlCppTranslator::buildNewRow(BuildCtx & ctx, IHqlExpressio
             }
 
             //We could associate the original expression to allow better cse for child datasets in transforms, but it doesn't actually improve any examples
-            //IHqlExpression * original = queryPropertyChild(expr, _original_Atom, 0);
+            //IHqlExpression * original = queryAttributeChild(expr, _original_Atom, 0);
             //if (original)
             //  bindRow(ctx, original, cursorExpr)->setResultAlias();
             break;//return createReferenceSelector(cursor);
@@ -975,7 +975,7 @@ bool HqlCppTranslator::canBuildOptimizedCount(BuildCtx & ctx, IHqlExpression * d
 
 void HqlCppTranslator::doBuildExprCount(BuildCtx & ctx, IHqlExpression * expr, CHqlBoundExpr & tgt)
 {
-    if (expr->hasProperty(keyedAtom))
+    if (expr->hasAttribute(keyedAtom))
         throwError(HQLERR_KeyedCountNonKeyable);
 
     IHqlExpression * dataset = expr->queryChild(0);
@@ -1688,7 +1688,7 @@ IHqlExpression * HqlCppTranslator::getResourcedChildGraph(BuildCtx & ctx, IHqlEx
         resourced.setown(resourceLoopGraph(*this, activeRows, resourced, targetClusterType, graphIdExpr, &numResults, insideChild));
     }
     else
-        resourced.setown(resourceNewChildGraph(*this, activeRows, resourced, targetClusterType, graphIdExpr, &numResults, childQuery->hasProperty(sequentialAtom)));
+        resourced.setown(resourceNewChildGraph(*this, activeRows, resourced, targetClusterType, graphIdExpr, &numResults, childQuery->hasAttribute(sequentialAtom)));
 
     DEBUG_TIMER("EclServer: resource graph", msTick()-time);
     checkNormalized(ctx, resourced);
@@ -1867,11 +1867,11 @@ IHqlExpression * HqlCppTranslator::forceInlineAssignDataset(BuildCtx & ctx, IHql
 
 IHqlExpression * createGetResultFromWorkunitDataset(IHqlExpression * expr)
 {
-    IHqlExpression * name = queryPropertyChild(expr, nameAtom, 0);
+    IHqlExpression * name = queryAttributeChild(expr, nameAtom, 0);
     if (name)
         name = createExprAttribute(namedAtom, LINK(name));
     assertex(expr->isDataset());
-    return createDataset(no_getresult, LINK(expr->queryRecord()), createComma(LINK(expr->queryProperty(sequenceAtom)), name));
+    return createDataset(no_getresult, LINK(expr->queryRecord()), createComma(LINK(expr->queryAttribute(sequenceAtom)), name));
 }
 
 void HqlCppTranslator::buildAssignSerializedDataset(BuildCtx & ctx, const CHqlBoundTarget & target, IHqlExpression * expr, IAtom * serializeForm)
@@ -2044,7 +2044,7 @@ void HqlCppTranslator::doBuildDataset(BuildCtx & ctx, IHqlExpression * expr, CHq
     switch (op)
     {
     case no_dataset_alias:
-        if (!expr->hasProperty(_normalized_Atom))
+        if (!expr->hasAttribute(_normalized_Atom))
         {
             OwnedHqlExpr uniqueChild = normalizeDatasetAlias(expr);
             doBuildDataset(ctx, uniqueChild, tgt, format);
@@ -2127,7 +2127,7 @@ void HqlCppTranslator::doBuildDataset(BuildCtx & ctx, IHqlExpression * expr, CHq
             return;
         }
     case no_limit:
-        if (expr->hasProperty(skipAtom) || expr->hasProperty(onFailAtom))
+        if (expr->hasAttribute(skipAtom) || expr->hasAttribute(onFailAtom))
             break;
         doBuildDatasetLimit(ctx, expr, tgt, format);
         return;
@@ -2570,7 +2570,7 @@ void HqlCppTranslator::buildDatasetAssign(BuildCtx & ctx, const CHqlBoundTarget
     switch (op)
     {
     case no_limit:
-        assertex(!expr->hasProperty(skipAtom) && !expr->hasProperty(onFailAtom));
+        assertex(!expr->hasAttribute(skipAtom) && !expr->hasAttribute(onFailAtom));
         //Do the limit check as a post test.  
         //It means we may read more records than we need to, but the code is inline, and the code is generally much better.
         if (target.count)
@@ -3144,7 +3144,7 @@ void HqlCppTranslator::buildDatasetAssignDatasetFromTransform(BuildCtx & ctx, IH
         return;
 
     IHqlExpression * transform = expr->queryChild(1);
-    IHqlExpression * counter = queryPropertyChild(expr, _countProject_Atom, 0);
+    IHqlExpression * counter = queryAttributeChild(expr, _countProject_Atom, 0);
 
     // If it is at all possible that it could be negative, we must test before producing rows
     CHqlBoundExpr boundCount;
@@ -3191,7 +3191,7 @@ void HqlCppTranslator::buildDatasetAssignProject(BuildCtx & ctx, IHqlCppDatasetB
 {
     BuildCtx iterctx(ctx);
     IHqlExpression * ds = expr->queryChild(0);
-    IHqlExpression * counter = queryPropertyChild(expr, _countProject_Atom, 0);
+    IHqlExpression * counter = queryAttributeChild(expr, _countProject_Atom, 0);
 
     OwnedHqlExpr counterVar;
     if (counter)
@@ -3247,7 +3247,7 @@ void HqlCppTranslator::buildDatasetAssignJoin(BuildCtx & ctx, IHqlCppDatasetBuil
     IHqlExpression * cond = expr->queryChild(2);
 
     IHqlExpression * selSeq = querySelSeq(expr);
-    bool leftOuter = expr->hasProperty(leftonlyAtom) || expr->hasProperty(leftouterAtom);
+    bool leftOuter = expr->hasAttribute(leftonlyAtom) || expr->hasAttribute(leftouterAtom);
 
     CHqlBoundExpr nullRhs;
     if (leftOuter)
@@ -3267,7 +3267,7 @@ void HqlCppTranslator::buildDatasetAssignJoin(BuildCtx & ctx, IHqlCppDatasetBuil
 
     OwnedHqlExpr cseCond = options.spotCSE ? spotScalarCSE(cond) : LINK(cond);
     buildFilter(rightIterCtx, cseCond);
-    if (!expr->hasProperty(leftonlyAtom))
+    if (!expr->hasAttribute(leftonlyAtom))
     {
         BoundRow * targetRow = target->buildCreateRow(rightIterCtx);
         Owned<IReferenceSelector> targetRef = buildActiveRow(rightIterCtx, targetRow->querySelector());
@@ -3686,7 +3686,7 @@ BoundRow * HqlCppTranslator::buildDatasetIterateProject(BuildCtx & ctx, IHqlExpr
 {
     IHqlExpression * dataset = expr->queryChild(0);
     OwnedHqlExpr counterVar;
-    IHqlExpression * counter = queryPropertyChild(expr, _countProject_Atom, 0);
+    IHqlExpression * counter = queryAttributeChild(expr, _countProject_Atom, 0);
     if (counter)
     {
         counterVar.setown(ctx.getTempDeclare(unsignedType, queryZero()));
@@ -3838,7 +3838,7 @@ BoundRow * HqlCppTranslator::buildDatasetIterate(BuildCtx & ctx, IHqlExpression
     switch (expr->getOperator())
     {
     case no_dataset_alias:
-        if (!expr->hasProperty(_normalized_Atom))
+        if (!expr->hasAttribute(_normalized_Atom))
         {
             OwnedHqlExpr uniqueChild = normalizeDatasetAlias(expr);
             BoundRow * childCursor = buildDatasetIterate(ctx, uniqueChild, needToBreak);
@@ -4231,7 +4231,7 @@ void HqlCppTranslator::doBuildRowAssignAggregate(BuildCtx & ctx, IReferenceSelec
 void HqlCppTranslator::doBuildRowAssignProject(BuildCtx & ctx, IReferenceSelector * target, IHqlExpression * expr)
 {
     IHqlExpression * dataset = expr->queryChild(0);
-    IHqlExpression * counter = queryPropertyChild(expr, _countProject_Atom, 0);
+    IHqlExpression * counter = queryAttributeChild(expr, _countProject_Atom, 0);
     if (counter && !ctx.queryMatchExpr(counter))
         throwError(HQLERR_CounterNotFound);
 
@@ -4628,7 +4628,7 @@ IHqlExpression * HqlCppTranslator::ensureIteratedRowIsLive(BuildCtx & initctx, B
         case no_select:
             if (ds->isDataset())
             {
-                if (ds->hasProperty(newAtom))
+                if (ds->hasAttribute(newAtom))
                 {
                     ds = ds->queryChild(0);
                     //don't walk complexds[1].childDataset<new> since the [1] will be generated as a temporary
@@ -4698,7 +4698,7 @@ IReferenceSelector * HqlCppTranslator::buildDatasetIndexViaIterator(BuildCtx & c
     case no_hqlproject:
         //optimize selectnth(project(rows, t), n) to projectrow(selectnth(rows, n), t)
         IHqlExpression * transform = dataset->queryChild(1);
-        if (!containsSkip(transform) && !expr->hasProperty(_countProject_Atom))
+        if (!containsSkip(transform) && !expr->hasAttribute(_countProject_Atom))
             childDataset = dataset->queryChild(0);
         break;
     }
@@ -4911,9 +4911,9 @@ IHqlExpression * HqlCppTranslator::buildGetLocalResult(BuildCtx & ctx, IHqlExpre
     if (!hasLinkCountedModifier(exprType))
         exprType.setown(makeAttributeModifier(LINK(exprType), getLinkCountedAttr()));
 
-    if (expr->hasProperty(externalAtom))
+    if (expr->hasAttribute(externalAtom))
     {
-        IHqlExpression * resultInstance = queryPropertyChild(expr, externalAtom, 0);
+        IHqlExpression * resultInstance = queryAttributeChild(expr, externalAtom, 0);
         HqlExprAssociation * matchedResults = ctx.queryMatchExpr(resultInstance);
         if (!matchedResults)
         {
@@ -4957,10 +4957,10 @@ IHqlExpression * HqlCppTranslator::buildGetLocalResult(BuildCtx & ctx, IHqlExpre
 
 void HqlCppTranslator::doBuildAssignGetGraphResult(BuildCtx & ctx, const CHqlBoundTarget & target, IHqlExpression * expr)
 {
-    if (expr->hasProperty(_streaming_Atom))
+    if (expr->hasAttribute(_streaming_Atom))
         throwError(HQLERR_LoopTooComplexForParallel);
 
-    if (expr->hasProperty(externalAtom))
+    if (expr->hasAttribute(externalAtom))
     {
         OwnedHqlExpr call = buildGetLocalResult(ctx, expr);
         buildExprAssign(ctx, target, call);
@@ -4984,7 +4984,7 @@ void HqlCppTranslator::doBuildAssignGetGraphResult(BuildCtx & ctx, const CHqlBou
 
 void HqlCppTranslator::doBuildExprGetGraphResult(BuildCtx & ctx, IHqlExpression * expr, CHqlBoundExpr & tgt, ExpressionFormat format)
 {
-    if (!expr->hasProperty(externalAtom))
+    if (!expr->hasAttribute(externalAtom))
     {
         doBuildAliasValue(ctx, expr, tgt);
         return;
@@ -5018,13 +5018,13 @@ ABoundActivity * HqlCppTranslator::doBuildActivityGetGraphResult(BuildCtx & ctx,
 {
     IHqlExpression * graphId = expr->queryChild(1);
     IHqlExpression * resultNum = expr->queryChild(2);
-    ThorActivityKind activityKind = (expr->hasProperty(_streaming_Atom) ? TAKlocalstreamread : TAKlocalresultread);
+    ThorActivityKind activityKind = (expr->hasAttribute(_streaming_Atom) ? TAKlocalstreamread : TAKlocalresultread);
 
     bool useImplementationClass = options.minimizeActivityClasses && (resultNum->getOperator() == no_constant);
     Owned<ActivityInstance> instance = new ActivityInstance(*this, ctx, activityKind, expr, "LocalResultRead");
     if (useImplementationClass)
         instance->setImplementationClass(newLocalResultReadArgId);
-    if (expr->hasProperty(_loop_Atom))
+    if (expr->hasAttribute(_loop_Atom))
     {
         if (isCurrentActiveGraph(ctx, graphId))
             instance->graphLabel.set("Begin Loop");
@@ -5053,7 +5053,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivitySetGraphDictionaryResult(Build
     IHqlExpression * dataset = dictionary->queryChild(0);
     IHqlExpression * graphId = expr->queryChild(1);
     IHqlExpression * resultNum = expr->queryChild(2);
-    bool isSpill = expr->hasProperty(_spill_Atom);
+    bool isSpill = expr->hasAttribute(_spill_Atom);
 
     ABoundActivity * parentActivity = activeActivities.ordinality() ? &activeActivities.tos() : NULL;
     Owned<ABoundActivity> boundDataset = buildCachedActivity(ctx, dataset);
@@ -5094,7 +5094,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivitySetGraphResult(BuildCtx & ctx,
 
     IHqlExpression * graphId = expr->queryChild(1);
     IHqlExpression * resultNum = expr->queryChild(2);
-    bool isSpill = expr->hasProperty(_spill_Atom);
+    bool isSpill = expr->hasAttribute(_spill_Atom);
 
     ABoundActivity * parentActivity = activeActivities.ordinality() ? &activeActivities.tos() : NULL;
     Owned<ABoundActivity> boundDataset = buildCachedActivity(ctx, dataset);
@@ -5113,7 +5113,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivitySetGraphResult(BuildCtx & ctx,
     if (useImplementationClass)
         instance->setImplementationClass(newLocalResultSpillArgId);
 
-    if (expr->hasProperty(_loop_Atom))
+    if (expr->hasAttribute(_loop_Atom))
         instance->graphLabel.set("End Loop");
     buildActivityFramework(instance, isRoot && !isSpill);
 
@@ -5133,7 +5133,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivitySetGraphResult(BuildCtx & ctx,
     if (parentActivity && !insideRemoteGraph(ctx) && !isSpill)
     {
         const char * relationship;
-        if (expr->hasProperty(_loop_Atom))
+        if (expr->hasAttribute(_loop_Atom))
             relationship = "Body";
         else if (insideRemoteGraph(ctx))
             relationship = "Remote";
@@ -5231,7 +5231,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivitySetGraphLoopResult(BuildCtx &
 {
     IHqlExpression * dataset = expr->queryChild(0);
     IHqlExpression * graphId = expr->queryChild(1);
-    bool isSpill = expr->hasProperty(_spill_Atom);
+    bool isSpill = expr->hasAttribute(_spill_Atom);
 
     ABoundActivity * parentActivity = activeActivities.ordinality() ? &activeActivities.tos() : NULL;
     Owned<ABoundActivity> boundDataset = buildCachedActivity(ctx, dataset);
@@ -5312,8 +5312,8 @@ ABoundActivity * HqlCppTranslator::doBuildActivityForceLocal(BuildCtx & ctx, IHq
 void HqlCppTranslator::doBuildStmtApply(BuildCtx & ctx, IHqlExpression * expr)
 {
     IHqlExpression * dataset = expr->queryChild(0);
-    IHqlExpression * start = expr->queryProperty(beforeAtom);
-    IHqlExpression * end = expr->queryProperty(afterAtom);
+    IHqlExpression * start = expr->queryAttribute(beforeAtom);
+    IHqlExpression * end = expr->queryAttribute(afterAtom);
 
     if (start)
         buildStmt(ctx, start->queryChild(0));

ecl/hqlcpp/hqlcpputil.cpp

@@ -435,7 +435,7 @@ IHqlExpression * mapInternalFunctionParameters(IHqlExpression * expr)
             case type_unicode:
             case type_utf8:
             case type_varunicode:
-                if (!expr->hasProperty(constAtom))
+                if (!expr->hasAttribute(constAtom))
                     return appendOwnedOperand(expr, createAttribute(constAtom));
                 break;
             }

ecl/hqlcpp/hqlcse.cpp

@@ -769,7 +769,7 @@ void CseScopeTransformer::analyseExpr(IHqlExpression * expr)
     //Add here so the cse are in the correct order to cope with dependencies...
     if (op == no_alias)
     {
-        assertex(!expr->hasProperty(globalAtom));
+        assertex(!expr->hasAttribute(globalAtom));
         allCSEs.append(*LINK(splitter));
     }
 }
@@ -996,7 +996,7 @@ void CseScopeTransformer::analyseExpr(IHqlExpression * expr)
     node_operator op = expr->getOperator();
     if (op == no_alias)
     {
-        assertex(!expr->hasProperty(globalAtom));
+        assertex(!expr->hasAttribute(globalAtom));
 
         CseScopeInfo * splitter = queryExtra(expr);
 
@@ -1220,7 +1220,7 @@ static bool canHoistInvariant(IHqlExpression * expr)
 {
     if (!canCreateTemporary(expr))
     {
-        if ((expr->getOperator() != no_alias) || expr->hasProperty(globalAtom))
+        if ((expr->getOperator() != no_alias) || expr->hasAttribute(globalAtom))
             return false;
     }
     if (!expr->isPure())
@@ -1283,7 +1283,7 @@ bool TableInvariantTransformer::isInvariant(IHqlExpression * expr)
             if (!expr->isDataset())
             {
                 IHqlExpression * ds = expr->queryChild(0);
-                if (expr->hasProperty(newAtom) || ds->isDatarow())
+                if (expr->hasAttribute(newAtom) || ds->isDatarow())
                     invariant = isInvariant(ds);
             }
             break;
@@ -1357,7 +1357,7 @@ void TableInvariantTransformer::analyseExpr(IHqlExpression * expr)
         TableInvariantInfo * extra = queryBodyExtra(expr);
         if (op == no_alias)
         {
-            if (!expr->hasProperty(globalAtom))
+            if (!expr->hasAttribute(globalAtom))
                 extra->createAlias = true;
         }
         else
@@ -1408,7 +1408,7 @@ void TableInvariantTransformer::analyseExpr(IHqlExpression * expr)
                     switch (op)
                     {
                     case no_alias:
-                        if (!expr->hasProperty(globalAtom))
+                        if (!expr->hasAttribute(globalAtom))
                             extra->createAlias = true;
                         return;
                     default:
@@ -1548,7 +1548,7 @@ void GlobalAliasTransformer::analyseExpr(IHqlExpression * expr)
     extra->numUses++;
     if (expr->getOperator() == no_alias)
     {
-        if (expr->hasProperty(globalAtom))
+        if (expr->hasAttribute(globalAtom))
         {
 //          assertex(!containsActiveDataset(expr) || isInlineTrivialDataset(expr));
             if (!insideGlobal)
@@ -1595,16 +1595,16 @@ IHqlExpression * GlobalAliasTransformer::createTransformed(IHqlExpression * expr
     if ((expr->getOperator() == no_alias))
     {
         GlobalAliasInfo * extra = queryBodyExtra(expr);
-        if (expr->hasProperty(globalAtom))
+        if (expr->hasAttribute(globalAtom))
         {
             if (!extra->isOuter)
             {
                 if (extra->numUses == 1)
                     return LINK(transformed->queryChild(0));
-                if (!expr->hasProperty(localAtom))
+                if (!expr->hasAttribute(localAtom))
                     return appendLocalAttribute(transformed);
             }
-            else if (expr->hasProperty(localAtom))
+            else if (expr->hasAttribute(localAtom))
             {
                 //Should never occur - but just about conceivable that some kind of constant folding
                 //might cause a surrounding global alias to be removed.
@@ -1613,7 +1613,7 @@ IHqlExpression * GlobalAliasTransformer::createTransformed(IHqlExpression * expr
         }
         else
         {
-            if ((extra->numUses == 1) && !expr->hasProperty(internalAtom))
+            if ((extra->numUses == 1) && !expr->hasAttribute(internalAtom))
                 return LINK(transformed->queryChild(0));
         }
     }

ecl/hqlcpp/hqlcset.cpp

@@ -50,7 +50,7 @@
 
 IHqlExpression * getOutOfRangeValue(IHqlExpression * indexExpr)
 {
-    IHqlExpression * dft = indexExpr->queryProperty(defaultAtom);
+    IHqlExpression * dft = indexExpr->queryAttribute(defaultAtom);
     if (dft)
         return LINK(dft->queryChild(0));
     else
@@ -158,7 +158,7 @@ BoundRow * BaseDatasetCursor::buildSelectNth(BuildCtx & ctx, IHqlExpression * in
     StringBuffer cursorName;
     buildIterateClass(ctx, cursorName, NULL);
 
-    bool conditional = !indexExpr->hasProperty(noBoundCheckAtom);
+    bool conditional = !indexExpr->hasAttribute(noBoundCheckAtom);
 
     //create a unique dataset and associate it with a call to select
     //set value to be the field selection from the dataset
@@ -365,7 +365,7 @@ BoundRow * InlineBlockDatasetCursor::buildIterateLoop(BuildCtx & ctx, bool needT
 BoundRow * InlineBlockDatasetCursor::buildSelectFirst(BuildCtx & ctx, IHqlExpression * indexExpr, bool createDefaultRowIfNull)
 {
     StringBuffer s, rowName;
-    bool conditional = !indexExpr->hasProperty(noBoundCheckAtom);
+    bool conditional = !indexExpr->hasAttribute(noBoundCheckAtom);
     OwnedHqlExpr row = createRow(ctx, "row", rowName, (conditional && createDefaultRowIfNull));
 
     BuildCtx subctx(ctx);
@@ -446,7 +446,7 @@ BoundRow * InlineBlockDatasetCursor::buildSelectNth(BuildCtx & ctx, IHqlExpressi
     if (matchesConstantValue(index, 1))
         return buildSelectFirst(ctx, indexExpr, CREATE_DEAULT_ROW_IF_NULL_VALUE);
 
-    bool conditional = !indexExpr->hasProperty(noBoundCheckAtom);
+    bool conditional = !indexExpr->hasAttribute(noBoundCheckAtom);
     //row = NULL
     StringBuffer s, rowName;
     OwnedHqlExpr row = createRow(ctx, "row", rowName, (conditional && CREATE_DEAULT_ROW_IF_NULL_VALUE));
@@ -635,7 +635,7 @@ BoundRow * InlineLinkedDatasetCursor::buildSelectNth(BuildCtx & ctx, IHqlExpress
 {
     OwnedHqlExpr index = foldHqlExpression(indexExpr->queryChild(1));
 
-    bool conditional = !indexExpr->hasProperty(noBoundCheckAtom);
+    bool conditional = !indexExpr->hasAttribute(noBoundCheckAtom);
 
     //row = NULL
     StringBuffer s, rowName;
@@ -1075,13 +1075,13 @@ void ListSetCursor::gatherSelect(BuildCtx & ctx, IHqlExpression * indexExpr, CHq
         CHqlBoundExpr boundIndex;
         ITypeInfo * elementType = expr->queryType()->queryChildType();  // not indexExpr->getType() because may now be more specific
         OwnedHqlExpr base0Index = adjustIndexBaseToZero(index);
-        if (indexExpr->hasProperty(noBoundCheckAtom))
+        if (indexExpr->hasAttribute(noBoundCheckAtom))
             translator.buildExpr(ctx, base0Index, boundIndex);
         else
             translator.buildSimpleExpr(ctx, base0Index, boundIndex);
         value.expr.setown(createValue(no_index, LINK(elementType), LINK(boundList.expr), LINK(boundIndex.expr)));
 
-        if (!indexExpr->hasProperty(noBoundCheckAtom))
+        if (!indexExpr->hasAttribute(noBoundCheckAtom))
         {
             ITypeInfo * indexType = boundIndex.expr->queryType();
             //ok to subtract early and remove a check for > 0 on unsigned values because they will wrap and fail upper limit test
@@ -1258,9 +1258,9 @@ IHqlExpression * GeneralSetCursor::createDatasetSelect(IHqlExpression * indexExp
 
 void GeneralSetCursor::buildExprSelect(BuildCtx & ctx, IHqlExpression * indexExpr, CHqlBoundExpr & tgt)
 {
-    if (indexExpr->hasProperty(noBoundCheckAtom))
+    if (indexExpr->hasAttribute(noBoundCheckAtom))
     {
-        if (indexExpr->hasProperty(forceAllCheckAtom))
+        if (indexExpr->hasAttribute(forceAllCheckAtom))
             checkNotAll(ctx);
 
         OwnedHqlExpr dsIndexExpr = createDatasetSelect(indexExpr);
@@ -1278,7 +1278,7 @@ void GeneralSetCursor::buildExprSelect(BuildCtx & ctx, IHqlExpression * indexExp
 
 void GeneralSetCursor::buildAssignSelect(BuildCtx & ctx, const CHqlBoundTarget & target, IHqlExpression * indexExpr)
 {
-    if (!indexExpr->hasProperty(noBoundCheckAtom) || indexExpr->hasProperty(forceAllCheckAtom))
+    if (!indexExpr->hasAttribute(noBoundCheckAtom) || indexExpr->hasAttribute(forceAllCheckAtom))
         checkNotAll(ctx);
 
     OwnedHqlExpr dsIndexExpr = createDatasetSelect(indexExpr);

ecl/hqlcpp/hqlgraph.cpp

@@ -647,9 +647,9 @@ const char * LogicalGraphCreator::getActivityText(IHqlExpression * expr, StringB
             if (filename)
             {
                 temp.append("Output");
-                if (expr->hasProperty(xmlAtom))
+                if (expr->hasAttribute(xmlAtom))
                     temp.append(" XML");
-                else if (expr->hasProperty(csvAtom))
+                else if (expr->hasAttribute(csvAtom))
                     temp.append(" CSV");
                 queryExpandFilename(temp, filename);
             }
@@ -688,8 +688,8 @@ const char * LogicalGraphCreator::getActivityText(IHqlExpression * expr, StringB
     case no_extractresult:
     case no_setresult:
         {
-            IHqlExpression * sequence = queryPropertyChild(expr, sequenceAtom, 0);
-            IHqlExpression * name = queryPropertyChild(expr, namedAtom, 0);
+            IHqlExpression * sequence = queryAttributeChild(expr, sequenceAtom, 0);
+            IHqlExpression * name = queryAttributeChild(expr, namedAtom, 0);
             temp.append("Store\n");
             getStoredDescription(temp, sequence, name, true);
             break;

ecl/hqlcpp/hqlinline.cpp

@@ -134,7 +134,7 @@ static unsigned calcInlineFlags(BuildCtx * ctx, IHqlExpression * expr)
             return 0;
     case no_newusertable:
         {
-            if (expr->hasProperty(prefetchAtom))
+            if (expr->hasAttribute(prefetchAtom))
                 return 0;
             IHqlExpression * ds = expr->queryChild(0);
             unsigned childFlags = getInlineFlags(ctx, ds);
@@ -197,7 +197,7 @@ static unsigned calcInlineFlags(BuildCtx * ctx, IHqlExpression * expr)
         }
     case no_limit:
         {
-            if (expr->hasProperty(skipAtom) || expr->hasProperty(onFailAtom))
+            if (expr->hasAttribute(skipAtom) || expr->hasAttribute(onFailAtom))
                 return 0;
             unsigned childFlags = getInlineFlags(ctx, expr->queryChild(0));
             if (childFlags == 0)
@@ -278,7 +278,7 @@ static unsigned calcInlineFlags(BuildCtx * ctx, IHqlExpression * expr)
     case no_forcegraph:
         return 0;
     case no_section:
-        if (expr->hasProperty(graphAtom))       // force it to appear in the graph
+        if (expr->hasAttribute(graphAtom))       // force it to appear in the graph
             return 0;
         return getInlineFlags(ctx, expr->queryChild(0));
     case no_call:               
@@ -286,7 +286,7 @@ static unsigned calcInlineFlags(BuildCtx * ctx, IHqlExpression * expr)
     case no_getresult:
         return expr->isDatarow() ? RETevaluate : RETassign;
     case no_getgraphresult:
-        if (expr->hasProperty(_distributed_Atom))
+        if (expr->hasAttribute(_distributed_Atom))
             return 0;
         return expr->isDatarow() ? RETevaluate : RETassign;
     case no_temptable:
@@ -295,7 +295,7 @@ static unsigned calcInlineFlags(BuildCtx * ctx, IHqlExpression * expr)
         return RETiterate;
     case no_dataset_from_transform:
     {
-        if (expr->hasProperty(distributedAtom))
+        if (expr->hasAttribute(distributedAtom))
             return 0;
         if (transformContainsSkip(expr->queryChild(1)))
             return 0;
@@ -344,7 +344,7 @@ static unsigned calcInlineFlags(BuildCtx * ctx, IHqlExpression * expr)
         return RETassign;
     case no_join:
         {
-            if (!expr->hasProperty(allAtom) || isKeyedJoin(expr))
+            if (!expr->hasAttribute(allAtom) || isKeyedJoin(expr))
                 return 0;
             //conservatively check we support the attributes.
             unsigned max = expr->numChildren();
@@ -539,7 +539,7 @@ GraphLocalisation queryActivityLocalisation(IHqlExpression * expr)
     {
     case no_compound_diskread:
         {
-            if (isLocalActivity(expr) || expr->hasProperty(_colocal_Atom))
+            if (isLocalActivity(expr) || expr->hasAttribute(_colocal_Atom))
                 return GraphCoLocal;
             //If a compound operation has been added, but with no other effect then don't allow that to change the localisation
             IHqlExpression * ds = expr->queryChild(0);
@@ -548,7 +548,7 @@ GraphLocalisation queryActivityLocalisation(IHqlExpression * expr)
             return GraphNonLocal;
         }
     case no_table:
-        if (expr->hasProperty(_noAccess_Atom))
+        if (expr->hasAttribute(_noAccess_Atom))
             return GraphNoAccess;
         //fallthrough
     case no_keyindex:
@@ -562,7 +562,7 @@ GraphLocalisation queryActivityLocalisation(IHqlExpression * expr)
     case no_compound_indexaggregate:
     case no_compound_indexcount:
     case no_compound_indexgroupaggregate:
-        if (!isLocalActivity(expr) && !expr->hasProperty(_colocal_Atom))
+        if (!isLocalActivity(expr) && !expr->hasAttribute(_colocal_Atom))
             return GraphNonLocal;
         break;
     case no_compound_fetch:
@@ -574,11 +574,11 @@ GraphLocalisation queryActivityLocalisation(IHqlExpression * expr)
     case no_join:
     case no_denormalize:
     case no_denormalizegroup:
-        if (isKeyedJoin(expr) && !expr->hasProperty(localAtom))
+        if (isKeyedJoin(expr) && !expr->hasAttribute(localAtom))
             return GraphNonLocal;
         break;
     case no_output:
-        if (expr->hasProperty(_spill_Atom))
+        if (expr->hasAttribute(_spill_Atom))
             return GraphNoAccess;
         break;
     case no_setgraphresult:
@@ -1114,10 +1114,10 @@ void ParentExtract::gatherActiveRows(BuildCtx & ctx)
             switch(represents->getOperator())
             {
             case no_null:
-                ok = !represents->hasProperty(clearAtom);           // Don't serialize rows used as default clear rows
+                ok = !represents->hasAttribute(clearAtom);           // Don't serialize rows used as default clear rows
                 break;
             case no_anon:
-                ok = !represents->hasProperty(selfAtom);
+                ok = !represents->hasAttribute(selfAtom);
                 break;
             default:
                 if (cur.isResultAlias())

ecl/hqlcpp/hqliproj.cpp

@@ -825,15 +825,15 @@ static unsigned getActivityCost(IHqlExpression * expr, ClusterType targetCluster
             {
             case no_sort:
                 //MORE: What about checking for grouped!
-                if (!expr->hasProperty(localAtom))
+                if (!expr->hasAttribute(localAtom))
                     return CostNetworkCopy;
                 return CostManyCopy;
             case no_subsort:
-                if (!expr->hasProperty(localAtom) && !isGrouped(expr))
+                if (!expr->hasAttribute(localAtom) && !isGrouped(expr))
                     return CostNetworkCopy;
                 break;
             case no_group:
-                if (!expr->hasProperty(localAtom))
+                if (!expr->hasAttribute(localAtom))
                     return CostNetworkGroup;
                 break;
             case no_keyeddistribute:
@@ -841,22 +841,22 @@ static unsigned getActivityCost(IHqlExpression * expr, ClusterType targetCluster
             case no_cosort:
                 return CostNetworkCopy;
             case no_topn:
-                if (!expr->hasProperty(localAtom))
+                if (!expr->hasAttribute(localAtom))
                     return CostGlobalTopN;
                 break;
             case no_selfjoin:
-                if (!expr->hasProperty(localAtom))
+                if (!expr->hasAttribute(localAtom))
                     return CostNetworkCopy;
                 break;
             case no_denormalize:
             case no_denormalizegroup:
             case no_join:
             case no_joincount:
-                if (!expr->hasProperty(localAtom))
+                if (!expr->hasAttribute(localAtom))
                 {
                     if (isKeyedJoin(expr))
                         break;
-                    if (expr->hasProperty(lookupAtom))
+                    if (expr->hasAttribute(lookupAtom))
                         return CostNetworkCopy/2;       //insert on rhs.
                     return CostNetworkCopy;
                 }
@@ -892,9 +892,9 @@ bool isSensibleRecord(IHqlExpression * record)
             case type_groupedtable:
                 {
                     //disqualify datasets with no_selfref counts/lengths
-                    IHqlExpression * limit = cur->queryProperty(countAtom);
+                    IHqlExpression * limit = cur->queryAttribute(countAtom);
                     if (!limit)
-                        limit = cur->queryProperty(sizeAtom);
+                        limit = cur->queryAttribute(sizeAtom);
                     if (limit && !limit->isConstant())
                         return false;
                     break;
@@ -911,7 +911,7 @@ IHqlExpression * queryRootSelector(IHqlExpression * select)
 {
     loop
     {
-        if (select->hasProperty(newAtom))
+        if (select->hasAttribute(newAtom))
             return select;
         IHqlExpression * ds = select->queryChild(0);
         if (ds->getOperator() != no_select)
@@ -1018,7 +1018,7 @@ void ImplicitProjectInfo::removeRowsFields(IHqlExpression * expr, IHqlExpression
     if (rowsSide == no_none)
         return;
 
-    IHqlExpression * rowsid = expr->queryProperty(_rowsid_Atom);
+    IHqlExpression * rowsid = expr->queryAttribute(_rowsid_Atom);
     switch (rowsSide)
     {
     case no_left:
@@ -1346,7 +1346,7 @@ void ImplicitProjectTransformer::analyseExpr(IHqlExpression * expr)
             {
                 Parent::analyseExpr(expr);
                 assertex(extra->activityKind() == ScalarSelectActivity);
-                if (expr->hasProperty(newAtom))
+                if (expr->hasAttribute(newAtom))
                     connect(expr->queryChild(0), expr);
                 activities.append(*LINK(expr));
             }
@@ -1680,7 +1680,7 @@ void ImplicitProjectTransformer::gatherFieldsUsed(IHqlExpression * expr, Implici
                 loop
                 {
                     IHqlExpression * ds = cur->queryChild(0);
-                    if (cur->hasProperty(newAtom))
+                    if (cur->hasAttribute(newAtom))
                     {
                         inheritActiveFields(extra, ds);
                         break;
@@ -2020,12 +2020,12 @@ ProjectExprKind ImplicitProjectTransformer::getProjectExprKind(IHqlExpression *
         {
         case no_thor:
         case no_flat:
-            if (expr->hasProperty(_spill_Atom) && options.isRoxie)
+            if (expr->hasAttribute(_spill_Atom) && options.isRoxie)
                 return SourceActivity;
             if (options.optimizeProjectsPreservePersists)
             {
                 //Don't project persists because it can mess up the redistibution code.
-                if (expr->hasProperty(_workflowPersist_Atom))
+                if (expr->hasAttribute(_workflowPersist_Atom))
                     return SourceActivity;
             }
             return CompoundableActivity;
@@ -2048,7 +2048,7 @@ ProjectExprKind ImplicitProjectTransformer::getProjectExprKind(IHqlExpression *
             {
                 //Don't project persists because it can mess up the redistibution code.
                 IHqlExpression * root = queryRoot(expr);
-                if (root && root->hasProperty(_workflowPersist_Atom))
+                if (root && root->hasAttribute(_workflowPersist_Atom))
                     return SourceActivity;
             }
             return CompoundActivity;
@@ -2106,7 +2106,7 @@ ProjectExprKind ImplicitProjectTransformer::getProjectExprKind(IHqlExpression *
     case no_normalizegroup:
         return FixedInputActivity;
     case no_aggregate:
-        if (expr->hasProperty(mergeTransformAtom))
+        if (expr->hasAttribute(mergeTransformAtom))
             return FixedInputActivity;
         return FixedInputActivity;  //MORE:???? Should be able to optimize this
     case no_fromxml:                // A bit bit like a source activity, no transform..., but has an input
@@ -2421,7 +2421,7 @@ void ImplicitProjectTransformer::calculateFieldsUsed(IHqlExpression * expr)
         if (extra->okToOptimize())
         {
             node_operator op = expr->getOperator();
-            if ((op == no_if) && expr->hasProperty(_resourced_Atom))
+            if ((op == no_if) && expr->hasAttribute(_resourced_Atom))
             {
                 extra->preventOptimization();
                 extra->addAllOutputs();
@@ -2429,7 +2429,7 @@ void ImplicitProjectTransformer::calculateFieldsUsed(IHqlExpression * expr)
             else if (op == no_merge)
             {
                 //Ensure all the fields used by the sort order are preserved in the input streams
-                IHqlExpression * order = expr->queryProperty(sortedAtom);
+                IHqlExpression * order = expr->queryAttribute(sortedAtom);
                 assertex(order);
                 ForEachChild(i, order)
                 {
@@ -2780,7 +2780,7 @@ IHqlExpression * ImplicitProjectTransformer::createTransformed(IHqlExpression *
                 args.replace(*newTransform, transformPos);
                 if (transform->getOperator() == no_newtransform)
                     args.replace(*LINK(complexExtra->queryOutputRecord()), transformPos-1);
-                IHqlExpression * onFail = queryProperty(onFailAtom, args);
+                IHqlExpression * onFail = queryAttribute(onFailAtom, args);
                 if (onFail)
                 {
                     IHqlExpression * newTransform = complexExtra->outputFields.createFilteredTransform(onFail->queryChild(0), NULL);
@@ -2791,7 +2791,7 @@ IHqlExpression * ImplicitProjectTransformer::createTransformed(IHqlExpression *
                 //We may have converted a count project into a project..... (see bug18839.xhql)
                 if (expr->getOperator() == no_hqlproject)
                 {
-                    IHqlExpression * countProjectAttr = queryProperty(_countProject_Atom, args);
+                    IHqlExpression * countProjectAttr = queryAttribute(_countProject_Atom, args);
                     if (countProjectAttr && !transformContainsCounter(newTransform, countProjectAttr->queryChild(0)))
                         args.zap(*countProjectAttr);
                 }
@@ -2922,7 +2922,7 @@ IHqlExpression * ImplicitProjectTransformer::createTransformed(IHqlExpression *
     case SimpleActivity:
         {
             transformed.setown(createParentTransformed(expr));
-            IHqlExpression * onFail = transformed->queryProperty(onFailAtom);
+            IHqlExpression * onFail = transformed->queryAttribute(onFailAtom);
             if (onFail)
             {
                 IHqlExpression * newTransform = complexExtra->outputFields.createFilteredTransform(onFail->queryChild(0), NULL);

ecl/hqlcpp/hqliter.cpp

@@ -199,7 +199,7 @@ IHqlExpression * gatherSelectorLevels(HqlExprArray & iterators, IHqlExpression *
         if (!root || root->getOperator() != no_select)
             return expr;
         iterators.add(*LINK(expr), 0);
-        if (!root->hasProperty(newAtom))
+        if (!root->hasAttribute(newAtom))
             return NULL;
         expr = root->queryChild(0);
     }

ecl/hqlcpp/hqllib.cpp

@@ -166,7 +166,7 @@ HqlCppLibraryInstance::HqlCppLibraryInstance(HqlCppTranslator & translator, IHql
     assertex(libraryFuncdef->getOperator() == no_funcdef);
     IHqlExpression * libraryScope = libraryFuncdef->queryChild(0);
     assertex(libraryScope->getOperator() == no_libraryscope);
-    IHqlExpression * libraryInterface = queryPropertyChild(libraryScope, implementsAtom, 0);
+    IHqlExpression * libraryInterface = queryAttributeChild(libraryScope, implementsAtom, 0);
     assertex(libraryInterface);
 
     library.setown(new HqlCppLibrary(translator, libraryInterface, clusterType));
@@ -198,7 +198,7 @@ public:
 
         IIdAtom * id = expr->queryChild(3)->queryId();
         HqlDummyLookupContext dummyctx(NULL);
-        OwnedHqlExpr value = newModule->queryScope()->lookupSymbol(id, makeLookupFlags(true, expr->hasProperty(ignoreBaseAtom), false), dummyctx);
+        OwnedHqlExpr value = newModule->queryScope()->lookupSymbol(id, makeLookupFlags(true, expr->hasAttribute(ignoreBaseAtom), false), dummyctx);
         assertex(value != NULL);
         IHqlExpression * oldAttr = expr->queryChild(2);
         if (oldAttr->isDataset() || oldAttr->isDatarow())
@@ -226,7 +226,7 @@ protected:
     {
         IHqlScope * oldScope = libraryExpr->queryScope();
         IHqlScope * lookupScope = oldScope;
-        IHqlExpression * interfaceExpr = queryPropertyChild(libraryExpr, implementsAtom, 0);
+        IHqlExpression * interfaceExpr = queryAttributeChild(libraryExpr, implementsAtom, 0);
         if (interfaceExpr)
             lookupScope = interfaceExpr->queryScope();
 
@@ -300,10 +300,10 @@ public:
                 assertex(scopeFunc->getOperator() == no_funcdef);
                 IHqlExpression * moduleExpr = scopeFunc->queryChild(0);
                 assertex(moduleExpr->getOperator() == no_libraryscope);
-                IHqlExpression * internalExpr = moduleExpr->queryProperty(internalAtom);
+                IHqlExpression * internalExpr = moduleExpr->queryAttribute(internalAtom);
                 if (internalExpr)
                 {
-                    IHqlExpression * nameExpr = moduleExpr->queryProperty(nameAtom);
+                    IHqlExpression * nameExpr = moduleExpr->queryAttribute(nameAtom);
                     if (!matchedInternalLibraries.contains(*nameExpr))
                     {
                         internalLibraries.append(*transformEmbeddedLibrary(scopeFunc));
@@ -514,10 +514,10 @@ ABoundActivity * HqlCppTranslator::doBuildActivityLibraryInstance(BuildCtx & ctx
     IHqlExpression * moduleFunction = expr->queryDefinition();      // no_funcdef
     IHqlExpression * module = moduleFunction->queryChild(0);
     assertex(module->getOperator() == no_libraryscope);
-    IHqlExpression * nameAttr = module->queryProperty(nameAtom);
+    IHqlExpression * nameAttr = module->queryAttribute(nameAtom);
     OwnedHqlExpr name = foldHqlExpression(nameAttr->queryChild(0));
     IValue * nameValue = name->queryValue();
-    IHqlExpression * originalName = queryPropertyChild(module, _original_Atom, 0);
+    IHqlExpression * originalName = queryAttributeChild(module, _original_Atom, 0);
 
     StringBuffer libraryName;
     if (nameValue)
@@ -554,7 +554,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityLibraryInstance(BuildCtx & ctx
     }
 
     instance->addAttributeInt("_interfaceHash", library->getInterfaceHash());
-    instance->addAttributeBool("embedded", module->hasProperty(internalAtom));
+    instance->addAttributeBool("embedded", module->hasAttribute(internalAtom));
     instance->addAttributeInt("_maxOutputs", library->outputs.ordinality());
     if (!targetHThor())
         instance->addAttributeInt("_graphid", nextActivityId());            // reserve an id...

ecl/hqlcpp/hqlnlp.cpp

@@ -168,10 +168,10 @@ NlpParseContext::NlpParseContext(IHqlExpression * _expr, IWorkUnit * _wu, const
     }
 
     info.charSize = (info.type == type_unicode) ? sizeof(UChar) : sizeof(char);
-    IHqlExpression * sepAttr = expr->queryProperty(separatorAtom);
+    IHqlExpression * sepAttr = expr->queryAttribute(separatorAtom);
     if (sepAttr)
         info.separator.set(sepAttr->queryChild(0));
-    info.caseSensitive = !expr->hasProperty(noCaseAtom);        // default true.
+    info.caseSensitive = !expr->hasAttribute(noCaseAtom);        // default true.
     info.dfaRepeatMax = options.dfaRepeatMax;
     info.dfaRepeatMaxScore = options.dfaRepeatMaxScore;
     info.uidBase = getUniqueId();
@@ -449,13 +449,13 @@ static void getOptions(IHqlExpression * expr, INlpParseAlgorithm::MatchAction &
 {
     matchAction = INlpParseAlgorithm::NlpMatchAll;
     scanAction = INlpParseAlgorithm::NlpScanNext;
-    if (expr->hasProperty(firstAtom))       matchAction = INlpParseAlgorithm::NlpMatchFirst;
-    if (expr->hasProperty(allAtom))         matchAction = INlpParseAlgorithm::NlpMatchAll;
+    if (expr->hasAttribute(firstAtom))       matchAction = INlpParseAlgorithm::NlpMatchFirst;
+    if (expr->hasAttribute(allAtom))         matchAction = INlpParseAlgorithm::NlpMatchAll;
 
-    if (expr->hasProperty(noScanAtom))      scanAction = INlpParseAlgorithm::NlpScanNone;
-    if (expr->hasProperty(scanAtom))        scanAction = INlpParseAlgorithm::NlpScanNext;
-    if (expr->hasProperty(scanAllAtom))     scanAction = INlpParseAlgorithm::NlpScanAll;
-    if (expr->hasProperty(wholeAtom))       scanAction = INlpParseAlgorithm::NlpScanWhole;
+    if (expr->hasAttribute(noScanAtom))      scanAction = INlpParseAlgorithm::NlpScanNone;
+    if (expr->hasAttribute(scanAtom))        scanAction = INlpParseAlgorithm::NlpScanNext;
+    if (expr->hasAttribute(scanAllAtom))     scanAction = INlpParseAlgorithm::NlpScanAll;
+    if (expr->hasAttribute(wholeAtom))       scanAction = INlpParseAlgorithm::NlpScanWhole;
 }
 
 void NlpParseContext::getDebugText(StringBuffer & s, unsigned detail)
@@ -491,16 +491,16 @@ void NlpParseContext::setParserOptions(INlpParseAlgorithm & parser)
     INlpParseAlgorithm::ScanAction scanAction;
     getOptions(expr, matchAction, scanAction);
 
-    IHqlExpression * keep = expr->queryProperty(keepAtom);
+    IHqlExpression * keep = expr->queryAttribute(keepAtom);
     unsigned keepLimit = keep ? (unsigned)keep->queryChild(0)->queryValue()->getIntValue() : 0;
-    IHqlExpression * atmost = expr->queryProperty(atmostAtom);
+    IHqlExpression * atmost = expr->queryAttribute(atmostAtom);
     unsigned atmostLimit = atmost ? (unsigned)atmost->queryChild(0)->queryValue()->getIntValue() : 0;
-    IHqlExpression * maxLength = expr->queryProperty(maxLengthAtom);
+    IHqlExpression * maxLength = expr->queryAttribute(maxLengthAtom);
     size32_t maxLengthValue = maxLength ? (unsigned)maxLength->queryChild(0)->queryValue()->getIntValue() : DEFAULT_PATTERN_MAX_LENGTH;
 
     parser.setOptions(matchAction, scanAction, info.inputFormat(), keepLimit, atmostLimit);
-    parser.setChoose(expr->hasProperty(minAtom), expr->hasProperty(maxAtom), expr->hasProperty(bestAtom), !expr->hasProperty(manyAtom));
-    parser.setJoin(expr->hasProperty(notMatchedAtom), expr->hasProperty(notMatchedOnlyAtom));
+    parser.setChoose(expr->hasAttribute(minAtom), expr->hasAttribute(maxAtom), expr->hasAttribute(bestAtom), !expr->hasAttribute(manyAtom));
+    parser.setJoin(expr->hasAttribute(notMatchedAtom), expr->hasAttribute(notMatchedOnlyAtom));
     parser.setLimit(maxLengthValue);
 }
 
@@ -616,8 +616,8 @@ void HqlCppTranslator::doBuildParseSearchText(BuildCtx & classctx, IHqlExpressio
 void HqlCppTranslator::doBuildParseExtra(BuildCtx & classctx, IHqlExpression * expr)
 {
     StringBuffer flags;
-    if (expr->hasProperty(groupAtom)) flags.append("|PFgroup");
-    if (expr->hasProperty(parallelAtom)) flags.append("|PFparallel");
+    if (expr->hasAttribute(groupAtom)) flags.append("|PFgroup");
+    if (expr->hasAttribute(parallelAtom)) flags.append("|PFparallel");
 
     if (flags.length())
         doBuildUnsignedFunction(classctx, "getFlags", flags.str()+1);
@@ -687,7 +687,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityParse(BuildCtx & ctx, IHqlExpr
     //This will become conditional on the flags....
     unsigned startPrepareTime = msTick();
     ITimeReporter * reporter = options.addTimingToWorkunit ? timeReporter : NULL;
-    if (expr->hasProperty(tomitaAtom))
+    if (expr->hasAttribute(tomitaAtom))
         nlpParse = createTomitaContext(expr, code->workunit, options, reporter);
     else
     {

ecl/hqlcpp/hqlregex.cpp

@@ -591,7 +591,7 @@ void HqlRegexExpr::calcDfaScore()
             else
                 dfaScore = argScore;
         }
-        else if (!expr->hasProperty(minimalAtom))
+        else if (!expr->hasAttribute(minimalAtom))
         {
             unsigned max = getRepeatMax();
             unsigned namedDfaScore = queryNamed()->getDfaScore();
@@ -861,7 +861,7 @@ bool HqlRegexExpr::canConsume(unsigned nextChar)
     case no_pat_set:
         {
             assertex(options.type != type_utf8);
-            bool invert = expr->hasProperty(notAtom);
+            bool invert = expr->hasAttribute(notAtom);
             ForEachChild(idx, expr)
             {
                 IHqlExpression * child = expr->queryChild(idx);
@@ -963,7 +963,7 @@ void HqlRegexExpr::gatherConsumeSymbols(SymbolArray & symbols)
         if (options.type == type_unicode)
         {
             //MORE: Need some kind of implementation for unicode - although invert and ranges may not be possible.
-            if (expr->hasProperty(notAtom))
+            if (expr->hasAttribute(notAtom))
                 throwError(HQLERR_DfaTooComplex);
 
             ForEachChild(idx, expr)
@@ -1381,7 +1381,7 @@ void HqlRegexExpr::generateRegex(GenerateRegexCtx & ctx)
     case no_pat_endcheckin:
         {
             bool stripSeparator = ctx.info.addedSeparators && (expr->queryType()->getTypeCode() != type_pattern);
-            created.setown(new RegexCheckInPattern(expr->hasProperty(notAtom), stripSeparator));
+            created.setown(new RegexCheckInPattern(expr->hasAttribute(notAtom), stripSeparator));
             break;
         }
     case no_pat_endchecklength:
@@ -1390,7 +1390,7 @@ void HqlRegexExpr::generateRegex(GenerateRegexCtx & ctx)
             unsigned maxLength = PATTERN_UNLIMITED_LENGTH;
             getCheckRange(expr->queryChild(1), minLength, maxLength, ctx.info.charSize);
             bool stripSeparator = ctx.info.addedSeparators && (expr->queryType()->getTypeCode() != type_pattern);
-            created.setown(new RegexCheckLengthPattern(expr->hasProperty(notAtom), stripSeparator, minLength, maxLength));
+            created.setown(new RegexCheckLengthPattern(expr->hasAttribute(notAtom), stripSeparator, minLength, maxLength));
             break;
         }
     case no_pat_endvalidate:
@@ -1430,14 +1430,14 @@ void HqlRegexExpr::generateRegex(GenerateRegexCtx & ctx)
         break;
     case no_pat_x_before_y:
     case no_pat_before_y:
-        created.setown(new RegexAssertNextPattern(expr->hasProperty(notAtom)));
+        created.setown(new RegexAssertNextPattern(expr->hasAttribute(notAtom)));
         break;
     case no_pat_x_after_y:
     case no_pat_after_y:
         {
             unsigned minSize = limitedMult(querySubPattern()->limit.minLength, ctx.info.charSize);
             unsigned maxSize = limitedMult(querySubPattern()->limit.maxLength, ctx.info.charSize);
-            created.setown(new RegexAssertPrevPattern(expr->hasProperty(notAtom), minSize, maxSize));
+            created.setown(new RegexAssertPrevPattern(expr->hasAttribute(notAtom), minSize, maxSize));
             break;
         }
     case no_pat_first:
@@ -1467,7 +1467,7 @@ void HqlRegexExpr::generateRegex(GenerateRegexCtx & ctx)
             else
                 pattern = new RegexAsciiISetPattern;
             created.setown(pattern);
-            if (expr->hasProperty(notAtom))
+            if (expr->hasAttribute(notAtom))
                 pattern->setInvert(true);
             ForEachChild(idx, expr)
             {
@@ -1556,11 +1556,11 @@ void HqlRegexExpr::generateRegex(GenerateRegexCtx & ctx)
         {
             if (expr->queryChild(0)->getOperator() == no_pat_anychar)
             {
-                created.setown(new RegexRepeatAnyPattern(getRepeatMin(), getRepeatMax(), expr->hasProperty(minimalAtom)));
+                created.setown(new RegexRepeatAnyPattern(getRepeatMin(), getRepeatMax(), expr->hasAttribute(minimalAtom)));
                 queryNamed()->noGenerate = true;
             }
             else
-                created.setown(new RegexRepeatPattern(getRepeatMin(), getRepeatMax(), !expr->hasProperty(minimalAtom)));
+                created.setown(new RegexRepeatPattern(getRepeatMin(), getRepeatMax(), !expr->hasAttribute(minimalAtom)));
         }
         break;
     case no_pat_endpattern:

ecl/hqlcpp/hqlresource.cpp

@@ -74,11 +74,11 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
     case no_selfjoin:
     case no_denormalize:
     case no_denormalizegroup:
-        if (isKeyedJoin(expr) || expr->hasProperty(_lightweight_Atom))
+        if (isKeyedJoin(expr) || expr->hasAttribute(_lightweight_Atom))
             resources.setLightweight();
-        else if (expr->hasProperty(lookupAtom))
+        else if (expr->hasAttribute(lookupAtom))
         {
-            if (expr->hasProperty(fewAtom))
+            if (expr->hasAttribute(fewAtom))
             {
                 resources.setLightweight().set(RESslavememory, MEM_Const_Minimal+LOOKUPJOINL_SMART_BUFFER_SIZE);
                 resources.setManyToMasterSockets(1);
@@ -89,7 +89,7 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
                 resources.setManyToMasterSockets(1);
             }
         }
-        else if (expr->hasProperty(hashAtom))
+        else if (expr->hasAttribute(hashAtom))
         {
             resources.setHeavyweight();
             setHashResources(expr, resources, options);
@@ -106,7 +106,7 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
         }
         break;
     case no_dedup:
-        if (isGrouped || (!expr->hasProperty(allAtom) && !expr->hasProperty(hashAtom)))
+        if (isGrouped || (!expr->hasAttribute(allAtom) && !expr->hasAttribute(hashAtom)))
         {
             resources.setLightweight();
             if (!isGrouped && !isLocal)
@@ -143,7 +143,7 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
         setHashResources(expr, resources, options);
         break;
     case no_subsort:
-        if (expr->hasProperty(manyAtom))
+        if (expr->hasAttribute(manyAtom))
             resources.setHeavyweight();
         else
             resources.setLightweight();
@@ -151,12 +151,12 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
     case no_sort:
         if (isGrouped)
         {
-            if (expr->hasProperty(manyAtom))
+            if (expr->hasAttribute(manyAtom))
                 resources.setHeavyweight();
             else
                 resources.setLightweight();
         }
-        else if (expr->hasProperty(fewAtom) && isLocal)
+        else if (expr->hasAttribute(fewAtom) && isLocal)
             resources.setLightweight();
         else if (isLocal)
             resources.setHeavyweight();
@@ -185,7 +185,7 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
             else
             {
                 resources.setLightweight();
-                if (expr->hasProperty(_workflowPersist_Atom) && expr->hasProperty(distributedAtom))
+                if (expr->hasAttribute(_workflowPersist_Atom) && expr->hasAttribute(distributedAtom))
                     setHashResources(expr, resources, options);         // may require a hash distribute
             }
             break;
@@ -193,7 +193,7 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
     case no_output:
         {
             IHqlExpression * filename = expr->queryChild(1);
-            if (expr->hasProperty(_spill_Atom))
+            if (expr->hasAttribute(_spill_Atom))
             {
                 //resources.setLightweight();   // assume no resources(!)
             }
@@ -235,7 +235,7 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
     case no_hqlproject:
         resources.setLightweight();
         //Add a flag onto count project to indicate it is a different variety.
-        if (expr->hasProperty(_countProject_Atom) && !isLocal)
+        if (expr->hasAttribute(_countProject_Atom) && !isLocal)
             resources.set(RESslavememory, COUNTPROJECT_SMART_BUFFER_SIZE);
         break;
     case no_enth:
@@ -244,7 +244,7 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
             resources.set(RESslavememory, CHOOSESETS_SMART_BUFFER_SIZE);
         break;
     case no_metaactivity:
-        if (expr->hasProperty(pullAtom))
+        if (expr->hasAttribute(pullAtom))
             resources.setLightweight().set(RESslavememory, PULL_SMART_BUFFER_SIZE);
         break;
     case no_setresult:
@@ -254,7 +254,7 @@ void getResources(IHqlExpression * expr, CResources & resources, const CResource
         break;
     case no_choosesets:
         resources.setLightweight();
-        if (!isLocal || expr->hasProperty(enthAtom) || expr->hasProperty(lastAtom))
+        if (!isLocal || expr->hasAttribute(enthAtom) || expr->hasAttribute(lastAtom))
             resources.set(RESslavememory, CHOOSESETS_SMART_BUFFER_SIZE);
         break;
     case no_iterate:
@@ -463,7 +463,7 @@ bool lightweightAndReducesDatasetSize(IHqlExpression * expr)
     case no_newusertable:
         return reducesRowSize(expr);
     case no_dedup:
-        if (isGroupedActivity(expr) || (!expr->hasProperty(allAtom) && !expr->hasProperty(hashAtom)))
+        if (isGroupedActivity(expr) || (!expr->hasAttribute(allAtom) && !expr->hasAttribute(hashAtom)))
             return true;
         break;
     case no_aggregate:
@@ -967,7 +967,7 @@ void ResourceGraphInfo::removeResources(const CResources & value)
 
 static void appendCloneProperty(HqlExprArray & args, IHqlExpression * expr, IAtom * name)
 {
-    IHqlExpression * prop = expr->queryProperty(name);
+    IHqlExpression * prop = expr->queryAttribute(name);
     if (prop)
         args.append(*LINK(prop));
 }
@@ -1494,7 +1494,7 @@ bool ResourcerInfo::expandRatherThanSpill(bool noteOtherSpills)
         case no_workunit_dataset:
             return !isProcessed && !isFiltered;
         case no_getgraphresult:
-            return !expr->hasProperty(_streaming_Atom);         // we must not duplicate streaming inputs!
+            return !expr->hasAttribute(_streaming_Atom);         // we must not duplicate streaming inputs!
         case no_keyindex:
         case no_newkeyindex:
             if (!isFiltered)
@@ -1526,7 +1526,7 @@ bool ResourcerInfo::expandRatherThanSpill(bool noteOtherSpills)
             isProcessed = true;
             break;
         case no_hqlproject:
-            if (expr->hasProperty(_countProject_Atom) || expr->hasProperty(prefetchAtom))
+            if (expr->hasAttribute(_countProject_Atom) || expr->hasAttribute(prefetchAtom))
                 return false;
             expr = expr->queryChild(0);
             isProcessed = true;
@@ -2138,7 +2138,7 @@ protected:
         {
         case no_select:
             //Only interested in the leftmost no_select
-            if (expr->hasProperty(newAtom))
+            if (expr->hasAttribute(newAtom))
             {
                 IHqlExpression * ds = expr->queryChild(0);
                 if (isEvaluateable(ds))
@@ -2209,7 +2209,7 @@ protected:
         case no_thisnode:
             throwUnexpected();
         case no_getgraphresult:
-            if (expr->hasProperty(_streaming_Atom) || expr->hasProperty(_distributed_Atom))
+            if (expr->hasAttribute(_streaming_Atom) || expr->hasAttribute(_distributed_Atom))
             {
                 noteDataset(expr, expr, true);
                 return;
@@ -2230,7 +2230,7 @@ protected:
                 switch (ds->getOperator())
                 {
                 case no_getgraphresult:
-                    if (!expr->hasProperty(_streaming_Atom) && !expr->hasProperty(_distributed_Atom))
+                    if (!expr->hasAttribute(_streaming_Atom) && !expr->hasAttribute(_distributed_Atom))
                         break;
                     //fallthrough
                 case no_getgraphloopresult:
@@ -2709,7 +2709,7 @@ bool EclResourcer::findSplitPoints(IHqlExpression * expr)
         case no_newusertable:
         case no_aggregate:
         case no_newaggregate:
-            if (options.preventKeyedSplit && expr->hasProperty(keyedAtom))
+            if (options.preventKeyedSplit && expr->hasAttribute(keyedAtom))
                 insideNeverSplit = true;
             break;
         case no_stepped:
@@ -2936,10 +2936,10 @@ void EclResourcer::createInitialGraph(IHqlExpression * expr, IHqlExpression * ow
                 //Needs the grouping to be saved in the same way.  Could cope with compressed matching, but not
                 //much point - since fairly unlikely.
                 IHqlExpression * filename = expr->queryChild(1);
-                if (filename && (filename->getOperator() == no_constant) && !expr->hasProperty(xmlAtom) && !expr->hasProperty(csvAtom))
+                if (filename && (filename->getOperator() == no_constant) && !expr->hasAttribute(xmlAtom) && !expr->hasAttribute(csvAtom))
                 {
                     IHqlExpression * dataset = expr->queryChild(0);
-                    if (expr->hasProperty(groupedAtom) == (dataset->queryType()->queryGroupInfo() != NULL))
+                    if (expr->hasAttribute(groupedAtom) == (dataset->queryType()->queryGroupInfo() != NULL))
                     {
                         StringBuffer filenameText;
                         filename->queryValue()->getStringValue(filenameText);
@@ -3533,16 +3533,16 @@ bool EclResourcer::addExprDependency(IHqlExpression * expr, ResourceGraphInfo *
         return isNewSelector(expr);
     case no_workunit_dataset:
         {
-            IHqlExpression * sequence = queryPropertyChild(expr, sequenceAtom, 0);
-            IHqlExpression * name = queryPropertyChild(expr, nameAtom, 0);
+            IHqlExpression * sequence = queryAttributeChild(expr, sequenceAtom, 0);
+            IHqlExpression * name = queryAttributeChild(expr, nameAtom, 0);
             OwnedHqlExpr value = createAttribute(resultAtom, LINK(sequence), LINK(name));
             addDependencyUse(value, curGraph, activityExpr);
             return false;
         }
     case no_getresult:
         {
-            IHqlExpression * sequence = queryPropertyChild(expr, sequenceAtom, 0);
-            IHqlExpression * name = queryPropertyChild(expr, namedAtom, 0);
+            IHqlExpression * sequence = queryAttributeChild(expr, sequenceAtom, 0);
+            IHqlExpression * name = queryAttributeChild(expr, namedAtom, 0);
             OwnedHqlExpr value = createAttribute(resultAtom, LINK(sequence), LINK(name));
             addDependencyUse(value, curGraph, activityExpr);
             return false;
@@ -3563,8 +3563,8 @@ bool EclResourcer::addExprDependency(IHqlExpression * expr, ResourceGraphInfo *
     case no_setresult:
     case no_extractresult:
         {
-            IHqlExpression * sequence = queryPropertyChild(expr, sequenceAtom, 0);
-            IHqlExpression * name = queryPropertyChild(expr, namedAtom, 0);
+            IHqlExpression * sequence = queryAttributeChild(expr, sequenceAtom, 0);
+            IHqlExpression * name = queryAttributeChild(expr, namedAtom, 0);
             OwnedHqlExpr value = createAttribute(resultAtom, LINK(sequence), LINK(name));
             addDependencySource(value, curGraph, activityExpr);
             return true;
@@ -3691,7 +3691,7 @@ void EclResourcer::spotUnbalancedSplitters(IHqlExpression * expr, unsigned which
             switch (expr->getOperator())
             {
             case no_addfiles:
-                if (expr->hasProperty(_ordered_Atom) || expr->hasProperty(_orderedPull_Atom) || isGrouped(expr))
+                if (expr->hasAttribute(_ordered_Atom) || expr->hasAttribute(_orderedPull_Atom) || isGrouped(expr))
                     modify = true;
                 break;
             default:
@@ -4344,7 +4344,7 @@ IHqlExpression * EclResourcer::doCreateResourced(IHqlExpression * expr, Resource
             {
                 args.append(*LINK(newDs));
                 unwindChildren(args, expr, 1);
-                if (!expr->hasProperty(newAtom) && isNewSelector(expr) && (newDs->getOperator() != no_select))
+                if (!expr->hasAttribute(newAtom) && isNewSelector(expr) && (newDs->getOperator() != no_select))
                     args.append(*LINK(queryNewSelectAttrExpr()));
                 same = false;
             }
@@ -4519,7 +4519,7 @@ IHqlExpression * EclResourcer::createResourced(IHqlExpression * expr, ResourceGr
             }
             else
             {
-                IHqlExpression * uid = info->transformed->queryProperty(_uid_Atom);
+                IHqlExpression * uid = info->transformed->queryAttribute(_uid_Atom);
                 source = createValue(no_callsideeffect, makeVoidType(), LINK(uid));
                 //source = LINK(info->transformed);
             }
@@ -4540,7 +4540,7 @@ IHqlExpression * EclResourcer::createResourced(IHqlExpression * expr, ResourceGr
     }
 
     OwnedHqlExpr resourced = doCreateResourced(expr, ownerGraph, expandInParent, defineSideEffect);
-    if (queryAddUniqueToActivity(resourced))// && !resourced->hasProperty(_internal_Atom))
+    if (queryAddUniqueToActivity(resourced))// && !resourced->hasAttribute(_internal_Atom))
         resourced.setown(appendUniqueAttr(resourced));
 
     if (!expandInParent)
@@ -4957,7 +4957,7 @@ void SpillActivityTransformer::analyseExpr(IHqlExpression * expr)
                     break;
                 input = cur;
             }
-            if (!body->hasProperty(balancedAtom))
+            if (!body->hasAttribute(balancedAtom))
                 setUnbalanced(input->queryBody());
         }
     }
@@ -4978,7 +4978,7 @@ IHqlExpression * SpillActivityTransformer::createTransformed(IHqlExpression * ex
             if (input->getOperator() == no_split)
                 return transform(input);
             OwnedHqlExpr transformed = NewHqlTransformer::createTransformed(expr);
-            if (transformed->hasProperty(balancedAtom) && isUnbalanced(expr))
+            if (transformed->hasAttribute(balancedAtom) && isUnbalanced(expr))
                 return removeProperty(transformed, balancedAtom);
             return transformed.getClear();
         }

ecl/hqlcpp/hqlsource.cpp

@@ -290,7 +290,7 @@ void VirtualFieldsInfo::gatherVirtualFields(IHqlExpression * _record, bool ignor
         IHqlExpression * cur = record->queryChild(idx);
         IHqlExpression * virtualAttr = NULL;
         if (!ignoreVirtuals)
-            virtualAttr = cur->queryProperty(virtualAtom);
+            virtualAttr = cur->queryAttribute(virtualAtom);
 
         if (virtualAttr)
         {
@@ -326,7 +326,7 @@ public:
 
     virtual IHqlExpression * getMissingAssignValue(IHqlExpression * expr)
     {
-        IHqlExpression * virtualAttr = expr->queryProperty(virtualAtom);
+        IHqlExpression * virtualAttr = expr->queryAttribute(virtualAtom);
         assertex(virtualAttr);
         return getVirtualReplacement(expr, virtualAttr->queryChild(0), dataset);
     }
@@ -405,7 +405,7 @@ void createPhysicalLogicalAssigns(HqlExprArray & assigns, IHqlExpression * self,
                 {
                     IHqlExpression * curPhysical = nextDiskField(diskRecord, diskIndex);
                     OwnedHqlExpr physicalSelect = createSelectExpr(LINK(diskDataset), LINK(curPhysical));
-                    if (cur->isDatarow() && !cur->hasProperty(blobAtom) && !isInPayload())
+                    if (cur->isDatarow() && !cur->hasAttribute(blobAtom) && !isInPayload())
                     {
                         createPhysicalLogicalAssigns(assigns, target, curPhysical->queryRecord(), cur->queryRecord(), physicalSelect, allowTranslate, NotFound);
                     }
@@ -472,7 +472,7 @@ static IHqlExpression * createPhysicalIndexRecord(HqlMapTransformer & mapper, IH
             physicalFields.append(*mapIfBlock(mapper, cur));
         else if (cur->getOperator() == no_record)
             physicalFields.append(*createPhysicalIndexRecord(mapper, tableExpr, cur, false, allowTranslate));
-        else if (cur->hasProperty(blobAtom))
+        else if (cur->hasAttribute(blobAtom))
         {
             newField = createField(cur->queryId(), makeIntType(8, false), NULL, NULL);
         }
@@ -494,7 +494,7 @@ static IHqlExpression * createPhysicalIndexRecord(HqlMapTransformer & mapper, IH
             {
                 //This should support other non serialized formats.  E.g., link counted strings. 
                 //Simplest would be to move getSerializedForm code + call that first.
-                if (cur->hasProperty(_linkCounted_Atom))
+                if (cur->hasAttribute(_linkCounted_Atom))
                 {
                     newField = getSerializedForm(cur, diskAtom);
                     assertex(newField != cur);
@@ -533,7 +533,7 @@ IHqlExpression * HqlCppTranslator::convertToPhysicalIndex(IHqlExpression * table
     if (match)
         return LINK(*match);
 
-    if (tableExpr->hasProperty(_original_Atom))
+    if (tableExpr->hasAttribute(_original_Atom))
         return LINK(tableExpr);
 
     assertex(tableExpr->getOperator() == no_newkeyindex);
@@ -674,7 +674,7 @@ public:
         isPreloaded = false;
         isCompoundCount = false;
         transformCanFilter = false;
-        IHqlExpression * preload = tableExpr ? tableExpr->queryProperty(preloadAtom) : NULL;
+        IHqlExpression * preload = tableExpr ? tableExpr->queryAttribute(preloadAtom) : NULL;
         if (preload)
         {
             isPreloaded = true;
@@ -687,7 +687,7 @@ public:
         returnIfFilterFails = true;
         useFilterMappings = true;
         generateUnfilteredTransform = false;
-        allowDynamicFormatChange = tableExpr && !tableExpr->hasProperty(fixedAtom);
+        allowDynamicFormatChange = tableExpr && !tableExpr->hasAttribute(fixedAtom);
         onlyExistsAggreate = false;
         monitorsForGrouping = false;
         useImplementationClass = false;
@@ -1281,7 +1281,7 @@ void SourceBuilder::buildTransformElements(BuildCtx & ctx, IHqlExpression * expr
             ForEachChild(idx, record)
             {
                 IHqlExpression * field = record->queryChild(idx);
-                IHqlExpression * virtualAttr = field->queryProperty(virtualAtom);
+                IHqlExpression * virtualAttr = field->queryAttribute(virtualAtom);
                 if (virtualAttr)
                 {
                     size32_t fieldSize = field->queryType()->getSize();
@@ -1305,7 +1305,7 @@ void SourceBuilder::buildTransformElements(BuildCtx & ctx, IHqlExpression * expr
             ForEachChild(idx2, record)
             {
                 IHqlExpression * field = record->queryChild(idx2);
-                IHqlExpression * virtualAttr = field->queryProperty(virtualAtom);
+                IHqlExpression * virtualAttr = field->queryAttribute(virtualAtom);
                 if (virtualAttr)
                 {
                     IHqlExpression * self = rootSelfRow->querySelector();
@@ -1779,7 +1779,7 @@ ABoundActivity * SourceBuilder::buildActivity(BuildCtx & ctx, IHqlExpression * e
     activityKind = _activityKind;
     translator.gatherActiveCursors(ctx, parentCursors);
 
-    bool isSpill = tableExpr && tableExpr->hasProperty(_spill_Atom);
+    bool isSpill = tableExpr && tableExpr->hasAttribute(_spill_Atom);
     useImplementationClass = translator.queryOptions().minimizeActivityClasses && translator.targetRoxie() && isSpill;
 
     Owned<ActivityInstance> localInstance = new ActivityInstance(translator, ctx, activityKind, expr, kind);
@@ -1816,7 +1816,7 @@ ABoundActivity * SourceBuilder::buildActivity(BuildCtx & ctx, IHqlExpression * e
                 case no_newusertable:
                 case no_transformascii:
                 case no_transformebcdic:
-                    if (!cur->hasProperty(_internal_Atom))
+                    if (!cur->hasAttribute(_internal_Atom))
                         isProjected = true;
                     break;
                 case no_table:
@@ -1976,7 +1976,7 @@ ABoundActivity * SourceBuilder::buildActivity(BuildCtx & ctx, IHqlExpression * e
     else
         instance->addAttributeBool("_isSpill", isSpill);
 
-    IHqlExpression * spillReason = tableExpr ? queryPropertyChild(tableExpr, _spillReason_Atom, 0) : NULL;
+    IHqlExpression * spillReason = tableExpr ? queryAttributeChild(tableExpr, _spillReason_Atom, 0) : NULL;
 
     if (spillReason)
     {
@@ -2014,7 +2014,7 @@ void SourceBuilder::buildKeyedLimitHelper(IHqlExpression * self)
         func2ctx.addQuotedCompound("virtual void onKeyedLimitExceeded()");
         translator.buildStmt(func2ctx, fail);
 
-        IHqlExpression * transform = queryPropertyChild(keyedLimitExpr, onFailAtom, 0);
+        IHqlExpression * transform = queryAttributeChild(keyedLimitExpr, onFailAtom, 0);
         if (transform)
         {
             BuildCtx transformctx(instance->startctx);
@@ -2030,21 +2030,21 @@ void SourceBuilder::buildSteppedHelpers()
 {
     StringBuffer steppedFlags;
 
-    IHqlExpression * priority = steppedExpr->queryProperty(priorityAtom);
+    IHqlExpression * priority = steppedExpr->queryAttribute(priorityAtom);
     if (priority)
     {
         steppedFlags.append("|SSFhaspriority");
         translator.doBuildFunction(instance->startctx, doubleType, "getPriority", priority->queryChild(0));
     }
 
-    IHqlExpression * prefetch = steppedExpr->queryProperty(prefetchAtom);
+    IHqlExpression * prefetch = steppedExpr->queryAttribute(prefetchAtom);
     if (prefetch)
     {
         steppedFlags.append("|SSFhasprefetch");
         translator.doBuildUnsignedFunction(instance->startctx, "getPrefetchSize", prefetch->queryChild(0));
     }
 
-    IHqlExpression * filtered = steppedExpr->queryProperty(filteredAtom);
+    IHqlExpression * filtered = steppedExpr->queryAttribute(filteredAtom);
     if (filtered)
         steppedFlags.append("|SSFalwaysfilter");
 
@@ -2620,12 +2620,12 @@ void DiskReadBuilderBase::buildMembers(IHqlExpression * expr)
     bool matched = translator.registerGlobalUsage(tableExpr->queryChild(0));
     if (translator.getTargetClusterType() == RoxieCluster)
     {
-        instance->addAttributeBool("_isOpt", tableExpr->hasProperty(optAtom));
-        instance->addAttributeBool("_isSpillGlobal", tableExpr->hasProperty(jobTempAtom));
-        if (tableExpr->hasProperty(jobTempAtom) && !matched)
+        instance->addAttributeBool("_isOpt", tableExpr->hasAttribute(optAtom));
+        instance->addAttributeBool("_isSpillGlobal", tableExpr->hasAttribute(jobTempAtom));
+        if (tableExpr->hasAttribute(jobTempAtom) && !matched)
             throwUnexpected();
     }
-    if (!matched && expr->hasProperty(_spill_Atom))
+    if (!matched && expr->hasAttribute(_spill_Atom))
     {
         StringBuffer spillName;
         getExprECL(tableExpr->queryChild(0), spillName);
@@ -2639,7 +2639,7 @@ void DiskReadBuilderBase::buildMembers(IHqlExpression * expr)
     if (guard)
         translator.doBuildBoolFunction(instance->startctx, "canMatchAny", guard);
 
-    translator.buildEncryptHelper(instance->startctx, tableExpr->queryProperty(encryptAtom));
+    translator.buildEncryptHelper(instance->startctx, tableExpr->queryAttribute(encryptAtom));
 
     //---- virtual size32_t getPreloadSize() { return <value>; } ----
     if (preloadSize)
@@ -2664,29 +2664,29 @@ void DiskReadBuilderBase::buildMembers(IHqlExpression * expr)
 void DiskReadBuilderBase::buildFlagsMember(IHqlExpression * expr)
 {
     StringBuffer flags;
-    if (tableExpr->hasProperty(_spill_Atom)) flags.append("|TDXtemporary");
-    if (tableExpr->hasProperty(jobTempAtom)) flags.append("|TDXjobtemp");
-    if (tableExpr->hasProperty(groupedAtom)) flags.append("|TDXgrouped");
-    if (tableExpr->hasProperty(__compressed__Atom)) flags.append("|TDXcompress");
-    if (tableExpr->hasProperty(unsortedAtom)) flags.append("|TDRunsorted");
-    if (tableExpr->hasProperty(optAtom)) flags.append("|TDRoptional");
-    if (tableExpr->hasProperty(_workflowPersist_Atom)) flags.append("|TDXupdateaccessed");
+    if (tableExpr->hasAttribute(_spill_Atom)) flags.append("|TDXtemporary");
+    if (tableExpr->hasAttribute(jobTempAtom)) flags.append("|TDXjobtemp");
+    if (tableExpr->hasAttribute(groupedAtom)) flags.append("|TDXgrouped");
+    if (tableExpr->hasAttribute(__compressed__Atom)) flags.append("|TDXcompress");
+    if (tableExpr->hasAttribute(unsortedAtom)) flags.append("|TDRunsorted");
+    if (tableExpr->hasAttribute(optAtom)) flags.append("|TDRoptional");
+    if (tableExpr->hasAttribute(_workflowPersist_Atom)) flags.append("|TDXupdateaccessed");
     if (isPreloaded) flags.append("|TDRpreload");
     if (monitors.isFiltered()) flags.append("|TDRkeyed");
     if (limitExpr)
     {
-        if (limitExpr->hasProperty(onFailAtom))
+        if (limitExpr->hasAttribute(onFailAtom))
             flags.append("|TDRlimitcreates");
-        else if (limitExpr->hasProperty(skipAtom))
+        else if (limitExpr->hasAttribute(skipAtom))
             flags.append("|TDRlimitskips");
     }
     if (keyedLimitExpr)
     {
-        if (keyedLimitExpr->hasProperty(onFailAtom))
+        if (keyedLimitExpr->hasAttribute(onFailAtom))
             flags.append("|TDRkeyedlimitcreates|TDRcountkeyedlimit");           // is count correct?
-        else if (keyedLimitExpr->hasProperty(skipAtom))
+        else if (keyedLimitExpr->hasAttribute(skipAtom))
             flags.append("|TDRkeyedlimitskips|TDRcountkeyedlimit");
-        else if (keyedLimitExpr->hasProperty(countAtom))
+        else if (keyedLimitExpr->hasAttribute(countAtom))
             flags.append("|TDRcountkeyedlimit");
     }
     if (onlyExistsAggreate) flags.append("|TDRaggregateexists");
@@ -2771,8 +2771,8 @@ void DiskReadBuilder::buildMembers(IHqlExpression * expr)
         pipeCtx.addQuotedCompound("virtual const char * getPipeProgram()");
         translator.buildReturn(pipeCtx, mode->queryChild(0), unknownVarStringType);
 
-        IHqlExpression * csvFromPipe = tableExpr->queryProperty(csvAtom);
-        IHqlExpression * xmlFromPipe = tableExpr->queryProperty(xmlAtom);
+        IHqlExpression * csvFromPipe = tableExpr->queryAttribute(csvAtom);
+        IHqlExpression * xmlFromPipe = tableExpr->queryAttribute(xmlAtom);
         bool usesContents = false;
         if (csvFromPipe)
         {
@@ -2793,13 +2793,13 @@ void DiskReadBuilder::buildMembers(IHqlExpression * expr)
         else if (xmlFromPipe)
         {
             translator.doBuildXmlReadMember(*instance, expr, "queryXmlTransformer", usesContents);
-            translator.doBuildVarStringFunction(instance->classctx, "getXmlIteratorPath", queryPropertyChild(xmlFromPipe, rowAtom, 0));
+            translator.doBuildVarStringFunction(instance->classctx, "getXmlIteratorPath", queryAttributeChild(xmlFromPipe, rowAtom, 0));
         }
         
         StringBuffer flags;
-        if (tableExpr->hasProperty(groupAtom))      // not supported in parser?
+        if (tableExpr->hasAttribute(groupAtom))      // not supported in parser?
             flags.append("|TPFgroupeachrow");
-        if (tableExpr->hasProperty(optAtom))        // not supported in parser?
+        if (tableExpr->hasAttribute(optAtom))        // not supported in parser?
             flags.append("|TPFnofail");
 
         if (csvFromPipe)
@@ -2865,7 +2865,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityDiskRead(BuildCtx & ctx, IHqlE
     bool isPiped = modeOp==no_pipe;
 
     DiskReadBuilder info(*this, tableExpr, tableExpr->queryChild(0));
-    info.gatherVirtualFields(tableExpr->hasProperty(_noVirtual_Atom) || isPiped, needToSerializeRecord(modeOp));
+    info.gatherVirtualFields(tableExpr->hasAttribute(_noVirtual_Atom) || isPiped, needToSerializeRecord(modeOp));
 
     unsigned optFlags = (options.foldOptimized ? HOOfold : 0);
     if (!info.fieldInfo.simpleVirtualsAtEnd || info.fieldInfo.requiresDeserialize ||
@@ -2956,7 +2956,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityDiskNormalize(BuildCtx & ctx,
     assertex(mode->getOperator()!=no_pipe);
 
     DiskNormalizeBuilder info(*this, tableExpr, tableExpr->queryChild(0));
-    info.gatherVirtualFields(tableExpr->hasProperty(_noVirtual_Atom), needToSerializeRecord(mode));
+    info.gatherVirtualFields(tableExpr->hasAttribute(_noVirtual_Atom), needToSerializeRecord(mode));
 
     LinkedHqlExpr transformed = expr;
     if (info.recordHasVirtualsOrDeserialize())
@@ -3113,7 +3113,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityDiskAggregate(BuildCtx & ctx,
     assertex(mode->getOperator()!=no_pipe);
 
     DiskAggregateBuilder info(*this, tableExpr, tableExpr->queryChild(0));
-    info.gatherVirtualFields(tableExpr->hasProperty(_noVirtual_Atom), needToSerializeRecord(mode));
+    info.gatherVirtualFields(tableExpr->hasAttribute(_noVirtual_Atom), needToSerializeRecord(mode));
 
     LinkedHqlExpr transformed = expr;
     if (info.recordHasVirtualsOrDeserialize())
@@ -3127,7 +3127,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityDiskAggregate(BuildCtx & ctx,
     if (aggOp == no_countgroup || aggOp == no_existsgroup)
     {
         DiskCountBuilder info(*this, tableExpr, tableExpr->queryChild(0), aggOp);
-        info.gatherVirtualFields(tableExpr->hasProperty(_noVirtual_Atom), needToSerializeRecord(mode));
+        info.gatherVirtualFields(tableExpr->hasAttribute(_noVirtual_Atom), needToSerializeRecord(mode));
 
         return info.buildActivity(ctx, expr, TAKdiskcount, "DiskCount", NULL);
     }
@@ -3190,7 +3190,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityDiskGroupAggregate(BuildCtx &
     assertex(mode->getOperator()!=no_pipe);
 
     DiskGroupAggregateBuilder info(*this, tableExpr, tableExpr->queryChild(0));
-    info.gatherVirtualFields(tableExpr->hasProperty(_noVirtual_Atom), needToSerializeRecord(mode));
+    info.gatherVirtualFields(tableExpr->hasAttribute(_noVirtual_Atom), needToSerializeRecord(mode));
 
     LinkedHqlExpr transformed = expr;
     if (info.recordHasVirtualsOrDeserialize())
@@ -3453,7 +3453,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityCompoundSelectNew(BuildCtx & c
 
 
     IHqlExpression * select = queryRoot(optimized);
-    if (!(select && select->getOperator() == no_select && select->hasProperty(newAtom)))
+    if (!(select && select->getOperator() == no_select && select->hasAttribute(newAtom)))
     {
         if (optimized->getOperator() == no_compound_selectnew)
             return buildCachedActivity(ctx, optimized->queryChild(0));
@@ -3608,7 +3608,7 @@ MonitorExtractor::MonitorExtractor(IHqlExpression * _tableExpr, HqlCppTranslator
     expandKeyableFields();
     cleanlyKeyedExplicitly = false;
     keyedExplicitly = false;
-    allowDynamicFormatChange = tableExpr && !tableExpr->hasProperty(fixedAtom);
+    allowDynamicFormatChange = tableExpr && !tableExpr->hasAttribute(fixedAtom);
 }
 
 void MonitorExtractor::callAddAll(BuildCtx & ctx, IHqlExpression * targetVar)
@@ -3659,7 +3659,7 @@ static ITypeInfo * getExpandedFieldType(ITypeInfo * type, IHqlExpression * expr)
         if (type->getSize() == UNKNOWN_LENGTH)
         {
             unsigned maxLength = UNKNOWN_LENGTH;
-            IHqlExpression * maxSizeExpr = expr ? queryPropertyChild(expr, maxSizeAtom, 0) : NULL;
+            IHqlExpression * maxSizeExpr = expr ? queryAttributeChild(expr, maxSizeAtom, 0) : NULL;
             if (maxSizeExpr)
             {
                 unsigned maxSize = (unsigned)maxSizeExpr->queryValue()->getIntValue();
@@ -3688,7 +3688,7 @@ static ITypeInfo * getExpandedFieldType(ITypeInfo * type, IHqlExpression * expr)
             }
             else
             {
-                IHqlExpression * maxLengthExpr = expr ? queryPropertyChild(expr, maxLengthAtom, 0) : NULL;
+                IHqlExpression * maxLengthExpr = expr ? queryAttributeChild(expr, maxLengthAtom, 0) : NULL;
                 if (maxLengthExpr)
                     maxLength = (unsigned)maxLengthExpr->queryValue()->getIntValue();
             }
@@ -4787,7 +4787,7 @@ void MonitorExtractor::buildSegments(BuildCtx & ctx, const char * listName, bool
 
         //MORE: Should also allow nested record structures, and allow keying on first elements.
         //      and field->queryType()->getSize() doesn't work for alien datatypes etc.
-        if(!field->hasProperty(virtualAtom))
+        if(!field->hasAttribute(virtualAtom))
         {
             if (mergedSizes.isItem(idx))
                 curSize = mergedSizes.item(idx);
@@ -5888,14 +5888,14 @@ bool MonitorExtractor::extractFilters(KeyConditionInfo & matches, IHqlExpression
             KeyFailureInfo reason;
             reason.merge(failReason);
             failReason.clear();
-            bool extend = expr->hasProperty(extendAtom);
+            bool extend = expr->hasAttribute(extendAtom);
             if (!extractFilters(matches, l, extend ? KeyedExtend : KeyedYes))
             {
                 if (!extend)
                     failReason.reportError(translator, expr);
             }
 
-            IHqlExpression * original = expr->queryProperty(_selectors_Atom);
+            IHqlExpression * original = expr->queryAttribute(_selectors_Atom);
             if (original)
             {
                 ForEachChild(i, original)
@@ -5908,7 +5908,7 @@ bool MonitorExtractor::extractFilters(KeyConditionInfo & matches, IHqlExpression
         {
             if (l->getOperator() == no_all)
             {
-                IHqlExpression * original = expr->queryProperty(_selectors_Atom);
+                IHqlExpression * original = expr->queryAttribute(_selectors_Atom);
                 assertex(original);
                 ForEachChild(i, original)
                     extractFoldedWildFields(original->queryChild(i));
@@ -6199,7 +6199,7 @@ void IndexReadBuilderBase::buildMembers(IHqlExpression * expr)
 
     instance->addAttributeBool("preload", isPreloaded);
     if (translator.getTargetClusterType() == RoxieCluster)
-        instance->addAttributeBool("_isIndexOpt", tableExpr->hasProperty(optAtom));
+        instance->addAttributeBool("_isIndexOpt", tableExpr->hasAttribute(optAtom));
 
     if (monitors.queryGlobalGuard())
         translator.doBuildBoolFunction(instance->startctx, "canMatchAny", monitors.queryGlobalGuard());
@@ -6207,7 +6207,7 @@ void IndexReadBuilderBase::buildMembers(IHqlExpression * expr)
     buildKeyedLimitHelper(expr);
 
     translator.buildFormatCrcFunction(instance->classctx, "getFormatCrc", tableExpr, tableExpr, 1);
-    IHqlExpression * originalKey = queryPropertyChild(tableExpr, _original_Atom, 0);
+    IHqlExpression * originalKey = queryAttributeChild(tableExpr, _original_Atom, 0);
     translator.buildSerializedLayoutMember(instance->classctx, originalKey->queryRecord(), "getIndexLayout", numKeyedFields(originalKey));
 
     //Note the helper base class contains code like the following
@@ -6218,29 +6218,29 @@ void IndexReadBuilderBase::buildMembers(IHqlExpression * expr)
 void IndexReadBuilderBase::buildFlagsMember(IHqlExpression * expr)
 {
     StringBuffer flags;
-    if (tableExpr->hasProperty(sortedAtom))
+    if (tableExpr->hasAttribute(sortedAtom))
         flags.append("|TIRsorted");
-    else if (tableExpr->hasProperty(unorderedAtom))
+    else if (tableExpr->hasAttribute(unorderedAtom))
         flags.append("|TIRunordered");
     if (!monitors.isFiltered())
         flags.append("|TIRnofilter");
     if (isPreloaded)
         flags.append("|TIRpreload");
-    if (tableExpr->hasProperty(optAtom))
+    if (tableExpr->hasAttribute(optAtom))
         flags.append("|TIRoptional");
-    if (limitExpr && limitExpr->hasProperty(skipAtom))
+    if (limitExpr && limitExpr->hasAttribute(skipAtom))
         flags.append("|TIRlimitskips");
-    if (limitExpr && limitExpr->hasProperty(onFailAtom))
+    if (limitExpr && limitExpr->hasAttribute(onFailAtom))
         flags.append("|TIRlimitcreates");
     if (generateUnfilteredTransform)
         flags.append("|TIRunfilteredtransform");
     if (keyedLimitExpr)
     {
-        if (keyedLimitExpr->hasProperty(onFailAtom))
+        if (keyedLimitExpr->hasAttribute(onFailAtom))
             flags.append("|TIRkeyedlimitcreates|TIRcountkeyedlimit");
-        else if (keyedLimitExpr->hasProperty(skipAtom))
+        else if (keyedLimitExpr->hasAttribute(skipAtom))
             flags.append("|TIRkeyedlimitskips|TIRcountkeyedlimit");
-        else if (keyedLimitExpr->hasProperty(countAtom))
+        else if (keyedLimitExpr->hasAttribute(countAtom))
             flags.append("|TIRcountkeyedlimit");
     }
     IHqlExpression * firstStepped = steppingInfo.firstStepped();
@@ -6985,7 +6985,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityXmlRead(BuildCtx & ctx, IHqlEx
 
     //---- virtual const char * getFileName() { return "x.d00"; } ----
     buildFilenameFunction(*instance, instance->startctx, "getFileName", filename, hasDynamicFilename(tableExpr));
-    buildEncryptHelper(instance->startctx, tableExpr->queryProperty(encryptAtom));
+    buildEncryptHelper(instance->startctx, tableExpr->queryAttribute(encryptAtom));
 
     bool usesContents = false;
     doBuildXmlReadMember(*instance, tableExpr, "queryTransformer", usesContents);
@@ -6996,11 +6996,11 @@ ABoundActivity * HqlCppTranslator::doBuildActivityXmlRead(BuildCtx & ctx, IHqlEx
 
     //virtual unsigned getFlags() = 0;
     StringBuffer flags;
-    if (expr->hasProperty(_spill_Atom)) flags.append("|TDXtemporary");
-    if (expr->hasProperty(unsortedAtom)) flags.append("|TDRunsorted");
-    if (expr->hasProperty(optAtom)) flags.append("|TDRoptional");
+    if (expr->hasAttribute(_spill_Atom)) flags.append("|TDXtemporary");
+    if (expr->hasAttribute(unsortedAtom)) flags.append("|TDRunsorted");
+    if (expr->hasAttribute(optAtom)) flags.append("|TDRoptional");
     if (usesContents) flags.append("|TDRusexmlcontents");
-    if (mode->hasProperty(noRootAtom)) flags.append("|TDRxmlnoroot");
+    if (mode->hasAttribute(noRootAtom)) flags.append("|TDRxmlnoroot");
     if (!filename->isConstant()) flags.append("|TDXvarfilename");
     if (hasDynamicFilename(expr)) flags.append("|TDXdynamicfilename");
 
@@ -7079,11 +7079,11 @@ void FetchBuilder::buildMembers(IHqlExpression * expr)
     translator.bindTableCursor(getposctx, fetch->queryChild(1), "right", no_right, selSeq);
     translator.buildReturn(getposctx, fetch->queryChild(2));
     
-    translator.buildEncryptHelper(instance->startctx, tableExpr->queryProperty(encryptAtom), "getFileEncryptKey");
+    translator.buildEncryptHelper(instance->startctx, tableExpr->queryAttribute(encryptAtom), "getFileEncryptKey");
 
     //Fetch flags
     StringBuffer flags;
-    if (tableExpr->hasProperty(optAtom))
+    if (tableExpr->hasAttribute(optAtom))
         flags.append("|FFdatafileoptional");
     if (!nameExpr->isConstant())
         flags.append("|FFvarfilename");
@@ -7093,7 +7093,7 @@ void FetchBuilder::buildMembers(IHqlExpression * expr)
     if (flags.length())
         translator.doBuildUnsignedFunction(instance->classctx, "getFetchFlags", flags.str()+1);
 
-    if (tableExpr->hasProperty(optAtom) && translator.targetRoxie())
+    if (tableExpr->hasAttribute(optAtom) && translator.targetRoxie())
         instance->addAttributeBool("_isOpt", true);
 
     buildLimits(instance->startctx, expr, instance->activityId);

ecl/hqlcpp/hqlstep.cpp

@@ -828,7 +828,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMerge(BuildCtx & ctx, IHql
     DatasetReference dsRef(dataset, no_left, querySelSeq(expr));        
     buildCompareClass(instance->nestedctx, "compare", sortOrder, dsRef);
 
-    if (expr->hasProperty(dedupAtom))
+    if (expr->hasAttribute(dedupAtom))
         doBuildBoolFunction(instance->classctx, "dedup", true);
 
     SteppingFieldSelection stepping;
@@ -859,11 +859,11 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
 
     buildInstancePrefix(instance);
 
-    IHqlExpression * mofn = expr->queryProperty(mofnAtom);
-    bool leftonly = expr->hasProperty(leftonlyAtom);
-    bool leftouter = expr->hasProperty(leftouterAtom);
+    IHqlExpression * mofn = expr->queryAttribute(mofnAtom);
+    bool leftonly = expr->hasAttribute(leftonlyAtom);
+    bool leftouter = expr->hasAttribute(leftouterAtom);
     IHqlExpression * selSeq = querySelSeq(expr);
-    IHqlExpression * rowsid = expr->queryProperty(_rowsid_Atom);
+    IHqlExpression * rowsid = expr->queryAttribute(_rowsid_Atom);
     IHqlExpression * transform = (op == no_nwayjoin) ? expr->queryChild(2) : NULL;
     IHqlExpression * sortOrder = (op == no_nwayjoin) ? expr->queryChild(3) : expr->queryChild(2);
 
@@ -878,8 +878,8 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
 
     OwnedHqlExpr equalityList = stepCondition.createEqualitySortList();
     IHqlExpression * rangeSelect = stepCondition.queryRangeLeftSelector();
-    IHqlExpression * internalFlags = queryPropertyChild(expr, internalFlagsAtom, 0);
-    IHqlExpression * skew = expr->queryProperty(skewAtom);
+    IHqlExpression * internalFlags = queryAttributeChild(expr, internalFlagsAtom, 0);
+    IHqlExpression * skew = expr->queryAttribute(skewAtom);
 
     //Now generate all the helper functions....
     bool createClearRow = true;//(!leftouter && !leftonly);
@@ -894,11 +894,11 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
     else
         flags.append("|MJFinner");
 
-    if (expr->hasProperty(dedupAtom)) flags.append("|MJFdedup");
-    if (expr->hasProperty(steppedAtom)) flags.append("|MJFstepped");
+    if (expr->hasAttribute(dedupAtom)) flags.append("|MJFdedup");
+    if (expr->hasAttribute(steppedAtom)) flags.append("|MJFstepped");
     if (transform) flags.append("|MJFtransform");
     if (rangeSelect) flags.append("|MJFhasrange");
-    if (expr->hasProperty(assertAtom) && generateAsserts()) flags.append("|MJFassertsorted");
+    if (expr->hasAttribute(assertAtom) && generateAsserts()) flags.append("|MJFassertsorted");
     if (stepCondition.queryGlobalCompare()) flags.append("|MJFglobalcompare");
     if (createClearRow) flags.append("|MJFhasclearlow");
     if (skew) flags.append("|MJFhaspartition");

ecl/hqlcpp/hqltcppc.cpp

@@ -334,7 +334,7 @@ void CContainerInfo::calcCachedSize(const SizeStruct & offset, SizeStruct & size
     if (cachedSize.isEmpty())
     {
         IHqlExpression * record = column->queryRecord();
-        if (record->hasProperty(_nonEmpty_Atom))
+        if (record->hasAttribute(_nonEmpty_Atom))
             cachedSize.addFixed(1);
     }
 
@@ -533,7 +533,7 @@ void CMemberInfo::doBuildSkipInput(HqlCppTranslator & translator, BuildCtx & ctx
 
 IHqlExpression * CMemberInfo::createSelfPeekDeserializer(HqlCppTranslator & translator, IHqlExpression * helper)
 {
-    IHqlExpression * size = column->queryAttribute(EPsize);
+    IHqlExpression * size = column->queryProperty(EPsize);
     LinkedHqlExpr maxSize = size->queryChild(2);
     if (!maxSize || maxSize->isAttribute())
         maxSize.setown(getSizetConstant(MAX_RECORD_SIZE));
@@ -777,12 +777,12 @@ void CMemberInfo::getXPath(StringBuffer & out)
 {
     if (container)
         container->getContainerXPath(out);
-    IHqlExpression * xpath = column->queryProperty(xpathAtom);
+    IHqlExpression * xpath = column->queryAttribute(xpathAtom);
     if (xpath)
         xpath->queryChild(0)->queryValue()->getStringValue(out);
     else
     {
-        IHqlExpression * named = column->queryProperty(namedAtom);
+        IHqlExpression * named = column->queryAttribute(namedAtom);
         if (named)
             named->queryChild(0)->queryValue()->getStringValue(out);
         else
@@ -883,7 +883,7 @@ void CContainerInfo::buildClear(HqlCppTranslator & translator, BuildCtx & ctx, I
 
     if (children.ordinality() == 0)
     {
-        if (column->queryRecord()->hasProperty(_nonEmpty_Atom))
+        if (column->queryRecord()->hasAttribute(_nonEmpty_Atom))
         {
             //Clear on an empty record that has the _nonEmpty_attrbute clears the implicit byte
             Owned<ITypeInfo> dummyType = makeIntType(1, false);
@@ -1033,12 +1033,12 @@ void CContainerInfo::getContainerXPath(StringBuffer & out)
     if (column->getOperator() == no_field)
     {
         StringBuffer temp;
-        IHqlExpression * xpath = column->queryProperty(xpathAtom);
+        IHqlExpression * xpath = column->queryAttribute(xpathAtom);
         if (xpath)
             xpath->queryChild(0)->queryValue()->getStringValue(temp);
         else
         {
-            IHqlExpression * named = column->queryProperty(namedAtom);
+            IHqlExpression * named = column->queryAttribute(namedAtom);
             if (named)
                 named->queryChild(0)->queryValue()->getStringValue(temp);
             else
@@ -2379,7 +2379,7 @@ bool CVirtualColumnInfo::isFixedSize()
 
 void CVirtualColumnInfo::buildColumnExpr(HqlCppTranslator & translator, BuildCtx & ctx, IReferenceSelector * selector, CHqlBoundExpr & bound)
 {
-    IHqlExpression * virtualAttr = column->queryProperty(virtualAtom);
+    IHqlExpression * virtualAttr = column->queryAttribute(virtualAtom);
     OwnedHqlExpr value = getVirtualReplacement(column, virtualAttr->queryChild(0), selector->queryRootRow()->querySelector());
     OwnedHqlExpr cast = ensureExprType(value, column->queryType()->queryPromotedType());
     translator.buildExpr(ctx, cast, bound);
@@ -2605,9 +2605,9 @@ void CXmlColumnInfo::buildColumnAssign(HqlCppTranslator & translator, BuildCtx &
     if (type->getSize() != UNKNOWN_LENGTH)
     {
         IIdAtom * func = NULL;
-        IHqlExpression * defaultValue = queryPropertyChild(column, xmlDefaultAtom, 0);
+        IHqlExpression * defaultValue = queryAttributeChild(column, xmlDefaultAtom, 0);
         if (!defaultValue)
-            defaultValue = queryPropertyChild(column, defaultAtom, 0);
+            defaultValue = queryAttributeChild(column, defaultAtom, 0);
 
         switch (type->getTypeCode())
         {
@@ -2748,9 +2748,9 @@ IHqlExpression * CXmlColumnInfo::getXmlSetExpr(HqlCppTranslator & translator, Bu
     Owned<IHqlCppSetBuilder> builder = translator.createTempSetBuilder(elementType, temp.isAll);
     builder->buildDeclare(ctx);
 
-    LinkedHqlExpr defaultValue = queryPropertyChild(column, xmlDefaultAtom, 0);
+    LinkedHqlExpr defaultValue = queryAttributeChild(column, xmlDefaultAtom, 0);
     if (!defaultValue)
-        defaultValue.set(queryPropertyChild(column, defaultAtom, 0));
+        defaultValue.set(queryAttributeChild(column, defaultAtom, 0));
     bool defaultIsAllValue = defaultValue && (defaultValue->getOperator() == no_all);
     if (checkForAll)
     {
@@ -2789,9 +2789,9 @@ IHqlExpression * CXmlColumnInfo::getCallExpr(HqlCppTranslator & translator, Buil
 {
     Linked<ITypeInfo> type = queryPhysicalType();
     IIdAtom * func = NULL;
-    IHqlExpression * defaultValue = queryPropertyChild(column, xmlDefaultAtom, 0);
+    IHqlExpression * defaultValue = queryAttributeChild(column, xmlDefaultAtom, 0);
     if (!defaultValue)
-        defaultValue = queryPropertyChild(column, defaultAtom, 0);
+        defaultValue = queryAttributeChild(column, defaultAtom, 0);
 
     switch (type->getTypeCode())
     {
@@ -2903,7 +2903,7 @@ CMemberInfo * ColumnToOffsetMap::addColumn(CContainerInfo * container, IHqlExpre
             if (column->queryType()->getTypeCode() != type_bitfield)
                 completeActiveBitfields();
 
-            if (translateVirtuals && column->hasProperty(virtualAtom) && (column->queryType()->getSize() != UNKNOWN_LENGTH))
+            if (translateVirtuals && column->hasAttribute(virtualAtom) && (column->queryType()->getSize() != UNKNOWN_LENGTH))
                 created = new CVirtualColumnInfo(container, prior, column);
             else
                 created = createColumn(container, column, map);
@@ -3007,7 +3007,7 @@ CMemberInfo * ColumnToOffsetMap::createColumn(CContainerInfo * container, IHqlEx
                 }
             }
 
-            if (column->hasProperty(_linkCounted_Atom))
+            if (column->hasAttribute(_linkCounted_Atom))
                 created = new CChildLinkedDatasetColumnInfo(container, prior, column, map, defaultMaxRecordSize);
             else if (count || size)
                 created = new CChildLimitedDatasetColumnInfo(container, prior, column, map, defaultMaxRecordSize);

ecl/hqlcpp/hqltcppc2.cpp

@@ -177,7 +177,7 @@ void CChildSetColumnInfo::setColumn(HqlCppTranslator & translator, BuildCtx & ct
 IHqlExpression * CMemberInfo::addDatasetLimits(HqlCppTranslator & translator, BuildCtx & ctx, IReferenceSelector * selector, IHqlExpression * _value)
 {
     LinkedHqlExpr value = _value;
-    IHqlExpression * choosen = column->queryProperty(choosenAtom);
+    IHqlExpression * choosen = column->queryAttribute(choosenAtom);
     if (choosen)
     {
         LinkedHqlExpr choosenValue = choosen->queryChild(0);
@@ -197,7 +197,7 @@ IHqlExpression * CMemberInfo::addDatasetLimits(HqlCppTranslator & translator, Bu
             value.setown(createDataset(no_choosen, LINK(value), LINK(choosenValue)));
     }
 
-    IHqlExpression * maxCount = queryPropertyChild(column, maxCountAtom, 0);
+    IHqlExpression * maxCount = queryAttributeChild(column, maxCountAtom, 0);
     if (maxCount && !hasNoMoreRowsThan(value, getIntValue(maxCount)))
     {
         //Generate a limit test if there isn't a limit that ensures it is small enough
@@ -213,10 +213,10 @@ IHqlExpression * CMemberInfo::addDatasetLimits(HqlCppTranslator & translator, Bu
 
 bool CMemberInfo::hasDatasetLimits() const
 {
-    if (column->queryProperty(choosenAtom))
+    if (column->queryAttribute(choosenAtom))
         return true;
 
-    if (queryPropertyChild(column, maxCountAtom, 0))
+    if (queryAttributeChild(column, maxCountAtom, 0))
         return true;
 
     return false;
@@ -405,12 +405,12 @@ AColumnInfo * CChildDatasetColumnInfo::lookupColumn(IHqlExpression * search)
 
 CChildLimitedDatasetColumnInfo::CChildLimitedDatasetColumnInfo(CContainerInfo * _container, CMemberInfo * _prior, IHqlExpression * _column, RecordOffsetMap & map, unsigned defaultMaxRecordSize) : CColumnInfo(_container, _prior, _column)
 {
-    IHqlExpression * count = column->queryProperty(countAtom);
+    IHqlExpression * count = column->queryAttribute(countAtom);
     if (count)
-        countField.setown(foldHqlExpression(column->queryProperty(countAtom)->queryChild(0)));
+        countField.setown(foldHqlExpression(column->queryAttribute(countAtom)->queryChild(0)));
     else
     {
-        IHqlExpression * size = column->queryProperty(sizeofAtom);
+        IHqlExpression * size = column->queryAttribute(sizeofAtom);
         if (size)
             sizeField.setown(foldHqlExpression(size->queryChild(0)));
         else

ecl/hqlcpp/hqltomita.cpp

@@ -1207,7 +1207,7 @@ void TomitaContext::createSteps(TomRule * self, TomProduction * production, IHql
                 canExpand = isToken(def, expandTokens);
             if (!canExpand)
             {
-                if (expr->hasProperty(_function_Atom))
+                if (expr->hasAttribute(_function_Atom))
                     createSteps(self, production, def, expandTokens);
                 else
                 {
@@ -1420,7 +1420,7 @@ void TomitaContext::generateLexer()
         throwError1(HQLERR_TomitaPatternTooComplex, s.str());
     }
 
-    IHqlExpression * separator = expr->queryProperty(separatorAtom);
+    IHqlExpression * separator = expr->queryAttribute(separatorAtom);
     if (separator)
     {
         RegexContext regex2(expr, wu(), translatorOptions, timeReporter, NLPAregexStack);
@@ -1433,7 +1433,7 @@ void TomitaContext::generateLexer()
     else
         parser.skipDfa.setEmpty();
 
-    IHqlExpression * terminator = expr->queryProperty(terminatorAtom);
+    IHqlExpression * terminator = expr->queryAttribute(terminatorAtom);
     if (terminator)
         addLexerTerminator(terminator->queryChild(0));
 

ecl/hqlcpp/hqlwcpp.cpp

@@ -587,10 +587,10 @@ bool HqlCppWriter::generateFunctionPrototype(IHqlExpression * funcdef, const cha
     IHqlExpression *body = funcdef->queryChild(0);
     IHqlExpression *formals = funcdef->queryChild(1);
 
-    if (body->hasProperty(includeAtom) || body->hasProperty(ctxmethodAtom) || body->hasProperty(gctxmethodAtom) || body->hasProperty(methodAtom) || body->hasProperty(sysAtom) || body->hasProperty(omethodAtom))
+    if (body->hasAttribute(includeAtom) || body->hasAttribute(ctxmethodAtom) || body->hasAttribute(gctxmethodAtom) || body->hasAttribute(methodAtom) || body->hasAttribute(sysAtom) || body->hasAttribute(omethodAtom))
         return false;
 
-    IHqlExpression *proto = body->queryProperty(prototypeAtom);
+    IHqlExpression *proto = body->queryAttribute(prototypeAtom);
     if (proto)
     {
         StringBuffer s;
@@ -599,15 +599,15 @@ bool HqlCppWriter::generateFunctionPrototype(IHqlExpression * funcdef, const cha
         return true;
     }
     enum { ServiceApi, RtlApi, FastApi, CApi, CppApi, LocalApi } api = ServiceApi;
-    bool isVirtual = funcdef->hasProperty(virtualAtom);
-    bool isLocal = body->hasProperty(localAtom);
-    if (body->hasProperty(eclrtlAtom))
+    bool isVirtual = funcdef->hasAttribute(virtualAtom);
+    bool isLocal = body->hasAttribute(localAtom);
+    if (body->hasAttribute(eclrtlAtom))
         api = RtlApi;
-    else if (body->hasProperty(fastAtom))
+    else if (body->hasAttribute(fastAtom))
         api = FastApi;
-    else if (body->hasProperty(cAtom))
+    else if (body->hasAttribute(cAtom))
         api = CApi;
-    else if (body->hasProperty(cppAtom))
+    else if (body->hasAttribute(cppAtom))
         api = CppApi;
     else if (isLocal || isVirtual)
         api = LocalApi;
@@ -656,17 +656,17 @@ bool HqlCppWriter::generateFunctionPrototype(IHqlExpression * funcdef, const cha
 
     bool firstParam = true;
     out.append('(');
-    if (body->hasProperty(contextAtom))
+    if (body->hasAttribute(contextAtom))
     {
         out.append("ICodeContext * ctx");
         firstParam = false;
     }
-    else if (body->hasProperty(globalContextAtom) )
+    else if (body->hasAttribute(globalContextAtom) )
     {
         out.append("IGlobalCodeContext * gctx");
         firstParam = false;
     }
-    else if (body->hasProperty(userMatchFunctionAtom))
+    else if (body->hasAttribute(userMatchFunctionAtom))
     {
         out.append("IMatchWalker * results");
         firstParam = false;
@@ -832,7 +832,7 @@ void HqlCppWriter::generateParamCpp(IHqlExpression * param)
         }
         break;
     case type_set:
-        if (!queryProperty(paramType, oldSetFormatAtom))
+        if (!queryAttribute(paramType, oldSetFormatAtom))
         {
             out.append("bool");
             if (paramName)
@@ -873,7 +873,7 @@ void HqlCppWriter::generateParamCpp(IHqlExpression * param)
             out.append(" &");
         break;
     case type_set:
-        if (!queryProperty(paramType, oldSetFormatAtom))
+        if (!queryAttribute(paramType, oldSetFormatAtom))
         {
             if (isConst)
                 out.append("const ");
@@ -1115,38 +1115,38 @@ StringBuffer & HqlCppWriter::generateExprCpp(IHqlExpression * expr)
                 unsigned firstArg = 0;
                 unsigned numArgs = expr->numChildren();
 
-                if (props->hasProperty(ctxmethodAtom))
+                if (props->hasAttribute(ctxmethodAtom))
                 {
                     out.append("ctx->");
                 }
-                else if (props->hasProperty(gctxmethodAtom))
+                else if (props->hasAttribute(gctxmethodAtom))
                 {
                     out.append("gctx->");
                 }
-                else if (props->hasProperty(methodAtom))
+                else if (props->hasAttribute(methodAtom))
                 {
                     generateExprCpp(expr->queryChild(firstArg)).append("->");
                     ++firstArg;
                 }
-                else if (props->hasProperty(omethodAtom))
+                else if (props->hasAttribute(omethodAtom))
                 {
                     generateExprCpp(expr->queryChild(firstArg)).append(".");
                     ++firstArg;
                 }
-                if (props->hasProperty(namespaceAtom))
+                if (props->hasAttribute(namespaceAtom))
                 {
                     getProperty(props, namespaceAtom, out);
                     out.append("::");
                 }
                 getProperty(props, entrypointAtom, out);
                 out.append('(');
-                if (props->hasProperty(contextAtom))
+                if (props->hasAttribute(contextAtom))
                 {
                     out.append("ctx");
                     if (numArgs)
                         out.append(',');
                 }
-                else if (props->hasProperty(globalContextAtom))
+                else if (props->hasAttribute(globalContextAtom))
                 {
                     out.append("gctx");
                     if (numArgs)
@@ -1237,7 +1237,7 @@ StringBuffer & HqlCppWriter::generateExprCpp(IHqlExpression * expr)
                 generateChildExpr(expr, 0);
                 if (hasWrapperModifier(child->queryType()))
                 {
-                    bool extend = expr->hasProperty(extendAtom);
+                    bool extend = expr->hasAttribute(extendAtom);
                     out.append(".");
                     ITypeInfo * type = expr->queryType();
                     switch (type->getTypeCode())
@@ -1362,7 +1362,7 @@ StringBuffer & HqlCppWriter::generateExprCpp(IHqlExpression * expr)
             {
                 IHqlExpression * body = expr->queryChild(0);
                 assertex(body->getOperator() == no_external);
-                IHqlExpression * entrypoint = queryPropertyChild(body, entrypointAtom, 0);
+                IHqlExpression * entrypoint = queryAttributeChild(body, entrypointAtom, 0);
                 getStringValue(out, entrypoint);
                 break;
             }

esp/services/ws_workunits/ws_workunitsHelpers.cpp

@@ -1279,11 +1279,11 @@ void WsWuInfo::getEclSchemaFields(IArrayOf<IEspECLSchemaItem>& schemas, IHqlExpr
         }
     case no_field:
         {
-            if (expr->hasProperty(__ifblockAtom))
+            if (expr->hasAttribute(__ifblockAtom))
                 break;
             ITypeInfo * type = expr->queryType();
             IAtom * name = expr->queryName();
-            IHqlExpression * nameAttr = expr->queryProperty(namedAtom);
+            IHqlExpression * nameAttr = expr->queryAttribute(namedAtom);
             StringBuffer outname;
             if (nameAttr && nameAttr->queryChild(0) && nameAttr->queryChild(0)->queryValue())
                 nameAttr->queryChild(0)->queryValue()->getStringValue(outname);