merge with 3.23.47 (DO statement)

@xref{REPLACE, , @code{REPLACE}}.

@item

The @code{FLUSH flush_option} statement.

The @code{FLUSH}, @code{RESET} and @code{DO} statements.

@item

The ability to set variables in a statement with @code{:=}:

it was never obtained by a call to @code{GET_LOCK()} or if it already has

been released.

The @code{DO} statement is convinient to use with @code{RELEASE_LOCK()}.

@xref{DO}.

@findex BENCHMARK()

@item BENCHMARK(count,expr)

The @code{BENCHMARK()} function executes the expression @code{expr}

* TRUNCATE::                    @code{TRUNCATE} Syntax

* REPLACE::                     @code{REPLACE} Syntax

* LOAD DATA::                   @code{LOAD DATA INFILE} Syntax

* DO::                          @code{DO} Syntax

@end menu

@node SELECT, HANDLER, Data Manipulation, Data Manipulation

row.

@node LOAD DATA,  , REPLACE, Data Manipulation

@node LOAD DATA, DO, REPLACE, Data Manipulation

@subsection @code{LOAD DATA INFILE} Syntax

@findex LOAD DATA INFILE

@xref{Insert speed}.

@node DO,  , LOAD DATA, Data Manipulation

@subsection @code{DO} Syntax

@findex DO

@example

DO expression, [expression, ...]

@end example

Execute the expression but don't return any results.  This is a

shorthand of @code{SELECT expression, expression}, but has the advantage

that it's slightly faster when you don't care about the result.

This is mainly useful with functions that has side effects, like

@code{RELEASE_LOCK}.

@node Data Definition, Basic User Commands, Data Manipulation, Reference

@section Data Definition: @code{CREATE}, @code{DROP}, @code{ALTER}

@appendixsubsec Changes in release 3.23.47

@itemize @bullet

@item

Fixed core-dump bug in replication when using SELECT RELEASE_LOCK();

@item

Added new statement DO expression,[expression].

@item

Added @code{slave-skip-errors} option

@item

Added statistics variables for all MySQL commands. (@code{SHOW STATUS} is

	mutex_exit(&(dict_sys->mutex));

	if (table != NULL) {

		if (table->stat_last_estimate_counter == (ulint)(-1)) {

	        if (!table->stat_initialized) {

			dict_update_statistics(table);

		}

	}

	table->stat_sum_of_other_index_sizes = sum_of_index_sizes

						- index->stat_index_size;

	table->stat_last_estimate_counter = table->stat_modif_counter;

	table->stat_initialized = TRUE;

        table->stat_modified_counter = 0;

}

/*************************************************************************

	table->does_not_fit_in_memory = FALSE;

	table->stat_last_estimate_counter = (ulint)(-1);

	table->stat_initialized = FALSE;

	table->stat_modif_counter = 0;

	table->stat_modified_counter = 0;

	mutex_create(&(table->autoinc_mutex));

	mutex_set_level(&(table->autoinc_mutex), SYNC_DICT_AUTOINC_MUTEX);

				database pages */

	ulint		stat_sum_of_other_index_sizes;

				/* other indexes in database pages */

	ulint		stat_last_estimate_counter;

				/* when the estimates were last time

				calculated; a value (ulint)-1 denotes that

				they have not yet been calculated for this

				table (or the counter has wrapped over) */

	ulint		stat_modif_counter;

	ibool           stat_initialized; /* TRUE if statistics have

				been calculated the first time

			        after database startup or table creation */

	ulint		stat_modified_counter;

				/* when a row is inserted, updated, or deleted,

				we add the row length to this number; we

				calculate new estimates for the stat_...

				values for the table and the indexes at an

				interval of DICT_STAT_CALCULATE_INTERVAL,

				but for small tables more often, also

				interval of 2 GB or when about 1 / 16 of table

				has been modified; also

				when the estimate operation is called

				for MySQL SHOW TABLE STATUS; this counter

				for MySQL SHOW TABLE STATUS; the counter is

				reset to zero at statistics calculation;

				this counter

				is not protected by any latch, because this

				is only used for heuristics */

	/*----------------------*/

};

#define	DICT_TABLE_MAGIC_N	76333786

/* Statistics are calculated at least with this interval; see the struct

above */

#define DICT_STAT_CALCULATE_INTERVAL	(UNIV_PAGE_SIZE * 8)

/* Data structure for a stored procedure */

struct dict_proc_struct{

	mem_heap_t*	heap;	/* memory heap */

	row_prebuilt_t*	prebuilt)	/* in: prebuilt struct */

{

	ulint	counter;

	ulint	old_counter;

	counter = prebuilt->table->stat_modif_counter;

	counter = prebuilt->table->stat_modified_counter;

	counter += prebuilt->mysql_row_len;

	prebuilt->table->stat_modif_counter = counter;

	/* Since the physical size of an InnoDB row is bigger than the

	MySQL row len, we put a safety factor 2 below */

	old_counter = prebuilt->table->stat_last_estimate_counter;

	counter += 2 * prebuilt->mysql_row_len;

	if (counter - old_counter >= DICT_STAT_CALCULATE_INTERVAL

	    || counter - old_counter >=

		(UNIV_PAGE_SIZE

			* prebuilt->table->stat_clustered_index_size / 2)) {

	prebuilt->table->stat_modified_counter = counter;

	/* Calculate new statistics if 1 / 16 of table has been modified

	since the last time a statistics batch was run, or if

	stat_modified_counter > 2 000 000 000 (to avoid wrap-around) */

	if (counter > 2000000000

	    || ((ib_longlong)counter >

		(UNIV_PAGE_SIZE * prebuilt->table->stat_clustered_index_size)

		/ 16)) {

		dict_update_statistics(prebuilt->table);

	}	

		os_event_set(srv_lock_timeout_thread_event);

	}

	keywordlen = ut_strlen("innodb_mem_validate");

	if (namelen >= keywordlen

		    && 0 == ut_memcmp(table->name + namelen - keywordlen,

 				"innodb_mem_validate", keywordlen)) {

	        /* We define here a debugging feature intended for

		developers */

	        printf("Validating InnoDB memory:\n"

		 "to use this feature you must compile InnoDB with\n"

		 "UNIV_MEM_DEBUG defined in univ.i and the server must be\n"

		 "quiet because allocation from a mem heap is not protected\n"

		       "by any semaphore.\n");

		ut_a(mem_validate());

		printf("Memory validated\n");

	}

	/* Serialize data dictionary operations with dictionary mutex:

	no deadlocks can occur then in these operations */