mlisp/usql/parser.h

#pragma once

#include "lexer.h"
#include "exception.h"
#include "ml_date.h"
#include "settings.h"

#include <string>
#include <utility>
#include <vector>

static const int FUNCTION_CALL = -1;

namespace usql {

enum class ColumnType {
	integer_type,
	float_type,
	varchar_type,
	date_type,
	bool_type
};

enum class NodeType {
	true_node,
	null_value,
	int_value,
	float_value,
	string_value,
	bool_value,
	logical_operator,
	relational_operator,
	arithmetical_operator,
	create_table,
	create_table_as_select,
	insert_into,
	select_from,
	delete_from,
	update_table,
	load_table,
	save_table,
	drop_table,
	create_index,
	set,
	show,
	database_value,
	offset_limit,
	column_order,
	function,
	column_def,
	error
};

struct Node {
	NodeType node_type;

	explicit Node(const NodeType type) : node_type(type) {}
	virtual ~Node() = default;

	virtual void dump() const {
		std::cout << "type: Node" << std::endl;
	}
};


struct ColOrderNode : Node {
	std::string col_name;
	int col_index;
	bool ascending;

	ColOrderNode(std::string  name, bool asc) : Node(NodeType::column_order), col_name(std::move(name)), col_index(-1), ascending(asc) {}
	ColOrderNode(int index, bool asc) : Node(NodeType::database_value), col_index(index), ascending(asc) {}

	void dump() const override {
		std::cout << "type: ColOrderNode, col_name: " << col_name << ", col_index: " << col_index << ", asc: " << ascending << std::endl;
	}
};



struct OffsetLimitNode : Node {
	size_t	offset;
	size_t	limit;

	OffsetLimitNode(size_t off, size_t lim) : Node(NodeType::offset_limit), offset(off), limit(lim) {}

	void dump() const override {
		std::cout << "type: OffsetLimitNode, offset: " << offset << ", limit: " << limit << std::endl;
	}
};


struct SelectColNode : Node {
	std::unique_ptr<Node>	value;
	std::string name;

	SelectColNode(std::unique_ptr<Node> column, std::string alias) :
	Node(NodeType::database_value), value(std::move(column)), name(std::move(alias)) {}

	void dump() const override {
		std::cout << "type: SelectColNode, name:" <<  name  << "value:" << std::endl;
		value->dump();
	}
};

struct ColDefNode : Node {
	std::string name;
	ColumnType type;
	int order;
	size_t length;
	bool null;

	ColDefNode(std::string  col_name,  ColumnType col_type, int col_order, size_t col_len, bool nullable) :
			Node(NodeType::column_def), name(std::move(col_name)), type(col_type), order(col_order), length(col_len),
			null(nullable) {}

	void dump() const override {
		std::cout << "type: ColDefNode, name: " << name << ", type: " << (int)type << " TODO add more" << std::endl;
	}
};

struct FunctionNode : Node {
	std::string				function;	// TODO use enum
	std::vector<std::unique_ptr<Node>>	params;

	FunctionNode(std::string  func_name, std::vector<std::unique_ptr<Node>> pars) :
	Node(NodeType::function), function(std::move(func_name)), params(std::move(pars)) {}

	void dump() const override {
		std::cout << "type: FunctionNode, function: " << function << " TODO add more" << std::endl;
	}
};

struct TrueNode : Node {
	TrueNode() : Node(NodeType::true_node) {}

	void dump() const override {
		std::cout << "type: TrueNode," << std::endl;
	}
};

struct ValueNode : Node {
	explicit ValueNode(NodeType type) : Node(type) {}

	virtual bool isNull() const { return false; }
	virtual long getIntegerValue() const = 0;
	virtual double getDoubleValue() const = 0;
	virtual std::string getStringValue() const = 0;
	virtual long getDateValue() const = 0;
	virtual bool getBooleanValue() const = 0;

	~ValueNode() override = default;
};

struct NullValueNode : ValueNode {

	NullValueNode() : ValueNode(NodeType::null_value) {}

	bool isNull() const override { return true; }

