MCOL-4030: Fix most of the overloaded-virtual warnings.

dbcon/execplan/aggregatecolumn.h

@@ -214,6 +214,7 @@ public:
     /**
      * fData: SQL representation of this object
      */
+    using ReturnedColumn::data;
     virtual void data(const std::string& data)
     {
         fData = data;
@@ -245,6 +246,7 @@ public:
      * Do a deep, strict (as opposed to semantic) equivalence test.
      * @return true iff every member of t is a duplicate copy of every member of this; false otherwise
      */
+    using ReturnedColumn::operator=;
     virtual bool operator==(const AggregateColumn& t) const;
 
     /** @brief Do a deep, strict (as opposed to semantic) equivalence test
@@ -259,6 +261,7 @@ public:
      * Do a deep, strict (as opposed to semantic) equivalence test.
      * @return false iff every member of t is a duplicate copy of every member of this; true otherwise
      */
+    using ReturnedColumn::operator!=;
     virtual bool operator!=(const AggregateColumn& t) const;
 
     /** @brief push back arg to group by column list*/
@@ -306,6 +309,7 @@ public:
     */
     static AggOp agname2num(const std::string&);
 
+    using ReturnedColumn::hasAggregate;
     virtual bool hasAggregate();
     virtual bool hasWindowFunc()
     {

dbcon/execplan/arithmeticcolumn.h

@@ -164,6 +164,7 @@ public:
      */
     bool operator!=(const ArithmeticColumn& t) const;
 
+    using ReturnedColumn::hasAggregate;
     virtual bool hasAggregate();
     virtual bool hasWindowFunc();
 
@@ -272,6 +273,7 @@ public:
 
 private:
     ParseTree* fExpression;
+    using TreeNode::evaluate;
     void evaluate(rowgroup::Row& row) {}
 };
 

dbcon/execplan/arithmeticoperator.h

@@ -106,38 +106,46 @@ public:
     /***********************************************************
      *                 F&E framework                           *
      ***********************************************************/
+    using Operator::evaluate;
     inline virtual void evaluate(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop);
 
+    using Operator::getStrVal;
     virtual const std::string& getStrVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getStrVal(fTimeZone);
     }
+    using Operator::getIntVal;
     virtual int64_t getIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getIntVal();
     }
+    using Operator::getUintVal;
     virtual uint64_t getUintVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getUintVal();
     }
+    using Operator::getFloatVal;
     virtual float getFloatVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getFloatVal();
     }
+    using Operator::getDoubleVal;
     virtual double getDoubleVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getDoubleVal();
     }
+    using Operator::getLongDoubleVal;
     virtual long double getLongDoubleVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getLongDoubleVal();
     }
+    using Operator::getDecimalVal;
     virtual IDB_Decimal getDecimalVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
@@ -156,26 +164,31 @@ public:
 
         return TreeNode::getDecimalVal();
     }
+    using Operator::getDateIntVal;
     virtual int32_t getDateIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getDateIntVal();
     }
+    using Operator::getDatetimeIntVal;
     virtual int64_t getDatetimeIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getDatetimeIntVal();
     }
+    using Operator::getTimestampIntVal;
     virtual int64_t getTimestampIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getTimestampIntVal();
     }
+    using Operator::getTimeIntVal;
     virtual int64_t getTimeIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);
         return TreeNode::getTimeIntVal();
     }
+    using Operator::getBoolVal;
     virtual bool getBoolVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         evaluate(row, isNull, lop, rop);

dbcon/execplan/constantcolumn.h

@@ -239,6 +239,7 @@ public:
     /**
      * F&E
      */
+    using ReturnedColumn::evaluate;
     virtual void evaluate(rowgroup::Row& row) {}
     /**
      * F&E

dbcon/execplan/functioncolumn.h

@@ -156,6 +156,7 @@ public:
     virtual void serialize(messageqcpp::ByteStream&) const;
     virtual void unserialize(messageqcpp::ByteStream&);
 
+    using ReturnedColumn::hasAggregate;
     virtual bool hasAggregate();
     virtual bool hasWindowFunc();
     virtual void setDerivedTable();

dbcon/execplan/groupconcatcolumn.h

@@ -118,6 +118,7 @@ public:
      * @return true iff every member of t is a duplicate copy of every member of this;
      *         false otherwise
      */
+    using AggregateColumn::operator==;
     virtual bool operator==(const GroupConcatColumn& t) const;
 
     /** @brief Do a deep, strict (as opposed to semantic) equivalence test
@@ -134,6 +135,7 @@ public:
      * @return false iff every member of t is a duplicate copy of every member of this;
      *         true otherwise
      */
+    using AggregateColumn::operator!=;
     virtual bool operator!=(const GroupConcatColumn& t) const;
 
 private:

dbcon/execplan/intervalcolumn.h

@@ -90,6 +90,7 @@ public:
         return new IntervalColumn (*this);
     }
 
