← Back to branch summary

~ubuntu-branches/ubuntu/natty/mysql-5.1/natty-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2012-02-22 08:30:45 UTC
  • mfrom: (1.4.1)
  • Revision ID: package-import@ubuntu.com-20120222083045-2rd53r4bnyx7qus4
Tags: 5.1.61-0ubuntu0.11.04.1
https://launchpad.net/bugs/937869
* SECURITY UPDATE: Update to 5.1.61 to fix multiple security issues
  (LP: #937869)
  - http://www.oracle.com/technetwork/topics/security/cpujan2012-366304.html
  - CVE-2011-2262
  - CVE-2012-0075
  - CVE-2012-0112
  - CVE-2012-0113
  - CVE-2012-0114
  - CVE-2012-0115
  - CVE-2012-0116
  - CVE-2012-0117
  - CVE-2012-0118
  - CVE-2012-0119
  - CVE-2012-0120
  - CVE-2012-0484
  - CVE-2012-0485
  - CVE-2012-0486
  - CVE-2012-0487
  - CVE-2012-0488
  - CVE-2012-0489
  - CVE-2012-0490
  - CVE-2012-0491
  - CVE-2012-0492
  - CVE-2012-0493
  - CVE-2012-0494
  - CVE-2012-0495
  - CVE-2012-0496

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/handler/ha_innodb.cc
130
130
 
131
131
static char*    internal_innobase_data_file_path        = NULL;
132
132
 
 
133
/* Possible values for system variable "innodb_stats_method". The values
 
134
are defined the same as its corresponding MyISAM system variable
 
135
"myisam_stats_method"(see "myisam_stats_method_names"), for better usability */
 
136
static const char* innodb_stats_method_names[] = {
 
137
        "nulls_equal",
 
138
        "nulls_unequal",
 
139
        "nulls_ignored",
 
140
        NullS
 
141
};
 
142
 
 
143
/* Used to define an enumerate type of the system variable innodb_stats_method.
 
144
This is the same as "myisam_stats_method_typelib" */
 
145
static TYPELIB innodb_stats_method_typelib = {
 
146
        array_elements(innodb_stats_method_names) - 1,
 
147
        "innodb_stats_method_typelib",
 
148
        innodb_stats_method_names,
 
149
        NULL
 
150
};
 
151
 
133
152
/* The following counter is used to convey information to InnoDB
134
153
about server activity: in selects it is not sensible to call
135
154
srv_active_wake_master_thread after each fetch or search, we only do
170
189
/*============================*/
171
190
                                        /* out: true if index name matches a
172
191
                                        reserved name */
173
 
        const trx_t*    trx,            /* in: InnoDB transaction handle */
 
192
        THD*            thd,            /* in/out: MySQL connection */
174
193
        const TABLE*    form,           /* in: information on table
175
194
                                        columns and indexes */
176
195
        const char*     norm_name);     /* in: table name */
3063
3082
        return(0);
3064
3083
}
3065
3084
 
3066
 
/******************************************************************
3067
 
Sets a field in a record to SQL NULL. Uses the record format
3068
 
information in table to track the null bit in record. */
3069
 
inline
3070
 
void
3071
 
set_field_in_record_to_null(
3072
 
/*========================*/
3073
 
        TABLE*  table,  /* in: MySQL table object */
3074
 
        Field*  field,  /* in: MySQL field object */
3075
 
        char*   record) /* in: a row in MySQL format */
3076
 