	long getIntegerValue() const override { throw Exception("getIntegerValue not supported on NullValueNode"); };
	double getDoubleValue() const override { throw Exception("getDoubleValue not supported on NullValueNode"); };
	std::string getStringValue() const override { throw Exception("getStringValue not supported on NullValueNode"); };
	long getDateValue() const override { throw Exception("getDateValue not supported on NullValueNode"); };
	bool getBooleanValue() const override { throw Exception("getBooleanValue not supported on NullValueNode"); };

	void dump() const override {
		std::cout << "type: NullValueNode," << std::endl;
	}
};

struct IntValueNode : ValueNode {
	long value;

	explicit IntValueNode(long value) : ValueNode(NodeType::int_value), value(value) {}

	long getIntegerValue() const override { return value; };
	double getDoubleValue() const override { return (double) value; };
	std::string getStringValue() const override { return Settings::long_to_string(value); }
	long getDateValue() const override { return value; };
	bool getBooleanValue() const override { return value != 0; };

	void dump() const override {
		std::cout << "type: IntValueNode, value: " << value << std::endl;
	}
};

struct DoubleValueNode : ValueNode {
	double value;

	explicit DoubleValueNode(double value) : ValueNode(NodeType::float_value), value(value) {}

	long getIntegerValue() const override { return (long) value; };
	double getDoubleValue() const override { return value; };
	std::string getStringValue() const override { return Settings::double_to_string(value); }
	long getDateValue() const override { return (long) value; };
	bool getBooleanValue() const override { return value != 0.0; };

	void dump() const override {
		std::cout << "type: DoubleValueNode, value: " << value << std::endl;
	}
};

struct StringValueNode : ValueNode {
	std::string value;

	explicit StringValueNode(std::string value) : ValueNode(NodeType::string_value), value(std::move(value)) {}

	long getIntegerValue() const override { return Settings::string_to_long(value); };
	double getDoubleValue() const override { return Settings::string_to_double(value); };
	std::string getStringValue() const override { return value; };
	long getDateValue() const override { return Settings::string_to_date(value); };
	bool getBooleanValue() const override { return Settings::string_to_bool(value); };

	void dump() const override {
		std::cout << "type: StringValueNode, value: " << value << std::endl;
	}
};

struct BooleanValueNode : ValueNode {
	bool value;

	explicit BooleanValueNode(bool value) : ValueNode(NodeType::bool_value), value(value) {}

	long getIntegerValue() const override { return (long) value; };
	double getDoubleValue() const override { return (double) value; };
	std::string getStringValue() const override { return Settings::bool_to_string(value); }
	long getDateValue() const override { return (long) value; };
	bool getBooleanValue() const override { return value; };

	void dump() const override {
		std::cout << "type: BooleanValueNode, value: " << value << std::endl;
	}
};


struct DatabaseValueNode : Node {
	std::string col_name;

	explicit DatabaseValueNode(std::string name) : Node(NodeType::database_value), col_name(std::move(name)) {}

	void dump() const override {
		std::cout << "type: DatabaseValueNode, col_name: " << col_name << std::endl;
	}
};

enum class LogicalOperatorType {
	and_operator,
	or_operator
	// not_operator
};

struct LogicalOperatorNode : Node {
	LogicalOperatorType op;
	std::unique_ptr<Node> left;
	std::unique_ptr<Node> right;

	LogicalOperatorNode(LogicalOperatorType op, std::unique_ptr<Node> left, std::unique_ptr<Node> right) :
			Node(NodeType::logical_operator), op(op), left(std::move(left)), right(std::move(right)) {};

	void dump() const override {
		std::cout << "type: LogicalOperatorNode, op: " << (int)op << std::endl;
		left->dump();
		right->dump();
	}
};

enum class RelationalOperatorType {
	equal,
	greater,
	greater_equal,
	lesser,
	lesser_equal,
	not_equal,
	is,
	is_not
	// like
};

struct RelationalOperatorNode : Node {
	RelationalOperatorType op;

	std::unique_ptr<Node> left;
	std::unique_ptr<Node> right;

