Bug#37292404 Update instant dropped extern blob

Thanks to mengchu shi (Alibaba) for the contribution.

Background:
  Row update is done:
  1. In-place, if the changes fit within the row
  2. Optimistically, if the changes fit within the page and page
    re-organization is not required
  3. Pessimistically otherwise: the old row is deleted and updated row
    is inserted

  The following steps are followed during pessimistic update:
  1. Prepare in-memory copy (dtuple_t) from the physical record (rec_t)
  2. Apply changes to the tuple as described by the update vector
  3. Check if field(s) of the tuple must be stored externally
  4. If yes, then modify update vector and tuple to indicate it; and
     create a big record (big_rec_t)
  5. Perform undo logging
  6. Delete the old physical record
  7. Create the physical record (rec_t) back from the updated tuple
  8. Insert the updated record

Description:
  When performing undo logging, we log all the fields being modified by
the update vector into the undo log. We must not encounter any field
which is dropped instantly when logging to the undo log. That is, the
update vector must not contain any field which is dropped instantly when
we start performing undo logging.

  When a column is dropped with ALGORITHM=INSTANT, the existing rows are
not touched. Thus, an in-memory tuple built from the such existing rows
will contain the field(s) which are dropped instantly.

Issue:
  Consider the following scenario:
  1. Table is created with a blob column say c1
  2. Row is inserted such that c1 is stored externally
  3. ALTER TABLE .. DROP COLUMN c1, ALGORITHM=INSTANT;
  4. Row is updated and the update is done pessimistically

  Observe the field c1 along the steps of the pessimistic update:
  1. The in-memory copy will contain the dropped field c1 as the column
     was dropped with ALGORITHM=INSTANT
  2. The changes to the tuple will propagate the dropped field as is to
     the updated tuple
  3. The field c1 must be stored externally
  4. The field c1 is stored externally and the update vector now
     includes c1
  5. We reach an unexpected state here, causing the server to halt.

  The field c1 is being undo logged as it is part of the update vector.
But the field c1 is already dropped instantly. This violates the
prerequisite of undo logging (see Description).

Fix:
  When applying the update on the tuple, ensure that any field which is
dropped instantly is removed from the tuple. This ensures that dropped
fields are not propagated and are not considered in later stages of the
update.

Note:
  When the update is performed pessimistically, the row is brought to
the latest row version. This is done when inserting the updated row.

Change-Id: I86695f34e88e70bd2fded2479fa90a75437eba28

Author: ram1048

storage/innobase/row/row0upd.cc

@@ -1119,44 +1119,41 @@ void row_upd_index_replace_new_col_vals_index_pos(dtuple_t *entry,
                                                   bool order_only,
                                                   mem_heap_t *heap) {
   DBUG_TRACE;
-
-  ulint i;
-  ulint n_fields;
-  const page_size_t &page_size = dict_table_page_size(index->table);
-
   ut_ad(index);
   ut_ad(!index->table->skip_alter_undo);
 
   dtuple_set_info_bits(entry, update->info_bits);
 
-  if (order_only) {
-    n_fields = dict_index_get_n_unique(index);
-  } else {
-    n_fields = dict_index_get_n_fields(index);
-  }
+  const ulint n_fields = order_only ? dict_index_get_n_unique(index)
+                                    : dict_index_get_n_fields(index);
+  for (ulint field_index = 0; field_index < n_fields; field_index++) {
+    ulint field_no;
+    bool is_virtual{false};
 
-  for (i = 0; i < n_fields; i++) {
-    const dict_field_t *field;
-    const dict_col_t *col;
-    const upd_field_t *uf;
+    const dict_field_t *field = index->get_field(field_index);
+    const dict_col_t *col = field->col;
 
-    field = index->get_field(i);
-    col = field->col;
-    if (col->is_virtual()) {
-      const dict_v_col_t *vcol = reinterpret_cast<const dict_v_col_t *>(col);
+    if (col->is_instant_dropped()) {
+      dfield_t *field = dtuple_get_nth_field(entry, field_index);
+      field->reset();
+      continue;
+    }
 
-      uf = upd_get_field_by_field_no(update, vcol->v_pos, true);
+    if (col->is_virtual()) {
+      is_virtual = true;
+      field_no = reinterpret_cast<const dict_v_col_t *>(col)->v_pos;
     } else {
-      uf = upd_get_field_by_field_no(update, i, false);
+      field_no = field_index;
     }
 
-    if (uf) {
+    if (auto uf = upd_get_field_by_field_no(update, field_no, is_virtual); uf) {
       upd_field_t *tmp = const_cast<upd_field_t *>(uf);
-      dfield_t *dfield = dtuple_get_nth_field(entry, i);
+      dfield_t *dfield = dtuple_get_nth_field(entry, field_index);
       tmp->ext_in_old = dfield_is_ext(dfield);
 
       dfield_copy(&tmp->old_val, dfield);
 
+      const auto &page_size = dict_table_page_size(index->table);
       row_upd_index_replace_new_col_val(index, dfield, field, col, uf, heap,
                                         dict_index_is_sdi(index), page_size);
     }