Skip to content

M
mariadb
Commit e437014d authored by marko's avatar marko
Browse files
Options

Remove code related to clustered tables. They were never implemented, and 

the implementation would be challenging with ROW_FORMAT=COMPACT.

Remove the table types DICT_TABLE_CLUSTER_MEMBER and DICT_TABLE_CLUSTER and
all related tests and functions.

dict_table_t: Remove mix_id, mix_len, mix_id_len, mix_id_buf, and
cluster_name.

plan_t: Remove mixed_index.

dict_create_sys_tables_tuple(): Set MIX_ID=0, MIX_LEN=0 and CLUSTER_NAME=NULL
when inserting into SYS_TABLES.

dict_tree_check_search_tuple(): Enclose in #ifdef UNIV_DEBUG.
parent b49a7757
Show whitespace changes
Inline Side-by-side
Showing with 45 additions and 448 deletions
btr/btr0btr.c
View file @ e437014d
......@@ -144,7 +144,7 @@ btr_root_get(
root = btr_page_get(space, root_page_no, RW_X_LATCH, mtr);
ut_a((ibool)!!page_is_comp(root) ==
dict_table_is_comp(UT_LIST_GET_FIRST(tree->tree_indexes)->table));
dict_table_is_comp(tree->tree_index->table));
return(root);
}
......@@ -259,7 +259,7 @@ btr_page_create(
ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
MTR_MEMO_PAGE_X_FIX));
page_create(page, mtr,
dict_table_is_comp(UT_LIST_GET_FIRST(tree->tree_indexes)->table));
dict_table_is_comp(tree->tree_index->table));
buf_block_align(page)->check_index_page_at_flush = TRUE;
btr_page_set_index_id(page, tree->id, mtr);
......@@ -574,7 +574,7 @@ btr_page_get_father_for_rec(
tuple = dict_tree_build_node_ptr(tree, user_rec, 0, heap,
btr_page_get_level(page, mtr));
index = UT_LIST_GET_FIRST(tree->tree_indexes);
index = tree->tree_index;
/* In the following, we choose just any index from the tree as the
first parameter for btr_cur_search_to_nth_level. */
......@@ -1073,8 +1073,7 @@ btr_root_raise_and_insert(
/* fprintf(stderr, "Root raise new page no %lu\n",
buf_frame_get_page_no(new_page)); */
ibuf_reset_free_bits(UT_LIST_GET_FIRST(tree->tree_indexes),
new_page);
ibuf_reset_free_bits(tree->tree_index, new_page);
/* Reposition the cursor to the child node */
page_cur_search(new_page, cursor->index, tuple,
PAGE_CUR_LE, page_cursor);
......@@ -1415,7 +1414,7 @@ btr_insert_on_non_leaf_level(
/* In the following, choose just any index from the tree as the
first parameter for btr_cur_search_to_nth_level. */
btr_cur_search_to_nth_level(UT_LIST_GET_FIRST(tree->tree_indexes),
btr_cur_search_to_nth_level(tree->tree_index,
level, tuple, PAGE_CUR_LE, BTR_CONT_MODIFY_TREE,
&cursor, 0, mtr);
......@@ -1479,7 +1478,7 @@ btr_attach_half_pages(
btr_node_ptr_set_child_page_no(node_ptr,
rec_get_offsets(node_ptr,
UT_LIST_GET_FIRST(tree->tree_indexes),
tree->tree_index,
NULL, ULINT_UNDEFINED, &heap),
lower_page_no, mtr);
mem_heap_empty(heap);
......@@ -1768,8 +1767,8 @@ func_start:
buf_frame_get_page_no(left_page),
buf_frame_get_page_no(right_page)); */
ut_ad(page_validate(left_page, UT_LIST_GET_FIRST(tree->tree_indexes)));
ut_ad(page_validate(right_page, UT_LIST_GET_FIRST(tree->tree_indexes)));
ut_ad(page_validate(left_page, tree->tree_index));
ut_ad(page_validate(right_page, tree->tree_index));
mem_heap_free(heap);
return(rec);
......@@ -1910,8 +1909,7 @@ btr_node_ptr_delete(
node_ptr = btr_page_get_father_node_ptr(tree, page, mtr);
btr_cur_position(UT_LIST_GET_FIRST(tree->tree_indexes), node_ptr,
&cursor);
btr_cur_position(tree->tree_index, node_ptr, &cursor);
compressed = btr_cur_pessimistic_delete(&err, TRUE, &cursor, FALSE,
mtr);
ut_a(err == DB_SUCCESS);
......@@ -1947,7 +1945,7 @@ btr_lift_page_up(
btr_page_get_father_node_ptr(tree, page, mtr));
page_level = btr_page_get_level(page, mtr);
index = UT_LIST_GET_FIRST(tree->tree_indexes);
index = tree->tree_index;
btr_search_drop_page_hash_index(page);
......@@ -2180,8 +2178,7 @@ btr_discard_only_page_on_level(
btr_page_empty(father_page, mtr);
/* We play safe and reset the free bits for the father */
ibuf_reset_free_bits(UT_LIST_GET_FIRST(tree->tree_indexes),
father_page);
ibuf_reset_free_bits(tree->tree_index, father_page);
} else {
ut_ad(page_get_n_recs(father_page) == 1);
......@@ -2449,7 +2446,7 @@ btr_check_node_ptr(
ut_a(cmp_dtuple_rec(node_ptr_tuple, node_ptr,
rec_get_offsets(node_ptr,
dict_tree_find_index(tree, node_ptr),
tree->tree_index,
NULL, ULINT_UNDEFINED, &heap)) == 0);
mem_heap_free(heap);
......@@ -2692,7 +2689,7 @@ btr_validate_level(
space = buf_frame_get_space_id(page);
index = UT_LIST_GET_FIRST(tree->tree_indexes);
index = tree->tree_index;
while (level != btr_page_get_level(page, &mtr)) {
......
btr/btr0pcur.c
View file @ e437014d
......@@ -259,10 +259,7 @@ btr_pcur_restore_position(
cursor->latch_mode = latch_mode;
#ifdef UNIV_DEBUG
rec = btr_pcur_get_rec(cursor);
index = dict_tree_find_index(
btr_cur_get_tree(
btr_pcur_get_btr_cur(cursor)),
rec);
index = btr_pcur_get_btr_cur(cursor)->index;
heap = mem_heap_create(256);
offsets1 = rec_get_offsets(cursor->old_rec,
......
dict/dict0crea.c
View file @ e437014d
......@@ -82,7 +82,7 @@ dict_create_sys_tables_tuple(
dfield = dtuple_get_nth_field(entry, 4);
ptr = mem_heap_alloc(heap, 8);
mach_write_to_8(ptr, table->mix_id);
memset(ptr, 0, 8);
dfield_set_data(dfield, ptr, 8);
/* 7: MIX_LEN --------------------------*/
......@@ -90,19 +90,13 @@ dict_create_sys_tables_tuple(
dfield = dtuple_get_nth_field(entry, 5);
ptr = mem_heap_alloc(heap, 4);
mach_write_to_4(ptr, table->mix_len);
memset(ptr, 0, 4);
dfield_set_data(dfield, ptr, 4);
/* 8: CLUSTER_NAME ---------------------*/
dfield = dtuple_get_nth_field(entry, 6);
dfield_set_data(dfield, NULL, UNIV_SQL_NULL); /* not supported */
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
dfield_set_data(dfield, table->cluster_name,
ut_strlen(table->cluster_name));
ut_error; /* Oracle-style clusters are not supported yet */
} else {
dfield_set_data(dfield, NULL, UNIV_SQL_NULL);
}
/* 9: SPACE ----------------------------*/
dfield = dtuple_get_nth_field(entry, 7);
......@@ -208,7 +202,6 @@ dict_build_table_def_step(
tab_node_t* node) /* in: table create node */
{
dict_table_t* table;
dict_table_t* cluster_table;
dtuple_t* row;
ulint error;
const char* path_or_name;
......@@ -236,23 +229,6 @@ dict_build_table_def_step(
return(DB_TOO_BIG_RECORD);
}
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
cluster_table = dict_table_get_low(table->cluster_name);
if (cluster_table == NULL) {
return(DB_CLUSTER_NOT_FOUND);
}
/* Inherit space and mix len from the cluster */
table->space = cluster_table->space;
table->mix_len = cluster_table->mix_len;
table->mix_id = dict_hdr_get_new_id(DICT_HDR_MIX_ID);
}
if (srv_file_per_table) {
/* We create a new single-table tablespace for the table.
We initially let it be 4 pages:
......@@ -615,15 +591,6 @@ dict_create_index_tree_step(
sys_indexes = dict_sys->sys_indexes;
if (index->type & DICT_CLUSTERED
&& table->type == DICT_TABLE_CLUSTER_MEMBER) {
/* Do not create a new index tree: entries are put to the
cluster tree */
return(DB_SUCCESS);
}
/* Run a mini-transaction in which the index tree is allocated for
the index and its root address is written to the index entry in
sys_indexes */
......
dict/dict0dict.c
View file @ e437014d
......@@ -883,13 +883,6 @@ dict_table_add_to_cache(
ut_a(table2 == NULL);
}
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
table->mix_id_len = mach_dulint_get_compressed_size(
table->mix_id);
mach_dulint_write_compressed(table->mix_id_buf, table->mix_id);
}
/* Add the columns to the column hash table */
for (i = 0; i < table->n_cols; i++) {
dict_col_add_to_cache(table, dict_table_get_nth_col(table, i));
......@@ -1407,7 +1400,6 @@ dict_index_add_to_cache(
{
dict_index_t* new_index;
dict_tree_t* tree;
dict_table_t* cluster;
dict_field_t* field;
ulint n_ord;
ibool success;
......@@ -1481,21 +1473,11 @@ dict_index_add_to_cache(
dict_field_get_col(field)->ord_part++;
}
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
/* The index tree is found from the cluster object */
cluster = dict_table_get_low(table->cluster_name);
tree = dict_index_get_tree(
UT_LIST_GET_FIRST(cluster->indexes));
new_index->tree = tree;
} else {
/* Create an index tree memory object for the index */
tree = dict_tree_create(new_index, page_no);
ut_ad(tree);
new_index->tree = tree;
}
if (!UNIV_UNLIKELY(new_index->type & DICT_UNIVERSAL)) {
......@@ -1513,7 +1495,7 @@ dict_index_add_to_cache(
}
/* Add the index to the list of indexes stored in the tree */
UT_LIST_ADD_LAST(tree_indexes, tree->tree_indexes, new_index);
tree->tree_index = new_index;
/* If the dictionary cache grows too big, trim the table LRU list */
......@@ -1545,7 +1527,7 @@ dict_index_remove_from_cache(
ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */
ut_ad(UT_LIST_GET_LEN((index->tree)->tree_indexes) == 1);
ut_ad(index->tree->tree_index);
dict_tree_free(index->tree);
/* Decrement the ord_part counts in columns which are ordering */
......@@ -1762,22 +1744,10 @@ dict_index_build_internal_clust(
new_index->id = index->id;
if (table->type != DICT_TABLE_ORDINARY) {
/* The index is mixed: copy common key prefix fields */
dict_index_copy(new_index, index, 0, table->mix_len);
ut_a(table->type == DICT_TABLE_ORDINARY);
/* Add the mix id column */
dict_index_add_col(new_index,
dict_table_get_sys_col(table, DATA_MIX_ID), 0);
/* Copy the rest of fields */
dict_index_copy(new_index, index, table->mix_len,
index->n_fields);
} else {
/* Copy the fields of index */
dict_index_copy(new_index, index, 0, index->n_fields);
}
if (UNIV_UNLIKELY(index->type & DICT_UNIVERSAL)) {
/* No fixed number of fields determines an entry uniquely */
......@@ -3654,7 +3624,7 @@ dict_tree_create(
tree->id = index->id;
UT_LIST_INIT(tree->tree_indexes);
tree->tree_index = NULL;
tree->magic_n = DICT_TREE_MAGIC_N;
......@@ -3680,135 +3650,7 @@ dict_tree_free(
mem_free(tree);
}
/**************************************************************************
In an index tree, finds the index corresponding to a record in the tree. */
UNIV_INLINE
dict_index_t*
dict_tree_find_index_low(
/*=====================*/
/* out: index */
dict_tree_t* tree, /* in: index tree */
rec_t* rec) /* in: record for which to find correct
index */
{
dict_index_t* index;
dict_table_t* table;
dulint mix_id;
ulint len;
index = UT_LIST_GET_FIRST(tree->tree_indexes);
ut_ad(index);
table = index->table;
if ((index->type & DICT_CLUSTERED)
&& UNIV_UNLIKELY(table->type != DICT_TABLE_ORDINARY)) {
/* Get the mix id of the record */
ut_a(!dict_table_is_comp(table));
mix_id = mach_dulint_read_compressed(
rec_get_nth_field_old(rec, table->mix_len, &len));
while (ut_dulint_cmp(table->mix_id, mix_id) != 0) {
index = UT_LIST_GET_NEXT(tree_indexes, index);
table = index->table;
ut_ad(index);
}
}
return(index);
}
/**************************************************************************
In an index tree, finds the index corresponding to a record in the tree. */
dict_index_t*
dict_tree_find_index(
/*=================*/
/* out: index */
dict_tree_t* tree, /* in: index tree */
rec_t* rec) /* in: record for which to find correct
index */
{
dict_index_t* index;
index = dict_tree_find_index_low(tree, rec);
return(index);
}
/**************************************************************************
In an index tree, finds the index corresponding to a dtuple which is used
in a search to a tree. */
dict_index_t*
dict_tree_find_index_for_tuple(
/*===========================*/
/* out: index; NULL if the tuple does not
contain the mix id field in a mixed tree */
dict_tree_t* tree, /* in: index tree */
dtuple_t* tuple) /* in: tuple for which to find index */
{
dict_index_t* index;
dict_table_t* table;
dulint mix_id;
ut_ad(dtuple_check_typed(tuple));
if (UT_LIST_GET_LEN(tree->tree_indexes) == 1) {
return(UT_LIST_GET_FIRST(tree->tree_indexes));
}
index = UT_LIST_GET_FIRST(tree->tree_indexes);
ut_ad(index);
table = index->table;
if (dtuple_get_n_fields(tuple) <= table->mix_len) {
return(NULL);
}
/* Get the mix id of the record */
mix_id = mach_dulint_read_compressed(
dfield_get_data(
dtuple_get_nth_field(tuple, table->mix_len)));
while (ut_dulint_cmp(table->mix_id, mix_id) != 0) {
index = UT_LIST_GET_NEXT(tree_indexes, index);
table = index->table;
ut_ad(index);
}
return(index);
}
/***********************************************************************
Checks if a table which is a mixed cluster member owns a record. */
ibool
dict_is_mixed_table_rec(
/*====================*/
/* out: TRUE if the record belongs to this
table */
dict_table_t* table, /* in: table in a mixed cluster */
rec_t* rec) /* in: user record in the clustered index */
{
byte* mix_id_field;
ulint len;
ut_ad(!dict_table_is_comp(table));
mix_id_field = rec_get_nth_field_old(rec,
table->mix_len, &len);
return(len == table->mix_id_len
&& !ut_memcmp(table->mix_id_buf, mix_id_field, len));
}
#ifdef UNIV_DEBUG
/**************************************************************************
Checks that a tuple has n_fields_cmp value in a sensible range, so that
no comparison can occur with the page number field in a node pointer. */
......@@ -3820,19 +3662,14 @@ dict_tree_check_search_tuple(
dict_tree_t* tree, /* in: index tree */
dtuple_t* tuple) /* in: tuple used in a search */
{
dict_index_t* index;
index = dict_tree_find_index_for_tuple(tree, tuple);
if (index == NULL) {
return(TRUE);
}
dict_index_t* index = tree->tree_index;
ut_a(index);
ut_a(dtuple_get_n_fields_cmp(tuple)
<= dict_index_get_n_unique_in_tree(index));
return(TRUE);
}
#endif /* UNIV_DEBUG */
/**************************************************************************
Builds a node pointer out of a physical record and a page number. */
......@@ -3855,7 +3692,7 @@ dict_tree_build_node_ptr(
byte* buf;
ulint n_unique;
ind = dict_tree_find_index_low(tree, rec);
ind = tree->tree_index;
if (UNIV_UNLIKELY(tree->type & DICT_UNIVERSAL)) {
/* In a universal index tree, we take the whole record as
......@@ -3923,7 +3760,7 @@ dict_tree_copy_rec_order_prefix(
ulint n;
UNIV_PREFETCH_R(rec);
index = dict_tree_find_index_low(tree, rec);
index = tree->tree_index;
if (UNIV_UNLIKELY(tree->type & DICT_UNIVERSAL)) {
ut_a(!dict_table_is_comp(index->table));
......@@ -3951,7 +3788,7 @@ dict_tree_build_data_tuple(
dtuple_t* tuple;
dict_index_t* ind;
ind = dict_tree_find_index_low(tree, rec);
ind = tree->tree_index;
ut_ad(dict_table_is_comp(ind->table)
|| n_fields <= rec_get_n_fields_old(rec));
......
dict/dict0load.c
View file @ e437014d
......@@ -849,35 +849,11 @@ dict_load_table(
field = rec_get_nth_field_old(rec, 5, &len);
table->type = mach_read_from_4(field);
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
ut_error;
#if 0 /* clustered tables have not been implemented yet */
field = rec_get_nth_field_old(rec, 6, &len);
table->mix_id = mach_read_from_8(field);
field = rec_get_nth_field_old(rec, 8, &len);
table->cluster_name = mem_heap_strdupl(heap, (char*) field, len);
#endif
}
if ((table->type == DICT_TABLE_CLUSTER)
|| (table->type == DICT_TABLE_CLUSTER_MEMBER)) {
field = rec_get_nth_field_old(rec, 7, &len);
ut_a(len == 4);
table->mix_len = mach_read_from_4(field);
}
ut_a(table->type == DICT_TABLE_ORDINARY);
btr_pcur_close(&pcur);
mtr_commit(&mtr);
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
/* Load the cluster table definition if not yet in
memory cache */
dict_table_get_low(table->cluster_name);
}
dict_load_columns(table, heap);
dict_table_add_to_cache(table);
......
dict/dict0mem.c
View file @ e437014d
......@@ -66,9 +66,6 @@ dict_mem_table_create(
table->cached = FALSE;
table->mix_id = ut_dulint_zero;
table->mix_len = 0;
table->cols = mem_heap_alloc(heap, (n_cols + DATA_N_SYS_COLS)
* sizeof(dict_col_t));
UT_LIST_INIT(table->indexes);
......@@ -97,44 +94,6 @@ dict_mem_table_create(
return(table);
}
/**************************************************************************
Creates a cluster memory object. */
dict_table_t*
dict_mem_cluster_create(
/*====================*/
/* out, own: cluster object */
const char* name, /* in: cluster name */
ulint space, /* in: space where the clustered indexes
of the member tables are placed */
ulint n_cols, /* in: number of columns */
ulint mix_len)/* in: length of the common key prefix in the
cluster */
{
dict_table_t* cluster;
/* Clustered tables cannot work with the compact record format. */
cluster = dict_mem_table_create(name, space, n_cols, 0);
cluster->type = DICT_TABLE_CLUSTER;
cluster->mix_len = mix_len;
return(cluster);
}
/**************************************************************************
Declares a non-published table as a member in a cluster. */
void
dict_mem_table_make_cluster_member(
/*===============================*/
dict_table_t* table, /* in: non-published table */
const char* cluster_name) /* in: cluster name */
{
table->type = DICT_TABLE_CLUSTER_MEMBER;
table->cluster_name = cluster_name;
}
/**************************************************************************
Adds a column definition to a table. */
......
include/dict0dict.h
View file @ e437014d
......@@ -734,33 +734,6 @@ dict_tree_free(
/**************************************************************************
In an index tree, finds the index corresponding to a record in the tree. */
dict_index_t*
dict_tree_find_index(
/*=================*/
/* out: index */
dict_tree_t* tree, /* in: index tree */
rec_t* rec); /* in: record for which to find correct index */
/**************************************************************************
In an index tree, finds the index corresponding to a dtuple which is used
in a search to a tree. */
dict_index_t*
dict_tree_find_index_for_tuple(
/*===========================*/
/* out: index; NULL if the tuple does not
contain the mix id field in a mixed tree */
dict_tree_t* tree, /* in: index tree */
dtuple_t* tuple); /* in: tuple for which to find index */
/***********************************************************************
Checks if a table which is a mixed cluster member owns a record. */
ibool
dict_is_mixed_table_rec(
/*====================*/
/* out: TRUE if the record belongs to this
table */
dict_table_t* table, /* in: table in a mixed cluster */
rec_t* rec); /* in: user record in the clustered index */
/**************************************************************************
Returns an index object if it is found in the dictionary cache. */
......@@ -769,6 +742,7 @@ dict_index_get_if_in_cache(
/*=======================*/
/* out: index, NULL if not found */
dulint index_id); /* in: index id */
#ifdef UNIV_DEBUG
/**************************************************************************
Checks that a tuple has n_fields_cmp value in a sensible range, so that
no comparison can occur with the page number field in a node pointer. */
......@@ -779,6 +753,7 @@ dict_tree_check_search_tuple(
/* out: TRUE if ok */
dict_tree_t* tree, /* in: index tree */
dtuple_t* tuple); /* in: tuple used in a search */
#endif /* UNIV_DEBUG */
/**************************************************************************
Builds a node pointer out of a physical record and a page number. */
......
include/dict0mem.h
View file @ e437014d
......@@ -35,9 +35,11 @@ combination of types */
/* Types for a table object */
#define DICT_TABLE_ORDINARY 1
#if 0 /* not implemented */
#define DICT_TABLE_CLUSTER_MEMBER 2
#define DICT_TABLE_CLUSTER 3 /* this means that the table is
really a cluster definition */
#endif
/* Table flags */
#define DICT_TF_COMPACT 1 /* compact page format */
......@@ -57,29 +59,6 @@ dict_mem_table_create(
ulint n_cols, /* in: number of columns */
ulint flags); /* in: table flags */
/**************************************************************************
Creates a cluster memory object. */
dict_cluster_t*
dict_mem_cluster_create(
/*====================*/
/* out, own: cluster object (where the
type dict_cluster_t == dict_table_t) */
const char* name, /* in: cluster name */
ulint space, /* in: space where the clustered
indexes of the member tables are
placed */
ulint n_cols, /* in: number of columns */
ulint mix_len); /* in: length of the common key prefix
in the cluster */
/**************************************************************************
Declares a non-published table as a member in a cluster. */
void
dict_mem_table_make_cluster_member(
/*===============================*/
dict_table_t* table, /* in: non-published table */
const char* cluster_name); /* in: cluster name */
/**************************************************************************
Adds a column definition to a table. */
void
......@@ -176,9 +155,7 @@ struct dict_field_struct{
/* Data structure for an index tree */
struct dict_tree_struct{
ulint type; /* tree type */
dulint id; /* id of the index stored in the tree, in the
case of a mixed index, the id of the clustered
index of the cluster table */
dulint id; /* id of the index stored in the tree */
ulint space; /* space of index tree */
ulint page; /* index tree root page number */
byte pad[64];/* Padding to prevent other memory hotspots on
......@@ -189,13 +166,8 @@ struct dict_tree_struct{
struct has been memoryfixed (by mini-
transactions wanting to access the index
tree) */
UT_LIST_BASE_NODE_T(dict_index_t)
tree_indexes; /* list of indexes stored in the
index tree: if the tree is not of the
mixed type there is only one index in
the list; if the tree is of the mixed
type, the first index in the list is the
index of the cluster which owns the tree */
dict_index_t* tree_index; /* the index stored in the
index tree */
ulint magic_n;/* magic number */
};
......@@ -301,7 +273,7 @@ a foreign key constraint is enforced, therefore RESTRICT just means no flag */
/* Data structure for a database table */
struct dict_table_struct{
dulint id; /* id of the table or cluster */
dulint id; /* id of the table */
ulint type; /* DICT_TABLE_ORDINARY, ... */
ulint flags; /* DICT_TF_COMPACT, ... */
mem_heap_t* heap; /* memory heap */
......@@ -371,17 +343,6 @@ struct dict_table_struct{
UT_LIST_BASE_NODE_T(lock_t)
locks; /* list of locks on the table */
/*----------------------*/
dulint mix_id; /* if the table is a member in a cluster,
this is its mix id */
ulint mix_len;/* if the table is a cluster or a member
this is the common key prefix lenght */
ulint mix_id_len;/* mix id length in a compressed form */
byte mix_id_buf[12];
/* mix id of a mixed table written in
a compressed form */
const char* cluster_name; /* if the table is a member in a
cluster, this is the name of the cluster */
/*----------------------*/
ibool does_not_fit_in_memory;
/* this field is used to specify in simulations
tables which are so big that disk should be
......
include/row0sel.h
View file @ e437014d
......@@ -224,8 +224,6 @@ struct plan_struct{
ulint first_prefetched;/* index of the first cached row in
select buffer arrays for each column */
ibool no_prefetch; /* no prefetch for this table */
ibool mixed_index; /* TRUE if index is a clustered index
in a mixed cluster */
sym_node_list_t columns; /* symbol table nodes for the columns
to retrieve from the table */
UT_LIST_BASE_NODE_T(func_node_t)
......
pars/pars0opt.c
View file @ e437014d
......@@ -313,7 +313,6 @@ opt_calc_index_goodness(
ulint goodness;
ulint n_fields;
ulint col_no;
ulint mix_id_col_no;
ulint op;
ulint j;
......@@ -326,8 +325,6 @@ opt_calc_index_goodness(
n_fields = dict_index_get_n_unique_in_tree(index);
mix_id_col_no = dict_table_get_sys_col_no(index->table, DATA_MIX_ID);
for (j = 0; j < n_fields; j++) {
col_no = dict_index_get_nth_col_no(index, j);
......@@ -335,13 +332,7 @@ opt_calc_index_goodness(
exp = opt_look_for_col_in_cond_before(OPT_EQUAL, col_no,
sel_node->search_cond,
sel_node, nth_table, &op);
if (col_no == mix_id_col_no) {
ut_ad(exp == NULL);
index_plan[j] = NULL;
*last_op = '=';
goodness += 4;
} else if (exp) {
if (exp) {
/* The value for this column is exactly known already
at this stage of the join */
......@@ -531,7 +522,6 @@ opt_search_plan_for_table(
warning */
ulint best_goodness;
ulint best_last_op = 0; /* remove warning */
ulint mix_id_pos;
que_node_t* index_plan[256];
que_node_t* best_index_plan[256];
......@@ -601,26 +591,6 @@ opt_search_plan_for_table(
plan->unique_search = FALSE;
}
if ((table->type != DICT_TABLE_ORDINARY)
&& (best_index->type & DICT_CLUSTERED)) {
plan->mixed_index = TRUE;
mix_id_pos = table->mix_len;
if (mix_id_pos < n_fields) {
/* We have to add the mix id as a (string) literal
expression to the tuple_exps */
plan->tuple_exps[mix_id_pos] =
sym_tab_add_str_lit(pars_sym_tab_global,
table->mix_id_buf,
table->mix_id_len);
}
} else {
plan->mixed_index = FALSE;
}
plan->old_vers_heap = NULL;
btr_pcur_init(&(plan->pcur));
......@@ -1055,7 +1025,6 @@ opt_clust_access(
dict_table_t* table;
dict_index_t* clust_index;
dict_index_t* index;
dfield_t* dfield;
mem_heap_t* heap;
ulint n_fields;
ulint pos;
......@@ -1109,22 +1078,7 @@ opt_clust_access(
*(plan->clust_map + i) = pos;
ut_ad((pos != ULINT_UNDEFINED)
|| ((table->type == DICT_TABLE_CLUSTER_MEMBER)
&& (i == table->mix_len)));
}
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
/* Preset the mix id field to the mix id constant */
dfield = dtuple_get_nth_field(plan->clust_ref, table->mix_len);
dfield_set_data(dfield, mem_heap_alloc(heap,
table->mix_id_len),
table->mix_id_len);
ut_memcpy(dfield_get_data(dfield), table->mix_id_buf,
table->mix_id_len);
ut_ad(pos != ULINT_UNDEFINED);
}
}
......
row/row0ins.c
View file @ e437014d
......@@ -140,7 +140,6 @@ row_ins_alloc_sys_fields(
mem_heap_t* heap;
dict_col_t* col;
dfield_t* dfield;
ulint len;
byte* ptr;
row = node->row;
......@@ -162,21 +161,6 @@ row_ins_alloc_sys_fields(
node->row_id_buf = ptr;
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
/* 2. Fill in the dfield for mix id */
col = dict_table_get_sys_col(table, DATA_MIX_ID);
dfield = dtuple_get_nth_field(row, dict_col_get_no(col));
len = mach_dulint_get_compressed_size(table->mix_id);
ptr = mem_heap_alloc(heap, DATA_MIX_ID_LEN);
mach_dulint_write_compressed(ptr, table->mix_id);
dfield_set_data(dfield, ptr, len);
}
/* 3. Allocate buffer for trx id */
col = dict_table_get_sys_col(table, DATA_TRX_ID);
......
row/row0sel.c
View file @ e437014d
......@@ -1430,14 +1430,6 @@ rec_loop:
/* Ok, no need to test end_conds or mix id */
} else if (plan->mixed_index) {
/* We have to check if the record in a mixed cluster belongs
to this table */
if (!dict_is_mixed_table_rec(plan->table, rec)) {
goto next_rec;
}
}
/* We are ready to look at a possible new index entry in the result
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7