Statement.h

Go to the documentation of this file.

#ifndef QUERY_STATEMENT_H
#define QUERY_STATEMENT_H
 
#include <string>
#include <vector>
#include <memory>
#include <variant>
 
namespace Xale::Query
{
    enum class StatementType
    {
        Select,
        Insert,
        Update,
        Delete,
        Create,
        Drop,
        List,
        Unknown
    };

    enum class ExpressionType
    {
        Identifier,
        StringLiteral,
        NumericLiteral,
        BinaryOp,
        Wildcard
    };

    struct Expression;
    struct BinaryExpression;

    struct Expression
    {
        ExpressionType type;
        std::string value;
        std::unique_ptr<BinaryExpression> binary;
 
        Expression() : type(ExpressionType::Identifier) {}
        explicit Expression(ExpressionType t, std::string val = "")
            : type(t), value(std::move(val)) {}
    };

    struct BinaryExpression
    {
        std::unique_ptr<Expression> left;
        std::string op;
        std::unique_ptr<Expression> right;
 
        BinaryExpression() = default;
        BinaryExpression(std::unique_ptr<Expression> l, std::string operation, std::unique_ptr<Expression> r)
            : left(std::move(l)), op(std::move(operation)), right(std::move(r)) {}
    };

    struct WhereClause
    {
        std::unique_ptr<Expression> condition;
        
        WhereClause() = default;
        explicit WhereClause(std::unique_ptr<Expression> cond)
            : condition(std::move(cond)) {}
    };

    struct Statement
    {
        StatementType type;
 
        explicit Statement(StatementType t) : type(t) {}
        virtual ~Statement() = default;
    };

    struct JoinClause
    {
        std::string tableName;      
        std::string leftTableCol;   
        std::string rightTableCol;  
    };

    struct SelectStatement : public Statement
    {
        std::vector<Expression> columns;
        std::string tableName;
        std::vector<JoinClause> joins; 
        std::unique_ptr<WhereClause> where;
 
        SelectStatement() : Statement(StatementType::Select) {}
    };

    struct InsertStatement : public Statement
    {
        std::string tableName;
        std::vector<std::string> columns;
        std::vector<Expression> values;
 
        InsertStatement() : Statement(StatementType::Insert) {}
    };

    struct UpdateStatement : public Statement
    {
        std::string tableName;
        std::vector<std::pair<std::string, Expression>> assignments;
        std::unique_ptr<WhereClause> where;
 
        UpdateStatement() : Statement(StatementType::Update) {}
    };

    struct DeleteStatement : public Statement
    {
        std::string tableName;
        std::unique_ptr<WhereClause> where;
 
        DeleteStatement() : Statement(StatementType::Delete) {}
    };

    struct ForeignKeyRef
    {
        std::string refTable;  
        std::string refColumn; 
    };

    struct ColumnDefinitionStmt
    {
        std::string name;
        std::string type;
        bool isPrimaryKey;
        ForeignKeyRef references; 
 
        ColumnDefinitionStmt() : isPrimaryKey(false) {}
        ColumnDefinitionStmt(std::string n, std::string t, bool pk = false)
            : name(std::move(n)), type(std::move(t)), isPrimaryKey(pk) {}
    };

    struct CreateStatement : public Statement
    {
        std::string tableName;
        std::vector<ColumnDefinitionStmt> columns;
        
        CreateStatement() : Statement(StatementType::Create) {}
    };

    struct DropStatement : public Statement
    {
        std::string tableName;
 
        DropStatement() : Statement(StatementType::Drop) {}
    };
 

    struct ListStatement : public Statement
    {
        ListStatement() : Statement(StatementType::List) {}
    };
}
 
#endif // QUERY_STATEMENT_H