parse_defs.h

/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
miniob is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
         http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details. */
 
//
// Created by Meiyi
//
 
#pragma once
 
#include <stddef.h>
#include <memory>
#include <vector>
#include <string>
 
#include "sql/parser/value.h"
 
class Expression;
 
struct RelAttrSqlNode
{
  std::string relation_name;   
  std::string attribute_name;  
};
 
enum CompOp 
{
  EQUAL_TO,     
  LESS_EQUAL,   
  NOT_EQUAL,    
  LESS_THAN,    
  GREAT_EQUAL,  
  GREAT_THAN,   
  NO_OP
};
 
struct ConditionSqlNode
{
  int             left_is_attr;    
  Value           left_value;      
  RelAttrSqlNode  left_attr;       
  CompOp          comp;            
  int             right_is_attr;   
  RelAttrSqlNode  right_attr;      
  Value           right_value;     
};
 
struct SelectSqlNode
{
  std::vector<RelAttrSqlNode>     attributes;    
  std::vector<std::string>        relations;     
  std::vector<ConditionSqlNode>   conditions;    
};
 
struct CalcSqlNode
{
  std::vector<Expression *> expressions;  
 
  ~CalcSqlNode();
};
 
struct InsertSqlNode
{
  std::string        relation_name;  
  std::vector<Value> values;         
};
 
struct DeleteSqlNode
{
  std::string                   relation_name;  
  std::vector<ConditionSqlNode> conditions;
};
 
struct UpdateSqlNode
{
  std::string                   relation_name;         
  std::string                   attribute_name;        
  Value                         value;                 
  std::vector<ConditionSqlNode> conditions;
};
 
struct AttrInfoSqlNode
{
  AttrType    type;       
  std::string name;       
  size_t      length;     
};
 
struct CreateTableSqlNode
{
  std::string                  relation_name;         
  std::vector<AttrInfoSqlNode> attr_infos;            
};
 
struct DropTableSqlNode
{
  std::string relation_name;  
};
 
struct CreateIndexSqlNode
{
  std::string index_name;      
  std::string relation_name;   
  std::string attribute_name;  
};
 
struct DropIndexSqlNode
{
  std::string index_name;     
  std::string relation_name;  
};
 
struct DescTableSqlNode
{
  std::string relation_name;
};
 
struct LoadDataSqlNode
{
  std::string relation_name;
  std::string file_name;
};
 
struct SetVariableSqlNode
{
  std::string name;
  Value       value;
};
 
class ParsedSqlNode;
 
struct ExplainSqlNode
{
  std::unique_ptr<ParsedSqlNode> sql_node;
};
 
struct ErrorSqlNode
{
  std::string error_msg;
  int         line;
  int         column;
};
 
enum SqlCommandFlag
{
  SCF_ERROR = 0,
  SCF_CALC,
  SCF_SELECT,
  SCF_INSERT,
  SCF_UPDATE,
  SCF_DELETE,
  SCF_CREATE_TABLE,
  SCF_DROP_TABLE,
  SCF_CREATE_INDEX,
  SCF_DROP_INDEX,
  SCF_SYNC,
  SCF_SHOW_TABLES,
  SCF_DESC_TABLE,
  SCF_BEGIN,        
  SCF_COMMIT,
  SCF_CLOG_SYNC,
  SCF_ROLLBACK,
  SCF_LOAD_DATA,
  SCF_HELP,
  SCF_EXIT,
  SCF_EXPLAIN,
  SCF_SET_VARIABLE, 
};
class ParsedSqlNode
{
public:
  enum SqlCommandFlag       flag;
  ErrorSqlNode              error;
  CalcSqlNode               calc;
  SelectSqlNode             selection;
  InsertSqlNode             insertion;
  DeleteSqlNode             deletion;
  UpdateSqlNode             update;
  CreateTableSqlNode        create_table;
  DropTableSqlNode          drop_table;
  CreateIndexSqlNode        create_index;
  DropIndexSqlNode          drop_index;
  DescTableSqlNode          desc_table;
  LoadDataSqlNode           load_data;
  ExplainSqlNode            explain;
  SetVariableSqlNode        set_variable;
 
public:
  ParsedSqlNode();
  explicit ParsedSqlNode(SqlCommandFlag flag);
};
 
class ParsedSqlResult
{
public:
  void add_sql_node(std::unique_ptr<ParsedSqlNode> sql_node);
  std::vector<std::unique_ptr<ParsedSqlNode>> &sql_nodes()
  {
    return sql_nodes_;
  }
 
private:
  std::vector<std::unique_ptr<ParsedSqlNode>> sql_nodes_;  
};