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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Executes SQL stored procedures and their control structures
  3. (c) 1998 Innobase Oy
  4. Created 1/20/1998 Heikki Tuuri
  5. *******************************************************/
  6. #include "eval0proc.h"
  7. #ifdef UNIV_NONINL
  8. #include "eval0proc.ic"
  9. #endif
  10. /**************************************************************************
  11. Performs an execution step of an if-statement node. */
  12. que_thr_t*
  13. if_step(
  14. /*====*/
  15. /* out: query thread to run next or NULL */
  16. que_thr_t* thr) /* in: query thread */
  17. {
  18. if_node_t* node;
  19. elsif_node_t* elsif_node;
  20. ut_ad(thr);
  21. node = thr->run_node;
  22. ut_ad(que_node_get_type(node) == QUE_NODE_IF);
  23. if (thr->prev_node == que_node_get_parent(node)) {
  24. /* Evaluate the condition */
  25. eval_exp(node->cond);
  26. if (eval_node_get_ibool_val(node->cond)) {
  27. /* The condition evaluated to TRUE: start execution
  28. from the first statement in the statement list */
  29. thr->run_node = node->stat_list;
  30. } else if (node->else_part) {
  31. thr->run_node = node->else_part;
  32. } else if (node->elsif_list) {
  33. elsif_node = node->elsif_list;
  34. for (;;) {
  35. eval_exp(elsif_node->cond);
  36. if (eval_node_get_ibool_val(elsif_node->cond)) {
  37. /* The condition evaluated to TRUE:
  38. start execution from the first
  39. statement in the statement list */
  40. thr->run_node = elsif_node->stat_list;
  41. break;
  42. }
  43. elsif_node = que_node_get_next(elsif_node);
  44. if (elsif_node == NULL) {
  45. thr->run_node = NULL;
  46. break;
  47. }
  48. }
  49. } else {
  50. thr->run_node = NULL;
  51. }
  52. } else {
  53. /* Move to the next statement */
  54. ut_ad(que_node_get_next(thr->prev_node) == NULL);
  55. thr->run_node = NULL;
  56. }
  57. if (thr->run_node == NULL) {
  58. thr->run_node = que_node_get_parent(node);
  59. }
  60. return(thr);
  61. /**************************************************************************
  62. Performs an execution step of a while-statement node. */
  63. que_thr_t*
  64. while_step(
  65. /*=======*/
  66. /* out: query thread to run next or NULL */
  67. que_thr_t* thr) /* in: query thread */
  68. {
  69. while_node_t* node;
  70. ut_ad(thr);
  71. node = thr->run_node;
  72. ut_ad(que_node_get_type(node) == QUE_NODE_WHILE);
  73. ut_ad((thr->prev_node == que_node_get_parent(node))
  74. || (que_node_get_next(thr->prev_node) == NULL));
  75. /* Evaluate the condition */
  76. eval_exp(node->cond);
  77. if (eval_node_get_ibool_val(node->cond)) {
  78. /* The condition evaluated to TRUE: start execution
  79. from the first statement in the statement list */
  80. thr->run_node = node->stat_list;
  81. } else {
  82. thr->run_node = que_node_get_parent(node);
  83. }
  84. return(thr);
  85. /**************************************************************************
  86. Performs an execution step of an assignment statement node. */
  87. que_thr_t*
  88. assign_step(
  89. /*========*/
  90. /* out: query thread to run next or NULL */
  91. que_thr_t* thr) /* in: query thread */
  92. {
  93. assign_node_t* node;
  94. ut_ad(thr);
  95. node = thr->run_node;
  96. ut_ad(que_node_get_type(node) == QUE_NODE_ASSIGNMENT);
  97. /* Evaluate the value to assign */
  98. eval_exp(node->val);
  99. eval_node_copy_val(node->var->alias, node->val);
  100. thr->run_node = que_node_get_parent(node);
  101. return(thr);
  102. /**************************************************************************
  103. Performs an execution step of a for-loop node. */
  104. que_thr_t*
  105. for_step(
  106. /*=====*/
  107. /* out: query thread to run next or NULL */
  108. que_thr_t* thr) /* in: query thread */
  109. {
  110. for_node_t* node;
  111. que_node_t* parent;
  112. lint loop_var_value;
  113. ut_ad(thr);
  114. node = thr->run_node;
  115. ut_ad(que_node_get_type(node) == QUE_NODE_FOR);
  116. parent = que_node_get_parent(node);
  117. if (thr->prev_node != parent) {
  118. /* Move to the next statement */
  119. thr->run_node = que_node_get_next(thr->prev_node);
  120. if (thr->run_node != NULL) {
  121. return(thr);
  122. }
  123. /* Increment the value of loop_var */
  124. loop_var_value = 1 + eval_node_get_int_val(node->loop_var);
  125. } else {
  126. /* Initialize the loop */
  127. eval_exp(node->loop_start_limit);
  128. eval_exp(node->loop_end_limit);
  129. loop_var_value = eval_node_get_int_val(node->loop_start_limit);
  130. node->loop_end_value = eval_node_get_int_val(
  131. node->loop_end_limit);
  132. }
  133. /* Check if we should do another loop */
  134. if (loop_var_value > node->loop_end_value) {
  135. /* Enough loops done */
  136. thr->run_node = parent;
  137. } else {
  138. eval_node_set_int_val(node->loop_var, loop_var_value);
  139. thr->run_node = node->stat_list;
  140. }
  141. return(thr);
  142. /**************************************************************************
  143. Performs an execution step of a return-statement node. */
  144. que_thr_t*
  145. return_step(
  146. /*========*/
  147. /* out: query thread to run next or NULL */
  148. que_thr_t* thr) /* in: query thread */
  149. {
  150. return_node_t* node;
  151. que_node_t* parent;
  152. ut_ad(thr);
  153. node = thr->run_node;
  154. ut_ad(que_node_get_type(node) == QUE_NODE_RETURN);
  155. parent = node;
  156. while (que_node_get_type(parent) != QUE_NODE_PROC) {
  157. parent = que_node_get_parent(parent);
  158. }
  159. ut_a(parent);
  160. thr->run_node = que_node_get_parent(parent);
  161. return(thr);
  162. }