{
3077
 
        int     null_offset;
3078
 
 
3079
 
        null_offset = (uint) ((char*) field->null_ptr
3080
 
                                        - (char*) table->record[0]);
3081
 
 
3082
 
        record[null_offset] = record[null_offset] | field->null_bit;
3083
 
}
3084
 
 
3085
3085
extern "C" {
3086
3086
/*****************************************************************
3087
3087
InnoDB uses this function to compare two data fields for which the data type
4087
4087
 
4088
4088
                        switch (sql_command) {
4089
4089
                        case SQLCOM_LOAD:
4090
 
                                if ((trx->duplicates
4091
 
                                    & (TRX_DUP_IGNORE | TRX_DUP_REPLACE))) {
 
4090
                                if (trx->duplicates) {
4092
4091
 
4093
4092
                                        goto set_max_autoinc;
4094
4093
                                }
4264
4263
                        /* The field has changed */
4265
4264
 
4266
4265
                        ufield = uvect->fields + n_changed;
 
4266
                        UNIV_MEM_INVALID(ufield, sizeof *ufield);
4267
4267
 
4268
4268
                        /* Let us use a dummy dfield to make the conversion
4269
4269
                        from the MySQL column format to the InnoDB format */
4270
4270
 
4271
 
                        dict_col_copy_type_noninline(prebuilt->table->cols + i,
4272
 
                                                     &dfield.type);
4273
 
 
4274
4271
                        if (n_len != UNIV_SQL_NULL) {
 
4272
                                dict_col_copy_type_noninline(
 
4273
                                        prebuilt->table->cols + i,
 
4274
                                        &dfield.type);
 
4275
 
4275
4276
                                buf = row_mysql_store_col_in_innobase_format(
4276
4277
                                        &dfield,
4277
4278
                                        (byte*)buf,
4282
4283
                                                        prebuilt->table));
4283
4284
                                ufield->new_val.data = dfield.data;
4284
4285
                                ufield->new_val.len = dfield.len;
 
4286
                                ufield->new_val.type = dfield.type;
4285
4287
                        } else {
4286
4288
                                ufield->new_val.data = NULL;
4287
4289
                                ufield->new_val.len = UNIV_SQL_NULL;
4288
4290
                        }
4289
4291
 
 
4292
                        ufield->extern_storage = FALSE;
4290
4293
                        ufield->exp = NULL;
4291
4294
                        ufield->field_no = dict_col_get_clust_pos_noninline(
4292
4295
                                &prebuilt->table->cols[i], clust_index);
4364
4367
            && table->next_number_field
4365
4368
            && new_row == table->record[0]
4366
4369
            && thd_sql_command(user_thd) == SQLCOM_INSERT
4367
 
            && (trx->duplicates & (TRX_DUP_IGNORE | TRX_DUP_REPLACE))
4368
 
                == TRX_DUP_IGNORE)  {
 
4370
            && trx->duplicates)  {
4369
4371
 
4370
4372
                ulonglong       auto_inc;
4371
4373
                ulonglong       col_max_value;
4713
4715
                                        index,
4714
4716
                                        (byte*) key_ptr,
4715
4717
                                        (ulint) key_len, prebuilt->trx);
 
4718
                DBUG_ASSERT(prebuilt->search_tuple->n_fields > 0);
4716
4719
        } else {
4717
4720
                /* We position the cursor to the last or the first entry
4718
4721
                in the index */
4799
4802
        dict_index_t*   index = 0;
4800
4803
 
4801
4804
        DBUG_ENTER("innobase_get_index");
4802
 
        ha_statistic_increment(&SSV::ha_read_key_count);
4803
4805
 
4804
4806
        ut_ad(user_thd == ha_thd());
4805
4807
        ut_a(prebuilt->trx == thd_to_trx(user_thd));
5266
5268
        DBUG_PRINT("enter", ("table_name: %s", table_name));
5267
5269
 
5268
5270
        ut_a(trx->mysql_thd != NULL);
5269
 
        if (IS_MAGIC_TABLE_AND_USER_DENIED_ACCESS(table_name,
5270
 
                                                  (THD*) trx->mysql_thd)) {
5271
 
                DBUG_RETURN(HA_ERR_GENERIC);
5272
 
        }
5273
5271
 
5274
5272
        n_cols = form->s->fields;
5275
5273
 
5378
5376
                        col_len);
5379
5377
        }
5380
5378
 
 
5379
        srv_lower_case_table_names = lower_case_table_names;
 
5380
 
5381
5381
        error = row_create_table_for_mysql(table, trx);
5382
5382
 
5383
5383
        innodb_check_for_record_too_big_error(flags & DICT_TF_COMPACT, error);
5623
5623
                DBUG_RETURN(HA_ERR_TO_BIG_ROW);
5624
5624
        }
5625
5625
 
5626
 
        /* Get the transaction associated with the current thd, or create one
5627
 
        if not yet created */
5628
 
 
5629
 
        parent_trx = check_trx_exists(thd);
5630
 
 
5631
 
        /* In case MySQL calls this in the middle of a SELECT query, release
5632
 
        possible adaptive hash latch to avoid deadlocks of threads */
