← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/handler/ha_innodb.cc

Merge Stewart - Update innobase plugin to be based on innodb 1.1.4 from MySQL 5.5.8 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/handler/ha_innodb.cc
1097
1097
    return(HA_ERR_ROW_IS_REFERENCED);
1098
1098
 
1099
1099
  case DB_CANNOT_ADD_CONSTRAINT:
 
1100
  case DB_CHILD_NO_INDEX:
 
1101
  case DB_PARENT_NO_INDEX:
1100
1102
    return(HA_ERR_CANNOT_ADD_FOREIGN);
1101
1103
 
1102
1104
  case DB_CANNOT_DROP_CONSTRAINT:
4288
4290
    n_requested_fields++;
4289
4291
 
4290
4292
    templ->col_no = i;
 
4293
    templ->clust_rec_field_no = dict_col_get_clust_pos(col, clust_index);
 
4294
    ut_ad(templ->clust_rec_field_no != ULINT_UNDEFINED);
4291
4295
 
4292
4296
    if (index == clust_index) {
4293
 
      templ->rec_field_no = dict_col_get_clust_pos(col, index);
 
4297
      templ->rec_field_no = templ->clust_rec_field_no;
4294
4298
    } else {
4295
4299
      templ->rec_field_no = dict_index_get_nth_col_pos(
4296
4300
                index, i);
4297
 
    }
4298
 
 
4299
 
    if (templ->rec_field_no == ULINT_UNDEFINED) {
4300
 
      prebuilt->need_to_access_clustered = TRUE;
 
4301
      if (templ->rec_field_no == ULINT_UNDEFINED) {
 
4302
        prebuilt->need_to_access_clustered = TRUE;
 
4303
      }
4301
4304
    }
4302
4305
 
4303
4306
    if (field->null_ptr) {
4347
4350
    for (i = 0; i < n_requested_fields; i++) {
4348
4351
      templ = prebuilt->mysql_template + i;
4349
4352
 
4350
 
      templ->rec_field_no = dict_col_get_clust_pos(
4351
 
        &index->table->cols[templ->col_no],
4352
 
        clust_index);
 
4353
      templ->rec_field_no = templ->clust_rec_field_no;
4353
4354
    }
4354
4355
  }
4355
4356
}
6336
6337
                                              query, strlen(query),
6337
6338
                                              norm_name,
6338
6339
                                              lex_identified_temp_table);
 
6340
    switch (error) {
 
6341
 
 
6342
    case DB_PARENT_NO_INDEX:
 
6343
      push_warning_printf(
 
6344
                          &session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
6345
                          HA_ERR_CANNOT_ADD_FOREIGN,
 
6346
                          "Create table '%s' with foreign key constraint"
 
6347
                          " failed. There is no index in the referenced"
 
6348
                          " table where the referenced columns appear"
 
6349
                          " as the first columns.\n", norm_name);
 
6350
      break;
 
6351
 
 
6352
    case DB_CHILD_NO_INDEX:
 
6353
      push_warning_printf(
 
6354
                          &session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
6355
                          HA_ERR_CANNOT_ADD_FOREIGN,
 
6356
                          "Create table '%s' with foreign key constraint"
 
6357
                          " failed. There is no index in the referencing"
 
6358
                          " table where referencing columns appear"
 
6359
                          " as the first columns.\n", norm_name);
 
6360
      break;
 
6361
    }
6339
6362
 
6340
6363
    error = convert_error_code_to_mysql(error, iflags, NULL);
6341
6364
 
6926
6949
  dict_index_t* index;
6927
6950
  uint64_t  estimate;
6928
6951
  uint64_t  local_data_file_length;
 
6952
  ulint stat_n_leaf_pages;
6929
6953
 
6930
6954
  /* We do not know if MySQL can call this function before calling
6931
6955
  external_lock(). To be safe, update the session of the current table
6943
6967
 
6944
6968
  index = dict_table_get_first_index(prebuilt->table);
6945
6969
 
6946
 
  ut_a(index->stat_n_leaf_pages > 0);
 
6970
  stat_n_leaf_pages = index->stat_n_leaf_pages;
 
6971
 
 
6972
  ut_a(stat_n_leaf_pages > 0);
6947
6973
 
6948
6974
  local_data_file_length =
6949
 
    ((uint64_t) index->stat_n_leaf_pages) * UNIV_PAGE_SIZE;
 
6975
    ((uint64_t) stat_n_leaf_pages) * UNIV_PAGE_SIZE;
6950
6976
 
6951
6977
 
6952
6978
  /* Calculate a minimum length for a clustered index record and from
7159
7185
 
7160
7186
    prebuilt->trx->op_info = "updating table statistics";
7161
7187
 
7162
 
    dict_update_statistics(ib_table);
 
7188
    dict_update_statistics(ib_table,
 
7189
                           FALSE /* update even if stats
 
7190
                                    are initialized */);
 
