~drizzle-trunk/drizzle/development

((table_ref->join_columns && /* This is a merge view. */ (table_ref->field_translation && table_ref->join_columns->elements == (ulong)(table_ref->field_translation_end - table_ref->field_translation))) ||

2846

/* This is stored table or a tmptable view. */

2847

(!table_ref->field_translation && table_ref->join_columns->elements == table_ref->table->s->fields)));

2848

field_it= &natural_join_it;

2849

}

2850

/* This is a base table or stored view. */

2851

else

2852

{

2853

assert(table_ref->table);

2854

field_it= &table_field_it;

2855

}

2856

field_it->set(table_ref);

2857

return;

2858

}

2859

2860

2861

void Field_iterator_table_ref::set(TABLE_LIST *table)

2862

{

2863

assert(table);

2864

first_leaf= table->first_leaf_for_name_resolution();

2865

last_leaf= table->last_leaf_for_name_resolution();

2866

assert(first_leaf && last_leaf);

2867

table_ref= first_leaf;

2868

set_field_iterator();

2869

}

2870

2871

2872

void Field_iterator_table_ref::next()

2873

{

2874

/* Move to the next field in the current table reference. */

2875

field_it->next();

2876

2877

If all fields of the current table reference are exhausted, move to

2878

the next leaf table reference.

2879

2880

if (field_it->end_of_fields() && table_ref != last_leaf)

2881

{

2882

table_ref= table_ref->next_name_resolution_table;

2883

assert(table_ref);

2884

set_field_iterator();

2885

}

2886

}

2887

2888

2889

const char *Field_iterator_table_ref::table_name()

2890

{

2891

if (table_ref->is_natural_join)

2892

return natural_join_it.column_ref()->table_name();

2893

2894

assert(!strcmp(table_ref->table_name,

2895

table_ref->table->s->table_name.str));

2896

return table_ref->table_name;

2897

}

2898

2899

2900

const char *Field_iterator_table_ref::db_name()

2901

{

2902

if (table_ref->is_natural_join)

2903

return natural_join_it.column_ref()->db_name();

2904

2905

2906

Test that TABLE_LIST::db is the same as st_table_share::db to

2907

ensure consistency. An exception are I_S schema tables, which

2908

are inconsistent in this respect.

2909

2910

assert(!strcmp(table_ref->db, table_ref->table->s->db.str) ||

2911

(table_ref->schema_table &&

2912

table_ref->table->s->db.str[0] == 0));

2913

2914

return table_ref->db;

2915

}

2916

2917

2918

2919

Create new or return existing column reference to a column of a

2920

natural/using join.

2921

2922

SYNOPSIS

2923

Field_iterator_table_ref::get_or_create_column_ref()

2924

parent_table_ref the parent table reference over which the

2925

iterator is iterating

2926

2927

DESCRIPTION

2928

Create a new natural join column for the current field of the

2929

iterator if no such column was created, or return an already

2930

created natural join column. The former happens for base tables or

2931

views, and the latter for natural/using joins. If a new field is

2932

created, then the field is added to 'parent_table_ref' if it is

2933

given, or to the original table referene of the field if

2934

parent_table_ref == NULL.

2935

2936

NOTES

2937

This method is designed so that when a Field_iterator_table_ref

2938

walks through the fields of a table reference, all its fields

2939

are created and stored as follows:

2940

- If the table reference being iterated is a stored table, view or

2941

natural/using join, store all natural join columns in a list

2942

attached to that table reference.

2943

- If the table reference being iterated is a nested join that is

2944

not natural/using join, then do not materialize its result

2945

fields. This is OK because for such table references

2946

Field_iterator_table_ref iterates over the fields of the nested

2947

table references (recursively). In this way we avoid the storage

2948

of unnecessay copies of result columns of nested joins.

2949

2950

RETURN

2951

# Pointer to a column of a natural join (or its operand)

2952

NULL No memory to allocate the column

2953

2954

2955

Natural_join_column *

2956

Field_iterator_table_ref::get_or_create_column_ref(TABLE_LIST *parent_table_ref)

2957

{

2958

Natural_join_column *nj_col;

2959

bool is_created= true;

2960

uint field_count=0;

2961

TABLE_LIST *add_table_ref= parent_table_ref ?

2962

parent_table_ref : table_ref;

2963

2964

if (field_it == &table_field_it)

2965

{

2966

/* The field belongs to a stored table. */

2967

Field *tmp_field= table_field_it.field();

2968

nj_col= new Natural_join_column(tmp_field, table_ref);

2969

field_count= table_ref->table->s->fields;

2970

}

2971

else if (field_it == &view_field_it)

2972

{

2973

/* The field belongs to a merge view or information schema table. */

2974

Field_translator *translated_field= view_field_it.field_translator();

2975

nj_col= new Natural_join_column(translated_field, table_ref);

2976

field_count= table_ref->field_translation_end -

2977

table_ref->field_translation;

2978

}

2979

else

2980

{

2981

2982

The field belongs to a NATURAL join, therefore the column reference was

2983

already created via one of the two constructor calls above. In this case

2984

we just return the already created column reference.

2985

2986

assert(table_ref->is_join_columns_complete);

2987

is_created= false;

2988

nj_col= natural_join_it.column_ref();

2989

assert(nj_col);

2990

}

2991

assert(!nj_col->table_field ||

2992

nj_col->table_ref->table == nj_col->table_field->table);

2993

2994

2995

If the natural join column was just created add it to the list of

2996

natural join columns of either 'parent_table_ref' or to the table

2997

reference that directly contains the original field.

2998

2999

if (is_created)

3000

{

3001

/* Make sure not all columns were materialized. */

3002

assert(!add_table_ref->is_join_columns_complete);

3003

if (!add_table_ref->join_columns)

3004

{

3005

/* Create a list of natural join columns on demand. */

3006

if (!(add_table_ref->join_columns= new List<Natural_join_column>))

3007

return NULL;

3008

add_table_ref->is_join_columns_complete= false;

3009

}

3010

add_table_ref->join_columns->push_back(nj_col);

3011

3012

If new fields are added to their original table reference, mark if

3013

all fields were added. We do it here as the caller has no easy way

3014

of knowing when to do it.

3015

If the fields are being added to parent_table_ref, then the caller

3016

must take care to mark when all fields are created/added.

3017

3018

if (!parent_table_ref &&

3019

add_table_ref->join_columns->elements == field_count)

3020

add_table_ref->is_join_columns_complete= true;

3021

}

3022

3023

return nj_col;

3024

}

3025

3026

3027

3028

Return an existing reference to a column of a natural/using join.

3029

3030

SYNOPSIS

3031

Field_iterator_table_ref::get_natural_column_ref()

3032

3033

DESCRIPTION

3034

The method should be called in contexts where it is expected that

3035

all natural join columns are already created, and that the column

3036

being retrieved is a Natural_join_column.

3037

3038

RETURN

3039

# Pointer to a column of a natural join (or its operand)

3040

NULL No memory to allocate the column

3041

3042

3043

Natural_join_column *

3044

Field_iterator_table_ref::get_natural_column_ref()

3045

{

3046

Natural_join_column *nj_col;

3047

3048

assert(field_it == &natural_join_it);

3049

3050

The field belongs to a NATURAL join, therefore the column reference was

3051

already created via one of the two constructor calls above. In this case

3052

we just return the already created column reference.

3053

3054

nj_col= natural_join_it.column_ref();

3055

assert(nj_col &&

3056

(!nj_col->table_field ||

3057

nj_col->table_ref->table == nj_col->table_field->table));

3058

return nj_col;

3059

}

1881

return last_char_is_space || (uint32_t) name_length > NAME_CHAR_LEN;

1882

}

1883

3060

1884

3061

1885

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

3062

1886

Functions to handle column usage bitmaps (read_set, write_set etc...)

3064

1888

3065

1889

/* Reset all columns bitmaps */

3066

1890

3067

void st_table::clear_column_bitmaps()

1891

void Table::clear_column_bitmaps()

3068

1892

{

3069

1893

3070

1894

Reset column read/write usage. It's identical to:

3071

1895

bitmap_clear_all(&table->def_read_set);

3072

1896

bitmap_clear_all(&table->def_write_set);

3073

1897

3074

memset(def_read_set.bitmap, 0, s->column_bitmap_size*2);

1898

def_read_set.clearAll();

1899

def_write_set.clearAll();

3075

1900

column_bitmaps_set(&def_read_set, &def_write_set);

3076

1901

}

3077

1902

3078

1903

3079

1904

3080

Tell handler we are going to call position() and rnd_pos() later.

3081

1905

Tell Cursor we are going to call position() and rnd_pos() later.

1906

3082

1907

NOTES:

3083

1908

This is needed for handlers that uses the primary key to find the

3084

1909

row. In this case we have to extend the read bitmap with the primary

3085

1910

key fields.

3086

1911

3087

1912

3088

void st_table::prepare_for_position()

1913

void Table::prepare_for_position()

3089

1914