+    using ReturnedColumn::hasAggregate;
     virtual bool hasAggregate()
     {
         return false;

dbcon/execplan/logicoperator.h

@@ -124,6 +124,7 @@ public:
     //result_t evaluate(result_t op1, result_t op2);
 
     // F&E framework
+    using Operator::getBoolVal;
     inline virtual bool getBoolVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         switch (fOp)
@@ -167,6 +168,7 @@ public:
         }
     }
 
+    using TreeNode::evaluate;
     inline virtual void evaluate(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         fResult.boolVal = getBoolVal(row, isNull, lop, rop);

dbcon/execplan/operator.h

@@ -156,53 +156,66 @@ public:
     {
         fOp = op;
     }
+    using TreeNode::evaluate;
     virtual void evaluate(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop) {}
 
     // The following methods should be pure virtual. Currently too many instanslization exists.
+    using TreeNode::getStrVal;
     virtual const std::string& getStrVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.strVal;
     }
+    using TreeNode::getIntVal;
     virtual int64_t getIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.intVal;
     }
+    using TreeNode::getUintVal;
     virtual uint64_t getUintVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.uintVal;
     }
+    using TreeNode::getFloatVal;
     virtual float getFloatVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.floatVal;
     }
+    using TreeNode::getDoubleVal;
     virtual double getDoubleVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.doubleVal;
     }
+    using TreeNode::getLongDoubleVal;
     virtual long double getLongDoubleVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.longDoubleVal;
     }
+    using TreeNode::getDecimalVal;
     virtual IDB_Decimal getDecimalVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.decimalVal;
     }
+    using TreeNode::getDateIntVal;
     virtual int32_t getDateIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.intVal;
     }
+    using TreeNode::getDatetimeIntVal;
     virtual int64_t getDatetimeIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.intVal;
     }
+    using TreeNode::getTimestampIntVal;
     virtual int64_t getTimestampIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.intVal;
     }
+    using TreeNode::getTimeIntVal;
     virtual int64_t getTimeIntVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.intVal;
     }
