/******************************************************************//**

Calculate the time it takes to read a set of ranges through an index

This enables us to optimise reads for clustered indexes.

@return    estimated time measured in disk seeks */

UNIV_INTERN

double

ha_innobase::read_time(

/*===================*/

    uint    index,    /*!< in: key number */

    uint    ranges,    /*!< in: how many ranges */

    ha_rows rows)    /*!< in: estimated number of rows in the ranges */

{

    ha_rows total_rows;

    double    time_for_scan;

    if (index != table->s->primary_key) {

        /* Not clustered */

        return(handler::read_time(index, ranges, rows));

    }

    if (rows <= ) {

        return((double) rows);

    }

    /* Assume that the read time is proportional to the scan time for all

    rows + at most one seek per range. */

    time_for_scan = scan_time();

    //estimate_rows_upper_bound这里就是计算全表总记录的函数

    if ((total_rows = estimate_rows_upper_bound()) < rows) {

        return(time_for_scan);

    }

    return(ranges + (double) rows / (double) total_rows * time_for_scan);

}

/*********************************************************************//**

Gives an UPPER BOUND to the number of rows in a table. This is used in

filesort.cc.

@return    upper bound of rows */

UNIV_INTERN

ha_rows

ha_innobase::estimate_rows_upper_bound(void)

/*======================================*/

{

    dict_index_t*    index;

    ulonglong    estimate;

    ulonglong    local_data_file_length;

    ulint        stat_n_leaf_pages;

    //取得该表的第一个索引，就是聚集索引

    index = dict_table_get_first_index(prebuilt->table);

    //聚焦索引的叶子结点个数

    stat_n_leaf_pages = index->stat_n_leaf_pages;

    //大小为 叶子结点个数*16k

    local_data_file_length = ((ulonglong) stat_n_leaf_pages) * UNIV_PAGE_SIZE;

    /* Calculate a minimum length for a clustered index record and from

    that an upper bound for the number of rows. Since we only calculate

    new statistics in row0mysql.c when a table has grown by a threshold

    factor, we must add a safety factor 2 in front of the formula below. */

    //计算这个聚集索引的大小

    // 2* 总叶子个数*16K / 聚焦索引大小 得到聚集索引记录个数

    estimate =  * local_data_file_length /

                     dict_index_calc_min_rec_len(index);

    DBUG_RETURN((ha_rows) estimate);

}

/*********************************************************************//**

Calculates the minimum record length in an index. */

UNIV_INTERN

ulint

dict_index_calc_min_rec_len(

/*========================*/

    const dict_index_t*    index)    /*!< in: index */

{

    ulint    sum    = ;

    ulint    i;

    //记录为compack 紧凑模式，因为有可能这个索引是由多个字段组成，要遍历，求出总字节数

    ulint    comp    = dict_table_is_comp(index->table);

    if (comp) {

        ulint nullable = ;

        sum = REC_N_NEW_EXTRA_BYTES;

        for (i = ; i < dict_index_get_n_fields(index); i++) {

            const dict_col_t*    col

                = dict_index_get_nth_col(index, i);

            ulint    size = dict_col_get_fixed_size(col, comp);

            sum += size;

            if (!size) {

                size = col->len;

                sum += size <  ?  : ;

            }

            if (!(col->prtype & DATA_NOT_NULL)) {

                nullable++;

            }

        }

        /* round the NULL flags up to full bytes */

        sum += UT_BITS_IN_BYTES(nullable);

        return(sum);

    }

}

/** InnoDB B-tree index */

typedef struct dict_index_struct dict_index_t;

/** Data structure for an index.  Most fields will be

initialized to 0, NULL or FALSE in dict_mem_index_create(). */

struct dict_index_struct{

    index_id_t    id;    /*!< id of the index */

    mem_heap_t*    heap;    /*!< memory heap */

    const char*    name;    /*!< index name */

    const char*    table_name;/*!< table name */

    dict_table_t*    table;    /*!< back pointer to table */ //

#ifndef UNIV_HOTBACKUP

    unsigned    space:;

                /*!< space where the index tree is placed */

    unsigned    page:;/*!< index tree root page number */

#endif /* !UNIV_HOTBACKUP */

    unsigned    type:DICT_IT_BITS;

                /*!< index type (DICT_CLUSTERED, DICT_UNIQUE,

                DICT_UNIVERSAL, DICT_IBUF, DICT_CORRUPT) */

#define MAX_KEY_LENGTH_BITS 12

    unsigned    trx_id_offset:MAX_KEY_LENGTH_BITS;

                /*!< position of the trx id column

                in a clustered index record, if the fields

                before it are known to be of a fixed size,

                0 otherwise */

#if (1<<MAX_KEY_LENGTH_BITS) < MAX_KEY_LENGTH

# error (<<MAX_KEY_LENGTH_BITS) < MAX_KEY_LENGTH

#endif

    unsigned    n_user_defined_cols:;

                /*!< number of columns the user defined to

                be in the index: in the internal

                representation we add more columns */

    unsigned    n_uniq:;/*!< number of fields from the beginning

                which are enough to determine an index

                entry uniquely */

    unsigned    n_def:;/*!< number of fields defined so far */

    unsigned    n_fields:;/*!< number of fields in the index */

    unsigned    n_nullable:;/*!< number of nullable fields */

    unsigned    cached:;/*!< TRUE if the index object is in the

                dictionary cache */

    unsigned    to_be_dropped:;

                /*!< TRUE if this index is marked to be

                dropped in ha_innobase::prepare_drop_index(),

                otherwise FALSE. Protected by

                dict_sys->mutex, dict_operation_lock and

                index->lock.*/

    dict_field_t*    fields;    /*!< array of field descriptions */

#ifndef UNIV_HOTBACKUP

    UT_LIST_NODE_T(dict_index_t)

            indexes;/*!< list of indexes of the table */

    btr_search_t*    search_info; /*!< info used in optimistic searches */

    /*----------------------*/

    /** Statistics for query optimization */

    /* @{ */

    ib_int64_t*    stat_n_diff_key_vals;

                /*!< approximate number of different

                key values for this index, for each

                n-column prefix where n <=

                dict_get_n_unique(index); we

                periodically calculate new

                estimates */

    ib_int64_t*    stat_n_non_null_key_vals;

                /* approximate number of non-null key values

                for this index, for each column where

                n < dict_get_n_unique(index); This

                is used when innodb_stats_method is

                "nulls_ignored". */

    ulint        stat_index_size;
/*!< approximate index size in

                database pages */
ulint        stat_n_leaf_pages;
  /*!< approximate number of leaf pages in the

                index tree */

    /* @} */

    rw_lock_t    lock;    /*!< read-write lock protecting the

                upper levels of the index tree */

    trx_id_t    trx_id; /*!< id of the transaction that created this

                index, or 0 if the index existed

                when InnoDB was started up */

#endif /* !UNIV_HOTBACKUP */

#ifdef UNIV_BLOB_DEBUG

    mutex_t        blobs_mutex;

                /*!< mutex protecting blobs */

    void*        blobs;    /*!< map of (page_no,heap_no,field_no)

                to first_blob_page_no; protected by

                blobs_mutex; @see btr_blob_dbg_t */

#endif /* UNIV_BLOB_DEBUG */

#ifdef UNIV_DEBUG

    ulint        magic_n;/*!< magic number */

/** Value of dict_index_struct::magic_n */

# define DICT_INDEX_MAGIC_N

#endif

};