~drizzle-trunk/drizzle/development

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)))

2677

1103

use_packed_rows= 1;

2678

1104

2679

share->reclength= reclength;

1105

table->getMutableShare()->setRecordLength(reclength);

2680

1106

{

2681

1107

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

2682

share->rec_buff_length= alloc_length;

2683

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

2684

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

1108

table->getMutableShare()->rec_buff_length= alloc_length;

1109

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

1110

{

2685

1111

goto err;

2686

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

2687

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

1112

}

1113

table->record[1]= table->getInsertRecord()+alloc_length;

1114

table->getMutableShare()->resizeDefaultValues(alloc_length);

2688

1115

}

2689

1116

copy_func[0]= 0; // End marker

2690

1117

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

2691

1118

2692

table->setup_tmp_table_column_bitmaps(bitmaps);

1119

table->setup_tmp_table_column_bitmaps();

2693

1120

2694

1121

recinfo=param->start_recinfo;

2695

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

2696

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

1122

null_flags=(unsigned char*) table->getInsertRecord();

1123

pos=table->getInsertRecord()+ null_pack_length;

2697

1124

if (null_pack_length)

2698

1125

{

2699

1126

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

2702

1129

recinfo++;

2703

1130

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

2704

1131

2705

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

2706

share->null_fields= null_count+ hidden_null_count;

2707

share->null_bytes= null_pack_length;

1132

table->null_flags= (unsigned char*) table->getInsertRecord();

1133

table->getMutableShare()->null_fields= null_count+ hidden_null_count;

1134

table->getMutableShare()->null_bytes= null_pack_length;

2708

1135

}

2709

1136

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

2710

1137

hidden_field_count=param->hidden_field_count;

2711

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

1138

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

2712

1139

{

2713

1140

Field *field= *reg_field;

2714

1141

uint32_t length;

2755

1182

ptrdiff_t diff;

2756

1183

Field *orig_field= default_field[i];

2757

1184

/* Get the value from default_values */

2758

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

2759

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

1185

diff= (ptrdiff_t) (orig_field->getTable()->getDefaultValues() - orig_field->getTable()->getInsertRecord());

2760

1186

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

2761

1187

if (orig_field->is_real_null())

2762

1188

field->set_null();

2765

1191

field->set_notnull();

2766

1192

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

2767

1193

}

2768

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

1194

orig_field->move_field_offset(-diff); // Back to getInsertRecord()

2769

1195

}

2770

1196

2771

1197

if (from_field[i])

2784

1210

recinfo->type=FIELD_NORMAL;

2785

1211

if (!--hidden_field_count)

2786

1212

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

2787

2788

// fix table name in field entry

2789

field->table_name= &table->alias;

2790

1213

}

2791

1214

2792

1215

param->copy_field_end=copy;

2794

1217

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

2795

1218

2796

1219

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

1220

{

2797

1221

max_rows= ~(uint64_t) 0;

1222

}

2798

1223

else

2799

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

2800

min(session->variables.tmp_table_size,

2801

session->variables.max_heap_table_size) :

2802

session->variables.tmp_table_size) /

2803

share->reclength);

1224

{

1225

max_rows= (uint64_t) (((table->getMutableShare()->db_type() == heap_engine) ?

1226

min(session->variables.tmp_table_size,

1227

session->variables.max_heap_table_size) :

1228

session->variables.tmp_table_size) /

1229

table->getMutableShare()->getRecordLength());

1230

}

2804

1231

2805

1232

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

2806

1233

2809

1236

2810

1237

set_if_smaller(max_rows, rows_limit);

2811

1238

2812

share->setMaxRows(max_rows);

1239

table->getMutableShare()->setMaxRows(max_rows);

2813

1240

2814

1241

param->end_write_records= rows_limit;

2815

1242

2819

1246

