开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
Code_expr_op.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：10k
源码类别：

MySQL数据库

开发平台：

Visual C++

Code_expr_op.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include "Code_expr.hpp"
  18. #include "Code_expr_op.hpp"
  19. #include "Code_expr_conv.hpp"
  20. #include "Code_root.hpp"
  22. // Expr_op
  24. const char*
  25. Expr_op::name() const
  26. {
  27.     switch (m_opcode) {
  28.     case Add:
  29. return "+";
  30.     case Subtract:
  31. return "-";
  32.     case Multiply:
  33. return "*";
  34.     case Divide:
  35. return "/";
  36.     case Plus:
  37. return "+";
  38.     case Minus:
  39. return "-";
  40.     }
  41.     ctx_assert(false);
  42.     return "";
  43. }
  45. unsigned
  46. Expr_op::arity() const
  47. {
  48.     switch (m_opcode) {
  49.     case Add:
  50.     case Subtract:
  51.     case Multiply:
  52.     case Divide:
  53. return 2;
  54.     case Plus:
  55.     case Minus:
  56. return 1;
  57.     }
  58.     ctx_assert(false);
  59.     return 0;
  60. }
  62. // Plan_expr_op
  64. Plan_expr_op::~Plan_expr_op()
  65. {
  66. }
  68. Plan_base*
  69. Plan_expr_op::analyze(Ctx& ctx, Ctl& ctl)
  70. {
  71.     m_exec = 0;
  72.     unsigned arity = m_op.arity();
  73.     // analyze operands
  74.     m_isAggr = false;
  75.     m_isBound = true;
  76.     for (unsigned i = 1; i <= arity; i++) {
  77. ctx_assert(m_expr[i] != 0);
  78. m_expr[i]->analyze(ctx, ctl);
  79. if (! ctx.ok())
  80.     return 0;
  81. if (m_expr[i]->m_isAggr)
  82.     m_isAggr = true;
  83. if (! m_expr[i]->m_isBound)
  84.     m_isBound = false;
  85.     }
  86.     // find result type and conversion types (currently same)
  87.     SqlType res;
  88.     SqlType con[1 + 2];
  89.     if (arity == 1) {
  90. const SqlType& t1 = m_expr[1]->sqlType();
  91. switch (t1.type()) {
  92. case SqlType::Char:
  93. case SqlType::Varchar:
  94.     break;
  95. case SqlType::Smallint:
  96. case SqlType::Integer:
  97. case SqlType::Bigint:
  98.     res.setType(ctx, SqlType::Bigint);
  99.     con[1] = res;
  100.     break;
  101. case SqlType::Real:
  102. case SqlType::Double:
  103.     res.setType(ctx, SqlType::Double);
  104.     con[1] = res;
  105.     break;
  106. case SqlType::Null:
  107.     res.setType(ctx, SqlType::Null);
  108.     con[1] = res;
  109.     break;
  110. case SqlType::Unbound:
  111.     res.setType(ctx, SqlType::Unbound);
  112.     con[1] = res;
  113. default:
  114.     break;
  115. }
  116. if (con[1].type() == SqlType::Undef) {
  117.     char b1[40];
  118.     t1.print(b1, sizeof(b1));
  119.     ctx.pushStatus(Error::Gen, "type mismatch in operation: %s %s", m_op.name(), b1);
  120.     return 0;
  121. }
  122.     } else if (arity == 2) {
  123. const SqlType& t1 = m_expr[1]->sqlType();
  124. const SqlType& t2 = m_expr[2]->sqlType();
  125. switch (t1.type()) {
  126. case SqlType::Char: // handle char types as in oracle
  127.     switch (t2.type()) {
  128.     case SqlType::Char:
  129. res.setType(ctx, SqlType::Char, t1.length() + t2.length());
  130. con[1] = t1;
  131. con[2] = t2;
  132. break;
  133.     case SqlType::Varchar:
  134. res.setType(ctx, SqlType::Varchar, t1.length() + t2.length());
  135. con[1] = t1;
  136. con[2] = t2;
  137. break;
  138.     case SqlType::Null:
  139. res.setType(ctx, SqlType::Varchar, t1.length());
  140. con[1] = t1;
  141. con[2] = t2;
  142. break;
  143.     case SqlType::Unbound:
  144. res.setType(ctx, SqlType::Unbound);
  145. con[1] = con[2] = res;
  146. break;
  147.     default:
  148. break;
  149.     }
  150.     break;
  151. case SqlType::Varchar:
  152.     switch (t2.type()) {
  153.     case SqlType::Char:
  154. res.setType(ctx, SqlType::Varchar, t1.length() + t2.length());
  155. con[1] = t1;
  156. con[2] = t2;
  157. break;
  158.     case SqlType::Varchar:
  159. res.setType(ctx, SqlType::Varchar, t1.length() + t2.length());
  160. con[1] = t1;
  161. con[2] = t2;
  162. break;
  163.     case SqlType::Null:
  164. res.setType(ctx, SqlType::Varchar, t1.length());
  165. con[1] = t1;
  166. con[2] = t2;
  167. break;
  168.     case SqlType::Unbound:
  169. res.setType(ctx, SqlType::Unbound);
  170. con[1] = con[2] = res;
  171. break;
  172.     default:
  173. break;
  174.     }
  175.     break;
  176. case SqlType::Smallint:
  177. case SqlType::Integer:
  178. case SqlType::Bigint:
  179.     switch (t2.type()) {
  180.     case SqlType::Smallint:
  181.     case SqlType::Integer:
  182.     case SqlType::Bigint:
  183. res.setType(ctx, SqlType::Bigint);
  184. con[1] = con[2] = res;
  185. if (t1.unSigned() || t2.unSigned()) {
  186.     con[1].unSigned(true);
  187.     con[2].unSigned(true);
  188. }
  189. break;
  190.     case SqlType::Real:
  191.     case SqlType::Double:
  192. res.setType(ctx, SqlType::Double);
  193. con[1] = con[2] = res;
  194. break;
  195.     case SqlType::Null:
  196. res.setType(ctx, SqlType::Null);
  197. con[1] = con[2] = res;
  198. break;
  199.     case SqlType::Unbound:
  200. res.setType(ctx, SqlType::Unbound);
  201. con[1] = con[2] = res;
  202. break;
  203.     default:
  204. break;
  205.     }
  206.     break;
  207. case SqlType::Real:
  208. case SqlType::Double:
  209.     switch (t2.type()) {
  210.     case SqlType::Smallint:
  211.     case SqlType::Integer:
  212.     case SqlType::Bigint:
  213.     case SqlType::Real:
  214.     case SqlType::Double:
  215. res.setType(ctx, SqlType::Double);
  216. con[1] = con[2] = res;
  217. break;
  218.     case SqlType::Null:
  219. res.setType(ctx, SqlType::Null);
  220. con[1] = con[2] = res;
  221. break;
  222.     case SqlType::Unbound:
  223. res.setType(ctx, SqlType::Unbound);
  224. con[1] = con[2] = res;
  225. break;
  226.     default:
  227. break;
  228.     }
  229.     break;
  230. case SqlType::Null:
  231.     switch (t2.type()) {
  232.     case SqlType::Char:
  233.     case SqlType::Varchar:
  234. res.setType(ctx, SqlType::Varchar, t2.length());
  235. con[1] = con[2] = res;
  236. break;
  237.     case SqlType::Unbound:
  238. res.setType(ctx, SqlType::Unbound);
  239. con[1] = con[2] = res;
  240. break;
  241.     default:
  242. res.setType(ctx, SqlType::Null);
  243. con[1] = con[2] = res;
  244. break;
  245.     }
  246.     break;
  247. case SqlType::Unbound:
  248.     res.setType(ctx, SqlType::Unbound);
  249.     con[1] = con[2] = res;
  250.     break;
  251. default:
  252.     break;
  253. }
  254. if (con[1].type() == SqlType::Undef || con[2].type() == SqlType::Undef) {
  255.     char b1[40], b2[40];
  256.     t1.print(b1, sizeof(b1));
  257.     t2.print(b2, sizeof(b2));
  258.     ctx.pushStatus(Error::Gen, "type mismatch in operation: %s %s %s", b1, m_op.name(), b2);
  259.     return 0;
  260. }
  261.     } else {
  262. ctx_assert(false);
  263. return 0;
  264.     }
  265.     if (! ctx.ok())
  266. return 0;
  267.     // insert required conversions
  268.     for (unsigned i = 1; i <= arity; i++) {
  269. if (con[i].type() == SqlType::Undef) {
  270.     ctx.pushStatus(Error::Gen, "mismatched types in operation");
  271.     return 0;
  272. }
  273. if (con[i].type() == SqlType::Unbound) {
  274.     // parameter type not yet bound
  275.     continue;
  276. }
  277. Plan_expr_conv* exprConv = new Plan_expr_conv(m_root, con[i]);
  278. m_root->saveNode(exprConv);
  279. exprConv->setExpr(m_expr[i]);
  280. m_expr[i] = static_cast<Plan_expr*>(exprConv->analyze(ctx, ctl));
  281. if (! ctx.ok())
  282.     return 0;
  283. ctx_assert(m_expr[i] != 0);
  284.     }
  285.     // set result type
  286.     m_sqlType = res;
  287.     // table dependencies are union from operands
  288.     for (unsigned i = 1; i <= arity; i++) {
  289. const TableSet& ts = m_expr[i]->tableSet();
  290. m_tableSet.insert(ts.begin(), ts.end());
  291.     }
  292.     // set alias name  XXX misses operator precedence
  293.     if (arity == 1) {
  294. m_alias.assign(m_op.name());
  295. m_alias.append(m_expr[1]->m_alias);
  296.     } else if (arity == 2) {
  297. m_alias.assign(m_expr[1]->m_alias);
  298. m_alias.append(m_op.name());
  299. m_alias.append(m_expr[2]->m_alias);
  300.     }
  301.     return this;
  302. }
  304. Exec_base*
  305. Plan_expr_op::codegen(Ctx& ctx, Ctl& ctl)
  306. {
  307.     if (m_exec != 0)
  308. return m_exec;
  309.     unsigned arity = m_op.arity();
  310.     Exec_expr_op* exec = new Exec_expr_op(ctl.m_execRoot);
  311.     ctl.m_execRoot->saveNode(exec);
  312.     // create code for operands
  313.     for (unsigned i = 1; i <= arity; i++) {
  314. ctx_assert(m_expr[i] != 0);
  315. Exec_expr* execExpr = static_cast<Exec_expr*>(m_expr[i]->codegen(ctx, ctl));
  316. if (! ctx.ok())
  317.     return 0;
  318. ctx_assert(execExpr != 0);
  319. exec->setExpr(i, execExpr);
  320.     }
  321.     // create the code
  322.     SqlSpec sqlSpec(sqlType(), SqlSpec::Physical);
  323.     Exec_expr_op::Code& code = *new Exec_expr_op::Code(m_op, sqlSpec);
  324.     exec->setCode(code);
  325.     m_exec = exec;
  326.     return exec;
  327. }
  329. void
  330. Plan_expr_op::print(Ctx& ctx)
  331. {
  332.     ctx.print(" [%s", m_op.name());
  333.     Plan_base* a[] = { m_expr[1], m_expr[2] };
  334.     printList(ctx, a, m_op.arity());
  335.     ctx.print("]");
  336. }
  338. bool
  339. Plan_expr_op::isEqual(const Plan_expr* expr) const
  340. {
  341.     ctx_assert(expr != 0);
  342.     if (expr->type() != Plan_expr::TypeOp)
  343. return false;
  344.     const Plan_expr_op* expr2 = static_cast<const Plan_expr_op*>(expr);
  345.     if (m_op.m_opcode != expr2->m_op.m_opcode)
  346. return false;
  347.     const unsigned arity = m_op.arity();
  348.     for (unsigned i = 1; i <= arity; i++) {
  349. ctx_assert(m_expr[i] != 0);
  350. if (! m_expr[i]->isEqual(expr2->m_expr[i]))
  351.     return false;
  352.     }
  353.     return true;
  354. }
  356. bool
  357. Plan_expr_op::isGroupBy(const Plan_expr_row* row) const
  358. {
  359.     if (isAnyEqual(row))
  360. return true;
  361.     const unsigned arity = m_op.arity();
  362.     for (unsigned i = 1; i <= arity; i++) {
  363. ctx_assert(m_expr[i] != 0);
  364. if (! m_expr[i]->isGroupBy(row))
  365.     return false;
  366.     }
  367.     return true;
  368. }
  370. // Code_expr_op
  372. Exec_expr_op::Code::~Code()
  373. {
  374. }
  376. Exec_expr_op::Data::~Data()
  377. {
  378. }
  380. Exec_expr_op::~Exec_expr_op()
  381. {
  382. }
  384. void
  385. Exec_expr_op::alloc(Ctx& ctx, Ctl& ctl)
  386. {
  387.     if (m_data != 0)
  388. return;
  389.     const Code& code = getCode();
  390.     // allocate subexpressions
  391.     unsigned arity = code.m_op.arity();
  392.     for (unsigned i = 1; i <= arity; i++) {
  393. ctx_assert(m_expr[i] != 0);
  394. m_expr[i]->alloc(ctx, ctl);
  395. if (! ctx.ok())
  396.     return;
  397.     }
  398.     SqlField sqlField(code.m_sqlSpec);
  399.     Data& data = *new Data(sqlField);
  400.     setData(data);
  401. }
  403. void
  404. Exec_expr_op::close(Ctx& ctx)
  405. {
  406.     const Code& code = getCode();
  407.     unsigned arity = code.m_op.arity();
  408.     for (unsigned i = 1; i <= arity; i++) {
  409. ctx_assert(m_expr[i] != 0);
  410. m_expr[i]->close(ctx);
  411.     }
  412.     Data& data = getData();
  413.     data.m_groupField.clear();
  414. }
  416. void
  417. Exec_expr_op::print(Ctx& ctx)
  418. {
  419.     const Code& code = getCode();
  420.     ctx.print(" [%s", code.m_op.name());
  421.     Exec_base* a[] = { m_expr[1], m_expr[2] };
  422.     printList(ctx, a, code.m_op.arity());
  423.     ctx.print("]");
  424. }