Expression.h

Go to the documentation of this file.

#ifndef EXPRESSION_H
#define EXPRESSION_H

#include <NMSTL/util>
#include <NMSTL/ptr>
#include <antlr/SemanticException.hpp>

#include "EString.h"
#include "TupleDescription.h"
#include "Exceptions.h"
#include "Registry.h"
#include "Timestamp.h"

// TRUE and FALSE need to be undefined so they do not conflict with the
// enumeration in ExprParserTokenTypes.hpp; which is generated from the
// expr.g grammar file.  This file is included by expr.g to achieve this.
//
#ifdef  TRUE
#undef  TRUE
#endif

#ifdef  FALSE
#undef  FALSE
#endif

using namespace std;
using namespace NMSTL;
 
BOREALIS_NAMESPACE_BEGIN

AURORA_EXCEPTION_TYPE( ExprException );
AURORA_EXCEPTION_TYPE( EvalException );



class ExprContext
{
  public:
    // Move to the DataType class???
    static const string to_string( DataType t );

    TupleDescription getTupleDescription() const { return _desc; }

    void setTupleDescription(TupleDescription desc) { _desc = desc; }

    void getNamedTupleInfo( string   name,
                  TupleDescription  &desc,
                      unsigned int  &index
                          ) const
    {
        pair<TupleDescription, unsigned int> info = lookup(_named_desc, name);
        desc  = info.first;
        index = info.second;
    }


    void setNamedTupleInfo(string name, TupleDescription desc, unsigned int index) {
        _named_desc[name] = make_pair(desc, index);
    }


    void findFieldName( string   field_name,
                        string  &tuple_name,
                  unsigned int  &tuple_index,
              TupleDescription  &tuple_desc,
                  unsigned int  &field_index
                      ) const
                 throw( ExprException )
    {
        bool found = false;

        for ( NamedDesc::const_iterator i = _named_desc.begin();
              i != _named_desc.end(); ++i)
        {
            int off = i->second.first.indexOfField( field_name );

            if ( off >= 0 )
            {   if ( found )
                {    Throw(ExprException, "multiple fields " + field_name + " in input tuple(s)");
                }

                found = true;
                // whoa... lispy...
                tuple_name = i->first;
                tuple_index = i->second.second;
                tuple_desc = i->second.first;
                field_index = off;
            }
        }

        if ( !found )
        {   Throw(ExprException, "no field " + field_name + " in any input tuple");
        }
    }

  private:
    TupleDescription _desc;

    typedef map<string, pair<TupleDescription, unsigned int> > NamedDesc;
    NamedDesc _named_desc;

    // Eventually - multiple descriptions (LEFT/RIGHT for join, etc.)
};



class EvalContext {
  public:
    EvalContext(unsigned int num_tuples = 1,
                unsigned int pool_size = EStringPool::DEFAULT_INITIAL_SIZE) :
        _tuple(num_tuples), _pool(pool_size)
    {}

    void reset() {
        _pool.reset();
    }

    void setTuple(const void *tuple) { _tuple[0] = tuple; }

    void setTuple(unsigned int index, const void *tuple)
    {
        ASSERT(index < _tuple.size());
        _tuple[index] = tuple;
    }

    const char *getTuple(unsigned int index = 0) const
    {
        ASSERT(index < _tuple.size());
        return static_cast<const char*>(_tuple[index]);
    }

    char *alloc(unsigned int size) const
    {
        return _pool.alloc(size);
    }

    EStringPool& getPool() const
    {
        return _pool;
    }

  private:
    vector<const void*> _tuple;
    mutable EStringPool _pool;

    EvalContext(const EvalContext&);
    EvalContext& operator = (const EvalContext&);

    // Eventually - multiple tuples.
};




template<class T> class EvalAs;

template<> class EvalAs<int32> {};

template<> class EvalAs<int64> {};

template<> class EvalAs<single> {};

template<> class EvalAs<double> {};

template<> class EvalAs<bool> {};

template<> class EvalAs<EString> {};

template<> class EvalAs<string> {};

template<> class EvalAs<Timestamp> {};

class Expression
{
  public:
    //#ifdef ENABLE_SERIALIZATION
    //  Expression() {}
    //#endif

    virtual ~Expression() {}

    template<typename T>
    T eval( const EvalContext  &ctxt ) throw( EvalException )
    {
        return( evalImpl( EvalAs<T>(), ctxt ));
    }

