branches/zip: Merge revisions 720:765 from trunk and reindent the code

as per revisions r763:765.

btr/btr0pcur.c

@@ -92,9 +92,9 @@ btr_pcur_store_position(
 	offs = ut_align_offset(rec, UNIV_PAGE_SIZE);
 
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-			MTR_MEMO_PAGE_S_FIX)
-		|| mtr_memo_contains(mtr, buf_block_align(page),
-			MTR_MEMO_PAGE_X_FIX));
+				MTR_MEMO_PAGE_S_FIX)
+	      || mtr_memo_contains(mtr, buf_block_align(page),
+				   MTR_MEMO_PAGE_X_FIX));
 	ut_a(cursor->latch_mode != BTR_NO_LATCHES);
 
 	if (UNIV_UNLIKELY(page_get_n_recs(page) == 0)) {
@@ -133,14 +133,13 @@ btr_pcur_store_position(
 	}
 
 	cursor->old_stored = BTR_PCUR_OLD_STORED;
-	cursor->old_rec = dict_tree_copy_rec_order_prefix(tree, rec,
-						&cursor->old_n_fields,
-						&cursor->old_rec_buf,
-						&cursor->buf_size);
+	cursor->old_rec = dict_tree_copy_rec_order_prefix
+		(tree, rec, &cursor->old_n_fields,
+		 &cursor->old_rec_buf, &cursor->buf_size);
 
 	cursor->block_when_stored = buf_block_align(page);
-	cursor->modify_clock = buf_block_get_modify_clock(
-				cursor->block_when_stored);
+	cursor->modify_clock = buf_block_get_modify_clock
+		(cursor->block_when_stored);
 }
 
 /******************************************************************
@@ -165,7 +164,7 @@ btr_pcur_copy_stored_position(
 		pcur_receive->old_rec_buf = mem_alloc(pcur_donate->buf_size);
 
 		ut_memcpy(pcur_receive->old_rec_buf, pcur_donate->old_rec_buf,
-						pcur_donate->buf_size);
+			  pcur_donate->buf_size);
 		pcur_receive->old_rec = pcur_receive->old_rec_buf
 			+ (pcur_donate->old_rec - pcur_donate->old_rec_buf);
 	}
@@ -206,8 +205,8 @@ btr_pcur_restore_position(
 	mem_heap_t*	heap;
 
 	if (UNIV_UNLIKELY(cursor->old_stored != BTR_PCUR_OLD_STORED)
-		|| UNIV_UNLIKELY(cursor->pos_state != BTR_PCUR_WAS_POSITIONED
-			&& cursor->pos_state != BTR_PCUR_IS_POSITIONED)) {
+	    || UNIV_UNLIKELY(cursor->pos_state != BTR_PCUR_WAS_POSITIONED
+			     && cursor->pos_state != BTR_PCUR_IS_POSITIONED)) {
 		ut_print_buf(stderr, cursor, sizeof(btr_pcur_t));
 		if (cursor->trx_if_known) {
 			trx_print(stderr, cursor->trx_if_known, 0);
@@ -216,19 +215,20 @@ btr_pcur_restore_position(
 		ut_error;
 	}
 
-	if (UNIV_UNLIKELY(cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
-			|| cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE)) {
+	if (UNIV_UNLIKELY
+	    (cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
+	     || cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE)) {
 
 		/* In these cases we do not try an optimistic restoration,
 		but always do a search */
 
-		btr_cur_open_at_index_side(
-			cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
-			btr_pcur_get_btr_cur(cursor)->index, latch_mode,
-					btr_pcur_get_btr_cur(cursor), mtr);
+		btr_cur_open_at_index_side
+			(cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
+			 btr_pcur_get_btr_cur(cursor)->index, latch_mode,
+			 btr_pcur_get_btr_cur(cursor), mtr);
 
-		cursor->block_when_stored =
-				buf_block_align(btr_pcur_get_page(cursor));
+		cursor->block_when_stored
+			= buf_block_align(btr_pcur_get_page(cursor));
 
 		return(FALSE);
 	}
