/home/sebastian/gpudbms/trunk/cogadb/include/sql/server/sql_parsetree.hpp

Go to the documentation of this file.

#ifndef __SQL_PARSETREE_HPP
#define __SQL_PARSETREE_HPP

#include <utility>
#include <list>
#include <string>

#include <boost/any.hpp>
#include <boost/shared_ptr.hpp>

#include <query_processing/query_processor.hpp>

namespace CoGaDB {
namespace SQL {
namespace ParseTree {

/*
 * Scalar types
 */
typedef std::string String;
typedef boost::any Integer;
typedef CoGaDB::AggregationMethod AggregationFunction;

/* base class for all Statements */
class Statement {
public:
        virtual ~Statement() {}

        virtual TablePtr execute(void) = 0;
};
typedef boost::shared_ptr<Statement> StatementPtr;

typedef CoGaDB::AttributeType AttributeType;
typedef CoGaDB::Attribut Attribute;
typedef CoGaDB::TableSchema TableSchema;
typedef CoGaDB::Table Table;
typedef CoGaDB::TablePtr TablePtr;

typedef query_processing::LogicalQueryPlan::TypedNodePtr TypedNodePtr;

class CreateTable : public Statement {
        TablePtr table;

public:
        CreateTable(TablePtr _table) : table(_table) {}
        CreateTable(Table *_table) : table(_table) {}

        TablePtr execute(void);
};

struct ScalarExpression {
        virtual ~ScalarExpression() {}

        virtual void setColumnName(const String &name);
        virtual String getQueryPlan(TypedNodePtr &io_node) = 0;
};
typedef boost::shared_ptr<ScalarExpression> ScalarExpressionPtr;
typedef std::list<ScalarExpressionPtr> ScalarExpressionList;
typedef boost::shared_ptr<ScalarExpressionList> ScalarExpressionListPtr;

struct AtomExpression : public ScalarExpression {
        boost::any atom;
        AttributeType type;

        String explicit_result_colname;

        AtomExpression(const boost::any &_atom, AttributeType _type)
                      : atom(_atom), type(_type) {}

        void setColumnName(const String &name);
        String toString();

        String getQueryPlan(TypedNodePtr &io_node);
};
typedef boost::shared_ptr<AtomExpression> AtomExpressionPtr;

struct ColumnExpression : public ScalarExpression {
        String column;

        ColumnExpression(String &_column) : column(_column) {}

        String getQueryPlan(TypedNodePtr &io_node);
};
typedef boost::shared_ptr<ColumnExpression> ColumnExpressionPtr;

struct FunctionExpression : public ScalarExpression {
        AggregationFunction function;
        ScalarExpressionPtr param;

        FunctionExpression(AggregationFunction _function,
                           ScalarExpressionPtr _param)
                          : function(_function), param(_param) {}

        void setColumnName(const String &name);
        String getQueryPlan(TypedNodePtr &io_node);
};
typedef boost::shared_ptr<FunctionExpression> FunctionExpressionPtr;

typedef CoGaDB::ColumnAlgebraOperation ColumnAlgebraOperation;

struct AlgebraExpression : public ScalarExpression {
        ScalarExpressionPtr lvalue;
        ColumnAlgebraOperation op;
        ScalarExpressionPtr rvalue;

        String explicit_result_colname;

        AlgebraExpression(ScalarExpressionPtr _lvalue,
                          ColumnAlgebraOperation _op,
                          ScalarExpressionPtr _rvalue)
                         : lvalue(_lvalue), op(_op), rvalue(_rvalue) {}

        void setColumnName(const String &name);
        String getQueryPlan(TypedNodePtr &io_node);
};

struct SearchCondition {
        virtual ~SearchCondition() {}

        virtual KNF_Selection_Expression getCNF(TypedNodePtr &io_node) = 0;
};
typedef boost::shared_ptr<SearchCondition> SearchConditionPtr;

struct AndCondition : public SearchCondition {
        SearchConditionPtr lvalue;      
        SearchConditionPtr rvalue;

        AndCondition(SearchConditionPtr _lvalue, SearchConditionPtr _rvalue)
                    : lvalue(_lvalue), rvalue(_rvalue) {}

        KNF_Selection_Expression getCNF(TypedNodePtr &io_node);
};
typedef boost::shared_ptr<AndCondition> AndConditionPtr;

struct OrCondition : public SearchCondition {
        SearchConditionPtr lvalue;      
        SearchConditionPtr rvalue;

        OrCondition(SearchConditionPtr _lvalue, SearchConditionPtr _rvalue)
                   : lvalue(_lvalue), rvalue(_rvalue) {}