{

3090

1915

3091

1916

if ((file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&

3092

1917

s->primary_key < MAX_KEY)

3093

1918

{

3094

mark_columns_used_by_index_no_reset(s->primary_key, read_set);

3095

/* signal change */

3096

file->column_bitmaps_signal();

1919

mark_columns_used_by_index_no_reset(s->primary_key);

3097

1920

}

3098

1921

return;

3099

1922

}

3105

1928

NOTE:

3106

1929

This changes the bitmap to use the tmp bitmap

3107

1930

After this, you can't access any other columns in the table until

3108

bitmaps are reset, for example with st_table::clear_column_bitmaps()

3109

or st_table::restore_column_maps_after_mark_index()

1931

bitmaps are reset, for example with Table::clear_column_bitmaps()

1932

or Table::restore_column_maps_after_mark_index()

3110

1933

3111

1934

3112

void st_table::mark_columns_used_by_index(uint index)

1935

void Table::mark_columns_used_by_index(uint32_t index)

3113

1936

{

3114

MY_BITMAP *bitmap= &tmp_set;

1937

MyBitmap *bitmap= &tmp_set;

3115

1938

3116

1939

(void) file->extra(HA_EXTRA_KEYREAD);

3117

bitmap_clear_all(bitmap);

1940

bitmap->clearAll();

3118

1941

mark_columns_used_by_index_no_reset(index, bitmap);

3119

1942

column_bitmaps_set(bitmap, bitmap);

3120

1943

return;

3132

1955

when calling mark_columns_used_by_index

3133

1956

3134

1957

3135

void st_table::restore_column_maps_after_mark_index()

1958

void Table::restore_column_maps_after_mark_index()

3136

1959

{

3137

1960

3138

1961

key_read= 0;

3139

1962

(void) file->extra(HA_EXTRA_NO_KEYREAD);

3140

1963

default_column_bitmaps();

3141

file->column_bitmaps_signal();

3142

1964

return;

3143

1965

}

3144

1966

3147

1969

mark columns used by key, but don't reset other fields

3148

1970

3149

1971

3150

void st_table::mark_columns_used_by_index_no_reset(uint index,

3151

MY_BITMAP *bitmap)

1972

void Table::mark_columns_used_by_index_no_reset(uint32_t index)

1973

{

1974

mark_columns_used_by_index_no_reset(index, read_set);

1975

}

1976

1977

void Table::mark_columns_used_by_index_no_reset(uint32_t index,

1978

MyBitmap *bitmap)

3152

1979

{

3153

1980

KEY_PART_INFO *key_part= key_info[index].key_part;

3154

1981

KEY_PART_INFO *key_part_end= (key_part +

3155

1982

key_info[index].key_parts);

3156

1983

for (;key_part != key_part_end; key_part++)

3157

bitmap_set_bit(bitmap, key_part->fieldnr-1);

1984

bitmap->setBit(key_part->fieldnr-1);

3158

1985

}

3159

1986

3160

1987

3166

1993

always set and sometimes read.

3167

1994

3168

1995

3169

void st_table::mark_auto_increment_column()

1996

void Table::mark_auto_increment_column()

3170

1997

{

3171

1998

assert(found_next_number_field);

3172

1999

3173

2000

We must set bit in read set as update_auto_increment() is using the

3174

2001

store() to check overflow of auto_increment values

3175

2002

3176

bitmap_set_bit(read_set, found_next_number_field->field_index);

3177

bitmap_set_bit(write_set, found_next_number_field->field_index);

2003

setReadSet(found_next_number_field->field_index);

2004

setWriteSet(found_next_number_field->field_index);

3178

2005

if (s->next_number_keypart)

3179

mark_columns_used_by_index_no_reset(s->next_number_index, read_set);

3180

file->column_bitmaps_signal();

2006

mark_columns_used_by_index_no_reset(s->next_number_index);

3181

2007

}

3182

2008

3183

2009

3199

2025

retrieve the row again.

3200

2026

3201

2027

3202

void st_table::mark_columns_needed_for_delete()

2028

void Table::mark_columns_needed_for_delete()

3203

2029

{

2030

2031

If the Cursor has no cursor capabilites, or we have row-based

2032

replication active for the current statement, we have to read

2033

either the primary key, the hidden primary key or all columns to

2034

be able to do an delete

2035

2036

2037

if (s->primary_key == MAX_KEY)

2038

{

2039

/* fallback to use all columns in the table to identify row */

2040

use_all_columns();

2041

return;

2042

}

2043

else

2044

mark_columns_used_by_index_no_reset(s->primary_key);

2045

2046

/* If we the engine wants all predicates we mark all keys */

3204

2047

if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)

3205

2048

{

3206

2049

Field **reg_field;

3207

2050

for (reg_field= field ; *reg_field ; reg_field++)

3208

2051

{

3209

2052

if ((*reg_field)->flags & PART_KEY_FLAG)

3210

bitmap_set_bit(read_set, (*reg_field)->field_index);

3211

}

3212

file->column_bitmaps_signal();

3213

}

3214

if (file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE ||

3215

(mysql_bin_log.is_open() && in_use && in_use->current_stmt_binlog_row_based))

3216

{

3217

3218

If the handler has no cursor capabilites, or we have row-based

3219

replication active for the current statement, we have to read

3220

either the primary key, the hidden primary key or all columns to

3221

be able to do an delete

3222

3223

if (s->primary_key == MAX_KEY)

3224

file->use_hidden_primary_key();

3225

else

3226

{

3227

mark_columns_used_by_index_no_reset(s->primary_key, read_set);

3228

file->column_bitmaps_signal();

2053

setReadSet((*reg_field)->field_index);

3229

2054

}

3230

2055

}

3231

2056

}

3249

2074

retrieve the row again.

3250

2075

3251

2076

3252

void st_table::mark_columns_needed_for_update()

2077

void Table::mark_columns_needed_for_update()

3253

2078

{

2079

2080

If the Cursor has no cursor capabilites, or we have row-based

2081

logging active for the current statement, we have to read either

2082

the primary key, the hidden primary key or all columns to be

2083

able to do an update

2084

2085

if (s->primary_key == MAX_KEY)

2086

{

2087

/* fallback to use all columns in the table to identify row */

2088

use_all_columns();

2089

return;

2090

}

2091

else

2092

mark_columns_used_by_index_no_reset(s->primary_key);

2093

3254

2094

if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)

3255

2095

{

3256

2096

/* Mark all used key columns for read */

3258

2098

for (reg_field= field ; *reg_field ; reg_field++)

3259

2099

{

3260

2100

/* Merge keys is all keys that had a column refered to in the query */

3261

if (merge_keys.is_overlapping((*reg_field)->part_of_key))

3262

bitmap_set_bit(read_set, (*reg_field)->field_index);

3263

}

3264

file->column_bitmaps_signal();

3265

}

3266

if ((file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) ||

3267

(mysql_bin_log.is_open() && in_use && in_use->current_stmt_binlog_row_based))

3268

{

3269

3270

If the handler has no cursor capabilites, or we have row-based

3271

logging active for the current statement, we have to read either

3272

the primary key, the hidden primary key or all columns to be

3273

able to do an update

3274

3275

if (s->primary_key == MAX_KEY)

3276

file->use_hidden_primary_key();

3277

else

3278

{

3279

mark_columns_used_by_index_no_reset(s->primary_key, read_set);

3280

file->column_bitmaps_signal();

3281

}

3282

}

3283

return;

2101

if (is_overlapping(merge_keys, (*reg_field)->part_of_key))

2102

setReadSet((*reg_field)->field_index);

2103

}

2104

}

2105

3284

2106

}

3285

2107

3286

2108

3287

2109

3288

Mark columns the handler needs for doing an insert

2110

Mark columns the Cursor needs for doing an insert

3289

2111

3290

2112

For now, this is used to mark fields used by the trigger

3291

2113

as changed.

3292

2114

3293

2115

3294

void st_table::mark_columns_needed_for_insert()

2116

void Table::mark_columns_needed_for_insert()

3295

2117

{

3296

2118

if (found_next_number_field)

3297

2119

mark_auto_increment_column();

3298

2120

}

3299

2121

3300

3301

Cleanup this table for re-execution.

3302

3303

SYNOPSIS

3304

TABLE_LIST::reinit_before_use()

3305

3306

3307

void TABLE_LIST::reinit_before_use(THD *thd)

3308

{

3309

3310

Reset old pointers to TABLEs: they are not valid since the tables

3311

were closed in the end of previous prepare or execute call.

3312

3313

table= 0;

3314

/* Reset is_schema_table_processed value(needed for I_S tables */

3315

schema_table_state= NOT_PROCESSED;

3316

3317

TABLE_LIST *embedded; /* The table at the current level of nesting. */

3318

TABLE_LIST *parent_embedding= this; /* The parent nested table reference. */

3319

3320

{

3321

embedded= parent_embedding;

3322

if (embedded->prep_on_expr)

3323

embedded->on_expr= embedded->prep_on_expr->copy_andor_structure(thd);

3324

parent_embedding= embedded->embedding;

3325

}

3326

while (parent_embedding &&

3327

parent_embedding->nested_join->join_list.head() == embedded);

3328

}

3329

3330

3331

Return subselect that contains the FROM list this table is taken from

3332

3333

SYNOPSIS

3334

TABLE_LIST::containing_subselect()

3335

3336

RETURN

3337

Subselect item for the subquery that contains the FROM list

3338

this table is taken from if there is any

3339

0 - otherwise

3340

3341

3342

3343

Item_subselect *TABLE_LIST::containing_subselect()

3344

{

3345

return (select_lex ? select_lex->master_unit()->item : 0);

3346

}

3347

3348

3349

Compiles the tagged hints list and fills up the bitmasks.

3350

3351

SYNOPSIS

3352

process_index_hints()

3353

table the TABLE to operate on.

3354

3355

DESCRIPTION

3356

The parser collects the index hints for each table in a "tagged list"

3357

(TABLE_LIST::index_hints). Using the information in this tagged list

3358

this function sets the members st_table::keys_in_use_for_query,

3359

st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,

3360

st_table::force_index and st_table::covering_keys.

3361

3362

Current implementation of the runtime does not allow mixing FORCE INDEX

3363

and USE INDEX, so this is checked here. Then the FORCE INDEX list

3364

(if non-empty) is appended to the USE INDEX list and a flag is set.

3365

3366

Multiple hints of the same kind are processed so that each clause

3367

is applied to what is computed in the previous clause.

3368

For example:

3369

USE INDEX (i1) USE INDEX (i2)

3370

is equivalent to

3371

USE INDEX (i1,i2)

3372

and means "consider only i1 and i2".

3373

3374

Similarly

3375

USE INDEX () USE INDEX (i1)

3376

is equivalent to

3377

USE INDEX (i1)

3378

and means "consider only the index i1"

3379

3380

It is OK to have the same index several times, e.g. "USE INDEX (i1,i1)" is

3381

not an error.

3382

3383

Different kind of hints (USE/FORCE/IGNORE) are processed in the following

3384

order:

3385