{

2820

1247

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

2821

1248

param->group_buff=group_buff;

2822

share->keys=1;

2823

share->uniques= test(using_unique_constraint);

1249

table->getMutableShare()->keys=1;

1250

table->getMutableShare()->uniques= test(using_unique_constraint);

2824

1251

table->key_info=keyinfo;

2825

1252

keyinfo->key_part=key_part_info;

2826

1253

keyinfo->flags=HA_NOSAME;

2829

1256

keyinfo->rec_per_key= 0;

2830

1257

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

2831

1258

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

2832

order_st *cur_group= group;

1259

Order *cur_group= group;

2833

1260

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

2834

1261

{

2835

1262

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

2836

1263

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

2837

1264

key_part_info->null_bit= 0;

2838

1265

key_part_info->field= field;

2839

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

1266

key_part_info->offset= field->offset(table->getInsertRecord());

2840

1267

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

2841

1268

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

2842

1269

key_part_info->key_type=

2864

1291

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

2865

1292

key_part_info->null_bit=field->null_bit;

2866

1293

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

2867

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

1294

(unsigned char*) table->getInsertRecord());

2868

1295

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

2869

1296

group_buff++; // Skipp null flag

2870

1297

}

2891

1318

indexes on blobs with arbitrary length. Such indexes cannot be

2892

1319

used for lookups.

2893

1320

2894

share->uniques= 1;

1321

table->getMutableShare()->uniques= 1;

2895

1322

}

2896

1323

null_pack_length-=hidden_null_pack_length;

2897

1324

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

2898

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

1325

(table->getMutableShare()->uniques ? test(null_pack_length) : 0));

2899

1326

table->distinct= 1;

2900

share->keys= 1;

2901