	RelationalOperatorNode(RelationalOperatorType op, std::unique_ptr<Node> left, std::unique_ptr<Node> right) :
			Node(NodeType::relational_operator), op(op), left(std::move(left)), right(std::move(right)) {};

	void dump() const override {
		std::cout << "type: RelationalOperatorNode, op: " << (int)op << std::endl;
		left->dump();
		right->dump();
	}
};

enum class ArithmeticalOperatorType {
	copy_value,     // just copy lef value and do nothing with it
	plus_operator,
	minus_operator,
	multiply_operator,
	divide_operator
};

struct ArithmeticalOperatorNode : Node {
	ArithmeticalOperatorType op;

	std::unique_ptr<Node> left;
	std::unique_ptr<Node> right;

	ArithmeticalOperatorNode(ArithmeticalOperatorType op, std::unique_ptr<Node> left, std::unique_ptr<Node> right) :
			Node(NodeType::arithmetical_operator), op(op), left(std::move(left)), right(std::move(right)) {};

	void dump() const override {
		std::cout << "type: ArithmeticalOperatorNode, op: " << (int)op << std::endl;
		left->dump();
		right->dump();
	}
};

struct CreateTableNode : Node {
	std::string table_name;
	std::vector<ColDefNode> cols_defs;

	CreateTableNode(std::string  name, std::vector<ColDefNode> defs) :
			Node(NodeType::create_table), table_name(std::move(name)), cols_defs(std::move(defs)) {}

	void dump() const override {
		std::cout << "type: CreateTableNode, table_name: " << table_name << "TODO complete me" << std::endl;
	}
};

struct InsertIntoTableNode : Node {
	std::string				table_name;
	std::vector<DatabaseValueNode>		cols_names;
	std::vector<std::unique_ptr<Node>>	cols_values;

	InsertIntoTableNode(std::string  name, std::vector<DatabaseValueNode> names, std::vector<std::unique_ptr<Node>> values) :
			Node(NodeType::insert_into), table_name(std::move(name)), cols_names(std::move(names)), cols_values(std::move(values)) {}

	void dump() const override {
		std::cout << "type: InsertIntoTableNode, table_name: " << table_name << "TODO complete me" << std::endl;
	}
};

struct SelectFromTableNode : Node {
	std::string table_name;
	std::unique_ptr<std::vector<SelectColNode>> cols_names;
	std::unique_ptr<Node> where;
	std::vector<ColOrderNode> order_by;
	OffsetLimitNode	offset_limit;
	bool distinct;

	SelectFromTableNode(std::string name, std::unique_ptr<std::vector<SelectColNode>> names, std::unique_ptr<Node> where_clause, std::vector<ColOrderNode> orderby, OffsetLimitNode offlim, bool distinct_):
	Node(NodeType::select_from), table_name(std::move(name)), cols_names(std::move(names)), where(std::move(where_clause)), order_by(std::move(orderby)), offset_limit(std::move(offlim)), distinct(distinct_) {}

	void dump() const override {
		std::cout << "type: SelectFromTableNode, table_name: " << table_name << "TODO complete me" << std::endl;
		where->dump();
	}
};

struct CreateTableAsSelectNode : Node {
	std::string		table_name;
	std::unique_ptr<Node>	select_table;

	CreateTableAsSelectNode(std::string  name, std::unique_ptr<Node> table) :
	Node(NodeType::create_table_as_select), table_name(std::move(name)), select_table(std::move(table)) {}

	void dump() const override {
		std::cout << "type: CreateTableAsSelectNode, table_name: " << table_name << std::endl;
		select_table->dump();
	}
};

struct UpdateTableNode : Node {
	std::string table_name;
	std::vector<DatabaseValueNode> cols_names;
	std::vector<std::unique_ptr<Node>> values;
	std::unique_ptr<Node> where;

	UpdateTableNode(std::string name, std::vector<DatabaseValueNode> names, std::vector<std::unique_ptr<Node>> vals,
			std::unique_ptr<Node> where_clause) :
			Node(NodeType::update_table), table_name(std::move(name)), cols_names(std::move(names)), values(std::move(vals)),
			where(std::move(where_clause)) {}

