diff --git a/src/ast.cpp b/src/ast.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..9bdb0c8a35587718a6c56a25ad668347ab232f39
--- /dev/null
+++ b/src/ast.cpp
@@ -0,0 +1,5546 @@
+#include "../include/ast.h"
+#include "../include/define.h"
+#include <cassert>
+
+using namespace std;
+
+//TRIM**SUBSTRING**BIT_AND**BIT_OR**BIT_XOR**COUNT**MIN**MAX**SUM**STD**STDDEV_SAMP**VARIANCE**VAR_SAMP**GROUP_CONCAT**
+
+const char* convertToTerminal[] = {
+	";",
+	"FROM",
+	"DELETE",
+	"",
+	"QUICK",
+	"LOW_PRIORITY",
+	"IGNORE",
+	"ALTER TABLE",
+	",",
+	"ADD COLUMN",
+	")",
+	"ADD COLUMN (",
+	"ADD",
+	"CHANGE COLUMN",
+	"MODIFY COLUMN",
+	"DROP COLUMN",
+	"DROP FOREIGN KEY",
+	"DROP PRIMARY KEY",
+	"DROP INDEX",
+	"DROP CHECK",
+	"DROP CONSTRAINT",
+	"SET DEFAULT (",
+	"ALTER COLUMN",
+	"DROP DEFAULT",
+	"SET",
+	"ALTER INDEX",
+	"RENAME TO",
+	"TO",
+	"RENAME INDEX",
+	"RENAME COLUMN",
+	"AFTER",
+	"FIRST",
+	"ON",
+	"DROP TABLE",
+	"IF EXISTS",
+	"DROP VIEW",
+	"UPDATE",
+	"LIMIT",
+	"INTO",
+	"INSERT",
+	"(",
+	"VALUES",
+	") VALUES",
+	"DEFAULT",
+	"AS",
+	"ON DUPLICATE KEY UPDATE",
+	"=",
+	"DELAYED",
+	"HIGH_PRIORITY",
+	"INDEX",
+	"CREATE",
+	"UNIQUE",
+	"VIEW",
+	"OR REPLACE",
+	"ALGORITHM = UNDEFINED",
+	"ALGORITHM = MERGE",
+	"ALGORITHM = TEMPTABLE",
+	"TABLE",
+	"TEMPORARY",
+	"IF NOT EXISTS",
+	"REPLACE",
+	"CHAR",
+	"BINARY",
+	"VARCHAR",
+	"VARBINARY",
+	"LONG VARBINARY",
+	"TINYBLOB",
+	"MEDIUMBLOB",
+	"LONGBLOB",
+	"BLOB",
+	"TINYTEXT",
+	"MEDIUMTEXT",
+	"LONGTEXT",
+	"TEXT",
+	"BOOL",
+	"BOOLEAN",
+	"FLOAT",
+	"DECIMAL",
+	"NUMERIC",
+	"FIXED",
+	"REAL",
+	"DOUBLE",
+	"INT",
+	"TINYINT",
+	"SMALLINT",
+	"MEDIUMINT",
+	"BIGINT",
+	"SIGNED",
+	"UNSIGNED",
+	"ZEROFILL",
+	"DEFAULT (",
+	"NOT NULL",
+	"VISIBLE",
+	"INVISIBLE",
+	"CONSTRAINT",
+	"CHECK (",
+	"FOREIGN KEY",
+	"REFERENCES",
+	"ON UPDATE",
+	"ON DELETE",
+	"CASCADE",
+	"SET NULL",
+	"NO ACTION",
+	"SET DEFAULT",
+	"PRIMARY KEY",
+	"UNION",
+	"EXCEPT",
+	"INTERSECT",
+	"SELECT",
+	"WINDOW",
+	"PARTITION BY",
+	"ORDER BY",
+	"ASC",
+	"DESC",
+	"ROWS",
+	"RANGE",
+	"UNBOUNDED PRECEDING",
+	"PRECEDING",
+	"CURRENT ROW",
+	"AND",
+	"BETWEEN",
+	"UNBOUNDED FOLLOWING",
+	"FOLLOWING",
+	"HAVING",
+	"GROUP BY",
+	"WITH ROLLUP",
+	"WHERE",
+	"LATERAL",
+	"USING (",
+	"JOIN",
+	"INNER JOIN",
+	"CROSS JOIN",
+	"STRAIGHT_JOIN",
+	"NATURAL",
+	"NATURAL RIGHT",
+	"NATURAL LEFT",
+	"INNER",
+	"OUTER",
+	"LEFT",
+	"RIGHT",
+	"*",
+	". *",
+	"SQL_NO_CACHE",
+	"DISTINCT",
+	"SQL_SMALL_RESULT",
+	"SQL_BIG_RESULT",
+	"SQL_BUFFER_RESULT",
+	"SQL_CALC_FOUND_ROWS",
+	"ALL",
+	"WITH",
+	"WITH RECURSIVE",
+	"OR",
+	"XOR",
+	"NOT",
+	"IS TRUE",
+	"IS NOT TRUE",
+	"IS FALSE",
+	"IS NOT FALSE",
+	"IS UNKNOWN",
+	"IS NOT UNKNOWN",
+	"IS NULL",
+	"IS NOT NULL",
+	"IN (",
+	"NOT IN (",
+	"NOT BETWEEN",
+	"SOUNDS LIKE",
+	"LIKE",
+	"NOT LIKE",
+	"REGEXP",
+	"NOT REGEXP",
+	"|",
+	"&",
+	"<<",
+	">>",
+	"+",
+	"-",
+	"/",
+	"%",
+	"^",
+	"~",
+	"EXISTS",
+	"ASCII (",
+	"BIN (",
+	"BIT_LENGTH (",
+	"CHAR_LENGTH (",
+	"LENGTH (",
+	"LOWER (",
+	"LTRIM (",
+	"OCT (",
+	"ORD (",
+	"QUOTE (",
+	"REVERSE (",
+	"RTRIM (",
+	"SPACE (",
+	"TRIM(",
+	"TRIM( LEADING FROM",
+	"TRIM( TRAILING FROM",
+	"UNHEX (",
+	"UPPER (",
+	"FIND_IN_SET (",
+	"INSTR (",
+	"LEFT (",
+	"LOCATE (",
+	"REPEAT (",
+	"RIGHT (",
+	"SUBSTRING(",
+	"TRIM( LEADING",
+	"TRIM( TRAILING",
+	"EXPORT_SET (",
+	"LPAD (",
+	"REPLACE (",
+	"RPAD (",
+	"SUBSTRING_INDEX (",
+	"INSERT (",
+	"CHAR (",
+	"CONCAT (",
+	"CONCAT_WS (",
+	"ELT (",
+	"FIELD (",
+	"MAKE_SET (",
+	"PI ( )",
+	"RAND ( )",
+	"ABS (",
+	"ACOS (",
+	"ASIN (",
+	"ATAN (",
+	"CEILING (",
+	"COS (",
+	"COT (",
+	"DEGREES (",
+	"EXP (",
+	"FLOOR (",
+	"HEX (",
+	"LN (",
+	"RADIANS (",
+	"RAND (",
+	"ROUND (",
+	"SIGN (",
+	"SIN (",
+	"SQRT (",
+	"TAN (",
+	"FORMAT (",
+	"LOG (",
+	"MOD (",
+	"POW (",
+	"TRUNCATE (",
+	"CONV (",
+	"ROW_NUMBER ( )",
+	"RANK ( )",
+	"DENSE_RANK ( )",
+	"CUME_DIST ( )",
+	"PERCENT_RANK ( )",
+	"NTILE (",
+	"LEAD (",
+	"LAG (",
+	"FIRST_VALUE (",
+	"LAST_VALUE (",
+	"NTH_VALUE (",
+	"RESPECT NULLS",
+	"IGNORE NULLS",
+	"FROM FIRST",
+	"FROM LAST",
+	"AVG (",
+	"BIT_AND(",
+	"BIT_OR(",
+	"BIT_XOR(",
+	"COUNT( * )",
+	"COUNT(",
+	"COUNT( DISTINCT",
+	"MIN(",
+	"MAX(",
+	"SUM(",
+	"STD(",
+	"STDDEV_SAMP(",
+	"VARIANCE(",
+	"VAR_SAMP(",
+	"GROUP_CONCAT(",
+	"SEPARATOR",
+	"OVER",
+	"IF (",
+	"IFNULL (",
+	"NULLIF (",
+	"END",
+	"CASE",
+	"THEN",
+	"WHEN",
+	"ELSE",
+	"CAST (",
+	"CONVERT (",
+	"NCHAR",
+	"NULL",
+	"FALSE",
+	"TRUE",
+	".",
+	">=",
+	">",
+	"<=",
+	"<",
+	"!=",
+	"ANY",
+	"SOME",
+	"IN",
+	"NOT IN",
+	"ICONST",
+	"FCONST",
+	"SCONST",
+	"IDENT",
+};
+
+void deep_delete(IR * root){
+	if (!root)
+		return;
+
+	if(root->left_) deep_delete(root->left_);
+	if(root->right_) deep_delete(root->right_);
+    
+	if(root->op_) delete root->op_;
+
+	delete root;
+}
+
+IR* deep_copy(const IR* root) {
+	IR* left = NULL, * right = NULL, * copy_res;
+
+	if (root == nullptr) return nullptr;
+
+	if (root->left_) left = deep_copy(root->left_);
+	if (root->right_) right = deep_copy(root->right_);
+
+	copy_res = new IR(root, left, right);
+
+	return copy_res;
+}
+
+string IR::to_string(){
+    	auto res = to_string_core();
+    	trim_string(res);
+    	return res;
+}
+
+string IR::to_string_core(){
+	switch (type_) {
+		case kIconst: 
+			return std::to_string(long_val_) + " ";
+		case kFconst: 
+			return std::to_string(float_val_) + " ";
+		case kSconst: 
+			return str_val_ + " ";
+		case kIdent: 
+			return str_val_ + " ";
+	}
+
+	string res;
+
+	if (op_->prefix_ != tEmpty)
+		res += string(convertToTerminal[op_->prefix_]) + " ";
+	if (left_ != NULL)
+		res += left_->to_string_core();
+	if (op_->middle_ != tEmpty)
+		res += string(convertToTerminal[op_->middle_]) + " ";
+	if (right_ != NULL)
+		res += right_->to_string_core();
+	if (op_->suffix_ != tEmpty)
+		res += string(convertToTerminal[op_->suffix_]) + " ";
+
+	return res;
+}
+
+void IR::trim_string(string& res) {
+   	char preChar = 0;
+   	int count = 0;
+
+	for (int i = 0; i < res.size(); i++) {
+		if ((res[i] == ' ') && (preChar == ';'))
+			res[i] = '\n';
+
+		preChar = res[i];
+	}
+
+	return;
+}
+
+IR* ParseToplevel::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(stmtmulti_);
+	res = new IR(IRTYPE::kParseToplevel, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void ParseToplevel::deep_delete() {
+	SAFEDELETE(stmtmulti_);
+	delete this;
+}
+
+IR* Stmtmulti::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(stmt_);
+			auto tmp2 = SAFETRANSLATE(stmtmulti_);
+			res = new IR(IRTYPE::kStmtmulti, OP3(TERMINAL::tEmpty, TERMINAL::tOpSemi, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(stmt_);
+			res = new IR(IRTYPE::kStmtmulti, OP3(TERMINAL::tEmpty, TERMINAL::tOpSemi, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Stmtmulti::deep_delete() {
+	SAFEDELETE(stmtmulti_);
+	SAFEDELETE(stmt_);
+	delete this;
+}
+
+IR* Stmt::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(create_table_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(create_view_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(create_index_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(select_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(drop_index_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(drop_table_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(drop_view_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(delete_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(update_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(insert_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(alter_table_stmt_);
+			res = new IR(IRTYPE::kStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Stmt::deep_delete() {
+	SAFEDELETE(create_table_stmt_);
+	SAFEDELETE(create_view_stmt_);
+	SAFEDELETE(create_index_stmt_);
+	SAFEDELETE(select_stmt_);
+	SAFEDELETE(drop_index_stmt_);
+	SAFEDELETE(drop_table_stmt_);
+	SAFEDELETE(drop_view_stmt_);
+	SAFEDELETE(delete_stmt_);
+	SAFEDELETE(update_stmt_);
+	SAFEDELETE(insert_stmt_);
+	SAFEDELETE(alter_table_stmt_);
+	delete this;
+}
+
+IR* DeleteStmt::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(opt_with_clause_);
+			auto tmp2 = SAFETRANSLATE(opt_delete_options_);
+			auto tmp3 = SAFETRANSLATE(table_name_);
+			auto tmp4 = SAFETRANSLATE(opt_alias_);
+			auto tmp5 = SAFETRANSLATE(opt_where_clause_);
+			auto tmp6 = SAFETRANSLATE(opt_order_clause_);
+			auto tmp7 = SAFETRANSLATE(opt_simple_limit_);
+			auto tmp8 = new IR(IRTYPE::kDeleteStmtTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp6, tmp7);
+			auto tmp9 = new IR(IRTYPE::kDeleteStmtTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp5, tmp8);
+			auto tmp10 = new IR(IRTYPE::kDeleteStmtTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp4, tmp9);
+			auto tmp11 = new IR(IRTYPE::kDeleteStmtTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp10);
+			auto tmp12 = new IR(IRTYPE::kDeleteStmtTmp5, OP3(TERMINAL::tEmpty, TERMINAL::tFrom, TERMINAL::tEmpty), tmp2, tmp11);
+			res = new IR(IRTYPE::kDeleteStmt, OP3(TERMINAL::tEmpty, TERMINAL::tDelete, TERMINAL::tEmpty), tmp1, tmp12);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(opt_with_clause_);
+			auto tmp2 = SAFETRANSLATE(opt_delete_options_);
+			auto tmp3 = SAFETRANSLATE(table_list_);
+			auto tmp4 = SAFETRANSLATE(table_reference_list_);
+			auto tmp5 = SAFETRANSLATE(opt_where_clause_);
+			auto tmp6 = new IR(IRTYPE::kDeleteStmtTmp6, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp4, tmp5);
+			auto tmp7 = new IR(IRTYPE::kDeleteStmtTmp7, OP3(TERMINAL::tEmpty, TERMINAL::tFrom, TERMINAL::tEmpty), tmp3, tmp6);
+			auto tmp8 = new IR(IRTYPE::kDeleteStmtTmp8, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp7);
+			res = new IR(IRTYPE::kDeleteStmt, OP3(TERMINAL::tEmpty, TERMINAL::tDelete, TERMINAL::tEmpty), tmp1, tmp8);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void DeleteStmt::deep_delete() {
+	SAFEDELETE(opt_simple_limit_);
+	SAFEDELETE(opt_order_clause_);
+	SAFEDELETE(opt_where_clause_);
+	SAFEDELETE(opt_alias_);
+	SAFEDELETE(table_name_);
+	SAFEDELETE(opt_delete_options_);
+	SAFEDELETE(opt_with_clause_);
+	SAFEDELETE(table_reference_list_);
+	SAFEDELETE(table_list_);
+	delete this;
+}
+
+IR* OptDeleteOptions::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptDeleteOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(delete_options_);
+			res = new IR(IRTYPE::kOptDeleteOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptDeleteOptions::deep_delete() {
+	SAFEDELETE(delete_options_);
+	delete this;
+}
+
+IR* DeleteOptions::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(delete_option_);
+			res = new IR(IRTYPE::kDeleteOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(delete_option_);
+			auto tmp2 = SAFETRANSLATE(delete_options_);
+			res = new IR(IRTYPE::kDeleteOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void DeleteOptions::deep_delete() {
+	SAFEDELETE(delete_option_);
+	SAFEDELETE(delete_options_);
+	delete this;
+}
+
+IR* DeleteOption::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kDeleteOption, OP3(TERMINAL::tQuick, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kDeleteOption, OP3(TERMINAL::tLowPriority, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kDeleteOption, OP3(TERMINAL::tIgnore, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void DeleteOption::deep_delete() {
+	delete this;
+}
+
+IR* AlterTableStmt::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(table_name_);
+	auto tmp2 = SAFETRANSLATE(alter_list_);
+	res = new IR(IRTYPE::kAlterTableStmt, OP3(TERMINAL::tAlterTable, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void AlterTableStmt::deep_delete() {
+	SAFEDELETE(alter_list_);
+	SAFEDELETE(table_name_);
+	delete this;
+}
+
+IR* AlterList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(alter_list_item_);
+			res = new IR(IRTYPE::kAlterList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(alter_list_item_);
+			auto tmp2 = SAFETRANSLATE(alter_list_);
+			res = new IR(IRTYPE::kAlterList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void AlterList::deep_delete() {
+	SAFEDELETE(alter_list_item_);
+	SAFEDELETE(alter_list_);
+	delete this;
+}
+
+IR* AlterListItem::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(column_name_1_);
+			auto tmp2 = SAFETRANSLATE(field_def_);
+			auto tmp3 = SAFETRANSLATE(opt_place_);
+			auto tmp4 = new IR(IRTYPE::kAlterListItemTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tAddColumn, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_element_list_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tAddColumnOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(table_constraint_def_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tAdd, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(column_name_1_);
+			auto tmp2 = SAFETRANSLATE(column_name_2_);
+			auto tmp3 = SAFETRANSLATE(field_def_);
+			auto tmp4 = SAFETRANSLATE(opt_place_);
+			auto tmp5 = new IR(IRTYPE::kAlterListItemTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kAlterListItemTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tChangeColumn, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(column_name_1_);
+			auto tmp2 = SAFETRANSLATE(field_def_);
+			auto tmp3 = SAFETRANSLATE(opt_place_);
+			auto tmp4 = new IR(IRTYPE::kAlterListItemTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tModifyColumn, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(column_name_1_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tDropColumn, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(constraint_name_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tDropForeignKey, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(7)
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tDropPrimaryKey, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(index_name_1_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tDropIndex, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(constraint_name_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tDropCheck, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(constraint_name_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tDropConstraint, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(11)
+			auto tmp1 = SAFETRANSLATE(column_name_1_);
+			auto tmp2 = SAFETRANSLATE(expr_root_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tAlterColumn, TERMINAL::tSetDefaultOpLp, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(12)
+			auto tmp1 = SAFETRANSLATE(column_name_1_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tAlterColumn, TERMINAL::tDropDefault, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(13)
+			auto tmp1 = SAFETRANSLATE(column_name_1_);
+			auto tmp2 = SAFETRANSLATE(visibility_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tAlterColumn, TERMINAL::tSet, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(14)
+			auto tmp1 = SAFETRANSLATE(index_name_1_);
+			auto tmp2 = SAFETRANSLATE(visibility_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tAlterIndex, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(15)
+			auto tmp1 = SAFETRANSLATE(table_name_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tRenameTo, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(16)
+			auto tmp1 = SAFETRANSLATE(index_name_1_);
+			auto tmp2 = SAFETRANSLATE(index_name_2_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tRenameIndex, TERMINAL::tTo, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(17)
+			auto tmp1 = SAFETRANSLATE(column_name_1_);
+			auto tmp2 = SAFETRANSLATE(column_name_2_);
+			res = new IR(IRTYPE::kAlterListItem, OP3(TERMINAL::tRenameColumn, TERMINAL::tTo, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void AlterListItem::deep_delete() {
+	SAFEDELETE(opt_place_);
+	SAFEDELETE(field_def_);
+	SAFEDELETE(column_name_1_);
+	SAFEDELETE(column_name_2_);
+	SAFEDELETE(table_element_list_);
+	SAFEDELETE(table_constraint_def_);
+	SAFEDELETE(constraint_name_);
+	SAFEDELETE(index_name_1_);
+	SAFEDELETE(index_name_2_);
+	SAFEDELETE(expr_root_);
+	SAFEDELETE(visibility_);
+	SAFEDELETE(table_name_);
+	delete this;
+}
+
+IR* OptPlace::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptPlace, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(column_name_);
+			res = new IR(IRTYPE::kOptPlace, OP3(TERMINAL::tAfter, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kOptPlace, OP3(TERMINAL::tFirst, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptPlace::deep_delete() {
+	SAFEDELETE(column_name_);
+	delete this;
+}
+
+IR* DropIndexStmt::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(index_name_);
+	auto tmp2 = SAFETRANSLATE(table_name_);
+	res = new IR(IRTYPE::kDropIndexStmt, OP3(TERMINAL::tDropIndex, TERMINAL::tOn, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void DropIndexStmt::deep_delete() {
+	SAFEDELETE(table_name_);
+	SAFEDELETE(index_name_);
+	delete this;
+}
+
+IR* DropTableStmt::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(if_exists_);
+	auto tmp2 = SAFETRANSLATE(table_list_);
+	res = new IR(IRTYPE::kDropTableStmt, OP3(TERMINAL::tDropTable, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void DropTableStmt::deep_delete() {
+	SAFEDELETE(table_list_);
+	SAFEDELETE(if_exists_);
+	delete this;
+}
+
+IR* IfExists::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kIfExists, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kIfExists, OP3(TERMINAL::tIfExists, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void IfExists::deep_delete() {
+	delete this;
+}
+
+IR* TableList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(table_name_);
+			res = new IR(IRTYPE::kTableList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_name_);
+			auto tmp2 = SAFETRANSLATE(table_list_);
+			res = new IR(IRTYPE::kTableList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TableList::deep_delete() {
+	SAFEDELETE(table_name_);
+	SAFEDELETE(table_list_);
+	delete this;
+}
+
+IR* DropViewStmt::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(if_exists_);
+	auto tmp2 = SAFETRANSLATE(table_list_);
+	res = new IR(IRTYPE::kDropViewStmt, OP3(TERMINAL::tDropView, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void DropViewStmt::deep_delete() {
+	SAFEDELETE(table_list_);
+	SAFEDELETE(if_exists_);
+	delete this;
+}
+
+IR* UpdateStmt::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(opt_with_clause_);
+	auto tmp2 = SAFETRANSLATE(opt_low_priority_);
+	auto tmp3 = SAFETRANSLATE(opt_ignore_);
+	auto tmp4 = SAFETRANSLATE(table_reference_list_);
+	auto tmp5 = SAFETRANSLATE(update_list_);
+	auto tmp6 = SAFETRANSLATE(opt_where_clause_);
+	auto tmp7 = SAFETRANSLATE(opt_order_clause_);
+	auto tmp8 = SAFETRANSLATE(opt_simple_limit_);
+	auto tmp9 = new IR(IRTYPE::kUpdateStmtTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp7, tmp8);
+	auto tmp10 = new IR(IRTYPE::kUpdateStmtTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp6, tmp9);
+	auto tmp11 = new IR(IRTYPE::kUpdateStmtTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp5, tmp10);
+	auto tmp12 = new IR(IRTYPE::kUpdateStmtTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tSet, TERMINAL::tEmpty), tmp4, tmp11);
+	auto tmp13 = new IR(IRTYPE::kUpdateStmtTmp5, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp12);
+	auto tmp14 = new IR(IRTYPE::kUpdateStmtTmp6, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp13);
+	res = new IR(IRTYPE::kUpdateStmt, OP3(TERMINAL::tEmpty, TERMINAL::tUpdate, TERMINAL::tEmpty), tmp1, tmp14);
+
+	TRANSLATEEND
+}
+
+void UpdateStmt::deep_delete() {
+	SAFEDELETE(opt_simple_limit_);
+	SAFEDELETE(opt_order_clause_);
+	SAFEDELETE(opt_where_clause_);
+	SAFEDELETE(update_list_);
+	SAFEDELETE(table_reference_list_);
+	SAFEDELETE(opt_ignore_);
+	SAFEDELETE(opt_low_priority_);
+	SAFEDELETE(opt_with_clause_);
+	delete this;
+}
+
+IR* OptSimpleLimit::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptSimpleLimit, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(iconst_);
+			res = new IR(IRTYPE::kOptSimpleLimit, OP3(TERMINAL::tLimit, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptSimpleLimit::deep_delete() {
+	SAFEDELETE(iconst_);
+	delete this;
+}
+
+IR* OptWithClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptWithClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(with_clause_);
+			res = new IR(IRTYPE::kOptWithClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptWithClause::deep_delete() {
+	SAFEDELETE(with_clause_);
+	delete this;
+}
+
+IR* OptLowPriority::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptLowPriority, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptLowPriority, OP3(TERMINAL::tLowPriority, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptLowPriority::deep_delete() {
+	delete this;
+}
+
+IR* InsertStmt::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(insert_lock_option_);
+			auto tmp2 = SAFETRANSLATE(opt_ignore_);
+			auto tmp3 = SAFETRANSLATE(table_name_);
+			auto tmp4 = SAFETRANSLATE(insert_from_constructor_);
+			auto tmp5 = SAFETRANSLATE(opt_values_reference_);
+			auto tmp6 = SAFETRANSLATE(opt_insert_update_list_);
+			auto tmp7 = new IR(IRTYPE::kInsertStmtTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp5, tmp6);
+			auto tmp8 = new IR(IRTYPE::kInsertStmtTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp4, tmp7);
+			auto tmp9 = new IR(IRTYPE::kInsertStmtTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp8);
+			auto tmp10 = new IR(IRTYPE::kInsertStmtTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tInto, TERMINAL::tEmpty), tmp2, tmp9);
+			res = new IR(IRTYPE::kInsertStmt, OP3(TERMINAL::tInsert, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp10);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(insert_lock_option_);
+			auto tmp2 = SAFETRANSLATE(opt_ignore_);
+			auto tmp3 = SAFETRANSLATE(table_name_);
+			auto tmp4 = SAFETRANSLATE(update_list_);
+			auto tmp5 = SAFETRANSLATE(opt_values_reference_);
+			auto tmp6 = SAFETRANSLATE(opt_insert_update_list_);
+			auto tmp7 = new IR(IRTYPE::kInsertStmtTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp5, tmp6);
+			auto tmp8 = new IR(IRTYPE::kInsertStmtTmp5, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp4, tmp7);
+			auto tmp9 = new IR(IRTYPE::kInsertStmtTmp6, OP3(TERMINAL::tEmpty, TERMINAL::tSet, TERMINAL::tEmpty), tmp3, tmp8);
+			auto tmp10 = new IR(IRTYPE::kInsertStmtTmp7, OP3(TERMINAL::tEmpty, TERMINAL::tInto, TERMINAL::tEmpty), tmp2, tmp9);
+			res = new IR(IRTYPE::kInsertStmt, OP3(TERMINAL::tInsert, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp10);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(insert_lock_option_);
+			auto tmp2 = SAFETRANSLATE(opt_ignore_);
+			auto tmp3 = SAFETRANSLATE(table_name_);
+			auto tmp4 = SAFETRANSLATE(insert_query_expression_);
+			auto tmp5 = SAFETRANSLATE(opt_insert_update_list_);
+			auto tmp6 = new IR(IRTYPE::kInsertStmtTmp8, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp4, tmp5);
+			auto tmp7 = new IR(IRTYPE::kInsertStmtTmp9, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp6);
+			auto tmp8 = new IR(IRTYPE::kInsertStmtTmp10, OP3(TERMINAL::tEmpty, TERMINAL::tInto, TERMINAL::tEmpty), tmp2, tmp7);
+			res = new IR(IRTYPE::kInsertStmt, OP3(TERMINAL::tInsert, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp8);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void InsertStmt::deep_delete() {
+	SAFEDELETE(opt_insert_update_list_);
+	SAFEDELETE(opt_values_reference_);
+	SAFEDELETE(insert_from_constructor_);
+	SAFEDELETE(table_name_);
+	SAFEDELETE(opt_ignore_);
+	SAFEDELETE(insert_lock_option_);
+	SAFEDELETE(update_list_);
+	SAFEDELETE(insert_query_expression_);
+	delete this;
+}
+
+IR* InsertQueryExpression::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(query_expression_);
+			res = new IR(IRTYPE::kInsertQueryExpression, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(column_list_);
+			auto tmp2 = SAFETRANSLATE(query_expression_);
+			res = new IR(IRTYPE::kInsertQueryExpression, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void InsertQueryExpression::deep_delete() {
+	SAFEDELETE(query_expression_);
+	SAFEDELETE(column_list_);
+	delete this;
+}
+
+IR* InsertFromConstructor::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(values_list_);
+			res = new IR(IRTYPE::kInsertFromConstructor, OP3(TERMINAL::tValues, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(column_list_);
+			auto tmp2 = SAFETRANSLATE(values_list_);
+			res = new IR(IRTYPE::kInsertFromConstructor, OP3(TERMINAL::tOpLp, TERMINAL::tOpRpValues, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void InsertFromConstructor::deep_delete() {
+	SAFEDELETE(values_list_);
+	SAFEDELETE(column_list_);
+	delete this;
+}
+
+IR* ValuesList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(row_value_);
+			res = new IR(IRTYPE::kValuesList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(row_value_);
+			auto tmp2 = SAFETRANSLATE(values_list_);
+			res = new IR(IRTYPE::kValuesList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ValuesList::deep_delete() {
+	SAFEDELETE(row_value_);
+	SAFEDELETE(values_list_);
+	delete this;
+}
+
+IR* RowValue::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(opt_values_);
+	res = new IR(IRTYPE::kRowValue, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void RowValue::deep_delete() {
+	SAFEDELETE(opt_values_);
+	delete this;
+}
+
+IR* OptValues::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptValues, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(values_);
+			res = new IR(IRTYPE::kOptValues, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptValues::deep_delete() {
+	SAFEDELETE(values_);
+	delete this;
+}
+
+IR* Values::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(expr_or_default_);
+			res = new IR(IRTYPE::kValues, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_or_default_);
+			auto tmp2 = SAFETRANSLATE(values_);
+			res = new IR(IRTYPE::kValues, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Values::deep_delete() {
+	SAFEDELETE(expr_or_default_);
+	SAFEDELETE(values_);
+	delete this;
+}
+
+IR* ExprOrDefault::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(expr_root_);
+			res = new IR(IRTYPE::kExprOrDefault, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kExprOrDefault, OP3(TERMINAL::tDefault, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ExprOrDefault::deep_delete() {
+	SAFEDELETE(expr_root_);
+	delete this;
+}
+
+IR* OptValuesReference::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptValuesReference, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_name_);
+			auto tmp2 = SAFETRANSLATE(opt_column_list_);
+			res = new IR(IRTYPE::kOptValuesReference, OP3(TERMINAL::tAs, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptValuesReference::deep_delete() {
+	SAFEDELETE(opt_column_list_);
+	SAFEDELETE(table_name_);
+	delete this;
+}
+
+IR* OptInsertUpdateList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptInsertUpdateList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(update_list_);
+			res = new IR(IRTYPE::kOptInsertUpdateList, OP3(TERMINAL::tOnDuplicateKeyUpdate, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptInsertUpdateList::deep_delete() {
+	SAFEDELETE(update_list_);
+	delete this;
+}
+
+IR* UpdateList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(update_elem_);
+			res = new IR(IRTYPE::kUpdateList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(update_elem_);
+			auto tmp2 = SAFETRANSLATE(update_list_);
+			res = new IR(IRTYPE::kUpdateList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void UpdateList::deep_delete() {
+	SAFEDELETE(update_elem_);
+	SAFEDELETE(update_list_);
+	delete this;
+}
+
+IR* UpdateElem::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(columnref_);
+	auto tmp2 = SAFETRANSLATE(expr_or_default_);
+	res = new IR(IRTYPE::kUpdateElem, OP3(TERMINAL::tEmpty, TERMINAL::tOpEqual, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void UpdateElem::deep_delete() {
+	SAFEDELETE(expr_or_default_);
+	SAFEDELETE(columnref_);
+	delete this;
+}
+
+IR* InsertLockOption::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kInsertLockOption, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kInsertLockOption, OP3(TERMINAL::tLowPriority, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kInsertLockOption, OP3(TERMINAL::tDelayed, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kInsertLockOption, OP3(TERMINAL::tHighPriority, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void InsertLockOption::deep_delete() {
+	delete this;
+}
+
+IR* OptIgnore::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptIgnore, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptIgnore, OP3(TERMINAL::tIgnore, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptIgnore::deep_delete() {
+	delete this;
+}
+
+IR* CreateIndexStmt::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(opt_unique_);
+	auto tmp2 = SAFETRANSLATE(index_name_);
+	auto tmp3 = SAFETRANSLATE(table_name_);
+	auto tmp4 = SAFETRANSLATE(key_list_with_expression_);
+	auto tmp5 = new IR(IRTYPE::kCreateIndexStmtTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpLp, TERMINAL::tOpRp), tmp3, tmp4);
+	auto tmp6 = new IR(IRTYPE::kCreateIndexStmtTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tOn, TERMINAL::tEmpty), tmp2, tmp5);
+	res = new IR(IRTYPE::kCreateIndexStmt, OP3(TERMINAL::tCreate, TERMINAL::tIndex, TERMINAL::tEmpty), tmp1, tmp6);
+
+	TRANSLATEEND
+}
+
+void CreateIndexStmt::deep_delete() {
+	SAFEDELETE(key_list_with_expression_);
+	SAFEDELETE(table_name_);
+	SAFEDELETE(index_name_);
+	SAFEDELETE(opt_unique_);
+	delete this;
+}
+
+IR* OptUnique::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptUnique, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptUnique, OP3(TERMINAL::tUnique, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptUnique::deep_delete() {
+	delete this;
+}
+
+IR* CreateViewStmt::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(opt_or_replace_);
+	auto tmp2 = SAFETRANSLATE(opt_view_algorithm_);
+	auto tmp3 = SAFETRANSLATE(view_name_);
+	auto tmp4 = SAFETRANSLATE(opt_column_list_);
+	auto tmp5 = SAFETRANSLATE(query_expression_);
+	auto tmp6 = new IR(IRTYPE::kCreateViewStmtTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tAs, TERMINAL::tEmpty), tmp4, tmp5);
+	auto tmp7 = new IR(IRTYPE::kCreateViewStmtTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp6);
+	auto tmp8 = new IR(IRTYPE::kCreateViewStmtTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tView, TERMINAL::tEmpty), tmp2, tmp7);
+	res = new IR(IRTYPE::kCreateViewStmt, OP3(TERMINAL::tCreate, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp8);
+
+	TRANSLATEEND
+}
+
+void CreateViewStmt::deep_delete() {
+	SAFEDELETE(query_expression_);
+	SAFEDELETE(opt_column_list_);
+	SAFEDELETE(view_name_);
+	SAFEDELETE(opt_view_algorithm_);
+	SAFEDELETE(opt_or_replace_);
+	delete this;
+}
+
+IR* OptOrReplace::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptOrReplace, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptOrReplace, OP3(TERMINAL::tOrReplace, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptOrReplace::deep_delete() {
+	delete this;
+}
+
+IR* OptViewAlgorithm::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptViewAlgorithm, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptViewAlgorithm, OP3(TERMINAL::tAlgorithmOpEqualUndefined, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kOptViewAlgorithm, OP3(TERMINAL::tAlgorithmOpEqualMerge, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kOptViewAlgorithm, OP3(TERMINAL::tAlgorithmOpEqualTemptable, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptViewAlgorithm::deep_delete() {
+	delete this;
+}
+
+IR* CreateTableStmt::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(opt_temporary_);
+			auto tmp2 = SAFETRANSLATE(opt_if_not_exists_);
+			auto tmp3 = SAFETRANSLATE(table_name_);
+			auto tmp4 = SAFETRANSLATE(table_element_list_);
+			auto tmp5 = SAFETRANSLATE(opt_duplicate_as_qe_);
+			auto tmp6 = new IR(IRTYPE::kCreateTableStmtTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp4, tmp5);
+			auto tmp7 = new IR(IRTYPE::kCreateTableStmtTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tOpLp, TERMINAL::tEmpty), tmp3, tmp6);
+			auto tmp8 = new IR(IRTYPE::kCreateTableStmtTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp7);
+			res = new IR(IRTYPE::kCreateTableStmt, OP3(TERMINAL::tCreate, TERMINAL::tTable, TERMINAL::tEmpty), tmp1, tmp8);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(opt_temporary_);
+			auto tmp2 = SAFETRANSLATE(opt_if_not_exists_);
+			auto tmp3 = SAFETRANSLATE(table_name_);
+			auto tmp4 = SAFETRANSLATE(duplicate_as_qe_);
+			auto tmp5 = new IR(IRTYPE::kCreateTableStmtTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kCreateTableStmtTmp5, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kCreateTableStmt, OP3(TERMINAL::tCreate, TERMINAL::tTable, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void CreateTableStmt::deep_delete() {
+	SAFEDELETE(opt_duplicate_as_qe_);
+	SAFEDELETE(table_element_list_);
+	SAFEDELETE(table_name_);
+	SAFEDELETE(opt_if_not_exists_);
+	SAFEDELETE(opt_temporary_);
+	SAFEDELETE(duplicate_as_qe_);
+	delete this;
+}
+
+IR* OptTemporary::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptTemporary, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptTemporary, OP3(TERMINAL::tTemporary, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptTemporary::deep_delete() {
+	delete this;
+}
+
+IR* OptIfNotExists::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptIfNotExists, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptIfNotExists, OP3(TERMINAL::tIfNotExists, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptIfNotExists::deep_delete() {
+	delete this;
+}
+
+IR* OptDuplicateAsQe::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptDuplicateAsQe, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(duplicate_as_qe_);
+			res = new IR(IRTYPE::kOptDuplicateAsQe, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptDuplicateAsQe::deep_delete() {
+	SAFEDELETE(duplicate_as_qe_);
+	delete this;
+}
+
+IR* DuplicateAsQe::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(duplicate_);
+			auto tmp2 = SAFETRANSLATE(query_expression_);
+			res = new IR(IRTYPE::kDuplicateAsQe, OP3(TERMINAL::tEmpty, TERMINAL::tAs, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(query_expression_);
+			res = new IR(IRTYPE::kDuplicateAsQe, OP3(TERMINAL::tAs, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void DuplicateAsQe::deep_delete() {
+	SAFEDELETE(query_expression_);
+	SAFEDELETE(duplicate_);
+	delete this;
+}
+
+IR* Duplicate::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kDuplicate, OP3(TERMINAL::tReplace, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kDuplicate, OP3(TERMINAL::tIgnore, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Duplicate::deep_delete() {
+	delete this;
+}
+
+IR* TableElementList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(table_element_);
+			res = new IR(IRTYPE::kTableElementList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_element_);
+			auto tmp2 = SAFETRANSLATE(table_element_list_);
+			res = new IR(IRTYPE::kTableElementList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TableElementList::deep_delete() {
+	SAFEDELETE(table_element_);
+	SAFEDELETE(table_element_list_);
+	delete this;
+}
+
+IR* TableElement::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(column_def_);
+			res = new IR(IRTYPE::kTableElement, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_constraint_def_);
+			res = new IR(IRTYPE::kTableElement, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TableElement::deep_delete() {
+	SAFEDELETE(column_def_);
+	SAFEDELETE(table_constraint_def_);
+	delete this;
+}
+
+IR* ColumnDef::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(column_name_);
+	auto tmp2 = SAFETRANSLATE(field_def_);
+	res = new IR(IRTYPE::kColumnDef, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void ColumnDef::deep_delete() {
+	SAFEDELETE(field_def_);
+	SAFEDELETE(column_name_);
+	delete this;
+}
+
+IR* FieldDef::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(data_type_);
+	auto tmp2 = SAFETRANSLATE(opt_column_attribute_list_);
+	res = new IR(IRTYPE::kFieldDef, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void FieldDef::deep_delete() {
+	SAFEDELETE(opt_column_attribute_list_);
+	SAFEDELETE(data_type_);
+	delete this;
+}
+
+IR* DataType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(number_type_);
+			res = new IR(IRTYPE::kDataType, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(bool_type_);
+			res = new IR(IRTYPE::kDataType, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(string_type_);
+			res = new IR(IRTYPE::kDataType, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void DataType::deep_delete() {
+	SAFEDELETE(number_type_);
+	SAFEDELETE(bool_type_);
+	SAFEDELETE(string_type_);
+	delete this;
+}
+
+IR* StringType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(opt_field_length_);
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tChar, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(opt_field_length_);
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tBinary, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(field_length_);
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tVarchar, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(field_length_);
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tVarbinary, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(4)
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tLongVarbinary, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(5)
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tTinyblob, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(6)
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tMediumblob, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(7)
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tLongblob, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(opt_field_length_);
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tBlob, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(9)
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tTinytext, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(10)
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tMediumtext, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(11)
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tLongtext, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(12)
+			res = new IR(IRTYPE::kStringType, OP3(TERMINAL::tText, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void StringType::deep_delete() {
+	SAFEDELETE(opt_field_length_);
+	SAFEDELETE(field_length_);
+	delete this;
+}
+
+IR* BoolType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kBoolType, OP3(TERMINAL::tBool, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kBoolType, OP3(TERMINAL::tBoolean, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void BoolType::deep_delete() {
+	delete this;
+}
+
+IR* NumberType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(int_type_);
+			auto tmp2 = SAFETRANSLATE(opt_field_options_);
+			res = new IR(IRTYPE::kNumberType, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(real_type_);
+			auto tmp2 = SAFETRANSLATE(opt_precision_);
+			auto tmp3 = SAFETRANSLATE(opt_field_options_);
+			auto tmp4 = new IR(IRTYPE::kNumberTypeTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kNumberType, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(numeric_type_);
+			auto tmp2 = SAFETRANSLATE(float_options_);
+			auto tmp3 = SAFETRANSLATE(opt_field_options_);
+			auto tmp4 = new IR(IRTYPE::kNumberTypeTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kNumberType, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void NumberType::deep_delete() {
+	SAFEDELETE(opt_field_options_);
+	SAFEDELETE(int_type_);
+	SAFEDELETE(opt_precision_);
+	SAFEDELETE(real_type_);
+	SAFEDELETE(float_options_);
+	SAFEDELETE(numeric_type_);
+	delete this;
+}
+
+IR* NumericType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kNumericType, OP3(TERMINAL::tFloat, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kNumericType, OP3(TERMINAL::tDecimal, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kNumericType, OP3(TERMINAL::tNumeric, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kNumericType, OP3(TERMINAL::tFixed, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void NumericType::deep_delete() {
+	delete this;
+}
+
+IR* RealType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kRealType, OP3(TERMINAL::tReal, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kRealType, OP3(TERMINAL::tDouble, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void RealType::deep_delete() {
+	delete this;
+}
+
+IR* OptPrecision::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptPrecision, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(precision_);
+			res = new IR(IRTYPE::kOptPrecision, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptPrecision::deep_delete() {
+	SAFEDELETE(precision_);
+	delete this;
+}
+
+IR* IntType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kIntType, OP3(TERMINAL::tInt, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kIntType, OP3(TERMINAL::tTinyint, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kIntType, OP3(TERMINAL::tSmallint, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kIntType, OP3(TERMINAL::tMediumint, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(4)
+			res = new IR(IRTYPE::kIntType, OP3(TERMINAL::tBigint, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void IntType::deep_delete() {
+	delete this;
+}
+
+IR* OptFieldOptions::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptFieldOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(field_option_list_);
+			res = new IR(IRTYPE::kOptFieldOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptFieldOptions::deep_delete() {
+	SAFEDELETE(field_option_list_);
+	delete this;
+}
+
+IR* FieldOptionList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(field_option_);
+			res = new IR(IRTYPE::kFieldOptionList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(field_option_);
+			auto tmp2 = SAFETRANSLATE(field_option_list_);
+			res = new IR(IRTYPE::kFieldOptionList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void FieldOptionList::deep_delete() {
+	SAFEDELETE(field_option_);
+	SAFEDELETE(field_option_list_);
+	delete this;
+}
+
+IR* FieldOption::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kFieldOption, OP3(TERMINAL::tSigned, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kFieldOption, OP3(TERMINAL::tUnsigned, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kFieldOption, OP3(TERMINAL::tZerofill, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void FieldOption::deep_delete() {
+	delete this;
+}
+
+IR* OptColumnAttributeList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptColumnAttributeList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(column_attribute_list_);
+			res = new IR(IRTYPE::kOptColumnAttributeList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptColumnAttributeList::deep_delete() {
+	SAFEDELETE(column_attribute_list_);
+	delete this;
+}
+
+IR* ColumnAttributeList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(column_attribute_);
+			res = new IR(IRTYPE::kColumnAttributeList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(column_attribute_);
+			auto tmp2 = SAFETRANSLATE(column_attribute_list_);
+			res = new IR(IRTYPE::kColumnAttributeList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ColumnAttributeList::deep_delete() {
+	SAFEDELETE(column_attribute_);
+	SAFEDELETE(column_attribute_list_);
+	delete this;
+}
+
+IR* ColumnAttribute::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(not_null_);
+			res = new IR(IRTYPE::kColumnAttribute, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(default_attribute_);
+			res = new IR(IRTYPE::kColumnAttribute, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(visibility_);
+			res = new IR(IRTYPE::kColumnAttribute, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ColumnAttribute::deep_delete() {
+	SAFEDELETE(not_null_);
+	SAFEDELETE(default_attribute_);
+	SAFEDELETE(visibility_);
+	delete this;
+}
+
+IR* DefaultAttribute::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(expr_root_);
+	res = new IR(IRTYPE::kDefaultAttribute, OP3(TERMINAL::tDefaultOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void DefaultAttribute::deep_delete() {
+	SAFEDELETE(expr_root_);
+	delete this;
+}
+
+IR* NotNull::translate() {
+	TRANSLATESTART
+
+	res = new IR(IRTYPE::kNotNull, OP3(TERMINAL::tNotNull, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+
+	TRANSLATEEND
+}
+
+void NotNull::deep_delete() {
+	delete this;
+}
+
+IR* Visibility::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kVisibility, OP3(TERMINAL::tVisible, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kVisibility, OP3(TERMINAL::tInvisible, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Visibility::deep_delete() {
+	delete this;
+}
+
+IR* OptConstraintName::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptConstraintName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(constraint_name_);
+			res = new IR(IRTYPE::kOptConstraintName, OP3(TERMINAL::tConstraint, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptConstraintName::deep_delete() {
+	SAFEDELETE(constraint_name_);
+	delete this;
+}
+
+IR* CheckConstraint::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(expr_root_);
+	res = new IR(IRTYPE::kCheckConstraint, OP3(TERMINAL::tCheckOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void CheckConstraint::deep_delete() {
+	SAFEDELETE(expr_root_);
+	delete this;
+}
+
+IR* TableConstraintDef::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(opt_index_name_);
+			auto tmp2 = SAFETRANSLATE(key_list_with_expression_);
+			res = new IR(IRTYPE::kTableConstraintDef, OP3(TERMINAL::tIndex, TERMINAL::tOpLp, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(opt_constraint_name_);
+			auto tmp2 = SAFETRANSLATE(constraint_key_type_);
+			auto tmp3 = SAFETRANSLATE(opt_index_name_);
+			auto tmp4 = SAFETRANSLATE(key_list_with_expression_);
+			auto tmp5 = new IR(IRTYPE::kTableConstraintDefTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpLp, TERMINAL::tOpRp), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kTableConstraintDefTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kTableConstraintDef, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(opt_constraint_name_);
+			auto tmp2 = SAFETRANSLATE(check_constraint_);
+			res = new IR(IRTYPE::kTableConstraintDef, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(opt_constraint_name_);
+			auto tmp2 = SAFETRANSLATE(opt_index_name_);
+			auto tmp3 = SAFETRANSLATE(key_list_);
+			auto tmp4 = SAFETRANSLATE(references_);
+			auto tmp5 = new IR(IRTYPE::kTableConstraintDefTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kTableConstraintDefTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tOpLp, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kTableConstraintDef, OP3(TERMINAL::tEmpty, TERMINAL::tForeignKey, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TableConstraintDef::deep_delete() {
+	SAFEDELETE(key_list_with_expression_);
+	SAFEDELETE(opt_index_name_);
+	SAFEDELETE(constraint_key_type_);
+	SAFEDELETE(opt_constraint_name_);
+	SAFEDELETE(check_constraint_);
+	SAFEDELETE(references_);
+	SAFEDELETE(key_list_);
+	delete this;
+}
+
+IR* References::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(table_name_);
+	auto tmp2 = SAFETRANSLATE(column_list_);
+	auto tmp3 = SAFETRANSLATE(opt_on_update_delete_);
+	auto tmp4 = new IR(IRTYPE::kReferencesTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp3);
+	res = new IR(IRTYPE::kReferences, OP3(TERMINAL::tReferences, TERMINAL::tOpLp, TERMINAL::tEmpty), tmp1, tmp4);
+
+	TRANSLATEEND
+}
+
+void References::deep_delete() {
+	SAFEDELETE(opt_on_update_delete_);
+	SAFEDELETE(column_list_);
+	SAFEDELETE(table_name_);
+	delete this;
+}
+
+IR* OptOnUpdateDelete::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptOnUpdateDelete, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(on_update_option_1_);
+			res = new IR(IRTYPE::kOptOnUpdateDelete, OP3(TERMINAL::tOnUpdate, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(on_update_option_1_);
+			res = new IR(IRTYPE::kOptOnUpdateDelete, OP3(TERMINAL::tOnDelete, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(on_update_option_1_);
+			auto tmp2 = SAFETRANSLATE(on_update_option_2_);
+			res = new IR(IRTYPE::kOptOnUpdateDelete, OP3(TERMINAL::tOnUpdate, TERMINAL::tOnDelete, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(on_update_option_1_);
+			auto tmp2 = SAFETRANSLATE(on_update_option_2_);
+			res = new IR(IRTYPE::kOptOnUpdateDelete, OP3(TERMINAL::tOnDelete, TERMINAL::tOnUpdate, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptOnUpdateDelete::deep_delete() {
+	SAFEDELETE(on_update_option_1_);
+	SAFEDELETE(on_update_option_2_);
+	delete this;
+}
+
+IR* OnUpdateOption::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOnUpdateOption, OP3(TERMINAL::tCascade, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOnUpdateOption, OP3(TERMINAL::tSetNull, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kOnUpdateOption, OP3(TERMINAL::tNoAction, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kOnUpdateOption, OP3(TERMINAL::tSetDefault, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OnUpdateOption::deep_delete() {
+	delete this;
+}
+
+IR* KeyList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(key_part_);
+			res = new IR(IRTYPE::kKeyList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(key_part_);
+			auto tmp2 = SAFETRANSLATE(key_list_);
+			res = new IR(IRTYPE::kKeyList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void KeyList::deep_delete() {
+	SAFEDELETE(key_part_);
+	SAFEDELETE(key_list_);
+	delete this;
+}
+
+IR* KeyListWithExpression::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(key_part_with_expression_);
+			res = new IR(IRTYPE::kKeyListWithExpression, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(key_part_with_expression_);
+			auto tmp2 = SAFETRANSLATE(key_list_with_expression_);
+			res = new IR(IRTYPE::kKeyListWithExpression, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void KeyListWithExpression::deep_delete() {
+	SAFEDELETE(key_part_with_expression_);
+	SAFEDELETE(key_list_with_expression_);
+	delete this;
+}
+
+IR* KeyPartWithExpression::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(key_part_);
+			res = new IR(IRTYPE::kKeyPartWithExpression, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_root_);
+			auto tmp2 = SAFETRANSLATE(opt_ordering_direction_);
+			res = new IR(IRTYPE::kKeyPartWithExpression, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void KeyPartWithExpression::deep_delete() {
+	SAFEDELETE(key_part_);
+	SAFEDELETE(opt_ordering_direction_);
+	SAFEDELETE(expr_root_);
+	delete this;
+}
+
+IR* KeyPart::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(column_name_);
+			auto tmp2 = SAFETRANSLATE(opt_ordering_direction_);
+			res = new IR(IRTYPE::kKeyPart, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(column_name_);
+			auto tmp2 = SAFETRANSLATE(iconst_);
+			auto tmp3 = SAFETRANSLATE(opt_ordering_direction_);
+			auto tmp4 = new IR(IRTYPE::kKeyPartTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kKeyPart, OP3(TERMINAL::tEmpty, TERMINAL::tOpLp, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void KeyPart::deep_delete() {
+	SAFEDELETE(opt_ordering_direction_);
+	SAFEDELETE(column_name_);
+	SAFEDELETE(iconst_);
+	delete this;
+}
+
+IR* ConstraintKeyType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kConstraintKeyType, OP3(TERMINAL::tPrimaryKey, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kConstraintKeyType, OP3(TERMINAL::tUnique, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ConstraintKeyType::deep_delete() {
+	delete this;
+}
+
+IR* OptIndexName::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptIndexName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(index_name_);
+			res = new IR(IRTYPE::kOptIndexName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptIndexName::deep_delete() {
+	SAFEDELETE(index_name_);
+	delete this;
+}
+
+IR* SelectStmt::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(query_expression_);
+	res = new IR(IRTYPE::kSelectStmt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void SelectStmt::deep_delete() {
+	SAFEDELETE(query_expression_);
+	delete this;
+}
+
+IR* QueryExpression::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(query_expression_body_);
+			auto tmp2 = SAFETRANSLATE(opt_order_clause_);
+			auto tmp3 = SAFETRANSLATE(opt_limit_clause_);
+			auto tmp4 = new IR(IRTYPE::kQueryExpressionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kQueryExpression, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(with_clause_);
+			auto tmp2 = SAFETRANSLATE(query_expression_body_);
+			auto tmp3 = SAFETRANSLATE(opt_order_clause_);
+			auto tmp4 = SAFETRANSLATE(opt_limit_clause_);
+			auto tmp5 = new IR(IRTYPE::kQueryExpressionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kQueryExpressionTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kQueryExpression, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void QueryExpression::deep_delete() {
+	SAFEDELETE(opt_limit_clause_);
+	SAFEDELETE(opt_order_clause_);
+	SAFEDELETE(query_expression_body_);
+	SAFEDELETE(with_clause_);
+	delete this;
+}
+
+IR* QueryExpressionBody::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(query_primary_);
+			res = new IR(IRTYPE::kQueryExpressionBody, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(query_expression_parens_);
+			res = new IR(IRTYPE::kQueryExpressionBody, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(query_expression_body_1_);
+			auto tmp2 = SAFETRANSLATE(opt_union_option_);
+			auto tmp3 = SAFETRANSLATE(query_expression_body_2_);
+			auto tmp4 = new IR(IRTYPE::kQueryExpressionBodyTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kQueryExpressionBody, OP3(TERMINAL::tEmpty, TERMINAL::tUnion, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(query_expression_body_1_);
+			auto tmp2 = SAFETRANSLATE(opt_union_option_);
+			auto tmp3 = SAFETRANSLATE(query_expression_body_2_);
+			auto tmp4 = new IR(IRTYPE::kQueryExpressionBodyTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kQueryExpressionBody, OP3(TERMINAL::tEmpty, TERMINAL::tExcept, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(query_expression_body_1_);
+			auto tmp2 = SAFETRANSLATE(opt_union_option_);
+			auto tmp3 = SAFETRANSLATE(query_expression_body_2_);
+			auto tmp4 = new IR(IRTYPE::kQueryExpressionBodyTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kQueryExpressionBody, OP3(TERMINAL::tEmpty, TERMINAL::tIntersect, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void QueryExpressionBody::deep_delete() {
+	SAFEDELETE(query_primary_);
+	SAFEDELETE(query_expression_parens_);
+	SAFEDELETE(query_expression_body_1_);
+	SAFEDELETE(query_expression_body_2_);
+	SAFEDELETE(opt_union_option_);
+	delete this;
+}
+
+IR* QueryPrimary::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(query_specification_);
+	res = new IR(IRTYPE::kQueryPrimary, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void QueryPrimary::deep_delete() {
+	SAFEDELETE(query_specification_);
+	delete this;
+}
+
+IR* QuerySpecification::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(opt_select_options_);
+	auto tmp2 = SAFETRANSLATE(select_item_list_);
+	auto tmp3 = SAFETRANSLATE(opt_from_clause_);
+	auto tmp4 = SAFETRANSLATE(opt_where_clause_);
+	auto tmp5 = SAFETRANSLATE(opt_group_clause_);
+	auto tmp6 = SAFETRANSLATE(opt_having_clause_);
+	auto tmp7 = SAFETRANSLATE(opt_window_clause_);
+	auto tmp8 = new IR(IRTYPE::kQuerySpecificationTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp6, tmp7);
+	auto tmp9 = new IR(IRTYPE::kQuerySpecificationTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp5, tmp8);
+	auto tmp10 = new IR(IRTYPE::kQuerySpecificationTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp4, tmp9);
+	auto tmp11 = new IR(IRTYPE::kQuerySpecificationTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp10);
+	auto tmp12 = new IR(IRTYPE::kQuerySpecificationTmp5, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp11);
+	res = new IR(IRTYPE::kQuerySpecification, OP3(TERMINAL::tSelect, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp12);
+
+	TRANSLATEEND
+}
+
+void QuerySpecification::deep_delete() {
+	SAFEDELETE(opt_window_clause_);
+	SAFEDELETE(opt_having_clause_);
+	SAFEDELETE(opt_group_clause_);
+	SAFEDELETE(opt_where_clause_);
+	SAFEDELETE(opt_from_clause_);
+	SAFEDELETE(select_item_list_);
+	SAFEDELETE(opt_select_options_);
+	delete this;
+}
+
+IR* OptWindowClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptWindowClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(window_definition_list_);
+			res = new IR(IRTYPE::kOptWindowClause, OP3(TERMINAL::tWindow, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptWindowClause::deep_delete() {
+	SAFEDELETE(window_definition_list_);
+	delete this;
+}
+
+IR* WindowDefinitionList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(window_definition_);
+			res = new IR(IRTYPE::kWindowDefinitionList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(window_definition_);
+			auto tmp2 = SAFETRANSLATE(window_definition_list_);
+			res = new IR(IRTYPE::kWindowDefinitionList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WindowDefinitionList::deep_delete() {
+	SAFEDELETE(window_definition_);
+	SAFEDELETE(window_definition_list_);
+	delete this;
+}
+
+IR* WindowDefinition::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(window_name_);
+	auto tmp2 = SAFETRANSLATE(window_spec_);
+	res = new IR(IRTYPE::kWindowDefinition, OP3(TERMINAL::tEmpty, TERMINAL::tAs, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void WindowDefinition::deep_delete() {
+	SAFEDELETE(window_spec_);
+	SAFEDELETE(window_name_);
+	delete this;
+}
+
+IR* WindowSpec::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(window_spec_details_);
+	res = new IR(IRTYPE::kWindowSpec, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void WindowSpec::deep_delete() {
+	SAFEDELETE(window_spec_details_);
+	delete this;
+}
+
+IR* WindowSpecDetails::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(opt_existing_window_name_);
+	auto tmp2 = SAFETRANSLATE(opt_partition_clause_);
+	auto tmp3 = SAFETRANSLATE(opt_window_order_by_clause_);
+	auto tmp4 = SAFETRANSLATE(opt_window_frame_clause_);
+	auto tmp5 = new IR(IRTYPE::kWindowSpecDetailsTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp4);
+	auto tmp6 = new IR(IRTYPE::kWindowSpecDetailsTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+	res = new IR(IRTYPE::kWindowSpecDetails, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+
+	TRANSLATEEND
+}
+
+void WindowSpecDetails::deep_delete() {
+	SAFEDELETE(opt_window_frame_clause_);
+	SAFEDELETE(opt_window_order_by_clause_);
+	SAFEDELETE(opt_partition_clause_);
+	SAFEDELETE(opt_existing_window_name_);
+	delete this;
+}
+
+IR* OptExistingWindowName::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptExistingWindowName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(window_name_);
+			res = new IR(IRTYPE::kOptExistingWindowName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptExistingWindowName::deep_delete() {
+	SAFEDELETE(window_name_);
+	delete this;
+}
+
+IR* OptPartitionClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptPartitionClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_root_list_);
+			res = new IR(IRTYPE::kOptPartitionClause, OP3(TERMINAL::tPartitionBy, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptPartitionClause::deep_delete() {
+	SAFEDELETE(expr_root_list_);
+	delete this;
+}
+
+IR* OptWindowOrderByClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptWindowOrderByClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(order_list_);
+			res = new IR(IRTYPE::kOptWindowOrderByClause, OP3(TERMINAL::tOrderBy, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptWindowOrderByClause::deep_delete() {
+	SAFEDELETE(order_list_);
+	delete this;
+}
+
+IR* OrderList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(order_expr_);
+			res = new IR(IRTYPE::kOrderList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(order_expr_);
+			auto tmp2 = SAFETRANSLATE(order_list_);
+			res = new IR(IRTYPE::kOrderList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OrderList::deep_delete() {
+	SAFEDELETE(order_expr_);
+	SAFEDELETE(order_list_);
+	delete this;
+}
+
+IR* OrderExpr::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(expr_root_);
+	auto tmp2 = SAFETRANSLATE(opt_ordering_direction_);
+	res = new IR(IRTYPE::kOrderExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void OrderExpr::deep_delete() {
+	SAFEDELETE(opt_ordering_direction_);
+	SAFEDELETE(expr_root_);
+	delete this;
+}
+
+IR* OptOrderingDirection::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptOrderingDirection, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptOrderingDirection, OP3(TERMINAL::tAsc, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kOptOrderingDirection, OP3(TERMINAL::tDesc, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptOrderingDirection::deep_delete() {
+	delete this;
+}
+
+IR* OptWindowFrameClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptWindowFrameClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(window_frame_units_);
+			auto tmp2 = SAFETRANSLATE(window_frame_extent_);
+			res = new IR(IRTYPE::kOptWindowFrameClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptWindowFrameClause::deep_delete() {
+	SAFEDELETE(window_frame_extent_);
+	SAFEDELETE(window_frame_units_);
+	delete this;
+}
+
+IR* WindowFrameUnits::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kWindowFrameUnits, OP3(TERMINAL::tRows, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kWindowFrameUnits, OP3(TERMINAL::tRange, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WindowFrameUnits::deep_delete() {
+	delete this;
+}
+
+IR* WindowFrameExtent::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(window_frame_start_);
+			res = new IR(IRTYPE::kWindowFrameExtent, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(window_frame_between_);
+			res = new IR(IRTYPE::kWindowFrameExtent, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WindowFrameExtent::deep_delete() {
+	SAFEDELETE(window_frame_start_);
+	SAFEDELETE(window_frame_between_);
+	delete this;
+}
+
+IR* WindowFrameStart::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kWindowFrameStart, OP3(TERMINAL::tUnboundedPreceding, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(iconst_);
+			res = new IR(IRTYPE::kWindowFrameStart, OP3(TERMINAL::tEmpty, TERMINAL::tPreceding, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kWindowFrameStart, OP3(TERMINAL::tCurrentRow, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WindowFrameStart::deep_delete() {
+	SAFEDELETE(iconst_);
+	delete this;
+}
+
+IR* WindowFrameBetween::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(window_frame_start_);
+	auto tmp2 = SAFETRANSLATE(window_frame_bound_);
+	res = new IR(IRTYPE::kWindowFrameBetween, OP3(TERMINAL::tBetween, TERMINAL::tAnd, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void WindowFrameBetween::deep_delete() {
+	SAFEDELETE(window_frame_bound_);
+	SAFEDELETE(window_frame_start_);
+	delete this;
+}
+
+IR* WindowFrameBound::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(window_frame_start_);
+			res = new IR(IRTYPE::kWindowFrameBound, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kWindowFrameBound, OP3(TERMINAL::tUnboundedFollowing, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(iconst_);
+			res = new IR(IRTYPE::kWindowFrameBound, OP3(TERMINAL::tEmpty, TERMINAL::tFollowing, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WindowFrameBound::deep_delete() {
+	SAFEDELETE(window_frame_start_);
+	SAFEDELETE(iconst_);
+	delete this;
+}
+
+IR* OptHavingClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptHavingClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_root_);
+			res = new IR(IRTYPE::kOptHavingClause, OP3(TERMINAL::tHaving, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptHavingClause::deep_delete() {
+	SAFEDELETE(expr_root_);
+	delete this;
+}
+
+IR* OptGroupClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptGroupClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_root_list_);
+			auto tmp2 = SAFETRANSLATE(olap_opt_);
+			res = new IR(IRTYPE::kOptGroupClause, OP3(TERMINAL::tGroupBy, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptGroupClause::deep_delete() {
+	SAFEDELETE(olap_opt_);
+	SAFEDELETE(expr_root_list_);
+	delete this;
+}
+
+IR* OlapOpt::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOlapOpt, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOlapOpt, OP3(TERMINAL::tWithRollup, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OlapOpt::deep_delete() {
+	delete this;
+}
+
+IR* OptWhereClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptWhereClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(where_clause_);
+			res = new IR(IRTYPE::kOptWhereClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptWhereClause::deep_delete() {
+	SAFEDELETE(where_clause_);
+	delete this;
+}
+
+IR* WhereClause::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(expr_root_);
+	res = new IR(IRTYPE::kWhereClause, OP3(TERMINAL::tWhere, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void WhereClause::deep_delete() {
+	SAFEDELETE(expr_root_);
+	delete this;
+}
+
+IR* OptFromClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptFromClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(from_clause_);
+			res = new IR(IRTYPE::kOptFromClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptFromClause::deep_delete() {
+	SAFEDELETE(from_clause_);
+	delete this;
+}
+
+IR* FromClause::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(table_reference_list_);
+	res = new IR(IRTYPE::kFromClause, OP3(TERMINAL::tFrom, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void FromClause::deep_delete() {
+	SAFEDELETE(table_reference_list_);
+	delete this;
+}
+
+IR* TableReferenceList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(table_reference_);
+			res = new IR(IRTYPE::kTableReferenceList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_reference_);
+			auto tmp2 = SAFETRANSLATE(table_reference_list_);
+			res = new IR(IRTYPE::kTableReferenceList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TableReferenceList::deep_delete() {
+	SAFEDELETE(table_reference_);
+	SAFEDELETE(table_reference_list_);
+	delete this;
+}
+
+IR* TableReference::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(table_factor_);
+			res = new IR(IRTYPE::kTableReference, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(joined_table_);
+			res = new IR(IRTYPE::kTableReference, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TableReference::deep_delete() {
+	SAFEDELETE(table_factor_);
+	SAFEDELETE(joined_table_);
+	delete this;
+}
+
+IR* TableFactor::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(single_table_);
+			res = new IR(IRTYPE::kTableFactor, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(derived_table_);
+			res = new IR(IRTYPE::kTableFactor, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(joined_table_parens_);
+			res = new IR(IRTYPE::kTableFactor, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(table_reference_list_parens_);
+			res = new IR(IRTYPE::kTableFactor, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TableFactor::deep_delete() {
+	SAFEDELETE(single_table_);
+	SAFEDELETE(derived_table_);
+	SAFEDELETE(joined_table_parens_);
+	SAFEDELETE(table_reference_list_parens_);
+	delete this;
+}
+
+IR* TableReferenceListParens::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(table_reference_);
+	auto tmp2 = SAFETRANSLATE(table_reference_list_);
+	res = new IR(IRTYPE::kTableReferenceListParens, OP3(TERMINAL::tOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void TableReferenceListParens::deep_delete() {
+	SAFEDELETE(table_reference_list_);
+	SAFEDELETE(table_reference_);
+	delete this;
+}
+
+IR* JoinedTableParens::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(joined_table_);
+	res = new IR(IRTYPE::kJoinedTableParens, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void JoinedTableParens::deep_delete() {
+	SAFEDELETE(joined_table_);
+	delete this;
+}
+
+IR* DerivedTable::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			auto tmp2 = SAFETRANSLATE(alias_);
+			auto tmp3 = SAFETRANSLATE(opt_column_list_);
+			auto tmp4 = new IR(IRTYPE::kDerivedTableTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kDerivedTable, OP3(TERMINAL::tEmpty, TERMINAL::tAs, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			auto tmp2 = SAFETRANSLATE(alias_);
+			auto tmp3 = SAFETRANSLATE(opt_column_list_);
+			auto tmp4 = new IR(IRTYPE::kDerivedTableTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kDerivedTable, OP3(TERMINAL::tLateral, TERMINAL::tAs, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void DerivedTable::deep_delete() {
+	SAFEDELETE(opt_column_list_);
+	SAFEDELETE(alias_);
+	SAFEDELETE(subquery_);
+	delete this;
+}
+
+IR* OptColumnList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptColumnList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(column_list_);
+			res = new IR(IRTYPE::kOptColumnList, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptColumnList::deep_delete() {
+	SAFEDELETE(column_list_);
+	delete this;
+}
+
+IR* ColumnList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(column_name_);
+			res = new IR(IRTYPE::kColumnList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(column_name_);
+			auto tmp2 = SAFETRANSLATE(column_list_);
+			res = new IR(IRTYPE::kColumnList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ColumnList::deep_delete() {
+	SAFEDELETE(column_name_);
+	SAFEDELETE(column_list_);
+	delete this;
+}
+
+IR* Subquery::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(query_expression_parens_);
+	res = new IR(IRTYPE::kSubquery, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void Subquery::deep_delete() {
+	SAFEDELETE(query_expression_parens_);
+	delete this;
+}
+
+IR* SingleTable::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(table_name_);
+	auto tmp2 = SAFETRANSLATE(opt_alias_);
+	res = new IR(IRTYPE::kSingleTable, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void SingleTable::deep_delete() {
+	SAFEDELETE(opt_alias_);
+	SAFEDELETE(table_name_);
+	delete this;
+}
+
+IR* OptAlias::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptAlias, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(alias_);
+			res = new IR(IRTYPE::kOptAlias, OP3(TERMINAL::tAs, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptAlias::deep_delete() {
+	SAFEDELETE(alias_);
+	delete this;
+}
+
+IR* JoinedTable::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(table_reference_1_);
+			auto tmp2 = SAFETRANSLATE(inner_join_type_);
+			auto tmp3 = SAFETRANSLATE(table_reference_2_);
+			auto tmp4 = SAFETRANSLATE(expr_root_);
+			auto tmp5 = new IR(IRTYPE::kJoinedTableTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOn, TERMINAL::tEmpty), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kJoinedTableTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kJoinedTable, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_reference_1_);
+			auto tmp2 = SAFETRANSLATE(inner_join_type_);
+			auto tmp3 = SAFETRANSLATE(table_reference_2_);
+			auto tmp4 = SAFETRANSLATE(column_list_);
+			auto tmp5 = new IR(IRTYPE::kJoinedTableTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tUsingOpLp, TERMINAL::tOpRp), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kJoinedTableTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kJoinedTable, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(table_reference_1_);
+			auto tmp2 = SAFETRANSLATE(outer_join_type_);
+			auto tmp3 = SAFETRANSLATE(table_reference_2_);
+			auto tmp4 = SAFETRANSLATE(expr_root_);
+			auto tmp5 = new IR(IRTYPE::kJoinedTableTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOn, TERMINAL::tEmpty), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kJoinedTableTmp5, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kJoinedTable, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(table_reference_1_);
+			auto tmp2 = SAFETRANSLATE(outer_join_type_);
+			auto tmp3 = SAFETRANSLATE(table_reference_2_);
+			auto tmp4 = SAFETRANSLATE(column_list_);
+			auto tmp5 = new IR(IRTYPE::kJoinedTableTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tUsingOpLp, TERMINAL::tOpRp), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kJoinedTableTmp6, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kJoinedTable, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(table_reference_1_);
+			auto tmp2 = SAFETRANSLATE(inner_join_type_);
+			auto tmp3 = SAFETRANSLATE(table_reference_2_);
+			auto tmp4 = new IR(IRTYPE::kJoinedTableTmp7, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kJoinedTable, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(table_reference_1_);
+			auto tmp2 = SAFETRANSLATE(natural_join_type_);
+			auto tmp3 = SAFETRANSLATE(table_factor_);
+			auto tmp4 = new IR(IRTYPE::kJoinedTableTmp8, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kJoinedTable, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void JoinedTable::deep_delete() {
+	SAFEDELETE(expr_root_);
+	SAFEDELETE(table_reference_1_);
+	SAFEDELETE(table_reference_2_);
+	SAFEDELETE(inner_join_type_);
+	SAFEDELETE(column_list_);
+	SAFEDELETE(outer_join_type_);
+	SAFEDELETE(table_factor_);
+	SAFEDELETE(natural_join_type_);
+	delete this;
+}
+
+IR* InnerJoinType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kInnerJoinType, OP3(TERMINAL::tJoin, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kInnerJoinType, OP3(TERMINAL::tInnerJoin, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kInnerJoinType, OP3(TERMINAL::tCrossJoin, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kInnerJoinType, OP3(TERMINAL::tStraightJoin, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void InnerJoinType::deep_delete() {
+	delete this;
+}
+
+IR* NaturalJoinType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(opt_inner_);
+			res = new IR(IRTYPE::kNaturalJoinType, OP3(TERMINAL::tNatural, TERMINAL::tJoin, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(opt_outer_);
+			res = new IR(IRTYPE::kNaturalJoinType, OP3(TERMINAL::tNaturalRight, TERMINAL::tJoin, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(opt_outer_);
+			res = new IR(IRTYPE::kNaturalJoinType, OP3(TERMINAL::tNaturalLeft, TERMINAL::tJoin, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void NaturalJoinType::deep_delete() {
+	SAFEDELETE(opt_inner_);
+	SAFEDELETE(opt_outer_);
+	delete this;
+}
+
+IR* OptInner::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptInner, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptInner, OP3(TERMINAL::tInner, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptInner::deep_delete() {
+	delete this;
+}
+
+IR* OptOuter::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptOuter, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptOuter, OP3(TERMINAL::tOuter, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptOuter::deep_delete() {
+	delete this;
+}
+
+IR* OuterJoinType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(opt_outer_);
+			res = new IR(IRTYPE::kOuterJoinType, OP3(TERMINAL::tLeft, TERMINAL::tJoin, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(opt_outer_);
+			res = new IR(IRTYPE::kOuterJoinType, OP3(TERMINAL::tRight, TERMINAL::tJoin, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OuterJoinType::deep_delete() {
+	SAFEDELETE(opt_outer_);
+	delete this;
+}
+
+IR* SelectItemList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(select_item_);
+			res = new IR(IRTYPE::kSelectItemList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(select_item_);
+			auto tmp2 = SAFETRANSLATE(select_item_list_);
+			res = new IR(IRTYPE::kSelectItemList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void SelectItemList::deep_delete() {
+	SAFEDELETE(select_item_);
+	SAFEDELETE(select_item_list_);
+	delete this;
+}
+
+IR* SelectItem::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(table_wild_);
+			res = new IR(IRTYPE::kSelectItem, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_root_);
+			auto tmp2 = SAFETRANSLATE(opt_alias_);
+			res = new IR(IRTYPE::kSelectItem, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void SelectItem::deep_delete() {
+	SAFEDELETE(table_wild_);
+	SAFEDELETE(opt_alias_);
+	SAFEDELETE(expr_root_);
+	delete this;
+}
+
+IR* TableWild::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kTableWild, OP3(TERMINAL::tOpMul, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_name_);
+			res = new IR(IRTYPE::kTableWild, OP3(TERMINAL::tEmpty, TERMINAL::tOpDotOpMul, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TableWild::deep_delete() {
+	SAFEDELETE(table_name_);
+	delete this;
+}
+
+IR* OptSelectOptions::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptSelectOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(select_option_list_);
+			res = new IR(IRTYPE::kOptSelectOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptSelectOptions::deep_delete() {
+	SAFEDELETE(select_option_list_);
+	delete this;
+}
+
+IR* SelectOptionList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(select_option_);
+			res = new IR(IRTYPE::kSelectOptionList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(select_option_);
+			auto tmp2 = SAFETRANSLATE(select_option_list_);
+			res = new IR(IRTYPE::kSelectOptionList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void SelectOptionList::deep_delete() {
+	SAFEDELETE(select_option_);
+	SAFEDELETE(select_option_list_);
+	delete this;
+}
+
+IR* SelectOption::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tSqlNoCache, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tStraightJoin, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tHighPriority, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tDistinct, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(4)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tSqlSmallResult, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(5)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tSqlBigResult, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(6)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tSqlBufferResult, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(7)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tSqlCalcFoundRows, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(8)
+			res = new IR(IRTYPE::kSelectOption, OP3(TERMINAL::tAll, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void SelectOption::deep_delete() {
+	delete this;
+}
+
+IR* QueryExpressionParens::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(query_expression_parens_);
+			res = new IR(IRTYPE::kQueryExpressionParens, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(query_expression_);
+			res = new IR(IRTYPE::kQueryExpressionParens, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void QueryExpressionParens::deep_delete() {
+	SAFEDELETE(query_expression_parens_);
+	SAFEDELETE(query_expression_);
+	delete this;
+}
+
+IR* OptUnionOption::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptUnionOption, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptUnionOption, OP3(TERMINAL::tDistinct, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kOptUnionOption, OP3(TERMINAL::tAll, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptUnionOption::deep_delete() {
+	delete this;
+}
+
+IR* OptOrderClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptOrderClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(order_clause_);
+			res = new IR(IRTYPE::kOptOrderClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptOrderClause::deep_delete() {
+	SAFEDELETE(order_clause_);
+	delete this;
+}
+
+IR* OrderClause::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(order_list_);
+	res = new IR(IRTYPE::kOrderClause, OP3(TERMINAL::tOrderBy, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void OrderClause::deep_delete() {
+	SAFEDELETE(order_list_);
+	delete this;
+}
+
+IR* OptLimitClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptLimitClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(limit_clause_);
+			res = new IR(IRTYPE::kOptLimitClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptLimitClause::deep_delete() {
+	SAFEDELETE(limit_clause_);
+	delete this;
+}
+
+IR* LimitClause::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(limit_options_);
+	res = new IR(IRTYPE::kLimitClause, OP3(TERMINAL::tLimit, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void LimitClause::deep_delete() {
+	SAFEDELETE(limit_options_);
+	delete this;
+}
+
+IR* LimitOptions::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(iconst_1_);
+			res = new IR(IRTYPE::kLimitOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(iconst_1_);
+			auto tmp2 = SAFETRANSLATE(iconst_2_);
+			res = new IR(IRTYPE::kLimitOptions, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void LimitOptions::deep_delete() {
+	SAFEDELETE(iconst_1_);
+	SAFEDELETE(iconst_2_);
+	delete this;
+}
+
+IR* WithClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(with_list_);
+			res = new IR(IRTYPE::kWithClause, OP3(TERMINAL::tWith, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(with_list_);
+			res = new IR(IRTYPE::kWithClause, OP3(TERMINAL::tWithRecursive, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WithClause::deep_delete() {
+	SAFEDELETE(with_list_);
+	delete this;
+}
+
+IR* WithList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(common_table_expr_);
+			res = new IR(IRTYPE::kWithList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(common_table_expr_);
+			auto tmp2 = SAFETRANSLATE(with_list_);
+			res = new IR(IRTYPE::kWithList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WithList::deep_delete() {
+	SAFEDELETE(common_table_expr_);
+	SAFEDELETE(with_list_);
+	delete this;
+}
+
+IR* CommonTableExpr::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(table_name_);
+	auto tmp2 = SAFETRANSLATE(opt_column_list_);
+	auto tmp3 = SAFETRANSLATE(subquery_);
+	auto tmp4 = new IR(IRTYPE::kCommonTableExprTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tAs, TERMINAL::tEmpty), tmp2, tmp3);
+	res = new IR(IRTYPE::kCommonTableExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+
+	TRANSLATEEND
+}
+
+void CommonTableExpr::deep_delete() {
+	SAFEDELETE(subquery_);
+	SAFEDELETE(opt_column_list_);
+	SAFEDELETE(table_name_);
+	delete this;
+}
+
+IR* ExprRootList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(expr_root_);
+			res = new IR(IRTYPE::kExprRootList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_root_);
+			auto tmp2 = SAFETRANSLATE(expr_root_list_);
+			res = new IR(IRTYPE::kExprRootList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ExprRootList::deep_delete() {
+	SAFEDELETE(expr_root_);
+	SAFEDELETE(expr_root_list_);
+	delete this;
+}
+
+IR* ExprRoot::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(expr_);
+	res = new IR(IRTYPE::kExprRoot, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void ExprRoot::deep_delete() {
+	SAFEDELETE(expr_);
+	delete this;
+}
+
+IR* Expr::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOr, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tXor, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tAnd, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tNot, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tIsTrue, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tIsNotTrue, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tIsFalse, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tIsNotFalse, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tIsUnknown, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tIsNotUnknown, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Expr::deep_delete() {
+	SAFEDELETE(expr_1_);
+	SAFEDELETE(expr_2_);
+	SAFEDELETE(bool_pri_);
+	delete this;
+}
+
+IR* BoolPri::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kBoolPri, OP3(TERMINAL::tEmpty, TERMINAL::tIsNull, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			res = new IR(IRTYPE::kBoolPri, OP3(TERMINAL::tEmpty, TERMINAL::tIsNotNull, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			auto tmp2 = SAFETRANSLATE(comp_op_);
+			auto tmp3 = SAFETRANSLATE(predicate_);
+			auto tmp4 = new IR(IRTYPE::kBoolPriTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kBoolPri, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(bool_pri_);
+			auto tmp2 = SAFETRANSLATE(comp_op_);
+			auto tmp3 = SAFETRANSLATE(all_subquery_);
+			auto tmp4 = new IR(IRTYPE::kBoolPriTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kBoolPri, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(predicate_);
+			res = new IR(IRTYPE::kBoolPri, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void BoolPri::deep_delete() {
+	SAFEDELETE(bool_pri_);
+	SAFEDELETE(predicate_);
+	SAFEDELETE(comp_op_);
+	SAFEDELETE(all_subquery_);
+	delete this;
+}
+
+IR* Predicate::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(in_subquery_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tInOpLp, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			auto tmp3 = SAFETRANSLATE(expr_list_);
+			auto tmp4 = new IR(IRTYPE::kPredicateTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tInOpLp, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tNotInOpLp, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			auto tmp3 = SAFETRANSLATE(expr_list_);
+			auto tmp4 = new IR(IRTYPE::kPredicateTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tNotInOpLp, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			auto tmp3 = SAFETRANSLATE(predicate_);
+			auto tmp4 = new IR(IRTYPE::kPredicateTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tAnd, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tBetween, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			auto tmp3 = SAFETRANSLATE(predicate_);
+			auto tmp4 = new IR(IRTYPE::kPredicateTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tAnd, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tNotBetween, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tSoundsLike, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(simple_expr_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tLike, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(simple_expr_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tNotLike, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tRegexp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(11)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tNotRegexp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(12)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			res = new IR(IRTYPE::kPredicate, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Predicate::deep_delete() {
+	SAFEDELETE(in_subquery_);
+	SAFEDELETE(bit_expr_1_);
+	SAFEDELETE(bit_expr_2_);
+	SAFEDELETE(expr_);
+	SAFEDELETE(expr_list_);
+	SAFEDELETE(predicate_);
+	SAFEDELETE(simple_expr_);
+	delete this;
+}
+
+IR* BitExpr::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpOr, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpAnd, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpShl, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpShr, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpAdd, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpSub, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpMul, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpDivide, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpMod, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(bit_expr_1_);
+			auto tmp2 = SAFETRANSLATE(bit_expr_2_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tOpXor, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(simple_expr_);
+			res = new IR(IRTYPE::kBitExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void BitExpr::deep_delete() {
+	SAFEDELETE(bit_expr_1_);
+	SAFEDELETE(bit_expr_2_);
+	SAFEDELETE(simple_expr_);
+	delete this;
+}
+
+IR* SimpleExpr::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(columnref_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(literal_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(iconst_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(fconst_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(sconst_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(simple_expr_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tOpAdd, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(simple_expr_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tOpSub, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(simple_expr_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tOpNot, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tExists, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(type_cast_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(11)
+			auto tmp1 = SAFETRANSLATE(case_expr_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(12)
+			auto tmp1 = SAFETRANSLATE(columnref_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tDefaultOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(13)
+			auto tmp1 = SAFETRANSLATE(function_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(14)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			res = new IR(IRTYPE::kSimpleExpr, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void SimpleExpr::deep_delete() {
+	SAFEDELETE(columnref_);
+	SAFEDELETE(literal_);
+	SAFEDELETE(iconst_);
+	SAFEDELETE(fconst_);
+	SAFEDELETE(sconst_);
+	SAFEDELETE(simple_expr_);
+	SAFEDELETE(subquery_);
+	SAFEDELETE(type_cast_);
+	SAFEDELETE(case_expr_);
+	SAFEDELETE(function_);
+	SAFEDELETE(expr_);
+	delete this;
+}
+
+IR* Function::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(control_function_);
+			res = new IR(IRTYPE::kFunction, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(math_function_);
+			res = new IR(IRTYPE::kFunction, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(string_function_);
+			res = new IR(IRTYPE::kFunction, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(aggregate_function_);
+			res = new IR(IRTYPE::kFunction, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(window_function_);
+			res = new IR(IRTYPE::kFunction, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Function::deep_delete() {
+	SAFEDELETE(control_function_);
+	SAFEDELETE(math_function_);
+	SAFEDELETE(string_function_);
+	SAFEDELETE(aggregate_function_);
+	SAFEDELETE(window_function_);
+	delete this;
+}
+
+IR* StringFunction::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tAsciiOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tBinOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tBitLengthOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tCharLengthOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tLengthOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tLowerOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tLtrimOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tOctOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tOrdOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tQuoteOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tReverseOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(11)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tRtrimOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(12)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tSpaceOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(13)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tTrimOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(14)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tTrimOpLpLeadingFrom, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(15)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tTrimOpLpTrailingFrom, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(16)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tUnhexOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(17)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tUpperOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(18)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tFindInSetOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(19)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tInstrOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(20)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tLeftOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(21)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tLocateOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(22)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tRepeatOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(23)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tRightOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(24)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tSubstringOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(25)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tTrimOpLpLeading, TERMINAL::tFrom, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(26)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tTrimOpLpTrailing, TERMINAL::tFrom, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(27)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tTrimOpLp, TERMINAL::tFrom, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(28)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tExportSetOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(29)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tLocateOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(30)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tLpadOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(31)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tReplaceOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(32)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tRpadOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(33)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tSubstringOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(34)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tSubstringIndexOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(35)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = SAFETRANSLATE(expr_4_);
+			auto tmp5 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kStringFunctionTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tExportSetOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(36)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = SAFETRANSLATE(expr_4_);
+			auto tmp5 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kStringFunctionTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tInsertOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(37)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = SAFETRANSLATE(expr_4_);
+			auto tmp5 = SAFETRANSLATE(expr_5_);
+			auto tmp6 = new IR(IRTYPE::kStringFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp4, tmp5);
+			auto tmp7 = new IR(IRTYPE::kStringFunctionTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp3, tmp6);
+			auto tmp8 = new IR(IRTYPE::kStringFunctionTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp2, tmp7);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tExportSetOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp8);
+		CASEEND
+		CASESTART(38)
+			auto tmp1 = SAFETRANSLATE(expr_list_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tCharOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(39)
+			auto tmp1 = SAFETRANSLATE(expr_list_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tConcatOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(40)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_list_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tConcatWsOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(41)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_list_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tEltOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(42)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_list_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tFieldOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(43)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_list_);
+			res = new IR(IRTYPE::kStringFunction, OP3(TERMINAL::tMakeSetOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void StringFunction::deep_delete() {
+	SAFEDELETE(expr_1_);
+	SAFEDELETE(expr_2_);
+	SAFEDELETE(expr_3_);
+	SAFEDELETE(expr_4_);
+	SAFEDELETE(expr_5_);
+	SAFEDELETE(expr_list_);
+	delete this;
+}
+
+IR* MathFunction::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tPiOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tRandOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tAbsOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tAcosOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tAsinOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tAtanOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tCeilingOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tCosOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tCotOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tDegreesOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tExpOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(11)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tFloorOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(12)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tHexOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(13)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tLnOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(14)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tRadiansOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(15)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tRandOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(16)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tRoundOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(17)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tSignOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(18)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tSinOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(19)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tSqrtOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(20)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tTanOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(21)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tAtanOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(22)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tFormatOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(23)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tLogOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(24)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tModOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(25)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tPowOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(26)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tRoundOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(27)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tTruncateOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(28)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kMathFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tConvOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void MathFunction::deep_delete() {
+	SAFEDELETE(expr_1_);
+	SAFEDELETE(expr_2_);
+	SAFEDELETE(expr_3_);
+	delete this;
+}
+
+IR* WindowFunction::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(windowing_clause_);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tRowNumberOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(windowing_clause_);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tRankOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(windowing_clause_);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tDenseRankOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(windowing_clause_);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tCumeDistOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(windowing_clause_);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tPercentRankOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(iconst_);
+			auto tmp2 = SAFETRANSLATE(windowing_clause_);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tNtileOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_lead_lag_info_);
+			auto tmp3 = SAFETRANSLATE(opt_null_treatment_);
+			auto tmp4 = SAFETRANSLATE(windowing_clause_);
+			auto tmp5 = new IR(IRTYPE::kWindowFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kWindowFunctionTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tLeadOpLp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_lead_lag_info_);
+			auto tmp3 = SAFETRANSLATE(opt_null_treatment_);
+			auto tmp4 = SAFETRANSLATE(windowing_clause_);
+			auto tmp5 = new IR(IRTYPE::kWindowFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp4);
+			auto tmp6 = new IR(IRTYPE::kWindowFunctionTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp5);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tLagOpLp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp6);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_null_treatment_);
+			auto tmp3 = SAFETRANSLATE(windowing_clause_);
+			auto tmp4 = new IR(IRTYPE::kWindowFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tFirstValueOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_null_treatment_);
+			auto tmp3 = SAFETRANSLATE(windowing_clause_);
+			auto tmp4 = new IR(IRTYPE::kWindowFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tLastValueOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(iconst_);
+			auto tmp3 = SAFETRANSLATE(opt_from_first_last_);
+			auto tmp4 = SAFETRANSLATE(opt_null_treatment_);
+			auto tmp5 = SAFETRANSLATE(windowing_clause_);
+			auto tmp6 = new IR(IRTYPE::kWindowFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp4, tmp5);
+			auto tmp7 = new IR(IRTYPE::kWindowFunctionTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp6);
+			auto tmp8 = new IR(IRTYPE::kWindowFunctionTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp7);
+			res = new IR(IRTYPE::kWindowFunction, OP3(TERMINAL::tNthValueOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp8);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WindowFunction::deep_delete() {
+	SAFEDELETE(windowing_clause_);
+	SAFEDELETE(iconst_);
+	SAFEDELETE(opt_null_treatment_);
+	SAFEDELETE(opt_lead_lag_info_);
+	SAFEDELETE(expr_);
+	SAFEDELETE(opt_from_first_last_);
+	delete this;
+}
+
+IR* OptNullTreatment::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptNullTreatment, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptNullTreatment, OP3(TERMINAL::tRespectNulls, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kOptNullTreatment, OP3(TERMINAL::tIgnoreNulls, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptNullTreatment::deep_delete() {
+	delete this;
+}
+
+IR* OptFromFirstLast::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptFromFirstLast, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptFromFirstLast, OP3(TERMINAL::tFromFirst, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kOptFromFirstLast, OP3(TERMINAL::tFromLast, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptFromFirstLast::deep_delete() {
+	delete this;
+}
+
+IR* OptLeadLagInfo::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptLeadLagInfo, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(lead_lag_info_);
+			res = new IR(IRTYPE::kOptLeadLagInfo, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptLeadLagInfo::deep_delete() {
+	SAFEDELETE(lead_lag_info_);
+	delete this;
+}
+
+IR* LeadLagInfo::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(iconst_);
+			res = new IR(IRTYPE::kLeadLagInfo, OP3(TERMINAL::tOpComma, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(iconst_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			res = new IR(IRTYPE::kLeadLagInfo, OP3(TERMINAL::tOpComma, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void LeadLagInfo::deep_delete() {
+	SAFEDELETE(iconst_);
+	SAFEDELETE(expr_);
+	delete this;
+}
+
+IR* AggregateFunction::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(opt_distinct_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			auto tmp3 = SAFETRANSLATE(opt_windowing_clause_);
+			auto tmp4 = new IR(IRTYPE::kAggregateFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tAvgOpLp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tBitAndOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tBitOrOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(3)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tBitXorOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(4)
+			auto tmp1 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tCountOpLpOpMulOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tCountOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(6)
+			auto tmp1 = SAFETRANSLATE(expr_list_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tCountOpLpDistinct, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(opt_distinct_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			auto tmp3 = SAFETRANSLATE(opt_windowing_clause_);
+			auto tmp4 = new IR(IRTYPE::kAggregateFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tMinOpLp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(8)
+			auto tmp1 = SAFETRANSLATE(opt_distinct_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			auto tmp3 = SAFETRANSLATE(opt_windowing_clause_);
+			auto tmp4 = new IR(IRTYPE::kAggregateFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tMaxOpLp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(9)
+			auto tmp1 = SAFETRANSLATE(opt_distinct_);
+			auto tmp2 = SAFETRANSLATE(expr_);
+			auto tmp3 = SAFETRANSLATE(opt_windowing_clause_);
+			auto tmp4 = new IR(IRTYPE::kAggregateFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp2, tmp3);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tSumOpLp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(10)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tStdOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(11)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tStddevSampOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(12)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tVarianceOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(13)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(opt_windowing_clause_);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tVarSampOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+		CASESTART(14)
+			auto tmp1 = SAFETRANSLATE(opt_distinct_);
+			auto tmp2 = SAFETRANSLATE(expr_list_);
+			auto tmp3 = SAFETRANSLATE(opt_order_clause_);
+			auto tmp4 = SAFETRANSLATE(opt_gconcat_separator_);
+			auto tmp5 = SAFETRANSLATE(opt_windowing_clause_);
+			auto tmp6 = new IR(IRTYPE::kAggregateFunctionTmp2, OP3(TERMINAL::tEmpty, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp4, tmp5);
+			auto tmp7 = new IR(IRTYPE::kAggregateFunctionTmp3, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp3, tmp6);
+			auto tmp8 = new IR(IRTYPE::kAggregateFunctionTmp4, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp2, tmp7);
+			res = new IR(IRTYPE::kAggregateFunction, OP3(TERMINAL::tGroupConcatOpLp, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp8);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void AggregateFunction::deep_delete() {
+	SAFEDELETE(opt_windowing_clause_);
+	SAFEDELETE(expr_);
+	SAFEDELETE(opt_distinct_);
+	SAFEDELETE(expr_list_);
+	SAFEDELETE(opt_gconcat_separator_);
+	SAFEDELETE(opt_order_clause_);
+	delete this;
+}
+
+IR* OptGconcatSeparator::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptGconcatSeparator, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(sconst_);
+			res = new IR(IRTYPE::kOptGconcatSeparator, OP3(TERMINAL::tSeparator, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptGconcatSeparator::deep_delete() {
+	SAFEDELETE(sconst_);
+	delete this;
+}
+
+IR* OptDistinct::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptDistinct, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kOptDistinct, OP3(TERMINAL::tDistinct, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptDistinct::deep_delete() {
+	delete this;
+}
+
+IR* OptWindowingClause::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptWindowingClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(windowing_clause_);
+			res = new IR(IRTYPE::kOptWindowingClause, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptWindowingClause::deep_delete() {
+	SAFEDELETE(windowing_clause_);
+	delete this;
+}
+
+IR* WindowingClause::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(window_name_or_spec_);
+	res = new IR(IRTYPE::kWindowingClause, OP3(TERMINAL::tOver, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void WindowingClause::deep_delete() {
+	SAFEDELETE(window_name_or_spec_);
+	delete this;
+}
+
+IR* WindowNameOrSpec::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(window_name_);
+			res = new IR(IRTYPE::kWindowNameOrSpec, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(window_spec_);
+			res = new IR(IRTYPE::kWindowNameOrSpec, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WindowNameOrSpec::deep_delete() {
+	SAFEDELETE(window_name_);
+	SAFEDELETE(window_spec_);
+	delete this;
+}
+
+IR* ControlFunction::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			auto tmp3 = SAFETRANSLATE(expr_3_);
+			auto tmp4 = new IR(IRTYPE::kControlFunctionTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp2, tmp3);
+			res = new IR(IRTYPE::kControlFunction, OP3(TERMINAL::tIfOpLp, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp4);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kControlFunction, OP3(TERMINAL::tIfnullOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(expr_1_);
+			auto tmp2 = SAFETRANSLATE(expr_2_);
+			res = new IR(IRTYPE::kControlFunction, OP3(TERMINAL::tNullifOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ControlFunction::deep_delete() {
+	SAFEDELETE(expr_1_);
+	SAFEDELETE(expr_2_);
+	SAFEDELETE(expr_3_);
+	delete this;
+}
+
+IR* CaseExpr::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(opt_expr_);
+	auto tmp2 = SAFETRANSLATE(when_clasue_list_);
+	auto tmp3 = SAFETRANSLATE(opt_else_);
+	auto tmp4 = new IR(IRTYPE::kCaseExprTmp1, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEnd), tmp2, tmp3);
+	res = new IR(IRTYPE::kCaseExpr, OP3(TERMINAL::tCase, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp4);
+
+	TRANSLATEEND
+}
+
+void CaseExpr::deep_delete() {
+	SAFEDELETE(opt_else_);
+	SAFEDELETE(when_clasue_list_);
+	SAFEDELETE(opt_expr_);
+	delete this;
+}
+
+IR* WhenClasueList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(when_list_);
+			res = new IR(IRTYPE::kWhenClasueList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(when_list_);
+			auto tmp2 = SAFETRANSLATE(when_clasue_list_);
+			res = new IR(IRTYPE::kWhenClasueList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void WhenClasueList::deep_delete() {
+	SAFEDELETE(when_list_);
+	SAFEDELETE(when_clasue_list_);
+	delete this;
+}
+
+IR* WhenList::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(expr_1_);
+	auto tmp2 = SAFETRANSLATE(expr_2_);
+	res = new IR(IRTYPE::kWhenList, OP3(TERMINAL::tWhen, TERMINAL::tThen, TERMINAL::tEmpty), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void WhenList::deep_delete() {
+	SAFEDELETE(expr_1_);
+	SAFEDELETE(expr_2_);
+	delete this;
+}
+
+IR* OptExpr::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			res = new IR(IRTYPE::kOptExpr, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptExpr::deep_delete() {
+	SAFEDELETE(expr_);
+	delete this;
+}
+
+IR* OptElse::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptElse, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			res = new IR(IRTYPE::kOptElse, OP3(TERMINAL::tElse, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptElse::deep_delete() {
+	SAFEDELETE(expr_);
+	delete this;
+}
+
+IR* TypeCast::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(cast_type_);
+			res = new IR(IRTYPE::kTypeCast, OP3(TERMINAL::tCastOpLp, TERMINAL::tAs, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(cast_type_);
+			res = new IR(IRTYPE::kTypeCast, OP3(TERMINAL::tConvertOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void TypeCast::deep_delete() {
+	SAFEDELETE(cast_type_);
+	SAFEDELETE(expr_);
+	delete this;
+}
+
+IR* CastType::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(opt_field_length_);
+			res = new IR(IRTYPE::kCastType, OP3(TERMINAL::tBinary, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(opt_field_length_);
+			res = new IR(IRTYPE::kCastType, OP3(TERMINAL::tChar, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(opt_field_length_);
+			res = new IR(IRTYPE::kCastType, OP3(TERMINAL::tNchar, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kCastType, OP3(TERMINAL::tSigned, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(4)
+			res = new IR(IRTYPE::kCastType, OP3(TERMINAL::tUnsigned, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(5)
+			auto tmp1 = SAFETRANSLATE(float_options_);
+			res = new IR(IRTYPE::kCastType, OP3(TERMINAL::tDecimal, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(6)
+			res = new IR(IRTYPE::kCastType, OP3(TERMINAL::tReal, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(7)
+			auto tmp1 = SAFETRANSLATE(opt_field_length_);
+			res = new IR(IRTYPE::kCastType, OP3(TERMINAL::tFloat, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void CastType::deep_delete() {
+	SAFEDELETE(opt_field_length_);
+	SAFEDELETE(float_options_);
+	delete this;
+}
+
+IR* FloatOptions::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kFloatOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(field_length_);
+			res = new IR(IRTYPE::kFloatOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(precision_);
+			res = new IR(IRTYPE::kFloatOptions, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void FloatOptions::deep_delete() {
+	SAFEDELETE(field_length_);
+	SAFEDELETE(precision_);
+	delete this;
+}
+
+IR* Precision::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(iconst_1_);
+	auto tmp2 = SAFETRANSLATE(iconst_2_);
+	res = new IR(IRTYPE::kPrecision, OP3(TERMINAL::tOpLp, TERMINAL::tOpComma, TERMINAL::tOpRp), tmp1, tmp2);
+
+	TRANSLATEEND
+}
+
+void Precision::deep_delete() {
+	SAFEDELETE(iconst_1_);
+	SAFEDELETE(iconst_2_);
+	delete this;
+}
+
+IR* OptFieldLength::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kOptFieldLength, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(field_length_);
+			res = new IR(IRTYPE::kOptFieldLength, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void OptFieldLength::deep_delete() {
+	SAFEDELETE(field_length_);
+	delete this;
+}
+
+IR* FieldLength::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(iconst_);
+	res = new IR(IRTYPE::kFieldLength, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void FieldLength::deep_delete() {
+	SAFEDELETE(iconst_);
+	delete this;
+}
+
+IR* Literal::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kLiteral, OP3(TERMINAL::tNull, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kLiteral, OP3(TERMINAL::tFalse, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kLiteral, OP3(TERMINAL::tTrue, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Literal::deep_delete() {
+	delete this;
+}
+
+IR* Columnref::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(column_name_);
+			res = new IR(IRTYPE::kColumnref, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(table_name_);
+			auto tmp2 = SAFETRANSLATE(column_name_);
+			res = new IR(IRTYPE::kColumnref, OP3(TERMINAL::tEmpty, TERMINAL::tOpDot, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void Columnref::deep_delete() {
+	SAFEDELETE(column_name_);
+	SAFEDELETE(table_name_);
+	delete this;
+}
+
+IR* CompOp::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			res = new IR(IRTYPE::kCompOp, OP3(TERMINAL::tOpEqual, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(1)
+			res = new IR(IRTYPE::kCompOp, OP3(TERMINAL::tOpGreatereq, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(2)
+			res = new IR(IRTYPE::kCompOp, OP3(TERMINAL::tOpGreaterthan, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(3)
+			res = new IR(IRTYPE::kCompOp, OP3(TERMINAL::tOpLesseq, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(4)
+			res = new IR(IRTYPE::kCompOp, OP3(TERMINAL::tOpLessthan, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+		CASESTART(5)
+			res = new IR(IRTYPE::kCompOp, OP3(TERMINAL::tOpNotequal, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void CompOp::deep_delete() {
+	delete this;
+}
+
+IR* AllSubquery::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			res = new IR(IRTYPE::kAllSubquery, OP3(TERMINAL::tAll, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			res = new IR(IRTYPE::kAllSubquery, OP3(TERMINAL::tAny, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(2)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			res = new IR(IRTYPE::kAllSubquery, OP3(TERMINAL::tSome, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void AllSubquery::deep_delete() {
+	SAFEDELETE(subquery_);
+	delete this;
+}
+
+IR* InSubquery::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			res = new IR(IRTYPE::kInSubquery, OP3(TERMINAL::tIn, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(subquery_);
+			res = new IR(IRTYPE::kInSubquery, OP3(TERMINAL::tNotIn, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void InSubquery::deep_delete() {
+	SAFEDELETE(subquery_);
+	delete this;
+}
+
+IR* ExprList::translate() {
+	TRANSLATESTART
+
+	SWITCHSTART
+		CASESTART(0)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			res = new IR(IRTYPE::kExprList, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+		CASEEND
+		CASESTART(1)
+			auto tmp1 = SAFETRANSLATE(expr_);
+			auto tmp2 = SAFETRANSLATE(expr_list_);
+			res = new IR(IRTYPE::kExprList, OP3(TERMINAL::tEmpty, TERMINAL::tOpComma, TERMINAL::tEmpty), tmp1, tmp2);
+		CASEEND
+	SWITCHEND
+
+	TRANSLATEEND
+}
+
+void ExprList::deep_delete() {
+	SAFEDELETE(expr_);
+	SAFEDELETE(expr_list_);
+	delete this;
+}
+
+IR*  Iconst::translate(){
+	TRANSLATESTART
+
+	res = new IR(kIconst, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+	res->long_val_ = this->long_val_;
+
+	TRANSLATEEND
+}
+
+void Iconst::deep_delete(){
+	delete this;
+}
+
+IR*  Fconst::translate(){
+	TRANSLATESTART
+
+	res = new IR(kFconst, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+	res->float_val_ = this->float_val_;
+
+	TRANSLATEEND
+}
+
+void Fconst::deep_delete(){
+	delete this;
+}
+
+IR*  Sconst::translate(){
+	TRANSLATESTART
+
+	res = new IR(kSconst, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+	res->str_val_ = this->str_val_;
+
+	TRANSLATEEND
+}
+
+void Sconst::deep_delete(){
+	delete this;
+}
+
+IR*  Ident::translate(){
+	TRANSLATESTART
+
+	res = new IR(kIdent, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+	res->str_val_ = this->str_val_;
+
+	TRANSLATEEND
+}
+
+void Ident::deep_delete(){
+	delete this;
+}
+
+IR* Alias::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(ident_);
+	res = new IR(IRTYPE::kAlias, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void Alias::deep_delete() {
+	SAFEDELETE(ident_);
+	delete this;
+}
+
+IR* ColumnName::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(ident_);
+	res = new IR(IRTYPE::kColumnName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void ColumnName::deep_delete() {
+	SAFEDELETE(ident_);
+	delete this;
+}
+
+IR* WindowName::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(ident_);
+	res = new IR(IRTYPE::kWindowName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void WindowName::deep_delete() {
+	SAFEDELETE(ident_);
+	delete this;
+}
+
+IR* TableName::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(ident_);
+	res = new IR(IRTYPE::kTableName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void TableName::deep_delete() {
+	SAFEDELETE(ident_);
+	delete this;
+}
+
+IR* ConstraintName::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(ident_);
+	res = new IR(IRTYPE::kConstraintName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void ConstraintName::deep_delete() {
+	SAFEDELETE(ident_);
+	delete this;
+}
+
+IR* IndexName::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(ident_);
+	res = new IR(IRTYPE::kIndexName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void IndexName::deep_delete() {
+	SAFEDELETE(ident_);
+	delete this;
+}
+
+IR* ViewName::translate() {
+	TRANSLATESTART
+
+	auto tmp1 = SAFETRANSLATE(ident_);
+	res = new IR(IRTYPE::kViewName, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), tmp1, nullptr);
+
+	TRANSLATEEND
+}
+
+void ViewName::deep_delete() {
+	SAFEDELETE(ident_);
+	delete this;
+}
+
diff --git a/src/connector.cpp b/src/connector.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..6ee4746b6d636712f0739a83ce2a24bb7fafdda0
--- /dev/null
+++ b/src/connector.cpp
@@ -0,0 +1,177 @@
+#include "../include/connector.h"
+
+static void myproc(void* arg, const PGresult* res) {
+	return;
+}
+
+Connector::Connector(const char* host, const char* userName, const char* password, unsigned int port, const char* serverName) {
+	conninfo_ += "host=" + string(host) + " ";
+	conninfo_ += "user=" + string(userName) + " ";
+	conninfo_ += "password=" + string(password) + " ";
+	conninfo_ += "port=" + to_string(port);
+	
+	serverName_ = serverName;
+
+	return;
+}
+
+bool Connector::start_db(const char* file, char* const options[]) {
+	pid_t dbPid = get_pid_by_name();
+
+	if (dbPid != 1) {
+		SQLSTATUS status = reset_db();
+
+		if (status == SQLSTATUS::ssNormal) {
+			return true;
+		}
+
+		return false;
+	}
+
+	int i = 0;
+	while (dbPid == 1 && i < 10) {
+		pid_t pid = fork();
+
+		if (pid == 0) {
+			execvp(file, options);
+			exit(1);
+		}
+		else {
+			wait(NULL);
+			sleep(5);
+		}
+
+		dbPid = get_pid_by_name();
+		i++;
+	}
+
+	if (dbPid != 1) {
+		SQLSTATUS status = reset_db();
+
+		if (status == SQLSTATUS::ssNormal) {
+			return true;
+		}		
+	}
+
+	return false;
+}
+bool Connector::close_db() {
+	pid_t dbPid = get_pid_by_name();
+	int res = -1;
+
+	if (dbPid != 1) {
+		res = kill(dbPid, SIGKILL);
+	}
+
+	if (res == -1) {
+		return false;
+	}
+
+	sleep(5);
+
+	return true;
+}
+
+SQLSTATUS Connector::execute(const char* sql) {
+	SQLSTATUS res = SQLSTATUS::ssNormal;
+	string curConninfo = "dbname=test " + conninfo_;
+
+	PGconn* conn = PQconnectdb(curConninfo.c_str());
+	if (PQstatus(conn) != CONNECTION_OK) {
+		PQfinish(conn);
+		return SQLSTATUS::ssConnectFailed;
+	}
+
+	PQsetNoticeReceiver(conn, myproc, nullptr);
+
+	reset_database(conn);
+
+	PGresult* pgres = PQexec(conn, sql);
+	if (PQstatus(conn) != CONNECTION_OK) {
+		res = SQLSTATUS::ssServerCrash;
+	}
+	else if (PQresultStatus(pgres) != PGRES_COMMAND_OK && PQresultStatus(pgres) != PGRES_TUPLES_OK) {
+		res = SQLSTATUS::ssSemanticError;
+	}
+
+	PQclear(pgres);
+	PQfinish(conn);
+
+	return res;
+}
+
+void Connector::reset_database(PGconn* conn) {
+	PGresult* res = PQexec(conn, "DROP SCHEMA public CASCADE; CREATE SCHEMA public;");
+	PQclear(res);
+
+	return;
+}
+
+SQLSTATUS Connector::reset_db() {
+	SQLSTATUS res = SQLSTATUS::ssNormal;
+	string curConninfo = "dbname=postgres " + conninfo_;
+
+	PGconn* conn = PQconnectdb(curConninfo.c_str());
+	if (PQstatus(conn) != CONNECTION_OK) {
+		PQfinish(conn);
+		return SQLSTATUS::ssConnectFailed;
+	}
+
+	PQsetNoticeReceiver(conn, myproc, nullptr);
+
+	int i = 0;
+
+	PGresult* pgres = PQexec(conn, "DROP DATABASE IF EXISTS test;");
+	PQclear(pgres);
+	pgres = PQexec(conn, "CREATE DATABASE IF NOT EXISTS test;");
+	PQclear(pgres);
+
+	PQfinish(conn);
+
+	res = execute("SELECT 1;");
+
+	return res;
+}
+
+pid_t Connector::get_pid_by_name() {
+    DIR* dir;
+    struct dirent* ptr;
+    FILE* fp;
+    char filepath[50];
+    char cur_task_name[50];
+    char buf[BUF_SIZE];
+
+    pid_t pid = 1;
+
+    dir = opendir("/proc");
+    if (NULL != dir)
+    {
+        while ((ptr = readdir(dir)) != NULL)
+        {
+
+            if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0))
+                continue;
+            if (DT_DIR != ptr->d_type)
+                continue;
+
+            sprintf(filepath, "/proc/%s/status", ptr->d_name);
+            fp = fopen(filepath, "r");
+            if (NULL != fp)
+            {
+                if (fgets(buf, BUF_SIZE - 1, fp) == NULL) {
+                    fclose(fp);
+                    continue;
+                }
+                sscanf(buf, "%*s %s", cur_task_name);
+
+                if (!strcmp(serverName_.c_str(), cur_task_name)) {
+                    sscanf(ptr->d_name, "%d", &pid);
+                }
+                fclose(fp);
+            }
+        }
+        closedir(dir);
+    }
+
+    return pid;
+}
diff --git a/src/instantiate.cpp b/src/instantiate.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..f1f80cfecaa779e2f32ec870ddfafa37230dac5b
--- /dev/null
+++ b/src/instantiate.cpp
@@ -0,0 +1,3555 @@
+#include "../include/instantiate.h"
+
+using namespace std;
+
+vector<vector<TypeCompatibility>> Column::compatibility_ = {};
+map<TERMINAL, ColumnType> Column::typeTranslation_ = {
+	{TERMINAL::tInt, ColumnType::ctInt},
+	{TERMINAL::tTinyint, ColumnType::ctTinyInt},
+	{TERMINAL::tSmallint, ColumnType::ctSmallInt},
+	{TERMINAL::tMediumint, ColumnType::ctMediumInt},
+	{TERMINAL::tBigint, ColumnType::ctBigInt},
+	{TERMINAL::tReal, ColumnType::ctReal},
+	{TERMINAL::tDouble, ColumnType::ctDouble},
+	{TERMINAL::tFloat, ColumnType::ctFloat},
+	{TERMINAL::tDecimal, ColumnType::ctDecimal},
+	{TERMINAL::tNumeric, ColumnType::ctNumeric},
+	{TERMINAL::tFixed, ColumnType::ctFixed},
+
+	{TERMINAL::tBool, ColumnType::ctBool},
+	{TERMINAL::tBoolean, ColumnType::ctBoolean},
+
+	{TERMINAL::tChar, ColumnType::ctChar},
+	{TERMINAL::tBinary, ColumnType::ctBinary},
+	{TERMINAL::tVarchar, ColumnType::ctVarchar},
+	{TERMINAL::tVarbinary, ColumnType::ctVarbinary},
+	{TERMINAL::tLongVarbinary, ColumnType::ctLongVarbinary},
+	{TERMINAL::tTinyblob, ColumnType::ctTinyBlob},
+	{TERMINAL::tMediumblob, ColumnType::ctMediumBlob},
+	{TERMINAL::tLongblob, ColumnType::ctLongBlob},
+	{TERMINAL::tBlob, ColumnType::ctBlob},
+	{TERMINAL::tTinytext, ColumnType::ctTinyText},
+	{TERMINAL::tMediumtext, ColumnType::ctMediumText},
+	{TERMINAL::tLongtext, ColumnType::ctLongText},
+	{TERMINAL::tText, ColumnType::ctText}
+};
+map<ColumnType, ColumnBasicType> Column::typeToBasicType_ = {
+	{ColumnType::ctNull, ColumnBasicType::ctBool},
+
+	{ColumnType::ctInt, ColumnBasicType::ctNumber},
+	{ColumnType::ctTinyInt, ColumnBasicType::ctNumber},
+	{ColumnType::ctSmallInt, ColumnBasicType::ctNumber},
+	{ColumnType::ctMediumInt, ColumnBasicType::ctNumber},
+	{ColumnType::ctBigInt, ColumnBasicType::ctNumber},
+	{ColumnType::ctReal, ColumnBasicType::ctNumber},
+	{ColumnType::ctDouble, ColumnBasicType::ctNumber},
+	{ColumnType::ctFloat, ColumnBasicType::ctNumber},
+	{ColumnType::ctDecimal, ColumnBasicType::ctNumber},
+	{ColumnType::ctNumeric, ColumnBasicType::ctNumber},
+	{ColumnType::ctFixed, ColumnBasicType::ctNumber},
+
+	{ColumnType::ctBool, ColumnBasicType::ctBool},
+	{ColumnType::ctBoolean, ColumnBasicType::ctBool},
+
+	{ColumnType::ctChar, ColumnBasicType::ctString},
+	{ColumnType::ctBinary, ColumnBasicType::ctString},
+	{ColumnType::ctVarchar, ColumnBasicType::ctString},
+	{ColumnType::ctVarbinary, ColumnBasicType::ctString},
+	{ColumnType::ctLongVarbinary, ColumnBasicType::ctString},
+	{ColumnType::ctTinyBlob, ColumnBasicType::ctString},
+	{ColumnType::ctMediumBlob, ColumnBasicType::ctString},
+	{ColumnType::ctLongBlob, ColumnBasicType::ctString},
+	{ColumnType::ctBlob, ColumnBasicType::ctString},
+	{ColumnType::ctTinyText, ColumnBasicType::ctString},
+	{ColumnType::ctMediumText, ColumnBasicType::ctString},
+	{ColumnType::ctLongText, ColumnBasicType::ctString},
+	{ColumnType::ctText, ColumnBasicType::ctString}
+};
+
+Instantiator::Instantiator() {
+	random_device rd;
+	srand(rd());
+
+	IRTrim_ = new IRTrim(this);
+	exprInstantiator_ = new ExprInstantiator(this);
+	globalStatusManger_ = new GlobalStatusManger();
+	
+	startTime = chrono::steady_clock::now();
+
+	return;
+}
+Instantiator::~Instantiator() {
+	delete IRTrim_;
+	delete globalStatusManger_;
+	delete exprInstantiator_;
+
+	return;
+}
+
+unsigned int Instantiator::get_duration_ms(){
+	chrono::time_point<chrono::steady_clock> curTime = chrono::steady_clock::now();
+
+	return chrono::duration_cast<chrono::milliseconds>(curTime - startTime).count();
+}
+
+bool Instantiator::instantaite_sql(IR* root) {
+	int maxCapacity = calc_capacity(root);
+	int curCapacity = calc_node(root);
+
+	if (curCapacity > maxCapacity) {
+		return false;
+	}
+
+	instantiate_parse_toplevel(NT_check(root, IRTYPE::kParseToplevel));
+
+	return true;
+}
+int Instantiator::calc_capacity(IR* root) {
+	int tmp_node_upper_limit = 0;
+
+	unsigned int curCapacity = CAPACITYBASE * pow(CAPACITYGROWTHRATE, static_cast<unsigned int>(get_duration_ms() / TIMETHRESHOLD));
+	curCapacity = curCapacity > MAXCAPACITY ? MAXCAPACITY : curCapacity;
+
+	if (root->type_ != IRTYPE::kParseToplevel)
+		return 0;
+
+	IR* stmtmulti = root->left_;
+
+	while (stmtmulti) {
+		tmp_node_upper_limit += curCapacity;
+		stmtmulti = stmtmulti->right_;
+	}
+
+	return tmp_node_upper_limit;
+}
+int Instantiator::calc_node(IR* root) {
+	int res = 0;
+
+	if (root->left_) res += calc_node(root->left_);
+	if (root->right_) res += calc_node(root->right_);
+
+	return res + 1;
+}
+
+void Instantiator::instantiate_parse_toplevel(IR* parse_toplevel) {
+	assert(parse_toplevel != nullptr && parse_toplevel->type_ == IRTYPE::kParseToplevel);
+	IR* stmtmulti = NT_check(parse_toplevel->left_, IRTYPE::kStmtmulti);
+
+	while (stmtmulti != nullptr) {
+		IR* stmt = NT_check(stmtmulti->left_, IRTYPE::kStmt);		
+
+		switch (stmt->left_->type_) {
+			case IRTYPE::kSelectStmt: {
+				instantiate_select_stmt(NT_check(stmt->left_, IRTYPE::kSelectStmt));
+				break;
+			}
+			case IRTYPE::kCreateTableStmt: {
+				instantiate_create_table_stmt(NT_check(stmt->left_, IRTYPE::kCreateTableStmt));
+				break;
+			}
+			case IRTYPE::kCreateViewStmt: {
+				instantiate_create_view_stmt(NT_check(stmt->left_, IRTYPE::kCreateViewStmt));
+				break;
+			}
+			case IRTYPE::kCreateIndexStmt: {
+				instantiate_create_index_stmt(NT_check(stmt->left_, IRTYPE::kCreateIndexStmt));
+				break;
+			}
+			case IRTYPE::kDropIndexStmt: {
+				instantiate_drop_index_stmt(NT_check(stmt->left_, IRTYPE::kDropIndexStmt));
+				break;
+			}
+			case IRTYPE::kDropTableStmt: {
+				instantiate_drop_table_or_view_stmt(NT_check(stmt->left_, IRTYPE::kDropTableStmt), IdentifierType::iTable);
+				break;
+			}
+			case IRTYPE::kDropViewStmt: {
+				instantiate_drop_table_or_view_stmt(NT_check(stmt->left_, IRTYPE::kDropViewStmt), IdentifierType::iView);
+				break;
+			}
+			case IRTYPE::kDeleteStmt: {
+				instantiate_delete_stmt(NT_check(stmt->left_, IRTYPE::kDeleteStmt));
+				break;
+			}
+			case IRTYPE::kUpdateStmt: {
+				instantiate_update_stmt(NT_check(stmt->left_, IRTYPE::kUpdateStmt));
+				break;
+			}
+			case IRTYPE::kInsertStmt: {
+				instantiate_insert_stmt(NT_check(stmt->left_, IRTYPE::kInsertStmt));
+				break;
+			}
+			case IRTYPE::kAlterTableStmt: {
+				instantiate_alter_table_stmt(NT_check(stmt->left_, IRTYPE::kAlterTableStmt));
+				break;
+			}
+			default: {
+				return;
+			}
+		}
+
+		stmtmulti = stmtmulti->right_;
+	}
+
+	globalStatusManger_->reset_status();
+
+	return;
+}
+
+void Instantiator::instantiate_alter_table_stmt(IR* alter_table_stmt) {
+	IR* table_name = NT_check(alter_table_stmt->left_, IRTYPE::kTableName);
+	IR* alter_list = NT_check(alter_table_stmt->right_, IRTYPE::kAlterList);
+
+	vector<Table*> tables = globalStatusManger_->get_acce_table(IdentifierType::iTable);
+	if (tables.empty()) {
+		return;
+	}
+
+	Table* table = tables[rand() % tables.size()];
+	instantiate_ident(table_name, IdentifierType::iTable, table->identifierName_);
+
+	IR* curNode = alter_list;
+	while (curNode != nullptr) {
+		IR* alter_list_item = NT_check(curNode->left_, IRTYPE::kAlterListItem);
+		instantiate_alter_list_item(alter_list_item, table);
+
+		curNode = curNode->right_;
+	}
+
+	return;
+}
+void Instantiator::instantiate_alter_list_item(IR* alter_list_item, Table* table) {
+	switch (alter_list_item->op_->prefix_) {
+		case TERMINAL::tAddColumn: {
+			IR* column_name = NT_check(alter_list_item->left_, IRTYPE::kColumnName);
+			IR* field_def = NT_check(alter_list_item->right_->left_, IRTYPE::kFieldDef);
+			IR* opt_place = NT_check(alter_list_item->right_->right_, IRTYPE::kOptPlace);
+
+			IR* data_type = NT_check(field_def->left_, IRTYPE::kDataType);
+			IR* opt_column_attribute_list = NT_check(field_def->right_, IRTYPE::kOptColumnAttributeList);
+
+			ColumnType type = instantiate_data_type(data_type);
+
+			name_t newColumnName = table->get_acce_column_name();
+			Column* column = new Column(newColumnName, type);
+
+			instantiate_ident(column_name, IdentifierType::iColumn, newColumnName);
+
+			if (opt_place->left_ != nullptr) {
+				IR* tmp_column_name = NT_check(opt_place->left_, IRTYPE::kColumnName);
+
+				Column* tmp_column = table->columns_[rand() % table->columns_.size()];
+				instantiate_ident(tmp_column_name, IdentifierType::iColumn, tmp_column->identifierName_);
+
+				table->add_column(column, tmp_column);
+			}
+			else if(opt_place->op_->prefix_ == TERMINAL::tFirst) {
+				table->add_column_first(column);
+			}
+			else {
+				table->add_column(column);
+			}
+
+			if (opt_column_attribute_list->left_ != nullptr) {
+				IR* curNode = NT_check(opt_column_attribute_list->left_, IRTYPE::kColumnAttributeList);
+
+				while (curNode != nullptr) {
+					IR* column_attribute = NT_check(curNode->left_, IRTYPE::kColumnAttribute);
+					instantiate_column_attribute(column_attribute, column, table);
+
+					curNode = curNode->right_;
+				}
+			}
+
+			break;
+		}
+		case TERMINAL::tAddColumnOpLp: {
+			IR* table_element_list = NT_check(alter_list_item->left_, IRTYPE::kTableElementList);
+
+			instantiate_table_element_list(table_element_list, table);
+
+			break;
+		}
+		case TERMINAL::tAdd: {
+			IR* table_constraint_def = NT_check(alter_list_item->left_, IRTYPE::kTableConstraintDef);
+
+			if (table_constraint_def->op_->prefix_ == TERMINAL::tIndex) {
+				instantiate_table_constraint_def_index(table_constraint_def, table);
+			}
+			else if (table_constraint_def->op_->middle_ == tForeignKey) {
+				instantiate_table_constraint_def_foreign_key(table_constraint_def, table);
+			}
+			else if (table_constraint_def->right_->type_ == IRTYPE::kCheckConstraint) {
+				instantiate_table_constraint_def_check(table_constraint_def, table);
+			}
+			else {
+				instantiate_table_constraint_def_key(table_constraint_def, table);
+			}
+
+			break;
+		}
+		case TERMINAL::tChangeColumn: {
+			IR* column_name_1 = nullptr;
+			IR* column_name_2 = nullptr;
+			IR* field_def = nullptr;
+			IR* opt_place = nullptr;
+
+			IR* unknown = nullptr;
+
+			column_name_1 = NT_check(alter_list_item->left_, IRTYPE::kColumnName);
+			unknown = alter_list_item->right_;
+
+			column_name_2 = NT_check(unknown->left_, IRTYPE::kColumnName);
+			unknown = unknown->right_;
+
+			field_def = NT_check(unknown->left_, IRTYPE::kFieldDef);
+			opt_place = NT_check(unknown->right_, IRTYPE::kOptPlace);
+
+			IR* data_type = NT_check(field_def->left_, IRTYPE::kDataType);
+			IR* opt_column_attribute_list = NT_check(field_def->right_, IRTYPE::kOptColumnAttributeList);
+
+			Column* column = table->columns_[rand() % table->columns_.size()];
+			column->columnType_ = instantiate_data_type(data_type);
+
+			name_t newColumnName = table->get_acce_column_name();
+			instantiate_ident(column_name_1, IdentifierType::iColumn, column->identifierName_);
+			instantiate_ident(column_name_2, IdentifierType::iColumn, newColumnName);
+
+			table->column_rename(column, column->identifierName_, newColumnName);
+
+			if (opt_place->left_ != nullptr) {
+				IR* tmp_column_name = NT_check(opt_place->left_, IRTYPE::kColumnName);
+
+				Column* tmp_column = table->columns_[rand() % table->columns_.size()];
+
+				if (tmp_column != column) {
+					instantiate_ident(tmp_column_name, IdentifierType::iColumn, tmp_column->identifierName_);
+					table->move_column(column, tmp_column);
+				}
+				else {
+					deep_delete(opt_place->left_);
+					opt_place->left_ = nullptr;
+					opt_place->op_->prefix_ = TERMINAL::tEmpty;
+				}
+			}
+			else if (opt_place->op_->prefix_ == TERMINAL::tFirst) {
+				table->move_column_first(column);
+			}
+
+			if (opt_column_attribute_list->left_ != nullptr) {
+				IR* curNode = NT_check(opt_column_attribute_list->left_, IRTYPE::kColumnAttributeList);
+
+				while (curNode != nullptr) {
+					IR* column_attribute = NT_check(curNode->left_, IRTYPE::kColumnAttribute);
+					instantiate_column_attribute(column_attribute, column, table);
+
+					curNode = curNode->right_;
+				}
+			}
+
+			break;
+		}
+		case TERMINAL::tModifyColumn: {
+			IR* column_name = NT_check(alter_list_item->left_, IRTYPE::kColumnName);
+			IR* field_def = NT_check(alter_list_item->right_->left_, IRTYPE::kFieldDef);
+			IR* opt_place = NT_check(alter_list_item->right_->right_, IRTYPE::kOptPlace);
+
+			IR* data_type = NT_check(field_def->left_, IRTYPE::kDataType);
+			IR* opt_column_attribute_list = NT_check(field_def->right_, IRTYPE::kOptColumnAttributeList);
+
+			Column* column = table->columns_[rand() % table->columns_.size()];
+			column->columnType_ = instantiate_data_type(data_type);
+			instantiate_ident(column_name, IdentifierType::iColumn, column->identifierName_);
+
+			if (opt_place->left_ != nullptr) {
+				IR* tmp_column_name = NT_check(opt_place->left_, IRTYPE::kColumnName);
+
+				Column* tmp_column = table->columns_[rand() % table->columns_.size()];
+				
+				if (tmp_column != column) {
+					instantiate_ident(tmp_column_name, IdentifierType::iColumn, tmp_column->identifierName_);
+					table->move_column(column, tmp_column);
+				}
+				else {
+					deep_delete(opt_place->left_);
+					opt_place->left_ = nullptr;
+					opt_place->op_->prefix_ = TERMINAL::tEmpty;
+				}
+			}
+			else if (opt_place->op_->prefix_ == TERMINAL::tFirst) {
+				table->move_column_first(column);
+			}
+
+			if (opt_column_attribute_list->left_ != nullptr) {
+				IR* curNode = NT_check(opt_column_attribute_list->left_, IRTYPE::kColumnAttributeList);
+
+				while (curNode != nullptr) {
+					IR* column_attribute = NT_check(curNode->left_, IRTYPE::kColumnAttribute);
+					instantiate_column_attribute(column_attribute, column, table);
+
+					curNode = curNode->right_;
+				}
+			}
+
+			break;
+		}
+		case TERMINAL::tDropColumn: {
+			IR* column_name = NT_check(alter_list_item->left_, IRTYPE::kColumnName);
+
+			if (table->columns_.size() <= 1) {
+				return;
+			}
+
+			Column* column = table->columns_[rand() % table->columns_.size()];
+			instantiate_ident(column_name, IdentifierType::iColumn, column->identifierName_);
+
+			table->drop_column(column);
+
+			break;
+		}
+		case TERMINAL::tDropForeignKey: {
+			IR* constraint_name = NT_check(alter_list_item->left_, IRTYPE::kConstraintName);
+
+			Constraint* constraint = nullptr;
+			for (Constraint* c : table->constraints_) {
+				if (c->constraintType_ != ConstraintType::ctForeignKey) {
+					continue;
+				}
+
+				constraint = c;
+				break;
+			}
+
+			if (constraint == nullptr) {
+				return;
+			}
+
+			instantiate_ident(constraint_name, IdentifierType::iConstraint, constraint->identifierName_);
+
+			table->drop_constraint(constraint);
+
+			break;
+		}
+		case TERMINAL::tDropPrimaryKey: {
+			if (table->hasPrimaryKey_ == false) {
+				return;
+			}
+
+			Constraint* constraint = nullptr;
+			for (Constraint* c : table->constraints_) {
+				if (c->constraintType_ != ConstraintType::ctPrimaryKey) {
+					continue;
+				}
+
+				constraint = c;
+				break;
+			}
+
+			assert(constraint != nullptr);
+
+			table->drop_constraint(constraint);
+			table->hasPrimaryKey_ = false;
+
+			break;
+		}
+		case TERMINAL::tDropIndex: {
+			IR* index_name = NT_check(alter_list_item->left_, IRTYPE::kIndexName);
+
+			if (table->indexes_.empty()) {
+				return;
+			}
+
+			Index* index = table->indexes_[rand() % table->indexes_.size()];
+			instantiate_ident(index_name, IdentifierType::iIndex, index->identifierName_);
+
+			table->drop_index(index);
+
+			break;
+		}
+		case TERMINAL::tDropCheck: {
+			IR* constraint_name = NT_check(alter_list_item->left_, IRTYPE::kConstraintName);
+
+			Constraint* constraint = nullptr;
+			for (Constraint* c : table->constraints_) {
+				if (c->constraintType_ != ConstraintType::ctCheck) {
+					continue;
+				}
+
+				constraint = c;
+				break;
+			}
+
+			if (constraint == nullptr) {
+				return;
+			}
+
+			instantiate_ident(constraint_name, IdentifierType::iConstraint, constraint->identifierName_);
+
+			table->drop_constraint(constraint);
+
+			break;
+		}
+		case TERMINAL::tDropConstraint: {
+			IR* constraint_name = NT_check(alter_list_item->left_, IRTYPE::kConstraintName);
+
+			if (table->constraints_.empty()) {
+				return;
+			}
+
+			Constraint* constraint = table->constraints_[rand() % table->constraints_.size()];
+			instantiate_ident(constraint_name, IdentifierType::iConstraint, constraint->identifierName_);
+
+			table->drop_constraint(constraint);
+
+			break;
+		}
+		case TERMINAL::tAlterColumn: {
+			IR* column_name = NT_check(alter_list_item->left_, IRTYPE::kColumnName);
+
+			Column* column = table->columns_[rand() % table->columns_.size()];
+			instantiate_ident(column_name, IdentifierType::iColumn, column->identifierName_);
+
+			switch (alter_list_item->op_->middle_) {
+				case TERMINAL::tSetDefaultOpLp: {
+					IR* expr_root = NT_check(alter_list_item->right_, IRTYPE::kExprRoot);
+
+					exprInstantiator_->instantiate_expr_root(expr_root, table->columns_, StmtLocation::slNotSubquery);
+					
+					break;
+				}
+				case TERMINAL::tDropDefault: {
+					break;
+				}
+				case TERMINAL::tSet: {
+					break;
+				}
+				default: {
+					fprintf(stderr, "ERROR: Unknown ALTER COLUMN!!!\n");
+					assert(0);
+				}
+			}
+
+			break;
+		}
+		case TERMINAL::tAlterIndex: {
+			IR* index_name = NT_check(alter_list_item->left_, IRTYPE::kIndexName);
+
+			if (table->indexes_.empty()) {
+				return;
+			}
+
+			Index* index = table->indexes_[rand() % table->indexes_.size()];
+			instantiate_ident(index_name, IdentifierType::iIndex, index->identifierName_);
+
+			break;
+		}
+		case TERMINAL::tRenameTo: {
+			IR* table_name = NT_check(alter_list_item->left_, IRTYPE::kTableName);
+
+			name_t newTableName = globalStatusManger_->get_new_table_name();
+
+			instantiate_ident(table_name, IdentifierType::iTable, newTableName);
+
+			table->identifierName_ = newTableName;
+
+			break;
+		}
+		case TERMINAL::tRenameIndex: {
+			IR* index_name_1 = NT_check(alter_list_item->left_, IRTYPE::kIndexName);
+			IR* index_name_2 = NT_check(alter_list_item->right_, IRTYPE::kIndexName);
+
+			if (table->indexes_.empty()) {
+				return;
+			}
+
+			Index* index = table->indexes_[rand() % table->indexes_.size()];
+			name_t newIndexName = globalStatusManger_->get_new_index_name();
+
+			instantiate_ident(index_name_1, IdentifierType::iIndex, index->identifierName_);
+			instantiate_ident(index_name_2, IdentifierType::iIndex, newIndexName);
+
+			index->identifierName_ = newIndexName;
+
+			break;
+		}
+		case TERMINAL::tRenameColumn: {
+			IR* column_name_1 = NT_check(alter_list_item->left_, IRTYPE::kColumnName);
+			IR* column_name_2 = NT_check(alter_list_item->right_, IRTYPE::kColumnName);
+
+			Column* column = table->columns_[rand() % table->columns_.size()];
+			name_t newColumnName = table->get_acce_column_name();
+
+			instantiate_ident(column_name_1, IdentifierType::iColumn, column->identifierName_);
+			instantiate_ident(column_name_2, IdentifierType::iColumn, newColumnName);
+
+			table->column_rename(column, column->identifierName_, newColumnName);
+
+			break;
+		}
+		default: {
+			fprintf(stderr, "ERROR: Unknown alter_list_item!!!\n");
+			assert(0);
+		}
+	}
+
+	return;
+}
+
+void Instantiator::instantiate_insert_stmt(IR* insert_stmt) {
+	IR* table_name = nullptr;
+	IR* insert_from_constructor = nullptr;
+	IR* opt_values_reference = nullptr;
+	IR* opt_insert_update_list = nullptr;
+	IR* update_list = nullptr;
+	IR* insert_query_expression = nullptr;
+
+	IR* unknown = insert_stmt->right_->right_;
+
+	table_name = NT_check(unknown->left_, IRTYPE::kTableName);
+	unknown = unknown->right_;
+
+	switch (unknown->left_->type_) {
+		case IRTYPE::kInsertFromConstructor: {
+			insert_from_constructor = NT_check(unknown->left_, IRTYPE::kInsertFromConstructor);
+			unknown = unknown->right_;
+
+			opt_values_reference = NT_check(unknown->left_, IRTYPE::kOptValuesReference);
+
+			break;
+		}
+		case IRTYPE::kUpdateList: {
+			update_list = NT_check(unknown->left_, IRTYPE::kUpdateList);
+			unknown = unknown->right_;
+
+			opt_values_reference = NT_check(unknown->left_, IRTYPE::kOptValuesReference);
+
+			break;
+		}
+		case IRTYPE::kInsertQueryExpression: {
+			insert_query_expression = NT_check(unknown->left_, IRTYPE::kInsertQueryExpression);
+			break;
+		}
+		default: {
+			fprintf(stderr, "ERROR: Unknown Insert Stmt!!!\n");
+			assert(0);
+		}
+	}
+
+	opt_insert_update_list = NT_check(unknown->right_, IRTYPE::kOptInsertUpdateList);
+
+	vector<Table*> tables = globalStatusManger_->get_acce_table(IdentifierType::iTable);
+	if (tables.empty()) {
+		return;
+	}
+
+	globalStatusManger_->push_selectInfo(StmtLocation::slNotSubquery, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	Table* chosenTable = tables[rand() % tables.size()];
+	instantiate_ident(table_name, IdentifierType::iTable, chosenTable->identifierName_);
+
+	Table* newTable = new Table(chosenTable, info);
+	info->add_used_table(newTable);
+
+	int chosenColumnNumber = chosenTable->columns_.size();
+	Table* tmpTable = nullptr;
+
+	info->update_acceColumns();
+
+	if (insert_from_constructor != nullptr) {
+		bool hasOptColumn = false;
+
+		IR* values_list = nullptr;
+		IR* column_list = nullptr;
+
+		if (insert_from_constructor->right_ == nullptr) {
+			values_list = NT_check(insert_from_constructor->left_, IRTYPE::kValuesList);
+		}
+		else {
+			values_list = NT_check(insert_from_constructor->right_, IRTYPE::kValuesList);
+			column_list = NT_check(insert_from_constructor->left_, IRTYPE::kColumnList);
+		}
+
+		if (column_list != nullptr) {
+			hasOptColumn = true;
+
+			vector<Column*> columnsSeq = chosenTable->get_column_seq();
+			vector<Column*> chosenColumns = vector<Column*>(columnsSeq.begin(), columnsSeq.begin() + exprInstantiator_->get_random_integer(1, chosenTable->columns_.size()));
+
+			chosenColumnNumber = chosenColumns.size();
+
+			instantiate_column_list(column_list, chosenColumns);
+		}
+
+		int tmpChosenColumnNumber = chosenColumnNumber;
+		if (hasOptColumn == false) {
+			tmpChosenColumnNumber = (rand() % 20) == 0 ? 0 : chosenColumnNumber;
+			chosenColumnNumber = tmpChosenColumnNumber;
+		}
+
+		instantiate_values_list(values_list, tmpChosenColumnNumber);
+	}
+	else if (update_list != nullptr) {
+		chosenColumnNumber = instantiate_update_list(update_list, nullptr);
+	}
+	else {
+		IR* query_expression = nullptr;
+		IR* column_list = nullptr;
+
+		if (insert_query_expression->right_ == nullptr) {
+			query_expression = NT_check(insert_query_expression->left_, IRTYPE::kQueryExpression);
+		}
+		else {
+			query_expression = NT_check(insert_query_expression->right_, IRTYPE::kQueryExpression);
+			column_list = NT_check(insert_query_expression->left_, IRTYPE::kColumnList);
+		}
+
+		if (column_list != nullptr) {
+			vector<Column*> columnsSeq = chosenTable->get_column_seq();
+			vector<Column*> chosenColumns = vector<Column*>(columnsSeq.begin(), columnsSeq.begin() + exprInstantiator_->get_random_integer(1, chosenTable->columns_.size()));
+
+			chosenColumnNumber = chosenColumns.size();
+
+			instantiate_column_list(column_list, chosenColumns);
+		}
+
+		Table* tmp = instantiate_query_expression(query_expression, StmtLocation::slNotSubquery, DEFAULTROWNUMBER, chosenColumnNumber);
+		delete tmp;
+	}
+
+	if (opt_values_reference != nullptr && opt_values_reference->left_ != nullptr) {
+		if (chosenColumnNumber != 0) {
+			IR* tmp_table_name = NT_check(opt_values_reference->left_, IRTYPE::kTableName);
+			IR* opt_column_list = NT_check(opt_values_reference->right_, IRTYPE::kOptColumnList);
+
+			name_t newTableName = globalStatusManger_->get_new_table_name();
+			instantiate_ident(tmp_table_name, IdentifierType::iTable, newTableName);
+
+			vector<name_t> chosenColumns;
+			if (opt_insert_update_list->left_ != nullptr) {
+				tmpTable = new Table(newTableName, IdentifierType::iTable, info);
+
+				for (int i = 0; i < chosenColumnNumber; i++) {
+					name_t newColumnName = tmpTable->get_acce_column_name();
+					Column* newColumn = new Column(newColumnName, ColumnType::ctNull);
+
+					tmpTable->add_column(newColumn);
+					chosenColumns.push_back(newColumnName);
+				}
+
+				if (opt_column_list->left_ == nullptr) {
+					opt_column_list->left_ = deep_copy(IRTrim_->simple_column_list_);
+					opt_column_list->op_->prefix_ = TERMINAL::tOpLp;
+					opt_column_list->op_->middle_ = TERMINAL::tOpRp;
+				}
+			}
+			else {
+				for (int i = 0; i < chosenColumnNumber; i++) {
+					chosenColumns.push_back(static_cast<name_t>(i));
+				}
+			}
+
+			if (opt_column_list->left_ != nullptr) {
+				IR* column_list = NT_check(opt_column_list->left_, IRTYPE::kColumnList);
+				instantiate_column_list(column_list, chosenColumns);
+			}
+		}
+		else {
+			deep_delete(opt_values_reference->left_);
+			deep_delete(opt_values_reference->right_);
+
+			opt_values_reference->left_ = nullptr;
+			opt_values_reference->right_ = nullptr;
+
+			opt_values_reference->op_->prefix_ = TERMINAL::tEmpty;
+		}
+	}
+
+	if (opt_insert_update_list->left_ != nullptr) {
+		IR* tmp_update_list = NT_check(opt_insert_update_list->left_, IRTYPE::kUpdateList);
+		instantiate_update_list(tmp_update_list, tmpTable);
+	}
+
+	if (tmpTable != nullptr) {
+		delete tmpTable;
+	}
+
+	globalStatusManger_->pop_selectInfo();
+
+	return;
+}
+void Instantiator::instantiate_values_list(IR* values_list, int chosenColumnNumber) {
+	IR* curNode = values_list;
+	while (curNode != nullptr) {
+		IR* opt_values = NT_check(curNode->left_->left_, IRTYPE::kOptValues);
+		IR* values = opt_values->left_ == nullptr ? nullptr : NT_check(opt_values->left_, IRTYPE::kValues);
+
+		if (chosenColumnNumber == 0 && values != nullptr) {
+			deep_delete(opt_values->left_);
+			opt_values->left_ = nullptr;
+			values = nullptr;
+		}
+		else if (chosenColumnNumber != 0 && values == nullptr) {
+			opt_values->left_ = deep_copy(IRTrim_->simple_values_);
+			values = opt_values->left_;
+		}
+
+		if (values != nullptr) {
+			assert(chosenColumnNumber > 0);
+			instantiate_values(values, chosenColumnNumber);
+		}
+
+		curNode = curNode->right_;
+	}
+
+	return;
+}
+void Instantiator::instantiate_values(IR* values, int chosenColumnNumber) {
+	int count = 0;
+	IR* curNode = values;
+	while (curNode != nullptr) {
+		IR* expr_or_default = NT_check(curNode->left_, IRTYPE::kExprOrDefault);
+		IR* expr_root = expr_or_default->left_ == nullptr ? nullptr : NT_check(expr_or_default->left_, IRTYPE::kExprRoot);
+
+		if (expr_root != nullptr) {
+			vector<Column*> tmp;
+			exprInstantiator_->instantiate_expr_root(expr_root, tmp, StmtLocation::slNotSubquery);
+		}
+
+		count++;
+
+		if (count == chosenColumnNumber && curNode->right_ != nullptr) {
+			deep_delete(curNode->right_);
+
+			curNode->right_ = nullptr;
+			curNode->op_->middle_ = TERMINAL::tEmpty;
+		}
+		else if (count < chosenColumnNumber && curNode->right_ == nullptr) {
+			curNode->right_ = deep_copy(IRTrim_->simple_values_);
+			curNode->op_->middle_ = TERMINAL::tOpComma;
+		}
+
+		curNode = curNode->right_;
+	}
+
+	return;
+}
+
+void Instantiator::instantiate_update_stmt(IR* update_stmt) {
+	IR* opt_with_clause = nullptr;
+	IR* table_reference_list = nullptr;
+	IR* update_list = nullptr;
+	IR* opt_where_clause = nullptr;
+	IR* opt_order_clause = nullptr;
+	IR* opt_simple_limit = nullptr;
+
+	IR* unknown = nullptr;
+
+	opt_with_clause = NT_check(update_stmt->left_, IRTYPE::kOptWithClause);
+	unknown = update_stmt->right_->right_->right_;
+
+	table_reference_list = NT_check(unknown->left_, IRTYPE::kTableReferenceList);
+	unknown = unknown->right_;
+
+	update_list = NT_check(unknown->left_, IRTYPE::kUpdateList);
+	unknown = unknown->right_;
+
+	opt_where_clause = NT_check(unknown->left_, IRTYPE::kOptWhereClause);
+	unknown = unknown->right_;
+
+	opt_order_clause = NT_check(unknown->left_, IRTYPE::kOptOrderClause);
+	opt_simple_limit = NT_check(unknown->right_, IRTYPE::kOptSimpleLimit);
+
+	globalStatusManger_->push_selectInfo(StmtLocation::slNotSubquery, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	if (opt_with_clause->left_ != nullptr) {
+		IR* with_clause = NT_check(opt_with_clause->left_, IRTYPE::kWithClause);
+		instantiate_with_clause(with_clause);
+	}
+
+	IR* curNode = table_reference_list;
+	while (curNode != nullptr) {
+		IR* table_reference = NT_check(curNode->left_, IRTYPE::kTableReference);
+		instantiate_table_reference(table_reference);
+
+		curNode = curNode->right_;
+	}
+
+	info->update_acceColumns();	
+
+	if (opt_where_clause->left_ != nullptr) {
+		IR* where_clause = NT_check(opt_where_clause->left_, IRTYPE::kWhereClause);
+		instantiate_where_clause(where_clause);
+	}
+
+	if (opt_order_clause->left_ != nullptr) {
+		IR* order_clause = NT_check(opt_order_clause->left_, IRTYPE::kOrderClause);
+		instantiate_order_clause(order_clause);
+	}
+
+	if (opt_simple_limit->left_ != nullptr) {
+		IR* iconst = NT_check(opt_simple_limit->left_, IRTYPE::kIconst);
+		iconst->long_val_ = exprInstantiator_->get_random_integer(LIMITMIN, LIMITMAX);
+	}
+
+	instantiate_update_list(update_list, nullptr);
+
+	globalStatusManger_->pop_selectInfo();
+
+	return;
+}
+int Instantiator::instantiate_update_list(IR* update_list, Table* table) {
+	int chosenColumnNumber = 0;
+
+	vector<Column*> columns;
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();	
+	
+	if (info->acceColumns_.empty()) {
+		return 0;
+	}
+
+	if (table != nullptr) {
+		vector<int> tmp = vector<int>(COLUMNNAMEMAX, 0);
+
+		for (Column* c : table->columns_) {
+			tmp[c->identifierName_]++;
+		}
+
+		for (Column* c : info->acceColumns_) {
+			Column* tmpColumn = new Column(c);
+			tmpColumn->parentTable_ = c->parentTable_;
+
+			if (tmp[tmpColumn->identifierName_] != 0) {
+				tmpColumn->duplicated_ = ColumnStatus::csDuplication;
+			}
+
+			tmp[tmpColumn->identifierName_]++;
+			columns.push_back(tmpColumn);
+		}
+
+		for (Column* c : table->columns_) {
+			Column* tmpColumn = new Column(c);
+			tmpColumn->parentTable_ = c->parentTable_;
+
+			if (tmp[tmpColumn->identifierName_] > 1) {
+				tmpColumn->duplicated_ = ColumnStatus::csDuplication;
+			}
+
+			columns.push_back(tmpColumn);
+		}
+	}
+
+	IR* curNode = update_list;
+	while (curNode != nullptr) {
+		chosenColumnNumber++;
+
+		IR* columnref = NT_check(curNode->left_->left_, IRTYPE::kColumnref);
+		IR* expr_root = (curNode->left_->right_->left_ == nullptr) ? nullptr : NT_check(curNode->left_->right_->left_, IRTYPE::kExprRoot);
+
+		Column* chosenColumn = info->acceColumns_[rand() % info->acceColumns_.size()];
+
+		IR* column_name = nullptr;
+		IR* table_name = nullptr;
+
+		if (chosenColumn->duplicated_ == ColumnStatus::csDuplication && columnref->right_ == nullptr) {
+			IR* tmp1 = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+			IR* tmp2 = new IR(IRTYPE::kTableName, OP0(), tmp1, nullptr);
+
+			columnref->right_ = columnref->left_;
+			columnref->left_ = tmp2;
+			columnref->op_->middle_ = TERMINAL::tOpDot;
+		}
+
+		if (columnref->right_ != nullptr) {
+			table_name = NT_check(columnref->left_, IRTYPE::kTableName);
+			column_name = NT_check(columnref->right_, IRTYPE::kColumnName);
+		}
+		else {
+			column_name = NT_check(columnref->left_, IRTYPE::kColumnName);
+		}
+
+		instantiate_ident(column_name, IdentifierType::iColumn, chosenColumn->identifierName_);
+		if (table_name != nullptr) {
+			instantiate_ident(table_name, IdentifierType::iTable, chosenColumn->parentTable_->identifierName_);
+		}
+
+		if (expr_root != nullptr) {
+			if (table != nullptr) {
+				exprInstantiator_->instantiate_expr_root(expr_root, columns, StmtLocation::slNotSubquery);
+			}
+			else {
+				exprInstantiator_->instantiate_expr_root(expr_root, info->acceColumns_, StmtLocation::slNotSubquery);
+			}
+		}
+
+		curNode = curNode->right_;
+	}
+
+	for (Column* c : columns) {
+		delete c;
+	}
+
+	return chosenColumnNumber;
+}
+
+void Instantiator::instantiate_delete_stmt(IR* delete_stmt) {
+	IR* opt_with_clause = nullptr;
+	IR* table_name = nullptr;
+	IR* opt_alias = nullptr;
+	IR* opt_where_clause = nullptr;
+	IR* opt_order_clause = nullptr;
+	IR* opt_simple_limit = nullptr;
+	IR* table_list = nullptr;
+	IR* table_reference_list = nullptr;
+
+	IR* unknown = nullptr;
+
+	opt_with_clause = NT_check(delete_stmt->left_, IRTYPE::kOptWithClause);
+	unknown = delete_stmt->right_->right_;
+
+	if (unknown->left_->type_ == IRTYPE::kTableName) {
+		table_name = NT_check(unknown->left_, IRTYPE::kTableName);
+		unknown = unknown->right_;
+
+		opt_alias = NT_check(unknown->left_, IRTYPE::kOptAlias);
+		unknown = unknown->right_;
+
+		opt_where_clause = NT_check(unknown->left_, IRTYPE::kOptWhereClause);
+		unknown = unknown->right_;
+
+		opt_order_clause = NT_check(unknown->left_, IRTYPE::kOptOrderClause);
+		opt_simple_limit = NT_check(unknown->right_, IRTYPE::kOptSimpleLimit);
+	}
+	else {
+		table_list = NT_check(unknown->left_, IRTYPE::kTableList);
+		unknown = unknown->right_;
+
+		table_reference_list = NT_check(unknown->left_, IRTYPE::kTableReferenceList);
+		opt_where_clause = NT_check(unknown->right_, IRTYPE::kOptWhereClause);
+	}
+
+	globalStatusManger_->push_selectInfo(StmtLocation::slNotSubquery, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	if (table_name != nullptr) {
+		if (opt_with_clause->left_ != nullptr) {
+			deep_delete(opt_with_clause->left_);
+			opt_with_clause->left_ = nullptr;
+		}
+
+		vector<Table*> tables = globalStatusManger_->get_acce_table(IdentifierType::iTable);
+		if (tables.empty()) {
+			globalStatusManger_->pop_selectInfo();
+			return;
+		}
+
+		Table* chosenTable = tables[rand() % tables.size()];
+		Table* newTable = new Table(chosenTable, info);
+		info->add_used_table(newTable);
+
+		instantiate_ident(table_name, IdentifierType::iTable, newTable->identifierName_);
+
+		if (opt_alias->left_ != nullptr) {
+			IR* alias = NT_check(opt_alias->left_, IRTYPE::kAlias);
+			name_t newName = globalStatusManger_->get_new_table_name();
+
+			instantiate_ident(alias, IdentifierType::iTable, newName);
+
+			newTable->identifierName_ = newName;
+		}
+
+		info->update_acceColumns();
+
+		if (opt_where_clause->left_ != nullptr) {
+			IR* where_clause = NT_check(opt_where_clause->left_, IRTYPE::kWhereClause);
+			instantiate_where_clause(where_clause);
+		}
+
+		if (opt_order_clause->left_ != nullptr) {
+			IR* order_clause = NT_check(opt_order_clause->left_, IRTYPE::kOrderClause);
+			instantiate_order_clause(order_clause);
+		}
+
+		if (opt_simple_limit->left_ != nullptr) {
+			IR* iconst = NT_check(opt_simple_limit->left_, IRTYPE::kIconst);
+			iconst->long_val_ = exprInstantiator_->get_random_integer(LIMITMIN, LIMITMAX);
+		}
+	}
+	else if (table_list != nullptr) {
+		if (opt_with_clause->left_ != nullptr) {
+			IR* with_clause = NT_check(opt_with_clause->left_, IRTYPE::kWithClause);
+			instantiate_with_clause(with_clause);
+		}
+
+		IR* curNode = table_reference_list;
+		while (curNode != nullptr) {
+			IR* table_reference = NT_check(curNode->left_, IRTYPE::kTableReference);
+			instantiate_table_reference(table_reference);
+
+			curNode = curNode->right_;
+		}
+
+		info->update_acceColumns();
+
+		vector<Table*> tables = info->usedTables_;
+		assert(!tables.empty());
+
+		curNode = table_list;
+		while (curNode != nullptr) {
+			IR* table_name = NT_check(curNode->left_, IRTYPE::kTableName);
+
+			int tmp = rand() % tables.size();
+			Table* table = tables[tmp];
+			tables.erase(tables.begin() + tmp);
+
+			instantiate_ident(table_name, table->identifierType_, table->identifierName_);
+
+			if (tables.empty() && curNode->right_ != nullptr) {
+				deep_delete(curNode->right_);
+				curNode->right_ = nullptr;
+				curNode->op_->middle_ = TERMINAL::tEmpty;
+			}
+
+			curNode = curNode->right_;
+		}
+
+		if (opt_where_clause->left_ != nullptr) {
+			IR* where_clause = NT_check(opt_where_clause->left_, IRTYPE::kWhereClause);
+			instantiate_where_clause(where_clause);
+		}
+	}
+	else {
+		fprintf(stderr, "ERROR: Incorrect Delete Statement!!!\n");
+		assert(0);
+	}
+
+	globalStatusManger_->pop_selectInfo();
+
+	return;
+}
+
+void Instantiator::instantiate_drop_table_or_view_stmt(IR* drop_table_stmt, IdentifierType type) {
+	bool existFlag = false;
+
+	IR* if_exists = NT_check(drop_table_stmt->left_, IRTYPE::kIfExists);
+	IR* table_list = NT_check(drop_table_stmt->right_, IRTYPE::kTableList);
+
+	vector<Table*> tables = globalStatusManger_->get_acce_table(type);
+	if (tables.empty()) {
+		if_exists->op_->prefix_ = TERMINAL::tIfExists;
+	}
+
+	if (if_exists->op_->prefix_ == TERMINAL::tIfExists) {
+		existFlag = true;
+	}
+
+	name_t nextTableName = UNREFERENCE;
+	if (type == IdentifierType::iTable) {
+		nextTableName = globalStatusManger_->get_new_table_name();
+	}
+	else if (type == IdentifierType::iView) {
+		nextTableName = globalStatusManger_->get_new_view_name();
+	}
+	else {
+		fprintf(stderr, "ERROR: IdentifierType isn't iTable or iView!!!\n");
+		assert(0);
+	}
+
+	IR* curNode = table_list;
+	while (curNode != nullptr) {
+		name_t tmpTableName = UNREFERENCE;
+		IR* table_name = NT_check(curNode->left_, IRTYPE::kTableName);
+
+		if (existFlag == true && (rand() % 2 == 0 || tables.empty())) {
+			tmpTableName = exprInstantiator_->get_random_integer(nextTableName, UCHAR_MAX);
+		}
+		else {
+			int tmp = rand() % tables.size();
+			Table* tmpTable = tables[tmp];
+
+			tmpTableName = tmpTable->identifierName_;
+
+			tables.erase(tables.begin() + tmp);
+			globalStatusManger_->drop_table(tmpTable);
+		}
+
+		instantiate_ident(table_name, type, tmpTableName);
+
+		if (existFlag == false && tables.empty() && curNode->right_ != nullptr) {
+			deep_delete(curNode->right_);
+			curNode->right_ = nullptr;
+			curNode->op_->middle_ = TERMINAL::tEmpty;
+		}
+
+		curNode = curNode->right_;
+	}
+
+	return;
+}
+
+void Instantiator::instantiate_drop_index_stmt(IR* drop_index_stmt) {
+	IR* index_name = NT_check(drop_index_stmt->left_, IRTYPE::kIndexName);
+	IR* table_name = NT_check(drop_index_stmt->right_, IRTYPE::kTableName);
+
+	vector<Table*> tables = globalStatusManger_->get_acce_table(IdentifierType::iTable);
+	if (tables.empty()) {
+		return;
+	}
+
+	Table* table = nullptr;
+	for (Table* t : tables) {
+		if (t->indexes_.empty()) {
+			continue;
+		}
+
+		table = t;
+		break;
+	}
+
+	if (table == nullptr) {
+		return;
+	}
+
+	Index* index = table->indexes_[rand() % table->indexes_.size()];
+
+	instantiate_ident(index_name, IdentifierType::iIndex, index->identifierName_);
+	instantiate_ident(table_name, IdentifierType::iTable, table->identifierName_);
+
+	table->drop_index(index);
+
+	return;
+}
+
+void Instantiator::instantiate_create_index_stmt(IR* create_index_stmt) {
+	IR* index_name = nullptr;
+	IR* table_name = nullptr;
+	IR* key_list_with_expression = nullptr;
+
+	IR* unknown = create_index_stmt->right_;
+
+	index_name = NT_check(unknown->left_, IRTYPE::kIndexName);
+	unknown = unknown->right_;
+
+	table_name = NT_check(unknown->left_, IRTYPE::kTableName);
+	key_list_with_expression = NT_check(unknown->right_, IRTYPE::kKeyListWithExpression);
+
+	vector<Table*> tables = globalStatusManger_->get_acce_table(IdentifierType::iTable);
+	if (tables.empty()) {
+		return;
+	}
+
+	Table* table = tables[rand() % tables.size()];
+
+	name_t newIndexName = globalStatusManger_->get_new_index_name();
+	Index* newIndex = new Index(newIndexName);
+
+	instantiate_ident(index_name, IdentifierType::iIndex, newIndex->identifierName_);
+	instantiate_ident(table_name, IdentifierType::iTable, table->identifierName_);
+
+	newIndex->columns_ = instantiate_key_list_with_expression(key_list_with_expression, table, ConstraintType::ctNull);
+
+	table->add_index(newIndex);
+
+	return;
+}
+
+void Instantiator::instantiate_create_view_stmt(IR* create_view_stmt) {
+	IR* opt_or_replace = nullptr;
+	IR* view_name = nullptr;
+	IR* opt_column_list = nullptr;
+	IR* query_expression = nullptr;
+
+	IR* unknown = nullptr;
+
+	opt_or_replace = NT_check(create_view_stmt->left_, IRTYPE::kOptOrReplace);
+	unknown = create_view_stmt->right_->right_;
+
+	view_name = NT_check(unknown->left_, IRTYPE::kViewName);
+	unknown = unknown->right_;
+
+	opt_column_list = NT_check(unknown->left_, IRTYPE::kOptColumnList);
+	query_expression = NT_check(unknown->right_, IRTYPE::kQueryExpression);
+
+	name_t newViewName = globalStatusManger_->get_new_view_name();
+	if (opt_or_replace->op_->prefix_ == TERMINAL::tOrReplace) {
+		newViewName = (newViewName != 0 && (rand() % 2) == 0) ? (rand() % newViewName) : newViewName;
+		globalStatusManger_->drop_table(newViewName, IdentifierType::iView);
+	}
+
+	instantiate_ident(view_name, IdentifierType::iView, newViewName);
+
+	Table* view = instantiate_query_expression(query_expression, StmtLocation::slNotSubquery, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);
+	
+	view->identifierName_ = newViewName;
+	view->identifierType_ = IdentifierType::iView;
+
+	if (opt_column_list->left_ != nullptr) {
+		IR* column_list = NT_check(opt_column_list->left_, IRTYPE::kColumnList);
+
+		for (Column* column : view->columns_) {
+			view->column_rename(column, column->identifierName_, view->get_acce_column_name());
+		}
+
+		instantiate_column_list(column_list, view->columns_);
+	}
+
+	assert(globalStatusManger_->add_table(view));
+
+	return;
+}
+
+void Instantiator::instantiate_create_table_stmt(IR* create_table_stmt) {
+	Table* res = nullptr;
+
+	IR* opt_temporary = nullptr;
+	IR* opt_if_not_exists = nullptr;
+	IR* table_name = nullptr;
+	IR* table_element_list = nullptr;
+	IR* duplicate_as_qe = nullptr;
+	IR* opt_duplicate_as_qe = nullptr;
+
+	IR* unknown = nullptr;
+
+	opt_temporary = NT_check(create_table_stmt->left_, IRTYPE::kOptTemporary);
+	unknown = create_table_stmt->right_;
+
+	opt_if_not_exists = NT_check(unknown->left_, IRTYPE::kOptIfNotExists);
+	unknown = unknown->right_;
+
+	table_name = NT_check(unknown->left_, IRTYPE::kTableName);
+	unknown = unknown->right_;
+
+	if (unknown->type_ == IRTYPE::kDuplicateAsQe) {
+		duplicate_as_qe = NT_check(unknown, IRTYPE::kDuplicateAsQe);
+	}
+	else {
+		table_element_list = NT_check(unknown->left_, IRTYPE::kTableElementList);
+		opt_duplicate_as_qe = NT_check(unknown->right_, IRTYPE::kOptDuplicateAsQe);
+
+		if (opt_duplicate_as_qe->left_ != nullptr) {
+			duplicate_as_qe = NT_check(opt_duplicate_as_qe->left_, IRTYPE::kDuplicateAsQe);
+		}
+	}
+
+	name_t newTableName = globalStatusManger_->get_new_table_name();
+	instantiate_ident(table_name, IdentifierType::iTable, newTableName);
+
+	if (table_element_list != nullptr) {
+		res = new Table(newTableName, IdentifierType::iTable, nullptr);
+		instantiate_table_element_list(table_element_list, res);
+	}
+	
+	if (duplicate_as_qe != nullptr) {
+		IR* query_expression = nullptr;
+
+		if (duplicate_as_qe->left_->type_ == IRTYPE::kQueryExpression) {
+			query_expression = NT_check(duplicate_as_qe->left_, IRTYPE::kQueryExpression);
+		}
+		else {
+			query_expression = NT_check(duplicate_as_qe->right_, IRTYPE::kQueryExpression);
+		}
+
+		Table* tmpTable = instantiate_query_expression(query_expression, StmtLocation::slNotSubquery, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);
+
+		if (res == nullptr) {
+			res = tmpTable;
+		}
+		else {
+			for (Column* c : tmpTable->columns_) {
+				res->add_column(new Column(c), nullptr);
+			}
+
+			delete tmpTable;
+		}
+
+		res->identifierName_ = newTableName;
+	}	
+
+	if (opt_temporary->op_->prefix_ == TERMINAL::tTemporary) {
+		res->isTemporary_ = true;
+	}
+
+	assert(globalStatusManger_->add_table(res));
+
+	return;
+}
+void Instantiator::instantiate_table_element_list(IR* table_element_list, Table* table) {
+	map<Column*, vector<IR*>> columnWithColumnAttributes;
+
+	int column_def_count = 0;
+	IR* curNode = table_element_list;
+	while (curNode != nullptr) {
+		IR* table_element = NT_check(curNode->left_, IRTYPE::kTableElement);
+
+		if (table_element->left_->type_ == IRTYPE::kColumnDef) {
+			column_def_count++;
+		}
+
+		curNode = curNode->right_;
+	}
+
+	if (table->columns_.empty() && column_def_count == 0) {
+		deep_delete(table_element_list->left_);
+		table_element_list->left_ = deep_copy(IRTrim_->simple_table_element_);
+	}
+
+	curNode = table_element_list;
+	vector<IR*> tableConstraintDefs;
+	while (curNode != nullptr) {
+		IR* table_element = curNode->left_;
+
+		if (table_element->left_->type_ == IRTYPE::kColumnDef) {
+			pair<Column*, vector<IR*>> tmp = instantiate_column_def(NT_check(table_element->left_, IRTYPE::kColumnDef), table);
+			columnWithColumnAttributes[tmp.first] = tmp.second;
+		}
+		else {
+			tableConstraintDefs.push_back(NT_check(table_element->left_, IRTYPE::kTableConstraintDef));			
+		}
+
+		curNode = curNode->right_;
+	}
+
+	assert(!table->columns_.empty());
+
+	for (auto& it : columnWithColumnAttributes) {
+		for (IR* column_attribute : it.second) {
+			instantiate_column_attribute(column_attribute, it.first, table);
+		}
+	}
+
+	vector<IR*> waitForDelete;
+	for (IR* tmp : tableConstraintDefs) {
+		bool flag = false;
+
+		if (tmp->left_->type_ == IRTYPE::kOptIndexName) {
+			flag = instantiate_table_constraint_def_index(tmp, table);
+		}
+		else if (tmp->right_->type_ == IRTYPE::kCheckConstraint) {
+			flag = instantiate_table_constraint_def_check(tmp, table);
+		}
+		else if (tmp->op_->middle_ == TERMINAL::tForeignKey) {
+			flag = instantiate_table_constraint_def_foreign_key(tmp, table);
+		}
+		else {
+			flag = instantiate_table_constraint_def_key(tmp, table);
+		}
+
+		if (flag == false) {
+			waitForDelete.push_back(tmp);
+		}
+	}
+
+	curNode = table_element_list;
+	IR* preNode = curNode;
+	while (curNode != nullptr && !waitForDelete.empty()) {
+		IR* table_element = curNode->left_;
+		
+		auto it = find(waitForDelete.begin(), waitForDelete.end(), table_element->left_);
+		if (it != waitForDelete.end()) {
+			if (curNode->right_ == nullptr) {
+				deep_delete(preNode->right_);
+				preNode->right_ = nullptr;
+				preNode->op_->middle_ = TERMINAL::tEmpty;
+
+				curNode = preNode;
+
+				waitForDelete.erase(it);
+			}
+			else {
+				IR* tmp = curNode->right_;
+
+				deep_delete(curNode->left_);
+				curNode->left_ = tmp->left_;
+				curNode->right_ = tmp->right_;
+				curNode->op_->middle_ = tmp->op_->middle_;
+
+				tmp->left_ = nullptr;
+				tmp->right_ = nullptr;
+				deep_delete(tmp);
+
+				waitForDelete.erase(it);
+
+				continue;
+			}			
+		}
+
+		preNode = curNode;
+		curNode = curNode->right_;
+	}
+
+	assert(waitForDelete.empty());
+
+	return;
+}
+pair<Column*, vector<IR*>> Instantiator::instantiate_column_def(IR* column_def, Table* table) {
+	vector<IR*> res;
+
+	IR* column_name = NT_check(column_def->left_, IRTYPE::kColumnName);
+	IR* data_type = NT_check(column_def->right_->left_, IRTYPE::kDataType);
+	IR* opt_column_attribute_list = NT_check(column_def->right_->right_, IRTYPE::kOptColumnAttributeList);
+
+	name_t columnName = table->get_acce_column_name();
+	ColumnType type = instantiate_data_type(data_type);
+
+	Column* column = new Column(columnName, type);
+	instantiate_ident(column_name, IdentifierType::iColumn, column->identifierName_);
+
+	if (opt_column_attribute_list->left_ != nullptr) {
+		IR* column_attribute_list = NT_check(opt_column_attribute_list->left_, IRTYPE::kColumnAttributeList);
+
+		while (column_attribute_list != nullptr) {
+			res.push_back(NT_check(column_attribute_list->left_, IRTYPE::kColumnAttribute));
+			column_attribute_list = column_attribute_list->right_;
+		}
+	}
+
+	table->add_column(column);
+
+	return { column, res };
+}
+ColumnType Instantiator::instantiate_data_type(IR* data_type) {
+	ColumnType res = ColumnType::ctNull;
+
+	switch (data_type->left_->type_) {
+		case IRTYPE::kNumberType: {
+			IR* number_type = NT_check(data_type->left_, IRTYPE::kNumberType);
+
+			IR* type = number_type->left_;
+			IR* precision = nullptr;
+			IR* float_options = nullptr;
+
+			if (type->type_ == IRTYPE::kRealType) {
+				IR* opt_precision = NT_check(number_type->right_->left_, IRTYPE::kOptPrecision);
+				precision = (opt_precision->left_ == nullptr) ? nullptr : NT_check(opt_precision->left_, IRTYPE::kPrecision);
+			}
+			else if (type->type_ == IRTYPE::kNumericType) {
+				float_options = NT_check(number_type->right_->left_, IRTYPE::kFloatOptions);
+			}
+
+			res = Column::typeTranslation_[type->op_->prefix_];
+
+			if (float_options != nullptr && float_options->left_ != nullptr) {
+				if (float_options->left_->type_ == IRTYPE::kPrecision) {
+					precision = NT_check(float_options->left_, IRTYPE::kPrecision);
+				}
+				else {
+					IR* field_length = NT_check(float_options->left_, IRTYPE::kFieldLength);
+					IR* iconst = NT_check(field_length->left_, IRTYPE::kIconst);
+
+					int v1 = exprInstantiator_->get_random_integer(0, 53);
+					iconst->long_val_ = v1;
+				}
+			}
+
+			if (precision != nullptr) {
+				IR* iconst_1 = NT_check(precision->left_, IRTYPE::kIconst);
+				IR* iconst_2 = NT_check(precision->right_, IRTYPE::kIconst);
+
+				int v1 = exprInstantiator_->get_random_integer(1, 255);
+				int v2 = exprInstantiator_->get_random_float(0, min(v1, 30));
+
+				iconst_1->long_val_ = v1;
+				iconst_2->long_val_ = v2;
+			}
+
+			break;
+		}
+		case IRTYPE::kBoolType: {
+			res = Column::typeTranslation_[data_type->left_->op_->prefix_];
+			break;
+		}
+		case IRTYPE::kStringType: {
+			IR* string_type = NT_check(data_type->left_, IRTYPE::kStringType);
+
+			IR* field_length = nullptr;
+			if (string_type->left_ != nullptr) {
+				field_length = (string_type->left_->type_ == IRTYPE::kFieldLength) ? NT_check(string_type->left_, IRTYPE::kFieldLength) : string_type->left_->left_;
+			}
+
+			res = Column::typeTranslation_[string_type->op_->prefix_];
+
+			if (field_length != nullptr) {
+				IR* iconst = NT_check(field_length->left_, IRTYPE::kIconst);
+
+				int v1 = exprInstantiator_->get_random_integer(32, 255);
+				iconst->long_val_ = v1;
+			}
+
+			break;
+		}
+		default: {
+			fprintf(stderr, "Unknown Data Type!!!\n");
+			assert(0);
+		}
+	}
+
+	return res;
+}
+void Instantiator::instantiate_column_attribute(IR* column_attribute, Column* column, Table* table) {
+	switch (column_attribute->left_->type_) {
+		case IRTYPE::kNotNull: {
+			column->notNull_ = true;
+			break;
+		}
+		case IRTYPE::kDefaultAttribute: {
+			IR* expr_root = NT_check(column_attribute->left_->left_, IRTYPE::kExprRoot);
+			exprInstantiator_->instantiate_expr_root(expr_root, table->columns_, StmtLocation::slNotSubquery);
+
+			column->hasDefault_ = true;
+
+			break;
+		}
+		case IRTYPE::kVisibility: {
+			column->isVisible_ = (column_attribute->left_->op_->prefix_ == TERMINAL::tVisible) ? true : false;
+			break;
+		}
+		default: {
+			fprintf(stderr, "Unknown Column Attribute!!!\n");
+			assert(0);
+		}
+	}
+
+	return;
+}
+map<Column*, IndexType> Instantiator::instantiate_key_list_with_expression(IR* key_list_with_expression, Table* table, ConstraintType type) {
+	map<Column*, IndexType> res;
+
+	IR* curNode = key_list_with_expression;
+	while (curNode != nullptr) {
+		IR* key_part_with_expression = NT_check(curNode->left_, IRTYPE::kKeyPartWithExpression);
+
+		if (type == ConstraintType::ctPrimaryKey && key_part_with_expression->left_->type_ != IRTYPE::kKeyPart) {
+			deep_delete(key_part_with_expression->left_);
+			key_part_with_expression->left_ = deep_copy(IRTrim_->simple_key_part_);
+		}
+
+		if (key_part_with_expression->left_->type_ == IRTYPE::kKeyPart) {
+			IR* key_part = NT_check(key_part_with_expression->left_, IRTYPE::kKeyPart);
+			IR* iconst = nullptr;
+
+			Column* columnChosen = table->get_column();
+			instantiate_ident(NT_check(key_part->left_, IRTYPE::kColumnName), IdentifierType::iColumn, columnChosen->identifierName_);
+
+			if (res.find(columnChosen) == res.end()) {
+				res[columnChosen] = IndexType::itNormal;
+			}			
+
+			if (key_part->right_->type_ != IRTYPE::kOptOrderingDirection) {
+				if (Column::typeToBasicType_[columnChosen->columnType_] != ColumnBasicType::ctString) {
+					deep_delete(key_part->right_);
+					key_part->right_ = new IR(IRTYPE::kOptOrderingDirection, OP0(), nullptr, nullptr);
+				}
+				else {
+					iconst = NT_check(key_part->right_->left_, IRTYPE::kIconst);
+				}
+			}
+
+			if (iconst != nullptr) {
+				int v1 = exprInstantiator_->get_random_integer(1, 32);
+				iconst->long_val_ = v1;
+			}
+		}
+		else {
+			IR* expr_root = NT_check(key_part_with_expression->left_, IRTYPE::kExprRoot);
+			exprInstantiator_->instantiate_expr_root(expr_root, table->columns_, StmtLocation::slNotSubquery);
+
+			for (Column* column : exprInstantiator_->usedColumnsBuffer_) {
+				res[column] = IndexType::itFunctional;
+			}
+		}
+
+		curNode = curNode->right_;
+	}
+
+	return res;
+}
+bool Instantiator::instantiate_table_constraint_def_index(IR* table_constraint_def, Table* table) {
+	IR* opt_index_name = NT_check(table_constraint_def->left_, IRTYPE::kOptIndexName);
+	IR* key_list_with_expression = NT_check(table_constraint_def->right_, IRTYPE::kKeyListWithExpression);
+
+	if (opt_index_name->left_ == nullptr) {
+		opt_index_name->left_ = deep_copy(IRTrim_->simple_index_name_);
+	}
+
+	name_t newIndexName = globalStatusManger_->get_new_index_name();
+	Index* newIndex = new Index(newIndexName);
+	instantiate_ident(NT_check(opt_index_name->left_, IRTYPE::kIndexName), IdentifierType::iIndex, newIndex->identifierName_);
+
+	newIndex->columns_ = instantiate_key_list_with_expression(key_list_with_expression, table, ConstraintType::ctNull);
+
+	table->add_index(newIndex);
+
+	return true;
+}
+bool Instantiator::instantiate_table_constraint_def_key(IR* table_constraint_def, Table* table) {
+	ConstraintType type = ConstraintType::ctNull;
+
+	IR* opt_constraint_name = nullptr;
+	IR* constraint_key_type = nullptr;
+	IR* opt_index_name = nullptr;
+	IR* key_list_with_expression = nullptr;
+
+	IR* unknown = nullptr;
+
+	opt_constraint_name = NT_check(table_constraint_def->left_, IRTYPE::kOptConstraintName);
+	unknown = table_constraint_def->right_;
+
+	constraint_key_type = NT_check(unknown->left_, IRTYPE::kConstraintKeyType);
+	unknown = unknown->right_;
+
+	opt_index_name = NT_check(unknown->left_, IRTYPE::kOptIndexName);
+	key_list_with_expression = NT_check(unknown->right_, IRTYPE::kKeyListWithExpression);
+
+	if (opt_constraint_name->left_ == nullptr) {
+		opt_constraint_name->left_ = deep_copy(IRTrim_->simple_constraint_name_);
+		opt_constraint_name->op_->prefix_ = TERMINAL::tConstraint;
+	}
+
+	if (opt_index_name->left_ == nullptr) {
+		opt_index_name->left_ = deep_copy(IRTrim_->simple_index_name_);
+	}
+
+	if (table->hasPrimaryKey_ == true) {
+		if (constraint_key_type->op_->prefix_ == TERMINAL::tPrimaryKey); {
+			return false;
+		}
+
+		type = ConstraintType::ctUnique;
+	}
+	else {
+		type = (constraint_key_type->op_->prefix_ == TERMINAL::tPrimaryKey) ? ConstraintType::ctPrimaryKey : ConstraintType::ctUnique;
+		if (type == ConstraintType::ctPrimaryKey) {
+			table->hasPrimaryKey_ = true;
+		}
+	}
+
+	name_t newConstraintName = globalStatusManger_->get_new_constraint_name();
+	name_t newIndexName = globalStatusManger_->get_new_index_name();
+
+	Constraint* newConstraint = new Constraint(newConstraintName, type);
+	Index* newIndex = new Index(newIndexName);
+
+	instantiate_ident(NT_check(opt_constraint_name->left_, IRTYPE::kConstraintName), IdentifierType::iConstraint, newConstraint->identifierName_);
+	instantiate_ident(NT_check(opt_index_name->left_, IRTYPE::kIndexName), IdentifierType::iIndex, newIndex->identifierName_);
+
+	newConstraint->columns_ = instantiate_key_list_with_expression(key_list_with_expression, table, type);
+	newIndex->columns_ = newConstraint->columns_;
+
+	table->add_constraint(newConstraint, newIndex);
+
+	return true;
+}
+bool Instantiator::instantiate_table_constraint_def_check(IR* table_constraint_def, Table* table) {
+	IR* opt_constraint_name = NT_check(table_constraint_def->left_, IRTYPE::kOptConstraintName);
+	IR* check_constraint = NT_check(table_constraint_def->right_, IRTYPE::kCheckConstraint);
+
+	if (opt_constraint_name->left_ == nullptr) {
+		opt_constraint_name->left_ = deep_copy(IRTrim_->simple_constraint_name_);
+		opt_constraint_name->op_->prefix_ = TERMINAL::tConstraint;
+	}
+
+	name_t newConstraintName = globalStatusManger_->get_new_constraint_name();
+	Constraint* newConstraint = new Constraint(newConstraintName, ConstraintType::ctCheck);
+	instantiate_ident(NT_check(opt_constraint_name->left_, IRTYPE::kConstraintName), IdentifierType::iConstraint, newConstraint->identifierName_);
+
+	exprInstantiator_->instantiate_expr_root(NT_check(check_constraint->left_, IRTYPE::kExprRoot), table->columns_, StmtLocation::slNotSubquery);
+	for (Column* column : exprInstantiator_->usedColumnsBuffer_) {
+		newConstraint->columns_[column] = IndexType::itFunctional;
+	}
+
+	table->add_constraint(newConstraint);
+
+	return true;
+}
+bool Instantiator::instantiate_table_constraint_def_foreign_key(IR* table_constraint_def, Table* table) {
+	IR* opt_constraint_name = nullptr;
+	IR* opt_index_name = nullptr;
+	IR* key_list = nullptr;
+	IR* references = nullptr;
+	IR* table_name = nullptr;
+	IR* column_list = nullptr;
+
+	IR* unknown = nullptr;
+
+	opt_constraint_name = NT_check(table_constraint_def->left_, IRTYPE::kOptConstraintName);
+	unknown = table_constraint_def->right_;
+
+	opt_index_name = NT_check(unknown->left_, IRTYPE::kOptIndexName);
+	unknown = unknown->right_;
+
+	key_list = NT_check(unknown->left_, IRTYPE::kKeyList);
+	references = NT_check(unknown->right_, IRTYPE::kReferences);
+
+	table_name = NT_check(references->left_, IRTYPE::kTableName);
+	column_list = NT_check(references->right_->left_, IRTYPE::kColumnList);
+
+	vector<Column*> curTableColumn;
+	vector<Column*> otherTableColumn;
+	if (check_foreign_key(table, curTableColumn, otherTableColumn) == false) {
+		return false;
+	}
+
+	assert(!curTableColumn.empty() && curTableColumn.size() == otherTableColumn.size());
+
+	if (opt_constraint_name->left_ == nullptr) {
+		opt_constraint_name->left_ = deep_copy(IRTrim_->simple_constraint_name_);
+		opt_constraint_name->op_->prefix_ = TERMINAL::tConstraint;
+	}
+
+	if (opt_index_name->left_ == nullptr) {
+		opt_index_name->left_ = deep_copy(IRTrim_->simple_index_name_);
+	}
+
+	name_t newConstraintName = globalStatusManger_->get_new_constraint_name();
+	name_t newIndexName = globalStatusManger_->get_new_index_name();
+
+	Constraint* newConstraint = new Constraint(newConstraintName, ConstraintType::ctForeignKey);
+
+	IR* constraint_name = NT_check(opt_constraint_name->left_, IRTYPE::kConstraintName);
+	IR* index_name = NT_check(opt_index_name->left_, IRTYPE::kIndexName);
+
+	instantiate_ident(constraint_name, IdentifierType::iConstraint, newConstraint->identifierName_);
+	instantiate_ident(index_name, IdentifierType::iIndex, newIndexName);
+
+	instantiate_ident(table_name, IdentifierType::iTable, otherTableColumn[0]->parentTable_->identifierName_);
+
+	instantiate_key_list(key_list, curTableColumn);
+	instantiate_column_list(column_list, otherTableColumn);
+
+	for (int i = 0; i < curTableColumn.size(); i++) {
+		newConstraint->refToOtherColumns_[curTableColumn[i]].push_back(otherTableColumn[i]);
+	}
+
+	table->add_constraint(newConstraint);
+
+	return true;
+}
+
+void Instantiator::instantiate_select_stmt(IR* select_stmt) {
+	globalStatusManger_->push_selectInfo(StmtLocation::slNotSubquery, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);
+
+	Table* t = instantiate_query_expression(NT_check(select_stmt->left_, IRTYPE::kQueryExpression));
+
+	globalStatusManger_->pop_selectInfo();
+	delete t;
+
+	return;
+}
+Table* Instantiator::instantiate_query_expression(IR* query_expression, StmtLocation location, int rowNumber, int columnNumber) {
+	globalStatusManger_->push_selectInfo(location, rowNumber, columnNumber);
+
+	Table* res = instantiate_query_expression(NT_check(query_expression, IRTYPE::kQueryExpression));
+	globalStatusManger_->pop_selectInfo();
+
+	res->inSelectStmtInfo_ = globalStatusManger_->get_cur_selectInfo();
+
+	return res;
+}
+Table* Instantiator::instantiate_query_expression(IR* query_expression) {
+	Table* res = nullptr;
+
+	IR* with_clause = nullptr;
+	IR* query_expression_body = nullptr;
+	IR* opt_order_clause = nullptr;
+	IR* opt_limit_clause = nullptr;
+
+	IR* unknown = nullptr;
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	if (query_expression->left_->type_ == IRTYPE::kQueryExpressionBody) {
+		query_expression_body = NT_check(query_expression->left_, IRTYPE::kQueryExpressionBody);
+		unknown = query_expression->right_;
+	}
+	else {
+		with_clause = NT_check(query_expression->left_, IRTYPE::kWithClause);
+
+		unknown = query_expression->right_;
+		query_expression_body = NT_check(unknown->left_, IRTYPE::kQueryExpressionBody);
+	
+		unknown = unknown->right_;
+	}
+
+	opt_order_clause = NT_check(unknown->left_, IRTYPE::kOptOrderClause);
+	opt_limit_clause = NT_check(unknown->right_, IRTYPE::kOptLimitClause);
+
+	if (with_clause != nullptr) {
+		instantiate_with_clause(with_clause);
+	}
+
+	switch (query_expression_body->left_->type_) {
+		case IRTYPE::kQueryPrimary: {
+			res = instantiate_query_primary(NT_check(query_expression_body->left_, IRTYPE::kQueryPrimary));
+			break;
+		}
+		case IRTYPE::kQueryExpressionParens: {
+			IR* query_expression_parens = NT_check(query_expression_body->left_, IRTYPE::kQueryExpressionParens);
+			while (query_expression_parens->left_->type_ == IRTYPE::kQueryExpressionParens) {
+				query_expression_parens = NT_check(query_expression_parens->left_, IRTYPE::kQueryExpressionParens);
+			}
+
+			res = instantiate_query_expression(NT_check(query_expression_parens->left_, IRTYPE::kQueryExpression));
+
+			break;
+		}
+		case IRTYPE::kQueryExpressionBody: {
+			res = instanitate_union(query_expression_body);
+			break;
+		}
+		default: {
+			fprintf(stderr, "ERROR: Unknown query_expression_body->left_->type_: %d\n", static_cast<int>(query_expression_body->left_->type_));
+			assert(0);
+		}
+	}
+
+	assert(info->usedTables_.empty());
+
+	if (opt_order_clause->left_ != nullptr) {
+		IR* order_clause = NT_check(opt_order_clause->left_, IRTYPE::kOrderClause);
+
+		vector<Table*> usedTables = { res };
+		vector<int> duplicationInfo = vector<int>(COLUMNNAMEMAX, 0);
+		info->update_acceColumns(usedTables, duplicationInfo);
+
+		instantiate_order_clause(order_clause);
+
+		info->acceColumns_.clear();
+	}
+
+	if (info->has_row_limit() && opt_limit_clause->left_ == nullptr) {
+		opt_limit_clause->left_ = deep_copy(IRTrim_->simple_limit_);
+	}
+	
+	if (opt_limit_clause->left_ != nullptr) {
+		IR* limit_clause = NT_check(opt_limit_clause->left_, IRTYPE::kLimitClause);
+		instantiate_limit_clause(limit_clause);
+	}
+
+	return res;
+}
+Table* Instantiator::instantiate_query_primary(IR* query_primary) {
+	Table* res = nullptr;
+
+	IR* query_specification = nullptr;
+
+	IR* opt_select_options = nullptr;
+	IR* select_item_list = nullptr;
+	IR* opt_from_clause = nullptr;
+	IR* opt_where_clause = nullptr;
+	IR* opt_group_clause = nullptr;
+	IR* opt_having_clause = nullptr;
+	IR* opt_window_clause = nullptr;
+
+	IR* unknown = nullptr;
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+	info->clear_local_info();
+
+	query_specification = NT_check(query_primary->left_, IRTYPE::kQuerySpecification);
+
+	opt_select_options = NT_check(query_specification->left_, IRTYPE::kOptSelectOptions);
+	unknown = query_specification->right_;
+
+	select_item_list = NT_check(unknown->left_, IRTYPE::kSelectItemList);
+	unknown = unknown->right_;
+
+	opt_from_clause = NT_check(unknown->left_, IRTYPE::kOptFromClause);
+	unknown = unknown->right_;
+
+	opt_where_clause = NT_check(unknown->left_, IRTYPE::kOptWhereClause);
+	unknown = unknown->right_;
+
+	opt_group_clause = NT_check(unknown->left_, IRTYPE::kOptGroupClause);
+	unknown = unknown->right_;
+
+	opt_having_clause = NT_check(unknown->left_, IRTYPE::kOptHavingClause);
+	opt_window_clause = NT_check(unknown->right_, IRTYPE::kOptWindowClause);
+
+	if (opt_from_clause->left_) {
+		int acceTableNumber = globalStatusManger_->get_acce_table_number();
+
+		if (acceTableNumber == 0) {
+			deep_delete(opt_from_clause->left_);
+			opt_from_clause->left_ = nullptr;
+		}
+		else {
+			IR* from_clause = NT_check(opt_from_clause->left_, IRTYPE::kFromClause);
+			instantiate_from_clause(from_clause);
+		}		
+	}
+
+	info->update_acceColumns();
+
+	if (opt_where_clause->left_ != nullptr) {
+		IR* where_clause = NT_check(opt_where_clause->left_, IRTYPE::kWhereClause);
+		instantiate_where_clause(where_clause);
+	}
+
+	if (opt_having_clause->left_ != nullptr) {
+		instantiate_having_clause(opt_having_clause);
+	}
+
+	if (opt_window_clause->left_ != nullptr) {
+		instantiate_window_clause(opt_window_clause);
+	}
+
+	res = instantiate_select_item_list(select_item_list);
+
+	if (info->hasAggregate && !info->usedInnerColumns_.empty() && opt_group_clause->left_ == nullptr) {
+		IR* olap_opt = new IR(IRTYPE::kOlapOpt, OP0(), nullptr, nullptr);
+		IR* expr_root_list = deep_copy(IRTrim_->simple_expr_root_list_);
+
+		opt_group_clause->left_ = expr_root_list;
+		opt_group_clause->right_ = olap_opt;
+		opt_group_clause->op_->prefix_ = TERMINAL::tGroupBy;
+	}
+
+	if (opt_group_clause->left_ != nullptr) {
+		instantiate_group_clause(opt_group_clause);
+	}
+
+	info->clear_local_info();
+
+	return res;
+}
+Table* Instantiator::instanitate_union(IR* query_expression_body) {
+	Table* res = nullptr;
+
+	IR* query_expression_body_1 = nullptr;
+	IR* query_expression_body_2 = nullptr;
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+	StmtLocation oldLocation = info->location_;
+
+	stack<IR*> stk;
+	vector<IR*> queue;
+
+	query_expression_body_1 = NT_check(query_expression_body->left_, IRTYPE::kQueryExpressionBody);
+	query_expression_body_2 = NT_check(query_expression_body->right_->right_, IRTYPE::kQueryExpressionBody);
+
+	stk.push(query_expression_body_2);
+	stk.push(query_expression_body_1);
+
+	while (!stk.empty()) {
+		IR* curIR = stk.top();
+		stk.pop();
+
+		switch (curIR->left_->type_) {
+			case IRTYPE::kQueryPrimary: {
+				IR* query_primary = NT_check(curIR->left_, IRTYPE::kQueryPrimary);
+				queue.push_back(query_primary);
+
+				break;
+			}
+			case IRTYPE::kQueryExpressionParens: {
+				IR* query_expression_parens = NT_check(curIR->left_, IRTYPE::kQueryExpressionParens);
+				queue.push_back(query_expression_parens);
+
+				break;
+			}
+			case IRTYPE::kQueryExpressionBody: {
+				IR* t_query_expression_body_1 = NT_check(curIR->left_, IRTYPE::kQueryExpressionBody);
+				IR* t_query_expression_body_2 = NT_check(curIR->right_->right_, IRTYPE::kQueryExpressionBody);
+
+				stk.push(t_query_expression_body_2);
+				stk.push(t_query_expression_body_1);
+
+				break;
+			}
+			default: {
+				fprintf(stderr, "ERROR: Unknown query_expression_body->left_->type_: %d\n", static_cast<int>(curIR->left_->type_));
+				assert(0);
+			}
+		}
+	}
+
+	assert(queue.size() >= 2);
+
+	for (int i = 0; i < queue.size(); i++) {
+		if (i == 0 && (oldLocation == StmtLocation::slRecursiveCTE || oldLocation == StmtLocation::slRecursivePart1)) {
+			info->location_ = StmtLocation::slRecursivePart1;
+		}
+		else if (i == queue.size() - 1 && (oldLocation == StmtLocation::slRecursiveCTE || oldLocation == StmtLocation::slRecursivePart2)) {
+			info->location_ = StmtLocation::slRecursivePart2;
+		}
+		else if(oldLocation == StmtLocation::slRecursiveCTE || oldLocation == StmtLocation::slRecursivePart1 || oldLocation == StmtLocation::slRecursivePart2) {
+			info->location_ = StmtLocation::slCTE;
+		}
+
+		IR* curIR = queue[i];
+		Table* tmp = nullptr;
+
+		switch (curIR->type_) {
+			case IRTYPE::kQueryPrimary: {
+				tmp = instantiate_query_primary(NT_check(curIR, IRTYPE::kQueryPrimary));
+				break;
+			}
+			case IRTYPE::kQueryExpressionParens: {
+				IR* query_expression_parens = NT_check(curIR, IRTYPE::kQueryExpressionParens);
+				while (query_expression_parens->left_->type_ == IRTYPE::kQueryExpressionParens) {
+					query_expression_parens = NT_check(query_expression_parens->left_, IRTYPE::kQueryExpressionParens);
+				}
+
+				tmp = instantiate_query_expression(NT_check(query_expression_parens->left_, IRTYPE::kQueryExpression));
+
+				break;
+			}
+			default: {
+				fprintf(stderr, "ERROR: Unknown curIR->type_: %d\n", static_cast<int>(curIR->type_));
+				assert(0);
+			}
+		}
+
+		if (i == 0) {
+			res = tmp;
+
+			if (curIR->type_ == IRTYPE::kQueryPrimary) {
+				if (!info->has_column_limit()) {
+					info->columnNumber_ = res->columns_.size();
+				}
+
+				if (info->recursiveCteName_ != UNREFERENCE && info->recursiveCte_ == nullptr) {
+					res->identifierName_ = info->recursiveCteName_;
+					info->recursiveCte_ = res;
+				}				
+			}
+		}
+		else {
+			delete tmp;
+		}
+	}
+
+	info->location_ = oldLocation;
+
+	return res;
+}
+
+void Instantiator::instantiate_with_clause(IR* with_clause) {
+	StmtLocation location = StmtLocation::slCTE;
+
+	IR* with_list = NT_check(with_clause->left_, IRTYPE::kWithList);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+	info->clear_cte();
+
+	if (with_clause->op_->prefix_ == TERMINAL::tWithRecursive) {
+		location = StmtLocation::slRecursiveCTE;
+	}
+
+	while (with_list != nullptr) {
+		IR* common_table_expr = NT_check(with_list->left_, IRTYPE::kCommonTableExpr);
+
+		IR* table_name = NT_check(common_table_expr->left_, IRTYPE::kTableName);
+		IR* opt_column_list = NT_check(common_table_expr->right_->left_, IRTYPE::kOptColumnList);
+		IR* subquery = NT_check(common_table_expr->right_->right_, IRTYPE::kSubquery);
+
+		name_t tableName = globalStatusManger_->get_new_table_name();
+		if (location == StmtLocation::slRecursiveCTE) {
+			info->recursiveCteName_ = tableName;
+		}
+
+		info->update_acceColumns();
+
+		IR* curNode = subquery->left_;
+		while (curNode->type_ != IRTYPE::kQueryExpression) {
+			curNode = curNode->left_;
+		}
+
+		Table* table = instantiate_query_expression(curNode, location, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);
+		table->isSubQuery_ = true;
+		table->identifierName_ = tableName;
+
+		instantiate_ident(table_name, IdentifierType::iTable, tableName);
+
+		if (opt_column_list->left_) {
+			IR* column_list = NT_check(opt_column_list->left_, IRTYPE::kColumnList);
+			instantiate_column_list(column_list, table->columns_);
+		}
+
+		info->innerCteTables_.push_back(table);
+
+		info->recursiveCteName_ = UNREFERENCE;
+		info->acceColumns_.clear();
+
+		with_list = with_list->right_;
+	}
+
+	return;
+}
+void Instantiator::instantiate_order_clause(IR* order_clause) {
+	IR* order_list = NT_check(order_clause->left_, IRTYPE::kOrderList);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	while (order_list != nullptr) {
+		IR* expr_root = NT_check(order_list->left_->left_, IRTYPE::kExprRoot);
+
+		exprInstantiator_->instantiate_expr_root(expr_root, info->acceColumns_, StmtLocation::slOrderClause);	
+		info->add_out_usedColumns(exprInstantiator_->usedColumnsBuffer_);
+
+		order_list = order_list->right_;
+	}
+
+	return;
+}
+void Instantiator::instantiate_limit_clause(IR* limit_clause) {
+	IR* limit_options = NT_check(limit_clause->left_, IRTYPE::kLimitOptions);
+	IR* iconst_1 = NT_check(limit_options->left_, IRTYPE::kIconst);
+	IR* iconst_2 = (limit_options->right_ == nullptr) ? nullptr : NT_check(limit_options->right_, IRTYPE::kIconst);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	if (info->has_row_limit()) {
+		iconst_1->long_val_ = exprInstantiator_->get_random_integer(info->rowNumber_, info->rowNumber_);
+		info->rowNumber_ = DEFAULTROWNUMBER;
+	}
+	else {
+		iconst_1->long_val_ = exprInstantiator_->get_random_integer(LIMITMIN, LIMITMAX);
+	}
+	
+	if (iconst_2 != nullptr) {
+		iconst_2->long_val_ = exprInstantiator_->get_random_integer(OFFSETMIN, OFFSETMAX);
+	}
+
+	return;
+}
+
+Table* Instantiator::instantiate_select_item_list(IR* select_item_list) {
+	IR* t_select_item_list = select_item_list;
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+	Table* res = new Table(UNREFERENCE, IdentifierType::iTable, info);
+
+	int columnCount = 0;
+	while (t_select_item_list != nullptr) {
+		IR* select_item = NT_check(t_select_item_list->left_, IRTYPE::kSelectItem);
+
+		if (info->location_ == StmtLocation::slRecursivePart1 && columnCount == 0) {
+			deep_delete(select_item->left_);
+			deep_delete(select_item->right_);
+
+			select_item->left_ = deep_copy(IRTrim_->simple_expr_root_);
+			select_item->right_ = new IR(IRTYPE::kOptAlias, OP3(TERMINAL::tAs, TERMINAL::tEmpty, TERMINAL::tEmpty), deep_copy(IRTrim_->simple_alias_), nullptr);
+
+			IR* alias = NT_check(select_item->right_->left_, IRTYPE::kAlias);
+			instantiate_ident(alias, IdentifierType::iColumn, RESERVEDCOLUMNNAME);
+
+			bool tmp = res->add_column(new Column(RESERVEDCOLUMNNAME, ColumnType::ctInt));
+			assert(tmp);
+
+			columnCount++;
+		}
+		else {
+			if (select_item->left_->type_ == IRTYPE::kTableWild) {
+				bool success = false;
+
+				if (!info->usedTables_.empty()) {
+					IR* table_wild = NT_check(select_item->left_, IRTYPE::kTableWild);
+					IR* table_name = nullptr;
+
+					if (table_wild->left_ != nullptr) {
+						table_name = NT_check(table_wild->left_, IRTYPE::kTableName);
+					}
+
+					if (table_name != nullptr) {
+						int index = exprInstantiator_->get_random_integer(0, info->usedTables_.size() - 1);
+						Table* table = info->usedTables_[index];
+
+						if (!info->exist_duplicated_column(res->columns_, table->columns_) && (!info->has_column_limit() || (columnCount + table->columns_.size()) <= info->columnNumber_)) {
+							instantiate_ident(table_name, IdentifierType::iTable, table->identifierName_);
+
+							for (Column* c : table->columns_) {
+								bool tmp = res->add_column(new Column(c));
+								assert(tmp);
+							}
+
+							columnCount += table->columns_.size();
+							success = true;
+						}
+					}
+					else {
+						vector<Column*> columns;
+
+						for (Table* t : info->usedTables_) {
+							for (Column* c : t->columns_) {
+								columns.push_back(c);
+							}
+						}
+
+						if (!info->exist_duplicated_column(res->columns_, columns) && (!info->has_column_limit() || (columnCount + columns.size()) <= info->columnNumber_)) {
+							for (Column* c : columns) {
+								bool tmp = res->add_column(new Column(c));
+								assert(tmp);
+							}
+
+							columnCount += columns.size();
+							success = true;
+						}
+					}
+				}
+
+				if (!success) {
+					deep_delete(select_item->left_);
+
+					select_item->left_ = deep_copy(IRTrim_->simple_expr_root_);
+					select_item->right_ = new IR(IRTYPE::kOptAlias, OP3(TERMINAL::tAs, TERMINAL::tEmpty, TERMINAL::tEmpty), deep_copy(IRTrim_->simple_alias_), nullptr);
+				}
+			}
+
+			if (select_item->left_->type_ == IRTYPE::kExprRoot) {
+				IR* expr_root = NT_check(select_item->left_, IRTYPE::kExprRoot);
+				IR* opt_alias = NT_check(select_item->right_, IRTYPE::kOptAlias);
+
+				if (opt_alias->left_ == nullptr) {
+					opt_alias->left_ = deep_copy(IRTrim_->simple_alias_);
+					opt_alias->op_->prefix_ = TERMINAL::tAs;
+				}
+
+				IR* alias = NT_check(opt_alias->left_, IRTYPE::kAlias);
+
+				name_t newColumnName = res->get_acce_column_name();
+				instantiate_ident(alias, IdentifierType::iColumn, newColumnName);
+
+				exprInstantiator_->instantiate_expr_root(expr_root, info->acceColumns_, StmtLocation::slTargetList);
+				info->add_all_usedColumns(exprInstantiator_->usedColumnsBuffer_);
+
+				bool tmp = res->add_column(new Column(newColumnName, ColumnType::ctNull));
+				assert(tmp);
+
+				columnCount++;
+			}
+		}		
+
+		if (info->has_column_limit()) {
+			assert(info->columnNumber_ > 0);
+
+			if (columnCount >= info->columnNumber_ && t_select_item_list->right_ != nullptr) {
+				deep_delete(t_select_item_list->right_);
+
+				t_select_item_list->right_ = nullptr;
+				t_select_item_list->op_->middle_ = TERMINAL::tEmpty;
+			}
+			else if (columnCount < info->columnNumber_ && t_select_item_list->right_ == nullptr) {
+				t_select_item_list->right_ = deep_copy(IRTrim_->simple_select_item_list_);
+				t_select_item_list->op_->middle_ = TERMINAL::tOpComma;
+			}
+		}		
+
+		t_select_item_list = t_select_item_list->right_;
+	}
+
+	assert(res->columns_.size() == columnCount);
+
+	return res;
+}
+void Instantiator::instantiate_from_clause(IR* from_clause) {
+	IR* table_reference_list = NT_check(from_clause->left_, IRTYPE::kTableReferenceList);
+
+	while (table_reference_list != nullptr) {
+		IR* table_reference = NT_check(table_reference_list->left_, IRTYPE::kTableReference);
+		instantiate_table_reference(table_reference);
+
+		table_reference_list = table_reference_list->right_;
+	}
+
+	return;
+}
+vector<Table*> Instantiator::instantiate_table_reference(IR* table_reference) {
+	vector<Table*> res;
+	vector<IR*> queue;
+
+	if (table_reference->left_->type_ == IRTYPE::kJoinedTable) {
+		IR* joined_table = NT_check(table_reference->left_, IRTYPE::kJoinedTable);
+		queue.push_back(joined_table);
+	}
+	else {
+		IR* table_factor = NT_check(table_reference->left_, IRTYPE::kTableFactor);
+
+		switch (table_factor->left_->type_) {
+			case IRTYPE::kSingleTable: {
+				IR* single_table = NT_check(table_factor->left_, IRTYPE::kSingleTable);
+				queue.push_back(single_table);
+
+				break;
+			}
+			case IRTYPE::kDerivedTable: {
+				IR* derived_table = NT_check(table_factor->left_, IRTYPE::kDerivedTable);
+				queue.push_back(derived_table);
+
+				break;
+			}
+			case IRTYPE::kJoinedTableParens: {
+				IR* joined_table = NT_check(table_factor->left_->left_, IRTYPE::kJoinedTable);
+				queue.push_back(joined_table);
+
+				break;
+			}
+			case IRTYPE::kTableReferenceListParens: {
+				IR* table_reference_list_parens = NT_check(table_factor->left_, IRTYPE::kTableReferenceListParens);
+
+				while (table_reference_list_parens != nullptr) {
+					IR* t_table_reference = NT_check(table_reference_list_parens->left_, IRTYPE::kTableReference);
+					queue.push_back(t_table_reference);
+
+					table_reference_list_parens = table_reference_list_parens->right_;
+				}
+
+				break;
+			}
+			default: {
+				fprintf(stderr, "ERROR: Unknown table_factor->left_->type_: %d\n", static_cast<int>(table_factor->left_->type_));
+				assert(0);
+			}
+		}
+	}
+
+	assert(!queue.empty());
+	for (int i = 0; i < queue.size(); i++) {
+		IR* curIR = queue[i];
+
+		switch (curIR->type_) {
+			case IRTYPE::kSingleTable: {
+				Table* table = instantiate_single_table(curIR);
+				res.push_back(table);
+
+				break;
+			}
+			case IRTYPE::kDerivedTable: {
+				Table* table = instantiate_derived_table(curIR);
+				res.push_back(table);
+
+				break;
+			}
+			case IRTYPE::kJoinedTable: {
+				vector<Table*> tables = instantiate_joined_table(curIR);
+
+				for (Table* table : tables) {
+					res.push_back(table);
+				}
+
+				break;
+			}
+			case IRTYPE::kTableReference: {
+				vector<Table*> tables = instantiate_table_reference(curIR);
+
+				for (Table* table : tables) {
+					res.push_back(table);
+				}
+
+				break;
+			}
+			default: {
+				fprintf(stderr, "ERROR: Unknown curIR->type_: %d\n", static_cast<int>(curIR->type_));
+				assert(0);
+			}
+		}
+	}
+
+	return res;
+}
+Table* Instantiator::instantiate_single_table(IR* single_table) {
+	Table* res = nullptr;
+	Table* chosenTable = nullptr;
+
+	IR* table_name = NT_check(single_table->left_, IRTYPE::kTableName);
+	IR* opt_alias = NT_check(single_table->right_, IRTYPE::kOptAlias);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	if (info->location_ == StmtLocation::slRecursivePart2 && info->recursiveCteName_ != UNREFERENCE && info->recursiveCte_ != nullptr) {
+		chosenTable = info->recursiveCte_;
+
+		info->recursiveCteName_ = UNREFERENCE;
+		info->recursiveCte_ = nullptr;
+	}
+	else {
+		int index = globalStatusManger_->get_acce_table_number();
+		assert(index > 0);
+
+		int randomNumber = exprInstantiator_->get_random_integer(0, index - 1);
+		chosenTable = globalStatusManger_->get_acce_table(randomNumber);
+	}
+
+	res = new Table(chosenTable, info);
+	instantiate_ident(table_name, res->identifierType_, res->identifierName_);
+
+	if (info->is_duplicated_table(res) && opt_alias->left_ == nullptr) {
+		opt_alias->left_ = deep_copy(IRTrim_->simple_alias_);
+		opt_alias->op_->prefix_ = TERMINAL::tAs;
+	}
+
+	if (opt_alias->left_ != nullptr) {
+		name_t newName = globalStatusManger_->get_new_table_name();
+		IR* alias = NT_check(opt_alias->left_, IRTYPE::kAlias);
+
+		instantiate_ident(alias, IdentifierType::iTable, newName);
+
+		res->identifierName_ = newName;
+	}
+
+	info->add_used_table(res);
+
+	return res;
+}
+Table* Instantiator::instantiate_derived_table(IR* derived_table) {
+	Table* res = nullptr;
+
+	IR* subquery = NT_check(derived_table->left_, IRTYPE::kSubquery);
+	IR* alias = NT_check(derived_table->right_->left_, IRTYPE::kAlias);
+	IR* opt_column_list = NT_check(derived_table->right_->right_, IRTYPE::kOptColumnList);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	if (derived_table->op_->prefix_ == TERMINAL::tLateral) {
+		info->update_acceColumns();
+	}
+	else {
+		info->acceColumns_ = info->outReferences_;
+	}
+
+	IR* curNode = subquery->left_;
+	while (curNode->type_ != IRTYPE::kQueryExpression) {
+		curNode = curNode->left_;
+	}
+
+	res = instantiate_query_expression(curNode, StmtLocation::slTableReference, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);
+	res->isSubQuery_ = true;
+
+	name_t newName = globalStatusManger_->get_new_table_name();
+	instantiate_ident(alias, IdentifierType::iTable, newName);
+	res->identifierName_ = newName;
+
+	if (opt_column_list->left_ != nullptr) {
+		IR* column_list = NT_check(opt_column_list->left_, IRTYPE::kColumnList);
+
+		for (Column* c: res->columns_) {
+			name_t name = res->get_acce_column_name();
+			res->remove_column_name(name);
+			
+			if (name != UNREFERENCE) {
+				res->add_column_name(c->identifierName_);
+				c->identifierName_ = name;
+			}
+		}
+		
+		instantiate_column_list(column_list, res->columns_);
+	}
+
+	info->acceColumns_.clear();
+	info->add_used_table(res);
+
+	return res;
+}
+vector<Table*> Instantiator::instantiate_joined_table(IR* joined_table) {
+	bool isRightJoin = false;
+	vector<Table*> res;
+
+	IR* table_reference_left = nullptr;
+	IR* table_reference_right = nullptr;
+	IR* table_factor = nullptr;
+	IR* expr_root = nullptr;
+	IR* column_list = nullptr;
+	IR* joined_table_tmp = nullptr;
+
+	IR* unknown = nullptr;
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	table_reference_left = NT_check(joined_table->left_, IRTYPE::kTableReference);
+	unknown = joined_table->right_;
+
+	if (unknown->left_->type_ == IRTYPE::kNaturalJoinType) {
+		IR* natural_join_type = NT_check(unknown->left_, IRTYPE::kNaturalJoinType);
+
+		if (natural_join_type->op_->prefix_ == TERMINAL::tNaturalRight) {
+			isRightJoin = true;
+		}
+	}
+	else if (unknown->left_->type_ == IRTYPE::kOuterJoinType) {
+		IR* outer_join_type = NT_check(unknown->left_, IRTYPE::kOuterJoinType);
+
+		if (outer_join_type->op_->prefix_ == TERMINAL::tRight) {
+			isRightJoin = true;
+		}
+	}
+
+	if (unknown->right_->type_ == IRTYPE::kTableReference) {
+		table_reference_right = NT_check(unknown->right_, IRTYPE::kTableReference);
+	}
+	else if (unknown->right_->type_ == IRTYPE::kTableFactor) {
+		table_factor = NT_check(unknown->right_, IRTYPE::kTableFactor);
+	}
+	else {
+		joined_table_tmp = unknown->right_;
+
+		table_reference_right = NT_check(joined_table_tmp->left_, IRTYPE::kTableReference);
+
+		if (joined_table_tmp->right_->type_ == IRTYPE::kExprRoot) {
+			expr_root = NT_check(joined_table_tmp->right_, IRTYPE::kExprRoot);
+		}
+		else {
+			column_list = NT_check(joined_table_tmp->right_, IRTYPE::kColumnList);
+		}
+	}
+
+	if (table_factor != nullptr) {
+		table_reference_right = new IR(IRTYPE::kTableReference, OP0(), table_factor, nullptr);
+	}
+
+	vector<Table*> left;
+	vector<Table*> right;
+	if (isRightJoin) {
+		right = instantiate_table_reference(table_reference_right);
+		left = instantiate_table_reference(table_reference_left);
+	}
+	else {
+		left = instantiate_table_reference(table_reference_left);
+		right = instantiate_table_reference(table_reference_right);
+	}
+
+	if (table_factor != nullptr && table_reference_right->left_ == table_factor) {
+		table_reference_right->left_ = nullptr;
+		deep_delete(table_reference_right);
+		table_reference_right = nullptr;
+	}
+
+	vector<int> columnNames = vector<int>(COLUMNNAMEMAX, 0);
+	for (Table* t : left) {
+		for (Column* c : t->columns_) {
+			columnNames[c->identifierName_]++;
+		}
+
+		res.push_back(t);
+	}
+
+	for (Table* t : right) {
+		for (Column* c : t->columns_) {
+			columnNames[c->identifierName_]++;
+		}
+
+		res.push_back(t);
+	}
+
+	if (column_list != nullptr) {
+		vector<name_t> duplicatedColumnNames;
+		for (int i = 0; i < COLUMNNAMEMAX; i++) {
+			if (columnNames[i] > 1) {
+				duplicatedColumnNames.push_back(static_cast<name_t>(i));
+			}
+		}
+
+		if (!duplicatedColumnNames.empty()) {
+			vector<name_t> usedColumns;
+
+			random_device rd;
+			mt19937 r_eng(rd());
+			uniform_int_distribution<int> dis(1, duplicatedColumnNames.size());
+
+			int max = dis(r_eng);
+			for (int i = 0; i < max; i++) {
+				usedColumns.push_back(duplicatedColumnNames[i]);
+			}
+
+			instantiate_column_list(column_list, usedColumns);
+		}
+		else {
+			deep_delete(joined_table_tmp->right_);
+			joined_table_tmp->right_ = deep_copy(IRTrim_->simple_expr_root_true_);
+
+			joined_table_tmp->op_->middle_ = TERMINAL::tOn;
+			joined_table_tmp->op_->suffix_ = TERMINAL::tEmpty;
+
+			column_list = nullptr;
+		}
+	}
+	else if (expr_root != nullptr) {
+		info->update_acceColumns(res, columnNames);
+
+		exprInstantiator_->instantiate_expr_root(expr_root, info->acceColumns_, StmtLocation::slTableReference);
+		info->add_out_usedColumns(exprInstantiator_->usedColumnsBuffer_);
+
+		info->acceColumns_.clear();
+	}
+
+	return res;
+}
+void Instantiator::instantiate_where_clause(IR* where_clause) {
+	IR* expr_root = NT_check(where_clause->left_, IRTYPE::kExprRoot);
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	exprInstantiator_->instantiate_expr_root(expr_root, info->acceColumns_, StmtLocation::slWhereClause);
+	info->add_out_usedColumns(exprInstantiator_->usedColumnsBuffer_);
+
+	if (info->location_ == StmtLocation::slRecursivePart2) {
+		IRTrim_->set_recursive_limit(expr_root);
+	}
+
+	return;
+}
+void Instantiator::instantiate_group_clause(IR* group_clause) {
+	IR* expr_root_list = NT_check(group_clause->left_, IRTYPE::kExprRootList);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	int i = 0;
+	while (expr_root_list != nullptr && i < info->usedInnerColumns_.size()) {
+		IR* expr_root = IRTrim_->get_expr_root_columnref(info->usedInnerColumns_[i]);
+
+		deep_delete(expr_root_list->left_);
+		expr_root_list->left_ = expr_root;
+
+		i++;
+
+		if (i < info->usedInnerColumns_.size() && expr_root_list->right_ == nullptr) {
+			expr_root_list->right_ = deep_copy(IRTrim_->simple_expr_root_list_);
+			expr_root_list->op_->middle_ = TERMINAL::tOpComma;
+		}
+
+		expr_root_list = expr_root_list->right_;
+	}
+
+	vector<Column*> usedColumns;
+	while (expr_root_list != nullptr && !info->acceColumns_.empty()) {
+		int index = exprInstantiator_->get_random_integer(0, info->acceColumns_.size() - 1);
+		Column* randomColumn = info->acceColumns_[index];
+
+		IR* expr_root = IRTrim_->get_expr_root_columnref(randomColumn);
+
+		deep_delete(expr_root_list->left_);
+		expr_root_list->left_ = expr_root;
+
+		if (find(usedColumns.begin(), usedColumns.end(), randomColumn) == usedColumns.end()) {
+			usedColumns.push_back(randomColumn);
+		}		
+
+		expr_root_list = expr_root_list->right_;
+	}
+
+	if (expr_root_list != nullptr) {
+		deep_delete(expr_root_list->left_);
+		expr_root_list->left_ = deep_copy(IRTrim_->simple_expr_root_);
+
+		deep_delete(expr_root_list->right_);
+
+		expr_root_list->right_ = nullptr;
+		expr_root_list->op_->middle_ = TERMINAL::tEmpty;
+	}
+
+	info->add_out_usedColumns(usedColumns);
+
+	return;
+}
+void Instantiator::instantiate_having_clause(IR* having_clause) {
+	IR* expr_root = NT_check(having_clause->left_, IRTYPE::kExprRoot);
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	exprInstantiator_->instantiate_expr_root(expr_root, info->acceColumns_, StmtLocation::slHavingClause);
+	info->add_all_usedColumns(exprInstantiator_->usedColumnsBuffer_);
+
+	return;
+}
+void Instantiator::instantiate_window_clause(IR* window_clause) {
+	IR* window_definition_list = NT_check(window_clause->left_, IRTYPE::kWindowDefinitionList);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	while (window_definition_list != nullptr) {
+		IR* window_definition = NT_check(window_definition_list->left_, IRTYPE::kWindowDefinition);
+		instantiate_window_definition(window_definition);
+
+		window_definition_list = window_definition_list->right_;
+	}
+
+	return;
+}
+void Instantiator::instantiate_window_definition(IR* window_definition) {
+	IR* window_name = NT_check(window_definition->left_, IRTYPE::kWindowName);
+	IR* window_spec = NT_check(window_definition->right_, IRTYPE::kWindowSpec);
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	name_t newWindowName = globalStatusManger_->get_new_window_name();
+	instantiate_ident(window_name, IdentifierType::iWindow, newWindowName);
+
+	WindowStatus windowStatus = instantiate_window_spec(window_spec);
+
+	info->windowStatusRecord_[newWindowName] = windowStatus;
+
+	return;
+}
+WindowStatus Instantiator::instantiate_window_spec(IR* window_spec) {
+	WindowStatus windowStatus = WindowStatus::wsNoInherit;
+
+	IR* window_spec_details = nullptr;
+
+	IR* opt_existing_window_name = nullptr;
+	IR* opt_partition_clause = nullptr;
+	IR* opt_window_order_by_clause = nullptr;
+	IR* opt_window_frame_clause = nullptr;
+
+	IR* unknown = nullptr;
+
+	SelectStmtInfo* info = globalStatusManger_->get_cur_selectInfo();
+
+	window_spec_details = NT_check(window_spec->left_, IRTYPE::kWindowSpecDetails);
+
+	opt_existing_window_name = NT_check(window_spec_details->left_, IRTYPE::kOptExistingWindowName);
+	unknown = window_spec_details->right_;
+
+	opt_partition_clause = NT_check(unknown->left_, IRTYPE::kOptPartitionClause);
+	unknown = unknown->right_;
+
+	opt_window_order_by_clause = NT_check(unknown->left_, IRTYPE::kOptWindowOrderByClause);
+	opt_window_frame_clause = NT_check(unknown->right_, IRTYPE::kOptWindowFrameClause);
+
+	if (opt_existing_window_name->left_ != nullptr) {
+		vector<name_t> inheritedWindows;
+
+		for (auto &it : info->windowStatusRecord_) {
+			if (it.second != WindowStatus::wsCantBeInherited) {
+				inheritedWindows.push_back(it.first);
+			}
+		}
+
+		if (inheritedWindows.empty()) {
+			deep_delete(opt_existing_window_name->left_);
+			opt_existing_window_name->left_ = nullptr;
+		}
+		else {
+			int index = exprInstantiator_->get_random_integer(0, inheritedWindows.size() - 1);
+			name_t inheritedWindowName = inheritedWindows[index];
+
+			IR* t_window_name = NT_check(opt_existing_window_name->left_, IRTYPE::kWindowName);
+			instantiate_ident(t_window_name, IdentifierType::iWindow, inheritedWindowName);
+
+			windowStatus = info->windowStatusRecord_[inheritedWindowName] == WindowStatus::wsWithOrder ? WindowStatus::wsWithOrder : WindowStatus::wsInherit;
+		}
+	}
+
+	if (opt_partition_clause->left_ != nullptr) {
+		if (windowStatus == WindowStatus::wsNoInherit) {
+			IR* expr_root_list = NT_check(opt_partition_clause->left_, IRTYPE::kExprRootList);
+
+			while (expr_root_list != nullptr) {
+				IR* expr_root = NT_check(expr_root_list->left_, IRTYPE::kExprRoot);
+
+				exprInstantiator_->instantiate_expr_root(expr_root, info->acceColumns_, StmtLocation::slWindowClause);
+				info->add_all_usedColumns(exprInstantiator_->usedColumnsBuffer_);
+
+				expr_root_list = expr_root_list->right_;
+			}
+		}
+		else {
+			deep_delete(opt_partition_clause->left_);
+
+			opt_partition_clause->left_ = nullptr;
+			opt_partition_clause->op_->prefix_ = TERMINAL::tEmpty;
+		}
+	}
+
+	if (opt_window_order_by_clause->left_ != nullptr) {
+		if (windowStatus != WindowStatus::wsWithOrder) {
+			IR* order_list = NT_check(opt_window_order_by_clause->left_, IRTYPE::kOrderList);
+
+			while (order_list != nullptr) {
+				IR* expr_root = NT_check(order_list->left_->left_, IRTYPE::kExprRoot);
+
+				exprInstantiator_->instantiate_expr_root(expr_root, info->acceColumns_, StmtLocation::slWindowClause);
+				info->add_all_usedColumns(exprInstantiator_->usedColumnsBuffer_);
+
+				order_list = order_list->right_;
+			}
+
+			windowStatus = WindowStatus::wsWithOrder;
+		}
+		else {
+			deep_delete(opt_window_order_by_clause->left_);
+
+			opt_window_order_by_clause->left_ = nullptr;
+			opt_window_order_by_clause->op_->prefix_ = TERMINAL::tEmpty;
+		}
+	}
+
+	if (opt_window_frame_clause->left_ != nullptr) {
+		IR* window_frame_units = NT_check(opt_window_frame_clause->left_, IRTYPE::kWindowFrameUnits);
+		IR* window_frame_extent = NT_check(opt_window_frame_clause->right_, IRTYPE::kWindowFrameExtent);
+
+		if (windowStatus != WindowStatus::wsWithOrder) {
+			window_frame_units->op_->prefix_ = TERMINAL::tRows;
+		}
+
+		stack<IR*> IRStack;
+		vector<IR*> iconsts;
+		IRStack.push(window_frame_extent);
+
+		while (!IRStack.empty()) {
+			IR* curIR = IRStack.top();
+			IRStack.pop();
+
+			if (curIR == nullptr) {
+				continue;
+			}
+			else if (curIR->type_ == IRTYPE::kIconst) {
+				iconsts.push_back(curIR);
+			}
+			else {
+				IRStack.push(curIR->right_);
+				IRStack.push(curIR->left_);
+			}
+		}
+
+		for (IR* curIR : iconsts) {
+			curIR->long_val_ = exprInstantiator_->get_random_integer(LIMITMIN, LIMITMAX);
+		}
+
+		windowStatus = WindowStatus::wsCantBeInherited;
+	}
+
+	return windowStatus;
+}
+
+void Instantiator::instantiate_column_list(IR* column_list, vector<name_t>& columns) {
+	int i = 0;
+
+	while (column_list != nullptr && i < columns.size()) {
+		IR* column_name = NT_check(column_list->left_, IRTYPE::kColumnName);
+		instantiate_ident(column_name, IdentifierType::iColumn, columns[i]);
+
+		i++;
+
+		if (i == columns.size() && column_list->right_ != nullptr) {
+			deep_delete(column_list->right_);
+
+			column_list->right_ = nullptr;
+			column_list->op_->middle_ = TERMINAL::tEmpty;
+		}
+		else if (i != columns.size() && column_list->right_ == nullptr) {
+			column_list->right_ = deep_copy(IRTrim_->simple_column_list_);
+			column_list->op_->middle_ = TERMINAL::tOpComma;
+		}
+
+		column_list = column_list->right_;
+	}
+
+	return;
+}
+void Instantiator::instantiate_column_list(IR* column_list, vector<Column*>& columns) {
+	vector<name_t> columnNames;
+
+	for (Column* c : columns) {
+		columnNames.push_back(c->identifierName_);
+	}
+
+	instantiate_column_list(column_list, columnNames);
+
+	return;
+}
+void Instantiator::instantiate_key_list(IR* key_list, vector<Column*>& columns) {
+	int count = 0;
+	IR* curNode = key_list;
+	while (curNode != nullptr && count < columns.size()) {
+		IR* key_part = NT_check(curNode->left_, IRTYPE::kKeyPart);
+		IR* column_name = NT_check(key_part->left_, IRTYPE::kColumnName);
+		IR* iconst = nullptr;
+
+		instantiate_ident(column_name, IdentifierType::iColumn, columns[count]->identifierName_);
+		
+		if (key_part->right_->type_ != IRTYPE::kOptOrderingDirection) {
+			if (Column::typeToBasicType_[columns[count]->columnType_] != ColumnBasicType::ctString) {
+				deep_delete(key_part->right_);
+				key_part->right_ = new IR(IRTYPE::kOptOrderingDirection, OP0(), nullptr, nullptr);
+			}
+			else {
+				iconst = NT_check(key_part->right_->left_, IRTYPE::kIconst);
+			}
+		}
+
+		if (iconst != nullptr) {
+			int v1 = exprInstantiator_->get_random_integer(1, 32);
+			iconst->long_val_ = v1;
+		}
+
+		count++;
+
+		if (count == columns.size() && curNode->right_ != nullptr) {
+			deep_delete(curNode->right_);
+
+			curNode->right_ = nullptr;
+			curNode->op_->middle_ = TERMINAL::tEmpty;
+		}
+		else if (count != columns.size() && curNode->right_ == nullptr) {
+			curNode->right_ = deep_copy(IRTrim_->simple_key_part_list_);
+			curNode->op_->middle_ = TERMINAL::tOpComma;
+		}
+
+		curNode = curNode->right_;
+	}
+
+	return;
+}
+void Instantiator::instantiate_ident(IR* identifier_name, IdentifierType type, name_t name) {
+	IR* ident = NT_check(identifier_name->left_, IRTYPE::kIdent);
+
+	switch(type) {
+		case IdentifierType::iColumn: {
+			ident->str_val_ = "c" + to_string(name);
+			break;
+		}
+		case IdentifierType::iTable: {
+			ident->str_val_ = "t" + to_string(name);
+			break;
+		}
+		case IdentifierType::iWindow: {
+			ident->str_val_ = "w" + to_string(name);
+			break;
+		}
+		case IdentifierType::iIndex: {
+			ident->str_val_ = "i" + to_string(name);
+			break;
+		}
+		case IdentifierType::iConstraint: {
+			ident->str_val_ = "cc" + to_string(name);
+			break;
+		}
+		case IdentifierType::iView: {
+			ident->str_val_ = "v" + to_string(name);
+			break;
+		}
+		default: {
+			fprintf(stderr, "ERROR: Unknown Ident Type: %d\n", static_cast<int>(type));
+			assert(0);
+		}
+	}
+
+	return;
+}
+
+bool Instantiator::check_foreign_key(Table* table, vector<Column*>& curTableColumn, vector<Column*>& otherTableColumn) {
+	vector<ColumnType> types;
+
+	vector<Table*> acceTable = globalStatusManger_->get_acce_table(IdentifierType::iTable);
+	acceTable.push_back(table);
+
+	for (Column* c : table->columns_) {
+		types.push_back(c->columnType_);
+	}
+
+	Table* chosenTable = acceTable[rand() % acceTable.size()];
+	for (Index* index : chosenTable->indexes_) {
+		bool flag = false;
+
+		for (auto& it : index->columns_) {
+			if (find(types.begin(), types.end(), it.first->columnType_) == types.end() || it.second == IndexType::itFunctional) {
+				continue;
+			}
+
+			for (Column* column : table->columns_) {
+				if (column->columnType_ != it.first->columnType_ || it.first == column) {
+					continue;
+				}
+
+				if (find(curTableColumn.begin(), curTableColumn.end(), column) == curTableColumn.end()) {
+					curTableColumn.push_back(column);
+					otherTableColumn.push_back(it.first);
+
+					flag = true;
+					break;
+				}
+			}
+		}
+
+		if (flag == true) {
+			break;
+		}
+	}
+
+	if (curTableColumn.empty() || curTableColumn.size() != otherTableColumn.size()) {
+		return false;
+	}
+
+	return true;
+}
+
+//-----------------------------ExprInstantiator-----------------------------
+void ExprInstantiator::instantiate_expr_root(IR* expr_root, vector<Column*>& acceColumns, StmtLocation location) {
+	usedColumnsBuffer_.clear();
+
+	IR* expr = NT_check(expr_root->left_, IRTYPE::kExpr);
+	instantiate_expr(expr, acceColumns, location);
+
+	return;
+}
+void ExprInstantiator::instantiate_expr(IR* expr, vector<Column*>& acceColumns, StmtLocation location) {
+	stack<IR*> IRStack;
+	vector<IR*> queue;
+
+	IRStack.push(expr);
+
+	while (!IRStack.empty()) {
+		IR* curIR = IRStack.top();
+		IRStack.pop();
+
+		if (curIR == nullptr) {
+			continue;
+		}
+
+		switch (curIR->type_) {
+			case IRTYPE::kAllSubquery:
+			case IRTYPE::kInSubquery: {
+				queue.push_back(curIR);
+				break;
+			}
+			case IRTYPE::kSimpleExpr: {
+				if (find(ignoreSimpleExpr_.begin(), ignoreSimpleExpr_.end(), curIR->left_->type_) != ignoreSimpleExpr_.end()) {
+					IRStack.push(curIR->left_);
+				}
+				else {
+					queue.push_back(curIR);
+				}
+
+				break;
+			}
+			default: {
+				IRStack.push(curIR->left_);
+				IRStack.push(curIR->right_);
+
+				break;
+			}
+		}
+	}
+
+	for (IR* curIR : queue) {
+		assert(curIR->type_ == IRTYPE::kInSubquery || curIR->type_ == IRTYPE::kAllSubquery || curIR->type_ == IRTYPE::kSimpleExpr);
+
+		if (curIR->type_ == IRTYPE::kSimpleExpr) {
+			instantiate_simple_expr(curIR, acceColumns, location);
+		}
+		else {
+			while (curIR->type_ != IRTYPE::kQueryExpression) {
+				curIR = curIR->left_;
+			}
+
+			vector<Column*> tmpUsedColumns = usedColumnsBuffer_;
+			Table* tmp = instantiator_->instantiate_query_expression(curIR, location, DEFAULTROWNUMBER, 1);
+
+			delete tmp;
+			usedColumnsBuffer_ = tmpUsedColumns;
+		}
+	}
+
+	return;
+}
+void ExprInstantiator::instantiate_simple_expr(IR* simple_expr, vector<Column*>& acceColumns, StmtLocation location) {
+	assert(find(ignoreSimpleExpr_.begin(), ignoreSimpleExpr_.end(), simple_expr->left_->type_) == ignoreSimpleExpr_.end());
+
+	switch (simple_expr->left_->type_) {
+		case IRTYPE::kColumnref: {
+			if (!acceColumns.empty()) {
+				IR* columnref = NT_check(simple_expr->left_, IRTYPE::kColumnref);
+
+				IR* table_name = nullptr;
+				IR* column_name = nullptr;
+
+				if (columnref->right_ == nullptr) {
+					column_name = NT_check(columnref->left_, IRTYPE::kColumnName);
+				}
+				else {
+					table_name = NT_check(columnref->left_, IRTYPE::kTableName);
+					column_name = NT_check(columnref->right_, IRTYPE::kColumnName);
+				}
+
+				int index = get_random_integer(0, acceColumns.size() - 1);
+				Column* column = acceColumns[index];
+
+				if (column->duplicated_ == ColumnStatus::csDuplication && table_name == nullptr) {
+					IR* tmp1 = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+					IR* tmp2 = new IR(IRTYPE::kTableName, OP0(), tmp1, nullptr);
+
+					table_name = tmp2;
+
+					columnref->left_ = table_name;
+					columnref->right_ = column_name;
+					columnref->op_->middle_ = TERMINAL::tOpDot;					
+				}
+
+				if (table_name != nullptr) {
+					name_t tableName = column->parentTable_->identifierName_;
+					instantiator_->instantiate_ident(table_name, IdentifierType::iTable, tableName);
+				}
+
+				name_t columnName = column->identifierName_;
+				instantiator_->instantiate_ident(column_name, IdentifierType::iColumn, columnName);
+
+				if (find(usedColumnsBuffer_.begin(), usedColumnsBuffer_.end(), column) == usedColumnsBuffer_.end()) {
+					usedColumnsBuffer_.push_back(column);
+				}
+			}
+			else {
+				deep_delete(simple_expr->left_);
+
+				simple_expr->left_ = new IR(IRTYPE::kIconst, OP0(), nullptr, nullptr);
+				simple_expr->left_->long_val_ = get_random_integer();
+			}			
+
+			break;
+		}
+		case IRTYPE::kIconst: {
+			IR* iconst = NT_check(simple_expr->left_, IRTYPE::kIconst);
+			iconst->long_val_ = (rand() % 10) == 0 ? get_random_integer() : get_random_integer(-128, 128);
+
+			break;
+		}
+		case IRTYPE::kFconst: {
+			IR* fconst = NT_check(simple_expr->left_, IRTYPE::kFconst);
+			fconst->float_val_ = (rand() % 10) == 0 ? get_random_float() : get_random_float(-128, 128);
+
+			break;
+		}
+		case IRTYPE::kSconst: {
+			IR* sconst = NT_check(simple_expr->left_, IRTYPE::kSconst);
+			sconst->str_val_ = get_random_string(MINSTRINGLENGTH, MAXSTRINGLENGTH);
+
+			break;
+		}
+		case IRTYPE::kSubquery: {
+			IR* subquery = NT_check(simple_expr->left_, IRTYPE::kSubquery);
+
+			IR* curNode = subquery->left_;
+			while (curNode->type_ != IRTYPE::kQueryExpression) {
+				curNode = curNode->left_;
+			}
+			
+			Table* tmp = nullptr;
+			vector<Column*> tmpUsedColumns = usedColumnsBuffer_;
+
+			if (simple_expr->op_->prefix_ == TERMINAL::tExists) {
+				tmp = instantiator_->instantiate_query_expression(curNode, StmtLocation::slTargetList, DEFAULTROWNUMBER, DEFAULTCOLUMNNUMBER);				
+			}
+			else {
+				tmp = instantiator_->instantiate_query_expression(curNode, StmtLocation::slTargetList, 1, 1);
+			}
+
+			delete tmp;
+			usedColumnsBuffer_ = tmpUsedColumns;
+
+			break;
+		}
+		case IRTYPE::kTypeCast: {
+			IR* type_cast = NT_check(simple_expr->left_, IRTYPE::kTypeCast);
+			instantiate_type_cast(type_cast, acceColumns, location);
+
+			break;
+		}
+		case IRTYPE::kFunction: {
+			IR* function = NT_check(simple_expr->left_, IRTYPE::kFunction);
+			instantiate_function(function, acceColumns, location);
+
+			break;
+		}
+		default: {
+			fprintf(stderr, "ERROR: Unknown simple_expr->left_->type_: %d\n", static_cast<int>(simple_expr->left_->type_));
+			assert(0);
+		}
+	}
+
+	return;
+}
+void ExprInstantiator::instantiate_type_cast(IR* type_cast, vector<Column*>& acceColumns, StmtLocation location) {
+	IR* expr = NT_check(type_cast->left_, IRTYPE::kExpr);
+	IR* cast_type = NT_check(type_cast->right_, IRTYPE::kCastType);
+
+	if (cast_type->left_ != nullptr && cast_type->left_->left_ != nullptr) {
+		IR* tmp = cast_type->left_;
+
+		if (tmp->left_->type_ == IRTYPE::kFieldLength) {
+			IR* field_length = NT_check(tmp->left_, IRTYPE::kFieldLength);
+			IR* iconst = NT_check(field_length->left_, IRTYPE::kIconst);
+
+			iconst->long_val_ = get_random_integer(1, LONG_MAX);
+		}
+		else if (tmp->left_->type_ == IRTYPE::kPrecision) {
+			IR* precision = NT_check(tmp->left_, IRTYPE::kPrecision);
+
+			IR* iconst_left = NT_check(precision->left_, IRTYPE::kIconst);
+			IR* iconst_right = NT_check(precision->right_, IRTYPE::kIconst);
+
+			iconst_left->long_val_ = get_random_integer(1, 65);
+			iconst_right->long_val_ = get_random_integer(1, min(static_cast<int>(iconst_left->long_val_), 30));
+		}
+		else {
+			fprintf(stderr, "ERROR: Unknown cast_type->left_->left_->type_: %d\n", static_cast<int>(cast_type->left_->left_->type_));
+			assert(0);
+		}
+	}
+
+	instantiate_expr(expr, acceColumns, location);
+
+	return;
+}
+void ExprInstantiator::instantiate_function(IR* function, vector<Column*>& acceColumns, StmtLocation location) {
+	switch (function->left_->type_) {
+		case IRTYPE::kControlFunction:
+		case IRTYPE::kMathFunction:
+		case IRTYPE::kStringFunction: {
+			stack<IR*> IRStack;
+			vector<IR*> queue;
+
+			IRStack.push(function->left_);
+			while (!IRStack.empty()) {
+				IR* curIR = IRStack.top();
+				IRStack.pop();
+
+				if (curIR == nullptr) {
+					continue;
+				}
+
+				if (curIR->type_ == IRTYPE::kExpr) {
+					queue.push_back(curIR);
+				}
+				else {
+					IRStack.push(curIR->left_);
+					IRStack.push(curIR->right_);
+				}
+			}
+
+			for (IR* expr : queue) {
+				assert(expr->type_ == IRTYPE::kExpr);
+
+				instantiate_expr(expr, acceColumns, location);
+			}
+
+			break;
+		}
+		case IRTYPE::kAggregateFunction: {
+			if (location != StmtLocation::slTargetList && location != StmtLocation::slHavingClause && location != StmtLocation::slWindowClause) {
+				deep_delete(function->left_);
+				function->left_ = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tRandOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+
+				break;
+			}
+
+			IR* aggregate_function = NT_check(function->left_, IRTYPE::kAggregateFunction);
+			instantiate_aggregate_function(aggregate_function, acceColumns, location);
+
+			break;
+		}
+		case IRTYPE::kWindowFunction: {
+			if (location != StmtLocation::slTargetList) {
+				deep_delete(function->left_);
+				function->left_ = new IR(IRTYPE::kMathFunction, OP3(TERMINAL::tRandOpLpOpRp, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+
+				break;
+			}
+
+			IR* window_function = NT_check(function->left_, IRTYPE::kWindowFunction);
+			instantiate_window_function(window_function, acceColumns, location);
+
+			break;
+		}
+		default: {
+			fprintf(stderr, "ERROR: Unknown function->left_->type_: %d\n", static_cast<int>(function->left_->type_));
+			assert(0);
+		}
+	}
+
+	return;
+}
+void ExprInstantiator::instantiate_aggregate_function(IR* aggregate_function, vector<Column*>& acceColumns, StmtLocation location) {	
+	stack<IR*> IRStack;
+	vector<IR*> queue;
+	vector<IRTYPE> captureType = { IRTYPE::kExpr, IRTYPE::kWindowingClause, IRTYPE::kOrderClause, IRTYPE::kSconst };
+
+	SelectStmtInfo* info = instantiator_->globalStatusManger_->get_cur_selectInfo();
+
+	IRStack.push(aggregate_function);
+	while (!IRStack.empty()) {
+		IR* curIR = IRStack.top();
+		IRStack.pop();
+
+		if (curIR == nullptr) {
+			continue;
+		}
+
+		if (find(captureType.begin(), captureType.end(), curIR->type_) != captureType.end()) {
+			queue.push_back(curIR);
+		}
+		else {
+			IRStack.push(curIR->left_);
+			IRStack.push(curIR->right_);
+		}
+	}
+
+	for (IR* curIR : queue) {
+		switch (curIR->type_) {
+			case IRTYPE::kExpr: {
+				instantiate_expr(curIR, acceColumns, location);
+				break;
+			}
+			case IRTYPE::kWindowingClause: {
+				IR* window_name_or_spec = NT_check(curIR->left_, IRTYPE::kWindowNameOrSpec);
+
+				if (info->windowStatusRecord_.empty() && window_name_or_spec->left_->type_ == IRTYPE::kWindowName) {
+					deep_delete(window_name_or_spec->left_);
+					window_name_or_spec->left_ = deep_copy(instantiator_->IRTrim_->simple_window_spec_);
+				}
+
+				if (window_name_or_spec->left_->type_ == IRTYPE::kWindowName) {
+					IR* window_name = NT_check(window_name_or_spec->left_, IRTYPE::kWindowName);
+
+					vector<name_t> windowNames;
+					for (auto &it : info->windowStatusRecord_) {
+						windowNames.push_back(it.first);
+					}
+
+					assert(!windowNames.empty());
+
+					int index = get_random_integer(0, windowNames.size() - 1);
+					name_t windowName = windowNames[index];
+
+					instantiator_->instantiate_ident(window_name, IdentifierType::iWindow, windowName);
+				}
+				else {
+					IR* window_spec = NT_check(window_name_or_spec->left_, IRTYPE::kWindowSpec);
+					instantiator_->instantiate_window_spec(window_spec);
+				}
+
+				break;
+			}
+			case IRTYPE::kOrderClause: {
+				instantiator_->instantiate_order_clause(curIR);
+				break;
+			}
+			case IRTYPE::kSconst: {
+				curIR->str_val_ = get_random_string(MINSTRINGLENGTH, MAXSTRINGLENGTH);
+				break;
+			}
+			default: {
+				fprintf(stderr, "ERROR: Unknown curIR->type_: %d\n", static_cast<int>(curIR->type_));
+				assert(0);
+			}
+		}
+	}
+
+	info->hasAggregate = true;
+
+	return;
+}
+void ExprInstantiator::instantiate_window_function(IR* window_function, vector<Column*>& acceColumns, StmtLocation location) {
+	stack<IR*> IRStack;
+	vector<IR*> queue;
+	vector<IRTYPE> captureType = { IRTYPE::kExpr, IRTYPE::kWindowingClause, IRTYPE::kIconst };
+
+	SelectStmtInfo* info = instantiator_->globalStatusManger_->get_cur_selectInfo();
+
+	IRStack.push(window_function);
+
+	while (!IRStack.empty()) {
+		IR* curIR = IRStack.top();
+		IRStack.pop();
+
+		if (curIR == nullptr) {
+			continue;
+		}
+
+		if (find(captureType.begin(), captureType.end(), curIR->type_) != captureType.end()) {
+			queue.push_back(curIR);
+		}
+		else {
+			IRStack.push(curIR->left_);
+			IRStack.push(curIR->right_);
+		}
+	}
+
+	for (IR* curIR : queue) {
+		switch (curIR->type_) {
+			case IRTYPE::kExpr: {
+				instantiate_expr(curIR, acceColumns, location);
+				break;
+			}
+			case IRTYPE::kWindowingClause: {
+				IR* window_name_or_spec = NT_check(curIR->left_, IRTYPE::kWindowNameOrSpec);
+
+				if (info->windowStatusRecord_.empty() && window_name_or_spec->left_->type_ == IRTYPE::kWindowName) {
+					deep_delete(window_name_or_spec->left_);
+					window_name_or_spec->left_ = deep_copy(instantiator_->IRTrim_->simple_window_spec_);
+				}
+
+				if (window_name_or_spec->left_->type_ == IRTYPE::kWindowName) {
+					IR* window_name = NT_check(window_name_or_spec->left_, IRTYPE::kWindowName);
+
+					vector<name_t> windowNames;
+					for (auto &it : info->windowStatusRecord_) {
+						windowNames.push_back(it.first);
+					}
+
+					assert(!windowNames.empty());
+
+					int index = get_random_integer(0, windowNames.size() - 1);
+					name_t windowName = windowNames[index];
+
+					instantiator_->instantiate_ident(window_name, IdentifierType::iWindow, windowName);
+				}
+				else {
+					IR* window_spec = NT_check(window_name_or_spec->left_, IRTYPE::kWindowSpec);
+					instantiator_->instantiate_window_spec(window_spec);
+				}
+
+				break;
+			}
+			case IRTYPE::kIconst: {
+				curIR->long_val_ = get_random_integer(1, LONG_MAX);
+				break;
+			}
+			default: {
+				fprintf(stderr, "ERROR: Unknown curIR->type_: %d\n", static_cast<int>(curIR->type_));
+				assert(0);
+			}
+		}
+	}
+
+	return;
+}
+
+long int ExprInstantiator::get_random_integer(long int min, long int max) {
+	assert(min <= max);
+
+	random_device rd;
+	mt19937 r_eng(rd());
+	uniform_int_distribution<long int> dis(min, max);
+
+	return dis(r_eng);
+}
+double ExprInstantiator::get_random_float(int min, int max) {
+	random_device rd;
+	mt19937 r_eng(rd());
+	uniform_real_distribution<double> dis(min, max);
+
+	return dis(r_eng);
+}
+string ExprInstantiator::get_random_string(int minLength, int maxLength) {
+	random_device rd;
+	mt19937 r_eng(rd());
+	uniform_int_distribution<int> charNumber(32, 126);
+	uniform_int_distribution<int> stringLength(minLength, maxLength);
+
+	int length = stringLength(r_eng);
+	string res = "\'";
+
+	for (int i = 0; i < length; i++) {
+		char tmp = charNumber(r_eng);
+
+		if (tmp == '\'' || tmp == '\\') {
+			res += "\\";			
+		}
+		
+		res += tmp;
+	}
+
+	res += "\'";
+
+	return res;
+}
diff --git a/src/mutate.cpp b/src/mutate.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..d0108f59ac9de7cb0f13bbcd63cb8a611dc774b1
--- /dev/null
+++ b/src/mutate.cpp
@@ -0,0 +1,1359 @@
+#include "../include/mutate.h"
+#include "../include/ast.h"
+#include "../include/define.h"
+
+#include "../parser/bison_parser.h"
+#include "../parser/flex_lexer.h"
+
+#include <iostream>
+#include <assert.h>
+#include <fstream>
+#include <cstdio>
+#include <climits>
+#include <cfloat>
+#include <algorithm>
+#include <deque>
+
+#include <filesystem>
+
+using namespace std;
+namespace fs = std::filesystem;
+
+double get_random_double(int min, int max) {
+	random_device rd;
+	mt19937 r_eng(rd());
+	uniform_real_distribution<double> dis(min, max);
+
+	return dis(r_eng);
+}
+
+//-----------------------------Mutator-----------------------------
+
+vector<IRTYPE> Mutator::stmtIRType_ = {
+	IRTYPE::kCreateTableStmt,
+	IRTYPE::kCreateViewStmt,
+	IRTYPE::kCreateIndexStmt,
+	IRTYPE::kSelectStmt,
+	IRTYPE::kDropIndexStmt,
+	IRTYPE::kDropTableStmt,
+	IRTYPE::kDropViewStmt,
+	IRTYPE::kDeleteStmt,
+	IRTYPE::kUpdateStmt,
+	IRTYPE::kInsertStmt,
+	IRTYPE::kAlterTableStmt
+};
+vector<IRTYPE> Mutator::clauseIRType_ = {
+	IRTYPE::kAlterListItem,
+	IRTYPE::kValues,
+	IRTYPE::kUpdateElem,
+	IRTYPE::kDefaultAttribute,
+	IRTYPE::kCheckConstraint,
+	IRTYPE::kKeyPartWithExpression,
+	IRTYPE::kOptWindowClause,
+	IRTYPE::kOptHavingClause,
+	IRTYPE::kWhereClause,
+	IRTYPE::kFromClause,
+	IRTYPE::kSelectItem
+};
+
+Mutator::Mutator() {
+	random_device rd;
+	srand(rd());
+
+	startTime = chrono::steady_clock::now();
+
+	not_mutatable_types_.insert({ IRTYPE::kParseToplevel, IRTYPE::kStmtmulti, IRTYPE::kStmt });
+
+	return;
+}
+Mutator::~Mutator() {
+	free_IR_library();
+	free_IR_config_info();
+
+	return;
+}
+
+bool Mutator::init_IR_library(string dirPath) {
+	vector<string> IRFileNames = get_all_files_in_dir(dirPath.c_str());
+	if (IRFileNames.empty()) {
+		fprintf(stderr, "ERROR: No IR library File in dirPath!!!\n");
+		return false;
+	}		
+
+	for (string fileName : IRFileNames) {
+		ifstream inputFile(fileName);
+		string sql;
+
+		while (getline(inputFile, sql)) {
+			if (sql.empty())
+				continue;
+
+			IR* p = IR_parser(sql.c_str());
+			if (p == nullptr)
+				continue;
+
+			add_ir_to_library(p);
+			deep_delete(p);
+		}
+	}
+
+	return true;
+}
+
+void Mutator::free_IR_library() {
+	for (IR* p : IR_library_[IRTYPE::kParseToplevel]) {
+		if (p)
+			deep_delete(p);
+	}
+
+	return;
+}
+
+bool Mutator::init_IR_config_info(string filePath) {
+	char flag = 0;
+	IRTYPE type = IRTYPE::kNone;
+	int count = 0;
+
+	FILE* fd = fopen(filePath.c_str(), "r");
+	if (!fd){
+		fprintf(stderr, "IR_config file is not exists!!\n");
+		return false;
+	}
+
+	while (!feof(fd)) {
+		if (!flag) {
+			int tmpType = 0;
+			fscanf(fd, "%d %d\n", &tmpType, &count);
+
+			type = static_cast<IRTYPE>(tmpType);
+
+			if (IRInfo_.find(static_cast<IRTYPE>(type)) != IRInfo_.end()) {
+				fprintf(stderr, "ERROR: IR_config file has duplication type: %d!!\n", type);
+				return false;
+			}
+
+			IRInfo_[type] = new IRInfoManger();
+			IRInfo_[type]->curIRType_ = type;
+
+			OpInfo_[type] = new OperatorManger();
+			OpInfo_[type]->curIRType_ = type;
+
+			IRTypeCount_[type] = { 0, 0 };
+
+			flag = 1;
+		}
+		else {
+			int prefix = 0;
+			int left = 0;
+			int middle = 0;
+			int right = 0;
+			int suffix = 0;
+
+			for (int i = 0; i < count; i++) {
+				fscanf(fd, "%d %d %d %d %d\n", &prefix, &left, &middle, &right, &suffix);
+
+				IRInfomation* tmp = new IRInfomation(prefix, left, middle, right, suffix);
+				IRInfo_[type]->add_IRInfomation(tmp);
+			}
+
+			flag = 0;
+			type = IRTYPE::kNone;
+			count = 0;
+		}
+	}
+
+	fclose(fd);
+
+	return true;
+}
+
+void Mutator::free_IR_config_info() {
+	for (auto& it : IRInfo_) {
+		delete it.second;
+	}
+
+	for (auto& it : OpInfo_) {
+		delete it.second;
+	}
+
+	return;
+}
+
+uint64_t Mutator::hash(string& sql) {
+	const void* key = static_cast<const void*>(sql.c_str());
+	int len = sql.size();
+
+	const uint64_t m = 0xc6a4a7935bd1e995;
+	const int r = 47;
+	uint64_t h = 0xdeadbeefdeadbeef ^ (len * m);
+
+	const uint64_t* data = static_cast<const uint64_t*>(key);
+	const uint64_t* end = data + (len / 8);
+
+	while (data != end)
+	{
+		uint64_t k = *data++;
+
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+
+		h ^= k;
+		h *= m;
+	}
+
+	const unsigned char* data2 = (const unsigned char*)data;
+
+	switch (len & 7)
+	{
+	case 7: h ^= uint64_t(data2[6]) << 48;
+	case 6: h ^= uint64_t(data2[5]) << 40;
+	case 5: h ^= uint64_t(data2[4]) << 32;
+	case 4: h ^= uint64_t(data2[3]) << 24;
+	case 3: h ^= uint64_t(data2[2]) << 16;
+	case 2: h ^= uint64_t(data2[1]) << 8;
+	case 1: h ^= uint64_t(data2[0]);
+		h *= m;
+	};
+
+	h ^= h >> r;
+	h *= m;
+	h ^= h >> r;
+
+	return h;
+}
+
+vector<string> Mutator::get_all_files_in_dir(const char* dirPath) {
+	vector<string> res;
+
+	fs::path dir = dirPath;
+	if (!fs::exists(dir)) {
+		return res;
+	}
+
+	for (const fs::directory_entry& entry : fs::directory_iterator(dir)) {
+		if (entry.is_regular_file()) {
+			res.push_back(entry.path().string());
+		}
+	}
+
+	return res;
+}
+
+ParseToplevel* Mutator::parser(const char* sql) {
+
+	yyscan_t scanner;
+	YY_BUFFER_STATE state;
+	ParseToplevel* p = new ParseToplevel();
+
+	if (ff_lex_init(&scanner)) {
+		return NULL;
+	}
+
+	state = ff__scan_string(sql, scanner);
+
+	int ret = ff_parse(p, scanner);
+
+	ff__delete_buffer(state, scanner);
+	ff_lex_destroy(scanner);
+
+	if (ret != 0) {
+		p->deep_delete();
+		return NULL;
+	}
+
+	return p;
+}
+
+IR* Mutator::IR_parser(const char* sql) {
+	ParseToplevel* p = parser(sql);
+	if (p == nullptr)
+		return nullptr;
+
+	IR* res = p->translate();
+	p->deep_delete();
+
+	return res;
+}
+
+bool Mutator::add_ir_to_library(IR* root) {
+	extract_struct(root);
+	IR* newRoot = deep_copy(root);
+
+	if (!add_ir_to_library_no_deepcopy(newRoot)) {
+		deep_delete(newRoot);
+		return false;
+	}
+
+	return true;
+}
+
+bool Mutator::add_ir_to_library_no_deepcopy(IR* root) {
+	bool flag = false;
+
+	if (root->left_) flag |= add_ir_to_library_no_deepcopy(root->left_);
+
+	if (root->right_) flag |= add_ir_to_library_no_deepcopy(root->right_);
+
+	IRTYPE type = root->type_;
+
+	string tmpStr = root->to_string();
+	uint64_t h = hash(tmpStr);
+	if (find(IR_library_hash_[type].begin(), IR_library_hash_[type].end(), h) != IR_library_hash_[type].end()) {
+		if ((type == IRTYPE::kParseToplevel) && flag) {
+			IR_library_[type].push_back(root);
+		}
+
+		return false | flag;
+	}
+
+	IR_library_[type].push_back(root);
+	IR_library_hash_[type].insert(h);
+
+	return true;
+}
+
+void Mutator::extract_struct(IR* root) {
+	IRTYPE type = root->type_;
+
+	if (root->left_) extract_struct(root->left_);
+	if (root->right_) extract_struct(root->right_);
+
+	if (root->left_ || root->right_) return;
+
+	switch (root->type_) {
+		case IRTYPE::kIconst:
+			root->long_val_ = 1;
+			break;
+		case IRTYPE::kFconst:
+			root->float_val_ = 1.0;
+			break;
+		case IRTYPE::kSconst:
+			root->str_val_ = "'x'";
+			break;
+		case IRTYPE::kIdent:
+			root->str_val_ = "x";
+			break;
+	}
+
+	return;
+}
+
+void Mutator::update_status(InputInfo* input, unsigned int execStatus, bool isValid) {
+	unsigned int reward = get_cur_reward();
+	bool hasNewCoverage = (execStatus == 1 || execStatus == 2);
+
+	IRInfoManger* manger = IRInfo_[input->MutateIRType_];
+	manger->update_count(&input->MutateContext_, input->MutateIRInfoItem_, hasNewCoverage, reward);
+
+#ifdef ORIGINAL
+	OperatorManger* OpManger = OpInfo_[input->MutateIRType_];
+	OpManger->update_count(&input->MutateContext_, input->MutateOperatorItem_, hasNewCoverage, reward);
+#endif
+
+	if (hasNewCoverage == true){	
+		if (execStatus == 1) {
+			IRTypeCount_[input->MutateIRType_].first += reward;
+		}
+		else{
+			IRTypeCount_[input->MutateIRType_].first += reward * REWARDNEWCOVERAGE;
+		}
+
+		if (isValid == true) {
+			add_ir_to_library(input->input_);
+		}		
+	}
+	else {
+		IRTypeCount_[input->MutateIRType_].second += reward;
+	}
+
+	return;
+}
+
+vector<InputInfo*> Mutator::mutate_all(const char* sql) {
+	vector<InputInfo*> res;
+	deque<pair<IR*, IRContextS>> q;
+
+	vector<IRTYPE> IRTypeRank;
+	vector<double> probabilityRank;
+
+	map<IRTYPE, vector<pair<IR*, IRContextS>>> indexes;
+
+	IR* originRoot = IR_parser(sql);
+	if (originRoot == nullptr)
+		return res;
+
+	IRContextS tmp = { 0 };
+	q.push_back({originRoot, tmp});
+
+	while (!q.empty()) {
+		IR* curIR = q.front().first;
+		IRContextS curContext = q.front().second;
+		q.pop_front();
+
+		if (curIR == nullptr) {
+			continue;
+		}
+
+		IRContextS nextContext = { 0 };
+
+		if (find(stmtIRType_.begin(), stmtIRType_.end(), curIR->type_) != stmtIRType_.end()) {
+			nextContext.stmt_ = static_cast<unsigned short int>(curIR->type_);
+		}
+		else {
+			nextContext.stmt_ = curContext.stmt_;
+		}
+
+		if (find(clauseIRType_.begin(), clauseIRType_.end(), curIR->type_) != clauseIRType_.end()) {
+			nextContext.clause_ = static_cast<unsigned short int>(curIR->type_);
+		}
+		else {
+			nextContext.clause_ = curContext.clause_;
+		}
+
+		if (curIR->type_ == IRTYPE::kSubquery) {
+			nextContext.inSubquery_ = 1;
+		}
+		else {
+			nextContext.inSubquery_ = curContext.inSubquery_;
+		}
+
+		nextContext.parentIRType_ = curIR->type_;
+		nextContext.parentIRItem_ = IRInfo_[curIR->type_]->get_index_of_IRInfo(curIR);
+
+		q.push_back({curIR->left_, nextContext });
+		q.push_back({ curIR->right_ , nextContext });
+
+		if (not_mutatable_types_.find(curIR->type_) != not_mutatable_types_.end()) {
+			continue;
+		}			
+
+		unsigned int chosenNumber = IRTypeCount_[curIR->type_].first + IRTypeCount_[curIR->type_].second;
+		if (find(IRTypeRank.begin(), IRTypeRank.end(), curIR->type_) == IRTypeRank.end() && chosenNumber > IRTYPEUPDATETHRESHOLD) {
+			if (IRTypeRank.size() < TOPNUMBER) {
+				IRTypeRank.push_back(curIR->type_);
+			}
+			else {
+				IRTYPE tLeft = IRTypeRank[IRTypeRank.size() - 1];
+
+				double pLeft = static_cast<double>(IRTypeCount_[tLeft].first) / (IRTypeCount_[tLeft].first + IRTypeCount_[tLeft].second);
+				double pRight = static_cast<double>(IRTypeCount_[curIR->type_].first) / chosenNumber;
+
+				if (pLeft < pRight) {
+					IRTypeRank[IRTypeRank.size() - 1] = curIR->type_;
+				}
+			}
+		}
+
+		for (int i = IRTypeRank.size() - 1; i > 0; i--) {
+			IRTYPE tLeft = IRTypeRank[i - 1];
+			IRTYPE tRight = IRTypeRank[i];
+
+			double pLeft = static_cast<double>(IRTypeCount_[tLeft].first) / (IRTypeCount_[tLeft].first + IRTypeCount_[tLeft].second);
+			double pRight = static_cast<double>(IRTypeCount_[tRight].first) / (IRTypeCount_[tRight].first + IRTypeCount_[tRight].second);
+
+			if (pLeft > pRight) {
+				break;
+			}
+
+			IRTYPE tmp = IRTypeRank[i];
+			IRTypeRank[i] = IRTypeRank[i - 1];
+			IRTypeRank[i - 1] = tmp;
+		}
+
+		indexes[curIR->type_].push_back({ curIR, curContext });
+	}
+
+	double expectSum = 0;
+	for (IRTYPE t : IRTypeRank) {
+		expectSum += static_cast<double>(IRTypeCount_[t].first) / (IRTypeCount_[t].first + IRTypeCount_[t].second);
+	}
+
+	for (int i = 0; i < IRTypeRank.size(); i++) {
+		IRTYPE t = IRTypeRank[i];
+		double p = static_cast<double>(IRTypeCount_[t].first) / (IRTypeCount_[t].first + IRTypeCount_[t].second);
+
+		probabilityRank.push_back(p / expectSum);
+	}
+
+	double heat = get_cur_heat();
+	for (auto& it : indexes) {
+		IRTYPE curType = it.first;
+		unsigned int chosenNumber = IRTypeCount_[curType].first + IRTypeCount_[curType].second;
+
+		for (pair<IR*, IRContextS>& node : it.second) {
+			IR* curNode = nullptr;
+			IRContextS curContext = { 0 };
+
+			double randomNumber = get_random_double(0, 1);
+
+			if (chosenNumber < IRTYPEUPDATETHRESHOLD || randomNumber < heat) {
+				curNode = node.first;
+				curContext = node.second;
+			}
+			else {
+				double tmpRand = get_random_double(0, 1);
+				IRTYPE tmpType = IRTYPE::kNone;
+
+				for (int i = 0; i < probabilityRank.size(); i++) {
+					if (tmpRand >= probabilityRank[i]) {
+						tmpRand -= probabilityRank[i];
+						continue;
+					}
+
+					tmpType = IRTypeRank[i];
+					break;
+				}
+
+				if (tmpType == IRTYPE::kNone) {
+					curNode = node.first;
+					curContext = node.second;
+				}
+				else {
+					pair<IR*, IRContextS>& tmp = indexes[tmpType][rand() % indexes[tmpType].size()];
+					curNode = tmp.first;
+					curContext = tmp.second;
+				}
+			}
+
+#ifdef ORIGINAL
+			vector<InputInfo*> newInputInfos = original_mutate(curNode, curContext, heat);
+#else
+			vector<InputInfo*> newInputInfos = mutate(curNode, curContext, heat);
+#endif	
+
+			for (InputInfo* newInputInfo : newInputInfos) {
+				newInputInfo->input_ = get_new_tree(originRoot, curNode, newInputInfo->input_);
+
+				extract_struct(newInputInfo->input_);
+
+				string tmpStr = newInputInfo->input_->to_string();
+
+				uint64_t h = hash(tmpStr);
+				if (sql_hash_.find(h) != sql_hash_.end()) {
+					delete newInputInfo;
+					continue;
+				}
+				sql_hash_.insert(h);
+
+				IR* checkSql = check_sql(tmpStr);
+				if (checkSql == nullptr) {
+					delete newInputInfo;
+					continue;
+				}
+				else {
+					deep_delete(newInputInfo->input_);
+					newInputInfo->input_ = checkSql;
+				}
+
+				res.push_back(newInputInfo);
+			}
+		}		
+	}
+
+	deep_delete(originRoot);
+
+	mutateNumber_.push_back(res.size());
+	seedCount_++;
+
+	return res;
+}
+
+vector<InputInfo*> Mutator::mutate(IR* root, IRContextS context, double heat) {
+	vector<InputInfo*> res;
+
+	IRInfoManger* manger = IRInfo_[root->type_];
+	vector<unsigned short int> indexes = manger->get_IRInfo_index(&context, heat);
+
+	for (unsigned short int index : indexes) {
+		char flag = (rand() % 3) + 1;
+
+		IR* left = nullptr;
+		IR* right = nullptr;
+
+		IRInfomation* tmpIRInformation = manger->get_IRInfomation(index);
+
+		InputInfo* newInputInfo = new InputInfo();
+		newInputInfo->MutateIRType_ = root->type_;
+		newInputInfo->MutateIRInfoItem_ = index;
+		newInputInfo->MutateContext_ = context;
+
+		if ((flag & 1) || ((root->left_ ? root->left_->type_ : IRTYPE::kNone) != tmpIRInformation->left_)) {
+			IR* tmp = get_ir_from_library(tmpIRInformation->left_);
+			left = deep_copy(tmp);
+		}
+		else {
+			left = deep_copy(root->left_);
+		}
+
+		if ((flag & 2) || ((root->right_ ? root->right_->type_ : IRTYPE::kNone) != tmpIRInformation->right_)) {
+			IR* tmp = get_ir_from_library(tmpIRInformation->right_);
+			right = deep_copy(tmp);
+		}
+		else {
+			right = deep_copy(root->right_);
+		}
+
+		IR* newIRTree = new IR(root, left, right);
+
+		newIRTree->op_->prefix_ = tmpIRInformation->prefix_;
+		newIRTree->op_->middle_ = tmpIRInformation->middle_;
+		newIRTree->op_->suffix_ = tmpIRInformation->suffix_;
+
+		newInputInfo->input_ = newIRTree;
+
+		res.push_back(newInputInfo);
+	}
+
+	return res;
+}
+
+IR* Mutator::get_ir_from_library(IRTYPE type) {
+	if (type == IRTYPE::kNone)
+		return nullptr;
+
+	if (IR_library_[type].empty()) {
+		fprintf(stderr, "ERROR: Lack IRTYPE : %d!!!\n", static_cast<int>(type));
+		assert(0);
+	}
+
+	return IR_library_[type][rand() % (IR_library_[type].size())];
+}
+
+IR* Mutator::get_new_tree(IR* oldIRRoot, IR* curIR, IR* newIR) {
+	assert(oldIRRoot && curIR && newIR);
+
+	IR* res = nullptr;
+	IR* left = nullptr;
+	IR* right = nullptr;
+
+	if (oldIRRoot->left_ != nullptr) {
+		if (oldIRRoot->left_ == curIR)
+			left = newIR;
+		else
+			left = get_new_tree(oldIRRoot->left_, curIR, newIR);
+	}
+
+	if (oldIRRoot->right_ != nullptr) {
+		if (oldIRRoot->right_ == curIR)
+			right = newIR;
+		else
+			right = get_new_tree(oldIRRoot->right_, curIR, newIR);
+	}
+
+	res = new IR(oldIRRoot, left, right);
+
+	return res;
+}
+
+void Mutator::print_information(string outputPath) {
+	print_IRType_information(outputPath);
+	print_IRInfo_information(outputPath);
+	print_Mutate_number(outputPath);
+
+#ifdef ORIGINAL
+	print_OpInfo_information(outputPath);
+#endif
+
+	return;
+}
+void Mutator::print_IRType_information(string outputPath) {
+	ofstream outFileIRType(outputPath + "IRType_Information", ios::trunc);
+
+	if (outFileIRType) {
+		for (auto& it : IRTypeCount_) {
+			IRTYPE curType = it.first;
+			pair<unsigned int, unsigned int>& count = it.second;
+
+			outFileIRType << "Current IRTYPE: " << to_string(curType) << endl;
+			outFileIRType << "\tSuccesses: " << to_string(count.first) << ", Failed: " << to_string(count.second) << ", Total: " << to_string(count.first + count.second) << endl << endl;
+		}
+
+		outFileIRType.close();
+	}
+	else {
+		cout << "ERROR: Can't Write IRType_Information File!!!" << endl;
+	}
+
+	return;
+}
+void Mutator::print_IRInfo_information(string outputPath) {
+	ofstream outFileIRInfo(outputPath + "IRInfo_information", ios::trunc);
+
+	if (outFileIRInfo) {
+		for (auto& it : IRInfo_) {
+			string info = it.second->print_IRInformation_status();
+			outFileIRInfo << info << endl;
+		}
+	}
+	else {
+		cout << "ERROR: Can't Write IRInfo_information File!!!" << endl;
+	}
+
+	return;
+}
+void Mutator::print_Mutate_number(string outputPath) {
+	ofstream outFileMutate(outputPath + "Mutate_number", ios::trunc);
+
+	if (outFileMutate) {
+		for (unsigned short n : mutateNumber_) {
+			outFileMutate << n << endl;
+		}
+	}
+	else {
+		cout << "ERROR: Can't Write Mutate_number File!!!" << endl;
+	}
+
+	return;
+}
+void Mutator::print_OpInfo_information(string outputPath) {
+	ofstream outFileIRInfo(outputPath + "OpInfo_information", ios::trunc);
+
+	if (outFileIRInfo) {
+		pair<unsigned long int, unsigned long int> OpReplace = { 0, 0 };
+		pair<unsigned long int, unsigned long int> OpInsert = { 0, 0 };
+		pair<unsigned long int, unsigned long int> OpDelete = { 0, 0 };
+
+		for (auto& it : OpInfo_) {
+			vector<unsigned long int>& chosenCounts = it.second->OpInfoChosenCount_;
+			vector<unsigned long int>& failedCounts = it.second->OpInfoFailedCount_;
+
+			OpReplace.first += chosenCounts[0];
+			OpReplace.second += failedCounts[0];
+
+			OpInsert.first += chosenCounts[1];
+			OpInsert.second += failedCounts[1];
+
+			OpDelete.first += chosenCounts[2];
+			OpDelete.second += failedCounts[2];
+
+			string info = it.second->print_OperatorInformation_status();
+			outFileIRInfo << info << endl;
+		}
+
+		outFileIRInfo << "Replace Operator\n\tTotal Chosen Number: " << to_string(OpReplace.first) << ", Total Failed Number: " << to_string(OpReplace.second) << ", Accuracy Rate: " << to_string(1 - static_cast<double>(OpReplace.second) / OpReplace.first) << "%" << endl;
+		outFileIRInfo << "Insert Operator\n\tTotal Chosen Number: " << to_string(OpInsert.first) << ", Total Failed Number: " << to_string(OpInsert.second) << ", Accuracy Rate: " << to_string(1 - static_cast<double>(OpInsert.second) / OpInsert.first) << "%" << endl;
+		outFileIRInfo << "Delete Operator\n\tTotal Chosen Number: " << to_string(OpDelete.first) << ", Total Failed Number: " << to_string(OpDelete.second) << ", Accuracy Rate: " << to_string(1 - static_cast<double>(OpDelete.second) / OpDelete.first) << "%" << endl;
+	}
+	else {
+		cout << "ERROR: Can't Write OpInfo_information File!!!" << endl;
+	}
+
+	return;
+}
+
+unsigned int Mutator::get_duration_ms() {
+	chrono::time_point<chrono::steady_clock> curTime = chrono::steady_clock::now();
+
+	return chrono::duration_cast<chrono::milliseconds>(curTime - startTime).count();
+}
+double Mutator::get_cur_heat() {
+	unsigned int duration = get_duration_ms();
+
+	return static_cast<double>(1) / (static_cast<unsigned int>(duration / TIMETHRESHOLD) + 1);
+}
+unsigned int Mutator::get_cur_reward() {
+	unsigned int duration = get_duration_ms();
+
+	return 1 + (duration / TIMETHRESHOLD) * REWARDINCREMENT;
+}
+
+vector<InputInfo*> Mutator::original_mutate(IR* root, IRContextS context, double heat) {
+	vector<InputInfo*> res;
+
+	OperatorManger* OpManger = OpInfo_[root->type_];
+	vector<unsigned short int> indexes = OpManger->get_OpInfo_index(&context, heat);
+
+	for (unsigned short int index : indexes) {
+		MutateOperator op = OpManger->get_operator(index);
+		IR* tmp = nullptr;
+
+		switch (op) {
+			case MutateOperator::moReplace: {
+				tmp = strategy_replace(root);
+				break;
+			}
+			case MutateOperator::moInsert: {
+				tmp = strategy_insert(root);
+				break;
+			}
+			case MutateOperator::moDelete: {
+				tmp = strategy_delete(root);
+				break;
+			}
+		}
+
+		if (tmp != nullptr) {
+			IRInfoManger* manger = IRInfo_[tmp->type_];
+			manger->get_IRInfo_index(&context, get_cur_heat());
+
+			InputInfo* newInputInfo = new InputInfo();
+
+			newInputInfo->MutateIRType_ = root->type_;
+			newInputInfo->MutateIRInfoItem_ = manger->get_index_of_IRInfo(tmp);
+			newInputInfo->MutateContext_ = context;
+			newInputInfo->MutateOperatorItem_ = index;
+
+			if (newInputInfo->MutateIRInfoItem_ != ERRORINDEX) {
+				manger->IRInfoChosenCount_[newInputInfo->MutateIRInfoItem_]++;
+			}
+
+			newInputInfo->input_ = tmp;
+
+			res.push_back(newInputInfo);
+		}
+		else {
+			OpManger->OpInfoFailedCount_[index]++;
+			OpManger->update_count(&context, index, false, get_cur_reward());
+		}
+	}
+
+	return res;
+}
+
+IR* Mutator::strategy_delete(IR* root) {
+	IR* res = nullptr;
+	int flag = 0;
+
+	if (root->left_ != nullptr && root->right_ != nullptr) {
+		flag = (rand() % 3) + 1;
+	}
+	else if (root->left_ != nullptr) {
+		flag = 1;
+	}
+	else if (root->right_ != nullptr) {
+		flag = 2;
+	}
+	else {
+		return nullptr;
+	}
+
+	res = deep_copy(root);
+
+	if ((flag & 1) == 1) {
+		deep_delete(res->left_);
+		res->left_ = nullptr;
+	}
+
+	if ((flag & 2) == 2) {
+		deep_delete(res->right_);
+		res->right_ = nullptr;
+	}
+
+	return res;
+}
+IR* Mutator::strategy_insert(IR* root) {
+	IRTYPE curType = root->type_;
+
+	if (root->right_ == nullptr && root->left_ != nullptr) {
+		IRTYPE leftNodeType = root->left_->type_;
+
+		for (int i = 0; i < 4; i++) {
+			IR* tmp = get_ir_from_library(curType);
+
+			if (tmp != nullptr && tmp->left_ != nullptr && tmp->left_->type_ == leftNodeType && tmp->right_ != nullptr) {
+				IR* res = deep_copy(root);
+				res->right_ = deep_copy(tmp->right_);
+
+				res->op_->prefix_ = tmp->op_->prefix_;
+				res->op_->middle_ = tmp->op_->middle_;
+				res->op_->suffix_ = tmp->op_->suffix_;
+
+				return res;
+			}
+		}
+	}
+	else if (root->right_ != nullptr && root->left_ == nullptr) {
+		IRTYPE rightNodeType = root->right_->type_;
+
+		for (int i = 0; i < 4; i++) {
+			IR* tmp = get_ir_from_library(curType);
+
+			if (tmp != nullptr && tmp->right_ != nullptr && tmp->right_->type_ == rightNodeType && tmp->left_ != nullptr) {
+				IR* res = deep_copy(root);
+				res->left_ = deep_copy(tmp->left_);
+
+				res->op_->prefix_ = tmp->op_->prefix_;
+				res->op_->middle_ = tmp->op_->middle_;
+				res->op_->suffix_ = tmp->op_->suffix_;
+
+				return res;
+			}
+		}
+	}
+	else if (root->right_ == nullptr && root->left_ == nullptr) {
+		for (int i = 0; i < 4; i++) {
+			IR* tmp = get_ir_from_library(curType);
+
+			if (tmp != nullptr && (tmp->left_ != nullptr || tmp->right_ != nullptr)) {
+				IR* res = deep_copy(root);
+				res->left_ = deep_copy(tmp->left_);
+				res->right_ = deep_copy(tmp->right_);
+
+				res->op_->prefix_ = tmp->op_->prefix_;
+				res->op_->middle_ = tmp->op_->middle_;
+				res->op_->suffix_ = tmp->op_->suffix_;
+
+				return res;
+			}
+		}
+	}
+
+	return nullptr;
+}
+IR* Mutator::strategy_replace(IR* root) {
+	IR* res = nullptr;
+	int flag = 0;
+
+	if (root->left_ != nullptr && root->right_ != nullptr) {
+		flag = (rand() % 3) + 1;
+	}
+	else if (root->left_ != nullptr) {
+		flag = 1;
+	}
+	else if (root->right_ != nullptr) {
+		flag = 2;
+	}
+	else {
+		return nullptr;
+	}
+
+	res = deep_copy(root);
+
+	if ((flag & 1) == 1) {
+		IR* tmpLeft = get_ir_from_library(res->left_->type_);
+
+		if (tmpLeft != nullptr) {
+			deep_delete(res->left_);
+			res->left_ = deep_copy(tmpLeft);
+		}
+	}
+
+	if ((flag & 2) == 2) {
+		IR* tmpRight = get_ir_from_library(res->right_->type_);
+
+		if (tmpRight != nullptr) {
+			deep_delete(res->right_);
+			res->right_ = deep_copy(tmpRight);
+		}
+	}
+
+	return res;
+}
+
+IR* Mutator::check_sql(string& sql) {
+	IR* res = IR_parser(sql.c_str());
+
+	totalMutate_++;
+	if (res == nullptr) {
+		failedMutate_++;
+	}
+	
+	return res;
+}
+
+//-----------------------------IRInfomation-----------------------------
+IRInfomation::IRInfomation(int prefix, int left, int middle, int right, int suffix) {
+	prefix_ = static_cast<TERMINAL>(prefix);
+	left_ = static_cast<IRTYPE>(left);
+	middle_ = static_cast<TERMINAL>(middle);
+	right_ = static_cast<IRTYPE>(right);
+	suffix_ = static_cast<TERMINAL>(suffix);
+
+	return;
+}
+IRInfomation::IRInfomation(IR* root) {
+	prefix_ = root->op_->prefix_;
+	left_ = root->left_ != nullptr ? root->left_->type_ : IRTYPE::kNone;
+	middle_ = root->op_->middle_;
+	right_ = root->right_ != nullptr ? root->right_->type_ : IRTYPE::kNone;
+	suffix_ = root->op_->suffix_;
+
+	return;
+}
+
+bool IRInfomation::operator!=(IRInfomation* info) {
+	if (info->prefix_ != prefix_) {
+		return true;
+	}
+
+	if (info->left_ != left_) {
+		return true;
+	}
+
+	if (info->middle_ != middle_) {
+		return true;
+	}
+
+	if (info->right_ != right_) {
+		return true;
+	}
+
+	if (info->suffix_ != suffix_) {
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------IRInfoManger-----------------------------
+IRInfoManger::IRInfoManger() {}
+IRInfoManger::~IRInfoManger() {
+	for (IRInfomation* info : IRInfomation_) {
+		delete info;
+	}
+
+	return;
+}
+
+void IRInfoManger::create_new_context(IRContextS* context) {
+	uint64_t index = *reinterpret_cast<uint64_t*>(context);
+
+	assert(contextDependentCount_.find(index) == contextDependentCount_.end());
+
+	for (int i = 0; i < IRInfomation_.size(); i++) {
+		contextDependentCount_[index].push_back({0, 0});
+	}
+
+	return;
+}
+
+void IRInfoManger::update_count(IRContextS* context, unsigned short int item, bool hasNewCoverage, unsigned int reward) {
+	uint64_t index = *reinterpret_cast<uint64_t*>(context);
+
+	assert(contextDependentCount_.find(index) != contextDependentCount_.end());
+
+	if (item == ERRORINDEX) {
+		return;
+	}
+
+	if (hasNewCoverage == true) {
+		contextDependentCount_[index][item].first += reward;
+	}
+	else {
+		contextDependentCount_[index][item].second += reward;
+	}
+
+	return;
+}
+
+void IRInfoManger::add_IRInfomation(IRInfomation* info) {
+	IRInfomation_.push_back(info);
+	IRInfoChosenCount_.push_back(0);
+	return;
+}
+IRInfomation* IRInfoManger::get_IRInfomation(unsigned short int index) {
+	assert(index < IRInfomation_.size() && index >= 0);
+	IRInfoChosenCount_[index]++;
+	return IRInfomation_[index];
+}
+
+#ifdef BALANCE
+vector<unsigned short int> IRInfoManger::get_IRInfo_index(IRContextS* context, double heat) {
+	vector<unsigned short int> res;
+	uint64_t index = *reinterpret_cast<uint64_t*>(context);
+
+	if (contextDependentCount_.find(index) == contextDependentCount_.end()) {
+		create_new_context(context);
+	}
+
+	for (int i = 0; i < MUTATENUMBER; i++) {
+		double randomNumber = get_random_double(0, 1);
+		if (randomNumber < heat) {
+			res.push_back(rand() % IRInfomation_.size());
+		}
+		else {
+			int maxIndex = ERRORINDEX;
+			double maxExpect = 0.0;
+			vector<pair<unsigned int, unsigned int>>& counts = contextDependentCount_[index];
+
+			for (int i = 0; i < counts.size(); i++) {
+				unsigned int totalNumber = counts[i].first + counts[i].second;
+				if (totalNumber <= IRINFOUPDATETHRESHOLD) {
+					continue;
+				}
+
+				double expect = counts[i].first / totalNumber;
+				if (expect > maxExpect) {
+					maxIndex = i;
+					maxExpect = expect;
+				}
+			}
+
+			if (maxIndex != ERRORINDEX) {
+				res.push_back(maxIndex);
+			}
+			else {
+				res.push_back(rand() % IRInfomation_.size());
+			}
+	}
+	}
+
+	return res;
+}
+#else
+vector<unsigned short int> IRInfoManger::get_IRInfo_index(IRContextS* context, double heat) {
+	vector<unsigned short int> res;
+	vector<unsigned short int> skip;
+	uint64_t index = *reinterpret_cast<uint64_t*>(context);
+
+	if (contextDependentCount_.find(index) == contextDependentCount_.end()) {
+		create_new_context(context);
+	}
+
+	unsigned short int maxExpectIndex = ERRORINDEX;
+	double maxExpect = 0;
+
+	vector<pair<unsigned int, unsigned int>>& curContextCount = contextDependentCount_[index];
+	int mutateNumber = curContextCount.size();
+
+	for (int i = 0; i < curContextCount.size(); i++) {
+		pair<unsigned int, unsigned int>& count = curContextCount[i];
+
+		unsigned int chosenNumber = count.first + count.second;
+		if (chosenNumber > IRINFOUPDATETHRESHOLD) {
+			double expect = static_cast<double>(count.first) / chosenNumber;
+
+			if (expect > maxExpect) {
+				maxExpectIndex = i;
+				maxExpect = expect;
+			}
+		}
+
+		double tmp = get_random_double(0, 1);
+		if (chosenNumber <= IRINFOUPDATETHRESHOLD || tmp < heat) {
+			res.push_back(i);
+			mutateNumber--;
+		}
+		else {
+			skip.push_back(i);
+		}
+	}
+
+	if (maxExpectIndex == ERRORINDEX) {
+		for (unsigned short int i : skip) {
+			res.push_back(i);
+		}
+	}
+	else {
+		while (mutateNumber > 0) {
+			res.push_back(maxExpectIndex);
+			mutateNumber--;
+		}
+	}
+
+	return res;
+}
+#endif
+
+unsigned short int IRInfoManger::get_index_of_IRInfo(IR* root) {
+	int res = ERRORINDEX;
+	IRInfomation curIRInfo(root);
+
+	for (int i = 0; i < IRInfomation_.size(); i++) {
+		if (*IRInfomation_[i] != &curIRInfo) {
+			continue;
+		}
+
+		res = i;
+		break;
+	}
+
+	return res;
+}
+
+string IRInfoManger::print_IRInformation_status() {
+	unsigned long totalSuccessCount = 0;
+	unsigned long totalFailedCount = 0;
+
+	string res = "Current IRTYPE: " + to_string(curIRType_) + "\n";
+
+	for (int i = 0; i < IRInfomation_.size(); i++) {
+		unsigned long successCount = 0;
+		unsigned long failedCount = 0;
+		IRInfomation* tmp = IRInfomation_[i];
+
+		res += "--IRInfo " + to_string(i) + ": " + to_string(tmp->prefix_) + " " + to_string(tmp->left_) + " " + to_string(tmp->middle_) + " " + to_string(tmp->right_) + " " + to_string(tmp->suffix_) + ":\n";
+		res += "--Total Chosen Number: " + to_string(IRInfoChosenCount_[i]) + "\n";
+
+		for (auto& it : contextDependentCount_) {
+			uint64_t context = it.first;
+			pair<unsigned int, unsigned int>& count = it.second[i];
+
+			successCount += count.first;
+			totalSuccessCount += count.first;
+			failedCount += count.second;
+			totalFailedCount += count.second;
+
+			res += "\tCurrent Context: " + to_string(context) + ", Successes: " + to_string(count.first) + ", Failed: " + to_string(count.second) + ", Total: " + to_string(count.first + count.second) + "\n";
+		}
+
+		res += "--Successes: " + to_string(successCount) + ", Failed: " + to_string(failedCount) + ", Total: " + to_string(successCount + failedCount) + "\n";
+	}
+
+	res += "Total Successes: " + to_string(totalSuccessCount) + ", Total Failed: " + to_string(totalFailedCount) + ", Total: " + to_string(totalSuccessCount + totalFailedCount) + "\n\n";
+
+	return res;
+}
+
+//-----------------------------InputInfo-----------------------------
+InputInfo::InputInfo() {}
+InputInfo::~InputInfo() {
+	deep_delete(input_);
+	return;
+}
+
+//-----------------------------OperatorManger-----------------------------
+OperatorManger::OperatorManger() {
+	OperatorInfomation_ = { MutateOperator::moReplace, MutateOperator::moInsert, MutateOperator::moDelete };
+	OpInfoChosenCount_ = { 0, 0, 0 };
+	OpInfoFailedCount_ = { 0, 0, 0 };
+
+	return;
+}
+OperatorManger::~OperatorManger() {}
+
+void OperatorManger::create_new_context(IRContextS* context) {
+	uint64_t index = *reinterpret_cast<uint64_t*>(context);
+
+	assert(contextDependentCount_.find(index) == contextDependentCount_.end());
+
+	for (int i = 0; i < OperatorInfomation_.size(); i++) {
+		contextDependentCount_[index].push_back({ 0, 0 });
+	}
+
+	return;
+}
+vector<unsigned short int> OperatorManger::get_OpInfo_index(IRContextS* context, double heat) {
+	vector<unsigned short int> res;
+	vector<unsigned short int> skip;
+
+	IRContextS OpContext = *context;
+	OpContext.parentIRItem_ = ERRORINDEX;
+
+	uint64_t index = *reinterpret_cast<uint64_t*>(&OpContext);
+
+	if (contextDependentCount_.find(index) == contextDependentCount_.end()) {
+		create_new_context(&OpContext);
+	}
+
+	unsigned short int maxExpectIndex = ERRORINDEX;
+	double maxExpect = 0;
+
+	vector<pair<unsigned int, unsigned int>>& curContextCount = contextDependentCount_[index];
+	int mutateNumber = curContextCount.size();
+
+	for (int i = 0; i < curContextCount.size(); i++) {
+		pair<unsigned int, unsigned int>& count = curContextCount[i];
+
+		unsigned int chosenNumber = count.first + count.second;
+		if (chosenNumber > IRINFOUPDATETHRESHOLD) {
+			double expect = static_cast<double>(count.first) / (count.first + count.second);
+
+			if (expect > maxExpect) {
+				maxExpectIndex = i;
+				maxExpect = expect;
+			}
+		}
+
+		double tmp = get_random_double(0, 1);
+		if (chosenNumber < IRINFOUPDATETHRESHOLD || tmp < heat) {
+			res.push_back(i);
+			mutateNumber--;
+		}
+		else {
+			skip.push_back(i);
+		}
+	}
+
+	if (maxExpectIndex == ERRORINDEX) {
+		for (unsigned short int i : skip) {
+			res.push_back(i);
+		}
+	}
+	else {
+		while (mutateNumber > 0) {
+			res.push_back(maxExpectIndex);
+			mutateNumber--;
+		}
+	}
+
+	return res;
+}
+MutateOperator OperatorManger::get_operator(unsigned short int index) {
+	assert(index < OperatorInfomation_.size() && index >= 0);
+	OpInfoChosenCount_[index]++;
+	return OperatorInfomation_[index];
+}
+
+void OperatorManger::update_count(IRContextS* context, unsigned short int item, bool hasNewCoverage, unsigned int reward) {
+	IRContextS OpContext = *context;
+	OpContext.parentIRItem_ = ERRORINDEX;
+
+	uint64_t index = *reinterpret_cast<uint64_t*>(&OpContext);
+
+	assert(contextDependentCount_.find(index) != contextDependentCount_.end());
+
+	if (item == ERRORINDEX) {
+		return;
+	}
+
+	if (hasNewCoverage == true) {
+		contextDependentCount_[index][item].first += reward;
+	}
+	else {
+		contextDependentCount_[index][item].second += reward;
+	}
+
+	return;
+}
+
+string OperatorManger::print_OperatorInformation_status() {
+	unsigned long totalSuccessCount = 0;
+	unsigned long totalFailedCount = 0;
+
+	string res = "Current IRTYPE: " + to_string(curIRType_) + "\n";
+
+	for (int i = 0; i < OperatorInfomation_.size(); i++) {
+		unsigned long successCount = 0;
+		unsigned long failedCount = 0;
+		MutateOperator op = OperatorInfomation_[i];
+
+		string OpStr = "";
+		switch (op) {
+			case MutateOperator::moReplace: {
+				OpStr += "REPLACE";
+				break;
+			}
+			case MutateOperator::moInsert: {
+				OpStr += "INSERT";
+				break;
+			}
+			case MutateOperator::moDelete: {
+				OpStr += "DELETE";
+				break;
+			}
+		}
+
+		res += "--Operator " + OpStr + ":\n";
+		res += "--Total Chosen Number: " + to_string(OpInfoChosenCount_[i]) + ", " + "Mutate Failed: " + to_string(OpInfoFailedCount_[i]) + "\n";
+
+		for (auto& it : contextDependentCount_) {
+			uint64_t context = it.first;
+			pair<unsigned int, unsigned int>& count = it.second[i];
+
+			successCount += count.first;
+			totalSuccessCount += count.first;
+			failedCount += count.second;
+			totalFailedCount += count.second;
+
+			res += "\tCurrent Context: " + to_string(context) + ", Successes: " + to_string(count.first) + ", Failed: " + to_string(count.second) + ", Total: " + to_string(count.first + count.second) + "\n";
+		}
+
+		res += "--Successes: " + to_string(successCount) + ", Failed: " + to_string(failedCount) + ", Total: " + to_string(successCount + failedCount) + "\n";
+	}
+
+	res += "Total Successes: " + to_string(totalSuccessCount) + ", Total Failed: " + to_string(totalFailedCount) + ", Total: " + to_string(totalSuccessCount + totalFailedCount) + "\n\n";
+
+	return res;
+}
diff --git a/src/tool.cpp b/src/tool.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..67baf7f49d03a1c8a782973b8e3d0cfae27ebe7f
--- /dev/null
+++ b/src/tool.cpp
@@ -0,0 +1,1122 @@
+#include "../include/instantiate.h"
+
+using namespace std;
+
+//-----------------------------Column-----------------------------
+Column::Column(name_t name, ColumnType type): identifierName_(name), columnType_(type) {}
+Column::Column(Column* column) {
+	notNull_ = column->notNull_;
+	hasDefault_ = column->hasDefault_;
+	isVisible_ = column->isVisible_;
+	identifierName_ = column->identifierName_;
+	duplicated_ = column->duplicated_;
+	columnType_ = column->columnType_;
+
+	return;
+}
+
+void Column::instantiate() {
+	return;
+}
+
+//-----------------------------Index-----------------------------
+Index::Index(name_t name): identifierName_(name) {}
+
+//-----------------------------Constraint-----------------------------
+Constraint::Constraint(name_t name, ConstraintType type): identifierName_(name), constraintType_(type) {}
+
+//-----------------------------Table-----------------------------
+Table::Table(name_t name, IdentifierType identifierType, SelectStmtInfo* inSelectStmtInfo) : identifierName_(name), inSelectStmtInfo_(inSelectStmtInfo), identifierType_(identifierType) {
+	for (int i = 0; i < RESERVEDCOLUMNNAME; i++) {
+		acceColumnNames_.push_back(i);
+	}
+
+	random_device rd;
+	mt19937 g(rd());
+
+	shuffle(acceColumnNames_.begin(), acceColumnNames_.end(), g);
+
+	return;
+}
+Table::Table(Table* otherTable, SelectStmtInfo* inSelectStmtInfo) : identifierName_(otherTable->identifierName_), inSelectStmtInfo_(inSelectStmtInfo), identifierType_(otherTable->identifierType_) {
+	acceColumnNames_ = otherTable->acceColumnNames_;
+
+	for (Column* c : otherTable->columns_) {
+		add_column(new Column(c));
+	}
+
+	return;
+}
+Table::~Table() {
+	for (Column* c : columns_) {
+		delete c;
+	}
+
+	for (Index* i : indexes_) {
+		delete i;
+	}
+
+	for (Constraint* c : constraints_) {
+		delete c;
+	}
+
+	return;
+}
+
+bool Table::check_drop_table() {
+	if (!refFromOtherColumns_.empty()) {
+		return false;
+	}
+
+	return false;
+}
+bool Table::exist_duplicated_column() {
+	for (Column* c : columns_) {
+		if (c->duplicated_ == ColumnStatus::csDuplication) {
+			return true;
+		}
+	}
+
+	return false;
+}
+void Table::update_duplicationInfo(vector<int>& duplicationInfo) {
+	assert(duplicationInfo.size() == COLUMNNAMEMAX);
+	int size = columns_.size();
+
+	for (int i = 0; i < size; i++) {
+		duplicationInfo[columns_[i]->identifierName_]++;
+	}
+
+	return;
+}
+void Table::update_duplicatedColumns(vector<int>& duplicationInfo) {
+	assert(duplicationInfo.size() == COLUMNNAMEMAX);
+
+	for (Column* c : columns_) {
+		assert(c->identifierName_ < COLUMNNAMEMAX);
+		if (duplicationInfo[c->identifierName_] > 1) {
+			c->duplicated_ = ColumnStatus::csDuplication;
+		}
+		else if (duplicationInfo[c->identifierName_] == 1) {
+			c->duplicated_ = ColumnStatus::csNormal;
+		}
+	}
+
+	return;
+}
+
+bool Table::column_drop_check(Column* column) {
+	vector<Index*> indexes = get_index(column);
+	vector<Constraint*> constraints = get_constraint(column);
+
+	if (find(columns_.begin(), columns_.end(), column) == columns_.end()) {
+		return false;
+	}
+
+	for (Index* index : indexes) {
+		if (index->columns_[column] == IndexType::itFunctional) {
+			return false;
+		}
+	}
+
+	for (Constraint* constraint : constraints) {
+		if (constraint->columns_[column] == IndexType::itFunctional || constraint->constraintType_ == ConstraintType::ctForeignKey || constraint->constraintType_ == ConstraintType::ctCheck) {
+			return false;
+		}
+	}
+
+	return true;
+}
+Column* Table::get_column() {
+	if (columns_.empty()) {
+		fprintf(stderr, "ERROR: Empty Table!!!\n");
+		assert(0);
+	}
+
+	return columns_[rand() % columns_.size()];
+}
+Column* Table::get_column(ColumnType type) {
+	vector<Column*> tmp;
+
+	for (Column* c : columns_) {
+		if (c->columnType_ == type) {
+			tmp.push_back(c);
+		}
+	}
+
+	if (tmp.empty()) {
+		return nullptr;
+	}
+
+	return tmp[rand() % tmp.size()];
+}
+name_t Table::get_acce_column_name() {
+	if (acceColumnNames_.empty()) {
+		return 0;
+	}
+
+	return acceColumnNames_[0];
+}
+vector<Column*> Table::get_column_seq() {
+	int size = columns_.size();
+	vector<Column*> tmp;
+
+	for (int i = 0; i < size; i++) {
+		tmp.push_back(columns_[i]);
+	}
+
+	random_device rd;
+	mt19937 g(rd());
+
+	shuffle(tmp.begin(), tmp.end(), g);
+
+	return tmp;
+}
+void Table::add_column_first(Column* column) {
+	assert(column != nullptr);
+	remove_column_name(column->identifierName_);
+	column->parentTable_ = this;
+
+	columns_.insert(columns_.begin(), column);
+
+	return;
+}
+bool Table::add_column(Column* column, Column* afterColumn) {
+	assert(column != nullptr);
+	remove_column_name(column->identifierName_);
+	column->parentTable_ = this;
+
+	return move_column(column, afterColumn);
+}
+void Table::move_column_first(Column* column) {
+	auto it = find(columns_.begin(), columns_.end(), column);
+	assert(it != columns_.end());
+
+	columns_.erase(it);
+	columns_.insert(columns_.begin(), column);
+
+	return;
+}
+bool Table::move_column(Column* column, Column* afterColumn) {
+	assert(column != afterColumn);
+
+	auto it1 = find(columns_.begin(), columns_.end(), column);
+	auto it2 = find(columns_.begin(), columns_.end(), afterColumn);
+
+	assert(afterColumn == nullptr || it2 != columns_.end());
+
+	if (it1 != columns_.end()) {
+		columns_.erase(it1);
+	}
+
+	if (afterColumn == nullptr) {
+		columns_.push_back(column);
+	}
+	else {
+		auto it2 = find(columns_.begin(), columns_.end(), afterColumn);
+		columns_.insert(it2 + 1, column);
+	}
+
+	return true;
+}
+bool Table::drop_column(Column* column) {
+	if (!column_drop_check(column)) {
+		return false;
+	}
+
+	auto it = find(columns_.begin(), columns_.end(), column);
+
+	add_column_name(column->identifierName_);
+	
+	drop_index(column);
+	drop_constraint(column);
+
+	delete column;
+	columns_.erase(it);
+
+	return true;
+}
+
+void Table::column_rename(Column* column, name_t oldName, name_t newName) {
+	column->identifierName_ = newName;
+
+	remove_column_name(newName);
+	add_column_name(oldName);
+
+	return;
+}
+
+Index* Table::get_index() {
+	if (indexes_.empty()) {
+		return nullptr;
+	}
+
+	return indexes_[rand() % indexes_.size()];
+}
+vector<Index*> Table::get_index(Column* column) {
+	vector<Index*> tmp;
+
+	for (Index* index : indexes_) {
+		if (index->columns_.find(column) != index->columns_.end()) {
+			tmp.push_back(index);
+		}
+	}
+
+	return tmp;
+}
+bool Table::add_index(Index* index) {
+	if (find(indexes_.begin(), indexes_.end(), index) != indexes_.end()) {
+		return false;
+	}
+
+	indexes_.push_back(index);
+	return true;
+}
+bool Table::drop_index(Index* index) {
+	if (!index_drop_check(index)) {
+		return false;
+	}
+
+	auto it = find(indexes_.begin(), indexes_.end(), index);
+
+	if (index->constraint_ != nullptr) {
+		assert(index->constraint_->index_ == index);
+		index->constraint_->index_ = nullptr;
+		drop_constraint(index->constraint_);
+	}
+
+	indexes_.erase(it);
+	delete index;	
+
+	return true;
+}
+
+Constraint* Table::get_constraint() {
+	if (constraints_.empty()) {
+		return nullptr;
+	}
+
+	return constraints_[rand() % constraints_.size()];
+}
+vector<Constraint*> Table::get_constraint(Column* column) {
+	vector<Constraint*> tmp;
+
+	for (Constraint* constraint : constraints_) {
+		if (constraint->columns_.find(column) != constraint->columns_.end()) {
+			tmp.push_back(constraint);
+		}
+	}
+
+	return tmp;
+}
+bool Table::add_constraint(Constraint* constraint, Index* index) {
+	if (find(constraints_.begin(), constraints_.end(), constraint) != constraints_.end()) {
+		return false;
+	}
+
+	constraint->index_ = index;
+	constraints_.push_back(constraint);
+
+	if (index != nullptr) {
+		index->constraint_ = constraint;
+		add_index(index);
+	}
+
+	if (constraint->constraintType_ == ConstraintType::ctForeignKey) {
+		for (auto& it : constraint->refToOtherColumns_) {
+			Column* otherTableColumn = it.first;
+			for (Column* curTableColumn : it.second) {
+				curTableColumn->parentTable_->set_references(curTableColumn, otherTableColumn);
+			}
+		}
+	}
+
+	if (constraint->constraintType_ == ConstraintType::ctPrimaryKey) {
+		hasPrimaryKey_ = true;
+	}
+
+	return true;
+}
+bool Table::drop_constraint(Constraint* constraint) {
+	if (!constraint_drop_check(constraint)) {
+		return false;
+	}
+
+	auto it = find(constraints_.begin(), constraints_.end(), constraint);
+
+	if (constraint->index_ != nullptr) {
+		assert(constraint->index_->constraint_ == constraint);
+		constraint->index_->constraint_ = nullptr;
+		drop_index(constraint->index_);
+	}
+
+	if (constraint->constraintType_ == ConstraintType::ctForeignKey) {
+		for (auto& it : constraint->refToOtherColumns_) {
+			Column* otherTableColumn = it.first;
+			for (Column* curTableColumn : it.second) {
+				curTableColumn->parentTable_->remove_references(curTableColumn, otherTableColumn);
+			}
+		}
+	}
+
+	if (constraint->constraintType_ == ConstraintType::ctPrimaryKey) {
+		hasPrimaryKey_ = false;
+	}
+
+	delete constraint;
+	constraints_.erase(it);
+
+	return true;
+}
+bool Table::set_references(Column* curTableColumn, Column* otherTableColumn) {
+	if (find(columns_.begin(), columns_.end(), curTableColumn) == columns_.end()) {
+		return false;
+	}
+
+	if (refFromOtherColumns_.find(curTableColumn) != refFromOtherColumns_.end() && refFromOtherColumns_[curTableColumn].find(otherTableColumn) != refFromOtherColumns_[curTableColumn].end()) {
+		refFromOtherColumns_[curTableColumn][otherTableColumn] += 1;
+	}
+	else {
+		refFromOtherColumns_[curTableColumn][otherTableColumn] = 1;
+	}
+
+	return true;
+}
+bool Table::remove_references(Column* curTableColumn, Column* otherTableColumn) {
+	if (find(columns_.begin(), columns_.end(), curTableColumn) == columns_.end()) {
+		return false;
+	}
+
+	if (refFromOtherColumns_.find(curTableColumn) != refFromOtherColumns_.end() && refFromOtherColumns_[curTableColumn].find(otherTableColumn) != refFromOtherColumns_[curTableColumn].end()) {
+		refFromOtherColumns_[curTableColumn][otherTableColumn] -= 1;
+
+		if (refFromOtherColumns_[curTableColumn][otherTableColumn] <= 0) {
+			auto it1 = refFromOtherColumns_[curTableColumn].find(otherTableColumn);
+			refFromOtherColumns_[curTableColumn].erase(it1);
+
+			if (refFromOtherColumns_[curTableColumn].empty()) {
+				auto it2 = refFromOtherColumns_.find(curTableColumn);
+				refFromOtherColumns_.erase(it2);
+			}
+		}
+	}
+	else {
+		return false;
+	}
+
+	return true;
+}
+
+
+bool Table::remove_column_name(name_t name) {
+	auto it = find(acceColumnNames_.begin(), acceColumnNames_.end(), name);
+
+	if (it == acceColumnNames_.end()) {
+		return false;
+	}
+
+	acceColumnNames_.erase(it);
+
+	return true;
+}
+bool Table::add_column_name(name_t name) {
+	auto it = find(acceColumnNames_.begin(), acceColumnNames_.end(), name);
+	if (it == acceColumnNames_.end()) {
+		acceColumnNames_.push_back(name);
+		return true;
+	}
+
+	return false;
+}
+void Table::drop_index(Column* column) {
+	vector<Index*> waitForDrop;
+	vector<Index*> indexes = get_index(column);
+
+	for (Index* index : indexes) {
+		auto it = index->columns_.find(column);
+		index->columns_.erase(it);
+
+		if (index->columns_.empty()) {
+			waitForDrop.push_back(index);
+		}
+	}
+
+	for (Index* index : waitForDrop) {
+		drop_index(index);
+	}
+
+	return;
+}
+void Table::drop_constraint(Column* column) {
+	vector<Constraint*> waitForDrop;
+	vector<Constraint*> constraints = get_constraint(column);
+
+	for (Constraint* constraint : constraints) {
+		auto it = constraint->columns_.find(column);
+		constraint->columns_.erase(column);
+
+		if (constraint->columns_.empty()) {
+			waitForDrop.push_back(constraint);
+		}
+	}
+
+	for (Constraint* constraint : constraints_) {
+		drop_constraint(constraint);
+	}
+
+	return;
+}
+
+bool Table::index_drop_check(Index* index) {
+	if (find(indexes_.begin(), indexes_.end(), index) == indexes_.end()) {
+		return false;
+	}
+
+	for (auto& it : index->columns_) {
+		if (refFromOtherColumns_.find(it.first) != refFromOtherColumns_.end()) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool Table::constraint_drop_check(Constraint* constraint) {
+	if (find(constraints_.begin(), constraints_.end(), constraint) == constraints_.end()) {
+		return false;
+	}
+
+	return true;
+}
+
+//-----------------------------SelectStmtInfo-----------------------------
+SelectStmtInfo::SelectStmtInfo(StmtLocation location, int rowNumber, int columnNumber) : location_(location), rowNumber_(rowNumber), columnNumber_(columnNumber) {}
+SelectStmtInfo::~SelectStmtInfo() {
+	clear_local_info();
+	clear_cte();
+
+	return;
+}
+
+bool SelectStmtInfo::is_duplicated_table(Table* table) {
+	for (Table* t : usedTables_) {
+		if (t->identifierName_ == table->identifierName_) {
+			return true;
+		}
+	}
+
+	return false;
+}
+bool SelectStmtInfo::exist_duplicated_column(vector<Column*>& v1, vector<Column*>& v2) {
+	vector<int> bitmap = vector<int>(COLUMNNAMEMAX, 0);
+
+	for (Column* c : v1) {
+		bitmap[c->identifierName_]++;
+	}
+
+	for (Column* c : v2) {
+		bitmap[c->identifierName_]++;
+	}
+
+	for (int i : bitmap) {
+		if (i > 1) {
+			return true;
+		}
+	}
+
+	return false;
+}
+bool SelectStmtInfo::has_column_limit() {
+	return columnNumber_ != DEFAULTCOLUMNNUMBER;
+}
+bool SelectStmtInfo::has_row_limit() {
+	return rowNumber_ != DEFAULTROWNUMBER;
+}
+
+void SelectStmtInfo::add_used_table(Table* table) {
+	table->update_duplicationInfo(duplicationInfo_);
+	usedTables_.push_back(table);
+
+	return;
+}
+void SelectStmtInfo::clear_local_info() {
+	for (Table* t : usedTables_) {
+		delete t;
+	}
+
+	for (int i = 0; i < COLUMNNAMEMAX; i++) {
+		duplicationInfo_[i] = 0;
+	}
+
+	hasAggregate = false;
+
+	usedTables_.clear();	
+	usedInnerColumns_.clear();
+	acceColumns_.clear();
+	windowStatusRecord_.clear();
+
+	return;
+}
+void SelectStmtInfo::clear_cte() {
+	for (auto it = innerCteTables_.begin(); it != innerCteTables_.end(); it++) {
+		Table* cte = *it;
+		delete cte;
+	}
+
+	innerCteTables_.clear();
+
+	return;
+}
+
+void SelectStmtInfo::update_acceColumns() {
+	acceColumns_.clear();
+	map<name_t, vector<Column*>> tmp;
+
+	for (Table* t : usedTables_) {
+		t->update_duplicatedColumns(duplicationInfo_);
+
+		for (Column* c : t->columns_) {
+			tmp[c->identifierName_].push_back(c);
+		}
+	}
+
+	for (Column* c : outReferences_) {
+		if (tmp.find(c->identifierName_) == tmp.end()) {
+			tmp[c->identifierName_].push_back(c);
+		}
+		else {
+			Column* cc = tmp[c->identifierName_][0];
+
+			if (cc->parentTable_->inSelectStmtInfo_ != this) {
+				tmp[c->identifierName_].push_back(c);
+			}
+		}
+	}
+
+	for (auto& it : tmp) {
+		for (Column* c : it.second) {
+			acceColumns_.push_back(c);
+		}
+	}
+
+	return;
+}
+void SelectStmtInfo::update_acceColumns(vector<Table*>& usedTables, vector<int>& duplicationInfo) {
+	acceColumns_.clear();
+	map<name_t, vector<Column*>> tmp;
+
+	for (Table* t : usedTables) {
+		t->update_duplicatedColumns(duplicationInfo);
+
+		for (Column* c: t->columns_) {
+			tmp[c->identifierName_].push_back(c);
+		}
+	}
+
+	for (Column* c : outReferences_) {
+		if (tmp.find(c->identifierName_) == tmp.end()) {
+			tmp[c->identifierName_].push_back(c);
+		}
+		else {
+			Column* cc = tmp[c->identifierName_][0];
+
+			if (cc->parentTable_->inSelectStmtInfo_ != this) {
+				tmp[c->identifierName_].push_back(c);
+			}
+		}
+	}
+
+	for (auto& it : tmp) {
+		for (Column* c : it.second) {
+			acceColumns_.push_back(c);
+		}
+	}
+
+	return;
+}
+
+void SelectStmtInfo::add_usedInnerColumns(Column* column) {
+	if (find(usedInnerColumns_.begin(), usedInnerColumns_.end(), column) == usedInnerColumns_.end()) {
+		usedInnerColumns_.push_back(column);
+	}
+
+	return;
+}
+void SelectStmtInfo::add_usedOutColumns(Column* column) {
+	if (find(usedOutColumns_.begin(), usedOutColumns_.end(), column) == usedOutColumns_.end()) {
+		usedOutColumns_.push_back(column);
+	}
+
+	return;
+}
+void SelectStmtInfo::add_out_usedColumns(vector<Column*>& usedColumns) {
+	for (Column* c : usedColumns) {
+		if (c->parentTable_->inSelectStmtInfo_ != this) {
+			add_usedOutColumns(c);
+		}
+	}
+
+	return;
+}
+void SelectStmtInfo::add_all_usedColumns(vector<Column*>& usedColumns) {
+	for (Column* c : usedColumns) {
+		if (c->parentTable_->inSelectStmtInfo_ == this) {
+			add_usedInnerColumns(c);
+		}
+		else {
+			add_usedOutColumns(c);
+		}
+	}
+
+	return;
+}
+
+//-----------------------------GlobalStatusManger-----------------------------
+GlobalStatusManger::~GlobalStatusManger() {
+	for (Table* t : globalTables_) {
+		delete t;
+	}
+
+	return;
+}
+
+void GlobalStatusManger::reset_status() {
+	totalTableName_ = 0;
+	totalViewName_ = 0;
+	totalWindowName_ = 0;
+	totalIndexName_ = 0;
+	totalConstraintName_ = 0;
+
+	assert(selectInfoStack_.empty());
+
+	for (Table* t : globalTables_) {
+		delete t;
+	}
+
+	globalTables_.clear();
+
+	return;
+}
+
+void GlobalStatusManger::push_selectInfo(StmtLocation location, int rowNumber, int columnNumber) {
+	SelectStmtInfo* info = new SelectStmtInfo(location, rowNumber, columnNumber);
+	SelectStmtInfo* preInfo = get_cur_selectInfo();
+
+	if (preInfo != nullptr) {
+		info->outCteTables_ = preInfo->outCteTables_;
+		for (Table* t : preInfo->innerCteTables_) {
+			info->outCteTables_.push_back(t);
+		}
+
+		info->outReferences_ = preInfo->acceColumns_;
+
+		if (location == StmtLocation::slRecursiveCTE) {
+			info->recursiveCteName_ = preInfo->recursiveCteName_;
+		}
+	}
+
+	selectInfoStack_.push(info);
+
+	return;
+}
+void GlobalStatusManger::pop_selectInfo() {
+	SelectStmtInfo* info = get_cur_selectInfo();
+	pop_cur_selectInfo();
+	SelectStmtInfo* preinfo = get_cur_selectInfo();
+
+	if (preinfo != nullptr && info != nullptr) {
+		if (find(ignoreInnerUsedColumns_.begin(), ignoreInnerUsedColumns_.end(), info->location_) != ignoreInnerUsedColumns_.end()) {
+			preinfo->add_out_usedColumns(info->usedOutColumns_);
+		}
+		else {
+			preinfo->add_all_usedColumns(info->usedOutColumns_);
+		}		
+	}
+
+	if (info != nullptr) {
+		delete info;
+	}
+
+	return;
+}
+
+SelectStmtInfo* GlobalStatusManger::get_cur_selectInfo() {
+	if (selectInfoStack_.empty()) {
+		return nullptr;
+	}		
+
+	return selectInfoStack_.top();
+}
+void GlobalStatusManger::pop_cur_selectInfo() {
+	if (selectInfoStack_.empty()) {
+		fprintf(stderr, "ERROR: Pop Empty Stack\n");
+		assert(0);
+	}
+
+	selectInfoStack_.pop();
+
+	return;
+}
+
+int GlobalStatusManger::get_acce_table_number() {
+	int res = 0;
+	SelectStmtInfo* info = get_cur_selectInfo();
+
+	res += globalTables_.size() + info->outCteTables_.size() + info->innerCteTables_.size();
+
+	return res;
+}
+Table* GlobalStatusManger::get_acce_table(int index) {
+	Table* res = nullptr;
+	SelectStmtInfo* info = get_cur_selectInfo();
+
+	if (index < globalTables_.size()) {
+		res = globalTables_[index];
+	}
+	else if(index - globalTables_.size() < info->outCteTables_.size()) {
+		res = info->outCteTables_[index - globalTables_.size()];
+	}
+	else {
+		res = info->innerCteTables_[index - globalTables_.size() - info->outCteTables_.size()];
+	}
+
+	assert(res != nullptr);
+
+	return res;
+}
+vector<Table*> GlobalStatusManger::get_acce_table(IdentifierType type) {
+	assert(type == IdentifierType::iTable || type == IdentifierType::iView);
+
+	vector<Table*> res;
+
+	for (Table* table : globalTables_) {
+		if (table->identifierType_ == type) {
+			res.push_back(table);
+		}
+	}
+
+	return res;
+}
+
+name_t GlobalStatusManger::get_new_table_name() {
+	return totalTableName_++;
+}
+name_t GlobalStatusManger::get_new_view_name() {
+	return totalViewName_++;
+}
+name_t GlobalStatusManger::get_new_window_name() {
+	return totalWindowName_++;
+}
+name_t GlobalStatusManger::get_new_index_name() {
+	return totalIndexName_++;
+}
+name_t GlobalStatusManger::get_new_constraint_name() {
+	return totalConstraintName_++;
+}
+
+bool GlobalStatusManger::add_table(Table* table) {
+	if (table == nullptr || find(globalTables_.begin(), globalTables_.end(), table) != globalTables_.end()) {
+		return false;
+	}
+
+	globalTables_.push_back(table);
+
+	return true;
+}
+bool GlobalStatusManger::drop_table(Table* table) {
+	auto it = find(globalTables_.begin(), globalTables_.end(), table);
+
+	if (it == globalTables_.end()) {
+		return false;
+	}
+
+	globalTables_.erase(it);
+	delete table;
+
+	return true;
+}
+bool GlobalStatusManger::drop_table(name_t name, IdentifierType type) {
+	Table* tmp = nullptr;
+
+	for (Table* table : globalTables_) {
+		if (table->identifierName_ == name && table->identifierType_ == type) {
+			tmp = table;
+			break;
+		}
+	}
+
+	if (tmp != nullptr) {
+		return drop_table(tmp);
+	}
+
+	return true;
+}
+
+//-----------------------------IRTrim-----------------------------
+IRTrim::IRTrim(Instantiator* instantiator): instantiator_(instantiator) {
+	instantiate_simple_limit();
+	instantiate_simple_column_list();
+	instantiate_simple_alias();
+	instantiate_simple_expr_root();
+	instantiate_simple_expr_root_true();
+	instantiate_simple_expr_root_list();
+	instantiate_simple_simple_select_item_list();
+	instantiate_simple_window_spec();
+	instantiate_simple_index_name();
+	instantiate_simple_constraint_name();
+	instantiate_simple_key_part();
+	instantiate_simple_key_part_list();
+	instantiate_simple_table_element();
+	instantiate_simple_values();
+
+	return;
+}
+IRTrim::~IRTrim() {
+	for (IR* ir : simpleIR_) {
+		if (ir != nullptr) {
+			deep_delete(ir);
+		}			
+	}
+
+	return;
+}
+
+void IRTrim::instantiate_simple_limit() {
+	IR* iconst = new IR(IRTYPE::kIconst, OP0(), nullptr, nullptr);
+	IR* limit_options = new IR(IRTYPE::kLimitOptions, OP0(), iconst, nullptr);
+	IR* limit_clause = new IR(IRTYPE::kLimitClause, OP3(TERMINAL::tLimit, TERMINAL::tEmpty, TERMINAL::tEmpty), limit_options, nullptr);
+
+	simple_limit_ = limit_clause;
+	simpleIR_.push_back(simple_limit_);
+
+	return;
+}
+void IRTrim::instantiate_simple_column_list() {
+	IR* ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+	IR* column_name = new IR(IRTYPE::kColumnName, OP0(), ident, nullptr);
+	IR* column_list = new IR(IRTYPE::kColumnList, OP0(), column_name, nullptr);
+
+	simple_column_list_ = column_list;
+	simpleIR_.push_back(simple_column_list_);
+
+	return;
+}
+void IRTrim::instantiate_simple_alias() {
+	IR* ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+	IR* alias = new IR(IRTYPE::kAlias, OP0(), ident, nullptr);
+
+	simple_alias_ = alias;
+	simpleIR_.push_back(simple_alias_);
+
+	return;
+}
+void IRTrim::instantiate_simple_expr_root() {
+	IR* iconst = new IR(IRTYPE::kIconst, OP0(), nullptr, nullptr);
+	IR* simple_expr = new IR(IRTYPE::kSimpleExpr, OP0(), iconst, nullptr);
+	IR* bit_expr = new IR(IRTYPE::kBitExpr, OP0(), simple_expr, nullptr);
+	IR* predicate = new IR(IRTYPE::kPredicate, OP0(), bit_expr, nullptr);
+	IR* bool_pri = new IR(IRTYPE::kBoolPri, OP0(), predicate, nullptr);
+	IR* expr = new IR(IRTYPE::kExpr, OP0(), bool_pri, nullptr);
+	IR* expr_root = new IR(IRTYPE::kExprRoot, OP0(), expr, nullptr);
+
+	iconst->long_val_ = 1;
+
+	simple_expr_root_ = expr_root;
+	simpleIR_.push_back(simple_expr_root_);
+
+	return;
+}
+void IRTrim::instantiate_simple_expr_root_true() {
+	IR* literal = new IR(IRTYPE::kLiteral, OP3(TERMINAL::tTrue, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+	IR* simple_expr = new IR(IRTYPE::kSimpleExpr, OP0(), literal, nullptr);
+	IR* bit_expr = new IR(IRTYPE::kBitExpr, OP0(), simple_expr, nullptr);
+	IR* predicate = new IR(IRTYPE::kPredicate, OP0(), bit_expr, nullptr);
+	IR* bool_pri = new IR(IRTYPE::kBoolPri, OP0(), predicate, nullptr);
+	IR* expr = new IR(IRTYPE::kExpr, OP0(), bool_pri, nullptr);
+	IR* expr_root = new IR(IRTYPE::kExprRoot, OP0(), expr, nullptr);
+	
+	simple_expr_root_true_ = expr_root;
+	simpleIR_.push_back(simple_expr_root_true_);
+
+	return;
+}
+void IRTrim::instantiate_simple_expr_root_list() {
+	IR* column_ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+	IR* column_name = new IR(IRTYPE::kColumnName, OP0(), column_ident, nullptr);
+	IR* columnref = new IR(IRTYPE::kColumnref, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), column_name, nullptr);
+	IR* simple_expr = new IR(IRTYPE::kSimpleExpr, OP0(), columnref, nullptr);
+	IR* bit_expr = new IR(IRTYPE::kBitExpr, OP0(), simple_expr, nullptr);
+	IR* predicate = new IR(IRTYPE::kPredicate, OP0(), bit_expr, nullptr);
+	IR* bool_pri = new IR(IRTYPE::kBoolPri, OP0(), predicate, nullptr);
+	IR* expr = new IR(IRTYPE::kExpr, OP0(), bool_pri, nullptr);
+	IR* exor_root = new IR(IRTYPE::kExprRoot, OP0(), expr, nullptr);
+	IR* expr_root_list = new IR(IRTYPE::kExprRootList, OP0(), exor_root, nullptr);
+
+	simple_expr_root_list_ = expr_root_list;
+	simpleIR_.push_back(simple_expr_root_list_);
+
+	return;
+}
+void IRTrim::instantiate_simple_simple_select_item_list() {
+	IR* expr_root = deep_copy(simple_expr_root_);
+	IR* alise = new IR(IRTYPE::kOptAlias, OP3(TERMINAL::tAs, TERMINAL::tEmpty, TERMINAL::tEmpty), deep_copy(simple_alias_), nullptr);
+	IR* select_item = new IR(IRTYPE::kSelectItem, OP0(), expr_root, alise);
+	IR* select_item_list = new IR(IRTYPE::kSelectItemList, OP0(), select_item, nullptr);
+
+	simple_select_item_list_ = select_item_list;
+	simpleIR_.push_back(simple_select_item_list_);
+
+	return;
+}
+void IRTrim::instantiate_simple_window_spec() {
+	IR* opt_existing_window_name = new IR(IRTYPE::kOptExistingWindowName, OP0(), nullptr, nullptr);
+	IR* opt_partition_clause = new IR(IRTYPE::kOptPartitionClause, OP0(), nullptr, nullptr);
+	IR* opt_window_order_by_clause = new IR(IRTYPE::kOptWindowOrderByClause, OP0(), nullptr, nullptr);
+	IR* opt_window_frame_clause = new IR(IRTYPE::kOptWindowFrameClause, OP0(), nullptr, nullptr);
+
+	IR* tmp1 = new IR(IRTYPE::kWindowSpecDetailsTmp1, OP0(), opt_window_order_by_clause, opt_window_frame_clause);
+	IR* tmp2 = new IR(IRTYPE::kWindowSpecDetailsTmp2, OP0(), opt_partition_clause, tmp1);
+	IR* window_spec_details = new IR(IRTYPE::kWindowSpecDetails, OP0(), opt_existing_window_name, tmp2);
+
+	IR* window_spec = new IR(IRTYPE::kWindowSpec, OP3(TERMINAL::tOpLp, TERMINAL::tOpRp, TERMINAL::tEmpty), window_spec_details, nullptr);
+
+	simple_window_spec_ = window_spec;
+	simpleIR_.push_back(simple_window_spec_);
+
+	return;
+}
+void IRTrim::instantiate_simple_index_name() {
+	IR* ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+	IR* index_name = new IR(IRTYPE::kIndexName, OP0(), ident, nullptr);
+
+	simple_index_name_ = index_name;
+	simpleIR_.push_back(simple_index_name_);
+
+	return;
+}
+void IRTrim::instantiate_simple_constraint_name() {
+	IR* ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+	IR* constraint_name = new IR(IRTYPE::kConstraintName, OP0(), ident, nullptr);
+
+	simple_constraint_name_ = constraint_name;
+	simpleIR_.push_back(simple_constraint_name_);
+
+	return;
+}
+void IRTrim::instantiate_simple_key_part() {
+	IR* ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+	IR* column_name = new IR(IRTYPE::kColumnName, OP0(), ident, nullptr);
+	IR* opt_ordering_direction = new IR(IRTYPE::kOptOrderingDirection, OP0(), nullptr, nullptr);
+	IR* key_part = new IR(IRTYPE::kKeyPart, OP0(), column_name, opt_ordering_direction);
+
+	simple_key_part_ = key_part;
+	simpleIR_.push_back(simple_key_part_);
+
+	return;
+}
+void IRTrim::instantiate_simple_key_part_list() {
+	IR* key_part = deep_copy(simple_key_part_);
+	IR* key_list = new IR(IRTYPE::kKeyList, OP0(), key_part, nullptr);
+
+	simple_key_part_list_ = key_list;
+	simpleIR_.push_back(simple_key_part_list_);
+
+	return;
+}
+void IRTrim::instantiate_simple_table_element() {
+	IR* int_type = new IR(IRTYPE::kIntType, OP3(TERMINAL::tInt, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+	IR* opt_field_options = new IR(IRTYPE::kOptFieldOptions, OP0(), nullptr, nullptr);
+	IR* number_type = new IR(IRTYPE::kNumberType, OP0(), int_type, opt_field_options);
+	IR* data_type = new IR(IRTYPE::kDataType, OP0(), number_type, nullptr);
+	IR* opt_column_attribute_list = new IR(IRTYPE::kOptColumnAttributeList, OP0(), nullptr, nullptr);
+	IR* field_def = new IR(IRTYPE::kFieldDef, OP0(), data_type, opt_column_attribute_list);
+
+	IR* ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+	IR* column_name = new IR(IRTYPE::kColumnName, OP0(), ident, nullptr);
+	IR* column_def = new IR(IRTYPE::kColumnDef, OP0(), column_name, field_def);
+	
+	IR* table_element = new IR(IRTYPE::kTableElement, OP0(), column_def, nullptr);
+
+	simple_table_element_ = table_element;
+	simpleIR_.push_back(simple_table_element_);
+
+	return;
+}
+void IRTrim::instantiate_simple_values() {
+	IR* expr_or_default = new IR(IRTYPE::kExprOrDefault, OP3(TERMINAL::tDefault, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+	IR* values = new IR(IRTYPE::kValues, OP0(), expr_or_default, nullptr);
+
+	simple_values_ = values;
+	simpleIR_.push_back(simple_values_);
+
+	return;
+}
+
+IR* IRTrim::get_expr_root_columnref(Column* column) {
+	IR* tmp1 = nullptr;
+
+	if (column->duplicated_ == ColumnStatus::csDuplication) {
+		IR* table_ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+		IR* table_name = new IR(IRTYPE::kTableName, OP0(), table_ident, nullptr);
+
+		instantiator_->instantiate_ident(table_name, IdentifierType::iTable, column->parentTable_->identifierName_);
+
+		IR* column_ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+		IR* column_name = new IR(IRTYPE::kColumnName, OP0(), column_ident, nullptr);
+
+		instantiator_->instantiate_ident(column_name, IdentifierType::iColumn, column->identifierName_);
+
+		tmp1 = new IR(IRTYPE::kColumnref, OP3(TERMINAL::tEmpty, TERMINAL::tOpDot, TERMINAL::tEmpty), table_name, column_name);
+	}
+	else {
+		IR* column_ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+		IR* column_name = new IR(IRTYPE::kColumnName, OP0(), column_ident, nullptr);
+
+		instantiator_->instantiate_ident(column_name, IdentifierType::iColumn, column->identifierName_);
+
+		tmp1 = new IR(IRTYPE::kColumnref, OP3(TERMINAL::tEmpty, TERMINAL::tEmpty, TERMINAL::tEmpty), column_name, nullptr);
+	}
+
+	IR* tmp2 = new IR(IRTYPE::kSimpleExpr, OP0(), tmp1, nullptr);
+	IR* tmp3 = new IR(IRTYPE::kBitExpr, OP0(), tmp2, nullptr);
+	IR* tmp4 = new IR(IRTYPE::kPredicate, OP0(), tmp3, nullptr);
+	IR* tmp5 = new IR(IRTYPE::kBoolPri, OP0(), tmp4, nullptr);
+	IR* tmp6 = new IR(IRTYPE::kExpr, OP0(), tmp5, nullptr);
+	IR* tmp7 = new IR(IRTYPE::kExprRoot, OP0(), tmp6, nullptr);
+
+	return tmp7;
+}
+void IRTrim::set_recursive_limit(IR* expr_root) {
+	IR* number_tmp1 = new IR(IRTYPE::kIconst, OP0(), nullptr, nullptr);
+	number_tmp1->long_val_ = rand() % LIMITMAX;
+
+	IR* number_tmp2 = new IR(IRTYPE::kSimpleExpr, OP0(), number_tmp1, nullptr);
+	IR* number_tmp3 = new IR(IRTYPE::kBitExpr, OP0(), number_tmp2, nullptr);
+	IR* number_tmp4 = new IR(IRTYPE::kPredicate, OP0(), number_tmp3, nullptr);
+
+
+	IR* column_ident = new IR(IRTYPE::kIdent, OP0(), nullptr, nullptr);
+	IR* column_name = new IR(IRTYPE::kColumnName, OP0(), column_ident, nullptr);
+
+	instantiator_->instantiate_ident(column_name, IdentifierType::iColumn, RESERVEDCOLUMNNAME);
+
+	IR* tmp1 = new IR(IRTYPE::kColumnref, OP0(), column_name, nullptr);
+	IR* tmp2 = new IR(IRTYPE::kSimpleExpr, OP0(), tmp1, nullptr);
+	IR* tmp3 = new IR(IRTYPE::kBitExpr, OP0(), tmp2, nullptr);
+	IR* tmp4 = new IR(IRTYPE::kPredicate, OP0(), tmp3, nullptr);
+	IR* tmp5 = new IR(IRTYPE::kBoolPri, OP0(), tmp4, nullptr);
+
+	IR* comp_op = new IR(IRTYPE::kCompOp, OP3(TERMINAL::tOpLessthan, TERMINAL::tEmpty, TERMINAL::tEmpty), nullptr, nullptr);
+
+	IR* bool_pri_tmp1 = new IR(IRTYPE::kBoolPriTmp1, OP0(), comp_op, number_tmp4);
+	IR* bool_pri = new IR(IRTYPE::kBoolPri, OP0(), tmp5, bool_pri_tmp1);
+
+	IR* expr_right = new IR(IRTYPE::kExpr, OP0(), bool_pri, nullptr);
+	IR* expr_left = NT_check(expr_root->left_, IRTYPE::kExpr);
+
+	IR* new_expr = new IR(IRTYPE::kExpr, OP3(TERMINAL::tEmpty, TERMINAL::tAnd, TERMINAL::tEmpty), expr_left, expr_right);
+
+	expr_root->left_ = new_expr;
+
+	return;
+}
\ No newline at end of file