chore(build): fixes to satisfy clang19 warnings

2025-08-08 14:22:09 +03:00 · 2025-05-08 15:26:36 +00:00
parent 9fd7f342a7
commit a0bee173f6
334 changed files with 3062 additions and 3323 deletions
--- a/dbcon/joblist/crossenginestep.h
+++ b/dbcon/joblist/crossenginestep.h
@@ -55,8 +55,7 @@ class CrossEngineStep : public BatchPrimitive, public TupleDeliveryStep
 public:
  /** @brief CrossEngineStep constructor
   */
-  CrossEngineStep(const std::string& schema, const std::string& table,
-		  const execplan::Partitions& partitions,
+  CrossEngineStep(const std::string& schema, const std::string& table, const execplan::Partitions& partitions,
                  const std::string& alias, const JobInfo& jobInfo);

  /** @brief CrossEngineStep destructor
@@ -89,29 +88,29 @@ class CrossEngineStep : public BatchPrimitive, public TupleDeliveryStep
    return 1;
  }
  void setBPP(JobStep* jobStep) override;
-  void setFirstStepType(PrimitiveStepType firstStepType) override
+  void setFirstStepType(PrimitiveStepType /*firstStepType*/) override
  {
  }
  void setIsProjectionOnly() override
  {
  }
-  void setLastTupleId(uint64_t id) override
+  void setLastTupleId(uint64_t /*id*/) override
  {
  }
-  void setOutputType(BPSOutputType outputType) override
+  void setOutputType(BPSOutputType /*outputType*/) override
  {
  }
-  void setProjectBPP(JobStep* jobStep1, JobStep* jobStep2) override;
+  void setProjectBPP(JobStep* /*jobStep1*/, JobStep* /*jobStep2*/) override;
  void setStepCount() override
  {
  }
-  void setSwallowRows(const bool swallowRows) override
+  void setSwallowRows(const bool /*swallowRows*/) override
  {
  }
  void setBppStep() override
  {
  }
-  void dec(DistributedEngineComm* dec) override
+  void dec(DistributedEngineComm* /*dec*/) override
  {
  }
  const OIDVector& getProjectOids() const override
@@ -146,7 +145,7 @@ class CrossEngineStep : public BatchPrimitive, public TupleDeliveryStep
  {
    return fAlias;
  }
-  void setJobInfo(const JobInfo* jobInfo) override
+  void setJobInfo(const JobInfo* /*jobInfo*/) override
  {
  }
  void setOutputRowGroup(const rowgroup::RowGroup&) override;
--- a/dbcon/joblist/datalist.h
+++ b/dbcon/joblist/datalist.h
@@ -105,7 +105,7 @@ class DataList
  {
    return 0;
  }
-  virtual bool totalDiskIoTime(uint64_t& w, uint64_t& r)
+  virtual bool totalDiskIoTime(uint64_t& /*w*/, uint64_t& /*r*/)
  {
    return false;
  }
--- a/dbcon/joblist/dictstep-jl.cpp
+++ b/dbcon/joblist/dictstep-jl.cpp
@@ -49,14 +49,14 @@ DictStepJL::DictStepJL(const pDictionaryStep& dict)

  hasEqFilter = dict.hasEqualityFilter;

-  if (hasEqFilter && dict.eqFilter.size()> USEEQFILTERTHRESHOLD)
+  if (hasEqFilter && dict.eqFilter.size() > USEEQFILTERTHRESHOLD)
  {
    eqOp = dict.tmpCOP;
    eqFilter = dict.eqFilter;
  }
  else
  {
-    hasEqFilter=false;
+    hasEqFilter = false;
    filterString = dict.fFilterString;
  }
  filterCount = dict.fFilterCount;
@@ -67,7 +67,7 @@ DictStepJL::~DictStepJL()
 {
 }

-void DictStepJL::setLBID(uint64_t token, uint32_t dbroot)
+void DictStepJL::setLBID(uint64_t /*token*/, uint32_t /*dbroot*/)
 {
  // 	lbid = token >> 10;  // the lbid is calculated on the PM
 }
@@ -94,7 +94,7 @@ void DictStepJL::createCommand(ByteStream& bs) const
  CommandJL::createCommand(bs);
 }

-void DictStepJL::runCommand(ByteStream& bs) const
+void DictStepJL::runCommand(ByteStream& /*bs*/) const
 {
 }