    template<typename T> bool is() const
    {
        return( isImpl( EvalAs<T>() ));
    }

    virtual int32 getStringLength() const { return -1; }

    int32 getLength() const
    {
        if      ( _type == DataType::INT    ) return sizeof( int32 );
        else if ( _type == DataType::LONG   ) return sizeof( int64 );
        else if ( _type == DataType::FLOAT  ) return sizeof( single );
        else if ( _type == DataType::SINGLE ) return sizeof( single );
        else if ( _type == DataType::DOUBLE ) return sizeof( double );
        else if ( _type == DataType::BOOL   ) return sizeof( bool );
        else if ( _type == DataType::TIMESTAMP  ) return sizeof( Timestamp );
        else
            return( getStringLength() );
    }

    void evalInto(char *buf, const EvalContext& ctxt) throw (EvalException)
    {
        ASSERT( getLength() != -1 );

        if      ( _type == DataType::INT    ) *(int32*)buf  = eval<int32>(ctxt);
        else if ( _type == DataType::LONG   ) *(int64*)buf  = eval<int64>(ctxt);
        else if ( _type == DataType::FLOAT  ) *(single*)buf = eval<single>(ctxt);
        else if ( _type == DataType::SINGLE ) *(single*)buf = eval<single>(ctxt);
        else if ( _type == DataType::DOUBLE ) *(double*)buf = eval<double>(ctxt);
        else if ( _type == DataType::BOOL   ) *(bool*)buf   = eval<bool>(ctxt);
        else if ( _type == DataType::TIMESTAMP ) *( Timestamp* )buf = eval<Timestamp>(ctxt);
        else {
            EString str = eval<EString>(ctxt);
            __builtin_memcpy( buf, str.data(), str.length() );

            int len = getStringLength();
            ASSERT( len >= 0 );
            ASSERT( str.length() <= (unsigned int)len );
            __builtin_memset( buf + str.length(), 0, len - str.length() );
        }
    }

    virtual bool is_numeric() const { return( is<double>() ); }

    DataType getType() const { return _type; }

    TupleDescription::Field getField(string name = string()) const throw (ExprException);

    virtual void dump( string& s, unsigned int indent = 0 ) const
    {
        for ( unsigned int i = 0; i < indent; ++i )
        {   s += "    ";
        }

        s << typeid( *this );

        string val = value();
        if ( !val.empty() )
        {   s << " - " << val;
        }

        s << "\n";

        dump_children( s, indent + 1 );
    }

    string as_string() const
    {
        return( ::to_string( typeid( *this )));
    }

    static ptr<Expression> parse( string  expr, const ExprContext  &ctxt )
                           throw( ExprException );

    static void evalVectorInto( const vector<ptr<Expression> >  &exprs,
                                char  *buf, const EvalContext  &ctxt )
        throw( EvalException );

    static ptr<Expression> makeFieldExpresssion( string   tuple_name,
                                                 string   field_name,
                                      const ExprContext  &ctxt
                                               )
                                          throw( ExprException );

    TupleDescription::Field toField( string  name ) const
                              throw( AuroraException );

  protected:
    Expression( DataType  type ) : _type(type) {}

  protected:    
    virtual bool evalImpl( EvalAs<bool>, const EvalContext& )
                    throw( EvalException )
    {
        throw EvalException( "Cannot coerce result of "
                           + ::to_string( typeid( *this )) + " to bool" );
    }

    virtual bool isImpl( EvalAs<bool> ) const { return( false ); }


    virtual int32 evalImpl( EvalAs<int32>, const EvalContext& )
                     throw( EvalException )
    {
        throw EvalException( "Cannot coerce result of "
                           + ::to_string( typeid( *this )) + " to int" );
    }

    virtual bool isImpl( EvalAs<int32> ) const { return( false ); }


    virtual int64 evalImpl( EvalAs<int64>, const EvalContext& )
                     throw( EvalException )
    {
        throw EvalException( "Cannot coerce result of "
                           + ::to_string( typeid( *this )) + " to long" );
    }

    virtual bool isImpl( EvalAs<int64> ) const { return( false ); }


    virtual single evalImpl( EvalAs<single>, const EvalContext& )
                      throw( EvalException )
    {
        throw EvalException( "Cannot coerce result of "
                           + ::to_string( typeid( *this )) + " to single" );
    }