if (!(key_part_info= (KEY_PART_INFO*)

2902

alloc_root(&table->mem_root,

2903

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

1327

table->getMutableShare()->keys= 1;

1328

if (!(key_part_info= (KeyPartInfo*)

1329

table->alloc_root(keyinfo->key_parts * sizeof(KeyPartInfo))))

2904

1330

goto err;

2905

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

1331

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

2906

1332

table->key_info=keyinfo;

2907

1333

keyinfo->key_part=key_part_info;

2908

1334

keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;

2916

1342

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

2917

1343

when we do not use UNIQUE indexes for blobs.

2918

1344

2919

if (null_pack_length && share->uniques)

1345

if (null_pack_length && table->getMutableShare()->uniques)

2920

1346

{

2921

1347

key_part_info->null_bit= 0;

2922

1348

key_part_info->offset=hidden_null_pack_length;

2923

1349

key_part_info->length=null_pack_length;

2924

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

1350

table->setVariableWidth();

1351

key_part_info->field= new Field_varstring(table->getInsertRecord(),

2925

1352

(uint32_t) key_part_info->length,

2926

1353

2927

1354

(unsigned char*) 0,

2928

1355

(uint32_t) 0,

2929

1356

NULL,

2930

table->s,

2931

1357

&my_charset_bin);

2932

1358

if (!key_part_info->field)

2933

1359

goto err;

2937

1363

key_part_info++;

2938

1364

}

2939

1365

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

2940

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

1366

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

2941

1367

i < field_count;

2942

1368

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

2943

1369

{

2944

1370

key_part_info->null_bit= 0;

2945

1371

key_part_info->field= *reg_field;

2946

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

1372

key_part_info->offset= (*reg_field)->offset(table->getInsertRecord());

2947

1373

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

2948

/* TODO:

2949

The below method of computing the key format length of the

1374

/* @todo The below method of computing the key format length of the

2950

1375

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

2951

1376

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

2952

1377

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

2972

1397

2973

1398

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

2974

1399

goto err;

2975

share->db_record_offset= 1;

2976

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

1400

table->getMutableShare()->db_record_offset= 1;

1401

if (table->getShare()->db_type() == myisam_engine)

2977

1402

{

2978

1403

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

2979

1404

&param->recinfo, select_options))

2980

1405

goto err;

2981

1406

}

1407

assert(table->in_use);

2982

1408

if (table->open_tmp_table())

2983

1409

goto err;

2984

1410

2988

1414

2989

1415

err:

2990

1416

session->mem_root= mem_root_save;

2991

table->free_tmp_table(session);

1417

table= NULL;

1418

2992

1419

return NULL;

2993

1420

}

2994

1421

2995

1422

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

2996

1423

2997

/**

2998

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

2999

list of field definitions.

3000

3001

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

3002

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

3003

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

3004

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

3005

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

3006

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

3007

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

3008

3009

@param session connection handle

3010

@param field_list list of column definitions

3011

3012

@return

3013

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

3014

3015

3016

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

3017

{

3018

uint32_t field_count= field_list.elements;

3019

uint32_t blob_count= 0;

3020

Field **field;

3021

CreateField *cdef; /* column definition */

3022

uint32_t record_length= 0;

3023

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

3024

uint32_t null_pack_length; /* NULL representation array length */

3025

uint32_t *blob_field;

3026

unsigned char *bitmaps;

3027

Table *table;

3028

TableShare *share;

3029

3030

if (!multi_alloc_root(session->mem_root,

3031

&table, sizeof(*table),

3032

&share, sizeof(*share),

3033

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

3034

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

3035

&bitmaps, bitmap_buffer_size(field_count)*2,

3036

NULL))

3037

return NULL;

3038

3039

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

3040

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

3041

table->field= field;

3042

table->s= share;

3043

share->blob_field= blob_field;

3044

share->fields= field_count;

3045

share->blob_ptr_size= portable_sizeof_char_ptr;

3046

table->setup_tmp_table_column_bitmaps(bitmaps);

3047

3048

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

3049

List_iterator_fast<CreateField> it(field_list);

3050

while ((cdef= it++))

3051

{

3052

*field= make_field(share,

3053

NULL,

3054

3055

cdef->length,

3056

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

3057

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

3058

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

3059

cdef->decimals,

3060

cdef->sql_type,

3061

cdef->charset,

3062

cdef->unireg_check,

3063

cdef->interval,

3064

cdef->field_name);

3065

if (!*field)

3066

goto error;

3067

(*field)->init(table);

3068

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

3069

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

3070

null_count++;

3071

3072

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

3073

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

3074

3075

field++;

3076

}

3077

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

3078

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

3079

share->blob_fields= blob_count;

3080

3081

null_pack_length= (null_count + 7)/8;

3082

share->reclength= record_length + null_pack_length;

3083

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

3084

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

3085

if (!table->record[0])

3086

goto error;

3087

3088

if (null_pack_length)

3089

{

3090

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

3091

share->null_fields= null_count;

3092

share->null_bytes= null_pack_length;

3093

}

3094

3095

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

3096

{

3097

/* Set up field pointers */

3098

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

3099

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

3100

uint32_t null_bit= 1;

3101

3102

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

3103

{

3104

Field *cur_field= *field;

3105

if ((cur_field->flags & NOT_NULL_FLAG))

3106

cur_field->move_field(field_pos);

3107

else

3108

{

3109

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

3110

null_bit<<= 1;

3111

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

3112

{

3113

++null_pos;

3114

null_bit= 1;

3115

}

3116

}

3117

cur_field->reset();

3118

3119

field_pos+= cur_field->pack_length();

3120

}

3121

}

3122

return table;

3123

error:

3124

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

3125

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

3126

return 0;

3127

}

3128

3129

bool Table::open_tmp_table()

3130

{

3131

int error;

3132

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

3133

HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))

3134

{

3135

print_error(error, MYF(0));

3136

db_stat= 0;

3137

return true;

3138

}

3139

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

3140

return false;

3141

}

3142

3143

3144

3145

Create MyISAM temporary table

3146

3147

SYNOPSIS

3148

create_myisam_tmp_table()

3149

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

3150

start_recinfo MyISAM's column descriptions

3151

recinfo INOUT End of MyISAM's column descriptions

3152

options Option bits

3153

3154

DESCRIPTION

3155

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

3156

assumed to have one unique index or constraint.

3157

3158

The passed array or MI_COLUMNDEF structures must have this form:

3159

3160

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

3161

when there are many nullable columns)

3162

2. Table columns

3163

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

3164

3165

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

3166

constraint.

3167

3168

RETURN

3169

false - OK

3170

true - Error

3171

3172

3173

