ExprLogicNodeArray.h

Go to the documentation of this file.

//# ExprLogicArrayNode.h: Nodes representing logical array operators in table select expression tree
//# Copyright (C) 1997,1999,2000
//# 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_EXPRLOGICNODEARRAY_H
#define TABLES_EXPRLOGICNODEARRAY_H
 
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/TaQL/ExprNodeArray.h>
#include <casacore/casa/Arrays/Array.h>
 
namespace casacore { //# NAMESPACE CASACORE - BEGIN
 
//# Forward Declarations
 
//# This file defines classes derived from TableExprNode representing
//# the data type and operator in a table expression.
//#
//# Data types Bool, Int64, Double, DComplex and String are used.
//# Char, uChar, Short, uShort, Int, and uInt are converted to Int64,
//# Float to Double, and Complex to DComplex.
//# Binary operators ==, >=, >, <, <= and != are recognized.
//# Also &&, ||, and unary ! are recognized.
 
 
 
// <summary>
// Bool Array comparison == in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an == comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayEQBool : public TableExprNodeArray
{
public:
    TableExprNodeArrayEQBool (const TableExprNodeRep&);
    ~TableExprNodeArrayEQBool();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Int Array comparison == in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an == comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayEQInt : public TableExprNodeArray
{
public:
    TableExprNodeArrayEQInt (const TableExprNodeRep&);
    ~TableExprNodeArrayEQInt();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Double Array comparison == in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an == comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayEQDouble : public TableExprNodeArray
{
public:
    TableExprNodeArrayEQDouble (const TableExprNodeRep&);
    ~TableExprNodeArrayEQDouble();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// DComplex Array comparison == in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an == comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayEQDComplex : public TableExprNodeArray
{
public:
    TableExprNodeArrayEQDComplex (const TableExprNodeRep&);
    ~TableExprNodeArrayEQDComplex();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// String Array comparison == in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an == comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayEQString : public TableExprNodeArray
{
public:
    TableExprNodeArrayEQString (const TableExprNodeRep&);
    ~TableExprNodeArrayEQString();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Regex Array comparison == in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an == comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayEQRegex : public TableExprNodeArray
{
public:
    TableExprNodeArrayEQRegex (const TableExprNodeRep&);
    ~TableExprNodeArrayEQRegex();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Date Array comparison == in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an == comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayEQDate : public TableExprNodeArray
{
public:
    TableExprNodeArrayEQDate (const TableExprNodeRep&);
    ~TableExprNodeArrayEQDate();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
 
// <summary>
// Bool Array comparison != in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an != comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayNEBool : public TableExprNodeArray
{
public:
    TableExprNodeArrayNEBool (const TableExprNodeRep&);
    ~TableExprNodeArrayNEBool();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Int Array comparison != in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an != comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayNEInt : public TableExprNodeArray
{
public:
    TableExprNodeArrayNEInt (const TableExprNodeRep&);
    ~TableExprNodeArrayNEInt();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Double Array comparison != in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an != comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayNEDouble : public TableExprNodeArray
{
public:
    TableExprNodeArrayNEDouble (const TableExprNodeRep&);
    ~TableExprNodeArrayNEDouble();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// DComplex Array comparison != in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an != comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayNEDComplex : public TableExprNodeArray
{
public:
    TableExprNodeArrayNEDComplex (const TableExprNodeRep&);
    ~TableExprNodeArrayNEDComplex();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// String Array comparison != in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an != comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayNEString : public TableExprNodeArray
{
public:
    TableExprNodeArrayNEString (const TableExprNodeRep&);
    ~TableExprNodeArrayNEString();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Regex Array comparison != in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an != comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayNERegex : public TableExprNodeArray
{
public:
    TableExprNodeArrayNERegex (const TableExprNodeRep&);
    ~TableExprNodeArrayNERegex();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Date Array comparison != in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an != comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayNEDate : public TableExprNodeArray
{
public:
    TableExprNodeArrayNEDate (const TableExprNodeRep&);
    ~TableExprNodeArrayNEDate();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
 
// <summary>
// Int Array comparison > in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an > comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGTInt : public TableExprNodeArray
{
public:
    TableExprNodeArrayGTInt (const TableExprNodeRep&);
    ~TableExprNodeArrayGTInt();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Double Array comparison > in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an > comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGTDouble : public TableExprNodeArray
{
public:
    TableExprNodeArrayGTDouble (const TableExprNodeRep&);
    ~TableExprNodeArrayGTDouble();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// DComplex Array comparison > in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an > comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGTDComplex : public TableExprNodeArray
{
public:
    TableExprNodeArrayGTDComplex (const TableExprNodeRep&);
    ~TableExprNodeArrayGTDComplex();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// String Array comparison > in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an > comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGTString : public TableExprNodeArray
{
public:
    TableExprNodeArrayGTString (const TableExprNodeRep&);
    ~TableExprNodeArrayGTString();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Date Array comparison > in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an > comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGTDate : public TableExprNodeArray
{
public:
    TableExprNodeArrayGTDate (const TableExprNodeRep&);
    ~TableExprNodeArrayGTDate();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
 
// <summary>
// Int Array comparison >= in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an >= comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGEInt : public TableExprNodeArray
{
public:
    TableExprNodeArrayGEInt (const TableExprNodeRep&);
    ~TableExprNodeArrayGEInt();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Double Array comparison >= in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an >= comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGEDouble : public TableExprNodeArray
{
public:
    TableExprNodeArrayGEDouble (const TableExprNodeRep&);
    ~TableExprNodeArrayGEDouble();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// DComplex Array comparison >= in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an >= comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGEDComplex : public TableExprNodeArray
{
public:
    TableExprNodeArrayGEDComplex (const TableExprNodeRep&);
    ~TableExprNodeArrayGEDComplex();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// String Array comparison >= in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an >= comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGEString : public TableExprNodeArray
{
public:
    TableExprNodeArrayGEString (const TableExprNodeRep&);
    ~TableExprNodeArrayGEString();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// Date Array comparison >= in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an >= comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayGEDate : public TableExprNodeArray
{
public:
    TableExprNodeArrayGEDate (const TableExprNodeRep&);
    ~TableExprNodeArrayGEDate();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
 
// <summary>
// Int Array comparison IN in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an IN comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// The right hand side can be optimized if it contains a constant array which
// can be replaced by an std::unordered_set<Int64> or a Block<Bool>.
// </synopsis> 
 
class TableExprNodeArrayINInt : public TableExprNodeArray
{
public:
    TableExprNodeArrayINInt (const TableExprNodeRep&);
    ~TableExprNodeArrayINInt();
    virtual void optimize() override;
    virtual MArray<Bool> getArrayBool (const TableExprId& id) override;
};
 
 
// <summary>
// Double Array comparison IN in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an IN comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayINDouble : public TableExprNodeArray
{
public:
    TableExprNodeArrayINDouble (const TableExprNodeRep&);
    ~TableExprNodeArrayINDouble();
    virtual void optimize() override;
    MArray<Bool> getArrayBool (const TableExprId& id) override;
};
 
 
// <summary>
// DComplex Array comparison IN in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an IN comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayINDComplex : public TableExprNodeArray
{
public:
    TableExprNodeArrayINDComplex (const TableExprNodeRep&);
    ~TableExprNodeArrayINDComplex();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
// <summary>
// String Array comparison IN in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an IN comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// The right hand side can be optimized if it contains a constant array which
// can be replaced by an std::unordered_set<String>
// </synopsis> 
 
class TableExprNodeArrayINString : public TableExprNodeArray
{
public:
    TableExprNodeArrayINString (const TableExprNodeRep&);
    ~TableExprNodeArrayINString();
    virtual void optimize() override;
    virtual MArray<Bool> getArrayBool (const TableExprId& id) override;
};
 
 
// <summary>
// Date Array comparison IN in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents an IN comparison in a table select expression tree.
// This is defined for all data types.
// Only the Bool get function is defined, because the result of a
// compare is always a Bool.
// </synopsis> 
 
class TableExprNodeArrayINDate : public TableExprNodeArray
{
public:
    TableExprNodeArrayINDate (const TableExprNodeRep&);
    ~TableExprNodeArrayINDate();
    virtual void optimize() override;
    MArray<Bool> getArrayBool (const TableExprId& id) override;
};
 
 
 
// <summary>
// Logical or in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents a logical or in a table select expression tree.
// This is defined for Bool only.
// </synopsis> 
 
class TableExprNodeArrayOR : public TableExprNodeArray
{
public:
    TableExprNodeArrayOR (const TableExprNodeRep&);
    ~TableExprNodeArrayOR();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
 
// <summary>
// Logical and in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNode
// </prerequisite>
 
// <synopsis> 
// This class represents a logical and in a table select expression tree.
// This is defined for Bool only.
// </synopsis> 
 
class TableExprNodeArrayAND: public TableExprNodeArray
{
public:
    TableExprNodeArrayAND (const TableExprNodeRep&);
    ~TableExprNodeArrayAND();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
 
// <summary>
// Logical not in table select expression tree
// </summary>
 
// <use visibility=local>
 
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
 
// <prerequisite>
//# Classes you should understand before using this one.
//   <li> TableExprNodeArray
// </prerequisite>
 
// <synopsis> 
// This class represents a logical not in a table select expression tree.
// This is defined for Bool only.
// </synopsis> 
 
class TableExprNodeArrayNOT: public TableExprNodeArray
{
public:
    TableExprNodeArrayNOT (const TableExprNodeRep&);
    ~TableExprNodeArrayNOT();
    MArray<Bool> getArrayBool (const TableExprId& id);
};
 
 
 
 
} //# NAMESPACE CASACORE - END
 
#endif