    virtual bool isImpl( EvalAs<single> ) const { return( false ); }

  
    virtual double evalImpl( EvalAs<double>, const EvalContext& )
                      throw( EvalException )
    {
        throw EvalException( "Cannot coerce result of "
                           + ::to_string( typeid( *this )) + " to double" );
    }

    virtual bool isImpl( EvalAs<double> ) const { return( false ); }


    virtual EString evalImpl( EvalAs<EString>, const EvalContext& )
                       throw( EvalException )
    {
        throw EvalException( "Cannot coerce result of "
                           + ::to_string( typeid( *this )) + " to EString" );
    }

    virtual bool isImpl( EvalAs<EString> ) const { return false; }

    virtual string evalImpl( EvalAs<string>, const EvalContext& ctxt )
                      throw( EvalException )
    {
        return( ::to_string( eval<EString>( ctxt )));
    }

    virtual bool isImpl( EvalAs<string> ) const { return is<EString>(); }


    virtual Timestamp evalImpl( EvalAs<Timestamp>, const EvalContext& )
                      throw( EvalException )
    {
        throw EvalException( "Cannot coerce result of "
                           + ::to_string( typeid( *this )) + " to Timestamp" );
    }

    virtual bool isImpl( EvalAs<Timestamp> ) const { return( false ); }



    virtual void dump_children( string& s, unsigned int indent ) const {}
    virtual string value() const { return string(); }

    //#ifdef ENABLE_SERIALIZATION
    //NMSTL_SERIAL_BASE(Expression, long, << _type);
    //#endif

  private:
    DataType  _type;
};


template<typename T> class TypedExpression;

template<>
class TypedExpression<bool> : public Expression
{
  public:
    TypedExpression() : Expression( DataType::BOOL ) {}

    virtual bool evalImpl( EvalAs<bool>, const EvalContext  &ctxt )
                    throw( EvalException ) = 0;

    bool isImpl( EvalAs<bool> ) const { return true; }


    int32 evalImpl( EvalAs<int32>, const EvalContext  &ctxt)
             throw( EvalException ) { return eval<bool>(ctxt); }

    bool isImpl( EvalAs<int32> ) const { return true; }


    int64 evalImpl( EvalAs<int64>, const EvalContext  &ctxt)
             throw( EvalException ) { return eval<bool>(ctxt); }

    bool isImpl( EvalAs<int64> ) const { return true; }


    single evalImpl( EvalAs<single>, const EvalContext &ctxt )
              throw( EvalException ) { return eval<bool>(ctxt); }

    bool isImpl( EvalAs<single> ) const { return true; }


    double evalImpl( EvalAs<double>, const EvalContext &ctxt )
              throw( EvalException ) { return eval<bool>(ctxt); }

    bool isImpl( EvalAs<double> ) const { return true; }


    EString evalImpl( EvalAs<EString>, const EvalContext  &ctxt )
               throw( EvalException )
    {
        return( EString::coerce( eval<bool>(ctxt), ctxt.getPool() ));
    }

    bool isImpl( EvalAs<EString> ) const { return true; }

    // Do we want to convert timestamps into bool? Maybe?
    //Timestamp evalImpl( EvalAs<Timestamp>, const EvalContext  &ctxt)
    //  throw( EvalException ) { return eval<bool>(ctxt); }
    //bool isImpl( EvalAs<Timestamp> ) const { return true; }

};


template<>
class TypedExpression<int32> : public Expression
{
  public:
    TypedExpression() : Expression( DataType::INT ) {}

    virtual int32 evalImpl( EvalAs<int32>, const EvalContext  &ctxt )
                     throw( EvalException ) = 0;

    bool isImpl( EvalAs<int32> ) const { return( true ); }


    int64 evalImpl( EvalAs<int64>, const EvalContext  &ctxt )
             throw( EvalException ) { return eval<int32>(ctxt); }

    bool isImpl( EvalAs<int64> ) const { return( true ); }


    single evalImpl( EvalAs<single>, const EvalContext  &ctxt )
             throw( EvalException ) { return eval<int32>(ctxt); }

    bool isImpl( EvalAs<single> ) const { return( true ); }


    double evalImpl( EvalAs<double>, const EvalContext  &ctxt )
             throw( EvalException ) { return eval<int32>(ctxt); }

    bool isImpl( EvalAs<double> ) const { return( true ); }


    EString evalImpl( EvalAs<EString>, const EvalContext  &ctxt )
               throw( EvalException )
    {
        return( EString::coerce( eval<int32>(ctxt), ctxt.getPool() ));
    }