5633
 
 
5634
 
        trx_search_latch_release_if_reserved(parent_trx);
5635
 
 
5636
 
        trx = trx_allocate_for_mysql();
5637
 
 
5638
 
        trx->mysql_thd = thd;
5639
 
        INNOBASE_COPY_STMT(thd, trx);
5640
 
 
5641
 
        if (thd_test_options(thd, OPTION_NO_FOREIGN_KEY_CHECKS)) {
5642
 
                trx->check_foreigns = FALSE;
5643
 
        }
5644
 
 
5645
 
        if (thd_test_options(thd, OPTION_RELAXED_UNIQUE_CHECKS)) {
5646
 
                trx->check_unique_secondary = FALSE;
5647
 
        }
5648
 
 
5649
 
        if (lower_case_table_names) {
5650
 
                srv_lower_case_table_names = TRUE;
5651
 
        } else {
5652
 
                srv_lower_case_table_names = FALSE;
5653
 
        }
5654
 
 
5655
5626
        strcpy(name2, name);
5656
5627
 
5657
5628
        normalize_table_name(norm_name, name2);
5658
5629
 
5659
 
        /* Latch the InnoDB data dictionary exclusively so that no deadlocks
5660
 
        or lock waits can happen in it during a table create operation.
5661
 
        Drop table etc. do this latching in row0mysql.c. */
5662
 
 
5663
 
        row_mysql_lock_data_dictionary(trx);
5664
 
 
5665
5630
        /* Create the table definition in InnoDB */
5666
5631
 
5667
 
        flags = 0;
5668
 
 
5669
 
        if (form->s->row_type != ROW_TYPE_REDUNDANT) {
5670
 
                flags |= DICT_TF_COMPACT;
5671
 
        }
 
5632
        flags = form->s->row_type != ROW_TYPE_REDUNDANT ? DICT_TF_COMPACT : 0;
5672
5633
 
5673
5634
        /* Look for a primary key */
5674
5635
 
5683
5644
 
5684
5645
        /* Check for name conflicts (with reserved name) for
5685
5646
        any user indices to be created. */
5686
 
        if (innobase_index_name_is_reserved(trx, form, norm_name)) {
5687
 
                error = -1;
5688
 
                goto cleanup;
5689
 
        }
 
5647
        if (innobase_index_name_is_reserved(thd, form, norm_name)) {
 
5648
                DBUG_RETURN(-1);
 
5649
        }
 
5650
 
 
5651
        if (IS_MAGIC_TABLE_AND_USER_DENIED_ACCESS(norm_name, thd)) {
 
5652
                DBUG_RETURN(HA_ERR_GENERIC);
 
5653
        }
 
5654
 
 
5655
        /* Get the transaction associated with the current thd, or create one
 
5656
        if not yet created */
 
5657
 
 
5658
        parent_trx = check_trx_exists(thd);
 
5659
 
 
5660
        /* In case MySQL calls this in the middle of a SELECT query, release
 
5661
        possible adaptive hash latch to avoid deadlocks of threads */
 
5662
 
 
5663
        trx_search_latch_release_if_reserved(parent_trx);
 
5664
 
 
5665
        trx = trx_allocate_for_mysql();
 
5666
 
 
5667
        trx->mysql_thd = thd;
 
5668
        INNOBASE_COPY_STMT(thd, trx);
 
5669
 
 
5670
        if (thd_test_options(thd, OPTION_NO_FOREIGN_KEY_CHECKS)) {
 
5671
                trx->check_foreigns = FALSE;
 
5672
        }
 
5673
 
 
5674
        if (thd_test_options(thd, OPTION_RELAXED_UNIQUE_CHECKS)) {
 
5675
                trx->check_unique_secondary = FALSE;
 
5676
        }
 
5677
 
 
5678
        /* Latch the InnoDB data dictionary exclusively so that no deadlocks
 
5679
        or lock waits can happen in it during a table create operation.
 
5680
        Drop table etc. do this latching in row0mysql.c. */
 
5681
 
 
5682
        row_mysql_lock_data_dictionary(trx);
5690
5683
 