bool Table::create_myisam_tmp_table(KEY *keyinfo,

3174

MI_COLUMNDEF *start_recinfo,

3175

MI_COLUMNDEF **recinfo,

3176

uint64_t options)

3177

{

3178

int error;

3179

MI_KEYDEF keydef;

3180

MI_UNIQUEDEF uniquedef;

3181

TableShare *share= s;

3182

3183

if (share->keys)

3184

{ // Get keys for ni_create

3185

bool using_unique_constraint= false;

3186

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

3187

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

3188

if (!seg)

3189

goto err;

3190

3191

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

3192

if (keyinfo->key_length >= cursor->getEngine()->max_key_length() ||

3193

keyinfo->key_parts > cursor->getEngine()->max_key_parts() ||

3194

share->uniques)

3195

{

3196

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

3197

share->keys= 0;

3198

share->uniques= 1;

3199

using_unique_constraint= true;

3200

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

3201

uniquedef.keysegs=keyinfo->key_parts;

3202

uniquedef.seg=seg;

3203

uniquedef.null_are_equal=1;

3204

3205

/* Create extra column for hash value */

3206

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

3207

(*recinfo)->type= FIELD_CHECK;

3208

(*recinfo)->length=MI_UNIQUE_HASH_LENGTH;

3209

(*recinfo)++;

3210

share->reclength+=MI_UNIQUE_HASH_LENGTH;

3211

}

3212

else

3213

{

3214

/* Create an unique key */

3215

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

3216

keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;

3217

keydef.keysegs= keyinfo->key_parts;

3218

keydef.seg= seg;

3219

}

3220

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

3221

{

3222

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

3223

seg->flag= 0;

3224

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

3225

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

3226

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

3227

if (key_field->flags & BLOB_FLAG)

3228

{

3229

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

3230

HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);

3231

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

3232

- share->blob_ptr_size);

3233

seg->flag= HA_BLOB_PART;

3234

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

3235

}

3236

else

3237

{

3238

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

3239

}

3240

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

3241

{

3242

seg->null_bit= key_field->null_bit;

3243

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

3244

3245

We are using a GROUP BY on something that contains NULL

3246

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

3247

on INSERT be regarded at the same value

3248

3249

if (! using_unique_constraint)

3250

keydef.flag|= HA_NULL_ARE_EQUAL;

3251

}

3252

}

3253

}

3254

MI_CREATE_INFO create_info;

3255

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

3256

3257

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

3258

OPTION_BIG_TABLES)

3259

create_info.data_file_length= ~(uint64_t) 0;

3260

3261

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

3262

(uint32_t) (*recinfo-start_recinfo),

3263

start_recinfo,

3264

share->uniques, &uniquedef,

3265

&create_info,

3266

HA_CREATE_TMP_TABLE)))

3267

{

3268

print_error(error, MYF(0));

3269

db_stat= 0;

3270

goto err;

3271

}

3272

status_var_increment(in_use->status_var.created_tmp_disk_tables);

3273

share->db_record_offset= 1;

3274

return false;

3275

err:

3276

return true;

3277

}

3278

3279

3280

void Table::free_tmp_table(Session *session)

3281

{

3282

memory::Root own_root= mem_root;

3283

const char *save_proc_info;

3284

3285

save_proc_info=session->get_proc_info();

3286

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

3287

3288

// Release latches since this can take a long time

3289

plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);

3290

3291

if (cursor)

3292

{

3293

if (db_stat)

3294

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

3295

3296

TableIdentifier identifier(s->getSchemaName(), s->table_name.str, s->table_name.str);

3297

s->db_type()->doDropTable(*session, identifier);

3298

3299

delete cursor;

3300

}

3301

3302

/* free blobs */

3303

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

3304

(*ptr)->free();

3305

free_io_cache();

3306

3307

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

3308

session->set_proc_info(save_proc_info);

3309

}

3310

3311