@@ -133,7 +133,8 @@ messageqcpp::ByteStream DictStepJL::reencodedFilterString() const
    for (uint32_t i = 0; i < filterCount; i++)
    {
      uint8_t roundFlag = 0;
-      int64_t encodedPrefix = encodeStringPrefix((unsigned char*)eqFilter[i].c_str(), eqFilter[i].size(), charsetNumber);
+      int64_t encodedPrefix =
+          encodeStringPrefix((unsigned char*)eqFilter[i].c_str(), eqFilter[i].size(), charsetNumber);
      bs << eqOp;
      bs << roundFlag;
      bs << encodedPrefix;
--- a/dbcon/joblist/distributedenginecomm.cpp
+++ b/dbcon/joblist/distributedenginecomm.cpp
@@ -1053,7 +1053,7 @@ void DistributedEngineComm::pushToTheLocalQueueAndNotifyRecv(const messageqcpp::
 // SBS is cleared when it is sent to PP at the same host. This fact forces any
 // code uses ::writeToClient to send to a local node in the last turn.
 int DistributedEngineComm::writeToClient(size_t aPMIndex, const SBS& bs, uint32_t senderUniqueID,
-                                         bool doInterleaving)
+                                         bool /*doInterleaving*/)
 {
  MessageQueueMap::iterator it;
  // Keep mqe's stats from being freed early
--- a/dbcon/joblist/elementcompression.h
+++ b/dbcon/joblist/elementcompression.h
@@ -83,74 +83,74 @@ class ElementCompression
  //
  template <typename DestType>
  static void compress(std::vector<ElementType>& vIn, std::vector<DestType>& vOut);
-  static void compress(std::vector<ElementType>& vIn, std::vector<CompElement32RidOnly>& vOut)
+  static void compress(std::vector<ElementType>& /*vIn*/, std::vector<CompElement32RidOnly>& /*vOut*/)
  {
    throw std::logic_error("Compression of ElementType to 32RidOnly not supported");
  }

-  static void compress(std::vector<StringElementType>& vIn, std::vector<CompElement64Rid32Val>& vOut)
+  static void compress(std::vector<StringElementType>& /*vIn*/, std::vector<CompElement64Rid32Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of StringElementType to 64/32 not supported");
  }
-  static void compress(std::vector<StringElementType>& vIn, std::vector<CompElement32Rid64Val>& vOut)
+  static void compress(std::vector<StringElementType>& /*vIn*/, std::vector<CompElement32Rid64Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of StringElementType to 32/64 not supported");
  }
-  static void compress(std::vector<StringElementType>& vIn, std::vector<CompElement32Rid32Val>& vOut)
+  static void compress(std::vector<StringElementType>& /*vIn*/, std::vector<CompElement32Rid32Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of StringElementType to 32/32 not supported");
  }
-  static void compress(std::vector<StringElementType>& vIn, std::vector<CompElement32RidOnly>& vOut)
+  static void compress(std::vector<StringElementType>& /*vIn*/, std::vector<CompElement32RidOnly>& /*vOut*/)
  {
    throw std::logic_error("Compression of StringElementType to 32RidOnly not supported");
  }

-  static void compress(std::vector<DoubleElementType>& vIn, std::vector<CompElement64Rid32Val>& vOut)
+  static void compress(std::vector<DoubleElementType>& /*vIn*/, std::vector<CompElement64Rid32Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of DoubleElementType to 64/32 not supported");
  }
-  static void compress(std::vector<DoubleElementType>& vIn, std::vector<CompElement32Rid64Val>& vOut)
+  static void compress(std::vector<DoubleElementType>& /*vIn*/, std::vector<CompElement32Rid64Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of DoubleElementType to 32/64 not supported");
  }
-  static void compress(std::vector<DoubleElementType>& vIn, std::vector<CompElement32Rid32Val>& vOut)
+  static void compress(std::vector<DoubleElementType>& /*vIn*/, std::vector<CompElement32Rid32Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of DoubleElementType to 32/32 not supported");
  }
-  static void compress(std::vector<DoubleElementType>& vIn, std::vector<CompElement32RidOnly>& vOut)
+  static void compress(std::vector<DoubleElementType>& /*vIn*/, std::vector<CompElement32RidOnly>& /*vOut*/)
  {
    throw std::logic_error("Compression of DoubleElementType to 32RidOnly not supported");
  }

-  static void compress(std::vector<RIDElementType>& vIn, std::vector<CompElement64Rid32Val>& vOut)
+  static void compress(std::vector<RIDElementType>& /*vIn*/, std::vector<CompElement64Rid32Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of RIDElementType to 64/32 not supported");
  }
-  static void compress(std::vector<RIDElementType>& vIn, std::vector<CompElement32Rid64Val>& vOut)
+  static void compress(std::vector<RIDElementType>& /*vIn*/, std::vector<CompElement32Rid64Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of RIDElementType to 32/64 not supported");
  }
-  static void compress(std::vector<RIDElementType>& vIn, std::vector<CompElement32Rid32Val>& vOut)
+  static void compress(std::vector<RIDElementType>& /*vIn*/, std::vector<CompElement32Rid32Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of RIDElementType to 32/32 not supported");
  }
-  static void compress(std::vector<RIDElementType>& vIn, std::vector<CompElement32RidOnly>& vOut);
+  static void compress(std::vector<RIDElementType>& /*vIn*/, std::vector<CompElement32RidOnly>& /*vOut*/);

-  static void compress(std::vector<TupleType>& vIn, std::vector<CompElement64Rid32Val>& vOut)
+  static void compress(std::vector<TupleType>& /*vIn*/, std::vector<CompElement64Rid32Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of TupleType to 64/32 not supported");
  }
-  static void compress(std::vector<TupleType>& vIn, std::vector<CompElement32Rid64Val>& vOut)
+  static void compress(std::vector<TupleType>& /*vIn*/, std::vector<CompElement32Rid64Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of TupleType to 32/64 not supported");
  }
-  static void compress(std::vector<TupleType>& vIn, std::vector<CompElement32Rid32Val>& vOut)
+  static void compress(std::vector<TupleType>& /*vIn*/, std::vector<CompElement32Rid32Val>& /*vOut*/)
  {
    throw std::logic_error("Compression of TupleType to 32/32 not supported");
  }
-  static void compress(std::vector<TupleType>& vIn, std::vector<CompElement32RidOnly>& vOut)
+  static void compress(std::vector<TupleType>& /*vIn*/, std::vector<CompElement32RidOnly>& /*vOut*/)
  {
-    throw std::logic_error("Compression of TupleType to 32/32 not supported");
+    throw std::logic_error("Compression of TupleType to 32RidOnly not supported");
  }

  //
@@ -158,72 +158,72 @@ class ElementCompression
  //
  template <typename SrcType>
  static void expand(std::vector<SrcType>& vIn, ElementType* vOut);
-  static void expand(std::vector<CompElement32RidOnly>& vIn, ElementType* vOut)
+  static void expand(std::vector<CompElement32RidOnly>& /*vIn*/, ElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to ElementType from 32RidOnly not supported");
  }

-  static void expand(std::vector<CompElement64Rid32Val>& vIn, StringElementType* vOut)
+  static void expand(std::vector<CompElement64Rid32Val>& /*vIn*/, StringElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to StringElementType from 64/32 not supported");
  }
-  static void expand(std::vector<CompElement32Rid64Val>& vIn, StringElementType* vOut)
+  static void expand(std::vector<CompElement32Rid64Val>& /*vIn*/, StringElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to StringElementType from 32/64 not supported");
  }
-  static void expand(std::vector<CompElement32Rid32Val>& vIn, StringElementType* vOut)
+  static void expand(std::vector<CompElement32Rid32Val>& /*vIn*/, StringElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to StringElementType from 32/32 not supported");
  }
-  static void expand(std::vector<CompElement32RidOnly>& vIn, StringElementType* vOut)
+  static void expand(std::vector<CompElement32RidOnly>& /*vIn*/, StringElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to StringElementType from 32RidOnly not supported");
  }

-  static void expand(std::vector<CompElement64Rid32Val>& vIn, DoubleElementType* vOut)
+  static void expand(std::vector<CompElement64Rid32Val>& /*vIn*/, DoubleElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to DoubleElementType from 64/32 not supported");
  }
-  static void expand(std::vector<CompElement32Rid64Val>& vIn, DoubleElementType* vOut)
+  static void expand(std::vector<CompElement32Rid64Val>& /*vIn*/, DoubleElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to DoubleElementType from 32/64 not supported");
  }
-  static void expand(std::vector<CompElement32Rid32Val>& vIn, DoubleElementType* vOut)
+  static void expand(std::vector<CompElement32Rid32Val>& /*vIn*/, DoubleElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to DoubleElementType from 32/32 not supported");
  }
-  static void expand(std::vector<CompElement32RidOnly>& vIn, DoubleElementType* vOut)
+  static void expand(std::vector<CompElement32RidOnly>& /*vIn*/, DoubleElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to DoubleElementType from 32RidOnly not supported");
  }

-  static void expand(std::vector<CompElement64Rid32Val>& vIn, RIDElementType* vOut)
+  static void expand(std::vector<CompElement64Rid32Val>& /*vIn*/, RIDElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to RIDElementType from 64/32 not supported");
  }
-  static void expand(std::vector<CompElement32Rid64Val>& vIn, RIDElementType* vOut)
+  static void expand(std::vector<CompElement32Rid64Val>& /*vIn*/, RIDElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to RIDElementType from 32/64 not supported");
  }
-  static void expand(std::vector<CompElement32Rid32Val>& vIn, RIDElementType* vOut)
+  static void expand(std::vector<CompElement32Rid32Val>& /*vIn*/, RIDElementType* /*vOut*/)
  {
    throw std::logic_error("Expansion to RIDElementType from 32/32 not supported");
  }
-  static void expand(std::vector<CompElement32RidOnly>& vIn, RIDElementType* vOut);
+  static void expand(std::vector<CompElement32RidOnly>& /*vIn*/, RIDElementType* /*vOut*/);

-  static void expand(std::vector<CompElement64Rid32Val>& vIn, TupleType* vOut)
+  static void expand(std::vector<CompElement64Rid32Val>& /*vIn*/, TupleType* /*vOut*/)
  {
    throw std::logic_error("Expansion to TupleType from 64/32 not supported");
  }
-  static void expand(std::vector<CompElement32Rid64Val>& vIn, TupleType* vOut)
+  static void expand(std::vector<CompElement32Rid64Val>& /*vIn*/, TupleType* /*vOut*/)
  {
    throw std::logic_error("Expansion to TupleType from 32/64 not supported");
  }
-  static void expand(std::vector<CompElement32Rid32Val>& vIn, TupleType* vOut)
+  static void expand(std::vector<CompElement32Rid32Val>& /*vIn*/, TupleType* /*vOut*/)
  {
    throw std::logic_error("Expansion to TupleType from 32/32 not supported");
  }
-  static void expand(std::vector<CompElement32RidOnly>& vIn, TupleType* vOut)
+  static void expand(std::vector<CompElement32RidOnly>& /*vIn*/, TupleType* /*vOut*/)
  {
    throw std::logic_error("Expansion to TupleType from 32/32 not supported");
  }
@@ -232,13 +232,13 @@ class ElementCompression
  //...Utilities to write a single element with a compressed 32 bit RID.
  //
  static void writeWith32Rid(const ElementType& e, std::fstream& fFile);
-  static void writeWith32Rid(const DoubleElementType& e, std::fstream& fFile)
+  static void writeWith32Rid(const DoubleElementType& /*e*/, std::fstream& /*fFile*/)
  {
    throw std::logic_error("Compress/Write of 32 RID DoubleElementType not supported");
  }
  static void writeWith32Rid(const StringElementType& e, std::fstream& fFile);
  static void writeWith32Rid(const RIDElementType& e, std::fstream& fFile);
-  static void writeWith32Rid(const TupleType& e, std::fstream& fFile)
+  static void writeWith32Rid(const TupleType& /*e*/, std::fstream& /*fFile*/)
  {
    throw std::logic_error("Compress/Write of 32 RID TupleType not supported");
  }
@@ -247,13 +247,13 @@ class ElementCompression
  //...Utilities to read a single element with a compressed 32 bit RID.
  //
  static void readWith32Rid(ElementType& e, std::fstream& fFile);
-  static void readWith32Rid(DoubleElementType& e, std::fstream& fFile)
+  static void readWith32Rid(DoubleElementType& /*e*/, std::fstream& /*fFile*/)
  {
    throw std::logic_error("Read/Expand of 32 RID DoubleElementType not supported");
  }
  static void readWith32Rid(StringElementType& e, std::fstream& fFile);
  static void readWith32Rid(RIDElementType& e, std::fstream& fFile);
-  static void readWith32Rid(TupleType& e, std::fstream& fFile)
+  static void readWith32Rid(TupleType& /*e*/, std::fstream& /*fFile*/)
  {
    throw std::logic_error("Read/Expand of 32 RID TupleType not supported");
  }
@@ -404,7 +404,6 @@ template <typename SrcType>
    fFile.read(d, dlen);
    e.second.assign((const uint8_t*)d, dlen);
  }
-
 }

 /* static */ inline void ElementCompression::readWith32Rid(RIDElementType& e, std::fstream& fFile)
