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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
eval0eval.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：15k
源码类别：

MySQL数据库

开发平台：

Visual C++

eval0eval.c：源码内容
  1. /******************************************************
  2. SQL evaluator: evaluates simple data structures, like expressions, in
  3. a query graph
  5. (c) 1997 Innobase Oy
  7. Created 12/29/1997 Heikki Tuuri
  8. *******************************************************/
  10. #include "eval0eval.h"
  12. #ifdef UNIV_NONINL
  13. #include "eval0eval.ic"
  14. #endif
  16. #include "data0data.h"
  17. #include "row0sel.h"
  19. /* The RND function seed */
  20. ulint eval_rnd  = 128367121;
  22. /* Dummy adress used when we should allocate a buffer of size 0 in
  23. the function below */
  25. byte eval_dummy;
  27. /*********************************************************************
  28. Allocate a buffer from global dynamic memory for a value of a que_node.
  29. NOTE that this memory must be explicitly freed when the query graph is
  30. freed. If the node already has an allocated buffer, that buffer is freed
  31. here. NOTE that this is the only function where dynamic memory should be
  32. allocated for a query node val field. */
  34. byte*
  35. eval_node_alloc_val_buf(
  36. /*====================*/
  37. /* out: pointer to allocated buffer */
  38. que_node_t* node, /* in: query graph node; sets the val field
  39. data field to point to the new buffer, and
  40. len field equal to size */
  41. ulint size) /* in: buffer size */
  42. {
  43. dfield_t* dfield;
  44. byte* data;
  46. ut_ad(que_node_get_type(node) == QUE_NODE_SYMBOL
  47.       || que_node_get_type(node) == QUE_NODE_FUNC);
  49. dfield = que_node_get_val(node);
  51. data = dfield_get_data(dfield);
  53. if (data && data != &eval_dummy) {
  54. mem_free(data);
  55. }
  57. if (size == 0) {
  58. data = &eval_dummy;
  59. } else {
  60. data = mem_alloc(size);
  61. }
  63. que_node_set_val_buf_size(node, size);
  65. dfield_set_data(dfield, data, size);
  67. return(data);
  68. }
  70. /*********************************************************************
  71. Free the buffer from global dynamic memory for a value of a que_node,
  72. if it has been allocated in the above function. The freeing for pushed
  73. column values is done in sel_col_prefetch_buf_free. */
  75. void
  76. eval_node_free_val_buf(
  77. /*===================*/
  78. que_node_t* node) /* in: query graph node */
  79. {
  80. dfield_t* dfield;
  81. byte* data;
  83. ut_ad(que_node_get_type(node) == QUE_NODE_SYMBOL
  84.       || que_node_get_type(node) == QUE_NODE_FUNC);
  86. dfield = que_node_get_val(node);
  88. data = dfield_get_data(dfield);
  90. if (que_node_get_val_buf_size(node) > 0) {
  91. ut_a(data);
  93. mem_free(data);
  94. }
  95. }
  97. /*********************************************************************
  98. Evaluates a comparison node. */
  100. ibool
  101. eval_cmp(
  102. /*=====*/
  103. /* out: the result of the comparison */
  104. func_node_t* cmp_node) /* in: comparison node */
  105. {
  106. que_node_t* arg1;
  107. que_node_t* arg2;
  108. int res;
  109. ibool val;
  110. int func;
  112. ut_ad(que_node_get_type(cmp_node) == QUE_NODE_FUNC);
  114. arg1 = cmp_node->args;
  115. arg2 = que_node_get_next(arg1);
  117. res = cmp_dfield_dfield(que_node_get_val(arg1),
  118. que_node_get_val(arg2));
  119. val = TRUE;
  121. func = cmp_node->func;
  123. if (func == '=') {
  124. if (res != 0) {
  125. val = FALSE;
  126. }
  127. } else if (func == '<') {
  128. if (res != -1) {
  129. val = FALSE;
  130. }
  131. } else if (func == PARS_LE_TOKEN) {
  132. if (res == 1) {
  133. val = FALSE;
  134. }
  135. } else if (func == PARS_NE_TOKEN) {
  136. if (res == 0) {
  137. val = FALSE;
  138. }
  139. } else if (func == PARS_GE_TOKEN) {
  140. if (res == -1) {
  141. val = FALSE;
  142. }
  143. } else {
  144. ut_ad(func == '>');
  146. if (res != 1) {
  147. val = FALSE;
  148. }
  149. }
  151. eval_node_set_ibool_val(cmp_node, val);
  153. return(val);
  154. }
  156. /*********************************************************************
  157. Evaluates a logical operation node. */
  158. UNIV_INLINE
  159. void
  160. eval_logical(
  161. /*=========*/
  162. func_node_t* logical_node) /* in: logical operation node */
  163. {
  164. que_node_t* arg1;
  165. que_node_t* arg2;
  166. ibool val1;
  167. ibool val2;
  168. ibool val;
  169. int func;
  171. ut_ad(que_node_get_type(logical_node) == QUE_NODE_FUNC);
  173. arg1 = logical_node->args;
  174. arg2 = que_node_get_next(arg1); /* arg2 is NULL if func is 'NOT' */
  176. val1 = eval_node_get_ibool_val(arg1);
  178. if (arg2) {
  179. val2 = eval_node_get_ibool_val(arg2);
  180. }
  182. func = logical_node->func;
  184. if (func == PARS_AND_TOKEN) {
  185. val = val1 & val2;
  186. } else if (func == PARS_OR_TOKEN) {
  187. val = val1 | val2;
  188. } else if (func == PARS_NOT_TOKEN) {
  189. val = TRUE - val1;
  190. } else {
  191. ut_error;
  192. }
  194. eval_node_set_ibool_val(logical_node, val);
  195. }
  197. /*********************************************************************
  198. Evaluates an arithmetic operation node. */
  199. UNIV_INLINE
  200. void
  201. eval_arith(
  202. /*=======*/
  203. func_node_t* arith_node) /* in: arithmetic operation node */
  204. {
  205. que_node_t* arg1;
  206. que_node_t* arg2;
  207. lint val1;
  208. lint val2;
  209. lint val;
  210. int func;
  212. ut_ad(que_node_get_type(arith_node) == QUE_NODE_FUNC);
  214. arg1 = arith_node->args;
  215. arg2 = que_node_get_next(arg1); /* arg2 is NULL if func is unary '-' */
  217. val1 = eval_node_get_int_val(arg1);
  219. if (arg2) {
  220. val2 = eval_node_get_int_val(arg2);
  221. }
  223. func = arith_node->func;
  225. if (func == '+') {
  226. val = val1 + val2;
  227. } else if ((func == '-') && arg2) {
  228. val = val1 - val2;
  229. } else if (func == '-') {
  230. val = -val1;
  231. } else if (func == '*') {
  232. val = val1 * val2;
  233. } else {
  234. ut_ad(func == '/');
  235. val = val1 / val2;
  236. }
  238. eval_node_set_int_val(arith_node, val);
  239. }
  241. /*********************************************************************
  242. Evaluates an aggregate operation node. */
  243. UNIV_INLINE
  244. void
  245. eval_aggregate(
  246. /*===========*/
  247. func_node_t* node) /* in: aggregate operation node */
  248. {
  249. que_node_t* arg;
  250. lint val;
  251. lint arg_val;
  252. int func;
  254. ut_ad(que_node_get_type(node) == QUE_NODE_FUNC);
  256. val = eval_node_get_int_val(node);
  258. func = node->func;
  260. if (func == PARS_COUNT_TOKEN) {
  262. val = val + 1;
  263. } else {
  264. ut_ad(func == PARS_SUM_TOKEN);
  266. arg = node->args;
  267. arg_val = eval_node_get_int_val(arg);
  269. val = val + arg_val;
  270. }
  272. eval_node_set_int_val(node, val);
  273. }
  275. /*********************************************************************
  276. Evaluates a predefined function node where the function is not relevant
  277. in benchmarks. */
  278. static
  279. void
  280. eval_predefined_2(
  281. /*==============*/
  282. func_node_t* func_node) /* in: predefined function node */
  283. {
  284. que_node_t* arg;
  285. que_node_t* arg1;
  286. que_node_t* arg2;
  287. lint int_val;
  288. byte* data;
  289. ulint len1;
  290. ulint len2;
  291. int func;
  292. ulint i;
  294. ut_ad(que_node_get_type(func_node) == QUE_NODE_FUNC);
  296. arg1 = func_node->args;
  298. if (arg1) {
  299. arg2 = que_node_get_next(arg1);
  300. }
  302. func = func_node->func;
  304. if (func == PARS_PRINTF_TOKEN) {
  306. arg = arg1;
  308. while (arg) {
  309. dfield_print(que_node_get_val(arg));
  311. arg = que_node_get_next(arg);
  312. }
  314. printf("n");
  316. } else if (func == PARS_ASSERT_TOKEN) {
  318. if (!eval_node_get_ibool_val(arg1)) {
  319. printf("SQL assertion fails in a stored procedure!n");
  320. }
  321.  
  322. ut_a(eval_node_get_ibool_val(arg1));
  324. /* This function, or more precisely, a debug procedure,
  325. returns no value */
  327. } else if (func == PARS_RND_TOKEN) {
  329. len1 = (ulint)eval_node_get_int_val(arg1);
  330. len2 = (ulint)eval_node_get_int_val(arg2);
  332. ut_ad(len2 >= len1);
  334. if (len2 > len1) {
  335. int_val = (lint)(len1 +
  336. (eval_rnd % (len2 - len1 + 1)));
  337. } else {
  338. int_val = (lint)len1;
  339. }
  341. eval_rnd = ut_rnd_gen_next_ulint(eval_rnd);
  343. eval_node_set_int_val(func_node, int_val);
  345. } else if (func == PARS_RND_STR_TOKEN) {
  347. len1 = (ulint)eval_node_get_int_val(arg1);
  349. data = eval_node_ensure_val_buf(func_node, len1);
  351. for (i = 0; i < len1; i++) {
  352. data[i] = (byte)(97 + (eval_rnd % 3));
  354. eval_rnd = ut_rnd_gen_next_ulint(eval_rnd);
  355. }
  356. } else {
  357. ut_error;
  358. }
  359. }
  361. /*********************************************************************
  362. Evaluates a notfound-function node. */
  363. UNIV_INLINE
  364. void
  365. eval_notfound(
  366. /*==========*/
  367. func_node_t* func_node) /* in: function node */
  368. {
  369. que_node_t* arg1;
  370. que_node_t* arg2;
  371. sym_node_t* cursor;
  372. sel_node_t* sel_node;
  373. ibool ibool_val;
  375. arg1 = func_node->args;
  376. arg2 = que_node_get_next(arg1);
  378. ut_ad(func_node->func == PARS_NOTFOUND_TOKEN);
  380. cursor = arg1;
  382. ut_ad(que_node_get_type(cursor) == QUE_NODE_SYMBOL);
  384. if (cursor->token_type == SYM_LIT) {
  386. ut_ad(ut_memcmp(dfield_get_data(que_node_get_val(cursor)),
  387. "SQL", 3) == 0);
  389. sel_node = cursor->sym_table->query_graph->last_sel_node;
  390. } else {
  391. sel_node = cursor->alias->cursor_def;
  392. }
  394. if (sel_node->state == SEL_NODE_NO_MORE_ROWS) {
  395. ibool_val = TRUE;
  396. } else {
  397. ibool_val = FALSE;
  398. }
  400. eval_node_set_ibool_val(func_node, ibool_val);
  401. }
  403. /*********************************************************************
  404. Evaluates a substr-function node. */
  405. UNIV_INLINE
  406. void
  407. eval_substr(
  408. /*========*/
  409. func_node_t* func_node) /* in: function node */
  410. {
  411. que_node_t* arg1;
  412. que_node_t* arg2;
  413. que_node_t* arg3;
  414. dfield_t* dfield;
  415. byte* str1;
  416. ulint len1;
  417. ulint len2;
  419. arg1 = func_node->args;
  420. arg2 = que_node_get_next(arg1);
  422. ut_ad(func_node->func == PARS_SUBSTR_TOKEN);
  424. arg3 = que_node_get_next(arg2);
  426. str1 = dfield_get_data(que_node_get_val(arg1));
  428. len1 = (ulint)eval_node_get_int_val(arg2);
  429. len2 = (ulint)eval_node_get_int_val(arg3);
  431. dfield = que_node_get_val(func_node);
  433. dfield_set_data(dfield, str1 + len1, len2);
  434. }
  436. /*********************************************************************
  437. Evaluates a replstr-procedure node. */
  438. static
  439. void
  440. eval_replstr(
  441. /*=========*/
  442. func_node_t* func_node) /* in: function node */
  443. {
  444. que_node_t* arg1;
  445. que_node_t* arg2;
  446. que_node_t* arg3;
  447. que_node_t* arg4;
  448. byte* str1;
  449. byte* str2;
  450. ulint len1;
  451. ulint len2;
  453. arg1 = func_node->args;
  454. arg2 = que_node_get_next(arg1);
  456. ut_ad(que_node_get_type(arg1) == QUE_NODE_SYMBOL);
  458. arg3 = que_node_get_next(arg2);
  459. arg4 = que_node_get_next(arg3);
  461. str1 = dfield_get_data(que_node_get_val(arg1));
  462. str2 = dfield_get_data(que_node_get_val(arg2));
  464. len1 = (ulint)eval_node_get_int_val(arg3);
  465. len2 = (ulint)eval_node_get_int_val(arg4);
  467. if ((dfield_get_len(que_node_get_val(arg1)) < len1 + len2)
  468. || (dfield_get_len(que_node_get_val(arg2)) < len2)) {
  470. ut_error;
  471. }
  473. ut_memcpy(str1 + len1, str2, len2);
  474. }
  476. /*********************************************************************
  477. Evaluates an instr-function node. */
  478. static
  479. void
  480. eval_instr(
  481. /*=======*/
  482. func_node_t* func_node) /* in: function node */
  483. {
  484. que_node_t* arg1;
  485. que_node_t* arg2;
  486. dfield_t* dfield1;
  487. dfield_t* dfield2;
  488. lint int_val;
  489. byte* str1;
  490. byte* str2;
  491. byte match_char;
  492. ulint len1;
  493. ulint len2;
  494. ulint i;
  495. ulint j;
  497. arg1 = func_node->args;
  498. arg2 = que_node_get_next(arg1);
  500. dfield1 = que_node_get_val(arg1);
  501. dfield2 = que_node_get_val(arg2);
  503. str1 = dfield_get_data(dfield1);
  504. str2 = dfield_get_data(dfield2);
  506. len1 = dfield_get_len(dfield1);
  507. len2 = dfield_get_len(dfield2);
  509. if (len2 == 0) {
  510. ut_error;
  511. }
  513. match_char = str2[0];
  515. for (i = 0; i < len1; i++) {
  516. /* In this outer loop, the number of matched characters is 0 */
  518. if (str1[i] == match_char) {
  520. if (i + len2 > len1) {
  522. break;
  523. }
  525. for (j = 1;; j++) {
  526. /* We have already matched j characters */
  528. if (j == len2) {
  529. int_val = i + 1;
  531. goto match_found;
  532. }
  534. if (str1[i + j] != str2[j]) {
  536. break;
  537. }
  538. }
  539. }
  540. }
  542. int_val = 0;
  544. match_found:
  545. eval_node_set_int_val(func_node, int_val);
  546. }
  548. /*********************************************************************
  549. Evaluates a predefined function node. */
  550. UNIV_INLINE
  551. void
  552. eval_binary_to_number(
  553. /*==================*/
  554. func_node_t* func_node) /* in: function node */
  555. {
  556. que_node_t* arg1;
  557. dfield_t* dfield;
  558. byte* str1;
  559. byte* str2;
  560. ulint len1;
  561. ulint int_val;
  563. arg1 = func_node->args;
  565. dfield = que_node_get_val(arg1);
  567. str1 = dfield_get_data(dfield);
  568. len1 = dfield_get_len(dfield);
  570.   if (len1 > 4) {
  571. ut_error;
  572. }
  574. if (len1 == 4) {
  575. str2 = str1;
  576. } else {
  577. int_val = 0;
  578. str2 = (byte*)&int_val;
  580. ut_memcpy(str2 + (4 - len1), str1, len1);
  581. }
  583. eval_node_copy_and_alloc_val(func_node, str2, 4);
  584. }
  586. /*********************************************************************
  587. Evaluates a predefined function node. */
  588. static
  589. void
  590. eval_concat(
  591. /*========*/
  592. func_node_t* func_node) /* in: function node */
  593. {
  594. que_node_t* arg;
  595. dfield_t* dfield;
  596. byte* data;
  597. ulint len;
  598. ulint len1;
  600. arg = func_node->args;
  601. len = 0;
  603. while (arg) {
  604. len1 = dfield_get_len(que_node_get_val(arg));
  606. len += len1;
  608. arg = que_node_get_next(arg);
  609. }
  611. data = eval_node_ensure_val_buf(func_node, len);
  613. arg = func_node->args;
  614. len = 0;
  616. while (arg) {
  617. dfield = que_node_get_val(arg);
  618. len1 = dfield_get_len(dfield);
  620. ut_memcpy(data + len, dfield_get_data(dfield), len1);
  622. len += len1;
  624. arg = que_node_get_next(arg);
  625. }
  626. }
  628. /*********************************************************************
  629. Evaluates a predefined function node. */
  630. UNIV_INLINE
  631. void
  632. eval_to_binary(
  633. /*===========*/
  634. func_node_t* func_node) /* in: function node */
  635. {
  636. que_node_t* arg1;
  637. que_node_t* arg2;
  638. dfield_t* dfield;
  639. byte* str1;
  640. ulint len1;
  642. arg1 = func_node->args;
  644. str1 = dfield_get_data(que_node_get_val(arg1));
  646. arg2 = que_node_get_next(arg1);
  648. len1 = (ulint)eval_node_get_int_val(arg2);
  650. if (len1 > 4) {
  652. ut_error;
  653. }
  655. dfield = que_node_get_val(func_node);
  657. dfield_set_data(dfield, str1 + (4 - len1), len1);
  658. }
  660. /*********************************************************************
  661. Evaluates a predefined function node. */
  662. UNIV_INLINE
  663. void
  664. eval_predefined(
  665. /*============*/
  666. func_node_t* func_node) /* in: function node */
  667. {
  668. que_node_t* arg1;
  669. lint int_val;
  670. byte* str1;
  671. byte* data;
  672. int func;
  674. func = func_node->func;
  676. arg1 = func_node->args;
  678. if (func == PARS_LENGTH_TOKEN) {
  680. int_val = (lint)dfield_get_len(que_node_get_val(arg1));
  682. } else if (func == PARS_TO_CHAR_TOKEN) {
  684. int_val = eval_node_get_int_val(arg1);
  686. data = eval_node_ensure_val_buf(func_node, 11);
  688. sprintf((char*)data, "%10li", int_val);
  690. dfield_set_len(que_node_get_val(func_node), 10);
  692. return;
  694. } else if (func == PARS_TO_NUMBER_TOKEN) {
  696. str1 = dfield_get_data(que_node_get_val(arg1));
  698. int_val = atoi((char*)str1);
  700. } else if (func == PARS_SYSDATE_TOKEN) {
  701. int_val = (lint)ut_time();
  702. } else {
  703. eval_predefined_2(func_node);
  705. return;
  706. }
  708. eval_node_set_int_val(func_node, int_val); 
  709. }
  711. /*********************************************************************
  712. Evaluates a function node. */
  714. void
  715. eval_func(
  716. /*======*/
  717. func_node_t* func_node) /* in: function node */
  718. {
  719. que_node_t* arg;
  720. ulint class;
  721. ulint func;
  723. ut_ad(que_node_get_type(func_node) == QUE_NODE_FUNC);
  725. class = func_node->class;
  726. func = func_node->func;
  728. arg = func_node->args;
  730. /* Evaluate first the argument list */
  731. while (arg) {
  732. eval_exp(arg);
  734. /* The functions are not defined for SQL null argument
  735. values, except for eval_cmp and notfound */
  737. if ((dfield_get_len(que_node_get_val(arg)) == UNIV_SQL_NULL)
  738. && (class != PARS_FUNC_CMP)
  739. && (func != PARS_NOTFOUND_TOKEN)
  740. && (func != PARS_PRINTF_TOKEN)) {
  741. ut_error;
  742. }
  744. arg = que_node_get_next(arg);
  745. }
  747. if (class == PARS_FUNC_CMP) {
  748. eval_cmp(func_node);
  749. } else if (class == PARS_FUNC_ARITH) {
  750. eval_arith(func_node);
  751. } else if (class == PARS_FUNC_AGGREGATE) {
  752. eval_aggregate(func_node);
  753. } else if (class == PARS_FUNC_PREDEFINED) {
  755. if (func == PARS_NOTFOUND_TOKEN) {
  756. eval_notfound(func_node);
  757. } else if (func == PARS_SUBSTR_TOKEN) {
  758. eval_substr(func_node);
  759. } else if (func == PARS_REPLSTR_TOKEN) {
  760. eval_replstr(func_node);
  761. } else if (func == PARS_INSTR_TOKEN) {
  762. eval_instr(func_node);
  763. } else if (func == PARS_BINARY_TO_NUMBER_TOKEN) {
  764. eval_binary_to_number(func_node);
  765. } else if (func == PARS_CONCAT_TOKEN) {
  766. eval_concat(func_node);
  767. } else if (func == PARS_TO_BINARY_TOKEN) {
  768. eval_to_binary(func_node);
  769. } else {
  770. eval_predefined(func_node);
  771. }
  772. } else {
  773. ut_ad(class == PARS_FUNC_LOGICAL);
  775. eval_logical(func_node);
  776. }
  777. }