/**

3312

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

3313

to this.

3314

3315

3316

bool create_myisam_from_heap(Session *session, Table *table,

3317

MI_COLUMNDEF *start_recinfo,

3318

MI_COLUMNDEF **recinfo,

3319

int error, bool ignore_last_dupp_key_error)

3320

{

3321

Table new_table;

3322

TableShare share;

3323

const char *save_proc_info;

3324

int write_err;

3325

3326

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

3327

error != HA_ERR_RECORD_FILE_FULL)

3328

{

3329

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

3330

return true;

3331

}

3332

3333

// Release latches since this can take a long time

3334

plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);

3335

3336

new_table= *table;

3337

share= *table->s;

3338

new_table.s= &share;

3339

new_table.s->storage_engine= myisam_engine;

3340

if (not (new_table.cursor= new_table.s->db_type()->getCursor(share, &new_table.mem_root)))

3341

return true; // End of memory

3342

3343

save_proc_info=session->get_proc_info();

3344

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

3345

3346

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

3347

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

3348

session->options))

3349

goto err2;

3350

if (new_table.open_tmp_table())

3351

goto err1;

3352

if (table->cursor->indexes_are_disabled())

3353

new_table.cursor->ha_disable_indexes(HA_KEY_SWITCH_ALL);

3354

table->cursor->ha_index_or_rnd_end();

3355

table->cursor->ha_rnd_init(1);

3356

if (table->no_rows)

3357

{

3358

new_table.cursor->extra(HA_EXTRA_NO_ROWS);

3359

new_table.no_rows=1;

3360

}

3361

3362

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

3363

new_table.cursor->extra(HA_EXTRA_WRITE_CACHE);

3364

3365

3366

copy all old rows from heap table to MyISAM table

3367

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

3368

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

3369

3370

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

3371

{

3372

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

3373

if (write_err)

3374

goto err;

3375

}

3376

/* copy row that filled HEAP table */

3377

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

3378

{

3379

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

3380

!ignore_last_dupp_key_error)

3381

goto err;

3382

}

3383

3384

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

3385

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

3386

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

3387

delete table->cursor;

3388

table->cursor= NULL;

3389

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

3390

*table= new_table;

3391

*table->s= share;

3392

3393

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

3394

table->use_all_columns();

3395

if (save_proc_info)

3396

{

3397

const char *new_proc_info=

3398

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

3399

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

3400

session->set_proc_info(new_proc_info);

3401

}

3402

return false;

3403

3404

err:

3405

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

3406

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

3407

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

3408

3409

err1:

3410

{

3411

TableIdentifier identifier(new_table.s->getSchemaName(), new_table.s->table_name.str, new_table.s->table_name.str);

3412

new_table.s->db_type()->doDropTable(*session, identifier);

3413

}

3414

3415

err2:

3416

delete new_table.cursor;

3417

session->set_proc_info(save_proc_info);

3418

table->mem_root= new_table.mem_root;

3419

return true;

3420

}

3421

3422

my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)

3423

