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

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

MySQL数据库

开发平台：

Visual C++

Code_comp_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 <dictionary/DictColumn.hpp>
  18. #include "Code_pred.hpp"
  19. #include "Code_comp_op.hpp"
  20. #include "Code_expr_conv.hpp"
  21. #include "Code_expr_column.hpp"
  22. #include "Code_table.hpp"
  23. #include "Code_root.hpp"
  25. // Comp_op
  27. const char*
  28. Comp_op::name() const
  29. {
  30.     switch (m_opcode) {
  31.     case Eq:
  32. return "=";
  33.     case Noteq:
  34. return "!=";
  35.     case Lt:
  36. return "<";
  37.     case Lteq:
  38. return "<=";
  39.     case Gt:
  40. return ">";
  41.     case Gteq:
  42. return ">=";
  43.     case Like:
  44. return "like";
  45.     case Notlike:
  46. return "not like";
  47.     case Isnull:
  48. return "is null";
  49.     case Isnotnull:
  50. return "is not null";
  51.     }
  52.     ctx_assert(false);
  53.     return "";
  54. }
  56. unsigned
  57. Comp_op::arity() const
  58. {
  59.     switch (m_opcode) {
  60.     case Eq:
  61.     case Noteq:
  62.     case Lt:
  63.     case Lteq:
  64.     case Gt:
  65.     case Gteq:
  66.     case Like:
  67.     case Notlike:
  68. return 2;
  69.     case Isnull:
  70.     case Isnotnull:
  71. return 1;
  72.     }
  73.     ctx_assert(false);
  74.     return 0;
  75. }
  77. // Plan_comp_op
  79. Plan_comp_op::~Plan_comp_op()
  80. {
  81. }
  83. Plan_base*
  84. Plan_comp_op::analyze(Ctx& ctx, Ctl& ctl)
  85. {
  86.     m_exec = 0;
  87.     const unsigned arity = m_op.arity();
  88.     // analyze operands
  89.     for (unsigned i = 1; i <= arity; i++) {
  90. ctx_assert(m_expr[i] != 0);
  91. m_expr[i]->analyze(ctx, ctl);
  92. if (! ctx.ok())
  93.     return 0;
  94.     }
  95.     // for each operand, find type to convert to
  96.     SqlType con[1 + 2];
  97.     if (arity == 1) {
  98. const SqlType& t1 = m_expr[1]->sqlType();
  99. switch (t1.type()) {
  100. case SqlType::Char:
  101. case SqlType::Varchar:
  102. case SqlType::Smallint:
  103. case SqlType::Integer:
  104. case SqlType::Bigint:
  105. case SqlType::Real:
  106. case SqlType::Double:
  107. case SqlType::Datetime:
  108. case SqlType::Null:
  109. case SqlType::Unbound:
  110.     con[1] = t1;
  111.     break;
  112. default:
  113.     break;
  114. }
  115. if (con[1].type() == SqlType::Undef) {
  116.     char b1[40];
  117.     t1.print(b1, sizeof(b1));
  118.     ctx.pushStatus(Error::Gen, "type mismatch in comparison: %s %s", b1, m_op.name());
  119.     return 0;
  120. }
  121.     } else if (arity == 2) {
  122. const SqlType& t1 = m_expr[1]->sqlType();
  123. const SqlType& t2 = m_expr[2]->sqlType();
  124. switch (t1.type()) {
  125. case SqlType::Char:
  126.     switch (t2.type()) {
  127.     case SqlType::Char:
  128.     case SqlType::Varchar:
  129.     case SqlType::Null:
  130. con[1] = t1;
  131. con[2] = t2;
  132. break;
  133.     case SqlType::Unbound:
  134. con[1] = con[2] = t2;
  135. break;
  136.     default:
  137. break;
  138.     }
  139.     break;
  140. case SqlType::Varchar:
  141.     switch (t2.type()) {
  142.     case SqlType::Char:
  143.     case SqlType::Varchar:
  144.     case SqlType::Null:
  145. con[1] = t1;
  146. con[2] = t2;
  147. break;
  148.     case SqlType::Unbound:
  149. con[1] = con[2] = t2;
  150. break;
  151.     default:
  152. break;
  153.     }
  154.     break;
  155. case SqlType::Smallint:
  156. case SqlType::Integer:
  157. case SqlType::Bigint:
  158.     switch (t2.type()) {
  159.     case SqlType::Smallint:
  160.     case SqlType::Integer:
  161.     case SqlType::Bigint:
  162. // conversion would mask primary key optimization
  163. con[1] = t1;
  164. con[2] = t2;
  165. break;
  166.     case SqlType::Real:
  167.     case SqlType::Double:
  168. con[1].setType(ctx, SqlType::Double);
  169. con[2] = con[1];
  170. break;
  171.     case SqlType::Null:
  172. con[1] = t1;
  173. con[2] = t2;
  174. break;
  175.     case SqlType::Unbound:
  176. con[1] = con[2] = t2;
  177. break;
  178.     default:
  179. break;
  180.     }
  181.     break;
  182. case SqlType::Real:
  183. case SqlType::Double:
  184.     switch (t2.type()) {
  185.     case SqlType::Smallint:
  186.     case SqlType::Integer:
  187.     case SqlType::Bigint:
  188.     case SqlType::Real:
  189.     case SqlType::Double:
  190. con[1].setType(ctx, SqlType::Double);
  191. con[2] = con[1];
  192. break;
  193.     case SqlType::Null:
  194. con[1] = t1;
  195. con[2] = t2;
  196. break;
  197.     case SqlType::Unbound:
  198. con[1] = con[2] = t2;
  199. break;
  200.     default:
  201. break;
  202.     }
  203.     break;
  204. case SqlType::Datetime:
  205.     switch (t2.type()) {
  206.     case SqlType::Datetime:
  207. con[1] = t1;
  208. con[2] = t2;
  209. break;
  210.     case SqlType::Unbound:
  211. con[1] = con[2] = t2;
  212. break;
  213.     default:
  214. break;
  215.     }
  216.     break;
  217. case SqlType::Null:
  218.     switch (t2.type()) {
  219.     case SqlType::Char:
  220.     case SqlType::Varchar:
  221.     case SqlType::Smallint:
  222.     case SqlType::Integer:
  223.     case SqlType::Bigint:
  224.     case SqlType::Real:
  225.     case SqlType::Double:
  226.     case SqlType::Datetime:
  227. con[1] = t1;
  228. con[2] = t2;
  229. break;
  230.     case SqlType::Unbound:
  231. con[1] = con[2] = t2;
  232. break;
  233.     default:
  234. break;
  235.     }
  236.     break;
  237. case SqlType::Unbound:
  238.     con[1] = con[2] = t1;
  239.     break;
  240. default:
  241.     break;
  242. }
  243. if (con[1].type() == SqlType::Undef || con[2].type() == SqlType::Undef) {
  244.     char b1[40], b2[40];
  245.     t1.print(b1, sizeof(b1));
  246.     t2.print(b2, sizeof(b2));
  247.     ctx.pushStatus(Error::Gen, "type mismatch in comparison: %s %s %s", b1, m_op.name(), b2);
  248.     return 0;
  249. }
  250.     } else {
  251. ctx_assert(false);
  252. return 0;
  253.     }
  254.     if (! ctx.ok())
  255. return 0;
  256.     // insert required conversions
  257.     for (unsigned i = 1; i <= arity; i++) {
  258. if (con[i].type() == SqlType::Unbound) {
  259.     continue;
  260. }
  261. Plan_expr_conv* exprConv = new Plan_expr_conv(m_root, con[i]);
  262. m_root->saveNode(exprConv);
  263. exprConv->setExpr(m_expr[i]);
  264. m_expr[i] = static_cast<Plan_expr*>(exprConv->analyze(ctx, ctl));
  265. if (! ctx.ok())
  266.     return 0;
  267. ctx_assert(m_expr[i] != 0);
  268.     }
  269.     // look for column=expr
  270.     if (ctl.m_topand && m_op.m_opcode == Comp_op::Eq) {
  271. ctx_assert(arity == 2);
  272. for (unsigned i = 1, j = 2; i <= 2; i++, j--) {
  273.     if (m_expr[i]->type() != Plan_expr::TypeColumn)
  274. continue;
  275.     Plan_expr_column* column = static_cast<Plan_expr_column*>(m_expr[i]);
  276.     if (! column->resolveEq(ctx, m_expr[j]))
  277. ctl.m_extra = true;
  278. }
  279.     } else {
  280. ctl.m_extra = true;
  281.     }
  282.     // save top level comparison on list
  283.     if (ctl.m_topand) {
  284. ctl.m_topcomp.push_back(this);
  285.     }
  286.     // table dependencies are union from operands
  287.     m_tableSet.clear();
  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 of tables for which interpreter cannot be used
  293.     m_noInterp.clear();
  294.     // convenient
  295. #undef ustype
  296. #define ustype(b, n) (((b) ? 1 : 0) * 100 + (n))
  297.     if (arity == 1) {
  298. for (unsigned i = 1; i <= 1; i++) {
  299.     const SqlType t1 = m_expr[i]->sqlType();
  300.     switch (m_op.m_opcode) {
  301.     case Comp_op::Isnull:
  302.     case Comp_op::Isnotnull:
  303. if (m_expr[i]->type() == Plan_expr::TypeColumn) {
  304.     switch (ustype(t1.unSigned(), t1.type())) {
  305.     // all types accepted now
  306.     default:
  307. {
  308.     Plan_expr_column* column = static_cast<Plan_expr_column*>(m_expr[i]);
  309.     ctx_assert(column->m_resTable != 0);
  310.     m_interpColumn[i] = column;
  311.     continue; // ok
  312. }
  313. break;
  314.     }
  315. }
  316. break;
  317.     default:
  318. break;
  319.     }
  320.     const TableSet& ts = m_expr[i]->tableSet();
  321.     m_noInterp.insert(ts.begin(), ts.end());
  322. }
  323.     } else if (arity == 2) {
  324. for (unsigned i = 1, j = 2; i <= 2; i++, j--) {
  325.     const SqlType t1 = m_expr[i]->sqlType();
  326.     switch (m_op.m_opcode) {
  327.     case Comp_op::Like:
  328.     case Comp_op::Notlike:
  329. if (i == 2) // col like val but not val like col
  330.     break;
  331. /*FALLTHRU*/
  332.     case Comp_op::Eq:
  333.     case Comp_op::Noteq:
  334.     case Comp_op::Lt:
  335.     case Comp_op::Lteq:
  336.     case Comp_op::Gt:
  337.     case Comp_op::Gteq:
  338. if (m_expr[i]->type() == Plan_expr::TypeColumn) {
  339.     switch (ustype(t1.unSigned(), t1.type())) {
  340.     case ustype(false, SqlType::Char):
  341.     case ustype(false, SqlType::Varchar):
  342.     case ustype(true, SqlType::Smallint):
  343.     case ustype(true, SqlType::Integer):
  344.     case ustype(true, SqlType::Bigint):
  345. {
  346.     Plan_expr_column* column = static_cast<Plan_expr_column*>(m_expr[i]);
  347.     ctx_assert(column->m_resTable != 0);
  348.     const TableSet& ts = m_expr[j]->tableSet();
  349.     if (ts.find(column->m_resTable) == ts.end()) {
  350. // candidate for column=const
  351. m_interpColumn[i] = column;
  352. continue; // ok
  353.     }
  354. }
  355. break;
  356.     default:
  357. break;
  358.     }
  359. }
  360. break;
  361.     default:
  362. break;
  363.     }
  364.     const TableSet& ts = m_expr[i]->tableSet();
  365.     m_noInterp.insert(ts.begin(), ts.end());
  366. }
  367.     } else {
  368. ctx_assert(false);
  369. return 0;
  370.     }
  371. #undef ustype
  372.     return this;
  373. }
  375. Exec_base*
  376. Plan_comp_op::codegen(Ctx& ctx, Ctl& ctl)
  377. {
  378.     if (m_exec != 0)
  379. return m_exec;
  380.     const unsigned arity = m_op.arity();
  381.     Exec_comp_op* exec = new Exec_comp_op(ctl.m_execRoot);
  382.     ctl.m_execRoot->saveNode(exec);
  383.     // create code for operands
  384.     for (unsigned i = 1; i <= arity; i++) {
  385. ctx_assert(m_expr[i] != 0);
  386. Exec_expr* execExpr = static_cast<Exec_expr*>(m_expr[i]->codegen(ctx, ctl));
  387. if (! ctx.ok())
  388.     return 0;
  389. ctx_assert(execExpr != 0);
  390. exec->setExpr(i, execExpr);
  391.     }
  392.     // create the code
  393.     Exec_comp_op::Code& code = *new Exec_comp_op::Code(m_op);
  394.     // interpreted column=const
  395.     if (! ctl.m_having) {
  396. ctx_assert(ctl.m_topTable != 0);
  397. for (unsigned i = 1; i <= arity; i++) {
  398.     Plan_expr_column* column = m_interpColumn[i];
  399.     if (column == 0)
  400. continue;
  401.     ctx_assert(column->m_resTable != 0);
  402.     if (column->m_resTable != ctl.m_topTable)
  403. continue;
  404.     ctx_assert(code.m_interpColumn == 0);
  405.     code.m_interpColumn = i;
  406.     code.m_interpAttrId = column->dictColumn().getAttrId();
  407.     ctx_log2(("can use interpreter on %s", column->getPrintName()));
  408. }
  409.     }
  410.     exec->setCode(code);
  411.     m_exec = exec;
  412.     return exec;
  413. }
  415. void
  416. Plan_comp_op::print(Ctx& ctx)
  417. {
  418.     ctx.print(" [%s", m_op.name());
  419.     Plan_base* a[] = { m_expr[1], m_expr[2] };
  420.     printList(ctx, a, m_op.arity());
  421.     ctx.print("]");
  422. }
  424. bool
  425. Plan_comp_op::isGroupBy(const Plan_expr_row* row) const
  426. {
  427.     const unsigned arity = m_op.arity();
  428.     for (unsigned i = 1; i <= arity; i++) {
  429. ctx_assert(m_expr[i] != 0);
  430. if (! m_expr[i]->isGroupBy(row))
  431.     return false;
  432.     }
  433.     return true;
  434. }
  436. // Code_comp_op
  438. Exec_comp_op::Code::~Code()
  439. {
  440. }
  442. Exec_comp_op::Data::~Data()
  443. {
  444. }
  446. Exec_comp_op::~Exec_comp_op()
  447. {
  448. }
  450. void
  451. Exec_comp_op::alloc(Ctx& ctx, Ctl& ctl)
  452. {
  453.     const Code& code = getCode();
  454.     // allocate subexpressions
  455.     unsigned arity = code.m_op.arity();
  456.     for (unsigned i = 1; i <= arity; i++) {
  457. ctx_assert(m_expr[i] != 0);
  458. m_expr[i]->alloc(ctx, ctl);
  459. if (! ctx.ok())
  460.     return;
  461.     }
  462.     Data& data = *new Data;
  463.     setData(data);
  464. }
  466. void
  467. Exec_comp_op::close(Ctx& ctx)
  468. {
  469.     const Code& code = getCode();
  470.     unsigned arity = code.m_op.arity();
  471.     for (unsigned i = 1; i <= arity; i++) {
  472. ctx_assert(m_expr[i] != 0);
  473. m_expr[i]->close(ctx);
  474.     }
  475. }
  477. void
  478. Exec_comp_op::print(Ctx& ctx)
  479. {
  480.     const Code& code = getCode();
  481.     ctx.print(" [%s", code.m_op.name());
  482.     Exec_base* a[] = { m_expr[1], m_expr[2] };
  483.     printList(ctx, a, code.m_op.arity());
  484.     ctx.print("]");
  485. }