@@ -239,12 +239,13 @@ btr_pcur_restore_position(
 	page = btr_cur_get_page(btr_pcur_get_btr_cur(cursor));
 
 	if (UNIV_LIKELY(latch_mode == BTR_SEARCH_LEAF)
-			|| UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF)) {
+	    || UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF)) {
 		/* Try optimistic restoration */
 
-		if (UNIV_LIKELY(buf_page_optimistic_get(latch_mode,
-					cursor->block_when_stored, page,
-					cursor->modify_clock, mtr))) {
+		if (UNIV_LIKELY
+		    (buf_page_optimistic_get(latch_mode,
+					     cursor->block_when_stored, page,
+					     cursor->modify_clock, mtr))) {
 			cursor->pos_state = BTR_PCUR_IS_POSITIONED;
 #ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(page, SYNC_TREE_NODE);
@@ -262,14 +263,16 @@ btr_pcur_restore_position(
 				index = btr_pcur_get_btr_cur(cursor)->index;
 
 				heap = mem_heap_create(256);
-				offsets1 = rec_get_offsets(cursor->old_rec,
-						index, NULL,
-						cursor->old_n_fields, &heap);
-				offsets2 = rec_get_offsets(rec, index, NULL,
-						cursor->old_n_fields, &heap);
-
-				ut_ad(cmp_rec_rec(cursor->old_rec,
-					rec, offsets1, offsets2, index) == 0);
+				offsets1 = rec_get_offsets
+					(cursor->old_rec, index, NULL,
+					 cursor->old_n_fields, &heap);
+				offsets2 = rec_get_offsets
+					(rec, index, NULL,
+					 cursor->old_n_fields, &heap);
+
+				ut_ad(!cmp_rec_rec(cursor->old_rec,
+						   rec, offsets1, offsets2,
+						   index));
 				mem_heap_free(heap);
 #endif /* UNIV_DEBUG */
 				return(TRUE);
@@ -285,7 +288,7 @@ btr_pcur_restore_position(
 
 	tree = btr_cur_get_tree(btr_pcur_get_btr_cur(cursor));
 	tuple = dict_tree_build_data_tuple(tree, cursor->old_rec,
-					cursor->old_n_fields, heap);
+					   cursor->old_n_fields, heap);
 
 	/* Save the old search mode of the cursor */
 	old_mode = cursor->search_mode;
@@ -300,26 +303,27 @@ btr_pcur_restore_position(
 	}
 
 	btr_pcur_open_with_no_init(btr_pcur_get_btr_cur(cursor)->index, tuple,
-					mode, latch_mode, cursor, 0, mtr);
+				   mode, latch_mode, cursor, 0, mtr);
 
 	/* Restore the old search mode */
 	cursor->search_mode = old_mode;
 
 	if (cursor->rel_pos == BTR_PCUR_ON
-		&& btr_pcur_is_on_user_rec(cursor, mtr)
-		&& 0 == cmp_dtuple_rec(tuple, btr_pcur_get_rec(cursor),
-			rec_get_offsets(btr_pcur_get_rec(cursor),
-				btr_pcur_get_btr_cur(cursor)->index,
-				NULL, ULINT_UNDEFINED, &heap))) {
+	    && btr_pcur_is_on_user_rec(cursor, mtr)
+	    && 0 == cmp_dtuple_rec(tuple, btr_pcur_get_rec(cursor),
+				   rec_get_offsets
+				   (btr_pcur_get_rec(cursor),
+				    btr_pcur_get_btr_cur(cursor)->index,
+				    NULL, ULINT_UNDEFINED, &heap))) {
 
 		/* We have to store the NEW value for the modify clock, since
 		the cursor can now be on a different page! But we can retain
 		the value of old_rec */
 
-		cursor->block_when_stored =
-			buf_block_align(btr_pcur_get_page(cursor));
-		cursor->modify_clock =
-			buf_block_get_modify_clock(cursor->block_when_stored);
+		cursor->block_when_stored = buf_block_align
+			(btr_pcur_get_page(cursor));
+		cursor->modify_clock = buf_block_get_modify_clock
+			(cursor->block_when_stored);
 		cursor->old_stored = BTR_PCUR_OLD_STORED;
 
 		mem_heap_free(heap);
@@ -467,14 +471,14 @@ btr_pcur_move_backward_from_page(
 	space = buf_frame_get_space_id(page);
 
 	if (btr_pcur_is_before_first_on_page(cursor, mtr)
-					&& (prev_page_no != FIL_NULL)) {
+	    && (prev_page_no != FIL_NULL)) {
 
 		prev_page = btr_pcur_get_btr_cur(cursor)->left_page;
 
 		btr_leaf_page_release(page, latch_mode, mtr);
 
 		page_cur_set_after_last(prev_page,
-						btr_pcur_get_page_cur(cursor));
+					btr_pcur_get_page_cur(cursor));
 	} else if (prev_page_no != FIL_NULL) {
 
 		/* The repositioned cursor did not end on an infimum record on

data/data0data.c

@@ -190,10 +190,10 @@ dfield_check_typed_no_assert(
 	dfield_t*	field)	/* in: data field */
 {
 	if (dfield_get_type(field)->mtype > DATA_MYSQL
-		|| dfield_get_type(field)->mtype < DATA_VARCHAR) {
+	    || dfield_get_type(field)->mtype < DATA_VARCHAR) {
 
 		fprintf(stderr,
-"InnoDB: Error: data field type %lu, len %lu\n",
+			"InnoDB: Error: data field type %lu, len %lu\n",
 			(ulong) dfield_get_type(field)->mtype,
 			(ulong) dfield_get_len(field));
 		return(FALSE);
@@ -216,9 +216,9 @@ dtuple_check_typed_no_assert(
 
 	if (dtuple_get_n_fields(tuple) > REC_MAX_N_FIELDS) {
 		fprintf(stderr,
-"InnoDB: Error: index entry has %lu fields\n",
+			"InnoDB: Error: index entry has %lu fields\n",
 			(ulong) dtuple_get_n_fields(tuple));
-	dump:
+dump:
 		fputs("InnoDB: Tuple contents: ", stderr);
 		dtuple_print(stderr, tuple);
 		putc('\n', stderr);
@@ -248,10 +248,10 @@ dfield_check_typed(
 	dfield_t*	field)	/* in: data field */
 {
 	if (dfield_get_type(field)->mtype > DATA_MYSQL
-		|| dfield_get_type(field)->mtype < DATA_VARCHAR) {
+	    || dfield_get_type(field)->mtype < DATA_VARCHAR) {
 
 		fprintf(stderr,
-"InnoDB: Error: data field type %lu, len %lu\n",
+			"InnoDB: Error: data field type %lu, len %lu\n",
 			(ulong) dfield_get_type(field)->mtype,
 			(ulong) dfield_get_len(field));
 
@@ -320,8 +320,8 @@ dtuple_validate(
 			for (j = 0; j < len; j++) {
 
 				data_dummy  += *data; /* fool the compiler not
-							to optimize out this
-							code */
+						      to optimize out this
+						      code */
 				data++;
 			}
 		}
@@ -434,15 +434,20 @@ dfield_print_also_hex(
 
 /*****************************************************************
 Print a dfield value using ut_print_buf. */
-
+static
 void
 dfield_print_raw(
 /*=============*/
 	FILE*		f,		/* in: output stream */
 	dfield_t*	dfield)		/* in: dfield */
 {
-	if (dfield->len != UNIV_SQL_NULL) {
-		ut_print_buf(f, dfield->data, dfield->len);
+	ulint	len	= dfield->len;
+	if (len != UNIV_SQL_NULL) {
+		ulint	print_len = ut_min(len, 1000);
+		ut_print_buf(f, dfield->data, print_len);
+		if (len != print_len) {
+			fprintf(f, "(total %lu bytes)", (ulong) len);
+		}
 	} else {
 		fputs(" SQL NULL", f);
 	}
@@ -518,14 +523,15 @@ dtuple_convert_big_rec(
 
 	if (UNIV_UNLIKELY(size > 1000000000)) {
 		fprintf(stderr,
-"InnoDB: Warning: tuple size very big: %lu\n", (ulong) size);
+			"InnoDB: Warning: tuple size very big: %lu\n",
+			(ulong) size);
 		fputs("InnoDB: Tuple contents: ", stderr);
 		dtuple_print(stderr, entry);
 		putc('\n', stderr);
 	}
 
 	heap = mem_heap_create(size + dtuple_get_n_fields(entry)
-					* sizeof(big_rec_field_t) + 1000);
+			       * sizeof(big_rec_field_t) + 1000);
 
 	vector = mem_heap_alloc(heap, sizeof(big_rec_t));
 
@@ -539,12 +545,12 @@ dtuple_convert_big_rec(
 	n_fields = 0;
 
 	while (page_zip_rec_needs_ext(rec_get_converted_size(index, entry),
-			dict_table_is_comp(index->table),
-			dict_table_zip_size(index->table))) {
+				      dict_table_is_comp(index->table),
+				      dict_table_zip_size(index->table))) {
 
 		longest = 0;
 		for (i = dict_index_get_n_unique_in_tree(index);
-				i < dtuple_get_n_fields(entry); i++) {
+		     i < dtuple_get_n_fields(entry); i++) {
 
 			/* Skip over fields which already are externally
 			stored */
@@ -560,7 +566,7 @@ dtuple_convert_big_rec(
 			dfield = dtuple_get_nth_field(entry, i);
 
 			if (dfield->len != UNIV_SQL_NULL
-				&& dfield->len > longest) {
+			    && dfield->len > longest) {
 
 				longest = dfield->len;
 
@@ -579,7 +585,7 @@ dtuple_convert_big_rec(
 #endif
 
 		if (longest < BTR_EXTERN_FIELD_REF_SIZE + 10
-						+ DICT_MAX_INDEX_COL_LEN) {
+		    + DICT_MAX_INDEX_COL_LEN) {
 			/* Cannot shorten more */
 
 			mem_heap_free(heap);
@@ -604,24 +610,24 @@ dtuple_convert_big_rec(
 		ut_a(dfield->len > DICT_MAX_INDEX_COL_LEN);
 
 		vector->fields[n_fields].len = dfield->len
-						- DICT_MAX_INDEX_COL_LEN;
+			- DICT_MAX_INDEX_COL_LEN;
 
-		vector->fields[n_fields].data = mem_heap_alloc(heap,
-						vector->fields[n_fields].len);
+		vector->fields[n_fields].data = mem_heap_alloc
+			(heap, vector->fields[n_fields].len);
 
 		/* Copy data (from the end of field) to big rec vector */
 
 		ut_memcpy(vector->fields[n_fields].data,
-				((byte*)dfield->data) + dfield->len
-						- vector->fields[n_fields].len,
-				vector->fields[n_fields].len);
+			  ((byte*)dfield->data) + dfield->len
+			  - vector->fields[n_fields].len,
+			  vector->fields[n_fields].len);
 		dfield->len = dfield->len - vector->fields[n_fields].len
-						+ BTR_EXTERN_FIELD_REF_SIZE;
+			+ BTR_EXTERN_FIELD_REF_SIZE;
 
 		/* Set the extern field reference in dfield to zero */
 		memset(((byte*)dfield->data)
-			+ dfield->len - BTR_EXTERN_FIELD_REF_SIZE,
-					0, BTR_EXTERN_FIELD_REF_SIZE);
+		       + dfield->len - BTR_EXTERN_FIELD_REF_SIZE,
+		       0, BTR_EXTERN_FIELD_REF_SIZE);
 		n_fields++;
 	}
 
@@ -648,15 +654,15 @@ dtuple_convert_back_big_rec(
 	for (i = 0; i < vector->n_fields; i++) {
 
 		dfield = dtuple_get_nth_field(entry,
-						vector->fields[i].field_no);
+					      vector->fields[i].field_no);
 		/* Copy data from big rec vector */
 
 		ut_memcpy(((byte*)dfield->data)
-				+ dfield->len - BTR_EXTERN_FIELD_REF_SIZE,
+			  + dfield->len - BTR_EXTERN_FIELD_REF_SIZE,
 			vector->fields[i].data,
 			vector->fields[i].len);
 		dfield->len = dfield->len + vector->fields[i].len
-						- BTR_EXTERN_FIELD_REF_SIZE;
+			- BTR_EXTERN_FIELD_REF_SIZE;
 	}
 
 	mem_heap_free(vector->heap);

data/data0type.c

@@ -67,9 +67,9 @@ dtype_get_at_most_n_mbchars(
 
 	if (dtype->mbminlen != dtype->mbmaxlen) {
 		ut_a(!(prefix_len % dtype->mbmaxlen));
-		return(innobase_get_at_most_n_mbchars(
-				dtype_get_charset_coll(dtype->prtype),
-				prefix_len, data_len, str));
+		return(innobase_get_at_most_n_mbchars
+		       (dtype_get_charset_coll(dtype->prtype),
+			prefix_len, data_len, str));
 	}
 
 	if (prefix_len < data_len) {
@@ -98,8 +98,8 @@ dtype_is_string_type(
 	ulint	mtype)	/* in: InnoDB main data type code: DATA_CHAR, ... */
 {
 	if (mtype <= DATA_BLOB
-		|| mtype == DATA_MYSQL
-		|| mtype == DATA_VARMYSQL) {
+	    || mtype == DATA_MYSQL
+	    || mtype == DATA_VARMYSQL) {
 
 		return(TRUE);
 	}
@@ -120,8 +120,8 @@ dtype_is_binary_string_type(
 	ulint	prtype)	/* in: precise type */
 {
 	if ((mtype == DATA_FIXBINARY)
-		|| (mtype == DATA_BINARY)
-		|| (mtype == DATA_BLOB && (prtype & DATA_BINARY_TYPE))) {
+	    || (mtype == DATA_BINARY)
+	    || (mtype == DATA_BLOB && (prtype & DATA_BINARY_TYPE))) {
 
 		return(TRUE);
 	}
@@ -143,7 +143,7 @@ dtype_is_non_binary_string_type(
 	ulint	prtype)	/* in: precise type */
 {
 	if (dtype_is_string_type(mtype) == TRUE
-		&& dtype_is_binary_string_type(mtype, prtype) == FALSE) {
+	    && dtype_is_binary_string_type(mtype, prtype) == FALSE) {
 
 		return(TRUE);
 	}
@@ -258,8 +258,8 @@ dtype_print(
 	len = type->len;
 
 	if ((type->mtype == DATA_SYS)
-	   || (type->mtype == DATA_VARCHAR)
-	   || (type->mtype == DATA_CHAR)) {
+	    || (type->mtype == DATA_VARCHAR)
+	    || (type->mtype == DATA_CHAR)) {
 		putc(' ', stderr);
 		if (prtype == DATA_ROW_ID) {
 			fputs("DATA_ROW_ID", stderr);
@@ -317,9 +317,9 @@ dtype_get_max_size(
 	case DATA_BINARY:
 	case DATA_DECIMAL:
 	case DATA_VARMYSQL:
-			return(type->len);
+		return(type->len);
 	case DATA_BLOB:
-			return(ULINT_MAX);
+		return(ULINT_MAX);
 	default:
 		ut_error;
 	}

dict/dict0mem.c

@@ -64,7 +64,7 @@ dict_mem_table_create(
 	table->cached = FALSE;
 
 	table->cols = mem_heap_alloc(heap, (n_cols + DATA_N_SYS_COLS)
-							* sizeof(dict_col_t));
+				     * sizeof(dict_col_t));
 	UT_LIST_INIT(table->indexes);
 
 	table->auto_inc_lock = mem_heap_alloc(heap, lock_get_size());
@@ -176,9 +176,9 @@ dict_mem_index_create(
 	index->n_def = index->n_nullable = 0;
 	index->n_fields = n_fields;
 	index->fields = mem_heap_alloc(heap, 1 + n_fields
-						* sizeof(dict_field_t));
-					/* The '1 +' above prevents allocation
-					of an empty mem block */
+				       * sizeof(dict_field_t));
+	/* The '1 +' above prevents allocation
+	of an empty mem block */
 	index->stat_n_diff_key_vals = NULL;
 
 	index->cached = FALSE;

handler/ha_innodb.cc

@@ -7405,7 +7405,9 @@ innobase_xa_prepare(
 	int error = 0;
 	trx_t* trx = check_trx_exists(thd);
 
-	if (thd->lex->sql_command != SQLCOM_XA_PREPARE) {
+	if (thd->lex->sql_command != SQLCOM_XA_PREPARE &&
+	    (all || !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))))
+	{
 
 		/* For ibbackup to work the order of transactions in binlog
 		and InnoDB must be the same. Consider the situation