1. All indexes in USE (or FORCE) INDEX are added to the mask.

3386

2. All IGNORE INDEX

3387

3388

e.g. "USE INDEX i1, IGNORE INDEX i1, USE INDEX i1" will not use i1 at all

3389

as if we had "USE INDEX i1, USE INDEX i1, IGNORE INDEX i1".

3390

3391

As an optimization if there is a covering index, and we have

3392

IGNORE INDEX FOR GROUP/ORDER, and this index is used for the JOIN part,

3393

then we have to ignore the IGNORE INDEX FROM GROUP/ORDER.

3394

3395

RETURN VALUE

3396

false no errors found

3397

TRUE found and reported an error.

3398

3399

bool TABLE_LIST::process_index_hints(TABLE *tbl)

3400

{

3401

/* initialize the result variables */

3402

tbl->keys_in_use_for_query= tbl->keys_in_use_for_group_by=

3403

tbl->keys_in_use_for_order_by= tbl->s->keys_in_use;

3404

3405

/* index hint list processing */

3406

if (index_hints)

3407

{

3408

key_map index_join[INDEX_HINT_FORCE + 1];

3409

key_map index_order[INDEX_HINT_FORCE + 1];

3410

key_map index_group[INDEX_HINT_FORCE + 1];

3411

Index_hint *hint;

3412

int type;

3413

bool have_empty_use_join= false, have_empty_use_order= false,

3414

have_empty_use_group= false;

3415

List_iterator <Index_hint> iter(*index_hints);

3416

3417

/* initialize temporary variables used to collect hints of each kind */

3418

for (type= INDEX_HINT_IGNORE; type <= INDEX_HINT_FORCE; type++)

3419

{

3420

index_join[type].clear_all();

3421

index_order[type].clear_all();

3422

index_group[type].clear_all();

3423

}

3424

3425

/* iterate over the hints list */

3426

while ((hint= iter++))

3427

{

3428

uint pos;

3429

3430

/* process empty USE INDEX () */

3431

if (hint->type == INDEX_HINT_USE && !hint->key_name.str)

3432

{

3433

if (hint->clause & INDEX_HINT_MASK_JOIN)

3434

{

3435

index_join[hint->type].clear_all();

3436

have_empty_use_join= true;

3437

}

3438

if (hint->clause & INDEX_HINT_MASK_ORDER)

3439

{

3440

index_order[hint->type].clear_all();

3441

have_empty_use_order= true;

3442

}

3443

if (hint->clause & INDEX_HINT_MASK_GROUP)

3444

{

3445

index_group[hint->type].clear_all();

3446

have_empty_use_group= true;

3447

}

3448

continue;

3449

}

3450

3451

3452

Check if an index with the given name exists and get his offset in

3453

the keys bitmask for the table

3454

3455

if (tbl->s->keynames.type_names == 0 ||

3456

(pos= find_type(&tbl->s->keynames, hint->key_name.str,

3457

hint->key_name.length, 1)) <= 0)

3458

{

3459

my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), hint->key_name.str, alias);

3460

return 1;

3461

}

3462

3463

pos--;

3464

3465

/* add to the appropriate clause mask */

3466

if (hint->clause & INDEX_HINT_MASK_JOIN)

3467

index_join[hint->type].set_bit (pos);

3468

if (hint->clause & INDEX_HINT_MASK_ORDER)

3469

index_order[hint->type].set_bit (pos);

3470

if (hint->clause & INDEX_HINT_MASK_GROUP)

3471

index_group[hint->type].set_bit (pos);

3472

}

3473

3474

/* cannot mix USE INDEX and FORCE INDEX */

3475

if ((!index_join[INDEX_HINT_FORCE].is_clear_all() ||

3476

!index_order[INDEX_HINT_FORCE].is_clear_all() ||

3477

!index_group[INDEX_HINT_FORCE].is_clear_all()) &&

3478

(!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join ||

3479

!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order ||

3480

!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group))

3481

{

3482

my_error(ER_WRONG_USAGE, MYF(0), index_hint_type_name[INDEX_HINT_USE],

3483

index_hint_type_name[INDEX_HINT_FORCE]);

3484

return 1;

3485

}

3486

3487

/* process FORCE INDEX as USE INDEX with a flag */

3488

if (!index_join[INDEX_HINT_FORCE].is_clear_all() ||

3489

!index_order[INDEX_HINT_FORCE].is_clear_all() ||

3490

!index_group[INDEX_HINT_FORCE].is_clear_all())

3491

{

3492

tbl->force_index= true;

3493

index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);

3494

index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);

3495

index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);

3496

}

3497

3498

/* apply USE INDEX */

3499

if (!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join)

3500

tbl->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);

3501

if (!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order)

3502

tbl->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);

3503

if (!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group)

3504

tbl->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);

3505

3506

/* apply IGNORE INDEX */

3507

tbl->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);

3508

tbl->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);

3509

tbl->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);

3510

}

3511

3512

/* make sure covering_keys don't include indexes disabled with a hint */

3513

tbl->covering_keys.intersect(tbl->keys_in_use_for_query);

3514

return 0;

3515

}

3516

3517

3518

size_t max_row_length(TABLE *table, const uchar *data)

3519