7191
 
7163
7192
 
7164
7193
    prebuilt->trx->op_info = "returning various info to MySQL";
7165
7194
 
7176
7205
  }
7177
7206
 
7178
7207
  if (flag & HA_STATUS_VARIABLE) {
 
7208
 
 
7209
    dict_table_stats_lock(ib_table, RW_S_LATCH);
 
7210
 
7179
7211
    n_rows = ib_table->stat_n_rows;
7180
7212
 
7181
7213
    /* Because we do not protect stat_n_rows by any mutex in a
7225
7257
        ib_table->stat_sum_of_other_index_sizes)
7226
7258
          * UNIV_PAGE_SIZE;
7227
7259
 
 
7260
    dict_table_stats_unlock(ib_table, RW_S_LATCH);
 
7261
 
7228
7262
    /* Since fsp_get_available_space_in_free_extents() is
7229
7263
    acquiring latches inside InnoDB, we do not call it if we
7230
7264
    are asked by MySQL to avoid locking. Another reason to
7241
7275
         innodb_crash_recovery is set to a high value. */
7242
7276
      stats.delete_length = 0;
7243
7277
    } else {
7244
 
      /* lock the data dictionary to avoid races with
7245
 
      ibd_file_missing and tablespace_discarded */
7246
 
      row_mysql_lock_data_dictionary(prebuilt->trx);
7247
 
 
7248
 
      /* ib_table->space must be an existent tablespace */
7249
 
      if (!ib_table->ibd_file_missing
7250
 
          && !ib_table->tablespace_discarded) {
7251
 
 
7252
 
        stats.delete_length =
7253
 
          fsp_get_available_space_in_free_extents(
7254
 
            ib_table->space) * 1024;
7255
 
      } else {
7256
 
 
 
7278
      ullint    avail_space;
 
7279
 
 
7280
      avail_space = fsp_get_available_space_in_free_extents(ib_table->space);
 
7281
 
 
7282
      if (avail_space == ULLINT_UNDEFINED) {
7257
7283
        Session*  session;
7258
7284
 
7259
7285
        session= getTable()->in_use;
7271
7297
          ib_table->name);
7272
7298
 
7273
7299
        stats.delete_length = 0;
 
7300
      } else {
 
7301
        stats.delete_length = avail_space * 1024;
7274
7302
      }
7275
 
 
7276
 
      row_mysql_unlock_data_dictionary(prebuilt->trx);
7277
7303
    }
7278
7304
 
7279
7305
    stats.check_time = 0;
7301
7327
                      getTable()->getShare()->keys);
7302
7328
    }
7303
7329
 
 
7330
    dict_table_stats_lock(ib_table, RW_S_LATCH);
 
7331
 
7304
7332
    for (i = 0; i < getTable()->getShare()->sizeKeys(); i++) {
7305
7333
      ulong j;
7306
7334
      /* We could get index quickly through internal
7338
7366
          break;
7339
7367
        }
7340
7368
 
7341
 
        dict_index_stat_mutex_enter(index);
7342
 
 
7343
7369
        if (index->stat_n_diff_key_vals[j + 1] == 0) {
7344
7370
 
7345
7371
          rec_per_key = stats.records;
7348
7374
           index->stat_n_diff_key_vals[j + 1]);
7349
7375
        }
7350
7376
 
7351
 
        dict_index_stat_mutex_exit(index);
7352
 
 
7353
7377
        /* Since MySQL seems to favor table scans
7354
7378
        too much over index searches, we pretend
7355
7379
        index selectivity is 2 times better than
7366
7390
          (ulong) rec_per_key;
7367
7391
      }
7368
7392
    }
 
7393
 
 
7394
    dict_table_stats_unlock(ib_table, RW_S_LATCH);
7369
7395
  }
7370
7396
 
7371
7397
  if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
7695
7721
  flen = ftell(srv_dict_tmpfile);
7696
7722
  if (flen < 0) {
7697
7723
    flen = 0;
7698
 
  } else if (flen > 64000 - 1) {
7699
 
    flen = 64000 - 1;
7700
7724
  }
7701
7725
 
7702
7726
  /* allocate buffer for the string, and