{

3424

my_bitmap_map *old= bitmap->getBitmap();

3425

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

1424

void Table::column_bitmaps_set(boost::dynamic_bitset<>& read_set_arg,

1425

boost::dynamic_bitset<>& write_set_arg)

1426

{

1427

read_set= &read_set_arg;

1428

write_set= &write_set_arg;

1429

}

1430

1431

1432

const boost::dynamic_bitset<> Table::use_all_columns(boost::dynamic_bitset<>& in_map)

1433

{

1434

const boost::dynamic_bitset<> old= in_map;

1435

in_map= getShare()->all_set;

3426

1436

return old;

3427

1437

}

3428

1438

3429

void Table::restore_column_map(my_bitmap_map *old)

1439

void Table::restore_column_map(const boost::dynamic_bitset<>& old)

3430

1440

{

3431

read_set->setBitmap(old);

1441

for (boost::dynamic_bitset<>::size_type i= 0; i < old.size(); i++)

1442

{

1443

if (old.test(i))

1444

{

1445

read_set->set(i);

1446

}

1447

else

1448

{

1449

read_set->reset(i);

1450

}

1451

}

3432

1452

}

3433

1453

3434

1454

uint32_t Table::find_shortest_key(const key_map *usable_keys)

3437

1457

uint32_t best= MAX_KEY;

3438

1458

if (usable_keys->any())

3439

1459

{

3440

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

1460

for (uint32_t nr= 0; nr < getShare()->sizeKeys() ; nr++)

3441

1461

{

3442

1462

if (usable_keys->test(nr))

3443

1463

{

3464

1484

{

3465

1485

for (; *ptr ; ptr++)

3466

1486

{

3467

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

1487

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

3468

1488

return true;

3469

1489

}

3470

1490

return false;

3474

1494

3475

1495

bool Table::compare_record()

3476

1496

{

3477

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

3478

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

1497

if (not getShare()->blob_fields + getShare()->hasVariableWidth())

1498

return memcmp(this->getInsertRecord(), this->getUpdateRecord(), (size_t) getShare()->getRecordLength());

3479

1499

3480

1500

/* Compare null bits */

3481

if (memcmp(null_flags, null_flags + s->rec_buff_length, s->null_bytes))

1501

if (memcmp(null_flags, null_flags + getShare()->rec_buff_length, getShare()->null_bytes))

3482

1502

return true; /* Diff in NULL value */

3483

1503

3484

1504

/* Compare updated fields */

3485

1505

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

3486

1506

{

3487

1507

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

3488

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

1508

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

3489

1509

return true;

3490

1510

}

3491

1511

return false;

3497

1517

3498

1518

void Table::storeRecord()

3499

1519

{

3500

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

1520

memcpy(getUpdateRecord(), getInsertRecord(), (size_t) getShare()->getRecordLength());

3501

1521

}

3502

1522

3503

1523

3506

1526

3507

1527

void Table::storeRecordAsInsert()

3508

1528

{

3509

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

1529

assert(insert_values.size() >= getShare()->getRecordLength());

1530

memcpy(&insert_values[0], getInsertRecord(), (size_t) getShare()->getRecordLength());

3510

1531

}

3511

1532

3512

1533

3515

1536

3516

1537

void Table::storeRecordAsDefault()

3517

1538

{

3518

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

1539

memcpy(getMutableShare()->getDefaultValues(), getInsertRecord(), (size_t) getShare()->getRecordLength());

3519

1540

}

3520

1541

3521

1542

3524

1545

3525

1546

void Table::restoreRecord()

3526

1547

{

3527

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

1548

memcpy(getInsertRecord(), getUpdateRecord(), (size_t) getShare()->getRecordLength());

3528

1549

}

3529

1550

3530

1551

3533

1554

3534

1555

void Table::restoreRecordAsDefault()

3535

1556

{

3536

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

1557

memcpy(getInsertRecord(), getMutableShare()->getDefaultValues(), (size_t) getShare()->getRecordLength());

3537

1558

}

3538

1559

3539

1560

3543

1564

void Table::emptyRecord()

3544

1565

{

3545

1566

restoreRecordAsDefault();

3546

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

1567

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

3547

1568

}

3548

1569

3549

Table::Table()

3550

: s(NULL),

3551

field(NULL),

3552

cursor(NULL),

3553

next(NULL),

3554

prev(NULL),

3555

read_set(NULL),

3556

write_set(NULL),

3557

tablenr(0),

3558

db_stat(0),

3559

in_use(NULL),

3560

insert_values(NULL),

3561

key_info(NULL),

3562

next_number_field(NULL),

3563

found_next_number_field(NULL),

3564

timestamp_field(NULL),

3565

pos_in_table_list(NULL),

3566

group(NULL),

3567

alias(NULL),

3568

null_flags(NULL),

3569

lock_position(0),

3570

lock_data_start(0),

3571

lock_count(0),

3572

used_fields(0),

3573

status(0),

3574

derived_select_number(0),

3575

current_lock(F_UNLCK),

3576

copy_blobs(false),

3577

maybe_null(false),

3578

null_row(false),

3579

force_index(false),

3580

distinct(false),

3581

const_table(false),

3582

no_rows(false),

3583

key_read(false),

3584

no_keyread(false),

3585

open_placeholder(false),

3586

locked_by_name(false),

3587

no_cache(false),

3588

auto_increment_field_not_null(false),

3589

alias_name_used(false),

3590

query_id(0),

3591

quick_condition_rows(0),

3592

timestamp_field_type(TIMESTAMP_NO_AUTO_SET),

3593

map(0)

1570

Table::Table() :

1571

field(NULL),

1572

cursor(NULL),

1573

next(NULL),

1574

prev(NULL),

1575

read_set(NULL),

1576

write_set(NULL),

1577

tablenr(0),

1578

db_stat(0),

1579

def_read_set(),

1580

def_write_set(),

1581

tmp_set(),

1582

in_use(NULL),

1583

key_info(NULL),

1584

next_number_field(NULL),

1585

found_next_number_field(NULL),

1586

timestamp_field(NULL),

1587

pos_in_table_list(NULL),

1588

group(NULL),

1589

null_flags(NULL),

1590

lock_position(0),

1591

lock_data_start(0),

1592

lock_count(0),

1593

used_fields(0),

1594

status(0),

1595

derived_select_number(0),

1596

current_lock(F_UNLCK),

1597

copy_blobs(false),

1598

maybe_null(false),

1599

null_row(false),

1600

force_index(false),

1601

distinct(false),

1602

const_table(false),

1603

no_rows(false),

1604

key_read(false),

1605

no_keyread(false),

1606

open_placeholder(false),

1607

locked_by_name(false),

1608

no_cache(false),

1609

auto_increment_field_not_null(false),

1610

alias_name_used(false),

1611

query_id(0),

1612

quick_condition_rows(0),

1613

timestamp_field_type(TIMESTAMP_NO_AUTO_SET),

1614

map(0)

3594

1615

{

3595

1616

record[0]= (unsigned char *) 0;

3596

1617

record[1]= (unsigned char *) 0;

3597

1618

1619

reginfo.reset();

3598

1620

covering_keys.reset();

3599

3600

1621

quick_keys.reset();

3601

1622

merge_keys.reset();

3602

1623

3609

1630

3610

1631

memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);

3611

1632

memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);

3612

3613

memory::init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);

3614

memset(&sort, 0, sizeof(filesort_info_st));

3615

1633

}

3616

1634

3617

1635

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

3634

1652

3635

1653

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

3636

1654

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

3637

error, s->path.str);

1655

error, getShare()->getPath());

3638

1656

print_error(error, MYF(0));

3639

1657

3640

1658

return 1;

3648

1666

null_row= 0;

3649

1667

status= STATUS_NO_RECORD;

3650

1668

maybe_null= table_list->outer_join;

3651

TableList *embedding= table_list->embedding;

1669

TableList *embedding= table_list->getEmbedding();

3652

1670

while (!maybe_null && embedding)

3653

1671

{

3654

1672

maybe_null= embedding->outer_join;

3655

embedding= embedding->embedding;

1673

embedding= embedding->getEmbedding();

3656

1674

}

3657

1675

tablenr= table_number;

3658

1676

map= (table_map) 1 << table_number;

3659

1677

force_index= table_list->force_index;

3660

covering_keys= s->keys_for_keyread;

1678

covering_keys= getShare()->keys_for_keyread;

3661

1679

merge_keys.reset();

3662

1680

}

3663

1681

3664

1682

3665

3666

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

3667

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

3668

name).

3669

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

3670

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

3671

3672

3673

bool Table::renameAlterTemporaryTable(TableIdentifier &identifier)

1683

bool Table::fill_item_list(List<Item> *item_list) const

3674

1684

{

3675

char *key;

3676

uint32_t key_length;

3677

TableShare *share= s;

3678

3679

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

3680

return true;

3681

3682

key_length= TableShare::createKey(key, identifier);

3683

share->set_table_cache_key(key, key_length);

3684

3685

message::Table *message= share->getTableProto();

3686

3687

message->set_name(identifier.getTableName());

3688

message->set_schema(identifier.getSchemaName());

3689

1685

1686

All Item_field's created using a direct pointer to a field

1687

are fixed in Item_field constructor.

1688

1689

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

1690

{

1691

Item_field *item= new Item_field(*ptr);

1692

if (!item || item_list->push_back(item))

1693

return true;

1694

}

3690

1695

return false;

3691

1696

}

3692

1697

Older »