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

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

MySQL数据库

开发平台：

Visual C++

Exec_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 <NdbScanFilter.hpp>
  18. #include <NdbSqlUtil.hpp>
  19. #include <codegen/Code_comp_op.hpp>
  21. void
  22. Exec_comp_op::execInterp(Ctx& ctx, Ctl& ctl)
  23. {
  24.     const Code& code = getCode();
  25.     const unsigned arity = code.m_op.arity();
  26.     const Comp_op::Opcode opcode = code.m_op.m_opcode;
  27.     Data& data = getData();
  28.     ctx_assert(ctl.m_scanFilter != 0);
  29.     NdbScanFilter& scanFilter = *ctl.m_scanFilter;
  30.     if (code.m_interpColumn == 0) {
  31. // args are constant on this level so evaluate entire predicate
  32. evaluate(ctx, ctl);
  33. if (! ctx.ok())
  34.     return;
  35. if (data.m_value == Pred_value_true)
  36.     scanFilter.istrue();
  37. else
  38.     scanFilter.isfalse();
  39. return;
  40.     }
  41.     const NdbAttrId interpAttrId = code.m_interpAttrId;
  42.     if (arity == 1) {
  43. ctx_assert(m_expr[1] != 0);
  44. const SqlType& t1 = m_expr[1]->getCode().sqlSpec().sqlType();
  45. const SqlField& f1 = m_expr[1]->getData().sqlField();
  46. switch (code.m_op.m_opcode) {
  47. case Comp_op::Isnull:
  48.     scanFilter.isnull(interpAttrId);
  49.     break;
  50. case Comp_op::Isnotnull:
  51.     scanFilter.isnotnull(interpAttrId);
  52.     break;
  53. default:
  54.     ctx_assert(false);
  55.     break;
  56. }
  57.     } else if (arity == 2) {
  58. ctx_assert(m_expr[1] != 0 && m_expr[2] != 0);
  59. // one is column and the other is constant at this level
  60. ctx_assert(code.m_interpColumn == 1 || code.m_interpColumn == 2);
  61. const unsigned i = code.m_interpColumn;
  62. const unsigned j = 3 - i;
  63. // evaluate the constant
  64. m_expr[j]->evaluate(ctx, ctl);
  65. if (! ctx.ok())
  66.     return;
  67. const SqlType& t1 = m_expr[i]->getCode().sqlSpec().sqlType();
  68. const SqlField& f1 = m_expr[i]->getData().sqlField();
  69. const SqlType& t2 = m_expr[j]->getCode().sqlSpec().sqlType();
  70. const SqlField& f2 = m_expr[j]->getData().sqlField();
  71. // handle null constant
  72. if (f2.sqlNull()) {
  73.     scanFilter.isfalse();
  74.     return;
  75. }
  76. // handle null in interpreter
  77. scanFilter.begin(NdbScanFilter::AND);
  78. scanFilter.isnotnull(interpAttrId);
  79. if (t1.type() == SqlType::Char || t1.type() == SqlType::Varchar) {
  80.     const char* v2 = 0;
  81.     unsigned n2 = 0;
  82.     bool nopad = false;
  83.     if (t1.type() == SqlType::Char && t2.type() == SqlType::Char) {
  84. v2 = reinterpret_cast<const char*>(f2.sqlChar());
  85. n2 = t2.length();
  86. nopad = false;
  87.     } else if (t1.type() == SqlType::Char && t2.type() == SqlType::Varchar) {
  88. v2 = reinterpret_cast<const char*>(f2.sqlVarchar(&n2));
  89. nopad = true;
  90.     } else if (t1.type() == SqlType::Varchar && t2.type() == SqlType::Char) {
  91. v2 = reinterpret_cast<const char*>(f2.sqlChar());
  92. n2 = t2.length();
  93. nopad = true;
  94.     } else if (t1.type() == SqlType::Varchar && t2.type() == SqlType::Varchar) {
  95. v2 = reinterpret_cast<const char*>(f2.sqlVarchar(&n2));
  96. nopad = true;
  97.     } else {
  98. ctx_assert(false);
  99.     }
  100.     switch (opcode) {
  101.     case Comp_op::Eq:
  102. scanFilter.eq(interpAttrId, v2, n2, nopad);
  103. break;
  104.     case Comp_op::Noteq:
  105. scanFilter.ne(interpAttrId, v2, n2, nopad);
  106. break;
  107.     case Comp_op::Lt:
  108. if (i == 1) {
  109.     scanFilter.lt(interpAttrId, v2, n2, nopad);
  110. } else {
  111.     scanFilter.gt(interpAttrId, v2, n2, nopad);
  112. }
  113. break;
  114.     case Comp_op::Lteq:
  115. if (i == 1) {
  116.     scanFilter.le(interpAttrId, v2, n2, nopad);
  117. } else {
  118.     scanFilter.ge(interpAttrId, v2, n2, nopad);
  119. }
  120. break;
  121.     case Comp_op::Gt:
  122. if (i == 1) {
  123.     scanFilter.gt(interpAttrId, v2, n2, nopad);
  124. } else {
  125.     scanFilter.lt(interpAttrId, v2, n2, nopad);
  126. }
  127. break;
  128.     case Comp_op::Gteq:
  129. if (i == 1) {
  130.     scanFilter.ge(interpAttrId, v2, n2, nopad);
  131. } else {
  132.     scanFilter.le(interpAttrId, v2, n2, nopad);
  133. }
  134. break;
  135.     case Comp_op::Like:
  136. scanFilter.like(interpAttrId, v2, n2, nopad);
  137. break;
  138.     case Comp_op::Notlike:
  139. scanFilter.notlike(interpAttrId, v2, n2, nopad);
  140. break;
  141.     default:
  142. ctx_assert(false);
  143. break;
  144.     }
  145. } else if (t1.type() == SqlType::Smallint || t1.type() == SqlType::Integer || t1.type() == SqlType::Bigint) {
  146.     ctx_assert(t1.unSigned());
  147.     bool s2 = ! t2.unSigned();
  148.     SqlBigint v2;
  149.     SqlUbigint uv2;
  150.     if (s2) {
  151. v2 =
  152.     t2.type() == SqlType::Smallint ? f2.sqlSmallint() :
  153.     t2.type() == SqlType::Integer ? f2.sqlInteger() : f2.sqlBigint();
  154. uv2 = v2;
  155.     } else {
  156. uv2 =
  157.     t2.type() == SqlType::Smallint ? (SqlUsmallint)f2.sqlSmallint() :
  158.     t2.type() == SqlType::Integer ? (SqlUinteger)f2.sqlInteger() : (SqlUbigint)f2.sqlBigint();
  159. v2 = uv2;
  160.     }
  161.     switch (code.m_op.m_opcode) {
  162.     case Comp_op::Eq:
  163. if (s2 && v2 < 0)
  164.     scanFilter.isfalse();
  165. else
  166.     scanFilter.eq(interpAttrId, uv2);
  167. break;
  168.     case Comp_op::Noteq:
  169. if (s2 && v2 < 0)
  170.     scanFilter.istrue();
  171. else
  172.     scanFilter.ne(interpAttrId, uv2);
  173. break;
  174.     case Comp_op::Lt:
  175. if (i == 1) {
  176.     if (s2 && v2 < 0)
  177. scanFilter.isfalse();
  178.     else
  179. scanFilter.lt(interpAttrId, uv2);
  180. } else {
  181.     if (s2 && v2 < 0)
  182. scanFilter.istrue();
  183.     else
  184. scanFilter.gt(interpAttrId, uv2);
  185. }
  186. break;
  187.     case Comp_op::Lteq:
  188. if (i == 1) {
  189.     if (s2 && v2 < 0)
  190. scanFilter.isfalse();
  191.     else
  192. scanFilter.le(interpAttrId, uv2);
  193. } else {
  194.     if (s2 && v2 < 0)
  195. scanFilter.istrue();
  196.     else
  197. scanFilter.ge(interpAttrId, uv2);
  198. }
  199. break;
  200.     case Comp_op::Gt:
  201. if (i == 1) {
  202.     if (s2 && v2 < 0)
  203. scanFilter.istrue();
  204.     else
  205. scanFilter.gt(interpAttrId, uv2);
  206. } else {
  207.     if (s2 && v2 < 0)
  208. scanFilter.isfalse();
  209.     else
  210. scanFilter.lt(interpAttrId, uv2);
  211. }
  212. break;
  213.     case Comp_op::Gteq:
  214. if (i == 1) {
  215.     if (s2 && v2 < 0)
  216. scanFilter.istrue();
  217.     else
  218. scanFilter.ge(interpAttrId, uv2);
  219. } else {
  220.     if (s2 && v2 < 0)
  221. scanFilter.isfalse();
  222.     else
  223. scanFilter.le(interpAttrId, uv2);
  224. }
  225. break;
  226.     default:
  227. ctx_assert(false);
  228. break;
  229.     }
  230. } else {
  231.     ctx_assert(false);
  232. }
  233. // end null guard
  234. scanFilter.end();
  235.     } else {
  236. ctx_assert(false);
  237.     }
  238. }
  240. static bool
  241. do_sqlchar_comp(Comp_op::Opcode opcode, const SqlChar* s1, unsigned n1, const SqlChar* s2, unsigned n2, bool padded)
  242. {
  243.     int ret = NdbSqlUtil::char_compare(reinterpret_cast<const char*>(s1), n1, reinterpret_cast<const char *>(s2), n2, padded);
  244.     switch (opcode) {
  245.     case Comp_op::Eq:
  246. return ret == 0;
  247.     case Comp_op::Noteq:
  248. return ret != 0;
  249.     case Comp_op::Lt:
  250. return ret < 0;
  251.     case Comp_op::Lteq:
  252. return ret <= 0;
  253.     case Comp_op::Gt:
  254. return ret > 0;
  255.     case Comp_op::Gteq:
  256. return ret >= 0;
  257.     default:
  258. break;
  259.     }
  260.     ctx_assert(false);
  261.     return false;
  262. }
  264. static bool
  265. do_sqlchar_like(const SqlChar* s1, unsigned n1, const SqlChar* s2, unsigned n2, bool padded)
  266. {
  267.     bool ret = NdbSqlUtil::char_like(reinterpret_cast<const char*>(s1), n1, reinterpret_cast<const char *>(s2), n2, padded);
  268.     return ret;
  269. }
  271. static bool
  272. do_datetime_comp(Comp_op::Opcode opcode, SqlDatetime v1, SqlDatetime v2)
  273. {
  274.     int k = v1.less(v2) ? -1 : v2.less(v1) ? 1 : 0;
  275.     switch (opcode) {
  276.     case Comp_op::Eq:
  277. return k == 0;
  278.     case Comp_op::Noteq:
  279. return k != 0;
  280.     case Comp_op::Lt:
  281. return k < 0;
  282.     case Comp_op::Lteq:
  283. return k <= 0;
  284.     case Comp_op::Gt:
  285. return k > 0;
  286.     case Comp_op::Gteq:
  287. return k >= 0;
  288.     default:
  289. break;
  290.     }
  291.     ctx_assert(false);
  292.     return false;
  293. }
  295. void
  296. Exec_comp_op::evaluate(Ctx& ctx, Ctl& ctl)
  297. {
  298.     const Code& code = getCode();
  299.     const unsigned arity = code.m_op.arity();
  300.     const Comp_op::Opcode opcode = code.m_op.m_opcode;
  301.     Data& data = getData();
  302.     Pred_value v = Pred_value_unknown;
  303.     if (arity == 1) {
  304. // evaluate sub-expression
  305. ctx_assert(m_expr[1] != 0);
  306. m_expr[1]->evaluate(ctx, ctl);
  307. if (! ctx.ok())
  308.     return;
  309. if (ctl.m_postEval)
  310.     return;
  311. // get type and value
  312. const SqlType& t1 = m_expr[1]->getCode().sqlSpec().sqlType();
  313. const SqlField& f1 = ctl.m_groupIndex == 0 ? m_expr[1]->getData().sqlField() : m_expr[1]->getData().groupField(ctl.m_groupIndex);
  314. switch (code.m_op.m_opcode) {
  315. case Comp_op::Isnull:
  316.     v = f1.sqlNull() ? Pred_value_true : Pred_value_false;
  317.     break;
  318. case Comp_op::Isnotnull:
  319.     v = f1.sqlNull() ? Pred_value_false : Pred_value_true;
  320.     break;
  321. default:
  322.     ctx_assert(false);
  323.     break;
  324. }
  325.     } else if (arity == 2) {
  326. // evaluate sub-expressions
  327. ctx_assert(m_expr[1] != 0 && m_expr[2] != 0);
  328. m_expr[1]->evaluate(ctx, ctl);
  329. if (! ctx.ok())
  330.     return;
  331. m_expr[2]->evaluate(ctx, ctl);
  332. if (! ctx.ok())
  333.     return;
  334. if (ctl.m_postEval)
  335.     return;
  336. // get types and values
  337. const SqlType& t1 = m_expr[1]->getCode().sqlSpec().sqlType();
  338. const SqlType& t2 = m_expr[2]->getCode().sqlSpec().sqlType();
  339. const SqlField& f1 = ctl.m_groupIndex == 0 ? m_expr[1]->getData().sqlField() : m_expr[1]->getData().groupField(ctl.m_groupIndex);
  340. const SqlField& f2 = ctl.m_groupIndex == 0 ? m_expr[2]->getData().sqlField() : m_expr[2]->getData().groupField(ctl.m_groupIndex);
  341. // handle null
  342. if (f1.sqlNull() || f2.sqlNull()) {
  343.     v = Pred_value_unknown;
  344. } else if (t1.type() == SqlType::Char) {
  345.     const SqlChar* v1 = f1.sqlChar();
  346.     unsigned n1 = t1.length();
  347.     if (t2.type() == SqlType::Char) {
  348. unsigned n2 = t2.length();
  349. const SqlChar* v2 = f2.sqlChar();
  350. bool b;
  351. switch (opcode) {
  352. case Comp_op::Like:
  353.     b = do_sqlchar_like(v1, n1, v2, n2, true);
  354.     break;
  355. case Comp_op::Notlike:
  356.     b = ! do_sqlchar_like(v1, n1, v2, n2, true);
  357.     break;
  358. default:
  359.     b = do_sqlchar_comp(opcode, v1, n1, v2, n2, true);
  360.     break;
  361. }
  362. v = b ? Pred_value_true : Pred_value_false;
  363.     } else if (t2.type() == SqlType::Varchar) {
  364. unsigned n2 = 0;
  365. const SqlChar* v2 = f2.sqlVarchar(&n2);
  366. bool b;
  367. switch (opcode) {
  368. case Comp_op::Like:
  369.     b = do_sqlchar_like(v1, n1, v2, n2, true);
  370.     break;
  371. case Comp_op::Notlike:
  372.     b = ! do_sqlchar_like(v1, n1, v2, n2, true);
  373.     break;
  374. default:
  375.     b = do_sqlchar_comp(opcode, v1, n1, v2, n2, false);
  376.     break;
  377. }
  378. v = b ? Pred_value_true : Pred_value_false;
  379.     } else {
  380. ctx_assert(false);
  381.     }
  382. } else if (t1.type() == SqlType::Varchar) {
  383.     unsigned n1 = 0;
  384.     const SqlChar* v1 = f1.sqlVarchar(&n1);
  385.     if (t2.type() == SqlType::Char) {
  386. unsigned n2 = t2.length();
  387. const SqlChar* v2 = f2.sqlChar();
  388. bool b;
  389. switch (opcode) {
  390. case Comp_op::Like:
  391.     b = do_sqlchar_like(v1, n1, v2, n2, false);
  392.     break;
  393. case Comp_op::Notlike:
  394.     b = ! do_sqlchar_like(v1, n1, v2, n2, false);
  395.     break;
  396. default:
  397.     b = do_sqlchar_comp(opcode, v1, n1, v2, n2, false);
  398.     break;
  399. }
  400. v = b ? Pred_value_true : Pred_value_false;
  401.     } else if (t2.type() == SqlType::Varchar) {
  402. unsigned n2 = 0;
  403. const SqlChar* v2 = f2.sqlVarchar(&n2);
  404. bool b;
  405. switch (opcode) {
  406. case Comp_op::Like:
  407.     b = do_sqlchar_like(v1, n1, v2, n2, false);
  408.     break;
  409. case Comp_op::Notlike:
  410.     b = ! do_sqlchar_like(v1, n1, v2, n2, false);
  411.     break;
  412. default:
  413.     b = do_sqlchar_comp(opcode, v1, n1, v2, n2, false);
  414.     break;
  415. }
  416. v = b ? Pred_value_true : Pred_value_false;
  417.     } else {
  418. ctx_assert(false);
  419.     }
  420. } else if (t1.type() == SqlType::Smallint || t1.type() == SqlType::Integer || t1.type() == SqlType::Bigint) {
  421.     // convert to bigint
  422.     bool s1 = ! t1.unSigned();
  423.     bool s2 = ! t2.unSigned();
  424.     SqlBigint v1, v2;
  425.     SqlUbigint uv1, uv2;
  426.     if (s1) {
  427. v1 =
  428.     t1.type() == SqlType::Smallint ? f1.sqlSmallint() :
  429.     t1.type() == SqlType::Integer ? f1.sqlInteger() : f1.sqlBigint();
  430. uv1 = v1;
  431.     } else {
  432. uv1 =
  433.     t1.type() == SqlType::Smallint ? (SqlUsmallint)f1.sqlSmallint() :
  434.     t1.type() == SqlType::Integer ? (SqlUinteger)f1.sqlInteger() : (SqlUbigint)f1.sqlBigint();
  435. v1 = uv1;
  436.     }
  437.     if (s2) {
  438. v2 =
  439.     t2.type() == SqlType::Smallint ? f2.sqlSmallint() :
  440.     t2.type() == SqlType::Integer ? f2.sqlInteger() : f2.sqlBigint();
  441. uv2 = v2;
  442.     } else {
  443. uv2 =
  444.     t2.type() == SqlType::Smallint ? (SqlUsmallint)f2.sqlSmallint() :
  445.     t2.type() == SqlType::Integer ? (SqlUinteger)f2.sqlInteger() : (SqlUbigint)f2.sqlBigint();
  446. v2 = uv2;
  447.     }
  448.     bool b;
  449.     switch (opcode) {
  450.     case Comp_op::Eq:
  451. b = s1 && s2 ? (v1 == v2) : s1 ? (v1 < 0 ? false : uv1 == uv2) : s2 ? (v2 < 0 ? false : uv1 == uv2) : (uv1 == uv2);
  452. break;
  453.     case Comp_op::Noteq:
  454. b = s1 && s2 ? (v1 == v2) : s1 ? (v1 < 0 ? true : uv1 != uv2) : s2 ? (v2 < 0 ? true : uv1 != uv2) : (uv1 != uv2);
  455. break;
  456.     case Comp_op::Lt:
  457. b = s1 && s2 ? (v1 < v2) : s1 ? (v1 < 0 ? true : uv1 < uv2) : s2 ? (v2 < 0 ? false : uv1 < uv2) : (uv1 < uv2);
  458. break;
  459.     case Comp_op::Lteq:
  460. b = s1 && s2 ? (v1 <= v2) : s1 ? (v1 < 0 ? true : uv1 <= uv2) : s2 ? (v2 < 0 ? false : uv1 <= uv2) : (uv1 <= uv2);
  461. break;
  462.     case Comp_op::Gt:
  463. b = s1 && s2 ? (v1 > v2) : s1 ? (v1 < 0 ? false : uv1 > uv2) : s2 ? (v2 < 0 ? true : uv1 > uv2) : (uv1 > uv2);
  464. break;
  465.     case Comp_op::Gteq:
  466. b = s1 && s2 ? (v1 >= v2) : s1 ? (v1 < 0 ? false : uv1 >= uv2) : s2 ? (v2 < 0 ? true : uv1 >= uv2) : (uv1 >= uv2);
  467. break;
  468.     default:
  469. ctx_assert(false);
  470. break;
  471.     }
  472.     v = b ? Pred_value_true : Pred_value_false;
  473. } else if (t1.type() == SqlType::Double) {
  474.     SqlDouble v1 = f1.sqlDouble();
  475.     SqlDouble v2 = f2.sqlDouble();
  476.     bool b;
  477.     switch (opcode) {
  478.     case Comp_op::Eq:
  479. b = (v1 == v2);
  480. break;
  481.     case Comp_op::Noteq:
  482. b = (v1 != v2);
  483. break;
  484.     case Comp_op::Lt:
  485. b = (v1 < v2);
  486. break;
  487.     case Comp_op::Lteq:
  488. b = (v1 <= v2);
  489. break;
  490.     case Comp_op::Gt:
  491. b = (v1 > v2);
  492. break;
  493.     case Comp_op::Gteq:
  494. b = (v1 >= v2);
  495. break;
  496.     default:
  497. ctx_assert(false);
  498. break;
  499.     }
  500.     v = b ? Pred_value_true : Pred_value_false;
  501. } else if (t1.type() == SqlType::Datetime) {
  502.     SqlDatetime v1 = f1.sqlDatetime();
  503.     SqlDatetime v2 = f2.sqlDatetime();
  504.     bool b;
  505.     b = do_datetime_comp(opcode, v1, v2);
  506.     v = b ? Pred_value_true : Pred_value_false;
  507. } else {
  508.     ctx_assert(false);
  509. }
  510.     } else {
  511. ctx_assert(false);
  512.     }
  513.     // set result
  514.     if (ctl.m_groupIndex == 0)
  515. data.m_value = v;
  516.     else
  517. data.groupValue(ctl.m_groupIndex, ctl.m_groupInit) = v;
  518. }