5691
5684
        error = create_table_def(trx, form, norm_name,
5692
5685
                create_info->options & HA_LEX_CREATE_TMP_TABLE ? name2 : NULL,
5917
5910
 
5918
5911
        trx_search_latch_release_if_reserved(parent_trx);
5919
5912
 
5920
 
        if (lower_case_table_names) {
5921
 
                srv_lower_case_table_names = TRUE;
5922
 
        } else {
5923
 
                srv_lower_case_table_names = FALSE;
5924
 
        }
5925
 
 
5926
5913
        trx = trx_allocate_for_mysql();
5927
5914
 
5928
5915
        trx->mysql_thd = thd;
5942
5929
 
5943
5930
        /* Drop the table in InnoDB */
5944
5931
 
 
5932
        srv_lower_case_table_names = lower_case_table_names;
 
5933
 
5945
5934
        error = row_drop_table_for_mysql(norm_name, trx,
5946
5935
                                         thd_sql_command(thd)
5947
5936
                                         == SQLCOM_DROP_DB);
6070
6059
 
6071
6060
        trx_search_latch_release_if_reserved(parent_trx);
6072
6061
 
6073
 
        if (lower_case_table_names) {
6074
 
                srv_lower_case_table_names = TRUE;
6075
 
        } else {
6076
 
                srv_lower_case_table_names = FALSE;
6077
 
        }
6078
 
 
6079
6062
        trx = trx_allocate_for_mysql();
6080
6063
        trx->mysql_thd = thd;
6081
6064
        INNOBASE_COPY_STMT(thd, trx);
6095
6078
 
6096
6079
        /* Rename the table in InnoDB */
6097
6080
 
 
6081
        srv_lower_case_table_names = lower_case_table_names;
 
6082
 
6098
6083
        error = row_rename_table_for_mysql(norm_from, norm_to, trx);
6099
6084
 
6100
6085
        /* Flush the log to reduce probability that the .frm files and
6185
6170
        void*           heap2;
6186
6171
 
6187
6172
        DBUG_ENTER("records_in_range");
 
6173
        DBUG_ASSERT(min_key || max_key);
6188
6174
 
6189
6175
        ut_a(prebuilt->trx == thd_to_trx(ha_thd()));
6190
6176
 
6215
6201
                                         (const uchar*) 0),
6216
6202
                                (ulint) (min_key ? min_key->length : 0),
6217
6203
                                prebuilt->trx);
 
6204
        DBUG_ASSERT(min_key
 
6205
                    ? range_start->n_fields > 0
 
6206
                    : range_start->n_fields == 0);
6218
6207
 
6219
6208
        row_sel_convert_mysql_key_to_innobase(
6220
6209
                                range_end, (byte*) key_val_buff2,
6223
6212
                                         (const uchar*) 0),
6224
6213
                                (ulint) (max_key ? max_key->length : 0),
6225
6214
                                prebuilt->trx);
 
6215
        DBUG_ASSERT(max_key
 
6216
                    ? range_end->n_fields > 0
 
6217
                    : range_end->n_fields == 0);
6226
6218
 
6227
6219
        mode1 = convert_search_mode_to_innobase(min_key ? min_key->flag :
6228
6220
                                                HA_READ_KEY_EXACT);
6363
6355
}
6364
6356
 
6365
6357
/*************************************************************************
 
6358
Calculate Record Per Key value. Need to exclude the NULL value if
 
6359
innodb_stats_method is set to "nulls_ignored" */
 
6360
static
 
6361
ha_rows
 
6362
innodb_rec_per_key(
 
6363
/*===============*/
 
6364
                                        /* out: estimated record per key
 
6365
                                        value */
 
6366
        dict_index_t*   index,          /* in: dict_index_t structure */
 
6367
        ulint           i,              /* in: the column we are
 
6368
                                        calculating rec per key */
 
6369
        ha_rows         records)        /* in: estimated total records */
 
6370
{
 
6371
        ha_rows         rec_per_key;
 
6372
 
 
6373
        ut_ad(i < dict_index_get_n_unique(index));
 
6374
 
 
6375
        /* Note the stat_n_diff_key_vals[] stores the diff value with
 
6376
        n-prefix indexing, so it is always stat_n_diff_key_vals[i + 1] */
 
6377
        if (index->stat_n_diff_key_vals[i + 1] == 0) {
 
6378
 
 
6379
                rec_per_key = records;
 
6380
        } else if (srv_innodb_stats_method == SRV_STATS_NULLS_IGNORED) {
 
6381
                ib_longlong     num_null;
 
6382
 
 
6383
                /* Number of rows with NULL value in this
 
6384
                field */
 
6385
                num_null = records - index->stat_n_non_null_key_vals[i];
 
6386
 
 
6387
                /* In theory, index->stat_n_non_null_key_vals[i]
 
6388
                should always be less than the number of records.
 
6389
                Since this is statistics value, the value could
 
6390
                have slight discrepancy. But we will make sure
 
6391
                the number of null values is not a negative number. */
 
6392
                num_null = (num_null < 0) ? 0 : num_null;
 
6393
 
 
6394
                /* If the number of NULL values is the same as or
 
6395
                large than that of the distinct values, we could
 
6396
                consider that the table consists mostly of NULL value.
 
6397
                Set rec_per_key to 1. */
 
6398
                if (index->stat_n_diff_key_vals[i + 1] <= num_null) {
 
6399
                        rec_per_key = 1;
 
6400
                } else {
 
6401
                        /* Need to exclude rows with NULL values from
 
6402
                        rec_per_key calculation */
 
6403
                        rec_per_key = (ha_rows)(
 
6404
                                (records - num_null)
 
6405
                                / (index->stat_n_diff_key_vals[i + 1]
 
6406
                                   - num_null));
 
6407
                }
 
6408
        } else {
 
6409
                rec_per_key = (ha_rows)
 
6410
                         (records / index->stat_n_diff_key_vals[i + 1]);
 
6411
        }
 
6412
 
 
6413
        return(rec_per_key);
 
6414
}
 
6415
 
 
6416
/*************************************************************************
6366
6417
Returns statistics information of the table to the MySQL interpreter,
6367
6418
in various fields of the handle object. */
6368
6419
 
6568
6619
                                        break;
6569
6620
                                }