{

3520

TABLE_SHARE *table_s= table->s;

3521

size_t length= table_s->reclength + 2 * table_s->fields;

3522

uint *const beg= table_s->blob_field;

3523

uint *const end= beg + table_s->blob_fields;

3524

3525

for (uint *ptr= beg ; ptr != end ; ++ptr)

3526

{

3527

Field_blob* const blob= (Field_blob*) table->field[*ptr];

3528

length+= blob->get_length((const uchar*)

3529

(data + blob->offset(table->record[0]))) +

2122

2123

2124

size_t Table::max_row_length(const unsigned char *data)

2125

{

2126

size_t length= getRecordLength() + 2 * sizeFields();

2127

uint32_t *const beg= getBlobField();

2128

uint32_t *const end= beg + sizeBlobFields();

2129

2130

for (uint32_t *ptr= beg ; ptr != end ; ++ptr)

2131

{

2132

Field_blob* const blob= (Field_blob*) field[*ptr];

2133

length+= blob->get_length((const unsigned char*)

2134

(data + blob->offset(record[0]))) +

3530

2135

HA_KEY_BLOB_LENGTH;

3531

2136

}

3532

2137

return length;

3533

2138

}

3534

2139

2140

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

2141

Functions for creating temporary tables.

2142

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

2143

2144

2145

/* Prototypes */

2146

void free_tmp_table(Session *session, Table *entry);

2147

2148

/**

2149

Create field for temporary table from given field.

2150

2151

@param session Thread Cursor

2152

@param org_field field from which new field will be created

2153

@param name New field name

2154

@param table Temporary table

2155

@param item !=NULL if item->result_field should point to new field.

2156

This is relevant for how fill_record() is going to work:

2157

If item != NULL then fill_record() will update

2158

the record in the original table.

2159

If item == NULL then fill_record() will update

2160

the temporary table

2161

@param convert_blob_length If >0 create a varstring(convert_blob_length)

2162

field instead of blob.

2163

2164

@retval

2165

NULL on error

2166

@retval

2167

new_created field

2168

2169

2170

Field *create_tmp_field_from_field(Session *session, Field *org_field,

2171

const char *name, Table *table,

2172

Item_field *item, uint32_t convert_blob_length)

2173

{

2174

Field *new_field;

2175

2176

2177

Make sure that the blob fits into a Field_varstring which has

2178

2-byte lenght.

2179

2180

if (convert_blob_length && convert_blob_length <= Field_varstring::MAX_SIZE &&

2181

(org_field->flags & BLOB_FLAG))

2182

new_field= new Field_varstring(convert_blob_length,

2183

org_field->maybe_null(),

2184

org_field->field_name, table->s,

2185

org_field->charset());

2186

else

2187

new_field= org_field->new_field(session->mem_root, table,

2188

table == org_field->table);

2189

if (new_field)

2190

{

2191

new_field->init(table);

2192

new_field->orig_table= org_field->orig_table;

2193

if (item)

2194

item->result_field= new_field;

2195

else

2196

new_field->field_name= name;

2197

new_field->flags|= (org_field->flags & NO_DEFAULT_VALUE_FLAG);

2198

if (org_field->maybe_null() || (item && item->maybe_null))

2199

new_field->flags&= ~NOT_NULL_FLAG; // Because of outer join

2200

if (org_field->type() == DRIZZLE_TYPE_VARCHAR)

2201

table->s->db_create_options|= HA_OPTION_PACK_RECORD;

2202

else if (org_field->type() == DRIZZLE_TYPE_DOUBLE)

2203

((Field_double *) new_field)->not_fixed= true;

2204

}

2205

return new_field;

2206

}

2207

2208

2209

/**

2210

Create field for information schema table.

2211

2212

@param session Thread Cursor

2213

@param table Temporary table

2214

@param item Item to create a field for

2215

2216

@retval

2217

0 on error

2218

@retval

2219

new_created field

2220

2221

2222

static Field *create_tmp_field_for_schema(Item *item, Table *table)

2223

{

2224

if (item->field_type() == DRIZZLE_TYPE_VARCHAR)

2225

{

2226

Field *field;

2227

if (item->max_length > MAX_FIELD_VARCHARLENGTH)

2228

field= new Field_blob(item->max_length, item->maybe_null,

2229

item->name, item->collation.collation);

2230

else

2231

field= new Field_varstring(item->max_length, item->maybe_null,

2232

item->name,

2233

table->s, item->collation.collation);

2234

if (field)

2235

field->init(table);

2236

return field;

2237

}

2238

return item->tmp_table_field_from_field_type(table, 0);

2239

}

2240

2241

2242

/**

2243

Create a temp table according to a field list.

2244

2245

Given field pointers are changed to point at tmp_table for

2246

send_fields. The table object is self contained: it's

2247

allocated in its own memory root, as well as Field objects

2248

created for table columns.

2249

This function will replace Item_sum items in 'fields' list with

2250

corresponding Item_field items, pointing at the fields in the

2251

temporary table, unless this was prohibited by true

2252

value of argument save_sum_fields. The Item_field objects

2253

are created in Session memory root.

2254

2255

@param session thread handle

2256

@param param a description used as input to create the table

2257

@param fields list of items that will be used to define

2258

column types of the table (also see NOTES)

2259

@param group TODO document

2260

@param distinct should table rows be distinct

2261

@param save_sum_fields see NOTES

2262

@param select_options

2263

@param rows_limit

2264

@param table_alias possible name of the temporary table that can

2265

be used for name resolving; can be "".

2266

2267

2268

#define STRING_TOTAL_LENGTH_TO_PACK_ROWS 128

2269

#define AVG_STRING_LENGTH_TO_PACK_ROWS 64

2270

#define RATIO_TO_PACK_ROWS 2

2271

2272

Table *

2273

create_tmp_table(Session *session,Tmp_Table_Param *param,List<Item> &fields,

2274

order_st *group, bool distinct, bool save_sum_fields,

2275

uint64_t select_options, ha_rows rows_limit,

2276

const char *table_alias)

2277

{

2278

MEM_ROOT *mem_root_save, own_root;

2279

Table *table;

2280

TableShare *share;

2281

uint i,field_count,null_count,null_pack_length;

2282

uint32_t copy_func_count= param->func_count;

2283

uint32_t hidden_null_count, hidden_null_pack_length, hidden_field_count;

2284

uint32_t blob_count,group_null_items, string_count;

2285

uint32_t fieldnr= 0;

2286

ulong reclength, string_total_length;

2287

bool using_unique_constraint= 0;

2288

bool use_packed_rows= 0;

2289

bool not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);

2290

char *tmpname,path[FN_REFLEN];

2291

unsigned char *pos, *group_buff, *bitmaps;

2292

unsigned char *null_flags;

2293

Field **reg_field, **from_field, **default_field;

2294

uint32_t *blob_field;

2295

CopyField *copy= 0;

2296

KEY *keyinfo;

2297

KEY_PART_INFO *key_part_info;

2298

Item **copy_func;

2299

MI_COLUMNDEF *recinfo;

2300

uint32_t total_uneven_bit_length= 0;

2301

bool force_copy_fields= param->force_copy_fields;

2302

uint64_t max_rows= 0;

2303

2304

status_var_increment(session->status_var.created_tmp_tables);

2305

2306

/* if we run out of slots or we are not using tempool */

2307

sprintf(path,"%s%lx_%"PRIx64"_%x", TMP_FILE_PREFIX, (unsigned long)current_pid,

2308

session->thread_id, session->tmp_table++);

2309

2310

2311

No need to change table name to lower case as we are only creating

2312

MyISAM or HEAP tables here

2313

2314

fn_format(path, path, drizzle_tmpdir, "", MY_REPLACE_EXT|MY_UNPACK_FILENAME);

2315

2316

2317

if (group)

2318

{

2319

if (!param->quick_group)

2320

group= 0; // Can't use group key

2321

else for (order_st *tmp=group ; tmp ; tmp=tmp->next)

2322

{

2323

2324

marker == 4 means two things:

2325

- store NULLs in the key, and

2326

- convert BIT fields to 64-bit long, needed because MEMORY tables

2327

can't index BIT fields.

2328

2329

(*tmp->item)->marker= 4;

2330

if ((*tmp->item)->max_length >= CONVERT_IF_BIGGER_TO_BLOB)

2331

using_unique_constraint=1;

2332

}

2333

if (param->group_length >= MAX_BLOB_WIDTH)

2334

using_unique_constraint=1;

2335

if (group)

2336

distinct= 0; // Can't use distinct

2337

}

2338

2339

field_count=param->field_count+param->func_count+param->sum_func_count;

2340

hidden_field_count=param->hidden_field_count;

2341

2342

2343

When loose index scan is employed as access method, it already

2344

computes all groups and the result of all aggregate functions. We

2345

make space for the items of the aggregate function in the list of

2346

functions Tmp_Table_Param::items_to_copy, so that the values of

2347

these items are stored in the temporary table.

2348

2349

if (param->precomputed_group_by)

2350

copy_func_count+= param->sum_func_count;

2351

2352

init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0);

2353

2354

if (!multi_alloc_root(&own_root,

2355

&table, sizeof(*table),

2356

&share, sizeof(*share),

2357

&reg_field, sizeof(Field*) * (field_count+1),

2358

&default_field, sizeof(Field*) * (field_count),

2359

&blob_field, sizeof(uint32_t)*(field_count+1),

2360

&from_field, sizeof(Field*)*field_count,

2361

&copy_func, sizeof(*copy_func)*(copy_func_count+1),

2362

&param->keyinfo, sizeof(*param->keyinfo),

2363

&key_part_info,

2364

sizeof(*key_part_info)*(param->group_parts+1),

2365

&param->start_recinfo,

2366

sizeof(*param->recinfo)*(field_count*2+4),

2367

&tmpname, (uint32_t) strlen(path)+1,

2368

&group_buff, (group && ! using_unique_constraint ?

2369

param->group_length : 0),

2370

&bitmaps, bitmap_buffer_size(field_count)*2,

2371

NULL))

2372

{

2373

return NULL;

2374

}

2375

/* CopyField belongs to Tmp_Table_Param, allocate it in Session mem_root */

2376

if (!(param->copy_field= copy= new (session->mem_root) CopyField[field_count]))

2377

{

2378

free_root(&own_root, MYF(0));

2379

return NULL;

2380

}

2381

param->items_to_copy= copy_func;

2382

strcpy(tmpname,path);

2383

/* make table according to fields */

2384

2385

memset(table, 0, sizeof(*table));

2386

memset(reg_field, 0, sizeof(Field*)*(field_count+1));

2387

memset(default_field, 0, sizeof(Field*) * (field_count));

2388

memset(from_field, 0, sizeof(Field*)*field_count);

2389

2390

table->mem_root= own_root;

2391

mem_root_save= session->mem_root;

2392

session->mem_root= &table->mem_root;

2393

2394

table->field=reg_field;

2395

table->alias= table_alias;

2396

table->reginfo.lock_type=TL_WRITE; /* Will be updated */

2397

table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;

2398

table->map=1;

2399

table->copy_blobs= 1;

2400

table->in_use= session;

2401

table->quick_keys.reset();

2402

table->covering_keys.reset();

2403

table->keys_in_use_for_query.reset();

2404

2405

table->setShare(share);

2406

share->init(tmpname, tmpname);

2407

share->blob_field= blob_field;

2408

share->blob_ptr_size= portable_sizeof_char_ptr;

2409

share->db_low_byte_first=1; // True for HEAP and MyISAM

2410

share->table_charset= param->table_charset;

2411

share->primary_key= MAX_KEY; // Indicate no primary key

2412

share->keys_for_keyread.reset();

2413

share->keys_in_use.reset();

2414

2415

/* Calculate which type of fields we will store in the temporary table */

2416

2417

reclength= string_total_length= 0;

2418

blob_count= string_count= null_count= hidden_null_count= group_null_items= 0;

2419

param->using_indirect_summary_function= 0;

2420

2421

List_iterator_fast<Item> li(fields);

2422

Item *item;

2423

Field **tmp_from_field=from_field;

2424

while ((item=li++))

2425

{

2426

Item::Type type=item->type();

2427

if (not_all_columns)

2428

{

2429

if (item->with_sum_func && type != Item::SUM_FUNC_ITEM)

2430

{

2431

if (item->used_tables() & OUTER_REF_TABLE_BIT)

2432

item->update_used_tables();

2433

if (type == Item::SUBSELECT_ITEM ||

2434

(item->used_tables() & ~OUTER_REF_TABLE_BIT))

2435

{

2436

2437

Mark that the we have ignored an item that refers to a summary

2438

function. We need to know this if someone is going to use

2439

DISTINCT on the result.

2440

2441

param->using_indirect_summary_function=1;

2442

continue;

2443

}

2444

}

2445

if (item->const_item() && (int) hidden_field_count <= 0)

2446

continue; // We don't have to store this

2447

}

2448

if (type == Item::SUM_FUNC_ITEM && !group && !save_sum_fields)

2449

{ /* Can't calc group yet */

2450

((Item_sum*) item)->result_field= 0;

2451

for (i= 0 ; i < ((Item_sum*) item)->arg_count ; i++)

2452

{

2453

Item **argp= ((Item_sum*) item)->args + i;

2454

Item *arg= *argp;

2455

if (!arg->const_item())

2456

{

2457

Field *new_field=

2458

create_tmp_field(session, table, arg, arg->type(), &copy_func,

2459

tmp_from_field, &default_field[fieldnr],

2460

group != 0,not_all_columns,

2461

distinct, 0,

2462

param->convert_blob_length);

2463

if (!new_field)

2464

goto err; // Should be OOM

2465

tmp_from_field++;

2466

reclength+=new_field->pack_length();

2467

if (new_field->flags & BLOB_FLAG)

2468

{

2469

*blob_field++= fieldnr;

2470

blob_count++;

2471

}

2472

*(reg_field++)= new_field;

2473

if (new_field->real_type() == DRIZZLE_TYPE_VARCHAR)

2474

{

2475

string_count++;

2476

string_total_length+= new_field->pack_length();

2477

}

2478

session->mem_root= mem_root_save;

2479

session->change_item_tree(argp, new Item_field(new_field));

2480

session->mem_root= &table->mem_root;

2481

if (!(new_field->flags & NOT_NULL_FLAG))

2482

{

2483

null_count++;

2484

2485

new_field->maybe_null() is still false, it will be

2486

changed below. But we have to setup Item_field correctly

2487

2488

(*argp)->maybe_null=1;

2489

}

2490

new_field->field_index= fieldnr++;

2491

}

2492

}

2493

}

2494

else

2495

{

2496

2497

The last parameter to create_tmp_field() is a bit tricky:

2498

2499

We need to set it to 0 in union, to get fill_record() to modify the

2500

temporary table.

2501

We need to set it to 1 on multi-table-update and in select to

2502

write rows to the temporary table.

2503

We here distinguish between UNION and multi-table-updates by the fact

2504

that in the later case group is set to the row pointer.

2505

2506

Field *new_field= (param->schema_table) ?

2507

create_tmp_field_for_schema(item, table) :

2508

create_tmp_field(session, table, item, type, &copy_func,

2509

tmp_from_field, &default_field[fieldnr],

2510

group != 0,

2511

!force_copy_fields &&

2512

(not_all_columns || group != 0),

2513

2514

If item->marker == 4 then we force create_tmp_field

2515

to create a 64-bit longs for BIT fields because HEAP

2516

tables can't index BIT fields directly. We do the same

2517

for distinct, as we want the distinct index to be

2518

usable in this case too.

2519

2520

item->marker == 4 || param->bit_fields_as_long,

2521

force_copy_fields,

2522

param->convert_blob_length);

2523

2524

if (!new_field)

2525

{

2526

if (session->is_fatal_error)

2527

goto err; // Got OOM

2528

continue; // Some kindf of const item

2529

}

2530

if (type == Item::SUM_FUNC_ITEM)

2531

((Item_sum *) item)->result_field= new_field;

2532

tmp_from_field++;

2533

reclength+=new_field->pack_length();

2534

if (!(new_field->flags & NOT_NULL_FLAG))

2535

null_count++;

2536

if (new_field->flags & BLOB_FLAG)

2537

{

2538

*blob_field++= fieldnr;

2539

blob_count++;

2540

}

2541

if (item->marker == 4 && item->maybe_null)

2542

{

2543

group_null_items++;

2544

new_field->flags|= GROUP_FLAG;

2545

}

2546

new_field->field_index= fieldnr++;

2547

*(reg_field++)= new_field;

2548

}

2549

if (!--hidden_field_count)

2550

{

2551

2552

This was the last hidden field; Remember how many hidden fields could

2553

have null

2554

2555

hidden_null_count=null_count;

2556

2557

We need to update hidden_field_count as we may have stored group

2558

functions with constant arguments

2559

2560

param->hidden_field_count= fieldnr;

2561

null_count= 0;

2562

}

2563

}

2564

assert(fieldnr == (uint32_t) (reg_field - table->field));

2565

assert(field_count >= (uint32_t) (reg_field - table->field));

2566

field_count= fieldnr;

2567

*reg_field= 0;

2568

*blob_field= 0; // End marker

2569

share->fields= field_count;

2570

2571

/* If result table is small; use a heap */

2572

/* future: storage engine selection can be made dynamic? */

2573

if (blob_count || using_unique_constraint ||

2574

(select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==

2575

OPTION_BIG_TABLES || (select_options & TMP_TABLE_FORCE_MYISAM))

2576

{

2577

share->storage_engine= myisam_engine;

2578

table->file= share->db_type()->getCursor(share, &table->mem_root);

2579

if (group &&

2580

(param->group_parts > table->file->max_key_parts() ||

2581

param->group_length > table->file->max_key_length()))

2582

using_unique_constraint=1;

2583

}

2584

else

2585

{

2586

share->storage_engine= heap_engine;

2587

table->file= share->db_type()->getCursor(share, &table->mem_root);

2588

}

2589

if (!table->file)

2590

goto err;

2591

2592

2593

if (!using_unique_constraint)

2594

reclength+= group_null_items; // null flag is stored separately

2595

2596

share->blob_fields= blob_count;

2597

if (blob_count == 0)

2598

{

2599

/* We need to ensure that first byte is not 0 for the delete link */

2600

if (param->hidden_field_count)

2601

hidden_null_count++;

2602

else

2603

null_count++;

2604

}

2605

hidden_null_pack_length=(hidden_null_count+7)/8;

2606

null_pack_length= (hidden_null_pack_length +

2607

(null_count + total_uneven_bit_length + 7) / 8);

2608

reclength+=null_pack_length;

2609

if (!reclength)

2610

reclength=1; // Dummy select

2611

/* Use packed rows if there is blobs or a lot of space to gain */

2612

if (blob_count || ((string_total_length >= STRING_TOTAL_LENGTH_TO_PACK_ROWS) && (reclength / string_total_length <= RATIO_TO_PACK_ROWS || (string_total_length / string_count) >= AVG_STRING_LENGTH_TO_PACK_ROWS)))

2613

use_packed_rows= 1;

2614

2615

share->reclength= reclength;

2616

{

2617

uint32_t alloc_length=ALIGN_SIZE(reclength+MI_UNIQUE_HASH_LENGTH+1);

2618

share->rec_buff_length= alloc_length;

2619

if (!(table->record[0]= (unsigned char*)

2620

alloc_root(&table->mem_root, alloc_length*3)))

2621

goto err;

2622

table->record[1]= table->record[0]+alloc_length;

2623

share->default_values= table->record[1]+alloc_length;

2624

}

2625

copy_func[0]= 0; // End marker

2626

param->func_count= copy_func - param->items_to_copy;

2627

2628

table->setup_tmp_table_column_bitmaps(bitmaps);

2629

2630

recinfo=param->start_recinfo;

2631

null_flags=(unsigned char*) table->record[0];

2632

pos=table->record[0]+ null_pack_length;

2633

if (null_pack_length)

2634

{

2635

memset(recinfo, 0, sizeof(*recinfo));

2636

recinfo->type=FIELD_NORMAL;

2637

recinfo->length=null_pack_length;

2638

recinfo++;

2639

memset(null_flags, 255, null_pack_length); // Set null fields

2640

2641

table->null_flags= (unsigned char*) table->record[0];

2642

share->null_fields= null_count+ hidden_null_count;

2643

share->null_bytes= null_pack_length;

2644

}

2645

null_count= (blob_count == 0) ? 1 : 0;

2646

hidden_field_count=param->hidden_field_count;

2647

for (i= 0,reg_field=table->field; i < field_count; i++,reg_field++,recinfo++)

2648

{

2649

Field *field= *reg_field;

2650

uint32_t length;

2651

memset(recinfo, 0, sizeof(*recinfo));

2652

2653

if (!(field->flags & NOT_NULL_FLAG))

2654

{

2655

if (field->flags & GROUP_FLAG && !using_unique_constraint)

2656

{

2657

2658

We have to reserve one byte here for NULL bits,

2659

as this is updated by 'end_update()'

2660

2661

*pos++= '\0'; // Null is stored here

2662

recinfo->length= 1;

2663

recinfo->type=FIELD_NORMAL;

2664

recinfo++;

2665

memset(recinfo, 0, sizeof(*recinfo));

2666

}

2667

else

2668

{

2669

recinfo->null_bit= 1 << (null_count & 7);

2670

recinfo->null_pos= null_count/8;

2671

}

2672

field->move_field(pos,null_flags+null_count/8,

2673

1 << (null_count & 7));

2674

null_count++;

2675

}

2676

else

2677

field->move_field(pos,(unsigned char*) 0,0);

2678

field->reset();

2679

2680

2681

Test if there is a default field value. The test for ->ptr is to skip

2682

'offset' fields generated by initalize_tables

2683

2684

if (default_field[i] && default_field[i]->ptr)

2685

{

2686

2687

default_field[i] is set only in the cases when 'field' can

2688

inherit the default value that is defined for the field referred

2689

by the Item_field object from which 'field' has been created.

2690

2691

ptrdiff_t diff;

2692

Field *orig_field= default_field[i];

2693

/* Get the value from default_values */

2694

diff= (ptrdiff_t) (orig_field->table->s->default_values-

2695

orig_field->table->record[0]);

2696

orig_field->move_field_offset(diff); // Points now at default_values

2697

if (orig_field->is_real_null())

2698

field->set_null();

2699

else

2700

{

2701

field->set_notnull();

2702

memcpy(field->ptr, orig_field->ptr, field->pack_length());

2703

}

2704

orig_field->move_field_offset(-diff); // Back to record[0]

2705

}

2706

2707

if (from_field[i])

2708

{ /* Not a table Item */

2709

copy->set(field,from_field[i],save_sum_fields);

2710

copy++;

2711

}

2712

length=field->pack_length();

2713

pos+= length;

2714

2715

/* Make entry for create table */

2716

recinfo->length=length;

2717

if (field->flags & BLOB_FLAG)

2718

recinfo->type= (int) FIELD_BLOB;

2719

else

2720

recinfo->type=FIELD_NORMAL;

2721

if (!--hidden_field_count)

2722

null_count=(null_count+7) & ~7; // move to next byte

2723

2724

// fix table name in field entry

2725

field->table_name= &table->alias;

2726

}

2727

2728

param->copy_field_end=copy;

2729

param->recinfo=recinfo;

2730

table->storeRecordAsDefault(); // Make empty default record

2731

2732

if (session->variables.tmp_table_size == ~ (uint64_t) 0) // No limit

2733

max_rows= ~(uint64_t) 0;

2734

else

2735

max_rows= (uint64_t) (((share->db_type() == heap_engine) ?

2736

min(session->variables.tmp_table_size,

2737

session->variables.max_heap_table_size) :

2738

session->variables.tmp_table_size) /

2739

share->reclength);

2740

2741

set_if_bigger(max_rows, (uint64_t)1); // For dummy start options

2742

2743

Push the LIMIT clause to the temporary table creation, so that we

2744

materialize only up to 'rows_limit' records instead of all result records.

2745

2746

set_if_smaller(max_rows, rows_limit);

2747

2748

share->setMaxRows(max_rows);

2749

2750

param->end_write_records= rows_limit;

2751

2752

keyinfo= param->keyinfo;

2753

2754

if (group)

2755

{

2756

table->group=group; /* Table is grouped by key */

2757

param->group_buff=group_buff;

2758

share->keys=1;

2759

share->uniques= test(using_unique_constraint);

2760

table->key_info=keyinfo;

2761

keyinfo->key_part=key_part_info;

2762

keyinfo->flags=HA_NOSAME;

2763

keyinfo->usable_key_parts=keyinfo->key_parts= param->group_parts;

2764

keyinfo->key_length= 0;

2765

keyinfo->rec_per_key= 0;

2766

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

2767

keyinfo->name= (char*) "group_key";

2768

order_st *cur_group= group;

2769

for (; cur_group ; cur_group= cur_group->next, key_part_info++)

2770

{

2771

Field *field=(*cur_group->item)->get_tmp_table_field();

2772

bool maybe_null=(*cur_group->item)->maybe_null;

2773

key_part_info->null_bit= 0;

2774

key_part_info->field= field;

2775

key_part_info->offset= field->offset(table->record[0]);

2776

key_part_info->length= (uint16_t) field->key_length();

2777

key_part_info->type= (uint8_t) field->key_type();

2778

key_part_info->key_type=

2779

((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||

2780

(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||

2781

(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?

2782

0 : 1;

2783

if (!using_unique_constraint)

2784

{

2785

cur_group->buff=(char*) group_buff;

2786

if (!(cur_group->field= field->new_key_field(session->mem_root,table,

2787

group_buff +

2788

test(maybe_null),

2789

field->null_ptr,

2790

field->null_bit)))

2791

goto err;

2792

if (maybe_null)

2793

{

2794

2795

To be able to group on NULL, we reserved place in group_buff

2796

for the NULL flag just before the column. (see above).

2797

The field data is after this flag.

2798

The NULL flag is updated in 'end_update()' and 'end_write()'

2799

2800

keyinfo->flags|= HA_NULL_ARE_EQUAL; // def. that NULL == NULL

2801

key_part_info->null_bit=field->null_bit;

2802

key_part_info->null_offset= (uint32_t) (field->null_ptr -

2803

(unsigned char*) table->record[0]);

2804

cur_group->buff++; // Pointer to field data

2805

group_buff++; // Skipp null flag

2806

}

2807

/* In GROUP BY 'a' and 'a ' are equal for VARCHAR fields */

2808

key_part_info->key_part_flag|= HA_END_SPACE_ARE_EQUAL;

2809

group_buff+= cur_group->field->pack_length();

2810

}

2811

keyinfo->key_length+= key_part_info->length;

2812

}

2813

}

2814

2815

if (distinct && field_count != param->hidden_field_count)

2816

{

2817

2818

Create an unique key or an unique constraint over all columns

2819

that should be in the result. In the temporary table, there are

2820

'param->hidden_field_count' extra columns, whose null bits are stored

2821

in the first 'hidden_null_pack_length' bytes of the row.

2822

2823

if (blob_count)

2824

{

2825

2826

Special mode for index creation in MyISAM used to support unique

2827

indexes on blobs with arbitrary length. Such indexes cannot be

2828

used for lookups.

2829

2830

share->uniques= 1;

2831

}

2832

null_pack_length-=hidden_null_pack_length;

2833

keyinfo->key_parts= ((field_count-param->hidden_field_count)+

2834

(share->uniques ? test(null_pack_length) : 0));

2835

table->distinct= 1;

2836

share->keys= 1;

2837

if (!(key_part_info= (KEY_PART_INFO*)

2838

alloc_root(&table->mem_root,

2839

keyinfo->key_parts * sizeof(KEY_PART_INFO))))

2840

goto err;

2841

memset(key_part_info, 0, keyinfo->key_parts * sizeof(KEY_PART_INFO));

2842

table->key_info=keyinfo;

2843

keyinfo->key_part=key_part_info;

2844

keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;

2845

keyinfo->key_length=(uint16_t) reclength;

2846

keyinfo->name= (char*) "distinct_key";

2847

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

2848

keyinfo->rec_per_key= 0;

2849

2850

2851

Create an extra field to hold NULL bits so that unique indexes on

2852

blobs can distinguish NULL from 0. This extra field is not needed

2853

when we do not use UNIQUE indexes for blobs.

2854

2855

if (null_pack_length && share->uniques)

2856

{

2857

key_part_info->null_bit= 0;

2858

key_part_info->offset=hidden_null_pack_length;

2859

key_part_info->length=null_pack_length;

2860

key_part_info->field= new Field_varstring(table->record[0],

2861

(uint32_t) key_part_info->length,

2862

2863

(unsigned char*) 0,

2864

(uint32_t) 0,

2865

NULL,

2866

table->s,

2867

&my_charset_bin);

2868

if (!key_part_info->field)

2869

goto err;

2870

key_part_info->field->init(table);

2871

key_part_info->key_type= 1; /* binary comparison */

2872

key_part_info->type= HA_KEYTYPE_BINARY;

2873

key_part_info++;

2874

}

2875

/* Create a distinct key over the columns we are going to return */

2876

for (i=param->hidden_field_count, reg_field=table->field + i ;

2877

i < field_count;

2878

i++, reg_field++, key_part_info++)

2879

{

2880

key_part_info->null_bit= 0;

2881

key_part_info->field= *reg_field;

2882

key_part_info->offset= (*reg_field)->offset(table->record[0]);

2883

key_part_info->length= (uint16_t) (*reg_field)->pack_length();

2884

/* TODO:

2885

The below method of computing the key format length of the

2886

key part is a copy/paste from opt_range.cc, and table.cc.

2887

This should be factored out, e.g. as a method of Field.

2888

In addition it is not clear if any of the Field::*_length

2889

methods is supposed to compute the same length. If so, it

2890

might be reused.

2891

2892

key_part_info->store_length= key_part_info->length;

2893

2894

if ((*reg_field)->real_maybe_null())

2895

key_part_info->store_length+= HA_KEY_NULL_LENGTH;

2896

if ((*reg_field)->type() == DRIZZLE_TYPE_BLOB ||

2897

(*reg_field)->real_type() == DRIZZLE_TYPE_VARCHAR)

2898

key_part_info->store_length+= HA_KEY_BLOB_LENGTH;

2899

2900

key_part_info->type= (uint8_t) (*reg_field)->key_type();

2901

key_part_info->key_type =

2902

((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||

2903

(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||

2904

(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?

2905

0 : 1;

2906

}

2907

}

2908

2909

if (session->is_fatal_error) // If end of memory

2910

goto err;

2911

share->db_record_offset= 1;

2912

if (share->db_type() == myisam_engine)

2913

{

2914

if (table->create_myisam_tmp_table(param->keyinfo, param->start_recinfo,

2915

&param->recinfo, select_options))

2916

goto err;

2917

}

2918

if (table->open_tmp_table())

2919

goto err;

2920

2921

session->mem_root= mem_root_save;

2922

2923

return(table);

2924

2925

err:

2926

session->mem_root= mem_root_save;

2927

table->free_tmp_table(session);

2928

return NULL;

2929

}

2930

2931

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

2932

2933

/**

2934

Create a reduced Table object with properly set up Field list from a

2935

list of field definitions.

2936

2937

The created table doesn't have a table Cursor associated with

2938

it, has no keys, no group/distinct, no copy_funcs array.

2939

The sole purpose of this Table object is to use the power of Field

2940

class to read/write data to/from table->record[0]. Then one can store

2941

the record in any container (RB tree, hash, etc).

2942

The table is created in Session mem_root, so are the table's fields.

2943

Consequently, if you don't BLOB fields, you don't need to free it.

2944

2945

@param session connection handle

2946

@param field_list list of column definitions

2947

2948

@return

2949

0 if out of memory, Table object in case of success

2950

2951

2952

Table *create_virtual_tmp_table(Session *session, List<CreateField> &field_list)

2953

{

2954

uint32_t field_count= field_list.elements;

2955

uint32_t blob_count= 0;

2956

Field **field;

2957

CreateField *cdef; /* column definition */

2958

uint32_t record_length= 0;

2959

uint32_t null_count= 0; /* number of columns which may be null */

2960

uint32_t null_pack_length; /* NULL representation array length */

2961

uint32_t *blob_field;

2962

unsigned char *bitmaps;

2963

Table *table;

2964

TableShare *share;

2965

2966

if (!multi_alloc_root(session->mem_root,

2967

&table, sizeof(*table),

2968

&share, sizeof(*share),

2969

&field, (field_count + 1) * sizeof(Field*),

2970

&blob_field, (field_count+1) *sizeof(uint32_t),

2971

&bitmaps, bitmap_buffer_size(field_count)*2,

2972

NULL))

2973

return NULL;

2974

2975

memset(table, 0, sizeof(*table));

2976

memset(share, 0, sizeof(*share));

2977

table->field= field;

2978

table->s= share;

2979

share->blob_field= blob_field;

2980

share->fields= field_count;

2981

share->blob_ptr_size= portable_sizeof_char_ptr;

2982

table->setup_tmp_table_column_bitmaps(bitmaps);

2983

2984

/* Create all fields and calculate the total length of record */

2985

List_iterator_fast<CreateField> it(field_list);

2986

while ((cdef= it++))

2987

{

2988

*field= make_field(share,

2989

NULL,

2990

2991

cdef->length,

2992

(cdef->flags & NOT_NULL_FLAG) ? false : true,

2993

(unsigned char *) ((cdef->flags & NOT_NULL_FLAG) ? 0 : ""),

2994

(cdef->flags & NOT_NULL_FLAG) ? 0 : 1,

2995

cdef->decimals,

2996

cdef->sql_type,

2997

cdef->charset,

2998

cdef->unireg_check,

2999

cdef->interval,

3000

cdef->field_name);

3001

if (!*field)

3002

goto error;

3003

(*field)->init(table);

3004

record_length+= (*field)->pack_length();

3005

if (! ((*field)->flags & NOT_NULL_FLAG))

3006

null_count++;

3007

3008

if ((*field)->flags & BLOB_FLAG)

3009

share->blob_field[blob_count++]= (uint32_t) (field - table->field);

3010

3011

field++;

3012

}

3013

*field= NULL; /* mark the end of the list */

3014

share->blob_field[blob_count]= 0; /* mark the end of the list */

3015

share->blob_fields= blob_count;

3016

3017

null_pack_length= (null_count + 7)/8;

3018

share->reclength= record_length + null_pack_length;

3019

share->rec_buff_length= ALIGN_SIZE(share->reclength + 1);

3020

table->record[0]= (unsigned char*) session->alloc(share->rec_buff_length);

3021

if (!table->record[0])

3022

goto error;

3023

3024

if (null_pack_length)

3025

{

3026

table->null_flags= (unsigned char*) table->record[0];

3027

share->null_fields= null_count;

3028

share->null_bytes= null_pack_length;

3029

}

3030

3031

table->in_use= session; /* field->reset() may access table->in_use */

3032

{

3033

/* Set up field pointers */

3034

unsigned char *null_pos= table->record[0];

3035

unsigned char *field_pos= null_pos + share->null_bytes;

3036

uint32_t null_bit= 1;

3037

3038

for (field= table->field; *field; ++field)

3039

{

3040

Field *cur_field= *field;

3041

if ((cur_field->flags & NOT_NULL_FLAG))

3042

cur_field->move_field(field_pos);

3043

else

3044

{

3045

cur_field->move_field(field_pos, (unsigned char*) null_pos, null_bit);

3046

null_bit<<= 1;

3047

if (null_bit == (1 << 8))

3048

{

3049

++null_pos;

3050

null_bit= 1;

3051

}

3052

}

3053

cur_field->reset();

3054

3055

field_pos+= cur_field->pack_length();

3056

}

3057

}

3058

return table;

3059

error:

3060

for (field= table->field; *field; ++field)

3061

delete *field; /* just invokes field destructor */

3062

return 0;

3063

}

3064

3065

bool Table::open_tmp_table()

3066

{

3067

int error;

3068

if ((error=file->ha_open(this, s->table_name.str,O_RDWR,

3069

HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))

3070

{

3071

file->print_error(error,MYF(0));

3072

db_stat= 0;

3073

return true;

3074

}

3075

(void) file->extra(HA_EXTRA_QUICK); /* Faster */

3076

return false;

3077

}

3078

3079

3535

3080

3536

Check type of .frm if we are not going to parse it

3081

Create MyISAM temporary table

3537

3082

3538

3083

SYNOPSIS

3539

mysql_frm_type()

3540

path path to file

3541

3542

RETURN

3543

FRMTYPE_ERROR error

3544

FRMTYPE_TABLE table

3084

create_myisam_tmp_table()

3085

keyinfo Description of the index (there is always one index)

3086

start_recinfo MyISAM's column descriptions

3087

recinfo INOUT End of MyISAM's column descriptions

3088

options Option bits

3089

3090

DESCRIPTION

3091

Create a MyISAM temporary table according to passed description. The is

3092

assumed to have one unique index or constraint.

3093

3094

The passed array or MI_COLUMNDEF structures must have this form:

3095

3096

1. 1-byte column (afaiu for 'deleted' flag) (note maybe not 1-byte

3097

when there are many nullable columns)

3098

2. Table columns

3099

3. One free MI_COLUMNDEF element (*recinfo points here)

3100

3101

This function may use the free element to create hash column for unique

3102

constraint.

3103

3104

RETURN

3105

false - OK

3106

true - Error

3545

3107

3546

3108

3547

frm_type_enum mysql_frm_type(THD *thd __attribute__((unused)),

3548

char *path, enum legacy_db_type *dbt)

3109

bool Table::create_myisam_tmp_table(KEY *keyinfo,

3110

MI_COLUMNDEF *start_recinfo,

3111

MI_COLUMNDEF **recinfo,

3112

uint64_t options)

3549

3113

{

3550

File file;

3551

uchar header[10]; /* This should be optimized */

3552

3114

int error;

3553

3554

*dbt= DB_TYPE_UNKNOWN;

3555

3556

if ((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0)

3557

return(FRMTYPE_ERROR);

3558

error= my_read(file, (uchar*) header, sizeof(header), MYF(MY_NABP));

3559

my_close(file, MYF(MY_WME));

3560

3561

if (error)

3562

return(FRMTYPE_ERROR);

3563

3564

3565

This is just a check for DB_TYPE. We'll return default unknown type

3566

if the following test is true (arg #3). This should not have effect

3567

on return value from this function (default FRMTYPE_TABLE)

3568

3569

if (header[0] != (uchar) 254 || header[1] != 1 ||

3570

(header[2] != FRM_VER && header[2] != FRM_VER+1 &&

3571

(header[2] < FRM_VER+3 || header[2] > FRM_VER+4)))

3572

return(FRMTYPE_TABLE);

3573

3574

*dbt= (enum legacy_db_type) (uint) *(header + 3);

3575

return(FRMTYPE_TABLE); // Is probably a .frm table

3576

}

3577

3578

3579

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

3580

** Instansiate templates

3581

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

3115

MI_KEYDEF keydef;

3116

MI_UNIQUEDEF uniquedef;

3117

TableShare *share= s;

3118

3119

if (share->keys)

3120

{ // Get keys for ni_create

3121

bool using_unique_constraint= 0;

3122

HA_KEYSEG *seg= (HA_KEYSEG*) alloc_root(&this->mem_root,

3123

sizeof(*seg) * keyinfo->key_parts);

3124

if (!seg)

3125

goto err;

3126

3127

memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);

3128

if (keyinfo->key_length >= file->max_key_length() ||

3129

keyinfo->key_parts > file->max_key_parts() ||

3130

share->uniques)

3131

{

3132

/* Can't create a key; Make a unique constraint instead of a key */

3133

share->keys= 0;

3134

share->uniques= 1;

3135

using_unique_constraint=1;

3136

memset(&uniquedef, 0, sizeof(uniquedef));

3137

uniquedef.keysegs=keyinfo->key_parts;

3138

uniquedef.seg=seg;

3139

uniquedef.null_are_equal=1;

3140

3141

/* Create extra column for hash value */

3142

memset(*recinfo, 0, sizeof(**recinfo));

3143

(*recinfo)->type= FIELD_CHECK;

3144

(*recinfo)->length=MI_UNIQUE_HASH_LENGTH;

3145

(*recinfo)++;

3146

share->reclength+=MI_UNIQUE_HASH_LENGTH;

3147

}

3148

else

3149

{

3150

/* Create an unique key */

3151

memset(&keydef, 0, sizeof(keydef));

3152

keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;

3153

keydef.keysegs= keyinfo->key_parts;

3154

keydef.seg= seg;

3155

}

3156

for (uint32_t i= 0; i < keyinfo->key_parts ; i++,seg++)

3157

{

3158

Field *key_field=keyinfo->key_part[i].field;

3159

seg->flag= 0;

3160

seg->language= key_field->charset()->number;

3161

seg->length= keyinfo->key_part[i].length;

3162

seg->start= keyinfo->key_part[i].offset;

3163

if (key_field->flags & BLOB_FLAG)

3164

{

3165

seg->type= ((keyinfo->key_part[i].key_type & 1 /* binary */) ?

3166

HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);

3167

seg->bit_start= (uint8_t)(key_field->pack_length()

3168

- share->blob_ptr_size);

3169

seg->flag= HA_BLOB_PART;

3170

seg->length= 0; // Whole blob in unique constraint

3171

}

3172

else

3173

{

3174

seg->type= keyinfo->key_part[i].type;

3175

}

3176

if (!(key_field->flags & NOT_NULL_FLAG))

3177

{

3178

seg->null_bit= key_field->null_bit;

3179

seg->null_pos= (uint32_t) (key_field->null_ptr - (unsigned char*) record[0]);

3180

3181

We are using a GROUP BY on something that contains NULL

3182

In this case we have to tell MyISAM that two NULL should

3183

on INSERT be regarded at the same value

3184

3185

if (!using_unique_constraint)

3186

keydef.flag|= HA_NULL_ARE_EQUAL;

3187

}

3188

}

3189

}

3190

MI_CREATE_INFO create_info;

3191

memset(&create_info, 0, sizeof(create_info));

3192

3193

if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==

3194

OPTION_BIG_TABLES)

3195

create_info.data_file_length= ~(uint64_t) 0;

3196

3197

if ((error=mi_create(share->table_name.str, share->keys, &keydef,

3198

(uint32_t) (*recinfo-start_recinfo),

3199

start_recinfo,

3200

share->uniques, &uniquedef,

3201

&create_info,

3202

HA_CREATE_TMP_TABLE)))

3203

{

3204

file->print_error(error,MYF(0));

3205

db_stat= 0;

3206

goto err;

3207

}

3208

status_var_increment(in_use->status_var.created_tmp_disk_tables);

3209

share->db_record_offset= 1;

3210

return false;

3211

err:

3212

return true;

3213

}

3214

3215

3216

void Table::free_tmp_table(Session *session)

3217

{

3218

MEM_ROOT own_root= mem_root;

3219

const char *save_proc_info;

3220

3221

save_proc_info=session->get_proc_info();

3222

session->set_proc_info("removing tmp table");

3223

3224

// Release latches since this can take a long time

3225

plugin::StorageEngine::releaseTemporaryLatches(session);

3226

3227

if (file)

3228

{

3229

if (db_stat)

3230

file->closeMarkForDelete(s->table_name.str);

3231

3232

s->db_type()->doDeleteTable(session, s->table_name.str);

3233

3234

delete file;

3235

}

3236

3237

/* free blobs */

3238

for (Field **ptr= field ; *ptr ; ptr++)

3239

(*ptr)->free();

3240

free_io_cache();

3241

3242

free_root(&own_root, MYF(0)); /* the table is allocated in its own root */

3243

session->set_proc_info(save_proc_info);

3244

}

3245

3246

/**

3247

If a HEAP table gets full, create a MyISAM table and copy all rows

3248

to this.

3249

3250

3251

bool create_myisam_from_heap(Session *session, Table *table,

3252

MI_COLUMNDEF *start_recinfo,

3253

MI_COLUMNDEF **recinfo,

3254

int error, bool ignore_last_dupp_key_error)

3255

{

3256

Table new_table;

3257

TableShare share;

3258

const char *save_proc_info;

3259

int write_err;

3260

3261

if (table->s->db_type() != heap_engine ||

3262

error != HA_ERR_RECORD_FILE_FULL)

3263

{

3264

table->file->print_error(error,MYF(0));

3265

return true;

3266

}

3267

3268

// Release latches since this can take a long time

3269

plugin::StorageEngine::releaseTemporaryLatches(session);

3270

3271

new_table= *table;

3272

share= *table->s;

3273

new_table.s= &share;

3274

new_table.s->storage_engine= myisam_engine;

3275

if (!(new_table.file= new_table.s->db_type()->getCursor(&share, &new_table.mem_root)))

3276

return true; // End of memory

3277

3278

save_proc_info=session->get_proc_info();

3279

session->set_proc_info("converting HEAP to MyISAM");

3280

3281

if (new_table.create_myisam_tmp_table(table->key_info, start_recinfo,

3282

recinfo, session->lex->select_lex.options |

3283

session->options))

3284

goto err2;

3285

if (new_table.open_tmp_table())

3286

goto err1;

3287

if (table->file->indexes_are_disabled())

3288

new_table.file->ha_disable_indexes(HA_KEY_SWITCH_ALL);

3289

table->file->ha_index_or_rnd_end();

3290

table->file->ha_rnd_init(1);

3291

if (table->no_rows)

3292

{

3293

new_table.file->extra(HA_EXTRA_NO_ROWS);

3294

new_table.no_rows=1;

3295

}

3296

3297

/* HA_EXTRA_WRITE_CACHE can stay until close, no need to disable it */

3298

new_table.file->extra(HA_EXTRA_WRITE_CACHE);

3299

3300

3301

copy all old rows from heap table to MyISAM table

3302

This is the only code that uses record[1] to read/write but this

3303

is safe as this is a temporary MyISAM table without timestamp/autoincrement.

3304

3305

while (!table->file->rnd_next(new_table.record[1]))

3306

{

3307

write_err= new_table.file->ha_write_row(new_table.record[1]);

3308

if (write_err)

3309

goto err;

3310

}

3311

/* copy row that filled HEAP table */

3312

if ((write_err=new_table.file->ha_write_row(table->record[0])))

3313

{

3314

if (new_table.file->is_fatal_error(write_err, HA_CHECK_DUP) ||

3315

!ignore_last_dupp_key_error)

3316

goto err;

3317

}

3318

3319

/* remove heap table and change to use myisam table */

3320

(void) table->file->ha_rnd_end();

3321

(void) table->file->close(); // This deletes the table !

3322

delete table->file;

3323

table->file= NULL;

3324

new_table.s= table->s; // Keep old share

3325

*table= new_table;

3326

*table->s= share;

3327

3328

table->file->change_table_ptr(table, table->s);

3329

table->use_all_columns();

3330

if (save_proc_info)

3331

{

3332

const char *new_proc_info=

3333

(!strcmp(save_proc_info,"Copying to tmp table") ?

3334

"Copying to tmp table on disk" : save_proc_info);

3335

session->set_proc_info(new_proc_info);

3336

}

3337

return false;

3338

3339

err:

3340

table->file->print_error(write_err, MYF(0));

3341

(void) table->file->ha_rnd_end();

3342

(void) new_table.file->close();

3343

err1:

3344

new_table.s->db_type()->doDeleteTable(session, new_table.s->table_name.str);

3345

err2:

3346

delete new_table.file;

3347

session->set_proc_info(save_proc_info);

3348

table->mem_root= new_table.mem_root;

3349

return true;

3350

}

3351

3352

my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)

3353

{

3354

my_bitmap_map *old= bitmap->getBitmap();

3355

bitmap->setBitmap(s->all_set.getBitmap());

3356

return old;

3357

}

3358

3359

void Table::restore_column_map(my_bitmap_map *old)

3360

{

3361

read_set->setBitmap(old);

3362

}

3363

3364

uint32_t Table::find_shortest_key(const key_map *usable_keys)

3365

{

3366

uint32_t min_length= UINT32_MAX;

3367

uint32_t best= MAX_KEY;

3368

if (usable_keys->any())

3369

{

3370

for (uint32_t nr= 0; nr < s->keys ; nr++)

3371

{

3372

if (usable_keys->test(nr))

3373

{

3374

if (key_info[nr].key_length < min_length)

3375

{

3376

min_length= key_info[nr].key_length;

3377

best=nr;

3378

}

3379

}

3380

}

3381

}

3382

return best;

3383

}

3384

3385

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

3386

Remove duplicates from tmp table

3387

This should be recoded to add a unique index to the table and remove

3388

duplicates

3389

Table is a locked single thread table

3390

fields is the number of fields to check (from the end)

3391

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

3392

3393

bool Table::compare_record(Field **ptr)

3394

{

3395

for (; *ptr ; ptr++)

3396

{

3397

if ((*ptr)->cmp_offset(s->rec_buff_length))

3398

return true;

3399

}

3400

return false;

3401

}

3402

3403

/* Return false if row hasn't changed */

3404

3405

bool Table::compare_record()

3406

{

3407

if (s->blob_fields + s->varchar_fields == 0)

3408

return memcmp(this->record[0], this->record[1], (size_t) s->reclength);

3409

/* Compare null bits */

3410

if (memcmp(null_flags,

3411

null_flags + s->rec_buff_length,

3412

s->null_bytes))

3413

return true; // Diff in NULL value

3414

/* Compare updated fields */

3415

for (Field **ptr= field ; *ptr ; ptr++)

3416

{

3417

if (isWriteSet((*ptr)->field_index) &&

3418

(*ptr)->cmp_binary_offset(s->rec_buff_length))

3419

return true;

3420

}

3421

return false;

3422

}

3423

3424

3425

* Store a record from previous record into next

3426

3427

3428

void Table::storeRecord()

3429

{

3430

memcpy(record[1], record[0], (size_t) s->reclength);

3431

}

3432

3433

3434

* Store a record as an insert

3435

3436

3437

void Table::storeRecordAsInsert()

3438

{

3439

memcpy(insert_values, record[0], (size_t) s->reclength);

3440

}

3441

3442

3443

* Store a record with default values

3444

3445

3446

void Table::storeRecordAsDefault()

3447

{

3448

memcpy(s->default_values, record[0], (size_t) s->reclength);

3449

}

3450

3451

3452

* Restore a record from previous record into next

3453

3454

3455

void Table::restoreRecord()

3456

{

3457

memcpy(record[0], record[1], (size_t) s->reclength);

3458

}

3459

3460

3461

* Restore a record with default values

3462

3463

3464

void Table::restoreRecordAsDefault()

3465

{

3466

memcpy(record[0], s->default_values, (size_t) s->reclength);

3467

}

3468

3469

3470

* Empty a record

3471

3472

3473

void Table::emptyRecord()

3474

{

3475

restoreRecordAsDefault();

3476

memset(null_flags, 255, s->null_bytes);

3477

}

3478

3479

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

3480

The different ways to read a record

3481

Returns -1 if row was not found, 0 if row was found and 1 on errors

3482

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

3483

3484

/** Help function when we get some an error from the table Cursor. */

3485

3486

int Table::report_error(int error)

3487

{

3488

if (error == HA_ERR_END_OF_FILE || error == HA_ERR_KEY_NOT_FOUND)

3489

{

3490

status= STATUS_GARBAGE;

3491

return -1; // key not found; ok

3492

}

3493

3494

Locking reads can legally return also these errors, do not

3495

print them to the .err log

3496

3497

if (error != HA_ERR_LOCK_DEADLOCK && error != HA_ERR_LOCK_WAIT_TIMEOUT)

3498

errmsg_printf(ERRMSG_LVL_ERROR, _("Got error %d when reading table '%s'"),

3499

error, s->path.str);

3500

file->print_error(error,MYF(0));

3501

3502

return 1;

3503

}

3504

3505

3506

void Table::setup_table_map(TableList *table_list, uint32_t table_number)

3507

{

3508

used_fields= 0;

3509

const_table= 0;

3510

null_row= 0;

3511

status= STATUS_NO_RECORD;

3512

maybe_null= table_list->outer_join;

3513

TableList *embedding= table_list->embedding;

3514

while (!maybe_null && embedding)

3515

{

3516

maybe_null= embedding->outer_join;

3517

embedding= embedding->embedding;

3518

}

3519

tablenr= table_number;

3520

map= (table_map) 1 << table_number;

3521

force_index= table_list->force_index;

3522

covering_keys= s->keys_for_keyread;

3523

merge_keys.reset();

3524

}

3525

3526

Field *Table::find_field_in_table_sef(const char *name)

3527

{

3528

Field **field_ptr;

3529

if (s->name_hash.records)

3530

{

3531

field_ptr= (Field**)hash_search(&s->name_hash,(unsigned char*) name,

3532

strlen(name));

3533

if (field_ptr)

3534

{

3535

3536

field_ptr points to field in TableShare. Convert it to the matching

3537

field in table

3538

3539

field_ptr= (field + (field_ptr - s->field));

3540

}

3541

}

3542

else

3543

{

3544

if (!(field_ptr= field))

3545

return (Field *)0;

3546

for (; *field_ptr; ++field_ptr)

3547

if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))

3548

break;

3549

}

3550

if (field_ptr)

3551

return *field_ptr;

3552

else

3553

return (Field *)0;

3554

}

3555

3556

3557

3558

Used by ALTER Table when the table is a temporary one. It changes something

3559

only if the ALTER contained a RENAME clause (otherwise, table_name is the old

3560

name).

3561

Prepares a table cache key, which is the concatenation of db, table_name and

3562

session->slave_proxy_id, separated by '\0'.

3563

3564

3565

bool Table::rename_temporary_table(const char *db, const char *table_name)

3566

{

3567

char *key;

3568

uint32_t key_length;

3569

TableShare *share= s;

3570

3571

if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))

3572

return true;

3573

3574

key_length= TableShare::createKey(key, db, table_name);

3575

share->set_table_cache_key(key, key_length);

3576

3577

return false;

3578

}

3582

3579

3583

3580

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

3584

3581

template class List<String>;

Older »