HPCC-18276 Generate override attribute on helper functions

Also clean up any resulting issues with unneccessary funtions having been
generated.

Signed-off-by: Richard Chapman <rchapman@hpccsystems.com>

ecl/hqlcpp/hqlckey.cpp

@@ -196,7 +196,7 @@ void HqlCppTranslator::buildJoinMatchFunction(BuildCtx & ctx, const char * name,
     if (match)
     {
         StringBuffer proto;
-        proto.append("virtual bool ").append(name).append("(const void * _left, const void * _right)" OPTIMIZE_FUNCTION_ATTRIBUTE);
+        proto.append("virtual bool ").append(name).append("(const void * _left, const void * _right) override" OPTIMIZE_FUNCTION_ATTRIBUTE);
 
         MemberFunction matchFunc(*this, ctx, proto, MFdynamicproto);
 
@@ -427,7 +427,7 @@ void KeyedJoinInfo::buildClearRightFunction(BuildCtx & classctx)
     {
         //Need to initialize the record with the zero logical values, not zero key values
         //which differs for biased integers etc.
-        MemberFunction func(translator, classctx, "virtual size32_t createDefaultRight(ARowBuilder & crSelf)");
+        MemberFunction func(translator, classctx, "virtual size32_t createDefaultRight(ARowBuilder & crSelf) override");
         translator.ensureRowAllocated(func.ctx, "crSelf");
         
         BoundRow * selfCursor = translator.bindSelf(func.ctx, rawKey, "crSelf");
@@ -447,7 +447,7 @@ void KeyedJoinInfo::buildExtractFetchFields(BuildCtx & ctx)
     //virtual size32_t extractFetchFields(ARowBuilder & crSelf, const void * _left) = 0;
     if (fileAccessDataset)
     {
-        MemberFunction func(translator, ctx, "virtual size32_t extractFetchFields(ARowBuilder & crSelf, const void * _left)");
+        MemberFunction func(translator, ctx, "virtual size32_t extractFetchFields(ARowBuilder & crSelf, const void * _left) override");
         translator.ensureRowAllocated(func.ctx, "crSelf");
         if (fileAccessTransform)
         {
@@ -467,7 +467,7 @@ void KeyedJoinInfo::buildExtractFetchFields(BuildCtx & ctx)
 void KeyedJoinInfo::buildExtractIndexReadFields(BuildCtx & ctx)
 {
     //virtual size32_t extractIndexReadFields(ARowBuilder & crSelf, const void * _left) = 0;
-    MemberFunction func(translator, ctx, "virtual size32_t extractIndexReadFields(ARowBuilder & crSelf, const void * _left)");
+    MemberFunction func(translator, ctx, "virtual size32_t extractIndexReadFields(ARowBuilder & crSelf, const void * _left) override");
     translator.ensureRowAllocated(func.ctx, "crSelf");
     if (keyAccessTransform)
     {
@@ -486,7 +486,7 @@ void KeyedJoinInfo::buildExtractIndexReadFields(BuildCtx & ctx)
 void KeyedJoinInfo::buildExtractJoinFields(ActivityInstance & instance)
 {
     //virtual size32_t extractJoinFields(void *dest, const void *diskRow, IBlobProvider * blobs) = 0;
-    MemberFunction func(translator, instance.startctx, "virtual size32_t extractJoinFields(ARowBuilder & crSelf, const void *_left, unsigned __int64 _filepos, IBlobProvider * blobs)");
+    MemberFunction func(translator, instance.startctx, "virtual size32_t extractJoinFields(ARowBuilder & crSelf, const void *_left, unsigned __int64 _filepos, IBlobProvider * blobs) override");
     translator.ensureRowAllocated(func.ctx, "crSelf");
     if (needToExtractJoinFields())
     {
@@ -528,7 +528,7 @@ void KeyedJoinInfo::buildIndexReadMatch(BuildCtx & ctx)
 
     if (matchExpr)
     {
-        MemberFunction func(translator, ctx, "virtual bool indexReadMatch(const void * _left, const void * _right, unsigned __int64 _filepos, IBlobProvider * blobs)");
+        MemberFunction func(translator, ctx, "virtual bool indexReadMatch(const void * _left, const void * _right, unsigned __int64 _filepos, IBlobProvider * blobs) override");
 
         func.ctx.addQuotedLiteral("const unsigned char * left = (const unsigned char *) _left;");
         func.ctx.addQuotedLiteral("const unsigned char * right = (const unsigned char *) _right;");
@@ -554,7 +554,7 @@ void KeyedJoinInfo::buildLeftOnly(BuildCtx & ctx)
 {
     if (leftOnlyMatch)
     {
-        MemberFunction func(translator, ctx, "virtual bool leftCanMatch(const void * _left)");
+        MemberFunction func(translator, ctx, "virtual bool leftCanMatch(const void * _left) override");
         func.ctx.addQuotedLiteral("const unsigned char * left = (const unsigned char *)_left;");
         translator.bindTableCursor(func.ctx, expr->queryChild(0), "left", no_left, joinSeq);
         translator.buildReturn(func.ctx, leftOnlyMatch);
@@ -567,7 +567,7 @@ void KeyedJoinInfo::buildMonitors(BuildCtx & ctx)
     monitors->optimizeSegments(keyAccessDataset->queryRecord());
 
     //---- virtual void createSegmentMonitors(struct IIndexReadContext *) { ... } ----
-    MemberFunction func(translator, ctx, "virtual void createSegmentMonitors(IIndexReadContext *irc, const void * _left)");
+    MemberFunction func(translator, ctx, "virtual void createSegmentMonitors(IIndexReadContext *irc, const void * _left) override");
     func.ctx.addQuotedLiteral("const unsigned char * left = (const unsigned char *) _left;");
     translator.bindTableCursor(func.ctx, keyAccessDataset, "left", no_left, joinSeq);
     monitors->buildSegments(func.ctx, "irc", false);
@@ -582,13 +582,13 @@ void KeyedJoinInfo::buildTransform(BuildCtx & ctx)
     case no_join:
     case no_denormalize:
         {
-            func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned __int64 _filepos, unsigned counter)");
+            func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned __int64 _filepos, unsigned counter) override");
             translator.associateCounter(func.ctx, counter, "counter");
             break;
         }
     case no_denormalizegroup:
         {
-            func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned numRows, const void * * _rows)");
+            func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned numRows, const void * * _rows) override");
             func.ctx.addQuotedLiteral("const byte * * rows = (const byte * *) _rows;");
             break;
         }
@@ -749,7 +749,7 @@ void KeyedJoinInfo::buildTransformBody(BuildCtx & ctx, IHqlExpression * transfor
 
 void KeyedJoinInfo::buildFailureTransform(BuildCtx & ctx, IHqlExpression * onFailTransform)
 {
-    MemberFunction func(translator, ctx, "virtual size32_t onFailTransform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned __int64 _filepos, IException * except)");
+    MemberFunction func(translator, ctx, "virtual size32_t onFailTransform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned __int64 _filepos, IException * except) override");
     translator.associateLocalFailure(func.ctx, "except");
     translator.ensureRowAllocated(func.ctx, "crSelf");
 
@@ -1249,7 +1249,7 @@ void HqlCppTranslator::buildKeyedJoinExtra(ActivityInstance & instance, IHqlExpr
     {
         IHqlExpression * index = info->queryKey();
         IHqlExpression * indexRecord = index->queryRecord();
-        MemberFunction func(*this, instance.startctx, "virtual unsigned __int64 extractPosition(const void * _right)");
+        MemberFunction func(*this, instance.startctx, "virtual unsigned __int64 extractPosition(const void * _right) override");
         func.ctx.addQuotedLiteral("const unsigned char * right = (const unsigned char *) _right;");
         bindTableCursor(func.ctx, index, "right");
         OwnedHqlExpr fileposExpr = createSelectExpr(LINK(index), LINK(indexRecord->queryChild(indexRecord->numChildren()-1)));
@@ -1279,7 +1279,7 @@ void HqlCppTranslator::buildKeyedJoinExtra(ActivityInstance & instance, IHqlExpr
     {
         if (limit->hasAttribute(skipAtom))
         {
-            MemberFunction func(*this, instance.startctx, "virtual unsigned __int64 getSkipLimit()");
+            MemberFunction func(*this, instance.startctx, "virtual unsigned __int64 getSkipLimit() override");
             buildReturn(func.ctx, limit->queryChild(0));
         }
         else

ecl/hqlcpp/hqlcpp.cpp

@@ -66,7 +66,7 @@
 #define MAX_SIMPLE_VAR_SIZE             99999
 #define MAX_STATIC_ROW_SIZE             10000
 #define MAX_LOCAL_ROW_SIZE              32
-#define DEFAULT_NLP_DETAIL              1
+#define DEFAULT_NLP_DETAIL              0
 #define DEFAULT_EXPIRY_PERIOD               7
 #define DEFAULT_PERSIST_EXPIRY_PERIOD       0           // Persists that expire by default have a period defined in sasha
 

ecl/hqlcpp/hqlcset.cpp

@@ -110,7 +110,7 @@ void BaseDatasetCursor::buildIterateMembers(BuildCtx & declarectx, BuildCtx & in
     //row = iter.first()
     {
         BuildCtx firstctx(declarectx);
-        firstctx.addQuotedFunction("virtual bool first()");
+        firstctx.addQuotedFunction("virtual bool first() override");
         s.clear().append(rowName).append(" = (byte *)").append(iterName).append(".first();");
         firstctx.addQuoted(s);
         s.clear().append("return ").append(rowName).append(" != NULL;");
@@ -120,7 +120,7 @@ void BaseDatasetCursor::buildIterateMembers(BuildCtx & declarectx, BuildCtx & in
     //row = iter.first()
     {
         BuildCtx nextctx(declarectx);
-        nextctx.addQuotedFunction("virtual bool next()");
+        nextctx.addQuotedFunction("virtual bool next() override");
         s.clear().append(rowName).append(" = (byte *)").append(iterName).append(".next();");
         nextctx.addQuoted(s);
         s.clear().append("return ").append(rowName).append(" != NULL;");

ecl/hqlcpp/hqlinline.cpp

@@ -1470,7 +1470,7 @@ void CtxCollection::createFunctionStructure(HqlCppTranslator & translator, Build
         //virtual void serializeCreateContext(MemoryBuffer & out)
         serializectx.setown(new BuildCtx(declarectx));
         StringBuffer s;
-        s.append("virtual void ").append(serializeFunc).append("(MemoryBuffer & out)");
+        s.append("virtual void ").append(serializeFunc).append("(MemoryBuffer & out) override");
         serializectx->addQuotedCompoundOpt(s.str());
     } else if (canEvaluate)
     {

ecl/hqlcpp/hqliter.cpp

@@ -280,10 +280,10 @@ void CompoundIteratorBuilder::createSingleIterator(StringBuffer & iterName, IHql
     IHqlExpression * root = queryRoot(expr);
     if (expr->queryBody() == root)
     {
-        MemberFunction firstfunc(translator, classctx, "virtual const byte * first()");
+        MemberFunction firstfunc(translator, classctx, "virtual const byte * first() override");
         createRawFirstFunc(firstfunc.ctx, expr, cursors);
 
-        MemberFunction nextfunc(translator, classctx, "virtual const byte * next()");
+        MemberFunction nextfunc(translator, classctx, "virtual const byte * next() override");
         createRawNextFunc(nextfunc.ctx, expr, cursors);
     }
     else
@@ -291,7 +291,7 @@ void CompoundIteratorBuilder::createSingleIterator(StringBuffer & iterName, IHql
         MemberFunction rawfirstfunc(translator, classctx, "inline const byte * rawFirst()");
         createRawFirstFunc(rawfirstfunc.ctx, root, cursors);
 
-        MemberFunction rawnextfunc(translator, classctx, "virtual const byte * rawNext()");
+        MemberFunction rawnextfunc(translator, classctx, "inline const byte * rawNext()");
         createRawNextFunc(rawnextfunc.ctx, root, cursors);
 
         OwnedHqlExpr failValue = createTranslatedOwned(createValue(no_nullptr, makeVoidType()));
@@ -309,14 +309,14 @@ void CompoundIteratorBuilder::createSingleIterator(StringBuffer & iterName, IHql
         checkfunc.ctx.addReturn(row);
 
         BuildCtx firstctx(classctx);
-        firstctx.addQuotedFunction("virtual const byte * first()");
+        firstctx.addQuotedFunction("virtual const byte * first() override");
         firstctx.addQuotedLiteral("if (!rawFirst()) return NULL;");
         firstctx.addQuotedCompoundLiteral("for (;;)");
         firstctx.addQuotedLiteral("const byte * valid = checkValid(); if (valid) return valid;");
         firstctx.addQuotedLiteral("if (!rawNext()) return NULL;");
 
         BuildCtx nextctx(classctx);
-        nextctx.addQuotedFunction("virtual const byte * next()");
+        nextctx.addQuotedFunction("virtual const byte * next() override");
         nextctx.addQuotedCompoundLiteral("for (;;)");
         nextctx.addQuotedLiteral("if (!rawNext()) return NULL;");
         nextctx.addQuotedLiteral("const byte * valid = checkValid(); if (valid) return valid;");

ecl/hqlcpp/hqllib.cpp

@@ -479,7 +479,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityLibrarySelect(BuildCtx & ctx,
 
 void HqlCppTranslator::buildLibraryInstanceExtract(BuildCtx & ctx, HqlCppLibraryInstance * libraryInstance)
 {
-    MemberFunction func(*this, ctx, "virtual void createParentExtract(rtlRowBuilder & builder)");
+    MemberFunction func(*this, ctx, "virtual void createParentExtract(rtlRowBuilder & builder) override");
 
     BuildCtx beforeBuilderCtx(func.ctx);
     beforeBuilderCtx.addGroup();
@@ -583,7 +583,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityLibraryInstance(BuildCtx & ctx
 
     StringBuffer s;
     BuildCtx metactx(instance->classctx);
-    metactx.addQuotedFunction("virtual IOutputMetaData * queryOutputMeta(unsigned whichOutput)");
+    metactx.addQuotedFunction("virtual IOutputMetaData * queryOutputMeta(unsigned whichOutput) override");
     BuildCtx switchctx(metactx);
     switchctx.addQuotedCompoundLiteral("switch (whichOutput)");
 
@@ -602,7 +602,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityLibraryInstance(BuildCtx & ctx
 
     {
         //Library Name must be onCreate invariant
-        MemberFunction func(*this, instance->createctx, "virtual char * getLibraryName()");
+        MemberFunction func(*this, instance->createctx, "virtual char * getLibraryName() override");
         buildReturn(func.ctx, name, unknownVarStringType);
     }
 

ecl/hqlcpp/hqlnlp.cpp

@@ -221,7 +221,7 @@ void NlpParseContext::buildValidators(HqlCppTranslator & translator, BuildCtx &
         IHqlStmt * helperClassStmt = translator.beginNestedClass(helperctx, "helper", "INlpHelper");
 
         BuildCtx funcctx(helperctx);
-        funcctx.addQuotedFunction("virtual IValidator * queryValidator(unsigned i)");
+        funcctx.addQuotedFunction("virtual IValidator * queryValidator(unsigned i) override");
         BuildCtx casectx(funcctx);
         casectx.addQuotedCompoundLiteral("switch (i)");
 
@@ -242,14 +242,14 @@ void NlpParseContext::buildValidators(HqlCppTranslator & translator, BuildCtx &
                 CHqlBoundExpr boundMatched;
                 if (kind != ValidateIsUnicode)
                 {
-                    func.start("virtual bool isValid(unsigned len, const char * data)");
+                    func.start("virtual bool isValid(unsigned len, const char * data) override");
                     boundMatched.length.setown(createVariable("len", LINK(sizetType)));
                     boundMatched.expr.setown(createVariable("data", makeReferenceModifier(LINK(unknownStringType))));
                     func.ctx.associateExpr(activeMatchTextExpr, boundMatched);
                 }
                 else
                 {
-                    func.start("virtual bool isValid(unsigned len, const UChar * data)");
+                    func.start("virtual bool isValid(unsigned len, const UChar * data) override");
                     boundMatched.length.setown(createVariable("len", LINK(sizetType)));
                     boundMatched.expr.setown(createVariable("data", makeReferenceModifier(LINK(unknownUnicodeType))));
                     func.ctx.associateExpr(activeMatchUnicodeExpr, boundMatched);
@@ -271,7 +271,7 @@ void NlpParseContext::buildValidators(HqlCppTranslator & translator, BuildCtx &
         funcctx.addReturn(queryQuotedNullExpr());
 
         translator.endNestedClass(helperClassStmt);
-        classctx.addQuotedLiteral("virtual INlpHelper * queryHelper() { return &helper; }");
+        classctx.addQuotedLiteral("virtual INlpHelper * queryHelper() override { return &helper; }");
     }
 }
 
@@ -283,7 +283,7 @@ void NlpParseContext::buildProductions(HqlCppTranslator & translator, BuildCtx &
 
     {
         BuildCtx metactx(classctx);
-        metactx.addQuotedFunction("virtual IOutputMetaData * queryProductionMeta(unsigned id)");
+        metactx.addQuotedFunction("virtual IOutputMetaData * queryProductionMeta(unsigned id) override");
 
         BuildCtx metacasectx(metactx);
         metacasectx.addQuotedCompoundLiteral("switch (id)");
@@ -305,7 +305,7 @@ void NlpParseContext::buildProductions(HqlCppTranslator & translator, BuildCtx &
     {
         OwnedHqlExpr callback = createVariable("input", makeBoolType());
 
-        MemberFunction func(translator, startctx, "virtual size32_t executeProduction(ARowBuilder & crSelf, unsigned id, IProductionCallback * input)");
+        MemberFunction func(translator, startctx, "virtual size32_t executeProduction(ARowBuilder & crSelf, unsigned id, IProductionCallback * input) override");
         func.ctx.associateExpr(activeProductionMarkerExpr, callback);
 
         BuildCtx prodcasectx(func.ctx);
@@ -509,7 +509,7 @@ void NlpParseContext::setParserOptions(INlpParseAlgorithm & parser)
 
 void HqlCppTranslator::doBuildParseTransform(BuildCtx & classctx, IHqlExpression * expr)
 {
-    MemberFunction func(*this, classctx, "virtual size32_t transform(ARowBuilder & crSelf, const void * _left, IMatchedResults * matched, IMatchWalker * walker)");
+    MemberFunction func(*this, classctx, "virtual size32_t transform(ARowBuilder & crSelf, const void * _left, IMatchedResults * matched, IMatchWalker * walker) override");
     ensureRowAllocated(func.ctx, "crSelf");
     func.ctx.addQuotedLiteral("const unsigned char * left = (const unsigned char *) _left;");
     func.ctx.associateExpr(activeNlpMarkerExpr, activeNlpMarkerExpr);
@@ -540,11 +540,11 @@ void HqlCppTranslator::doBuildParseSearchText(BuildCtx & classctx, IHqlExpressio
 
         if (searchTypeCode == type_unicode)
         {
-            func.start("virtual void getSearchText(size32_t & retLen, char * & _retText, const void * _self)");
+            func.start("virtual void getSearchText(size32_t & retLen, char * & _retText, const void * _self) override");
             func.ctx.addQuotedLiteral("UChar * & retText = *(UChar * *)&_retText;");        // don't ask.
         }
         else
-            func.start("virtual void getSearchText(size32_t & retLen, char * & retText, const void * _self)");
+            func.start("virtual void getSearchText(size32_t & retLen, char * & retText, const void * _self) override");
         func.ctx.addQuotedLiteral("const unsigned char * self = (const unsigned char *) _self;");
         bindTableCursor(func.ctx, dataset, "self");
 
@@ -648,7 +648,7 @@ void HqlCppTranslator::doBuildParseCompiled(BuildCtx & classctx, MemoryBuffer &
     OwnedHqlExpr srcData = addDataLiteral((const char *)compressed.toByteArray(), buffLen);
     OwnedHqlExpr retData = createVariable("retData", makePointerType(makeVoidType()));
 
-    funcctx.addQuotedFunction("virtual void queryCompiled(IResourceContext *ctx, size32_t & retLen, const void * & retData)");
+    funcctx.addQuotedFunction("virtual void queryCompiled(IResourceContext *ctx, size32_t & retLen, const void * & retData) override");
     funcctx.addQuotedF("//uncompressed size = %d", buffer.length());
     buildExpr(funcctx, srcData, bound);
 

ecl/hqlcpp/hqlsource.cpp

@@ -642,7 +642,7 @@ public:
             {
                 outputStepping.generateSteppingMetaMember(translator, ctx, "ProjectedSteppingMeta");
 
-                MemberFunction func(translator, ctx, "virtual void mapOutputToInput(ARowBuilder & crSelf, const void * _projected, unsigned numFields)");
+                MemberFunction func(translator, ctx, "virtual void mapOutputToInput(ARowBuilder & crSelf, const void * _projected, unsigned numFields) override");
                 translator.ensureRowAllocated(func.ctx, "crSelf");
                 func.ctx.addQuotedLiteral("const byte * pr = (const byte *)_projected;");
 
@@ -663,7 +663,7 @@ public:
         else
         {
             OwnedHqlExpr fail = createValue(no_fail, makeVoidType(), createConstant("Cannot step output of index read"));
-            MemberFunction func(translator, ctx, "virtual void mapOutputToInput(void * _original, const void * _projected, unsigned numFields)");
+            MemberFunction func(translator, ctx, "virtual void mapOutputToInput(ARowBuilder & crSelf, const void * _projected, unsigned numFields) override");
             translator.buildStmt(func.ctx, fail);
         }
     }
@@ -1151,12 +1151,11 @@ void SourceBuilder::buildFilenameMember()
 void SourceBuilder::buildReadMembers(IHqlExpression * expr)
 {
     buildFilenameMember();
-    
     //---- virtual bool needTransform() { return <bool>; } ----
     if (needToCallTransform || transformCanFilter)
         translator.doBuildBoolFunction(instance->classctx, "needTransform", true);
 
-    //---- virtual bool needTransform() { return <bool>; } ----
+    //---- virtual bool transformMayFilter() { return <bool>; } ----
     if (transformCanFilter)
         translator.doBuildBoolFunction(instance->classctx, "transformMayFilter", true);
 }
@@ -1168,7 +1167,7 @@ void SourceBuilder::buildLimits(BuildCtx & classctx, IHqlExpression * expr, uniq
 
     if (choosenValue)
     {
-        MemberFunction func(translator, classctx, "virtual unsigned __int64 getChooseNLimit()");
+        MemberFunction func(translator, classctx, "virtual unsigned __int64 getChooseNLimit() override");
         OwnedHqlExpr newLimit = ensurePositiveOrZeroInt64(choosenValue);
         translator.buildReturn(func.ctx, newLimit);
     }
@@ -1657,13 +1656,13 @@ void SourceBuilder::doBuildNormalizeIterators(BuildCtx & ctx, IHqlExpression * e
     if (isChildIterator)
     {
         assertex(!root);
-        firstFunc.start("virtual bool first()");
+        firstFunc.start("virtual bool first() override");
     }
     else
     {
         assertex(root);
 
-        firstFunc.start("virtual bool first(const void * _src)");
+        firstFunc.start("virtual bool first(const void * _src) override");
         bool isProjected = (root->queryNormalizedSelector() != tableExpr->queryNormalizedSelector());
         if (!isProjected)
         {
@@ -1703,7 +1702,7 @@ void SourceBuilder::doBuildNormalizeIterators(BuildCtx & ctx, IHqlExpression * e
 
         {
             BuildCtx nextctx(instance->startctx);
-            nextctx.addQuotedFunction("virtual bool next()");
+            nextctx.addQuotedFunction("virtual bool next() override");
             nextctx.addQuoted(s.clear().append("return (").append(cursorName).append(" = (byte *)").append(iterName).append(".next()) != 0;"));
         }
     }
@@ -1715,7 +1714,7 @@ void SourceBuilder::doBuildNormalizeIterators(BuildCtx & ctx, IHqlExpression * e
 
         {
             BuildCtx nextctx(instance->startctx);
-            nextctx.addQuotedFunction("virtual bool next()");
+            nextctx.addQuotedFunction("virtual bool next() override");
             nextctx.addQuotedLiteral("return iter.next();");
         }
     }
@@ -1999,7 +1998,7 @@ ABoundActivity * SourceBuilder::buildActivity(BuildCtx & ctx, IHqlExpression * e
         buildTransform(expr);
         buildFlagsMember(expr);
 
-        if (tableExpr)
+        if (tableExpr && (activityKind < TAKchildread || activityKind > TAKchildthroughnormalize))
         {
             if (fieldInfo.hasVirtualsOrDeserialize())
             {
@@ -2074,7 +2073,7 @@ void SourceBuilder::buildKeyedLimitHelper(IHqlExpression * self)
     {
         IHqlExpression * limitValue = keyedLimitExpr->queryChild(1);
         {
-            MemberFunction func(translator, instance->startctx, "virtual unsigned __int64 getKeyedLimit()");
+            MemberFunction func(translator, instance->startctx, "virtual unsigned __int64 getKeyedLimit() override");
             translator.buildReturn(func.ctx, limitValue);
             if (isZero(limitValue))
                 translator.WARNING(CategoryUnusual, HQLWRN_KeyedLimitIsZero);
@@ -2085,14 +2084,14 @@ void SourceBuilder::buildKeyedLimitHelper(IHqlExpression * self)
             fail.setown(translator.createFailAction("Keyed limit exceeded", limitValue, NULL, instance->activityId));
 
         {
-            MemberFunction func(translator, instance->startctx, "virtual void onKeyedLimitExceeded()");
+            MemberFunction func(translator, instance->startctx, "virtual void onKeyedLimitExceeded() override");
             translator.buildStmt(func.ctx, fail);
         }
 
         IHqlExpression * transform = queryAttributeChild(keyedLimitExpr, onFailAtom, 0);
         if (transform)
         {
-            MemberFunction func(translator, instance->startctx, "virtual size32_t transformOnKeyedLimitExceeded(ARowBuilder & crSelf)");
+            MemberFunction func(translator, instance->startctx, "virtual size32_t transformOnKeyedLimitExceeded(ARowBuilder & crSelf) override");
             translator.ensureRowAllocated(func.ctx, "crSelf");
             translator.buildTransformBody(func.ctx, transform, NULL, NULL, self, NULL);
         }
@@ -2149,13 +2148,13 @@ void SourceBuilder::assignLocalExtract(BuildCtx & ctx, ParentExtract * extractBu
 
 void SourceBuilder::buildGroupAggregateHashHelper(ParentExtract * extractBuilder, IHqlExpression * dataset, IHqlExpression * fields)
 {
-    instance->classctx.addQuotedLiteral("virtual IHash * queryHash() { return &hash; }");
+    instance->classctx.addQuotedLiteral("virtual IHash * queryHash() override { return &hash; }");
 
     BuildCtx classctx(instance->nestedctx);
     IHqlStmt * classStmt = translator.beginNestedClass(classctx, "hash", "IHash", NULL, extractBuilder);
 
     {
-        MemberFunction func(translator, classctx, "virtual unsigned hash(const void * _self)");
+        MemberFunction func(translator, classctx, "virtual unsigned hash(const void * _self) override");
         assignLocalExtract(func.ctx, extractBuilder, dataset, "_self");
 
         OwnedHqlExpr hash = createValue(no_hash32, LINK(unsignedType), LINK(fields), createAttribute(internalAtom));
@@ -2213,13 +2212,13 @@ void SourceBuilder::buildGroupAggregateCompareHelper(ParentExtract * extractBuil
     OwnedHqlExpr order = createValue(no_order, makeIntType(sizeof(signed), true), LINK(leftList), LINK(rightResolved));
 
     //Now generate the nested class
-    instance->classctx.addQuotedLiteral("virtual ICompare * queryCompareRowElement() { return &compareRowElement; }");
+    instance->classctx.addQuotedLiteral("virtual ICompare * queryCompareRowElement() override { return &compareRowElement; }");
 
     BuildCtx classctx(instance->nestedctx);
     IHqlStmt * classStmt = translator.beginNestedClass(classctx, "compareRowElement", "ICompare", NULL, extractBuilder);
 
     {
-        MemberFunction func(translator, classctx, "virtual int docompare(const void * _left, const void * _right) const");
+        MemberFunction func(translator, classctx, "virtual int docompare(const void * _left, const void * _right) const override");
         assignLocalExtract(func.ctx, extractBuilder, aggregate->queryChild(0), "_left");
         func.ctx.addQuotedLiteral("const unsigned char * right = (const unsigned char *) _right;");
         func.ctx.associateExpr(constantMemberMarkerExpr, constantMemberMarkerExpr);
@@ -2239,7 +2238,7 @@ void SourceBuilder::buildGroupAggregateProcessHelper(ParentExtract * extractBuil
     IHqlExpression * tgtRecord = aggregate->queryChild(1);
     OwnedHqlExpr resultDataset = createDataset(no_anon, LINK(tgtRecord));
 
-    proto.append("virtual size32_t ").append(name).append("(ARowBuilder & crSelf, const void * _src)");
+    proto.append("virtual size32_t ").append(name).append("(ARowBuilder & crSelf, const void * _src) override");
     MemberFunction validateFunc(translator, instance->nestedctx, proto, MFdynamicproto);
 
     translator.ensureRowAllocated(validateFunc.ctx, "crSelf");
@@ -2350,13 +2349,13 @@ void SourceBuilder::buildGlobalGroupAggregateHelpers(IHqlExpression * expr)
     //virtual void processRow(void * self, const void * src) = 0;
     {
         BuildCtx rowctx(instance->startctx);
-        rowctx.addQuotedFunction("virtual void processRow(const void * src, IHThorGroupAggregateCallback * callback)");
+        rowctx.addQuotedFunction("virtual void processRow(const void * src, IHThorGroupAggregateCallback * callback) override");
         rowctx.addQuotedLiteral("doProcessRow((byte *)src, callback);");
     }
 
     //virtual void processRows(void * self, size32_t srcLen, const void * src) = 0;
     {
-        MemberFunction func(translator, instance->startctx, "virtual void processRows(size32_t srcLen, const void * _left, IHThorGroupAggregateCallback * callback)");
+        MemberFunction func(translator, instance->startctx, "virtual void processRows(size32_t srcLen, const void * _left, IHThorGroupAggregateCallback * callback) override");
         func.ctx.addQuotedLiteral("unsigned char * left = (unsigned char *)_left;");
         OwnedHqlExpr ds = createVariable("left", makeReferenceModifier(tableExpr->getType()));
         OwnedHqlExpr len = createVariable("srcLen", LINK(sizetType));
@@ -2381,7 +2380,7 @@ void SourceBuilder::buildGroupingMonitors(IHqlExpression * expr, MonitorExtracto
     IHqlExpression * grouping = aggregate->queryChild(3);
 
     //virtual void createGroupSegmentMonitors(IIndexReadContext *ctx) = 0;
-    MemberFunction func(translator, instance->startctx, "virtual bool createGroupSegmentMonitors(IIndexReadContext * irc)");
+    MemberFunction func(translator, instance->startctx, "virtual bool createGroupSegmentMonitors(IIndexReadContext * irc) override");
 
     monitorsForGrouping = true;
     if (op == no_newaggregate)
@@ -2449,13 +2448,13 @@ void SourceBuilder::buildCountHelpers(IHqlExpression * expr, bool allowMultiple)
             //virtual size32_t numValid(const void * src) = 0;
             {
                 BuildCtx rowctx(instance->startctx);
-                rowctx.addQuotedFunction("virtual size32_t numValid(const void * src)");
+                rowctx.addQuotedFunction("virtual size32_t numValid(const void * src) override");
                 rowctx.addQuotedLiteral("return valid((byte *)src);");
             }
 
             //virtual size32_t numValid(size32_t srcLen, const void * src);
             {
-                MemberFunction func(translator, instance->startctx, "virtual size32_t numValid(size32_t srcLen, const void * _src)");
+                MemberFunction func(translator, instance->startctx, "virtual size32_t numValid(size32_t srcLen, const void * _src) override");
                 func.ctx.addQuotedLiteral("unsigned char * src = (unsigned char *)_src;");
                 OwnedHqlExpr ds = createVariable("src", makeReferenceModifier(tableExpr->getType()));
                 OwnedHqlExpr len = createVariable("srcLen", LINK(sizetType));
@@ -2488,7 +2487,7 @@ void SourceBuilder::buildCountHelpers(IHqlExpression * expr, bool allowMultiple)
         else
         {
             //virtual size32_t numValid(size32_t srcLen, const void * src);
-            MemberFunction func(translator, instance->startctx, "virtual size32_t numValid(size32_t srcLen, const void * _src)");
+            MemberFunction func(translator, instance->startctx, "virtual size32_t numValid(size32_t srcLen, const void * _src) override");
             if (isExists)
                 func.ctx.addReturn(one);
             else
@@ -2662,7 +2661,7 @@ public:
         logicalFilenameMarker.setown(getFileLogicalName(tableExpr));
         mode = tableExpr->queryChild(2);
         modeOp = mode->getOperator();
-        includeFormatCrc = (modeOp != no_csv);
+        includeFormatCrc = (modeOp != no_csv && modeOp != no_pipe);
     }
 
     virtual void buildMembers(IHqlExpression * expr);
@@ -2688,7 +2687,7 @@ void DiskReadBuilderBase::buildMembers(IHqlExpression * expr)
     //Process any KEYED() information
     if (monitors.isFiltered())
     {
-        MemberFunction func(translator, instance->startctx, "virtual void createSegmentMonitors(IIndexReadContext *irc)");
+        MemberFunction func(translator, instance->startctx, "virtual void createSegmentMonitors(IIndexReadContext *irc) override");
         monitors.buildSegments(func.ctx, "irc", true);
     }
     instance->addAttributeBool("_isKeyed", monitors.isFiltered());
@@ -2723,11 +2722,9 @@ void DiskReadBuilderBase::buildMembers(IHqlExpression * expr)
 
     translator.buildEncryptHelper(instance->startctx, tableExpr->queryAttribute(encryptAtom));
 
-    //---- virtual size32_t getPreloadSize() { return <value>; } ----
+    //---- preloadSize is passed via the xgmml, not via a member
     if (preloadSize)
     {
-        MemberFunction func(translator, instance->classctx, "virtual size32_t getPreloadSize()");
-        translator.buildReturn(func.ctx, preloadSize, sizetType);
         instance->addAttributeInt("_preloadSize", preloadSize->queryValue()->getIntValue());
     }
 
@@ -2845,7 +2842,10 @@ public:
 
 void DiskReadBuilder::buildMembers(IHqlExpression * expr)
 {
-    buildReadMembers(expr);
+    if (modeOp == no_csv)
+        buildFilenameMember();
+    else if (modeOp != no_pipe)
+        buildReadMembers(expr);
     DiskReadBuilderBase::buildMembers(expr);
 
     //---- virtual const char * getPipeProgram() { return "grep"; } ----
@@ -2855,7 +2855,7 @@ void DiskReadBuilder::buildMembers(IHqlExpression * expr)
             throwError(HQLERR_PipeNotAllowed);
 
         {
-            MemberFunction func(translator, instance->startctx, "virtual const char * getPipeProgram()");
+            MemberFunction func(translator, instance->startctx, "virtual const char * getPipeProgram() override");
             translator.buildReturn(func.ctx, mode->queryChild(0), unknownVarStringType);
         }
 
@@ -2870,7 +2870,7 @@ void DiskReadBuilder::buildMembers(IHqlExpression * expr)
                 translator.buildCsvReadTransformer(tableExpr, csvInstanceName, csvFromPipe);
 
                 StringBuffer s;
-                s.append("virtual ICsvToRowTransformer * queryCsvTransformer() { return &").append(csvInstanceName).append("; }");
+                s.append("virtual ICsvToRowTransformer * queryCsvTransformer() override { return &").append(csvInstanceName).append("; }");
                 instance->classctx.addQuoted(s);
             }
             else
@@ -2916,7 +2916,7 @@ void DiskReadBuilder::buildTransform(IHqlExpression * expr)
         translator.buildCsvParameters(instance->nestedctx, mode, NULL, true);
 
         {
-            MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf, unsigned * lenSrc, const char * * dataSrc)");
+            MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf, unsigned * lenSrc, const char * * dataSrc) override");
             translator.ensureRowAllocated(func.ctx, "crSelf");
 
             //associateVirtualCallbacks(*this, func.ctx, tableExpr);
@@ -2933,9 +2933,9 @@ void DiskReadBuilder::buildTransform(IHqlExpression * expr)
 
     MemberFunction func(translator, instance->startctx);
     if (instance->kind == TAKdiskread)
-        func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left)");
+        func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left) override");
     else
-        func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left, IFilePositionProvider * fpp)");
+        func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left, IFilePositionProvider * fpp) override");
     translator.ensureRowAllocated(func.ctx, "crSelf");
     func.ctx.addQuotedLiteral("unsigned char * left = (unsigned char *)_left;");
     buildTransformBody(func.ctx, expr, true, false, true);
@@ -3031,7 +3031,7 @@ void DiskNormalizeBuilder::buildTransform(IHqlExpression * expr)
     globaliterctx.setown(new BuildCtx(instance->startctx));
     globaliterctx->addGroup();
 
-    MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf)");
+    MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf) override");
     translator.ensureRowAllocated(func.ctx, "crSelf");
     buildTransformBody(func.ctx, expr, true, false, false);
 }
@@ -3100,13 +3100,13 @@ void DiskAggregateBuilder::buildMembers(IHqlExpression * expr)
     //virtual void processRow(void * self, const void * src) = 0;
     {
         BuildCtx rowctx(instance->startctx);
-        rowctx.addQuotedFunction("virtual void processRow(ARowBuilder & crSelf, const void * src)");
+        rowctx.addQuotedFunction("virtual void processRow(ARowBuilder & crSelf, const void * src) override");
         rowctx.addQuotedLiteral("doProcessRow(crSelf, (const byte *)src);");
     }
 
     //virtual void processRows(void * self, size32_t srcLen, const void * src) = 0;
     {
-        MemberFunction func(translator, instance->startctx, "virtual void processRows(ARowBuilder & crSelf, size32_t srcLen, const void * _left)");
+        MemberFunction func(translator, instance->startctx, "virtual void processRows(ARowBuilder & crSelf, size32_t srcLen, const void * _left) override");
         func.ctx.addQuotedLiteral("unsigned char * left = (unsigned char *)_left;");
         OwnedHqlExpr ds = createVariable("left", makeReferenceModifier(tableExpr->getType()));
         OwnedHqlExpr len = createVariable("srcLen", LINK(sizetType));
@@ -3354,7 +3354,7 @@ void ChildNormalizeBuilder::buildTransform(IHqlExpression * expr)
     globaliterctx.setown(new BuildCtx(instance->startctx));
     globaliterctx->addGroup();
 
-    MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf)");
+    MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf) override");
     translator.ensureRowAllocated(func.ctx, "crSelf");
     buildTransformBody(func.ctx, expr, true, false, false);
 }
@@ -3409,7 +3409,7 @@ void ChildAggregateBuilder::buildMembers(IHqlExpression * expr)
 
 void ChildAggregateBuilder::buildTransform(IHqlExpression * expr)
 {
-    MemberFunction func(translator, instance->startctx, "virtual void processRows(ARowBuilder & crSelf)");
+    MemberFunction func(translator, instance->startctx, "virtual void processRows(ARowBuilder & crSelf) override");
     translator.ensureRowAllocated(func.ctx, "crSelf");
     buildTransformBody(func.ctx, expr, false, false, false);
 }
@@ -3467,7 +3467,7 @@ void ChildGroupAggregateBuilder::buildMembers(IHqlExpression * expr)
     translator.doBuildAggregateClearFunc(instance->startctx, aggregate);
 
     //virtual size32_t mergeAggregate(ARowBuilder & crSelf, const void * src) - never actually called.
-    instance->startctx.addQuotedLiteral("virtual size32_t mergeAggregate(ARowBuilder & crSelf, const void * src) { return 0; }");
+    instance->startctx.addQuotedLiteral("virtual size32_t mergeAggregate(ARowBuilder & crSelf, const void * src) override { return 0; }");
 }
 
 void ChildGroupAggregateBuilder::buildTransform(IHqlExpression * expr)
@@ -3532,7 +3532,7 @@ void ChildThroughNormalizeBuilder::buildTransform(IHqlExpression * expr)
     globaliterctx.setown(new BuildCtx(instance->startctx));
     globaliterctx->addGroup();
 
-    MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf)");
+    MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf) override");
     translator.ensureRowAllocated(func.ctx, "crSelf");
     buildTransformBody(func.ctx, expr, true, false, false);
 }
@@ -4540,13 +4540,13 @@ void MonitorExtractor::generateFormatWrapping(StringBuffer & createMonitorText,
     s.clear().append("struct ").append(className).append(" : public RtlCInterface, public IKeySegmentFormatTranslator");
     suffix.append(instanceName).append(";");
     classctx.addQuotedCompound(s, suffix);
-    classctx.addQuotedLiteral("virtual void Link() const { RtlCInterface::Link(); }");
-    classctx.addQuotedLiteral("virtual bool Release() const { return RtlCInterface::Release(); }");
-    classctx.addQuoted(s.clear().append("virtual const char * queryFactoryName() const { return \"").append(factoryName).append("\"; }"));
-    classctx.addQuoted(s.clear().append("virtual unsigned queryHashCode() const { return ").append(getExpressionCRC(selector)).append("; }"));
+    classctx.addQuotedLiteral("virtual void Link() const override { RtlCInterface::Link(); }");
+    classctx.addQuotedLiteral("virtual bool Release() const override { return RtlCInterface::Release(); }");
+    classctx.addQuoted(s.clear().append("virtual const char * queryFactoryName() const override { return \"").append(factoryName).append("\"; }"));
+    classctx.addQuoted(s.clear().append("virtual unsigned queryHashCode() const override { return ").append(getExpressionCRC(selector)).append("; }"));
 
     {
-        MemberFunction func(translator, classctx, "virtual void extractField(void * _target, const void * _row) const");
+        MemberFunction func(translator, classctx, "virtual void extractField(void * _target, const void * _row) const override");
         classctx.associateExpr(constantMemberMarkerExpr, constantMemberMarkerExpr);
         func.ctx.addQuotedLiteral("const byte * row = (const byte *)_row;");
         func.ctx.addQuotedLiteral("byte * target = (byte *)_target;");
@@ -6280,7 +6280,7 @@ void IndexReadBuilderBase::buildMembers(IHqlExpression * expr)
 {
     //---- virtual void createSegmentMonitors(struct IIndexReadContext *) { ... } ----
     {
-        MemberFunction func(translator, instance->startctx, "virtual void createSegmentMonitors(IIndexReadContext *irc)");
+        MemberFunction func(translator, instance->startctx, "virtual void createSegmentMonitors(IIndexReadContext *irc) override");
         monitors.buildSegments(func.ctx, "irc", false);
     }
 
@@ -6463,7 +6463,7 @@ void NewIndexReadBuilder::buildTransform(IHqlExpression * expr)
 {
     if (true)
     {
-        MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf, const void * _left)");
+        MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf, const void * _left) override");
         translator.ensureRowAllocated(func.ctx, "crSelf");
         func.ctx.addQuotedLiteral("unsigned char * left = (unsigned char *)_left;");
         translator.associateBlobHelper(func.ctx, tableExpr, "fpp");
@@ -6472,7 +6472,7 @@ void NewIndexReadBuilder::buildTransform(IHqlExpression * expr)
 
     if (generateUnfilteredTransform)
     {
-        MemberFunction func(translator, instance->startctx, "virtual size32_t unfilteredTransform(ARowBuilder & crSelf, const void * _left)");
+        MemberFunction func(translator, instance->startctx, "virtual size32_t unfilteredTransform(ARowBuilder & crSelf, const void * _left) override");
         translator.ensureRowAllocated(func.ctx, "crSelf");
         func.ctx.addQuotedLiteral("unsigned char * left = (unsigned char *)_left;");
         translator.associateBlobHelper(func.ctx, tableExpr, "fpp");
@@ -6545,7 +6545,7 @@ void IndexNormalizeBuilder::buildTransform(IHqlExpression * expr)
     globaliterctx.setown(new BuildCtx(instance->startctx));
     globaliterctx->addGroup();
 
-    MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf)");
+    MemberFunction func(translator, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf) override");
     translator.ensureRowAllocated(func.ctx, "crSelf");
 
     //Because this transform creates iterator classes for the child iterators the expression tree needs to be modified
@@ -6614,12 +6614,12 @@ void IndexAggregateBuilder::buildMembers(IHqlExpression * expr)
     //virtual void processRow(void * self, const void * src) = 0;
     {
         BuildCtx rowctx(instance->startctx);
-        rowctx.addQuotedFunction("virtual void processRow(ARowBuilder & crSelf, const void * src)");
+        rowctx.addQuotedFunction("virtual void processRow(ARowBuilder & crSelf, const void * src) override");
         rowctx.addQuotedLiteral("doProcessRow(crSelf, (const byte *)src);");
     }
 
     {
-        MemberFunction func(translator, instance->startctx, "virtual void processRows(ARowBuilder & crSelf, size32_t srcLen, const void * _left)");
+        MemberFunction func(translator, instance->startctx, "virtual void processRows(ARowBuilder & crSelf, size32_t srcLen, const void * _left) override");
         func.ctx.addQuotedLiteral("unsigned char * left = (unsigned char *)_left;");
         OwnedHqlExpr ds = createVariable("left", makeReferenceModifier(tableExpr->getType()));
         OwnedHqlExpr len = createVariable("srcLen", LINK(sizetType));
@@ -6707,7 +6707,7 @@ void IndexCountBuilder::buildTransform(IHqlExpression * expr)
 {
     if (transformCanFilter||isNormalize)
     {
-        MemberFunction func(translator, instance->startctx, "virtual size32_t numValid(const void * _left)");
+        MemberFunction func(translator, instance->startctx, "virtual size32_t numValid(const void * _left) override");
         func.ctx.addQuotedLiteral("unsigned char * left = (unsigned char *)_left;");
         translator.associateBlobHelper(func.ctx, tableExpr, "fpp");
         OwnedHqlExpr cnt;
@@ -6824,7 +6824,7 @@ void IndexGroupAggregateBuilder::doBuildProcessCountMembers(BuildCtx & ctx, IHql
     OwnedHqlExpr resultDataset = createDataset(no_anon, LINK(tgtRecord));
 
     {
-        MemberFunction func(translator, ctx, "virtual size32_t initialiseCountGrouping(ARowBuilder & crSelf, const void * _src)");
+        MemberFunction func(translator, ctx, "virtual size32_t initialiseCountGrouping(ARowBuilder & crSelf, const void * _src) override");
         translator.ensureRowAllocated(func.ctx, "crSelf");
         func.ctx.addQuotedLiteral("unsigned char * src = (unsigned char *) _src;");
         translator.associateBlobHelper(func.ctx, tableExpr, "fpp");
@@ -6843,7 +6843,7 @@ void IndexGroupAggregateBuilder::doBuildProcessCountMembers(BuildCtx & ctx, IHql
     }
 
     {
-        MemberFunction func(translator, ctx, "virtual size32_t processCountGrouping(ARowBuilder & crSelf, unsigned __int64 count)");
+        MemberFunction func(translator, ctx, "virtual size32_t processCountGrouping(ARowBuilder & crSelf, unsigned __int64 count) override");
         translator.ensureRowAllocated(func.ctx, "crSelf");
         BoundRow * selfCursor = translator.bindSelf(func.ctx, resultDataset, "crSelf");
 
@@ -6953,7 +6953,7 @@ void HqlCppTranslator::buildXmlReadTransform(IHqlExpression * dataset, StringBuf
     classctx.addQuoted(s);
 
     {
-        MemberFunction func(*this, classctx, "virtual size32_t transform(ARowBuilder & crSelf, IColumnProvider * row, IThorDiskCallback * fpp)");
+        MemberFunction func(*this, classctx, "virtual size32_t transform(ARowBuilder & crSelf, IColumnProvider * row, IThorDiskCallback * fpp) override");
         ensureRowAllocated(func.ctx, "crSelf");
 
         xmlUsesContents = false;
@@ -6990,9 +6990,9 @@ unsigned HqlCppTranslator::buildCsvReadTransform(BuildCtx & subctx, IHqlExpressi
     MemberFunction func(*this, subctx);
 
     if (newInterface)
-        func.start("virtual size32_t transform(ARowBuilder & crSelf, unsigned * lenSrc, const char * * dataSrc)");
+        func.start("virtual size32_t transform(ARowBuilder & crSelf, unsigned * lenSrc, const char * * dataSrc) override");
     else
-        func.start("virtual size32_t transform(ARowBuilder & crSelf, unsigned * lenSrc, const char * * dataSrc, unsigned __int64 _fpos)");
+        func.start("virtual size32_t transform(ARowBuilder & crSelf, unsigned * lenSrc, const char * * dataSrc, unsigned __int64 _fpos) override");
 
     //MORE: If this becomes a compound activity
     BoundRow * rootSelfRow = bindSelf(func.ctx, dataset, "crSelf");
@@ -7046,8 +7046,8 @@ void HqlCppTranslator::buildCsvReadTransformer(IHqlExpression * dataset, StringB
     transformClass->setIncomplete(true);
     transformClass->setIncluded(false);         // if can't generate csv for this record, then don't generate an invalid class.
 
-    classctx.addQuotedLiteral("virtual void Link() const { RtlCInterface::Link(); }");
-    classctx.addQuotedLiteral("virtual bool Release() const { return RtlCInterface::Release(); }");
+    classctx.addQuotedLiteral("virtual void Link() const override { RtlCInterface::Link(); }");
+    classctx.addQuotedLiteral("virtual bool Release() const override { return RtlCInterface::Release(); }");
 
     unsigned maxColumns = buildCsvReadTransform(classctx, dataset, false, optCsvAttr);
     doBuildUnsignedFunction(classctx, "getMaxColumns", maxColumns);
@@ -7179,11 +7179,11 @@ protected:
 
 void FetchBuilder::buildMembers(IHqlExpression * expr)
 {
-    buildReadMembers(expr);
+    buildFilenameMember();
 
     IHqlExpression * fetch = queryFetch(expr);
     {
-        MemberFunction func(translator, instance->startctx, "virtual unsigned __int64 extractPosition(const void * _right)");
+        MemberFunction func(translator, instance->startctx, "virtual unsigned __int64 extractPosition(const void * _right) override");
         func.ctx.addQuotedLiteral("const unsigned char * right = (const unsigned char *) _right;");
         translator.bindTableCursor(func.ctx, fetch->queryChild(1), "right", no_right, selSeq);
         translator.buildReturn(func.ctx, fetch->queryChild(2));
@@ -7215,17 +7215,13 @@ void FetchBuilder::buildMembers(IHqlExpression * expr)
             translator.buildCsvParameters(instance->nestedctx, tableExpr->queryChild(2), NULL, true);
             unsigned maxColumns = getFieldCount(tableExpr->queryRecord());
             StringBuffer s;
-            s.clear().append("virtual unsigned getMaxColumns() { return ").append(maxColumns).append("; }");
+            s.clear().append("virtual unsigned getMaxColumns() override { return ").append(maxColumns).append("; }");
             instance->classctx.addQuoted(s);
             break;
         }
     case no_xml:
     case no_json:
-        {
-            // virtual const char * getXmlIteratorPath()
-            translator.doBuildVarStringFunction(instance->classctx, "getXmlIteratorPath", queryRealChild(tableExpr->queryChild(2), 0));
-            break;
-        }
+        break;
     default:
         translator.buildFormatCrcFunction(instance->classctx, "getDiskFormatCrc", physicalRecord, NULL, 0);
         break;
@@ -7234,10 +7230,10 @@ void FetchBuilder::buildMembers(IHqlExpression * expr)
     if (!containsOnlyLeft(fetch->queryChild(3), true))
     {
         //MORE: Need to change following if we optimize it to only extract the relevant fields.
-        instance->classctx.addQuotedLiteral("virtual bool extractAllJoinFields() { return true; }");
+        instance->classctx.addQuotedLiteral("virtual bool extractAllJoinFields() override { return true; }");
 
         {
-            MemberFunction func(translator, instance->startctx, "virtual size32_t extractJoinFields(ARowBuilder & crSelf, const void * _left)");
+            MemberFunction func(translator, instance->startctx, "virtual size32_t extractJoinFields(ARowBuilder & crSelf, const void * _left) override");
             translator.ensureRowAllocated(func.ctx, "crSelf");
             translator.buildRecordSerializeExtract(func.ctx, memoryRhsRecord);
         }
@@ -7245,7 +7241,7 @@ void FetchBuilder::buildMembers(IHqlExpression * expr)
         StringBuffer s;
         MetaInstance meta(translator, serializedRhsRecord, false);
         translator.buildMetaInfo(meta);
-        instance->classctx.addQuoted(s.clear().append("virtual IOutputMetaData * queryExtractedSize() { return &").append(meta.queryInstanceObject()).append("; }"));
+        instance->classctx.addQuoted(s.clear().append("virtual IOutputMetaData * queryExtractedSize() override { return &").append(meta.queryInstanceObject()).append("; }"));
     }
 }
 
@@ -7258,16 +7254,16 @@ void FetchBuilder::buildTransform(IHqlExpression * expr)
     switch (getDatasetKind(tableExpr))
     {
     case no_csv:
-        func.start("virtual size32_t transform(ARowBuilder & crSelf, unsigned * lenLeft, const char * * dataLeft, const void * _right, unsigned __int64 _fpos)");
+        func.start("virtual size32_t transform(ARowBuilder & crSelf, unsigned * lenLeft, const char * * dataLeft, const void * _right, unsigned __int64 _fpos) override");
         func.ctx.addQuotedLiteral("unsigned char * right = (unsigned char *)_right;");
         break;
     case no_xml:
     case no_json:
-        func.start("virtual size32_t transform(ARowBuilder & crSelf, IColumnProvider * xmlLeft, const void * _right, unsigned __int64 _fpos)");
+        func.start("virtual size32_t transform(ARowBuilder & crSelf, IColumnProvider * xmlLeft, const void * _right, unsigned __int64 _fpos) override");
         func.ctx.addQuotedLiteral("unsigned char * right = (unsigned char *)_right;");
         break;
     default:
-        func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned __int64 _fpos)");
+        func.start("virtual size32_t transform(ARowBuilder & crSelf, const void * _left, const void * _right, unsigned __int64 _fpos) override");
         func.ctx.addQuotedLiteral("unsigned char * left = (unsigned char *)_left;");
         func.ctx.addQuotedLiteral("unsigned char * right = (unsigned char *)_right;");
         break;
@@ -7277,7 +7273,7 @@ void FetchBuilder::buildTransform(IHqlExpression * expr)
     buildTransformBody(func.ctx, expr, true, false, true);
 
     if (translator.xmlUsesContents)
-        instance->classctx.addQuotedLiteral("virtual bool requiresContents() { return true; }");
+        instance->classctx.addQuotedLiteral("virtual bool requiresContents() override { return true; }");
 }
 
 

ecl/hqlcpp/hqlstep.cpp

@@ -542,7 +542,7 @@ IHqlExpression * SteppingFieldSelection::generateSteppingMeta(HqlCppTranslator &
     classctx.addQuotedCompound(s.clear().append("struct C").append(memberName).append(" : public ISteppingMeta"), s2.append(" ").append(memberName).append(";").str());
     translator.doBuildUnsignedFunction(classctx, "getNumFields", lenOffsets/2);
 
-    classctx.addQuoted(s.clear().append("virtual const CFieldOffsetSize * queryFields() { return ").append(offsetName).append("; }"));
+    classctx.addQuoted(s.clear().append("virtual const CFieldOffsetSize * queryFields() override { return ").append(offsetName).append("; }"));
 
     //compare function.
     {
@@ -556,7 +556,7 @@ IHqlExpression * SteppingFieldSelection::generateSteppingMeta(HqlCppTranslator &
         translator.doBuildUnsignedFunction(comparectx, "maxFields", lenOffsets/2);
 
         {
-            MemberFunction func(translator, comparectx, "virtual int docompare(const void * _left,const void * _right, unsigned numFields) const");
+            MemberFunction func(translator, comparectx, "virtual int docompare(const void * _left,const void * _right, unsigned numFields) const override");
             func.ctx.addQuotedLiteral("const byte * left = (const byte *)_left;");
             func.ctx.addQuotedLiteral("const byte * right = (const byte *)_right;");
             func.ctx.addQuotedLiteral("int ret;");
@@ -578,7 +578,7 @@ IHqlExpression * SteppingFieldSelection::generateSteppingMeta(HqlCppTranslator &
             func.ctx.addReturn(result);
         }
     
-        classctx.addQuoted(s.clear().append("virtual IRangeCompare * queryCompare() { return &").append(compareName).append("; }"));
+        classctx.addQuoted(s.clear().append("virtual IRangeCompare * queryCompare() override { return &").append(compareName).append("; }"));
     }
 
     //distance function - very similar to compare
@@ -592,7 +592,7 @@ IHqlExpression * SteppingFieldSelection::generateSteppingMeta(HqlCppTranslator &
         distancectx.addQuotedCompoundLiteral("class Distance : public IDistanceCalculator", s2.clear().append(" ").append(distanceName).append(";"));
 
         {
-            MemberFunction func(translator, distancectx, "virtual unsigned getDistance(unsigned __int64 & distance, const void * _before, const void * _after, unsigned numFields) const");
+            MemberFunction func(translator, distancectx, "virtual unsigned getDistance(unsigned __int64 & distance, const void * _before, const void * _after, unsigned numFields) const override");
             func.ctx.addQuotedLiteral("const byte * before = (const byte *)_before;");
             func.ctx.addQuotedLiteral("const byte * after = (const byte *)_after;");
 
@@ -623,7 +623,7 @@ IHqlExpression * SteppingFieldSelection::generateSteppingMeta(HqlCppTranslator &
             func.ctx.addQuotedLiteral("return DISTANCE_EXACT_MATCH;");
         }
     
-        classctx.addQuoted(s.clear().append("virtual IDistanceCalculator * queryDistance() { return &").append(distanceName).append("; }"));
+        classctx.addQuoted(s.clear().append("virtual IDistanceCalculator * queryDistance() override { return &").append(distanceName).append("; }"));
     }
 
     StringBuffer resultText;
@@ -645,7 +645,7 @@ void SteppingFieldSelection::generateSteppingMetaMember(HqlCppTranslator & trans
     IHqlExpression * func = generateSteppingMeta(translator);
 
     StringBuffer s;
-    s.clear().append("virtual ISteppingMeta * query").append(name).append("() { return &");
+    s.clear().append("virtual ISteppingMeta * query").append(name).append("() override { return & ");
     translator.generateExprCpp(s, func);
     s.append(";}");
     ctx.addQuoted(s);
@@ -761,7 +761,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityRowsetRange(BuildCtx & ctx, IH
     OwnedHqlExpr normalized = normalizeListCasts(castList);
 
     {
-        MemberFunction func(*this, instance->startctx, "virtual void getInputSelection(bool & __isAllResult, size32_t & __lenResult, void * & __result)");
+        MemberFunction func(*this, instance->startctx, "virtual void getInputSelection(bool & __isAllResult, size32_t & __lenResult, void * & __result) override");
         doBuildFunctionReturn(func.ctx, castType, normalized);
     }
 
@@ -959,7 +959,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
         buildMetaInfo(inputmeta);
 
         StringBuffer s;
-        s.append("virtual IOutputMetaData * queryInputMeta() { return &").append(inputmeta.queryInstanceObject()).append("; }");
+        s.append("virtual IOutputMetaData * queryInputMeta() override { return &").append(inputmeta.queryInstanceObject()).append("; }");
         instance->classctx.addQuoted(s);
     }
 
@@ -972,7 +972,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
         BuildCtx funcctx(instance->startctx);
         OwnedHqlExpr func = getClearRecordFunction(dataset->queryRecord(), -1);
         StringBuffer s;
-        generateExprCpp(s.append("virtual size32_t createLowInputRow(ARowBuilder & crSelf) { return "), func).append("(crSelf, ctx); }");
+        generateExprCpp(s.append("virtual size32_t createLowInputRow(ARowBuilder & crSelf) override { return "), func).append("(crSelf, ctx); }");
         funcctx.addQuoted(s);
     }
 
@@ -993,7 +993,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
 
         //virtual unsigned __int64 extractRangeValue(const void * input);               // distance is assumed to be unsigned, code generator must bias if not true.
         {
-            MemberFunction func(*this, instance->startctx, "unsigned __int64 extractRangeValue(const void * _left)");
+            MemberFunction func(*this, instance->startctx, "virtual unsigned __int64 extractRangeValue(const void * _left) override");
             func.ctx.addQuotedLiteral("const byte * left = (const byte *)_left;");
             bindTableCursor(func.ctx, dataset, "left", no_left, selSeq);
             buildReturn(func.ctx, rangeValue);
@@ -1001,7 +1001,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
 
         //virtual void adjustRangeValue(void * self, const void * input, __int64 delta);        // implementation must ensure field doesn't go -ve.
         {
-            MemberFunction func(*this, instance->startctx, "void adjustRangeValue(ARowBuilder & crSelf, const void * _left, __int64 delta)");
+            MemberFunction func(*this, instance->startctx, "virtual void adjustRangeValue(ARowBuilder & crSelf, const void * _left, __int64 delta) override");
             ensureRowAllocated(func.ctx, "crSelf");
             func.ctx.addQuotedLiteral("const byte * left = (const byte *)_left;");
 
@@ -1030,14 +1030,14 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
 
         //virtual __int64 maxRightBeforeLeft()
         {
-            MemberFunction func(*this, instance->startctx, "virtual __int64 maxRightBeforeLeft()");
+            MemberFunction func(*this, instance->startctx, "virtual __int64 maxRightBeforeLeft() override");
             OwnedHqlExpr mrbl = stepCondition.getMaxRightBeforeLeft();
             buildReturn(func.ctx, mrbl);
         }
 
         //virtual __int64 maxLeftBeforeRight()
         {
-            MemberFunction func(*this, instance->startctx, "virtual __int64 maxLeftBeforeRight()");
+            MemberFunction func(*this, instance->startctx, "virtual __int64 maxLeftBeforeRight() override");
             OwnedHqlExpr mlbr = stepCondition.getMaxLeftBeforeRight();
             buildReturn(func.ctx, mlbr);
         }
@@ -1056,7 +1056,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
     //virtual size32_t transform(ARowBuilder & crSelf, unsigned _num, const void * * _rows)
     if (transform)
     {
-        MemberFunction func(*this, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf, unsigned numRows, const void * * _rows)");
+        MemberFunction func(*this, instance->startctx, "virtual size32_t transform(ARowBuilder & crSelf, unsigned numRows, const void * * _rows) override");
         ensureRowAllocated(func.ctx, "crSelf");
         func.ctx.addQuotedLiteral("const unsigned char * left = (const unsigned char *) _rows[0];");
         func.ctx.addQuotedLiteral("const unsigned char * right = (const unsigned char *) _rows[1];");
@@ -1085,7 +1085,7 @@ ABoundActivity * HqlCppTranslator::doBuildActivityNWayMergeJoin(BuildCtx & ctx,
         IHqlExpression * lastJoinField = equalityList->queryChild(numEqualFields-1);
         if (lastJoinField->queryType()->isInteger())
         {
-            MemberFunction func(*this, instance->startctx, "virtual bool createNextJoinValue(ARowBuilder & crSelf, const void * _value)");
+            MemberFunction func(*this, instance->startctx, "virtual bool createNextJoinValue(ARowBuilder & crSelf, const void * _value) override");
             ensureRowAllocated(func.ctx, "crSelf");
             func.ctx.addQuotedLiteral("const byte * value = (const byte *)_value;");
 

rtl/include/eclhelper.hpp

@@ -1415,6 +1415,7 @@ struct IHThorCombineGroupArg : public IHThorArg
 
 struct IHThorRollupGroupArg : public IHThorArg
 {
+    virtual bool canFilter()                                { return false; }
     virtual size32_t transform(ARowBuilder & rowBuilder, unsigned _num, const void * * _rows) = 0;
 };
 
@@ -1771,6 +1772,8 @@ struct IHThorAnyJoinBaseArg : public IHThorArg
     virtual size32_t createDefaultRight(ARowBuilder & rowBuilder) = 0;
     virtual unsigned getJoinFlags() = 0;
     virtual unsigned getKeepLimit() = 0;
+    virtual unsigned getMatchAbortLimit() = 0;
+    virtual void onMatchAbortLimitExceeded() = 0;
 
 //Join:
 //Denormalize
@@ -1796,8 +1799,6 @@ struct IHThorJoinBaseArg : public IHThorAnyJoinBaseArg
     virtual double getSkew() = 0;
     virtual unsigned getJoinLimit() = 0;                                        // if a key joins more than this limit no records are output (0 = no limit)
     virtual double getTargetSkew() = 0;
-    virtual unsigned getMatchAbortLimit() = 0;
-    virtual void onMatchAbortLimitExceeded() = 0;
     virtual ICompare * queryCompareLeftRightLower() = 0;
     virtual ICompare * queryCompareLeftRightUpper() = 0;
     virtual ICompare * queryPrefixCompare() = 0;
@@ -2678,7 +2679,6 @@ struct IHThorChildGroupAggregateArg : extends IHThorChildGroupAggregateBaseArg,
 };
 
 
-//Normalize - not yet implemented...
 struct IHThorChildThroughNormalizeBaseArg : public IHThorArg
 {
 };

rtl/include/eclhelper_base.hpp

@@ -1555,6 +1555,8 @@ class CThorAllJoinArg : implements IHThorAllJoinArg, public CThorArg
     virtual bool match(const void * _left, const void * _right) { return true; }
     virtual unsigned getKeepLimit()                     { return 0; }
     virtual unsigned getJoinFlags()                     { return 0; }
+    virtual unsigned getMatchAbortLimit()               { return 0; }
+    virtual void onMatchAbortLimitExceeded()            { }
 
 //Join:
 //Denormalize