--- a/dbcon/joblist/elementtype.cpp
+++ b/dbcon/joblist/elementtype.cpp
@@ -66,11 +66,11 @@ ostream& operator<<(ostream& out, const ElementType& rhs)

 static ostream& writeRid(std::ostream& out, const uint64_t& rhs)
 {
-  out.write((const char*) (&rhs), sizeof(rhs));
+  out.write((const char*)(&rhs), sizeof(rhs));
  return out;
 }

-std::istream& operator >>(std::istream& in, utils::NullString& ns)
+std::istream& operator>>(std::istream& in, utils::NullString& ns)
 {
  uint8_t isNull;
  in.read((char*)(&isNull), sizeof(isNull));
@@ -89,7 +89,7 @@ std::istream& operator >>(std::istream& in, utils::NullString& ns)
  return in;
 }

-std::ostream& operator <<(std::ostream& out, const utils::NullString& ns)
+std::ostream& operator<<(std::ostream& out, const utils::NullString& ns)
 {
  uint8_t isNull = ns.isNull();
  out.write((char*)(&isNull), sizeof(isNull));
@@ -103,8 +103,8 @@ std::ostream& operator <<(std::ostream& out, const utils::NullString& ns)
  return out;
 }

-// XXX: somewhat hacky. there's an operator with unknown/unneccessarily complex semantics, so I invented mine's, with
-// slightly different types.
+// XXX: somewhat hacky. there's an operator with unknown/unneccessarily complex semantics, so I invented
+// mine's, with slightly different types.
 static istream& readRid(std::istream& in, uint64_t& rhs)
 {
  in.read((char*)(&rhs), sizeof(rhs));
@@ -173,12 +173,12 @@ ostream& operator<<(ostream& os, const RIDElementType& dl)
  return os;
 }

-istream& operator>>(istream& is, TupleType& dl)
+istream& operator>>(istream& /*is*/, TupleType& /*dl*/)
 {
  throw std::logic_error("TupleType >> not implemented");
 }

-ostream& operator<<(ostream& os, const TupleType& dl)
+ostream& operator<<(ostream& /*os*/, const TupleType& /*dl*/)
 {
  throw std::logic_error("TupleType << not implemented");
 }
--- a/dbcon/joblist/elementtype.h
+++ b/dbcon/joblist/elementtype.h
@@ -170,7 +170,7 @@ struct RIDElementType
  RIDElementType();
  explicit RIDElementType(uint64_t f);

-  const char* getHashString(uint64_t mode, uint64_t* len) const
+  const char* getHashString(uint64_t /*mode*/, uint64_t* len) const
  {
    *len = 8;
    return (char*)&first;
@@ -211,7 +211,7 @@ struct TupleType
   * @note params mode and len are ignored here. they are carried
   * just to keep a consistent interface with the other element type
   */
-  const char* getHashString(uint64_t mode, uint64_t* len) const
+  const char* getHashString(uint64_t /*mode*/, uint64_t* /*len*/) const
  {
    return (char*)second;
  }
@@ -404,7 +404,6 @@ class AnyDataList
  AnyDataList(const AnyDataList& rhs) = delete;
  AnyDataList& operator=(const AnyDataList& rhs) = delete;
  boost::shared_ptr<RowGroupDL> fDatalist;
-  bool fDisown;
 };

 /** @brief type AnyDataListSPtr
--- a/dbcon/joblist/expressionstep.h
+++ b/dbcon/joblist/expressionstep.h
@@ -76,7 +76,7 @@ class ExpressionStep : public JobStep
    return fViews.empty() ? "" : fViews.front();
  }
  using JobStep::partitions;
-  execplan::Partitions partitions() const
+  execplan::Partitions partitions() const override
  {
    return fPartitions;
  }
--- a/dbcon/joblist/fifo.h
+++ b/dbcon/joblist/fifo.h
@@ -167,9 +167,11 @@ class FIFO : public DataListImpl<std::vector<element_t>, element_t>
  uint64_t blockedInsertWriteCount;
  uint64_t blockedNextReadCount;

-  FIFO& operator=(const FIFO&);
-  FIFO(const FIFO&);
-  FIFO();
+  FIFO& operator=(const FIFO&) = delete;
+  FIFO(const FIFO&) = delete;
+  FIFO& operator=(FIFO&&) = delete;
+  FIFO(FIFO&&) = delete;
+  FIFO() = delete;

  void signalPs();
  bool swapBuffers(bool waitIfBlocked = true);
@@ -207,24 +209,6 @@ FIFO<element_t>::FIFO(uint32_t con, uint32_t max) : DataListImpl<std::vector<ele
  blockedInsertWriteCount = blockedNextReadCount = 0;
 }

-template <typename element_t>
-FIFO<element_t>::FIFO()
-{
-  throw std::logic_error("don't use FIFO()");
-}
-
-template <typename element_t>
-FIFO<element_t>::FIFO(const FIFO<element_t>& f)
-{
-  throw std::logic_error("don't use FIFO(FIFO &)");
-}
-
-template <typename element_t>
-FIFO<element_t>& FIFO<element_t>::operator=(const FIFO<element_t>& f)
-{
-  throw std::logic_error("don't use FIFO:: =");
-}
-
 template <typename element_t>
 FIFO<element_t>::~FIFO()
 {
--- a/dbcon/joblist/filtercommand-jl.cpp
+++ b/dbcon/joblist/filtercommand-jl.cpp
@@ -38,7 +38,7 @@ FilterCommandJL::~FilterCommandJL()
 {
 }

-void FilterCommandJL::setLBID(uint64_t rid, uint32_t dbroot)
+void FilterCommandJL::setLBID(uint64_t /*rid*/, uint32_t /*dbroot*/)
 {
 }