6570
6621
 
6571
 
                                if (index->stat_n_diff_key_vals[j + 1] == 0) {
6572
 
 
6573
 
                                        rec_per_key = stats.records;
6574
 
                                } else {
6575
 
                                        rec_per_key = (ha_rows)(stats.records /
6576
 
                                         index->stat_n_diff_key_vals[j + 1]);
6577
 
                                }
 
6622
                                rec_per_key = innodb_rec_per_key(
 
6623
                                        index, j, stats.records);
6578
6624
 
6579
6625
                                /* Since MySQL seems to favor table scans
6580
6626
                                too much over index searches, we pretend
7054
7100
                        break;
7055
7101
                case HA_EXTRA_RESET_STATE:
7056
7102
                        reset_template(prebuilt);
 
7103
                        thd_to_trx(ha_thd())->duplicates = 0;
7057
7104
                        break;
7058
7105
                case HA_EXTRA_NO_KEYREAD:
7059
7106
                        prebuilt->read_just_key = 0;
7071
7118
                        parameters below.  We must not invoke update_thd()
7072
7119
                        either, because the calling threads may change.
7073
7120
                        CAREFUL HERE, OR MEMORY CORRUPTION MAY OCCUR! */
7074
 
                case HA_EXTRA_IGNORE_DUP_KEY:
 
7121
                case HA_EXTRA_INSERT_WITH_UPDATE:
7075
7122
                        thd_to_trx(ha_thd())->duplicates |= TRX_DUP_IGNORE;
7076
7123
                        break;
 
7124
                case HA_EXTRA_NO_IGNORE_DUP_KEY:
 
7125
                        thd_to_trx(ha_thd())->duplicates &= ~TRX_DUP_IGNORE;
 
7126
                        break;
7077
7127
                case HA_EXTRA_WRITE_CAN_REPLACE:
7078
7128
                        thd_to_trx(ha_thd())->duplicates |= TRX_DUP_REPLACE;
7079
7129
                        break;
7080
7130
                case HA_EXTRA_WRITE_CANNOT_REPLACE:
7081
7131
                        thd_to_trx(ha_thd())->duplicates &= ~TRX_DUP_REPLACE;
7082
7132
                        break;
7083
 
                case HA_EXTRA_NO_IGNORE_DUP_KEY:
7084
 
                        thd_to_trx(ha_thd())->duplicates &=
7085
 
                                ~(TRX_DUP_IGNORE | TRX_DUP_REPLACE);
