Creation of mysql-trunk = {summit + "Innodb plugin replacing the builtin"}:

bzr branch mysql-5.1-performance-version mysql-trunk # Summit
cd mysql-trunk
bzr merge mysql-5.1-innodb_plugin # which is 5.1 + Innodb plugin 
bzr rm innobase # remove the builtin
Next step: build, test fixes.

2 files changed, 0 insertions, 1114 deletions

diff --git a/storage/innobase/eval/eval0eval.c b/storage/innobase/eval/eval0eval.c
deleted file mode 100644
index cbc47ec508f..00000000000
--- a/storage/innobase/eval/eval0eval.c
+++ /dev/null
@@ -1,836 +0,0 @@
-/******************************************************
-SQL evaluator: evaluates simple data structures, like expressions, in
-a query graph
-
-(c) 1997 Innobase Oy
-
-Created 12/29/1997 Heikki Tuuri
-*******************************************************/
-
-#include "eval0eval.h"
-
-#ifdef UNIV_NONINL
-#include "eval0eval.ic"
-#endif
-
-#include "data0data.h"
-#include "row0sel.h"
-
-/* The RND function seed */
-ulint	eval_rnd	= 128367121;
-
-/* Dummy adress used when we should allocate a buffer of size 0 in
-the function below */
-
-byte	eval_dummy;
-
-/*********************************************************************
-Allocate a buffer from global dynamic memory for a value of a que_node.
-NOTE that this memory must be explicitly freed when the query graph is
-freed. If the node already has an allocated buffer, that buffer is freed
-here. NOTE that this is the only function where dynamic memory should be
-allocated for a query node val field. */
-
-byte*
-eval_node_alloc_val_buf(
-/*====================*/
-				/* out: pointer to allocated buffer */
-	que_node_t*	node,	/* in: query graph node; sets the val field
-				data field to point to the new buffer, and
-				len field equal to size */
-	ulint		size)	/* in: buffer size */
-{
-	dfield_t*	dfield;
-	byte*		data;
-
-	ut_ad(que_node_get_type(node) == QUE_NODE_SYMBOL
-	      || que_node_get_type(node) == QUE_NODE_FUNC);
-
-	dfield = que_node_get_val(node);
-
-	data = dfield_get_data(dfield);
-
-	if (data && data != &eval_dummy) {
-		mem_free(data);
-	}
-
-	if (size == 0) {
-		data = &eval_dummy;
-	} else {
-		data = mem_alloc(size);
-	}
-
-	que_node_set_val_buf_size(node, size);
-
-	dfield_set_data(dfield, data, size);
-
-	return(data);
-}
-
-/*********************************************************************
-Free the buffer from global dynamic memory for a value of a que_node,
-if it has been allocated in the above function. The freeing for pushed
-column values is done in sel_col_prefetch_buf_free. */
-
-void
-eval_node_free_val_buf(
-/*===================*/
-	que_node_t*	node)	/* in: query graph node */
-{
-	dfield_t*	dfield;
-	byte*		data;
-
-	ut_ad(que_node_get_type(node) == QUE_NODE_SYMBOL
-	      || que_node_get_type(node) == QUE_NODE_FUNC);
-
-	dfield = que_node_get_val(node);
-
-	data = dfield_get_data(dfield);
-
-	if (que_node_get_val_buf_size(node) > 0) {
-		ut_a(data);
-
-		mem_free(data);
-	}
-}
-
-/*********************************************************************
-Evaluates a comparison node. */
-
-ibool
-eval_cmp(
-/*=====*/
-					/* out: the result of the comparison */
-	func_node_t*	cmp_node)	/* in: comparison node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	int		res;
-	ibool		val;
-	int		func;
-
-	ut_ad(que_node_get_type(cmp_node) == QUE_NODE_FUNC);
-
-	arg1 = cmp_node->args;
-	arg2 = que_node_get_next(arg1);
-
-	res = cmp_dfield_dfield(que_node_get_val(arg1),
-				que_node_get_val(arg2));
-	val = TRUE;
-
-	func = cmp_node->func;
-
-	if (func == '=') {
-		if (res != 0) {
-			val = FALSE;
-		}
-	} else if (func == '<') {
-		if (res != -1) {
-			val = FALSE;
-		}
-	} else if (func == PARS_LE_TOKEN) {
-		if (res == 1) {
-			val = FALSE;
-		}
-	} else if (func == PARS_NE_TOKEN) {
-		if (res == 0) {
-			val = FALSE;
-		}
-	} else if (func == PARS_GE_TOKEN) {
-		if (res == -1) {
-			val = FALSE;
-		}
-	} else {
-		ut_ad(func == '>');
-
-		if (res != 1) {
-			val = FALSE;
-		}
-	}
-
-	eval_node_set_ibool_val(cmp_node, val);
-
-	return(val);
-}
-
-/*********************************************************************
-Evaluates a logical operation node. */
-UNIV_INLINE
-void
-eval_logical(
-/*=========*/
-	func_node_t*	logical_node)	/* in: logical operation node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	ibool		val1;
-	ibool		val2 = 0; /* remove warning */
-	ibool		val = 0;  /* remove warning */
-	int		func;
-
-	ut_ad(que_node_get_type(logical_node) == QUE_NODE_FUNC);
-
-	arg1 = logical_node->args;
-	arg2 = que_node_get_next(arg1); /* arg2 is NULL if func is 'NOT' */
-
-	val1 = eval_node_get_ibool_val(arg1);
-
-	if (arg2) {
-		val2 = eval_node_get_ibool_val(arg2);
-	}
-
-	func = logical_node->func;
-
-	if (func == PARS_AND_TOKEN) {
-		val = val1 & val2;
-	} else if (func == PARS_OR_TOKEN) {
-		val = val1 | val2;
-	} else if (func == PARS_NOT_TOKEN) {
-		val = TRUE - val1;
-	} else {
-		ut_error;
-	}
-
-	eval_node_set_ibool_val(logical_node, val);
-}
-
-/*********************************************************************
-Evaluates an arithmetic operation node. */
-UNIV_INLINE
-void
-eval_arith(
-/*=======*/
-	func_node_t*	arith_node)	/* in: arithmetic operation node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	lint		val1;
-	lint		val2 = 0; /* remove warning */
-	lint		val;
-	int		func;
-
-	ut_ad(que_node_get_type(arith_node) == QUE_NODE_FUNC);
-
-	arg1 = arith_node->args;
-	arg2 = que_node_get_next(arg1); /* arg2 is NULL if func is unary '-' */
-
-	val1 = eval_node_get_int_val(arg1);
-
-	if (arg2) {
-		val2 = eval_node_get_int_val(arg2);
-	}
-
-	func = arith_node->func;
-
-	if (func == '+') {
-		val = val1 + val2;
-	} else if ((func == '-') && arg2) {
-		val = val1 - val2;
-	} else if (func == '-') {
-		val = -val1;
-	} else if (func == '*') {
-		val = val1 * val2;
-	} else {
-		ut_ad(func == '/');
-		val = val1 / val2;
-	}
-
-	eval_node_set_int_val(arith_node, val);
-}
-
-/*********************************************************************
-Evaluates an aggregate operation node. */
-UNIV_INLINE
-void
-eval_aggregate(
-/*===========*/
-	func_node_t*	node)	/* in: aggregate operation node */
-{
-	que_node_t*	arg;
-	lint		val;
-	lint		arg_val;
-	int		func;
-
-	ut_ad(que_node_get_type(node) == QUE_NODE_FUNC);
-
-	val = eval_node_get_int_val(node);
-
-	func = node->func;
-
-	if (func == PARS_COUNT_TOKEN) {
-
-		val = val + 1;
-	} else {
-		ut_ad(func == PARS_SUM_TOKEN);
-
-		arg = node->args;
-		arg_val = eval_node_get_int_val(arg);
-
-		val = val + arg_val;
-	}
-
-	eval_node_set_int_val(node, val);
-}
-
-/*********************************************************************
-Evaluates a predefined function node where the function is not relevant
-in benchmarks. */
-static
-void
-eval_predefined_2(
-/*==============*/
-	func_node_t*	func_node)	/* in: predefined function node */
-{
-	que_node_t*	arg;
-	que_node_t*	arg1;
-	que_node_t*	arg2 = 0; /* remove warning (??? bug ???) */
-	lint		int_val;
-	byte*		data;
-	ulint		len1;
-	ulint		len2;
-	int		func;
-	ulint		i;
-
-	ut_ad(que_node_get_type(func_node) == QUE_NODE_FUNC);
-
-	arg1 = func_node->args;
-
-	if (arg1) {
-		arg2 = que_node_get_next(arg1);
-	}
-
-	func = func_node->func;
-
-	if (func == PARS_PRINTF_TOKEN) {
-
-		arg = arg1;
-
-		while (arg) {
-			dfield_print(que_node_get_val(arg));
-
-			arg = que_node_get_next(arg);
-		}
-
-		putc('\n', stderr);
-
-	} else if (func == PARS_ASSERT_TOKEN) {
-
-		if (!eval_node_get_ibool_val(arg1)) {
-			fputs("SQL assertion fails in a stored procedure!\n",
-			      stderr);
-		}
-
-		ut_a(eval_node_get_ibool_val(arg1));
-
-		/* This function, or more precisely, a debug procedure,
-		returns no value */
-
-	} else if (func == PARS_RND_TOKEN) {
-
-		len1 = (ulint)eval_node_get_int_val(arg1);
-		len2 = (ulint)eval_node_get_int_val(arg2);
-
-		ut_ad(len2 >= len1);
-
-		if (len2 > len1) {
-			int_val = (lint) (len1
-					  + (eval_rnd % (len2 - len1 + 1)));
-		} else {
-			int_val = (lint) len1;
-		}
-
-		eval_rnd = ut_rnd_gen_next_ulint(eval_rnd);
-
-		eval_node_set_int_val(func_node, int_val);
-
-	} else if (func == PARS_RND_STR_TOKEN) {
-
-		len1 = (ulint)eval_node_get_int_val(arg1);
-
-		data = eval_node_ensure_val_buf(func_node, len1);
-
-		for (i = 0; i < len1; i++) {
-			data[i] = (byte)(97 + (eval_rnd % 3));
-
-			eval_rnd = ut_rnd_gen_next_ulint(eval_rnd);
-		}
-	} else {
-		ut_error;
-	}
-}
-
-/*********************************************************************
-Evaluates a notfound-function node. */
-UNIV_INLINE
-void
-eval_notfound(
-/*==========*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	sym_node_t*	cursor;
-	sel_node_t*	sel_node;
-	ibool		ibool_val;
-
-	arg1 = func_node->args;
-	arg2 = que_node_get_next(arg1);
-
-	ut_ad(func_node->func == PARS_NOTFOUND_TOKEN);
-
-	cursor = arg1;
-
-	ut_ad(que_node_get_type(cursor) == QUE_NODE_SYMBOL);
-
-	if (cursor->token_type == SYM_LIT) {
-
-		ut_ad(ut_memcmp(dfield_get_data(que_node_get_val(cursor)),
-				"SQL", 3) == 0);
-
-		sel_node = cursor->sym_table->query_graph->last_sel_node;
-	} else {
-		sel_node = cursor->alias->cursor_def;
-	}
-
-	if (sel_node->state == SEL_NODE_NO_MORE_ROWS) {
-		ibool_val = TRUE;
-	} else {
-		ibool_val = FALSE;
-	}
-
-	eval_node_set_ibool_val(func_node, ibool_val);
-}
-
-/*********************************************************************
-Evaluates a substr-function node. */
-UNIV_INLINE
-void
-eval_substr(
-/*========*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	que_node_t*	arg3;
-	dfield_t*	dfield;
-	byte*		str1;
-	ulint		len1;
-	ulint		len2;
-
-	arg1 = func_node->args;
-	arg2 = que_node_get_next(arg1);
-
-	ut_ad(func_node->func == PARS_SUBSTR_TOKEN);
-
-	arg3 = que_node_get_next(arg2);
-
-	str1 = dfield_get_data(que_node_get_val(arg1));
-
-	len1 = (ulint)eval_node_get_int_val(arg2);
-	len2 = (ulint)eval_node_get_int_val(arg3);
-
-	dfield = que_node_get_val(func_node);
-
-	dfield_set_data(dfield, str1 + len1, len2);
-}
-
-/*********************************************************************
-Evaluates a replstr-procedure node. */
-static
-void
-eval_replstr(
-/*=========*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	que_node_t*	arg3;
-	que_node_t*	arg4;
-	byte*		str1;
-	byte*		str2;
-	ulint		len1;
-	ulint		len2;
-
-	arg1 = func_node->args;
-	arg2 = que_node_get_next(arg1);
-
-	ut_ad(que_node_get_type(arg1) == QUE_NODE_SYMBOL);
-
-	arg3 = que_node_get_next(arg2);
-	arg4 = que_node_get_next(arg3);
-
-	str1 = dfield_get_data(que_node_get_val(arg1));
-	str2 = dfield_get_data(que_node_get_val(arg2));
-
-	len1 = (ulint)eval_node_get_int_val(arg3);
-	len2 = (ulint)eval_node_get_int_val(arg4);
-
-	if ((dfield_get_len(que_node_get_val(arg1)) < len1 + len2)
-	    || (dfield_get_len(que_node_get_val(arg2)) < len2)) {
-
-		ut_error;
-	}
-
-	ut_memcpy(str1 + len1, str2, len2);
-}
-
-/*********************************************************************
-Evaluates an instr-function node. */
-static
-void
-eval_instr(
-/*=======*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	dfield_t*	dfield1;
-	dfield_t*	dfield2;
-	lint		int_val;
-	byte*		str1;
-	byte*		str2;
-	byte		match_char;
-	ulint		len1;
-	ulint		len2;
-	ulint		i;
-	ulint		j;
-
-	arg1 = func_node->args;
-	arg2 = que_node_get_next(arg1);
-
-	dfield1 = que_node_get_val(arg1);
-	dfield2 = que_node_get_val(arg2);
-
-	str1 = dfield_get_data(dfield1);
-	str2 = dfield_get_data(dfield2);
-
-	len1 = dfield_get_len(dfield1);
-	len2 = dfield_get_len(dfield2);
-
-	if (len2 == 0) {
-		ut_error;
-	}
-
-	match_char = str2[0];
-
-	for (i = 0; i < len1; i++) {
-		/* In this outer loop, the number of matched characters is 0 */
-
-		if (str1[i] == match_char) {
-
-			if (i + len2 > len1) {
-
-				break;
-			}
-
-			for (j = 1;; j++) {
-				/* We have already matched j characters */
-
-				if (j == len2) {
-					int_val = i + 1;
-
-					goto match_found;
-				}
-
-				if (str1[i + j] != str2[j]) {
-
-					break;
-				}
-			}
-		}
-	}
-
-	int_val = 0;
-
-match_found:
-	eval_node_set_int_val(func_node, int_val);
-}
-
-/*********************************************************************
-Evaluates a predefined function node. */
-UNIV_INLINE
-void
-eval_binary_to_number(
-/*==================*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg1;
-	dfield_t*	dfield;
-	byte*		str1;
-	byte*		str2;
-	ulint		len1;
-	ulint		int_val;
-
-	arg1 = func_node->args;
-
-	dfield = que_node_get_val(arg1);
-
-	str1 = dfield_get_data(dfield);
-	len1 = dfield_get_len(dfield);
-
-	if (len1 > 4) {
-		ut_error;
-	}
-
-	if (len1 == 4) {
-		str2 = str1;
-	} else {
-		int_val = 0;
-		str2 = (byte*)&int_val;
-
-		ut_memcpy(str2 + (4 - len1), str1, len1);
-	}
-
-	eval_node_copy_and_alloc_val(func_node, str2, 4);
-}
-
-/*********************************************************************
-Evaluates a predefined function node. */
-static
-void
-eval_concat(
-/*========*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg;
-	dfield_t*	dfield;
-	byte*		data;
-	ulint		len;
-	ulint		len1;
-
-	arg = func_node->args;
-	len = 0;
-
-	while (arg) {
-		len1 = dfield_get_len(que_node_get_val(arg));
-
-		len += len1;
-
-		arg = que_node_get_next(arg);
-	}
-
-	data = eval_node_ensure_val_buf(func_node, len);
-
-	arg = func_node->args;
-	len = 0;
-
-	while (arg) {
-		dfield = que_node_get_val(arg);
-		len1 = dfield_get_len(dfield);
-
-		ut_memcpy(data + len, dfield_get_data(dfield), len1);
-
-		len += len1;
-
-		arg = que_node_get_next(arg);
-	}
-}
-
-/*********************************************************************
-Evaluates a predefined function node. If the first argument is an integer,
-this function looks at the second argument which is the integer length in
-bytes, and converts the integer to a VARCHAR.
-If the first argument is of some other type, this function converts it to
-BINARY. */
-UNIV_INLINE
-void
-eval_to_binary(
-/*===========*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg1;
-	que_node_t*	arg2;
-	dfield_t*	dfield;
-	byte*		str1;
-	ulint		len;
-	ulint		len1;
-
-	arg1 = func_node->args;
-
-	str1 = dfield_get_data(que_node_get_val(arg1));
-
-	if (dtype_get_mtype(que_node_get_data_type(arg1)) != DATA_INT) {
-
-		len = dfield_get_len(que_node_get_val(arg1));
-
-		dfield = que_node_get_val(func_node);
-
-		dfield_set_data(dfield, str1, len);
-
-		return;
-	}
-
-	arg2 = que_node_get_next(arg1);
-
-	len1 = (ulint)eval_node_get_int_val(arg2);
-
-	if (len1 > 4) {
-
-		ut_error;
-	}
-
-	dfield = que_node_get_val(func_node);
-
-	dfield_set_data(dfield, str1 + (4 - len1), len1);
-}
-
-/*********************************************************************
-Evaluates a predefined function node. */
-UNIV_INLINE
-void
-eval_predefined(
-/*============*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg1;
-	lint		int_val;
-	byte*		data;
-	int		func;
-
-	func = func_node->func;
-
-	arg1 = func_node->args;
-
-	if (func == PARS_LENGTH_TOKEN) {
-
-		int_val = (lint)dfield_get_len(que_node_get_val(arg1));
-
-	} else if (func == PARS_TO_CHAR_TOKEN) {
-
-		/* Convert number to character string as a
-		signed decimal integer. */
-
-		ulint	uint_val;
-		int	int_len;
-
-		int_val = eval_node_get_int_val(arg1);
-
-		/* Determine the length of the string. */
-
-		if (int_val == 0) {
-			int_len = 1; /* the number 0 occupies 1 byte */
-		} else {
-			int_len = 0;
-			if (int_val < 0) {
-				uint_val = ((ulint) -int_val - 1) + 1;
-				int_len++; /* reserve space for minus sign */
-			} else {
-				uint_val = (ulint) int_val;
-			}
-			for (; uint_val > 0; int_len++) {
-				uint_val /= 10;
-			}
-		}
-
-		/* allocate the string */
-		data = eval_node_ensure_val_buf(func_node, int_len + 1);
-
-		/* add terminating NUL character */
-		data[int_len] = 0;
-
-		/* convert the number */
-
-		if (int_val == 0) {
-			data[0] = '0';
-		} else {
-			int tmp;
-			if (int_val < 0) {
-				data[0] = '-'; /* preceding minus sign */
-				uint_val = ((ulint) -int_val - 1) + 1;
-			} else {
-				uint_val = (ulint) int_val;
-			}
-			for (tmp = int_len; uint_val > 0; uint_val /= 10) {
-				data[--tmp] = (byte)
-					('0' + (byte)(uint_val % 10));
-			}
-		}
-
-		dfield_set_len((dfield_t*) que_node_get_val(func_node),
-			       int_len);
-
-		return;
-
-	} else if (func == PARS_TO_NUMBER_TOKEN) {
-
-		int_val = atoi((char*)
-			       dfield_get_data(que_node_get_val(arg1)));
-
-	} else if (func == PARS_SYSDATE_TOKEN) {
-		int_val = (lint)ut_time();
-	} else {
-		eval_predefined_2(func_node);
-
-		return;
-	}
-
-	eval_node_set_int_val(func_node, int_val);
-}
-
-/*********************************************************************
-Evaluates a function node. */
-
-void
-eval_func(
-/*======*/
-	func_node_t*	func_node)	/* in: function node */
-{
-	que_node_t*	arg;
-	ulint		class;
-	ulint		func;
-
-	ut_ad(que_node_get_type(func_node) == QUE_NODE_FUNC);
-
-	class = func_node->class;
-	func = func_node->func;
-
-	arg = func_node->args;
-
-	/* Evaluate first the argument list */
-	while (arg) {
-		eval_exp(arg);
-
-		/* The functions are not defined for SQL null argument
-		values, except for eval_cmp and notfound */
-
-		if ((dfield_get_len(que_node_get_val(arg)) == UNIV_SQL_NULL)
-		    && (class != PARS_FUNC_CMP)
-		    && (func != PARS_NOTFOUND_TOKEN)
-		    && (func != PARS_PRINTF_TOKEN)) {
-			ut_error;
-		}
-
-		arg = que_node_get_next(arg);
-	}
-
-	if (class == PARS_FUNC_CMP) {
-		eval_cmp(func_node);
-	} else if (class == PARS_FUNC_ARITH) {
-		eval_arith(func_node);
-	} else if (class == PARS_FUNC_AGGREGATE) {
-		eval_aggregate(func_node);
-	} else if (class == PARS_FUNC_PREDEFINED) {
-
-		if (func == PARS_NOTFOUND_TOKEN) {
-			eval_notfound(func_node);
-		} else if (func == PARS_SUBSTR_TOKEN) {
-			eval_substr(func_node);
-		} else if (func == PARS_REPLSTR_TOKEN) {
-			eval_replstr(func_node);
-		} else if (func == PARS_INSTR_TOKEN) {
-			eval_instr(func_node);
-		} else if (func == PARS_BINARY_TO_NUMBER_TOKEN) {
-			eval_binary_to_number(func_node);
-		} else if (func == PARS_CONCAT_TOKEN) {
-			eval_concat(func_node);
-		} else if (func == PARS_TO_BINARY_TOKEN) {
-			eval_to_binary(func_node);
-		} else {
-			eval_predefined(func_node);
-		}
-	} else {
-		ut_ad(class == PARS_FUNC_LOGICAL);
-
-		eval_logical(func_node);
-	}
-}
diff --git a/storage/innobase/eval/eval0proc.c b/storage/innobase/eval/eval0proc.c
deleted file mode 100644
index a513e8e4024..00000000000
--- a/storage/innobase/eval/eval0proc.c
+++ /dev/null
@@ -1,278 +0,0 @@
-/******************************************************
-Executes SQL stored procedures and their control structures
-
-(c) 1998 Innobase Oy
-
-Created 1/20/1998 Heikki Tuuri
-*******************************************************/
-
-#include "eval0proc.h"
-
-#ifdef UNIV_NONINL
-#include "eval0proc.ic"
-#endif
-
-/**************************************************************************
-Performs an execution step of an if-statement node. */
-
-que_thr_t*
-if_step(
-/*====*/
-				/* out: query thread to run next or NULL */
-	que_thr_t*	thr)	/* in: query thread */
-{
-	if_node_t*	node;
-	elsif_node_t*	elsif_node;
-
-	ut_ad(thr);
-
-	node = thr->run_node;
-	ut_ad(que_node_get_type(node) == QUE_NODE_IF);
-
-	if (thr->prev_node == que_node_get_parent(node)) {
-
-		/* Evaluate the condition */
-
-		eval_exp(node->cond);
-
-		if (eval_node_get_ibool_val(node->cond)) {
-
-			/* The condition evaluated to TRUE: start execution
-			from the first statement in the statement list */
-
-			thr->run_node = node->stat_list;
-
-		} else if (node->else_part) {
-			thr->run_node = node->else_part;
-
-		} else if (node->elsif_list) {
-			elsif_node = node->elsif_list;
-
-			for (;;) {
-				eval_exp(elsif_node->cond);
-
-				if (eval_node_get_ibool_val(
-					    elsif_node->cond)) {
-
-					/* The condition evaluated to TRUE:
-					start execution from the first
-					statement in the statement list */
-
-					thr->run_node = elsif_node->stat_list;
-
-					break;
-				}
-
-				elsif_node = que_node_get_next(elsif_node);
-
-				if (elsif_node == NULL) {
-					thr->run_node = NULL;
-
-					break;
-				}
-			}
-		} else {
-			thr->run_node = NULL;
-		}
-	} else {
-		/* Move to the next statement */
-		ut_ad(que_node_get_next(thr->prev_node) == NULL);
-
-		thr->run_node = NULL;
-	}
-
-	if (thr->run_node == NULL) {
-		thr->run_node = que_node_get_parent(node);
-	}
-
-	return(thr);
-}
-
-/**************************************************************************
-Performs an execution step of a while-statement node. */
-
-que_thr_t*
-while_step(
-/*=======*/
-				/* out: query thread to run next or NULL */
-	que_thr_t*	thr)	/* in: query thread */
-{
-	while_node_t*	node;
-
-	ut_ad(thr);
-
-	node = thr->run_node;
-	ut_ad(que_node_get_type(node) == QUE_NODE_WHILE);
-
-	ut_ad((thr->prev_node == que_node_get_parent(node))
-	      || (que_node_get_next(thr->prev_node) == NULL));
-
-	/* Evaluate the condition */
-
-	eval_exp(node->cond);
-
-	if (eval_node_get_ibool_val(node->cond)) {
-
-		/* The condition evaluated to TRUE: start execution
-		from the first statement in the statement list */
-
-		thr->run_node = node->stat_list;
-	} else {
-		thr->run_node = que_node_get_parent(node);
-	}
-
-	return(thr);
-}
-
-/**************************************************************************
-Performs an execution step of an assignment statement node. */
-
-que_thr_t*
-assign_step(
-/*========*/
-				/* out: query thread to run next or NULL */
-	que_thr_t*	thr)	/* in: query thread */
-{
-	assign_node_t*	node;
-
-	ut_ad(thr);
-
-	node = thr->run_node;
-	ut_ad(que_node_get_type(node) == QUE_NODE_ASSIGNMENT);
-
-	/* Evaluate the value to assign */
-
-	eval_exp(node->val);
-
-	eval_node_copy_val(node->var->alias, node->val);
-
-	thr->run_node = que_node_get_parent(node);
-
-	return(thr);
-}
-
-/**************************************************************************
-Performs an execution step of a for-loop node. */
-
-que_thr_t*
-for_step(
-/*=====*/
-				/* out: query thread to run next or NULL */
-	que_thr_t*	thr)	/* in: query thread */
-{
-	for_node_t*	node;
-	que_node_t*	parent;
-	lint		loop_var_value;
-
-	ut_ad(thr);
-
-	node = thr->run_node;
-
-	ut_ad(que_node_get_type(node) == QUE_NODE_FOR);
-
-	parent = que_node_get_parent(node);
-
-	if (thr->prev_node != parent) {
-
-		/* Move to the next statement */
-		thr->run_node = que_node_get_next(thr->prev_node);
-
-		if (thr->run_node != NULL) {
-
-			return(thr);
-		}
-
-		/* Increment the value of loop_var */
-
-		loop_var_value = 1 + eval_node_get_int_val(node->loop_var);
-	} else {
-		/* Initialize the loop */
-
-		eval_exp(node->loop_start_limit);
-		eval_exp(node->loop_end_limit);
-
-		loop_var_value = eval_node_get_int_val(node->loop_start_limit);
-
-		node->loop_end_value
-                  = (int) eval_node_get_int_val(node->loop_end_limit);
-	}
-
-	/* Check if we should do another loop */
-
-	if (loop_var_value > node->loop_end_value) {
-
-		/* Enough loops done */
-
-		thr->run_node = parent;
-	} else {
-		eval_node_set_int_val(node->loop_var, loop_var_value);
-
-		thr->run_node = node->stat_list;
-	}
-
-	return(thr);
-}
-
-/**************************************************************************
-Performs an execution step of an exit statement node. */
-
-que_thr_t*
-exit_step(
-/*======*/
-				/* out: query thread to run next or NULL */
-	que_thr_t*	thr)	/* in: query thread */
-{
-	exit_node_t*	node;
-	que_node_t*	loop_node;
-
-	ut_ad(thr);
-
-	node = thr->run_node;
-
-	ut_ad(que_node_get_type(node) == QUE_NODE_EXIT);
-
-	/* Loops exit by setting thr->run_node as the loop node's parent, so
-	find our containing loop node and get its parent. */
-
-	loop_node = que_node_get_containing_loop_node(node);
-
-	/* If someone uses an EXIT statement outside of a loop, this will
-	trigger. */
-	ut_a(loop_node);
-
-	thr->run_node = que_node_get_parent(loop_node);
-
-	return(thr);
-}
-
-/**************************************************************************
-Performs an execution step of a return-statement node. */
-
-que_thr_t*
-return_step(
-/*========*/
-				/* out: query thread to run next or NULL */
-	que_thr_t*	thr)	/* in: query thread */
-{
-	return_node_t*	node;
-	que_node_t*	parent;
-
-	ut_ad(thr);
-
-	node = thr->run_node;
-
-	ut_ad(que_node_get_type(node) == QUE_NODE_RETURN);
-
-	parent = node;
-
-	while (que_node_get_type(parent) != QUE_NODE_PROC) {
-
-		parent = que_node_get_parent(parent);
-	}
-
-	ut_a(parent);
-
-	thr->run_node = que_node_get_parent(parent);
-
-	return(thr);
-}