        KNF_Selection_Expression getCNF(TypedNodePtr &io_node);
};
typedef boost::shared_ptr<OrCondition> OrConditionPtr;

enum ValueComparator {
        LESSER,
        LESSER_EQUAL,
        GREATER,
        GREATER_EQUAL,
        EQUAL,
        UNEQUAL
};

struct Predicate : public SearchCondition {};

struct ComparisonPredicate : public Predicate {
        ScalarExpressionPtr lvalue;
        ValueComparator op;
        ScalarExpressionPtr rvalue;

        ComparisonPredicate(ScalarExpressionPtr _lvalue,
                            ValueComparator _op,
                            ScalarExpressionPtr _rvalue)
                           : lvalue(_lvalue), op(_op), rvalue(_rvalue) {}

        KNF_Selection_Expression getCNF(TypedNodePtr &io_node);
};
typedef boost::shared_ptr<ComparisonPredicate> ComparisonPredicatePtr;

struct BetweenPredicate : public Predicate {
        AndConditionPtr and_cond;

        BetweenPredicate(ScalarExpressionPtr _exp,
                         ScalarExpressionPtr _lvalue,
                         ScalarExpressionPtr _rvalue);

        KNF_Selection_Expression getCNF(TypedNodePtr &io_node);
};

struct NotBetweenPredicate : public Predicate {
        OrConditionPtr or_cond;

        NotBetweenPredicate(ScalarExpressionPtr _exp,
                            ScalarExpressionPtr _lvalue,
                            ScalarExpressionPtr _rvalue);

        KNF_Selection_Expression getCNF(TypedNodePtr &io_node);
};

struct TableReference {
        virtual ~TableReference() {}

        virtual TypedNodePtr getQueryPlan() = 0;
};
typedef boost::shared_ptr<TableReference> TableReferencePtr;
typedef std::list<TableReferencePtr> TableReferenceList;

struct TableName : public TableReference {
        String table;

        TableName(String &_table) : table(_table) {}

        TypedNodePtr getQueryPlan();
};
typedef boost::shared_ptr<TableName> TableNamePtr;

struct Join : public TableReference {
        TableReferencePtr lvalue;
        TableReferencePtr rvalue;

        Join(TableReferencePtr _lvalue, TableReferencePtr _rvalue)
            : lvalue(_lvalue), rvalue(_rvalue) {}
};

struct InnerJoin : public Join {
        SearchConditionPtr condition;

        InnerJoin(TableReferencePtr _lvalue, TableReferencePtr _rvalue,
                  SearchConditionPtr _condition)
                 : Join(_lvalue, _rvalue), condition(_condition) {}

        TypedNodePtr getQueryPlan();
};
typedef boost::shared_ptr<InnerJoin> InnerJoinPtr;

struct CrossJoin : public Join {
        CrossJoin(TableReferencePtr _lvalue, TableReferencePtr _rvalue)
                 : Join(_lvalue, _rvalue) {}

        TypedNodePtr getQueryPlan();
};
typedef boost::shared_ptr<CrossJoin> CrossJoinPtr;

typedef std::list<String> ColumnList;
typedef boost::shared_ptr<ColumnList> ColumnListPtr;
typedef CoGaDB::Tuple Tuple;

typedef CoGaDB::SortOrder SortOrder;
typedef std::pair<String, SortOrder> OrderingSpec;

struct OrderBy {
        ColumnList list;
        SortOrder order;
};
typedef boost::shared_ptr<OrderBy> OrderByPtr;

class InsertInto : public Statement {
        String table;
        Tuple row;

public:
        InsertInto(TableName &_table, Tuple &_row)
                  : table(_table.table), row(_row) {}

        TablePtr execute(void);
};

struct TableExpression {
        TypedNodePtr table;
        ColumnListPtr group_by;
        OrderByPtr order_by;

        TableExpression(TableReferenceList &from, SearchConditionPtr where,
                        ColumnListPtr _group_by, OrderByPtr _order_by);
};

class SelectFrom : public Statement {
        TypedNodePtr node;

public:
        SelectFrom(ScalarExpressionListPtr columns, TableExpression &table_exp);

        TablePtr execute(void);
};

class Sequence {
        std::list<StatementPtr> statements;

public:
        inline void
        push_back(StatementPtr statement)
        {
                statements.push_back(statement);
        }
        inline void
        push_back(Statement *statement)
        {
                push_back(StatementPtr(statement));
        }

        TablePtr execute(void);
};
typedef boost::shared_ptr<Sequence> SequencePtr;

} /* namespace ParseTree */
} /* namespace SQL */
} /* namespace CoGaDB */

#endif