7086
 
                        break;
7087
7133
                default:/* Do nothing */
7088
7134
                        ;
7089
7135
        }
7269
7315
 
7270
7316
        reset_template(prebuilt);
7271
7317
 
7272
 
        if (lock_type == F_WRLCK) {
 
7318
        if (lock_type == F_WRLCK
 
7319
            || (table->s->tmp_table
 
7320
                && thd_sql_command(thd) == SQLCOM_LOCK_TABLES)) {
7273
7321
 
7274
7322
                /* If this is a SELECT, then it is in UPDATE TABLE ...
7275
 
                or SELECT ... FOR UPDATE */
 
7323
                or SELECT ... FOR UPDATE
 
7324
 
 
7325
                For temporary tables which are locked for READ by LOCK TABLES
 
7326
                updates are still allowed by SQL-layer. In order to accomodate
 
7327
                for such a situation we always request X-lock for such table
 
7328
                at LOCK TABLES time.
 
7329
                */
7276
7330
                prebuilt->select_lock_type = LOCK_X;
7277
7331
                prebuilt->stored_select_lock_type = LOCK_X;
7278
7332
        }
8492
8546
 
8493
8547
        if (trx) {
8494
8548
                innobase_commit_low(trx);
8495
 
 
 
8549
                trx_free_for_background(trx);
8496
8550
                return(XA_OK);
8497
8551
        } else {
8498
8552
                return(XAER_NOTA);
8515
8569
        trx = trx_get_trx_by_xid(xid);
8516
8570
 
8517
8571
        if (trx) {
8518
 
                return(innobase_rollback_trx(trx));
 
8572
                int     ret = innobase_rollback_trx(trx);
 
8573
                trx_free_for_background(trx);
 
8574
                return(ret);
8519
8575
        } else {
8520
8576
                return(XAER_NOTA);
8521
8577
        }
8751
8807
/*============================*/
8752
8808
                                        /* out: true if an index name
8753
8809
                                        matches the reserved name */
8754
 
        const trx_t*    trx,            /* in: InnoDB transaction handle */
 
8810
        THD*            thd,            /* in/out: MySQL connection */
8755
8811
        const TABLE*    form,           /* in: information on table
8756
8812
                                        columns and indexes */
8757
8813
        const char*     norm_name)      /* in: table name */
8765
8821
                if (innobase_strcasecmp(key->name,
8766
8822
                                        innobase_index_reserve_name) == 0) {
8767
8823
                        /* Push warning to mysql */
8768
 
                        push_warning_printf((THD*) trx->mysql_thd,
 
8824
                        push_warning_printf(thd,
8769
8825
                                            MYSQL_ERROR::WARN_LEVEL_WARN,
8770
8826
                                            ER_CANT_CREATE_TABLE,
8771
8827
                                            "Cannot Create Index with name "
8990
9046
  AUTOINC_OLD_STYLE_LOCKING,    /* Minimum value */
8991
9047
  AUTOINC_NO_LOCKING, 0);       /* Maximum value */
8992
9048
 
 
9049
static MYSQL_SYSVAR_ENUM(stats_method, srv_innodb_stats_method,
 
9050
   PLUGIN_VAR_RQCMDARG,
 
9051
  "Specifies how InnoDB index statistics collection code should "
 
9052
  "treat NULLs. Possible values are NULLS_EQUAL (default), "
 
9053
  "NULLS_UNEQUAL and NULLS_IGNORED",
 
9054
   NULL, NULL, SRV_STATS_NULLS_EQUAL, &innodb_stats_method_typelib);
 
9055
 
8993
9056
#if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
8994
9057
static MYSQL_SYSVAR_UINT(change_buffering_debug, ibuf_debug,
8995
9058
  PLUGIN_VAR_RQCMDARG,
9031
9094
  MYSQL_SYSVAR(stats_on_metadata),
9032
9095
  MYSQL_SYSVAR(use_legacy_cardinality_algorithm),
9033
9096
  MYSQL_SYSVAR(adaptive_hash_index),
 
9097
  MYSQL_SYSVAR(stats_method),
9034
9098
  MYSQL_SYSVAR(status_file),
9035
9099
  MYSQL_SYSVAR(support_xa),
9036
9100
  MYSQL_SYSVAR(sync_spin_loops),