parsed_expression.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "cast.h"
#include "copy_constructors.h"
#include "expression_type.h"
 
namespace kuzu {
 
namespace common {
struct FileInfo;
class Serializer;
class Deserializer;
} // namespace common
 
namespace parser {
 
class ParsedExpression;
class ParsedExpressionChildrenVisitor;
using parsed_expr_vector = std::vector<std::unique_ptr<ParsedExpression>>;
using parsed_expr_pair =
 std::pair<std::unique_ptr<ParsedExpression>, std::unique_ptr<ParsedExpression>>;
using s_parsed_expr_pair = std::pair<std::string, std::unique_ptr<ParsedExpression>>;
 
class KUZU_API ParsedExpression {
 friend class ParsedExpressionChildrenVisitor;
 
public:
 ParsedExpression(common::ExpressionType type, std::unique_ptr<ParsedExpression> child,
 std::string rawName);
 ParsedExpression(common::ExpressionType type, std::unique_ptr<ParsedExpression> left,
 std::unique_ptr<ParsedExpression> right, std::string rawName);
 ParsedExpression(common::ExpressionType type, std::string rawName)
 : type{type}, rawName{std::move(rawName)} {}
 explicit ParsedExpression(common::ExpressionType type) : type{type} {}
 
 ParsedExpression(common::ExpressionType type, std::string alias, std::string rawName,
 parsed_expr_vector children)
 : type{type}, alias{std::move(alias)}, rawName{std::move(rawName)},
 children{std::move(children)} {}
 DELETE_COPY_DEFAULT_MOVE(ParsedExpression);
 virtual ~ParsedExpression() = default;
 
 common::ExpressionType getExpressionType() const { return type; }
 
 void setAlias(std::string name) { alias = std::move(name); }
 
 bool hasAlias() const { return !alias.empty(); }
 
 std::string getAlias() const { return alias; }
 
 std::string getRawName() const { return rawName; }
 
 uint32_t getNumChildren() const { return children.size(); }
 ParsedExpression* getChild(uint32_t idx) const { return children[idx].get(); }
 
 std::string toString() const { return rawName; }
 
 virtual std::unique_ptr<ParsedExpression> copy() const {
 return std::make_unique<ParsedExpression>(type, alias, rawName, copyVector(children));
 }
 
 void serialize(common::Serializer& serializer) const;
 
 static std::unique_ptr<ParsedExpression> deserialize(common::Deserializer& deserializer);
 
 template<class TARGET>
 TARGET& cast() {
 return common::ku_dynamic_cast<ParsedExpression&, TARGET&>(*this);
 }
 template<class TARGET>
 const TARGET& constCast() const {
 return common::ku_dynamic_cast<const ParsedExpression&, const TARGET&>(*this);
 }
 template<class TARGET>
 const TARGET* constPtrCast() const {
 return common::ku_dynamic_cast<const ParsedExpression*, const TARGET*>(this);
 }
 
private:
 virtual void serializeInternal(common::Serializer&) const {}
 
protected:
 common::ExpressionType type;
 std::string alias;
 std::string rawName;
 parsed_expr_vector children;
};
 
using options_t = std::unordered_map<std::string, std::unique_ptr<parser::ParsedExpression>>;
 
struct ParsedExpressionUtils {
 static std::unique_ptr<ParsedExpression> getSerialDefaultExpr(const std::string& sequenceName);
};
 
} // namespace parser
} // namespace kuzu