Code_expr_op.hpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:4k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef ODBC_CODEGEN_Code_expr_op_hpp
  14. #define ODBC_CODEGEN_Code_expr_op_hpp
  15. #include <common/common.hpp>
  16. #include <common/DataField.hpp>
  17. #include "Code_expr.hpp"
  18. /**
  19.  * @class Expr_op
  20.  * @brief Arithmetic and string operators
  21.  */
  22. struct Expr_op {
  23.     enum Opcode {
  24. Add = 1, // binary
  25. Subtract,
  26. Multiply,
  27. Divide,
  28. Plus, // unary
  29. Minus
  30.     };
  31.     Expr_op(Opcode opcode);
  32.     const char* name() const;
  33.     unsigned arity() const;
  34.     Opcode m_opcode;
  35. };
  36. inline
  37. Expr_op::Expr_op(Opcode opcode) :
  38.     m_opcode(opcode)
  39. {
  40. }
  41. /**
  42.  * @class Plan_expr_op
  43.  * @brief Operator node in an expression in PlanTree
  44.  */
  45. class Plan_expr_op : public Plan_expr {
  46. public:
  47.     Plan_expr_op(Plan_root* root, Expr_op op);
  48.     virtual ~Plan_expr_op();
  49.     Plan_base* analyze(Ctx& ctx, Ctl& ctl);
  50.     Exec_base* codegen(Ctx& ctx, Ctl& ctl);
  51.     void print(Ctx& ctx);
  52.     bool isEqual(const Plan_expr* expr) const;
  53.     bool isGroupBy(const Plan_expr_row* row) const;
  54.     // children
  55.     void setExpr(unsigned i, Plan_expr* expr);
  56. protected:
  57.     Expr_op m_op;
  58.     Plan_expr* m_expr[1 + 2];
  59. };
  60. inline
  61. Plan_expr_op::Plan_expr_op(Plan_root* root, Expr_op op) :
  62.     Plan_expr(root, TypeOp),
  63.     m_op(op)
  64. {
  65.     m_expr[0] = m_expr[1] = m_expr[2] = 0;
  66. }
  67. inline void
  68. Plan_expr_op::setExpr(unsigned i, Plan_expr* expr)
  69. {
  70.     ctx_assert(1 <= i && i <= 2 && expr != 0);
  71.     m_expr[i] = expr;
  72. }
  73. /**
  74.  * @class Exec_expr_op
  75.  * @brief Operator node in an expression in ExecTree
  76.  */
  77. class Exec_expr_op : public Exec_expr {
  78. public:
  79.     class Code : public Exec_expr::Code {
  80.     public:
  81. Code(Expr_op op, const SqlSpec& spec);
  82. virtual ~Code();
  83.     protected:
  84. friend class Exec_expr_op;
  85. Expr_op m_op;
  86. const SqlSpec m_sqlSpec;
  87.     };
  88.     class Data : public Exec_expr::Data {
  89.     public:
  90. Data(const SqlField& sqlField);
  91. virtual ~Data();
  92.     protected:
  93. friend class Exec_expr_op;
  94. SqlField m_sqlField;
  95.     };
  96.     Exec_expr_op(Exec_root* root);
  97.     virtual ~Exec_expr_op();
  98.     void alloc(Ctx& ctx, Ctl& ctl);
  99.     void evaluate(Ctx& ctx, Ctl& ctl);
  100.     void close(Ctx& ctx);
  101.     void print(Ctx& ctx);
  102.     // children
  103.     const Code& getCode() const;
  104.     Data& getData() const;
  105.     void setExpr(unsigned i, Exec_expr* expr);
  106. protected:
  107.     Exec_expr* m_expr[1 + 2];
  108. };
  109. inline
  110. Exec_expr_op::Code::Code(Expr_op op, const SqlSpec& sqlSpec) :
  111.     Exec_expr::Code(m_sqlSpec),
  112.     m_op(op),
  113.     m_sqlSpec(sqlSpec)
  114. {
  115. }
  116. inline
  117. Exec_expr_op::Data::Data(const SqlField& sqlField) :
  118.     Exec_expr::Data(m_sqlField),
  119.     m_sqlField(sqlField)
  120. {
  121. }
  122. inline
  123. Exec_expr_op::Exec_expr_op(Exec_root* root) :
  124.     Exec_expr(root)
  125. {
  126.     m_expr[0] = m_expr[1] = m_expr[2] = 0;
  127. }
  128. // children
  129. inline const Exec_expr_op::Code&
  130. Exec_expr_op::getCode() const
  131. {
  132.     const Code* code = static_cast<const Code*>(m_code);
  133.     return *code;
  134. }
  135. inline Exec_expr_op::Data&
  136. Exec_expr_op::getData() const
  137. {
  138.     Data* data = static_cast<Data*>(m_data);
  139.     return *data;
  140. }
  141. inline void
  142. Exec_expr_op::setExpr(unsigned i, Exec_expr* expr)
  143. {
  144.     ctx_assert(1 <= i && i <= 2 && m_expr[i] == 0);
  145.     m_expr[i] = expr;
  146. }
  147. #endif