Loading...
Searching...
No Matches
ExprGroup.h
Go to the documentation of this file.
//# ExprGroup.h: Classes handling TaQL's GROUPBY functionality
//# Copyright (C) 2013
//# 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_EXPRGROUP_H
#define TABLES_EXPRGROUP_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/BasicSL/String.h>
#include <casacore/tables/TaQL/ExprAggrNode.h>
#include <vector>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary>
// Class representing a key in the groupby clause.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tTableGram">
// </reviewed>
// <synopsis>
// The GROUPBY clause consists of one or more keys, each being a scalar
// TaQL expression with an arbitrary data type.
// This class contains the value of a key for a particular table row.
// It is part of a TableExprGroupKeySet object.
// </synopsis>
class TableExprGroupKey
{
public:
// Construct for a given data type.
explicit TableExprGroupKey (TableExprNodeRep::NodeDataType dtype)
: itsDT (dtype)
{}
// Get the data type.
TableExprNodeRep::NodeDataType dataType() const
{ return itsDT; }
// Set the key's value.
// <group>
void set (Bool v)
{ itsBool = v; }
void set (Int64 v)
{ itsInt64 = v; }
void set (Double v)
{ itsDouble = v; }
void set (const String& v)
{ itsString = v; }
// </group>
// Compare this and that key.
// <group>
bool operator== (const TableExprGroupKey&) const;
bool operator< (const TableExprGroupKey&) const;
// </group>
private:
TableExprNodeRep::NodeDataType itsDT;
Bool itsBool = false;
Int64 itsInt64 = 0;
Double itsDouble = 0.0;
String itsString;
};
// <summary>
// Class representing all keys in the groupby clause.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tTableGram">
// </reviewed>
// <synopsis>
// The GROUPBY clause consists of one or more keys, each being a scalar
// TaQL expression with an arbitrary data type.
// This class contains a set of TableExprGroupKey objects, each containing
// the value of a key for a particular table row.
// <br>It contains comparison functions to make it possible to use them
// in a std::map object to map the groupby keyset to a group.
// </synopsis>
class TableExprGroupKeySet
{
public:
// Form the object from the given groupby nodes.
TableExprGroupKeySet (const vector<TableExprNode>& nodes);
// Add a key to end the set.
void addKey (TableExprNodeRep::NodeDataType dtype)
{ itsKeys.push_back (TableExprGroupKey(dtype)); }
// Fill the keys with the values from the nodes for this rowid.
void fill (const vector<TableExprNode>& nodes, const TableExprId& id);
// Compare all keys in the set.
// The keyset is compared in order of key, thus the first key defines
// the major ordering.
bool operator== (const TableExprGroupKeySet&) const;
bool operator< (const TableExprGroupKeySet&) const;
private:
vector<TableExprGroupKey> itsKeys;
};
// <summary>
// Class holding the results of groupby and aggregation
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tTableGram">
// </reviewed>
// <synopsis>
// The SELECT (and HAVING) clause can contain aggregate functions
// of which the results can be grouped using the GROUPBY clause.
// This class holds the results of the (immediate) aggregate functions
// and, if needed, the TableExprId ids of all rows belonging to each group.
// These ids are used to evaluate the lazy aggregate functions.
// <br>An object of this class is part of the TableExprIdAggr object
// used to get the aggregated values of each group.
// </synopsis>
class TableExprGroupResult
{
public:
// Create from the possible set of immediate aggregate functions.
// No immediate functions were used, thus no TableExprIds needed.
explicit TableExprGroupResult
(const vector<std::shared_ptr<TableExprGroupFuncSet>>& funcSets);
// Create from the possible set of immediate aggregate functions
// and the set of TableExprIds per group for lazy aggregate functions.
TableExprGroupResult
(const vector<std::shared_ptr<TableExprGroupFuncSet>>& funcSets,
const vector<std::shared_ptr<vector<TableExprId>>>& ids);
// Get the nr of groups.
uInt ngroup() const
{ return itsFuncSets.size(); }
// Get the set of functions (and their results) for the given group.
TableExprGroupFuncSet& funcSet (uInt group) const
{ return *itsFuncSets[group]; }
// Get the set of TableExprIds for the given group.
const vector<TableExprId>& ids (uInt group) const
{ return *itsIds[group]; }
private:
vector<std::shared_ptr<TableExprGroupFuncSet>> itsFuncSets;
vector<std::shared_ptr<vector<TableExprId>>> itsIds;
};
// <summary>
// Abstract base class for classes calculating an aggregated group result.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// The GROUPBY clause divides a table into groups for which aggregated
// results can be calculated like the mean or minimum. These results are
// calculated in classes derived from this abstract base class.
// <br>There is one such function object per aggregation per group. All
// aggregation objects of a group are combined in a std::vector.
// This vector is mapped to a TableExprGroupKeySet object to keep track
// of all groups and aggregations.
// <br> There are two types of aggregation function classes.
// <ul>
// <li> Immediate classes implement the 'apply' function to immediately
// apply the operand's value in the aggregation.
// Such classes do not keep the operand's values.
// <li> Lazy classes do not need the 'apply' function. Instead they
// read all values of the group in the 'getXXX' function and do the
// aggregation. Such classes are meant for aggregation functions
// like 'median' that need to keep all values. When applying it
// immediately, all groups need to keep their values which might need
// too much memory. Lazy classes need the values of only one group
// at a time, but have the disadvantage that reading the values from
// the table might be done in a non-sequential order.
// </ul>
// Most derived classes are immediate classes.
// </synopsis>
class TableExprGroupFuncBase
{
public:
// Construct from the TaQL aggregation node. It keeps the operand
// of the aggregation node.
explicit TableExprGroupFuncBase (TableExprNodeRep* node);
virtual ~TableExprGroupFuncBase();
// Copying is not needed, thus not allowed.
TableExprGroupFuncBase (const TableExprGroupFuncBase&) = delete;
TableExprGroupFuncBase& operator= (const TableExprGroupFuncBase&) = delete;
// Does the aggregate function use lazy semantics?
// The default implementation returns False.
virtual Bool isLazy() const;
// Get the function's sequence nr.
uInt seqnr() const
{ return itsSeqnr; }
// Set the function's sequence nr.
void setSeqnr (uInt seqnr)
{ itsSeqnr = seqnr; }
// Get the operand's value for the given row and apply it to the aggregation.
// This function should not be called for lazy classes.
virtual void apply (const TableExprId& id) = 0;
// If needed, finish the aggregation.
// By default nothing is done.
virtual void finish();
// Get the assembled TableExprIds of a group. It is specifically meant
// for TableExprGroupExprId used for lazy aggregation.
virtual std::shared_ptr<vector<TableExprId>> getIds() const;
// Get the aggregated value.
// Immediate classes can return the already calculated value, while
// lazy classes will get the values of all rows given by the TableExprIds
// and do the aggregation.
// <group>
virtual Bool getBool (const vector<TableExprId>& = vector<TableExprId>());
virtual Int64 getInt (const vector<TableExprId>& = vector<TableExprId>());
virtual Double getDouble (const vector<TableExprId>& = vector<TableExprId>());
virtual DComplex getDComplex (const vector<TableExprId>& = vector<TableExprId>());
virtual MVTime getDate (const vector<TableExprId>& = vector<TableExprId>());
virtual String getString (const vector<TableExprId>& = vector<TableExprId>());
virtual MArray<Bool> getArrayBool (const vector<TableExprId>& = vector<TableExprId>());
virtual MArray<Int64> getArrayInt (const vector<TableExprId>& = vector<TableExprId>());
virtual MArray<Double> getArrayDouble (const vector<TableExprId>& = vector<TableExprId>());
virtual MArray<DComplex> getArrayDComplex (const vector<TableExprId>& = vector<TableExprId>());
virtual MArray<MVTime> getArrayDate (const vector<TableExprId>& = vector<TableExprId>());
virtual MArray<String> getArrayString (const vector<TableExprId>& = vector<TableExprId>());
// <group>
protected:
//# Data member
TableExprNodeRep* itsNode; // refers the node (not owned)
TableExprNodeRep* itsOperand; // refers the operand (not owned)
uInt itsSeqnr;
};
// <summary>
// Class derived from TableExprGroupFuncBase representing a no function
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class represents a null aggregate function which is meant for
// possible aggregate functionality in UDFs.
// </synopsis>
class TableExprGroupNull: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupNull (TableExprNodeRep* node);
virtual ~TableExprGroupNull();
virtual Bool isLazy() const;
virtual void apply (const TableExprId& id);
};
// <summary>
// Class derived from TableExprGroupFuncBase for the first value in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class keeps the TableExprId of the first value in a group.
// The 'getXXX' functions get the value for that TableExprId.
// </synopsis>
class TableExprGroupFirst: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFirst (TableExprNodeRep* node);
virtual ~TableExprGroupFirst();
virtual void apply (const TableExprId& id);
virtual Bool getBool (const vector<TableExprId>&);
virtual Int64 getInt (const vector<TableExprId>&);
virtual Double getDouble (const vector<TableExprId>&);
virtual DComplex getDComplex (const vector<TableExprId>&);
virtual MVTime getDate (const vector<TableExprId>&);
virtual String getString (const vector<TableExprId>&);
virtual MArray<Bool> getArrayBool (const vector<TableExprId>&);
virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
virtual MArray<Double> getArrayDouble (const vector<TableExprId>&);
virtual MArray<DComplex> getArrayDComplex (const vector<TableExprId>&);
virtual MArray<MVTime> getArrayDate (const vector<TableExprId>&);
virtual MArray<String> getArrayString (const vector<TableExprId>&);
protected:
TableExprId itsId;
};
// <summary>
// Class derived from TableExprGroupFuncBase for the first value in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class keeps the TableExprId of the last value in a group.
// The 'getXXX' functions get the value for that TableExprId.
// <br>For ease of use this class is derived from TableExprGroupFirst.
// </synopsis>
class TableExprGroupLast: public TableExprGroupFirst
{
public:
explicit TableExprGroupLast (TableExprNodeRep* node);
virtual ~TableExprGroupLast();
virtual void apply (const TableExprId& id);
};
// <summary>
// Class derived from TableExprGroupFuncBase collecting the ids in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class keeps all TableExprIds in a group.
// It is meant for lazy aggregation classes which use the collected
// TableExprIds in their 'getXXX' functions.
// </synopsis>
class TableExprGroupExprId: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupExprId (TableExprNodeRep* node);
virtual ~TableExprGroupExprId();
virtual Bool isLazy() const;
virtual void apply (const TableExprId& id);
virtual std::shared_ptr<vector<TableExprId>> getIds() const;
private:
std::shared_ptr<vector<TableExprId>> itsIds;
};
// <summary>
// Class collecting the rowids of entries in a group.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class collects the row numbers of the rows in a group.
// </synopsis>
class TableExprGroupRowid: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupRowid (TableExprNodeRep* node);
virtual ~TableExprGroupRowid();
virtual Bool isLazy() const;
virtual void apply (const TableExprId& id);
virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
};
// <summary>
// Class collecting the arrays in a group.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class collects the non-empty arrays in a group into an array with
// one more axis. All arrays (if not empty) must have the same shape.
// </synopsis>
class TableExprGroupAggr: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupAggr (TableExprNodeRep* node);
virtual ~TableExprGroupAggr();
virtual Bool isLazy() const;
virtual void apply (const TableExprId& id);
virtual MArray<Bool> getArrayBool (const vector<TableExprId>&);
virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
virtual MArray<Double> getArrayDouble (const vector<TableExprId>&);
virtual MArray<DComplex> getArrayDComplex (const vector<TableExprId>&);
virtual MArray<MVTime> getArrayDate (const vector<TableExprId>&);
virtual MArray<String> getArrayString (const vector<TableExprId>&);
protected:
template<typename T>
MArray<T> getArray (const vector<TableExprId>& ids)
{
// Return scalar values as a Vector.
if (itsOperand->valueType() == TableExprNodeRep::VTScalar) {
Vector<T> result(ids.size());
for (size_t i=0; i<ids.size(); ++i) {
itsOperand->get (ids[i], result[i]);
}
return MArray<T>(result);
}
// Array values are returned as an array with one more axis.
// Use the first non-null value to determine the shape and if masked.
MArray<T> arr;
size_t id;
Bool hasMask = False;
IPosition shp;
for (id=0; id<ids.size(); ++id) {
itsOperand->get (ids[id], arr);
if (! arr.isNull()) {
hasMask = arr.hasMask();
shp = arr.shape();
shp.append (IPosition (1, ids.size()));
break;
}
}
size_t ndef = 0;
if (id == ids.size()) {
// All arrays are null.
return MArray<T>();
}
Array<T> result(shp);
ArrayIterator<T> iter (result, arr.ndim());
Array<Bool> mask;
std::shared_ptr<ArrayIterator<Bool>> miter;
if (hasMask) {
mask.resize (shp);
miter.reset (new ArrayIterator<Bool> (mask, arr.ndim()));
}
for (; id<ids.size(); ++id) {
MArray<T> values;
itsOperand->get (ids[id], values);
if (! values.isNull()) {
ndef++;
iter.array() = values.array();
iter.next();
if (hasMask) {
miter->array() = values.mask();
miter->next();
}
}
}
if (ndef < ids.size()) {
shp[shp.size() - 1] = ndef;
result.resize (shp, True);
if (hasMask) {
mask.resize (shp, True);
}
}
return MArray<T>(result, mask);
}
};
// <summary>
// Abstract base class for aggregate functions giving a bool scalar.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a bool scalar.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncBool: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncBool (TableExprNodeRep* node)
: TableExprGroupFuncBase (node)
{}
TableExprGroupFuncBool (TableExprNodeRep* node, Bool initValue)
: TableExprGroupFuncBase (node),
itsValue (initValue)
{}
virtual ~TableExprGroupFuncBool();
virtual Bool getBool (const vector<TableExprId>&);
protected:
Bool itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving an integer scalar.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in an integer scalar.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncInt: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncInt (TableExprNodeRep* node, Int64 initValue=0)
: TableExprGroupFuncBase (node),
itsValue (initValue)
{}
virtual ~TableExprGroupFuncInt();
virtual Int64 getInt (const vector<TableExprId>&);
virtual Double getDouble (const vector<TableExprId>&);
protected:
Int64 itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a double scalar.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a double scalar.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncDouble: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncDouble (TableExprNodeRep* node,
Double initValue = 0)
: TableExprGroupFuncBase (node),
itsValue (initValue)
{}
virtual ~TableExprGroupFuncDouble();
virtual Double getDouble (const vector<TableExprId>&);
protected:
Double itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a dcomplex scalar.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a dcomplex scalar.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncDComplex: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncDComplex (TableExprNodeRep* node,
const DComplex& initValue = DComplex())
: TableExprGroupFuncBase (node),
itsValue (initValue)
{}
virtual ~TableExprGroupFuncDComplex();
virtual DComplex getDComplex (const vector<TableExprId>&);
protected:
DComplex itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a date/time scalar.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a date/time scalar.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncDate: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncDate (TableExprNodeRep* node,
const MVTime& initValue = MVTime())
: TableExprGroupFuncBase (node),
itsValue (initValue)
{}
virtual ~TableExprGroupFuncDate();
virtual MVTime getDate (const vector<TableExprId>&);
protected:
MVTime itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a string scalar.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a string scalar.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncString: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncString (TableExprNodeRep* node,
const String& initValue = String())
: TableExprGroupFuncBase (node),
itsValue (initValue)
{}
virtual ~TableExprGroupFuncString();
virtual String getString (const vector<TableExprId>&);
protected:
String itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a bool array.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a bool array.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncArrayBool: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncArrayBool (TableExprNodeRep* node)
: TableExprGroupFuncBase (node)
{}
virtual ~TableExprGroupFuncArrayBool();
virtual MArray<Bool> getArrayBool (const vector<TableExprId>&);
protected:
// If not empty, check if the shape matches that of <src>itsValue</src>.
// If <src>itsValue</src> is still empty, it is sized.
Bool checkShape (const MArrayBase& arr, const String& func);
MArray<Bool> itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving an integer array.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in an integer array.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncArrayInt: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncArrayInt (TableExprNodeRep* node)
: TableExprGroupFuncBase (node)
{}
virtual ~TableExprGroupFuncArrayInt();
virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
protected:
// If not empty, check if the shape matches that of <src>itsValue</src>.
// If <src>itsValue</src> is still empty, it is sized.
Bool checkShape (const MArrayBase& arr, const String& func);
MArray<Int64> itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a double array.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a double array.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncArrayDouble: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncArrayDouble (TableExprNodeRep* node)
: TableExprGroupFuncBase (node)
{}
virtual ~TableExprGroupFuncArrayDouble();
virtual MArray<Double> getArrayDouble (const vector<TableExprId>&);
protected:
// If not empty, check if the shape matches that of <src>itsValue</src>.
// If <src>itsValue</src> is still empty, it is sized.
Bool checkShape (const MArrayBase& arr, const String& func);
MArray<Double> itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a dcomplex array.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a dcomplex array.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncArrayDComplex: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncArrayDComplex (TableExprNodeRep* node)
: TableExprGroupFuncBase (node)
{}
virtual ~TableExprGroupFuncArrayDComplex();
virtual MArray<DComplex> getArrayDComplex (const vector<TableExprId>&);
protected:
// If not empty, check if the shape matches that of <src>itsValue</src>.
// If <src>itsValue</src> is still empty, it is sized.
Bool checkShape (const MArrayBase& arr, const String& func);
MArray<DComplex> itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a date/time array.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a date/time array.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncArrayDate: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncArrayDate (TableExprNodeRep* node)
: TableExprGroupFuncBase (node)
{}
virtual ~TableExprGroupFuncArrayDate();
virtual MArray<MVTime> getArrayDate (const vector<TableExprId>&);
protected:
// If not empty, check if the shape matches that of <src>itsValue</src>.
// If <src>itsValue</src> is still empty, it is sized.
Bool checkShape (const MArrayBase& arr, const String& func);
MArray<MVTime> itsValue;
};
// <summary>
// Abstract base class for aggregate functions giving a string array.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class is derived from TableExprGroupFuncBase and acts as the
// abstract base class for aggregate functions resulting in a string array.
// <br>Derived classes can use <src>itsValue</src> to contain the
// aggregated value. It that case they do not need to implement the
// <src>get</src> function.
// </synopsis>
class TableExprGroupFuncArrayString: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupFuncArrayString (TableExprNodeRep* node)
: TableExprGroupFuncBase (node)
{}
virtual ~TableExprGroupFuncArrayString();
virtual MArray<String> getArrayString (const vector<TableExprId>&);
protected:
// If not empty, check if the shape matches that of <src>itsValue</src>.
// If <src>itsValue</src> is still empty, it is sized.
Bool checkShape (const MArrayBase& arr, const String& func);
MArray<String> itsValue;
};
// <summary>
// Class containing the results of aggregated values in a group.
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// This class contains the set of aggregate function objects containing
// all aggregate results of a particular GROUPBY group.
// It also contains the TableExprId of the last row in the group.
// It is used for possible non-aggregate expressions.
// </synopsis>
class TableExprGroupFuncSet
{
public:
TableExprGroupFuncSet()
: itsId (0)
{}
// Let the aggregate node objects construct the function set.
TableExprGroupFuncSet (const vector<TableExprNodeRep*>& aggrNodes);
// Copying is not needed, thus not allowed.
TableExprGroupFuncSet (const TableExprGroupFuncSet&) = delete;
TableExprGroupFuncSet& operator= (const TableExprGroupFuncSet&) = delete;
// Add a function object.
void add (const std::shared_ptr<TableExprGroupFuncBase>& func);
// Apply the functions to the given row.
void apply (const TableExprId& id);
// Get the vector of functions.
const vector<std::shared_ptr<TableExprGroupFuncBase>>& getFuncs() const
{ return itsFuncs; }
// Get the TableExprId.
const TableExprId& getId() const
{ return itsId; }
private:
//# Data members.
vector<std::shared_ptr<TableExprGroupFuncBase>> itsFuncs;
TableExprId itsId; //# row containing the non-aggregate variables
};
} //# NAMESPACE CASACORE - END
#endif
casacore::ArrayIterator
Definition ArrayIter.h:70
casacore::ArrayIterator::array
Array< T > & array()
Return the cursor.
Definition ArrayIter.h:113
casacore::ArrayIterator::next
virtual void next() override
Move the cursor to the next position.
casacore::Array
Definition Array.h:155
casacore::Array::resize
void resize()
Make this array a different shape.
casacore::IPosition
Definition IPosition.h:117
casacore::IPosition::size
size_t size() const
Definition IPosition.h:570
casacore::IPosition::append
void append(const IPosition &other)
Append this IPosition with another one (causing a resize).
casacore::MArrayBase
Definition MArrayBase.h:83
casacore::MArrayBase::isNull
Bool isNull() const
Is the array null?
Definition MArrayBase.h:109
casacore::MArrayBase::ndim
uInt ndim() const
Get the dimensionality.
Definition MArrayBase.h:141
casacore::MArrayBase::mask
const Array< Bool > & mask() const
Get the mask.
Definition MArrayBase.h:124
casacore::MArrayBase::hasMask
Bool hasMask() const
Is there a mask?
Definition MArrayBase.h:117
casacore::MArrayBase::shape
const IPosition & shape() const
Get the shape.
Definition MArrayBase.h:145
casacore::MArray
Definition MArray.h:68
casacore::MArray::array
const Array< T > & array() const
Get access to the array.
Definition MArray.h:151
casacore::MVTime
Definition MVTime.h:268
casacore::String
String: the storage and methods of handling collections of characters.
Definition String.h:223
casacore::TableExprGroupAggr::getArrayString
virtual MArray< String > getArrayString(const vector< TableExprId > &)
casacore::TableExprGroupAggr::isLazy
virtual Bool isLazy() const
Does the aggregate function use lazy semantics?
casacore::TableExprGroupAggr::getArrayDComplex
virtual MArray< DComplex > getArrayDComplex(const vector< TableExprId > &)
casacore::TableExprGroupAggr::getArrayDate
virtual MArray< MVTime > getArrayDate(const vector< TableExprId > &)
casacore::TableExprGroupAggr::getArrayDouble
virtual MArray< Double > getArrayDouble(const vector< TableExprId > &)
casacore::TableExprGroupAggr::~TableExprGroupAggr
virtual ~TableExprGroupAggr()
casacore::TableExprGroupAggr::getArrayInt
virtual MArray< Int64 > getArrayInt(const vector< TableExprId > &)
casacore::TableExprGroupAggr::getArrayBool
virtual MArray< Bool > getArrayBool(const vector< TableExprId > &)
casacore::TableExprGroupAggr::getArray
MArray< T > getArray(const vector< TableExprId > &ids)
Definition ExprGroup.h:390
casacore::TableExprGroupAggr::TableExprGroupAggr
TableExprGroupAggr(TableExprNodeRep *node)
casacore::TableExprGroupAggr::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupExprId::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupExprId::isLazy
virtual Bool isLazy() const
Does the aggregate function use lazy semantics?
casacore::TableExprGroupExprId::itsIds
std::shared_ptr< vector< TableExprId > > itsIds
Definition ExprGroup.h:343
casacore::TableExprGroupExprId::getIds
virtual std::shared_ptr< vector< TableExprId > > getIds() const
Get the assembled TableExprIds of a group.
casacore::TableExprGroupExprId::TableExprGroupExprId
TableExprGroupExprId(TableExprNodeRep *node)
casacore::TableExprGroupExprId::~TableExprGroupExprId
virtual ~TableExprGroupExprId()
casacore::TableExprGroupFirst::getBool
virtual Bool getBool(const vector< TableExprId > &)
Get the aggregated value.
casacore::TableExprGroupFirst::~TableExprGroupFirst
virtual ~TableExprGroupFirst()
casacore::TableExprGroupFirst::itsId
TableExprId itsId
Definition ExprGroup.h:301
casacore::TableExprGroupFirst::getArrayString
virtual MArray< String > getArrayString(const vector< TableExprId > &)
casacore::TableExprGroupFirst::getDate
virtual MVTime getDate(const vector< TableExprId > &)
casacore::TableExprGroupFirst::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupFirst::getArrayDate
virtual MArray< MVTime > getArrayDate(const vector< TableExprId > &)
casacore::TableExprGroupFirst::getDComplex
virtual DComplex getDComplex(const vector< TableExprId > &)
casacore::TableExprGroupFirst::getInt
virtual Int64 getInt(const vector< TableExprId > &)
casacore::TableExprGroupFirst::getString
virtual String getString(const vector< TableExprId > &)
casacore::TableExprGroupFirst::getArrayDouble
virtual MArray< Double > getArrayDouble(const vector< TableExprId > &)
casacore::TableExprGroupFirst::TableExprGroupFirst
TableExprGroupFirst(TableExprNodeRep *node)
casacore::TableExprGroupFirst::getArrayDComplex
virtual MArray< DComplex > getArrayDComplex(const vector< TableExprId > &)
casacore::TableExprGroupFirst::getDouble
virtual Double getDouble(const vector< TableExprId > &)
casacore::TableExprGroupFirst::getArrayInt
virtual MArray< Int64 > getArrayInt(const vector< TableExprId > &)
casacore::TableExprGroupFirst::getArrayBool
virtual MArray< Bool > getArrayBool(const vector< TableExprId > &)
casacore::TableExprGroupFuncArrayBool::itsValue
MArray< Bool > itsValue
Definition ExprGroup.h:642
casacore::TableExprGroupFuncArrayBool::getArrayBool
virtual MArray< Bool > getArrayBool(const vector< TableExprId > &)
casacore::TableExprGroupFuncArrayBool::~TableExprGroupFuncArrayBool
virtual ~TableExprGroupFuncArrayBool()
casacore::TableExprGroupFuncArrayBool::checkShape
Bool checkShape(const MArrayBase &arr, const String &func)
If not empty, check if the shape matches that of itsValue.
casacore::TableExprGroupFuncArrayBool::TableExprGroupFuncArrayBool
TableExprGroupFuncArrayBool(TableExprNodeRep *node)
Definition ExprGroup.h:633
casacore::TableExprGroupFuncArrayDComplex::itsValue
MArray< DComplex > itsValue
Definition ExprGroup.h:726
casacore::TableExprGroupFuncArrayDComplex::TableExprGroupFuncArrayDComplex
TableExprGroupFuncArrayDComplex(TableExprNodeRep *node)
Definition ExprGroup.h:717
casacore::TableExprGroupFuncArrayDComplex::getArrayDComplex
virtual MArray< DComplex > getArrayDComplex(const vector< TableExprId > &)
casacore::TableExprGroupFuncArrayDComplex::~TableExprGroupFuncArrayDComplex
virtual ~TableExprGroupFuncArrayDComplex()
casacore::TableExprGroupFuncArrayDComplex::checkShape
Bool checkShape(const MArrayBase &arr, const String &func)
If not empty, check if the shape matches that of itsValue.
casacore::TableExprGroupFuncArrayDate::getArrayDate
virtual MArray< MVTime > getArrayDate(const vector< TableExprId > &)
casacore::TableExprGroupFuncArrayDate::checkShape
Bool checkShape(const MArrayBase &arr, const String &func)
If not empty, check if the shape matches that of itsValue.
casacore::TableExprGroupFuncArrayDate::TableExprGroupFuncArrayDate
TableExprGroupFuncArrayDate(TableExprNodeRep *node)
Definition ExprGroup.h:745
casacore::TableExprGroupFuncArrayDate::~TableExprGroupFuncArrayDate
virtual ~TableExprGroupFuncArrayDate()
casacore::TableExprGroupFuncArrayDate::itsValue
MArray< MVTime > itsValue
Definition ExprGroup.h:754
casacore::TableExprGroupFuncArrayDouble::itsValue
MArray< Double > itsValue
Definition ExprGroup.h:698
casacore::TableExprGroupFuncArrayDouble::getArrayDouble
virtual MArray< Double > getArrayDouble(const vector< TableExprId > &)
casacore::TableExprGroupFuncArrayDouble::TableExprGroupFuncArrayDouble
TableExprGroupFuncArrayDouble(TableExprNodeRep *node)
Definition ExprGroup.h:689
casacore::TableExprGroupFuncArrayDouble::checkShape
Bool checkShape(const MArrayBase &arr, const String &func)
If not empty, check if the shape matches that of itsValue.
casacore::TableExprGroupFuncArrayDouble::~TableExprGroupFuncArrayDouble
virtual ~TableExprGroupFuncArrayDouble()
casacore::TableExprGroupFuncArrayInt::getArrayInt
virtual MArray< Int64 > getArrayInt(const vector< TableExprId > &)
casacore::TableExprGroupFuncArrayInt::checkShape
Bool checkShape(const MArrayBase &arr, const String &func)
If not empty, check if the shape matches that of itsValue.
casacore::TableExprGroupFuncArrayInt::itsValue
MArray< Int64 > itsValue
Definition ExprGroup.h:670
casacore::TableExprGroupFuncArrayInt::~TableExprGroupFuncArrayInt
virtual ~TableExprGroupFuncArrayInt()
casacore::TableExprGroupFuncArrayInt::TableExprGroupFuncArrayInt
TableExprGroupFuncArrayInt(TableExprNodeRep *node)
Definition ExprGroup.h:661
casacore::TableExprGroupFuncArrayString::getArrayString
virtual MArray< String > getArrayString(const vector< TableExprId > &)
casacore::TableExprGroupFuncArrayString::checkShape
Bool checkShape(const MArrayBase &arr, const String &func)
If not empty, check if the shape matches that of itsValue.
casacore::TableExprGroupFuncArrayString::itsValue
MArray< String > itsValue
Definition ExprGroup.h:782
casacore::TableExprGroupFuncArrayString::TableExprGroupFuncArrayString
TableExprGroupFuncArrayString(TableExprNodeRep *node)
Definition ExprGroup.h:773
casacore::TableExprGroupFuncArrayString::~TableExprGroupFuncArrayString
virtual ~TableExprGroupFuncArrayString()
casacore::TableExprGroupFuncBase::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupFuncBase::TableExprGroupFuncBase
TableExprGroupFuncBase(TableExprNodeRep *node)
Construct from the TaQL aggregation node.
casacore::TableExprGroupFuncBase::apply
virtual void apply(const TableExprId &id)=0
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupFuncBase::getIds
virtual std::shared_ptr< vector< TableExprId > > getIds() const
Get the assembled TableExprIds of a group.
casacore::TableExprGroupFuncBase::itsSeqnr
uInt itsSeqnr
Definition ExprGroup.h:249
casacore::TableExprGroupFuncBase::getArrayBool
virtual MArray< Bool > getArrayBool(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::operator=
TableExprGroupFuncBase & operator=(const TableExprGroupFuncBase &)=delete
casacore::TableExprGroupFuncBase::getInt
virtual Int64 getInt(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::getDate
virtual MVTime getDate(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::getArrayInt
virtual MArray< Int64 > getArrayInt(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::getArrayDate
virtual MArray< MVTime > getArrayDate(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::seqnr
uInt seqnr() const
Get the function's sequence nr.
Definition ExprGroup.h:213
casacore::TableExprGroupFuncBase::getArrayString
virtual MArray< String > getArrayString(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::getDouble
virtual Double getDouble(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::isLazy
virtual Bool isLazy() const
Does the aggregate function use lazy semantics?
casacore::TableExprGroupFuncBase::TableExprGroupFuncBase
TableExprGroupFuncBase(const TableExprGroupFuncBase &)=delete
Copying is not needed, thus not allowed.
casacore::TableExprGroupFuncBase::getArrayDouble
virtual MArray< Double > getArrayDouble(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::itsNode
TableExprNodeRep * itsNode
Definition ExprGroup.h:247
casacore::TableExprGroupFuncBase::getDComplex
virtual DComplex getDComplex(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::setSeqnr
void setSeqnr(uInt seqnr)
Set the function's sequence nr.
Definition ExprGroup.h:216
casacore::TableExprGroupFuncBase::itsOperand
TableExprNodeRep * itsOperand
Definition ExprGroup.h:248
casacore::TableExprGroupFuncBase::getBool
virtual Bool getBool(const vector< TableExprId > &=vector< TableExprId >())
Get the aggregated value.
casacore::TableExprGroupFuncBase::getArrayDComplex
virtual MArray< DComplex > getArrayDComplex(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBase::~TableExprGroupFuncBase
virtual ~TableExprGroupFuncBase()
casacore::TableExprGroupFuncBase::getString
virtual String getString(const vector< TableExprId > &=vector< TableExprId >())
casacore::TableExprGroupFuncBool::getBool
virtual Bool getBool(const vector< TableExprId > &)
Get the aggregated value.
casacore::TableExprGroupFuncBool::TableExprGroupFuncBool
TableExprGroupFuncBool(TableExprNodeRep *node, Bool initValue)
Definition ExprGroup.h:472
casacore::TableExprGroupFuncBool::~TableExprGroupFuncBool
virtual ~TableExprGroupFuncBool()
casacore::TableExprGroupFuncBool::TableExprGroupFuncBool
TableExprGroupFuncBool(TableExprNodeRep *node)
Definition ExprGroup.h:469
casacore::TableExprGroupFuncBool::itsValue
Bool itsValue
Definition ExprGroup.h:479
casacore::TableExprGroupFuncDComplex::TableExprGroupFuncDComplex
TableExprGroupFuncDComplex(TableExprNodeRep *node, const DComplex &initValue=DComplex())
Definition ExprGroup.h:552
casacore::TableExprGroupFuncDComplex::itsValue
DComplex itsValue
Definition ExprGroup.h:560
casacore::TableExprGroupFuncDComplex::getDComplex
virtual DComplex getDComplex(const vector< TableExprId > &)
casacore::TableExprGroupFuncDComplex::~TableExprGroupFuncDComplex
virtual ~TableExprGroupFuncDComplex()
casacore::TableExprGroupFuncDate::getDate
virtual MVTime getDate(const vector< TableExprId > &)
casacore::TableExprGroupFuncDate::itsValue
MVTime itsValue
Definition ExprGroup.h:587
casacore::TableExprGroupFuncDate::TableExprGroupFuncDate
TableExprGroupFuncDate(TableExprNodeRep *node, const MVTime &initValue=MVTime())
Definition ExprGroup.h:579
casacore::TableExprGroupFuncDate::~TableExprGroupFuncDate
virtual ~TableExprGroupFuncDate()
casacore::TableExprGroupFuncDouble::~TableExprGroupFuncDouble
virtual ~TableExprGroupFuncDouble()
casacore::TableExprGroupFuncDouble::getDouble
virtual Double getDouble(const vector< TableExprId > &)
casacore::TableExprGroupFuncDouble::TableExprGroupFuncDouble
TableExprGroupFuncDouble(TableExprNodeRep *node, Double initValue=0)
Definition ExprGroup.h:525
casacore::TableExprGroupFuncDouble::itsValue
Double itsValue
Definition ExprGroup.h:533
casacore::TableExprGroupFuncInt::~TableExprGroupFuncInt
virtual ~TableExprGroupFuncInt()
casacore::TableExprGroupFuncInt::itsValue
Int64 itsValue
Definition ExprGroup.h:506
casacore::TableExprGroupFuncInt::getDouble
virtual Double getDouble(const vector< TableExprId > &)
casacore::TableExprGroupFuncInt::getInt
virtual Int64 getInt(const vector< TableExprId > &)
casacore::TableExprGroupFuncInt::TableExprGroupFuncInt
TableExprGroupFuncInt(TableExprNodeRep *node, Int64 initValue=0)
Definition ExprGroup.h:498
casacore::TableExprGroupFuncSet
Class containing the results of aggregated values in a group.
Definition ExprGroup.h:799
casacore::TableExprGroupFuncSet::getFuncs
const vector< std::shared_ptr< TableExprGroupFuncBase > > & getFuncs() const
Get the vector of functions.
Definition ExprGroup.h:819
casacore::TableExprGroupFuncSet::getId
const TableExprId & getId() const
Get the TableExprId.
Definition ExprGroup.h:823
casacore::TableExprGroupFuncSet::TableExprGroupFuncSet
TableExprGroupFuncSet(const vector< TableExprNodeRep * > &aggrNodes)
Let the aggregate node objects construct the function set.
casacore::TableExprGroupFuncSet::add
void add(const std::shared_ptr< TableExprGroupFuncBase > &func)
Add a function object.
casacore::TableExprGroupFuncSet::itsId
TableExprId itsId
Definition ExprGroup.h:829
casacore::TableExprGroupFuncSet::apply
void apply(const TableExprId &id)
Apply the functions to the given row.
casacore::TableExprGroupFuncSet::operator=
TableExprGroupFuncSet & operator=(const TableExprGroupFuncSet &)=delete
casacore::TableExprGroupFuncSet::TableExprGroupFuncSet
TableExprGroupFuncSet(const TableExprGroupFuncSet &)=delete
Copying is not needed, thus not allowed.
casacore::TableExprGroupFuncSet::itsFuncs
vector< std::shared_ptr< TableExprGroupFuncBase > > itsFuncs
Definition ExprGroup.h:828
casacore::TableExprGroupFuncSet::TableExprGroupFuncSet
TableExprGroupFuncSet()
Definition ExprGroup.h:801
casacore::TableExprGroupFuncString::itsValue
String itsValue
Definition ExprGroup.h:614
casacore::TableExprGroupFuncString::TableExprGroupFuncString
TableExprGroupFuncString(TableExprNodeRep *node, const String &initValue=String())
Definition ExprGroup.h:606
casacore::TableExprGroupFuncString::~TableExprGroupFuncString
virtual ~TableExprGroupFuncString()
casacore::TableExprGroupFuncString::getString
virtual String getString(const vector< TableExprId > &)
casacore::TableExprGroupKeySet::TableExprGroupKeySet
TableExprGroupKeySet(const vector< TableExprNode > &nodes)
Form the object from the given groupby nodes.
casacore::TableExprGroupKeySet::operator<
bool operator<(const TableExprGroupKeySet &) const
casacore::TableExprGroupKeySet::fill
void fill(const vector< TableExprNode > &nodes, const TableExprId &id)
Fill the keys with the values from the nodes for this rowid.
casacore::TableExprGroupKeySet::addKey
void addKey(TableExprNodeRep::NodeDataType dtype)
Add a key to end the set.
Definition ExprGroup.h:110
casacore::TableExprGroupKeySet::operator==
bool operator==(const TableExprGroupKeySet &) const
Compare all keys in the set.
casacore::TableExprGroupKeySet::itsKeys
vector< TableExprGroupKey > itsKeys
Definition ExprGroup.h:123
casacore::TableExprGroupKey
Definition ExprGroup.h:51
casacore::TableExprGroupKey::operator<
bool operator<(const TableExprGroupKey &) const
casacore::TableExprGroupKey::set
void set(const String &v)
Definition ExprGroup.h:70
casacore::TableExprGroupKey::TableExprGroupKey
TableExprGroupKey(TableExprNodeRep::NodeDataType dtype)
Construct for a given data type.
Definition ExprGroup.h:54
casacore::TableExprGroupKey::operator==
bool operator==(const TableExprGroupKey &) const
Compare this and that key.
casacore::TableExprGroupKey::itsDouble
Double itsDouble
Definition ExprGroup.h:84
casacore::TableExprGroupKey::itsDT
TableExprNodeRep::NodeDataType itsDT
Definition ExprGroup.h:81
casacore::TableExprGroupKey::itsInt64
Int64 itsInt64
Definition ExprGroup.h:83
casacore::TableExprGroupKey::set
void set(Double v)
Definition ExprGroup.h:68
casacore::TableExprGroupKey::set
void set(Int64 v)
Definition ExprGroup.h:66
casacore::TableExprGroupKey::itsString
String itsString
Definition ExprGroup.h:85
casacore::TableExprGroupKey::itsBool
Bool itsBool
Definition ExprGroup.h:82
casacore::TableExprGroupKey::dataType
TableExprNodeRep::NodeDataType dataType() const
Get the data type.
Definition ExprGroup.h:59
casacore::TableExprGroupKey::set
void set(Bool v)
Set the key's value.
Definition ExprGroup.h:64
casacore::TableExprGroupLast::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupLast::TableExprGroupLast
TableExprGroupLast(TableExprNodeRep *node)
casacore::TableExprGroupLast::~TableExprGroupLast
virtual ~TableExprGroupLast()
casacore::TableExprGroupNull::TableExprGroupNull
TableExprGroupNull(TableExprNodeRep *node)
casacore::TableExprGroupNull::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupNull::~TableExprGroupNull
virtual ~TableExprGroupNull()
casacore::TableExprGroupNull::isLazy
virtual Bool isLazy() const
Does the aggregate function use lazy semantics?
casacore::TableExprGroupResult::TableExprGroupResult
TableExprGroupResult(const vector< std::shared_ptr< TableExprGroupFuncSet > > &funcSets, const vector< std::shared_ptr< vector< TableExprId > > > &ids)
Create from the possible set of immediate aggregate functions and the set of TableExprIds per group f...
casacore::TableExprGroupResult::itsFuncSets
vector< std::shared_ptr< TableExprGroupFuncSet > > itsFuncSets
Definition ExprGroup.h:164
casacore::TableExprGroupResult::ngroup
uInt ngroup() const
Get the nr of groups.
Definition ExprGroup.h:155
casacore::TableExprGroupResult::itsIds
vector< std::shared_ptr< vector< TableExprId > > > itsIds
Definition ExprGroup.h:165
casacore::TableExprGroupResult::funcSet
TableExprGroupFuncSet & funcSet(uInt group) const
Get the set of functions (and their results) for the given group.
Definition ExprGroup.h:158
casacore::TableExprGroupResult::TableExprGroupResult
TableExprGroupResult(const vector< std::shared_ptr< TableExprGroupFuncSet > > &funcSets)
Create from the possible set of immediate aggregate functions.
casacore::TableExprGroupResult::ids
const vector< TableExprId > & ids(uInt group) const
Get the set of TableExprIds for the given group.
Definition ExprGroup.h:161
casacore::TableExprGroupRowid::isLazy
virtual Bool isLazy() const
Does the aggregate function use lazy semantics?
casacore::TableExprGroupRowid::getArrayInt
virtual MArray< Int64 > getArrayInt(const vector< TableExprId > &)
casacore::TableExprGroupRowid::TableExprGroupRowid
TableExprGroupRowid(TableExprNodeRep *node)
casacore::TableExprGroupRowid::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupRowid::~TableExprGroupRowid
virtual ~TableExprGroupRowid()
casacore::TableExprId
Definition TableExprId.h:95
casacore::TableExprNodeRep
Abstract base class for a node in a table column expression tree.
Definition ExprNodeRep.h:202
casacore::TableExprNodeRep::NodeDataType
NodeDataType
Define the data types of a node.
Definition ExprNodeRep.h:205
casacore::TableExprNodeRep::VTScalar
@ VTScalar
Definition ExprNodeRep.h:221
casacore::Vector
Definition Vector.h:82
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::False
const Bool False
Definition aipstype.h:42
casacore::uInt
unsigned int uInt
Definition aipstype.h:49
casacore::mask
LatticeExprNode mask(const LatticeExprNode &expr)
This function returns the mask of the given expression.
casacore::Int64
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size).
Definition aipsxtype.h:36
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::True
const Bool True
Definition aipstype.h:41
casacore::Double
double Double
Definition aipstype.h:53