    bool isImpl(EvalAs<EString>) const { return( true ); }

    //Timestamp evalImpl( EvalAs<Timestamp>, const EvalContext  &ctxt)
    //  throw( EvalException ) { return eval<int32>(ctxt); }
    //bool isImpl( EvalAs<Timestamp> ) const { return true; }

};


template<>
class TypedExpression<int64> : public Expression
{
  public:
    TypedExpression() : Expression( DataType::LONG ) {}

    virtual int64 evalImpl( EvalAs<int64>, const EvalContext  &ctxt )
                     throw( EvalException ) = 0;

    bool isImpl( EvalAs<int64> ) const { return( true ); }


    int32 evalImpl( EvalAs<int32>, const EvalContext  &ctxt )
             throw( EvalException ) { return eval<int64>(ctxt); }

    bool isImpl( EvalAs<int32> ) const { return( true ); }


    single evalImpl( EvalAs<single>, const EvalContext  &ctxt )
             throw( EvalException ) { return eval<int64>(ctxt); }

    bool isImpl( EvalAs<single> ) const { return( true ); }


    double evalImpl( EvalAs<double>, const EvalContext  &ctxt )
             throw( EvalException ) { return eval<int64>(ctxt); }

    bool isImpl( EvalAs<double> ) const { return( true ); }


    EString evalImpl( EvalAs<EString>, const EvalContext  &ctxt )
               throw( EvalException )
    {
        return( EString::coerce( eval<int64>(ctxt), ctxt.getPool() ));
    }

    bool isImpl(EvalAs<EString>) const { return( true ); }

    //Timestamp evalImpl( EvalAs<Timestamp>, const EvalContext  &ctxt)
    //  throw( EvalException ) { return eval<int64>(ctxt); }
    //bool isImpl( EvalAs<Timestamp> ) const { return true; }
};



template<>
class TypedExpression<single> : public Expression
{
  public:
    TypedExpression() : Expression( DataType::SINGLE ) {}

    virtual single evalImpl( EvalAs<single>, const EvalContext  &ctxt )
                      throw( EvalException ) = 0;

    bool isImpl( EvalAs<single> ) const { return( true ); }

    EString evalImpl( EvalAs<EString>, const EvalContext  &ctxt )
               throw( EvalException )
    {
        return( EString::coerce( eval<single>(ctxt), ctxt.getPool() ));
    }

    bool isImpl(EvalAs<EString>) const { return( true ); }

    //Timestamp evalImpl( EvalAs<Timestamp>, const EvalContext  &ctxt)
    //  throw( EvalException ) { return eval<single>(ctxt); }
    //bool isImpl( EvalAs<Timestamp> ) const { return true; }
};


template<>
class TypedExpression<double> : public Expression
{
  public:
    TypedExpression() : Expression( DataType::DOUBLE ) {}

    virtual double evalImpl( EvalAs<double>, const EvalContext  &ctxt )
                      throw( EvalException ) = 0;

    bool isImpl( EvalAs<double> ) const { return( true ); }

    EString evalImpl( EvalAs<EString>, const EvalContext  &ctxt )
               throw( EvalException )
    {
        return( EString::coerce(eval<double>(ctxt), ctxt.getPool() ));
    }

    bool isImpl(EvalAs<EString>) const { return( true ); }

    //Timestamp evalImpl( EvalAs<Timestamp>, const EvalContext  &ctxt)
    //  throw( EvalException ) { return eval<double>(ctxt); }
    //bool isImpl( EvalAs<Timestamp> ) const { return true; }
};



template<>
class TypedExpression<EString> : public Expression
{
  public:
    virtual EString evalImpl( EvalAs<EString>, const EvalContext  &ctxt )
                       throw( EvalException ) = 0;

    bool isImpl( EvalAs<EString> ) const { return( true ); }

    TypedExpression() : Expression( DataType::STRING ) {}
};

template<>
class TypedExpression<Timestamp> : public Expression
{
 public:
    TypedExpression() : Expression ( DataType::TIMESTAMP ) {}

    virtual Timestamp evalImpl( EvalAs<Timestamp>, const EvalContext  &ctxt)
        throw( EvalException ) = 0;

    bool isImpl( EvalAs<Timestamp> ) const { return true; }
};

BOREALIS_NAMESPACE_END
#endif                       // EXPRESSION_H

---