@@ -67,7 +67,7 @@ void FilterCommandJL::createCommand(ByteStream& bs) const
  CommandJL::createCommand(bs);
 }

-void FilterCommandJL::runCommand(ByteStream& bs) const
+void FilterCommandJL::runCommand(ByteStream& /*bs*/) const
 {
 }

--- a/dbcon/joblist/jlf_common.cpp
+++ b/dbcon/joblist/jlf_common.cpp
@@ -44,9 +44,8 @@ namespace
 // @brief Returns unique key for a column, table, or expresssion.
 uint32_t uniqTupleKey(JobInfo& jobInfo, CalpontSystemCatalog::OID& o, CalpontSystemCatalog::OID& t,
                      const string& cn, const string& ca, const string& tn, const string& ta,
-                      const string& sn, const string& vw, const execplan::Partitions& pa,
-		      uint32_t pi, uint64_t en,
-                      bool correlated = false)
+                      const string& sn, const string& vw, const execplan::Partitions& pa, uint32_t pi,
+                      uint64_t en, bool correlated = false)
 {
  uint64_t subId = jobInfo.subId;

@@ -159,13 +158,12 @@ TupleInfo setTupleInfo_(const CalpontSystemCatalog::ColType& ct, CalpontSystemCa
                        JobInfo& jobInfo, CalpontSystemCatalog::OID tbl_oid, const string& col_name,
                        const string& col_alias, const string& sch_name, const string& tbl_name,
                        const string& tbl_alias, const string& vw_name,
-			const execplan::Partitions& partitions,
-			bool correlated = false,
-                        uint32_t pc_id = 0, uint64_t engine = 0)
+                        const execplan::Partitions& partitions, bool correlated = false, uint32_t pc_id = 0,
+                        uint64_t engine = 0)
 {
  // get the unique tupleOids for this column
-  uint32_t tbl_key = uniqTupleKey(jobInfo, tbl_oid, tbl_oid, "", "", tbl_name, tbl_alias, sch_name, vw_name, partitions,
-                                  0, engine, correlated);
+  uint32_t tbl_key = uniqTupleKey(jobInfo, tbl_oid, tbl_oid, "", "", tbl_name, tbl_alias, sch_name, vw_name,
+                                  partitions, 0, engine, correlated);
  uint32_t col_key = uniqTupleKey(jobInfo, col_oid, tbl_oid, col_name, col_alias, tbl_name, tbl_alias,
                                  sch_name, vw_name, partitions, pc_id, engine, correlated);
  // If this is the first time we've seen this col, add it to the tim
@@ -197,8 +195,8 @@ TupleInfo setTupleInfo_(const CalpontSystemCatalog::ColType& ct, CalpontSystemCa

 uint32_t getTupleKey_(const JobInfo& jobInfo, CalpontSystemCatalog::OID oid, const string& colName,
                      const string& tblAlias, const string& schema, const string& view,
-		      const execplan::Partitions& part,
-                      bool correlated = false, uint32_t pseudo = 0, uint64_t engine = 0)
+                      const execplan::Partitions& part, bool correlated = false, uint32_t pseudo = 0,
+                      uint64_t /*engine*/ = 0)
 {
  uint64_t subId = jobInfo.subId;

@@ -289,9 +287,7 @@ string UniqId::toString() const
    strstm << dlm << p;
    dlm = ",";
  }
-  strstm << "):"
-         << fPseudo << ":"
-         << (int64_t)fSubId;
+  strstm << "):" << fPseudo << ":" << (int64_t)fSubId;
  return strstm.str();
 }

@@ -410,7 +406,7 @@ uint32_t getTupleKey(JobInfo& jobInfo, const execplan::SimpleColumn* sc, bool ad
    // TupleInfo is expected to be set already
    return getTupleKey_(jobInfo, sc->oid(), sc->columnName(), extractTableAlias(sc), sc->schemaName(),
                        sc->viewName(), execplan::Partitions(),
-			((sc->joinInfo() & execplan::JOIN_CORRELATED) != 0), pseudoType,
+                        ((sc->joinInfo() & execplan::JOIN_CORRELATED) != 0), pseudoType,
                        (sc->isColumnStore() ? 0 : 1));
  }

@@ -492,7 +488,7 @@ uint32_t getTupleKey(JobInfo& jobInfo, const SRCP& srcp, bool add)

 uint32_t getTableKey(const JobInfo& jobInfo, execplan::CalpontSystemCatalog::OID tableOid,
                     const string& alias, const string& schema, const string& view,
-		     const execplan::Partitions& part)
+                     const execplan::Partitions& part)
 {
  return getTupleKey_(jobInfo, tableOid, "", alias, schema, view, part);
 }
@@ -582,7 +578,8 @@ TupleInfo setExpTupleInfo(const execplan::CalpontSystemCatalog::ColType& ct, uin
  if (!(ji->subAlias.empty()))
    expAlias += ji->subAlias;

-  return setTupleInfo_(ct, expressionId, jobInfo, CNX_EXP_TABLE_ID, "", alias, "", "$exp", expAlias, "", execplan::Partitions(), cr);
+  return setTupleInfo_(ct, expressionId, jobInfo, CNX_EXP_TABLE_ID, "", alias, "", "$exp", expAlias, "",
+                       execplan::Partitions(), cr);
 }

 TupleInfo setExpTupleInfo(const execplan::ReturnedColumn* rc, JobInfo& jobInfo)
