TableParseGroupby.h

Go to the documentation of this file.

// # TableParseGroupby.h: Class handling GROUPBY and aggregate functions
// # Copyright (C) 1994-2022
// # Associated Universities, Inc. Washington DC, USA.
// #
// # This library is free software; you can redistribute it and/or modify it
// # under the terms of the GNU Library General Public License as published by
// # the Free Software Foundation; either version 2 of the License, or (at your
// # option) any later version.
// #
// # This library is distributed in the hope that it will be useful, but WITHOUT
// # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
// # License for more details.
// #
// # You should have received a copy of the GNU Library General Public License
// # along with this library; if not, write to the Free Software Foundation,
// # Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
// #
// # Correspondence concerning AIPS++ should be addressed as follows:
// #        Internet email: casa-feedback@nrao.edu.
// #        Postal address: AIPS++ Project Office
// #                        National Radio Astronomy Observatory
// #                        520 Edgemont Road
// #                        Charlottesville, VA 22903-2475 USA
 
#ifndef TABLES_TABLEPARSEGROUPBY_H
#define TABLES_TABLEPARSEGROUPBY_H
 
// # Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/TaQL/ExprNode.h>
#include <casacore/tables/TaQL/ExprGroup.h>
#include <vector>
 
namespace casacore {  // # NAMESPACE CASACORE - BEGIN
 
// # Forward declarations
class TableParseQuery;
 
// <summary>
// Class handling GROUPBY and aggregate functions
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <synopsis>
// This class is used by TableParseQuery to handle TaQL's GROUPBY and HAVING
// clauses and to setup and evaluate aggregate functions.
// It checks that the commands and functions are given in a valid way.
// <br>Note that some hooks are present for the ROLLUP keyword, but it is not
// possible to use it yet.
// </synopsis>
 
class TableParseGroupby {
 public:
  enum GroupAggrType { GROUPBY = 1, AGGR_FUNCS = 2, ONLY_COUNTALL = 4 };
 
  // Keep the groupby expressions.
  // It checks if they are all scalar expressions and do not contain
  // aggregate functions..
  void handleGroupby(const std::vector<TableExprNode>&, Bool rollup);
 
  // Keep the having expression.
  // It checks if the node results in a bool scalar value.
  void handleHaving(const TableExprNode&);
 
  // Find if groupby and/or aggregate functions are given.
  // The column nodes can only contain aggregate functions if SELECT is used.
  // Finally it checks that HAVING is only used if a column node contains
  // an aggregate function (it makes no sense otherwise).
  void findGroupAggr(const Block<TableExprNode>& columnNodes, Bool isSelect);
 
  // Is GROUPBY and/or aggregation used?
  Bool isUsed() const { return itsGroupAggrUsed != 0; }
 
  // Is only aggregation used?
  Bool isOnlyAggr() const { return itsGroupAggrUsed != 0 && (itsGroupAggrUsed & GROUPBY) == 0; }
 
  // Get the number of aggregation ndes.
  uInt size() const { return itsAggrNodes.size(); }
 
  // Disable applySelection for the column nodes of aggregate functions.
  uInt disableApplySelection();
 
  // An exception is thrown if the node uses an aggregate function.
  static void checkAggrFuncs(const TableExprNode& node);
 
  // Execute the grouping and aggregation and return the results.
  // The rownrs are adapted to the resulting rownrs consisting of the
  // first row of each group.
  std::shared_ptr<TableExprGroupResult> execGroupAggr(Vector<rownr_t>& rownrs) const;
 
  // Execute the HAVING clause (if present).
  // Return False in no HAVING.
  Bool execHaving(Vector<rownr_t>& rownrs, const std::shared_ptr<TableExprGroupResult>& groups);
 
 private:
  // Do the grouping and aggregation and return the results.
  // It distinguishes the immediate and lazy aggregate functions.
  // The rownrs are adapted to the resulting rownrs consisting of the
  // first row of each group.
  std::shared_ptr<TableExprGroupResult> aggregate(Vector<rownr_t>& rownrs) const;
 
  // Do the grouping and aggregation and return the results.
  // It consists of a single COUNTALL operation.
  // The rownrs are adapted to the resulting rownrs consisting of the
  // first row of each group.
  std::shared_ptr<TableExprGroupResult> countAll(Vector<rownr_t>& rownrs) const;
 
  // Create the set of aggregate functions and groupby keys.
  std::vector<std::shared_ptr<TableExprGroupFuncSet>> multiKey(
      const std::vector<TableExprNodeRep*>&, const Vector<rownr_t>& rownrs) const;
 
  // Create the set of aggregate functions and groupby keys in case
  // a single groupby key is given.
  // This offers much faster map access then the general multipleKeys.
  template <typename T>
  std::vector<std::shared_ptr<TableExprGroupFuncSet>> singleKey(
      const std::vector<TableExprNodeRep*>& nodes, const Vector<rownr_t>& rownrs) const {
    // We have to group the data according to the (possibly empty) groupby.
    // We step through the table in the normal order which may not be the
    // groupby order.
    // A map<key,int> is used to keep track of the results where the int
    // is the index in a vector of a set of aggregate function objects.
    std::vector<std::shared_ptr<TableExprGroupFuncSet>> funcSets;
    std::map<T, int> keyFuncMap;
    T lastKey = std::numeric_limits<T>::max();
    int groupnr = -1;
    // Loop through all rows.
    // For each row generate the key to get the right entry.
    TableExprId rowid(0);
    T key;
    for (rownr_t i = 0; i < rownrs.size(); ++i) {
      rowid.setRownr(rownrs[i]);
      itsGroupbyNodes[0].get(rowid, key);
      if (key != lastKey) {
        typename std::map<T, int>::iterator iter = keyFuncMap.find(key);
        if (iter == keyFuncMap.end()) {
          groupnr = funcSets.size();
          keyFuncMap[key] = groupnr;
          funcSets.push_back(
              std::shared_ptr<TableExprGroupFuncSet>(new TableExprGroupFuncSet(nodes)));
        } else {
          groupnr = iter->second;
        }
      }
      rowid.setRownr(rownrs[i]);
      funcSets[groupnr]->apply(rowid);
    }
    return funcSets;
  }
 
  // Get pointers to the aggregate nodes in the node expression.
  void getAggrNodes(const TableExprNode& node, std::vector<TableExprNodeRep*>& aggrNodes) const;
 
  // # Data members.
  //  The possible GROUPBY expressions.
  std::vector<TableExprNode> itsGroupbyNodes;
  Bool itsGroupbyRollup;  // # use ROLLUP in GROUPBY?
  // The possible HAVING expression.
  TableExprNode itsHavingNode;
  // Pointers to the aggregate function nodes.
  std::vector<TableExprNodeRep*> itsAggrNodes;
  Int itsGroupAggrUsed;
};
 
}  // namespace casacore
 
#endif