2 files changed, 112 insertions, 147 deletions

diff --git a/storage/innobase/mtr/mtr0log.cc b/storage/innobase/mtr/mtr0log.cc
index 9cc9b77d6a8..6baf1f06bf9 100644
--- a/storage/innobase/mtr/mtr0log.cc
+++ b/storage/innobase/mtr/mtr0log.cc
@@ -148,7 +148,7 @@ mlog_parse_nbytes(
 	offset = mach_read_from_2(ptr);
 	ptr += 2;
 
-	if (offset >= UNIV_PAGE_SIZE) {
+	if (offset >= srv_page_size) {
 		recv_sys->found_corrupt_log = TRUE;
 
 		return(NULL);
@@ -316,7 +316,7 @@ mlog_write_string(
 	mtr_t*		mtr)	/*!< in: mini-transaction handle */
 {
 	ut_ad(ptr && mtr);
-	ut_a(len < UNIV_PAGE_SIZE);
+	ut_a(len < srv_page_size);
 
 	memcpy(ptr, str, len);
 
@@ -336,7 +336,7 @@ mlog_log_string(
 	byte*	log_ptr;
 
 	ut_ad(ptr && mtr);
-	ut_ad(len <= UNIV_PAGE_SIZE);
+	ut_ad(len <= srv_page_size);
 
 	log_ptr = mlog_open(mtr, 30);
 
@@ -387,7 +387,7 @@ mlog_parse_string(
 	len = mach_read_from_2(ptr);
 	ptr += 2;
 
-	if (offset >= UNIV_PAGE_SIZE || len + offset > UNIV_PAGE_SIZE) {
+	if (offset >= srv_page_size || len + offset > srv_page_size) {
 		recv_sys->found_corrupt_log = TRUE;
 
 		return(NULL);
@@ -430,23 +430,30 @@ mlog_open_and_write_index(
 
 	ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table));
 
+	mtr->set_modified();
+	switch (mtr->get_log_mode()) {
+	case MTR_LOG_NONE:
+	case MTR_LOG_NO_REDO:
+		return NULL;
+	case MTR_LOG_SHORT_INSERTS:
+		ut_ad(0);
+		/* fall through */
+	case MTR_LOG_ALL:
+		break;
+	}
+
 	if (!page_rec_is_comp(rec)) {
-		log_start = log_ptr = mlog_open(mtr, 11 + size);
-		if (!log_ptr) {
-			return(NULL); /* logging is disabled */
-		}
+		log_start = log_ptr = mtr->get_log()->open(11 + size);
 		log_ptr = mlog_write_initial_log_record_fast(rec, type,
 							     log_ptr, mtr);
 		log_end = log_ptr + 11 + size;
 	} else {
 		ulint	i;
+		bool	is_instant = index->is_instant();
 		ulint	n	= dict_index_get_n_fields(index);
-		ulint	total	= 11 + size + (n + 2) * 2;
-		ulint	alloc	= total;
-
-		if (alloc > mtr_buf_t::MAX_DATA_SIZE) {
-			alloc = mtr_buf_t::MAX_DATA_SIZE;
-		}
+		ulint	total	= 11 + (is_instant ? 2 : 0) + size + (n + 2) * 2;
+		ulint	alloc	= std::min(total,
+					   ulint(mtr_buf_t::MAX_DATA_SIZE));
 
 		const bool is_leaf = page_is_leaf(page_align(rec));
 
@@ -456,30 +463,30 @@ mlog_open_and_write_index(
 			n = DICT_INDEX_SPATIAL_NODEPTR_SIZE;
 		}
 
-		log_start = log_ptr = mlog_open(mtr, alloc);
-
-		if (!log_ptr) {
-			return(NULL); /* logging is disabled */
-		}
-
+		log_start = log_ptr = mtr->get_log()->open(alloc);
 		log_end = log_ptr + alloc;
 
 		log_ptr = mlog_write_initial_log_record_fast(
 			rec, type, log_ptr, mtr);
 
-		mach_write_to_2(log_ptr, n);
-		log_ptr += 2;
+		if (is_instant) {
+			// marked as instant index
+			mach_write_to_2(log_ptr, n | 0x8000);
+
+			log_ptr += 2;
 
-		if (is_leaf) {
-			mach_write_to_2(
-				log_ptr, dict_index_get_n_unique_in_tree(index));
+			// record the n_core_fields
+			mach_write_to_2(log_ptr, index->n_core_fields);
 		} else {
-			mach_write_to_2(
-				log_ptr,
-				dict_index_get_n_unique_in_tree_nonleaf(index));
+			mach_write_to_2(log_ptr, n);
 		}
 
 		log_ptr += 2;
+		mach_write_to_2(
+			log_ptr, is_leaf
+			? dict_index_get_n_unique_in_tree(index)
+			: dict_index_get_n_unique_in_tree_nonleaf(index));
+		log_ptr += 2;
 
 		for (i = 0; i < n; i++) {
 			dict_field_t*		field;
@@ -501,19 +508,14 @@ mlog_open_and_write_index(
 			}
 			if (log_ptr + 2 > log_end) {
 				mlog_close(mtr, log_ptr);
-				ut_a(total > (ulint) (log_ptr - log_start));
-				total -= log_ptr - log_start;
-				alloc = total;
-
-				if (alloc > mtr_buf_t::MAX_DATA_SIZE) {
-					alloc = mtr_buf_t::MAX_DATA_SIZE;
-				}
-
-				log_start = log_ptr = mlog_open(mtr, alloc);
-
-				if (!log_ptr) {
-					return(NULL); /* logging is disabled */
-				}
+				ut_a(total > ulint(log_ptr - log_start));
+				total -= ulint(log_ptr - log_start);
+				alloc = std::min(
+					total,
+					ulint(mtr_buf_t::MAX_DATA_SIZE));
+
+				log_start = log_ptr = mtr->get_log()->open(
+					alloc);
 				log_end = log_ptr + alloc;
 			}
 			mach_write_to_2(log_ptr, len);
@@ -544,6 +546,7 @@ mlog_parse_index(
 	ulint		i, n, n_uniq;
 	dict_table_t*	table;
 	dict_index_t*	ind;
+	ulint		n_core_fields = 0;
 
 	ut_ad(comp == FALSE || comp == TRUE);
 
@@ -553,6 +556,23 @@ mlog_parse_index(
 		}
 		n = mach_read_from_2(ptr);
 		ptr += 2;
+		if (n & 0x8000) { /* record after instant ADD COLUMN */
+			n &= 0x7FFF;
+
+			n_core_fields = mach_read_from_2(ptr);
+
+			if (!n_core_fields || n_core_fields > n) {
+				recv_sys->found_corrupt_log = TRUE;
+				return(NULL);
+			}
+
+			ptr += 2;
+
+			if (end_ptr < ptr + 2) {
+				return(NULL);
+			}
+		}
+
 		n_uniq = mach_read_from_2(ptr);
 		ptr += 2;
 		ut_ad(n_uniq <= n);
@@ -562,11 +582,9 @@ mlog_parse_index(
 	} else {
 		n = n_uniq = 1;
 	}
-	table = dict_mem_table_create("LOG_DUMMY", DICT_HDR_SPACE, n, 0,
+	table = dict_mem_table_create("LOG_DUMMY", NULL, n, 0,
 				      comp ? DICT_TF_COMPACT : 0, 0);
-	ind = dict_mem_index_create("LOG_DUMMY", "LOG_DUMMY",
-				    DICT_HDR_SPACE, 0, n);
-	ind->table = table;
+	ind = dict_mem_index_create(table, "LOG_DUMMY", 0, n);
 	ind->n_uniq = (unsigned int) n_uniq;
 	if (n_uniq != n) {
 		ut_a(n_uniq + DATA_ROLL_PTR <= n);
@@ -604,6 +622,22 @@ mlog_parse_index(
 			ind->fields[DATA_ROLL_PTR - 1 + n_uniq].col
 				= &table->cols[n + DATA_ROLL_PTR];
 		}
+
+		ut_ad(table->n_cols == table->n_def);
+
+		if (n_core_fields) {
+			for (i = n_core_fields; i < n; i++) {
+				ind->fields[i].col->def_val.len
+					= UNIV_SQL_NULL;
+			}
+			ind->n_core_fields = n_core_fields;
+			ind->n_core_null_bytes = UT_BITS_IN_BYTES(
+				ind->get_n_nullable(n_core_fields));
+		} else {
+			ind->n_core_null_bytes = UT_BITS_IN_BYTES(
+				unsigned(ind->n_nullable));
+			ind->n_core_fields = ind->n_fields;
+		}
 	}
 	/* avoid ut_ad(index->cached) in dict_index_get_n_unique_in_tree */
 	ind->cached = TRUE;
diff --git a/storage/innobase/mtr/mtr0mtr.cc b/storage/innobase/mtr/mtr0mtr.cc
index dafa41e7a9c..92b1aa38a81 100644
--- a/storage/innobase/mtr/mtr0mtr.cc
+++ b/storage/innobase/mtr/mtr0mtr.cc
@@ -467,7 +467,7 @@ mtr_write_log(
 	ut_ad(!recv_no_log_write);
 	DBUG_PRINT("ib_log",
 		   (ULINTPF " extra bytes written at " LSN_PF,
-		    len, log_sys->lsn));
+		    len, log_sys.lsn));
 
 	log_reserve_and_open(len);
 	log->for_each_block(write_log);
@@ -495,8 +495,6 @@ void mtr_t::start()
 	m_impl.m_state = MTR_STATE_ACTIVE;
 	ut_d(m_impl.m_user_space_id = TRX_SYS_SPACE);
 	m_impl.m_user_space = NULL;
-	m_impl.m_undo_space = NULL;
-	m_impl.m_sys_space = NULL;
 	m_impl.m_flush_observer = NULL;
 
 	ut_d(m_impl.m_magic_n = MTR_MAGIC_N);
@@ -593,9 +591,7 @@ mtr_t::commit_checkpoint(
 
 	if (write_mlog_checkpoint) {
 		byte*	ptr = m_impl.m_log.push<byte*>(SIZE_OF_MLOG_CHECKPOINT);
-#if SIZE_OF_MLOG_CHECKPOINT != 9
-# error SIZE_OF_MLOG_CHECKPOINT != 9
-#endif
+		compile_time_assert(SIZE_OF_MLOG_CHECKPOINT == 1 + 8);
 		*ptr = MLOG_CHECKPOINT;
 		mach_write_to_8(ptr + 1, checkpoint_lsn);
 	}
@@ -607,7 +603,7 @@ mtr_t::commit_checkpoint(
 	if (write_mlog_checkpoint) {
 		DBUG_PRINT("ib_log",
 			   ("MLOG_CHECKPOINT(" LSN_PF ") written at " LSN_PF,
-			    checkpoint_lsn, log_sys->lsn));
+			    checkpoint_lsn, log_sys.lsn));
 	}
 }
 
@@ -619,18 +615,8 @@ mtr_t::commit_checkpoint(
 bool
 mtr_t::is_named_space(ulint space) const
 {
-	ut_ad(!m_impl.m_sys_space
-	      || m_impl.m_sys_space->id == TRX_SYS_SPACE);
-	ut_ad(!m_impl.m_undo_space
-	      || m_impl.m_undo_space->id != TRX_SYS_SPACE);
 	ut_ad(!m_impl.m_user_space
 	      || m_impl.m_user_space->id != TRX_SYS_SPACE);
-	ut_ad(!m_impl.m_sys_space
-	      || m_impl.m_sys_space != m_impl.m_user_space);
-	ut_ad(!m_impl.m_sys_space
-	      || m_impl.m_sys_space != m_impl.m_undo_space);
-	ut_ad(!m_impl.m_user_space
-	      || m_impl.m_user_space != m_impl.m_undo_space);
 
 	switch (get_log_mode()) {
 	case MTR_LOG_NONE:
@@ -645,6 +631,28 @@ mtr_t::is_named_space(ulint space) const
 	ut_error;
 	return(false);
 }
+/** Check if a tablespace is associated with the mini-transaction
+(needed for generating a MLOG_FILE_NAME record)
+@param[in]	space	tablespace
+@return whether the mini-transaction is associated with the space */
+bool mtr_t::is_named_space(const fil_space_t* space) const
+{
+	ut_ad(!m_impl.m_user_space
+	      || m_impl.m_user_space->id != TRX_SYS_SPACE);
+
+	switch (get_log_mode()) {
+	case MTR_LOG_NONE:
+	case MTR_LOG_NO_REDO:
+		return true;
+	case MTR_LOG_ALL:
+	case MTR_LOG_SHORT_INSERTS:
+		return(m_impl.m_user_space == space
+		       || is_predefined_tablespace(space->id));
+	}
+
+	ut_error;
+	return false;
+}
 #endif /* UNIV_DEBUG */
 
 /** Acquire a tablespace X-latch.
@@ -662,22 +670,15 @@ mtr_t::x_lock_space(ulint space_id, const char* file, unsigned line)
 	ut_ad(is_active());
 
 	if (space_id == TRX_SYS_SPACE) {
-		space = m_impl.m_sys_space;
-
-		if (!space) {
-			space = m_impl.m_sys_space = fil_space_get(space_id);
-		}
+		space = fil_system.sys_space;
 	} else if ((space = m_impl.m_user_space) && space_id == space->id) {
-	} else if ((space = m_impl.m_undo_space) && space_id == space->id) {
-	} else if (get_log_mode() == MTR_LOG_NO_REDO) {
+	} else {
 		space = fil_space_get(space_id);
-		ut_ad(space->purpose == FIL_TYPE_TEMPORARY
+		ut_ad(get_log_mode() != MTR_LOG_NO_REDO
+		      || space->purpose == FIL_TYPE_TEMPORARY
 		      || space->purpose == FIL_TYPE_IMPORT
-		      || space->redo_skipped_count > 0
+		      || my_atomic_loadlint(&space->redo_skipped_count) > 0
 		      || srv_is_tablespace_truncated(space->id));
-	} else {
-		/* called from trx_rseg_create() */
-		space = m_impl.m_undo_space = fil_space_get(space_id);
 	}
 
 	ut_ad(space);
@@ -689,44 +690,6 @@ mtr_t::x_lock_space(ulint space_id, const char* file, unsigned line)
 	return(space);
 }
 
-/** Look up the system tablespace. */
-void
-mtr_t::lookup_sys_space()
-{
-	ut_ad(!m_impl.m_sys_space);
-	m_impl.m_sys_space = fil_space_get(TRX_SYS_SPACE);
-	ut_ad(m_impl.m_sys_space);
-}
-
-/** Look up the user tablespace.
-@param[in]	space_id	tablespace ID */
-void
-mtr_t::lookup_user_space(ulint space_id)
-{
-	ut_ad(space_id != TRX_SYS_SPACE);
-	ut_ad(m_impl.m_user_space_id == space_id);
-	ut_ad(!m_impl.m_user_space);
-	m_impl.m_user_space = fil_space_get(space_id);
-	ut_ad(m_impl.m_user_space);
-}
-
-/** Set the tablespace associated with the mini-transaction
-(needed for generating a MLOG_FILE_NAME record)
-@param[in]	space	user or system tablespace */
-void
-mtr_t::set_named_space(fil_space_t* space)
-{
-	ut_ad(m_impl.m_user_space_id == TRX_SYS_SPACE);
-	ut_d(m_impl.m_user_space_id = space->id);
-	if (space->id == TRX_SYS_SPACE) {
-		ut_ad(m_impl.m_sys_space == NULL
-		      || m_impl.m_sys_space == space);
-		m_impl.m_sys_space = space;
-	} else {
-		m_impl.m_user_space = space;
-	}
-}
-
 /** Release an object in the memo stack.
 @return true if released */
 bool
@@ -790,7 +753,7 @@ mtr_t::Command::prepare_write()
 	case MTR_LOG_NONE:
 		ut_ad(m_impl->m_log.size() == 0);
 		log_mutex_enter();
-		m_end_lsn = m_start_lsn = log_sys->lsn;
+		m_end_lsn = m_start_lsn = log_sys.lsn;
 		return(0);
 	case MTR_LOG_ALL:
 		break;
@@ -801,8 +764,8 @@ mtr_t::Command::prepare_write()
 	ut_ad(len > 0);
 	ut_ad(n_recs > 0);
 
-	if (len > log_sys->buf_size / 2) {
-		log_buffer_extend((len + 1) * 2);
+	if (len > srv_log_buffer_size / 2) {
+		log_buffer_extend(ulong((len + 1) * 2));
 	}
 
 	ut_ad(m_impl->m_n_log_recs == n_recs);
@@ -956,38 +919,6 @@ mtr_t::Command::execute()
 	release_resources();
 }
 
-/** Release the free extents that was reserved using
-fsp_reserve_free_extents().  This is equivalent to calling
-fil_space_release_free_extents().  This is intended for use
-with index pages.
-@param[in]	n_reserved	number of reserved extents */
-void
-mtr_t::release_free_extents(ulint n_reserved)
-{
-	fil_space_t*	space;
-
-	ut_ad(m_impl.m_undo_space == NULL);
-
-	if (m_impl.m_user_space != NULL) {
-
-		ut_ad(m_impl.m_user_space->id
-		      == m_impl.m_user_space_id);
-		ut_ad(memo_contains(get_memo(), &m_impl.m_user_space->latch,
-				    MTR_MEMO_X_LOCK));
-
-		space = m_impl.m_user_space;
-	} else {
-
-		ut_ad(m_impl.m_sys_space->id == TRX_SYS_SPACE);
-		ut_ad(memo_contains(get_memo(), &m_impl.m_sys_space->latch,
-				    MTR_MEMO_X_LOCK));
-
-		space = m_impl.m_sys_space;
-	}
-
-	space->release_free_extents(n_reserved);
-}
-
 #ifdef UNIV_DEBUG
 /** Check if memo contains the given item.
 @return	true if contains */