+    using TreeNode::getBoolVal;
     virtual bool getBoolVal(rowgroup::Row& row, bool& isNull, ParseTree* lop, ParseTree* rop)
     {
         return fResult.boolVal;

dbcon/execplan/predicateoperator.h

@@ -115,6 +115,7 @@ public:
     /***********************************************************
      *                  F&E framework                          *
      ***********************************************************/
+    using Operator::getBoolVal;
     virtual bool getBoolVal(rowgroup::Row& row, bool& isNull, ReturnedColumn* lop, ReturnedColumn* rop);
     void setOpType(Type& l, Type& r);
 

dbcon/execplan/rowcolumn.h

@@ -135,6 +135,7 @@ public:
      * @return false iff every member of t is a duplicate copy of every member of this; true otherwise
      */
     bool operator!=(const RowColumn& t) const;
+    using ReturnedColumn::hasAggregate;
     virtual bool hasAggregate()
     {
         return false;
@@ -162,6 +163,7 @@ public:
     {
         return new SubSelect();
     }
+    using ReturnedColumn::hasAggregate;
     virtual bool hasAggregate()
     {
         return false;

dbcon/execplan/simplefilter.h

@@ -104,6 +104,7 @@ public:
         fTimeZone = timeZone;
     }
 
+    using Filter::data;
     virtual const std::string data() const;
 
     /** assign fLhs

dbcon/execplan/udafcolumn.h

@@ -102,6 +102,7 @@ public:
      * @return true iff every member of t is a duplicate copy of every member of this;
      *         false otherwise
      */
+    using AggregateColumn::operator==;
     virtual bool operator==(const UDAFColumn& t) const;
 
     /** @brief Do a deep, strict (as opposed to semantic) equivalence test
@@ -118,6 +119,7 @@ public:
      * @return false iff every member of t is a duplicate copy of every member of this;
      *         true otherwise
      */
+    using AggregateColumn::operator!=;
     virtual bool operator!=(const UDAFColumn& t) const;
 
 private:

dbcon/execplan/windowfunctioncolumn.h

@@ -129,6 +129,7 @@ public:
     // util function for connector to use.
     void addToPartition(std::vector<SRCP>& groupByList);
 
+    using ReturnedColumn::hasAggregate;
     virtual bool hasAggregate()
     {
         return false;

dbcon/joblist/expressionstep.h

@@ -68,14 +68,17 @@ public:
     {
         return fTableOids.empty() ? 0 : fTableOids.front();
     }
+    using JobStep::alias;
     std::string alias() const
     {
         return fAliases.empty() ? "" : fAliases.front();
     }
+    using JobStep::view;
     std::string view() const
     {
         return fViews.empty() ? "" : fViews.front();
     }
+    using JobStep::schema;
     std::string schema() const
     {
         return fSchemas.empty() ? "" : fSchemas.front();

dbcon/joblist/groupconcat.h

@@ -84,6 +84,7 @@ public:
     EXPORT GroupConcatAgUM(rowgroup::SP_GroupConcat&);
     EXPORT ~GroupConcatAgUM();
 
+    using rowgroup::GroupConcatAg::merge;
     void initialize();
     void processRow(const rowgroup::Row&);
     EXPORT void merge(const rowgroup::Row&, int64_t);
@@ -147,6 +148,7 @@ public:
     void processRow(const rowgroup::Row&);
 
     void merge(GroupConcator*);
+    using GroupConcator::getResult;
     void getResult(uint8_t* buff, const std::string& sep);
 
     const std::string toString() const;
@@ -172,11 +174,13 @@ public:
     GroupConcatOrderBy();
     virtual ~GroupConcatOrderBy();
 
+    using ordering::IdbOrderBy::initialize;
     void initialize(const rowgroup::SP_GroupConcat&);
     void processRow(const rowgroup::Row&);
     uint64_t getKeyLength() const;
 
     void merge(GroupConcator*);
+    using GroupConcator::getResult;
     void getResult(uint8_t* buff, const std::string& sep);
 
     const std::string toString() const;

dbcon/joblist/limitedorderby.h

@@ -45,7 +45,7 @@ class LimitedOrderBy : public ordering::IdbOrderBy
 public:
     LimitedOrderBy();
     virtual ~LimitedOrderBy();
-
+    using ordering::IdbOrderBy::initialize;
     void initialize(const rowgroup::RowGroup&, 
         const JobInfo&, 
         bool invertRules = false, 

dbcon/joblist/primitivestep.h

@@ -460,6 +460,7 @@ public:
      *
      * The main loop for the receive-side thread.  Don't call it directly.
      */
+    using PrimitiveMsg::receivePrimitiveMessages;
     void receivePrimitiveMessages(uint64_t i = 0);
 
     /** @brief Add a filter when the column is a 4-byte float type

dbcon/joblist/tupleconstantstep.h

@@ -134,6 +134,7 @@ public:
     uint32_t nextBand(messageqcpp::ByteStream& bs);
 
 protected:
+    using TupleConstantStep::fillInConstants;
     void fillInConstants();
 
 };
@@ -159,6 +160,7 @@ public:
     	However (for now), it's ok, because it's only called in one place and
     	doesn't need to be virtual there.
      */
+    using TupleConstantStep::initialize;
     void initialize(const rowgroup::RowGroup& rgIn, const JobInfo& jobInfo);
 
     const std::string toString() const;
@@ -175,6 +177,7 @@ public:
 
 protected:
     void execute() {}
+    using TupleConstantStep::fillInConstants;
     void fillInConstants() {}
     void constructContanstRow(const JobInfo& jobInfo) {}
 

dbcon/joblist/tuplehashjoin.h

@@ -176,7 +176,7 @@ public:
     {
         fCorrelatedSide = c;
     }
-
+    using JobStep::tupleId;
     uint64_t tupleId() const
     {
         return fTupleId2;

dbcon/joblist/tuplehavingstep.h

@@ -68,6 +68,7 @@ public:
     bool  deliverStringTableRowGroup() const;
 
     void initialize(const rowgroup::RowGroup& rgIn, const JobInfo& jobInfo);
+    using ExpressionStep::expressionFilter;
     void expressionFilter(const execplan::ParseTree* filter, JobInfo& jobInfo);
 
     virtual bool stringTableFriendly()

utils/messageqcpp/compressed_iss.h

@@ -44,6 +44,7 @@ public:
     CompressedInetStreamSocket();
     virtual ~CompressedInetStreamSocket(){};
 
+    using InetStreamSocket::operator=;
     virtual Socket* clone() const;
     virtual const SBS read(const struct timespec* timeout = 0, bool* isTimeOut = NULL,
                            Stats* stats = NULL) const;

utils/rowgroup/rowaggregation.h

@@ -1096,9 +1096,12 @@ public:
                           const std::vector<SP_ROWAGG_FUNC_t>& funct);
 
     void setInputOutput(const RowGroup& pRowGroupIn, RowGroup* pRowGroupOut);
+    using RowAggregationDistinct::addRowGroup;
     void addRowGroup(const RowGroup* pRowGroupIn);
 
+    using RowAggregationDistinct::doDistinctAggregation;
     virtual void doDistinctAggregation();
+    using RowAggregationDistinct::doDistinctAggregation_rowVec;
     virtual void doDistinctAggregation_rowVec(std::vector<std::vector<Row::Pointer> >& inRows);
 
     inline virtual RowAggregationMultiDistinct* clone() const

writeengine/bulk/we_colbufmgr.h

@@ -272,6 +272,7 @@ public:
     virtual ~ColumnBufferManagerDctnry();
 
     virtual int rowsExtentCheck( int nRows, int& nRows2 );
+    using ColumnBufferManager::writeToFileExtentCheck;
     virtual int writeToFileExtentCheck(uint32_t startOffset, uint32_t writeSize);
 };