	void dump() const override {
		std::cout << "type: UpdateTableNode, table_name: " << table_name << "TODO complete me" << std::endl;
		where->dump();
	}
};

struct LoadIntoTableNode : Node {
	std::string table_name;
	std::string filename;

	LoadIntoTableNode(std::string  name, std::string file) :
			Node(NodeType::load_table), table_name(std::move(name)), filename(std::move(file)) {}

	void dump() const override {
		std::cout << "type: LoadIntoTableNode, table_name: " << table_name << ", filename" << filename << std::endl;
	}
};

struct SaveTableNode : Node {
	std::string table_name;
	std::string filename;

	SaveTableNode(std::string  name, std::string file) :
	Node(NodeType::save_table), table_name(std::move(name)), filename(std::move(file)) {}

	void dump() const override {
		std::cout << "type: SaveTableNode, table_name: " << table_name << ", filename" << filename << std::endl;
	}
};

struct DropTableNode : Node {
	std::string table_name;

	explicit DropTableNode(std::string  name) : Node(NodeType::drop_table), table_name(std::move(name)) {}

	void dump() const override {
		std::cout << "type: SelectFromTableNode, table_name: " << table_name << std::endl;
	}
};

struct DeleteFromTableNode : Node {
	std::string table_name;
	std::unique_ptr<Node> where;

	DeleteFromTableNode(std::string  name, std::unique_ptr<Node> where_clause) :
			Node(NodeType::delete_from), table_name(std::move(name)), where(std::move(where_clause)) {}

	void dump() const override {
		std::cout << "type: DeleteFromTableNode, table_name: " << table_name << std::endl;
		where->dump();
	}
};

struct SetNode : Node {
	std::string name;
	std::string value;

	SetNode(std::string  node_name, std::string  node_value) :
			Node(NodeType::set), name(std::move(node_name)), value(std::move(node_value)) {}

	void dump() const override {
		std::cout << "type: SetNode, name: " << name << ", value: " << value << std::endl;
	}
};

struct ShowNode : Node {
	std::string name;

	explicit ShowNode(std::string  node_name) : Node(NodeType::show), name(std::move(node_name)) {}

	void dump() const override {
		std::cout << "type: ShowNode, name: " << name << std::endl;
	}
};

struct CreateIndexNode : Node {
	std::string index_name;
	std::string table_name;
	std::string column_name;

	CreateIndexNode(std::string  idx_name, std::string  tbl_name, std::string col_name) :
			Node(NodeType::create_index), index_name(std::move(idx_name)), table_name(std::move(tbl_name)), column_name(std::move(col_name)) {}

	void dump() const override {
		std::cout << "type: CreateIndexNode, table_name: " << table_name << ", index_name: " << index_name << ", column_name: " << column_name << std::endl;
	}
};

class Parser {
private:
public:
	Parser();

	std::unique_ptr<Node> parse(const std::string &code);

private:
	std::unique_ptr<Node> parse_create_table();
	std::unique_ptr<Node> parse_drop_table();
	std::unique_ptr<Node> parse_load_table();
	std::unique_ptr<Node> parse_save_table();
	std::unique_ptr<Node> parse_set();
	std::unique_ptr<Node> parse_show();

	std::unique_ptr<Node> parse_insert_into_table();
	std::unique_ptr<Node> parse_select_from_table();
	std::unique_ptr<Node> parse_delete_from_table();
	std::unique_ptr<Node> parse_update_table();
	std::unique_ptr<Node> parse_create_index();

	std::vector<ColOrderNode>  parse_order_by_clause();
	OffsetLimitNode parse_offset_limit_clause();

	std::unique_ptr<Node> parse_where_clause();
	std::unique_ptr<Node> parse_expression();
	std::unique_ptr<Node> parse_expression(std::unique_ptr<Node> left);

	std::unique_ptr<Node> parse_value();
	RelationalOperatorType parse_relational_operator();
	LogicalOperatorType parse_logical_operator();
	ArithmeticalOperatorType parse_arithmetical_operator();

private:
	Lexer m_lexer;
};

}	// namespace