--- a/dbcon/joblist/jlf_execplantojoblist.cpp
+++ b/dbcon/joblist/jlf_execplantojoblist.cpp
@@ -306,14 +306,10 @@ void convertValueNum(const string& str, const CalpontSystemCatalog::ColType& ct,
    case CalpontSystemCatalog::USMALLINT: v = boost::any_cast<uint16_t>(anyVal); break;

    case CalpontSystemCatalog::MEDINT:
-    case CalpontSystemCatalog::INT:
-      v = boost::any_cast<int32_t>(anyVal);
-      break;
+    case CalpontSystemCatalog::INT: v = boost::any_cast<int32_t>(anyVal); break;

    case CalpontSystemCatalog::UMEDINT:
-    case CalpontSystemCatalog::UINT:
-      v = boost::any_cast<uint32_t>(anyVal);
-      break;
+    case CalpontSystemCatalog::UINT: v = boost::any_cast<uint32_t>(anyVal); break;

    case CalpontSystemCatalog::BIGINT: v = boost::any_cast<long long>(anyVal); break;

@@ -772,7 +768,6 @@ const JobStepVector doColFilter(const SimpleColumn* sc1, const SimpleColumn* sc2
      // data list for column 1 step 1 (pcolstep) output
      AnyDataListSPtr spdl11(new AnyDataList());

-
      JobStepAssociation outJs1;
      outJs1.outAdd(spdl11);
      pcs1->outputAssociation(outJs1);
@@ -833,7 +828,6 @@ const JobStepVector doColFilter(const SimpleColumn* sc1, const SimpleColumn* sc2
      // data list for column 1 step 1 (pcolstep) output
      AnyDataListSPtr spdl11(new AnyDataList());

-
      JobStepAssociation outJs1;
      outJs1.outAdd(spdl11);
      pcs1->outputAssociation(outJs1);
@@ -1815,7 +1809,8 @@ const JobStepVector doSimpleFilter(SimpleFilter* sf, JobInfo& jobInfo)
        }

        if (cc->isNull() && (opis == *sop || opisnull == *sop))
-          jobInfo.tableHasIsNull.insert(getTableKey(jobInfo, tbl_oid, alias, sc->schemaName(), view, sc->partitions()));
+          jobInfo.tableHasIsNull.insert(
+              getTableKey(jobInfo, tbl_oid, alias, sc->schemaName(), view, sc->partitions()));
      }
      else
      {
@@ -2045,11 +2040,11 @@ const JobStepVector doOuterJoinOnFilter(OuterJoinOnFilter* oj, JobInfo& jobInfo)
        // @bug3037, workaround on join order, wish this can be corrected soon,
        // cascade outer table attribute.
        CalpontSystemCatalog::OID tableOid1 = tableOid(sc1, jobInfo.csc);
-        uint64_t tid1 =
-            getTableKey(jobInfo, tableOid1, sc1->tableAlias(), sc1->schemaName(), sc1->viewName(), sc1->partitions());
+        uint64_t tid1 = getTableKey(jobInfo, tableOid1, sc1->tableAlias(), sc1->schemaName(), sc1->viewName(),
+                                    sc1->partitions());
        CalpontSystemCatalog::OID tableOid2 = tableOid(sc2, jobInfo.csc);
-        uint64_t tid2 =
-            getTableKey(jobInfo, tableOid2, sc2->tableAlias(), sc2->schemaName(), sc2->viewName(), sc2->partitions());
+        uint64_t tid2 = getTableKey(jobInfo, tableOid2, sc2->tableAlias(), sc2->schemaName(), sc2->viewName(),
+                                    sc2->partitions());

        if (tablesInOuter.find(tid1) != tablesInOuter.end())
          sc1->returnAll(true);
@@ -2196,7 +2191,8 @@ const JobStepVector doOuterJoinOnFilter(OuterJoinOnFilter* oj, JobInfo& jobInfo)
        if (sc != NULL)
        {
          CalpontSystemCatalog::OID tblOid = tableOid(sc, jobInfo.csc);
-          uint64_t tid = getTableKey(jobInfo, tblOid, sc->tableAlias(), sc->schemaName(), sc->viewName(), sc->partitions());
+          uint64_t tid = getTableKey(jobInfo, tblOid, sc->tableAlias(), sc->schemaName(), sc->viewName(),
+                                     sc->partitions());

          // skip outer table filters or table not directly involved in the outer join
          if (tablesInOuter.find(tid) != tablesInOuter.end() || tablesInJoin.find(tid) == tablesInJoin.end())
@@ -2427,7 +2423,7 @@ bool tryCombineDictionary(JobStepVector& jsv1, JobStepVector& jsv2, int8_t bop)
  return false;
 }

-bool tryCombineDictionaryScan(JobStepVector& jsv1, JobStepVector& jsv2, int8_t bop)
+bool tryCombineDictionaryScan(JobStepVector& /*jsv1*/, JobStepVector& /*jsv2*/, int8_t /*bop*/)
 {
 // disable dictionary scan -- bug3321
 #if 0
--- a/dbcon/joblist/jlf_tuplejoblist.cpp
+++ b/dbcon/joblist/jlf_tuplejoblist.cpp
@@ -25,8 +25,8 @@
 #include <stack>
 #include <iterator>
 #include <algorithm>
-//#define NDEBUG
-//#include <cassert>
+// #define NDEBUG
+// #include <cassert>
 #include <vector>
 #include <set>
 #include <map>
@@ -300,7 +300,7 @@ void constructJoinedRowGroup(RowGroup& rg, set<uint32_t>& tableSet, TableInfoMap
  rg = tmpRg;
 }

-void updateExp2Cols(JobStepVector& expSteps, TableInfoMap& tableInfoMap, JobInfo& jobInfo)
+void updateExp2Cols(JobStepVector& expSteps, TableInfoMap& tableInfoMap, JobInfo& /*jobInfo*/)
 {
  for (JobStepVector::iterator it = expSteps.begin(); it != expSteps.end(); it++)
  {
@@ -817,7 +817,8 @@ void addExpresssionStepsToBps(TableInfoMap::iterator& mit, SJSTEP& sjsp, JobInfo
    }
    else
    {
-      sjsp.reset(new CrossEngineStep(mit->second.fSchema, mit->second.fName, mit->second.fPartitions, mit->second.fAlias, jobInfo));
+      sjsp.reset(new CrossEngineStep(mit->second.fSchema, mit->second.fName, mit->second.fPartitions,
+                                     mit->second.fAlias, jobInfo));

      bps = dynamic_cast<CrossEngineStep*>(sjsp.get());
    }
@@ -1003,8 +1004,8 @@ bool combineJobStepsByTable(TableInfoMap::iterator& mit, JobInfo& jobInfo)
          }
          else
          {
-            sjsp.reset(
-                new CrossEngineStep(mit->second.fSchema, mit->second.fName, mit->second.fPartitions, mit->second.fAlias, jobInfo));
+            sjsp.reset(new CrossEngineStep(mit->second.fSchema, mit->second.fName, mit->second.fPartitions,
+                                           mit->second.fAlias, jobInfo));
            bps = dynamic_cast<CrossEngineStep*>(sjsp.get());
          }
        }
@@ -3407,8 +3408,9 @@ SP_JoinInfo joinToLargeTable(uint32_t large, TableInfoMap& tableInfoMap, JobInfo
        {
          if ((jointypes[i] & SEMI) || (jointypes[i] & ANTI) || (jointypes[i] & SCALAR))
          {
-            uint32_t tid = getTableKey(jobInfo, smallSides[i]->fTableOid, smallSides[i]->fAlias,
-                                       smallSides[i]->fSchema, smallSides[i]->fView, smallSides[i]->fPartitions);
+            uint32_t tid =
+                getTableKey(jobInfo, smallSides[i]->fTableOid, smallSides[i]->fAlias, smallSides[i]->fSchema,
+                            smallSides[i]->fView, smallSides[i]->fPartitions);
            correlateTables[tid] = i;
            correlateCompare[tid] = NULL;
          }
@@ -4173,8 +4175,9 @@ void joinTablesInOrder(uint32_t largest, JobStepVector& joinSteps, TableInfoMap&
      {
        if ((jointypes[i] & SEMI) || (jointypes[i] & ANTI) || (jointypes[i] & SCALAR))
        {
-          uint32_t tid = getTableKey(jobInfo, smallSides[i]->fTableOid, smallSides[i]->fAlias,
-                                     smallSides[i]->fSchema, smallSides[i]->fView, smallSides[i]->fPartitions);
+          uint32_t tid =
+              getTableKey(jobInfo, smallSides[i]->fTableOid, smallSides[i]->fAlias, smallSides[i]->fSchema,
+                          smallSides[i]->fView, smallSides[i]->fPartitions);
          correlateTables[tid] = i;
          correlateCompare[tid] = NULL;
        }
@@ -4413,7 +4416,7 @@ void associateTupleJobSteps(JobStepVector& querySteps, JobStepVector& projectSte
    const boost::shared_ptr<TupleKeyInfo>& keyInfo = jobInfo.keyInfo;
    cout << "query steps:" << endl;

-    for (const auto& step: querySteps)
+    for (const auto& step : querySteps)
    {
      auto* thjs = dynamic_cast<TupleHashJoinStep*>(step.get());

@@ -4436,7 +4439,7 @@ void associateTupleJobSteps(JobStepVector& querySteps, JobStepVector& projectSte

    cout << "project steps:" << endl;

-    for (const auto& prStep: projectSteps)
+    for (const auto& prStep : projectSteps)
    {
      cout << typeid(prStep.get()).name() << ": " << prStep->oid() << " " << prStep->tupleId() << " "
           << getTableKey(jobInfo, prStep->tupleId()) << endl;
@@ -4444,7 +4447,7 @@ void associateTupleJobSteps(JobStepVector& querySteps, JobStepVector& projectSte

    cout << "delivery steps:" << endl;

-    for (const auto& [_, value]: deliverySteps)
+    for (const auto& [_, value] : deliverySteps)
    {
      cout << typeid(value.get()).name() << endl;
    }
@@ -4606,7 +4609,7 @@ void associateTupleJobSteps(JobStepVector& querySteps, JobStepVector& projectSte

  // Make sure each query step has an output DL
  // This is necessary for toString() method on most steps
-  for (auto& step: steps)
+  for (auto& step : steps)
  {
    // if (dynamic_cast<OrDelimiter*>(it->get()))
    //	continue;
@@ -4798,7 +4801,7 @@ void associateTupleJobSteps(JobStepVector& querySteps, JobStepVector& projectSte
      bool tableInOuterQuery = false;
      set<uint32_t> tableSet;  // involved unique tables

-      for (unsigned int table: tables)
+      for (unsigned int table : tables)
      {
        if (find(jobInfo.tableList.begin(), jobInfo.tableList.end(), table) != jobInfo.tableList.end())
          tableSet.insert(table);
@@ -5039,7 +5042,7 @@ void associateTupleJobSteps(JobStepVector& querySteps, JobStepVector& projectSte
  joinTables(joinSteps, tableInfoMap, jobInfo, joinOrder, overrideLargeSideEstimate);

  // 3. put the steps together
-  for (uint32_t i: joinOrder)
+  for (uint32_t i : joinOrder)
    querySteps.insert(querySteps.end(), tableInfoMap[i].fQuerySteps.begin(),
                      tableInfoMap[i].fQuerySteps.end());

--- a/dbcon/joblist/joblist.cpp
+++ b/dbcon/joblist/joblist.cpp
@@ -558,7 +558,7 @@ void JobList::querySummary(bool extendedStats)
 }

 // @bug 828. Added additional information to the graph at the end of execution
-void JobList::graph(uint32_t sessionID)
+void JobList::graph(uint32_t /*sessionID*/)
 {
  // Graphic view draw
  auto jsrname = jlf_graphics::generateDotFileName("jobstep_results.");
--- a/dbcon/joblist/joblistfactory.cpp
+++ b/dbcon/joblist/joblistfactory.cpp
@@ -22,7 +22,7 @@
 #include <stack>
 #include <iterator>
 #include <algorithm>
-//#define NDEBUG
+// #define NDEBUG
 #include <cassert>
 #include <vector>
 #include <set>
@@ -384,7 +384,6 @@ void checkHavingClause(CalpontSelectExecutionPlan* csep, JobInfo& jobInfo)
      }
    }
  }
-
 }

 void preProcessFunctionOnAggregation(const vector<SimpleColumn*>& scs, const vector<AggregateColumn*>& aggs,
@@ -519,9 +518,9 @@ void checkGroupByCols(CalpontSelectExecutionPlan* csep, JobInfo& jobInfo)
        // Not an aggregate column and not an expression of aggregation.
        if (dynamic_cast<AggregateColumn*>(orderByCols[i].get()) == NULL &&
            orderByCols[i]->aggColumnList().empty())
-	{
+        {
          csep->groupByCols().push_back(orderByCols[i]);
-	}
+        }
      }
    }
  }
@@ -1132,7 +1131,9 @@ const JobStepVector doAggProject(const CalpontSelectExecutionPlan* csep, JobInfo
              it = pcv.insert(pcv.end(), srcp);

            auto placeToInsert = std::distance(pcv.begin(), it);
-            projectKeys.insert(projectKeys.begin() + std::min(placeToInsert, projectKeys.end() - projectKeys.begin()), tupleKey);
+            projectKeys.insert(
+                projectKeys.begin() + std::min(placeToInsert, projectKeys.end() - projectKeys.begin()),
+                tupleKey);
          }
          else if (doDistinct)  // @bug4250, move forward distinct column if necessary.
          {
@@ -1304,7 +1305,8 @@ const JobStepVector doAggProject(const CalpontSelectExecutionPlan* csep, JobInfo
          it = pcv.insert(pcv.end(), srcp);

        auto placeToInsert = std::distance(pcv.begin(), it);
-        projectKeys.insert(projectKeys.begin() + std::min(placeToInsert, projectKeys.end() - projectKeys.begin()), tupleKey);
+        projectKeys.insert(
+            projectKeys.begin() + std::min(placeToInsert, projectKeys.end() - projectKeys.begin()), tupleKey);
      }
      else if (doDistinct)  // @bug4250, move forward distinct column if necessary.
      {
@@ -1539,7 +1541,7 @@ void exceptionHandler(JobList* joblist, const JobInfo& jobInfo, const string& lo
 }

 void parseExecutionPlan(CalpontSelectExecutionPlan* csep, JobInfo& jobInfo, JobStepVector& querySteps,
-                        JobStepVector& projectSteps, DeliveredTableMap& deliverySteps)
+                        JobStepVector& projectSteps, DeliveredTableMap& /*deliverySteps*/)
 {
  ParseTree* filters = csep->filters();
  jobInfo.deliveredCols = csep->returnedCols();
@@ -1966,7 +1968,8 @@ void makeJobSteps(CalpontSelectExecutionPlan* csep, JobInfo& jobInfo, JobStepVec
    else
      oid = 0;

-    uint32_t tableUid = makeTableKey(jobInfo, oid, it->table, it->alias, it->schema, it->view, it->partitions);
+    uint32_t tableUid =
+        makeTableKey(jobInfo, oid, it->table, it->alias, it->schema, it->view, it->partitions);
    jobInfo.tableList.push_back(tableUid);
  }

@@ -2308,8 +2311,8 @@ namespace joblist
 {
 /* static */
 SJLP JobListFactory::makeJobList(CalpontExecutionPlan* cplan, ResourceManager* rm,
-                                 const PrimitiveServerThreadPools& primitiveServerThreadPools, bool tryTuple,
-                                 bool isExeMgr)
+                                 const PrimitiveServerThreadPools& primitiveServerThreadPools,
+                                 bool /*tryTuple*/, bool isExeMgr)
 {
  SJLP ret;
  string emsg;
--- a/dbcon/joblist/lbidlist.cpp
+++ b/dbcon/joblist/lbidlist.cpp
@@ -144,7 +144,7 @@ LBIDList::~LBIDList()
 #endif
 }

-void LBIDList::Dump(long Index, int Count) const
+void LBIDList::Dump(long /*Index*/, int /*Count*/) const
 {
  LBIDRange LBIDR;

@@ -422,8 +422,8 @@ void LBIDList::UpdateMinMax(T min, T max, int64_t lbid, bool dictScan,
 #ifdef DEBUG

      if (IS_VERBOSE)
-        cout << "UpdateMinMax() new Mn/Mx " << mmp->min << "/" << mmp->max << " "
-             << " lbid " << lbid << " seq " << mmp->seq << " valid " << mmp->isValid << endl;
+        cout << "UpdateMinMax() new Mn/Mx " << mmp->min << "/" << mmp->max << " " << " lbid " << lbid
+             << " seq " << mmp->seq << " valid " << mmp->isValid << endl;

 #endif
      return;
@@ -929,4 +929,3 @@ template bool LBIDList::checkRangeOverlap<int64_t>(int64_t min, int64_t max, int
                                                   const execplan::CalpontSystemCatalog::ColType& type);

 }  // namespace joblist
-
--- a/dbcon/joblist/limitedorderby.cpp
+++ b/dbcon/joblist/limitedorderby.cpp
@@ -18,7 +18,7 @@
 //  $Id: limitedorderby.cpp 9581 2013-05-31 13:46:14Z pleblanc $

 #include <iostream>
-//#define NDEBUG
+// #define NDEBUG
 #include <cassert>
 #include <string>
 using namespace std;
@@ -196,7 +196,7 @@ void LimitedOrderBy::finalize()
    fDataQueue.push(fData);

  auto& orderByQueue = getQueue();
-  
+
  if (orderByQueue.size() > 0)
  {
    // *DRRTUY Very memory intensive. CS needs to account active
--- a/dbcon/joblist/passthrucommand-jl.cpp
+++ b/dbcon/joblist/passthrucommand-jl.cpp
@@ -76,7 +76,7 @@ PassThruCommandJL::~PassThruCommandJL()
 {
 }

-void PassThruCommandJL::setLBID(uint64_t l, uint32_t dbroot)
+void PassThruCommandJL::setLBID(uint64_t /*l*/, uint32_t /*dbroot*/)
 {
 }

@@ -87,7 +87,7 @@ void PassThruCommandJL::createCommand(ByteStream& bs) const
  CommandJL::createCommand(bs);
 }

-void PassThruCommandJL::runCommand(ByteStream& bs) const
+void PassThruCommandJL::runCommand(ByteStream& /*bs*/) const
 {
 }

--- a/dbcon/joblist/pdictionary.cpp
+++ b/dbcon/joblist/pdictionary.cpp
@@ -160,7 +160,7 @@ const string pDictionaryStep::toString() const
  return oss.str();
 }

-void pDictionaryStep::appendFilter(const messageqcpp::ByteStream& filter, unsigned count)
+void pDictionaryStep::appendFilter(const messageqcpp::ByteStream& filter, unsigned /*count*/)
 {
  ByteStream bs(filter);  // need to preserve the input BS
  uint8_t* buf;
--- a/dbcon/joblist/resourcedistributor.h
+++ b/dbcon/joblist/resourcedistributor.h
@@ -132,7 +132,6 @@ class ResourceDistributor
  std::string fJob;
  std::string fIdentity;
  uint64_t fTotalResource;
-  uint64_t fResourceBlock;
  boost::mutex fResourceLock;
  boost::condition fResourceAvailable;

--- a/dbcon/joblist/rowestimator.cpp
+++ b/dbcon/joblist/rowestimator.cpp
@@ -184,7 +184,7 @@ uint32_t RowEstimator::estimateDistinctValues(const execplan::CalpontSystemCatal
 // predicate against the given range.  This function is used for estimating an individual operation such as
 // col1 = 2.
 template <class T>
-float RowEstimator::estimateOpFactor(const T& min, const T& max, const T& value, char op, uint8_t lcf,
+float RowEstimator::estimateOpFactor(const T& min, const T& max, const T& value, char op, uint8_t /*lcf*/,
                                     uint32_t distinctValues, char cpStatus,
                                     const execplan::CalpontSystemCatalog::ColType& ct)
 {
@@ -263,7 +263,7 @@ float RowEstimator::estimateOpFactor(const T& min, const T& max, const T& value,
 float RowEstimator::estimateRowReturnFactor(const BRM::EMEntry& emEntry, const messageqcpp::ByteStream* bs,
                                            const uint16_t NOPS,
                                            const execplan::CalpontSystemCatalog::ColType& ct,
-                                            const uint8_t BOP, const uint32_t& rowsInExtent)
+                                            const uint8_t BOP, const uint32_t& /*rowsInExtent*/)
 {
  bool bIsUnsigned = datatypes::isUnsigned(ct.colDataType);
  float factor = 1.0;
@@ -500,8 +500,8 @@ float RowEstimator::estimateRowReturnFactor(const BRM::EMEntry& emEntry, const m
 // This function returns the estimated row count for the entire TupleBPS.  It samples the last 20
 // (configurable) extents to calculate the estimate.
 uint64_t RowEstimator::estimateRows(const vector<ColumnCommandJL*>& cpColVec,
-                                    const std::vector<bool>& scanFlags, BRM::DBRM& dbrm,
-                                    const execplan::CalpontSystemCatalog::OID oid)
+                                    const std::vector<bool>& scanFlags, BRM::DBRM& /*dbrm*/,
+                                    const execplan::CalpontSystemCatalog::OID /*oid*/)

 {
 #if ROW_EST_DEBUG
--- a/dbcon/joblist/rowestimator.h
+++ b/dbcon/joblist/rowestimator.h
@@ -47,14 +47,7 @@ class RowEstimator
 public:
  /** @brief ctor
   */
-  RowEstimator()
-   : fExtentsToSample(20)
-   , fIntDistinctAdjust(1)
-   , fDecDistinctAdjust(1)
-   , fChar1DistinctAdjust(1)
-   , fChar2Thru7DistinctAdjust(1)
-   , fDictDistinctAdjust(1)
-   , fDateDistinctAdjust(1)
+  RowEstimator() : fExtentsToSample(20)
  {
  }

@@ -132,12 +125,6 @@ class RowEstimator

  // Configurables read from Columnstore.xml - future.
  uint32_t fExtentsToSample;
-  uint32_t fIntDistinctAdjust;
-  uint32_t fDecDistinctAdjust;
-  uint32_t fChar1DistinctAdjust;
-  uint32_t fChar2Thru7DistinctAdjust;
-  uint32_t fDictDistinctAdjust;
-  uint32_t fDateDistinctAdjust;

  static const uint32_t fRowsPerExtent = 8192 * 1024;
  static const uint32_t fBlockSize = 8192;  // Block size in bytes.
--- a/dbcon/joblist/tupleaggregatestep.cpp
+++ b/dbcon/joblist/tupleaggregatestep.cpp
@@ -2414,7 +2414,7 @@ void TupleAggregateStep::prep1PhaseDistinctAggregate(JobInfo& jobInfo, vector<Ro
                throw IDBExcept(emsg, ERR_NOT_GROUPBY_EXPRESSION);
              }
            }  // else
-          }    // switch
+          }  // switch
        }
      }

@@ -5342,7 +5342,7 @@ void TupleAggregateStep::aggregateRowGroups()
  }
 }

-void TupleAggregateStep::threadedAggregateFinalize(uint32_t threadID)
+void TupleAggregateStep::threadedAggregateFinalize(uint32_t /*threadID*/)
 {
  for (uint32_t i = 0; i < fNumOfBuckets; ++i)
  {
@@ -5631,8 +5631,7 @@ void TupleAggregateStep::threadedAggregateRowGroups(uint32_t threadID)
    catch (...)
    {
      handleException(std::current_exception(), logging::tupleAggregateStepErr,
-                      logging::ERR_AGGREGATION_TOO_BIG,
-                      "TupleAggregateStep::threadedAggregateRowGroups()");
+                      logging::ERR_AGGREGATION_TOO_BIG, "TupleAggregateStep::threadedAggregateRowGroups()");
      fEndOfResult = true;
      fDoneAggregate = true;
    }
@@ -6030,15 +6029,9 @@ void TupleAggregateStep::printCalTrace()
 void TupleAggregateStep::formatMiniStats()
 {
  ostringstream oss;
-  oss << "TAS "
-      << "UM "
-      << "- "
-      << "- "
-      << "- "
-      << "- "
-      << "- "
-      << "- " << JSTimeStamp::tsdiffstr(dlTimes.EndOfInputTime(), dlTimes.FirstReadTime()) << " "
-      << fRowsReturned << " ";
+  oss << "TAS " << "UM " << "- " << "- " << "- " << "- " << "- " << "- "
+      << JSTimeStamp::tsdiffstr(dlTimes.EndOfInputTime(), dlTimes.FirstReadTime()) << " " << fRowsReturned
+      << " ";
  fMiniInfo += oss.str();
 }

--- a/dbcon/joblist/tupleannexstep.cpp
+++ b/dbcon/joblist/tupleannexstep.cpp
@@ -158,7 +158,7 @@ TupleAnnexStep::~TupleAnnexStep()
  fConstant = NULL;
 }

-void TupleAnnexStep::setOutputRowGroup(const rowgroup::RowGroup& rg)
+void TupleAnnexStep::setOutputRowGroup(const rowgroup::RowGroup& /*rg*/)
 {
  throw runtime_error("Disabled, use initialize() to set output RowGroup.");
 }
--- a/dbcon/joblist/tupleconstantstep.cpp
+++ b/dbcon/joblist/tupleconstantstep.cpp
@@ -18,7 +18,7 @@

 //  $Id: tupleconstantstep.cpp 9649 2013-06-25 16:08:05Z xlou $

-//#define NDEBUG
+// #define NDEBUG
 #include <cassert>
 #include <sstream>
 #include <iomanip>
@@ -90,7 +90,7 @@ TupleConstantStep::~TupleConstantStep()
 {
 }

-void TupleConstantStep::setOutputRowGroup(const rowgroup::RowGroup& rg)
+void TupleConstantStep::setOutputRowGroup(const rowgroup::RowGroup& /*rg*/)
 {
  throw runtime_error("Disabled, use initialize() to set output RowGroup.");
 }
@@ -278,7 +278,7 @@ void TupleConstantStep::constructContanstRow(const JobInfo& jobInfo)
        break;
      }
    }  // switch
-  }    // for constant columns
+  }  // for constant columns
 }

 void TupleConstantStep::run()
@@ -567,22 +567,15 @@ void TupleConstantStep::printCalTrace()
 void TupleConstantStep::formatMiniStats()
 {
  ostringstream oss;
-  oss << "TCS "
-      << "UM "
-      << "- "
-      << "- "
-      << "- "
-      << "- "
-      << "- "
-      << "- " << JSTimeStamp::tsdiffstr(dlTimes.EndOfInputTime(), dlTimes.FirstReadTime()) << " "
-      << fRowsReturned << " ";
+  oss << "TCS " << "UM " << "- " << "- " << "- " << "- " << "- " << "- "
+      << JSTimeStamp::tsdiffstr(dlTimes.EndOfInputTime(), dlTimes.FirstReadTime()) << " " << fRowsReturned
+      << " ";
  fMiniInfo += oss.str();
 }

 // class TupleConstantOnlyStep
 TupleConstantOnlyStep::TupleConstantOnlyStep(const JobInfo& jobInfo)
-  : TupleConstantStep(jobInfo)
-  , fEmptySet(jobInfo.constantFalse)
+ : TupleConstantStep(jobInfo), fEmptySet(jobInfo.constantFalse)
 {
  //	fExtendedInfo = "TCOS: ";
 }
@@ -592,7 +585,7 @@ TupleConstantOnlyStep::~TupleConstantOnlyStep()
 }

 // void TupleConstantOnlyStep::initialize(const RowGroup& rgIn, const JobInfo& jobInfo)
-void TupleConstantOnlyStep::initialize(const JobInfo& jobInfo, const rowgroup::RowGroup* rgIn)
+void TupleConstantOnlyStep::initialize(const JobInfo& jobInfo, const rowgroup::RowGroup* /*rgIn*/)
 {
  vector<uint32_t> oids;
  vector<uint32_t> keys;
--- a/dbcon/joblist/tupleconstantstep.h
+++ b/dbcon/joblist/tupleconstantstep.h
@@ -180,10 +180,9 @@ class TupleConstantBooleanStep : public TupleConstantStep
  void fillInConstants() override
  {
  }
-  void constructContanstRow(const JobInfo& jobInfo) override
+  void constructContanstRow(const JobInfo& /*jobInfo*/) override
  {
  }
-
  // boolean value
  bool fValue;
 };
--- a/dbcon/joblist/tuplehavingstep.cpp
+++ b/dbcon/joblist/tuplehavingstep.cpp
@@ -17,7 +17,7 @@

 //  $Id: tuplehavingstep.cpp 9709 2013-07-20 06:08:46Z xlou $

-//#define NDEBUG
+// #define NDEBUG
 #include <cassert>
 #include <sstream>
 #include <iomanip>
@@ -73,7 +73,7 @@ TupleHavingStep::~TupleHavingStep()
 {
 }

-void TupleHavingStep::setOutputRowGroup(const rowgroup::RowGroup& rg)
+void TupleHavingStep::setOutputRowGroup(const rowgroup::RowGroup& /*rg*/)
 {
  throw runtime_error("Disabled, use initialize() to set output RowGroup.");
 }
--- a/dbcon/joblist/windowfunctionstep.cpp
+++ b/dbcon/joblist/windowfunctionstep.cpp
@@ -239,7 +239,7 @@ uint32_t WindowFunctionStep::nextBand(messageqcpp::ByteStream& bs)
  return rowCount;
 }

-void WindowFunctionStep::setOutputRowGroup(const RowGroup& rg)
+void WindowFunctionStep::setOutputRowGroup(const RowGroup& /*rg*/)
 {
  idbassert(0);
 }
@@ -1580,15 +1580,9 @@ void WindowFunctionStep::printCalTrace()
 void WindowFunctionStep::formatMiniStats()
 {
  ostringstream oss;
-  oss << "WFS "
-      << "UM "
-      << "- "
-      << "- "
-      << "- "
-      << "- "
-      << "- "
-      << "- " << JSTimeStamp::tsdiffstr(dlTimes.EndOfInputTime(), dlTimes.FirstReadTime()) << " "
-      << fRowsReturned << " ";
+  oss << "WFS " << "UM " << "- " << "- " << "- " << "- " << "- " << "- "
+      << JSTimeStamp::tsdiffstr(dlTimes.EndOfInputTime(), dlTimes.FirstReadTime()) << " " << fRowsReturned
+      << " ";
  fMiniInfo += oss.str();
 }