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

4042

use_packed_rows= 1;

4043

1020

4044

share->reclength= reclength;

1021

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

4045

1022

{

4046

1023

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

4047

share->rec_buff_length= alloc_length;

4048

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

4049

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

4050

goto err;

4051

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

4052

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

1024

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

1025

table->record[0]= table->alloc(alloc_length*2);

1026

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

1027

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

4053

1028

}

4054

copy_func[0]=0; // End marker

4055

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

1029

copy_func[0]= 0; // End marker

1030

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

4056

1031

4057

table->setup_tmp_table_column_bitmaps(bitmaps);

1032

table->setup_tmp_table_column_bitmaps();

4058

1033

4059

1034

recinfo=param->start_recinfo;

4060

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

4061

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

1035

null_flags= table->getInsertRecord();

1036

pos=table->getInsertRecord()+ null_pack_length;

4062

1037

if (null_pack_length)

4063

1038

{

4064

1039

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

4067

1042

recinfo++;

4068

1043

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

4069

1044

4070

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

4071

share->null_fields= null_count+ hidden_null_count;

4072

share->null_bytes= null_pack_length;

1045

table->null_flags= table->getInsertRecord();

1046

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

1047

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

4073

1048

}

4074

1049

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

4075

1050

hidden_field_count=param->hidden_field_count;

4076

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

1051

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

4077

1052

{

4078

1053

Field *field= *reg_field;

4079

1054

uint32_t length;

4087

1062

We have to reserve one byte here for NULL bits,

4088

1063

as this is updated by 'end_update()'

4089

1064

4090

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

4091

recinfo->length=1;

1065

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

1066

recinfo->length= 1;

4092

1067

recinfo->type=FIELD_NORMAL;

4093

1068

recinfo++;

4094

1069

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

4112

1087

4113

1088

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

4114

1089

{

4115

1090

4116

1091

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

4117

1092

inherit the default value that is defined for the field referred

4118

1093

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

4119

1094

4120

my_ptrdiff_t diff;

1095

ptrdiff_t diff;

4121

1096

Field *orig_field= default_field[i];

4122

1097

/* Get the value from default_values */

4123

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

4124

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

1098

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

4125

1099

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

4126

1100

if (orig_field->is_real_null())

4127

1101

field->set_null();

4130

1104

field->set_notnull();

4131

1105

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

4132

1106

}

4133

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

4134

}

1107

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

1108

}

4135

1109

4136

1110

if (from_field[i])

4137

1111

{ /* Not a table Item */

4149

1123

recinfo->type=FIELD_NORMAL;

4150

1124

if (!--hidden_field_count)

4151

1125

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

4152

4153

// fix table name in field entry

4154

field->table_name= &table->alias;

4155

1126

}

4156

1127

4157

1128

param->copy_field_end=copy;

4158

1129

param->recinfo=recinfo;

4159

store_record(table,s->default_values); // Make empty default record

1130

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

4160

1131

4161

1132

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

4162

share->max_rows= ~(ha_rows) 0;

1133

{

1134

max_rows= ~(uint64_t) 0;

1135

}

4163

1136

else

4164

share->max_rows= (ha_rows) (((share->db_type() == heap_hton) ?

4165

cmin(session->variables.tmp_table_size,

4166

session->variables.max_heap_table_size) :

4167

session->variables.tmp_table_size) /

4168

share->reclength);

4169

set_if_bigger(share->max_rows,1); // For dummy start options

1137

{

1138

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

1139

min(session->variables.tmp_table_size,

1140

session->variables.max_heap_table_size) :

1141

session->variables.tmp_table_size) /

1142

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

1143

}

1144

1145

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

4170

1146

4171

1147

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

4172

1148

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

4173

1149

4174

set_if_smaller(share->max_rows, rows_limit);

1150

set_if_smaller(max_rows, rows_limit);

1151

1152

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

1153

4175

1154

param->end_write_records= rows_limit;

4176

1155

4177

1156

keyinfo= param->keyinfo;

4180

1159

{

4181

1160

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

4182

1161

param->group_buff=group_buff;

4183

share->keys=1;

4184

share->uniques= test(using_unique_constraint);

1162

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

1163

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

4185

1164

table->key_info=keyinfo;

4186

1165

keyinfo->key_part=key_part_info;

4187

1166

keyinfo->flags=HA_NOSAME;

4188

1167

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

4189

keyinfo->key_length=0;

4190

keyinfo->rec_per_key=0;

1168

keyinfo->key_length= 0;

1169

keyinfo->rec_per_key= 0;

4191

1170

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

4192

1171

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

4193

order_st *cur_group= group;

1172

Order *cur_group= group;

4194

1173

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

4195

1174

{

4196

1175

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

4197

1176

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

4198

key_part_info->null_bit=0;

1177

key_part_info->null_bit= 0;

4199

1178

key_part_info->field= field;

4200

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

1179

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

4201

1180

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

4202

1181

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

4203

key_part_info->key_type =

1182

key_part_info->key_type=

4204

1183

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

4205

1184

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

4206

1185

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

4207

0 : FIELDFLAG_BINARY;

1186

0 : 1;

4208

1187

if (!using_unique_constraint)

4209

1188

{

4210

1189

cur_group->buff=(char*) group_buff;

4213

1192

test(maybe_null),

4214

1193

field->null_ptr,

4215

1194

field->null_bit)))

4216

goto err; /* purecov: inspected */

1195

goto err;

4217

1196

if (maybe_null)

4218

1197

{

4219

1198

4224

1203

4225

1204

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

4226

1205

key_part_info->null_bit=field->null_bit;

4227

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

4228

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

1206

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

1207

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

4229

1208

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

4230

1209

group_buff++; // Skipp null flag

4231

1210

}

4252

1231

indexes on blobs with arbitrary length. Such indexes cannot be

4253

1232

used for lookups.

4254

1233

4255

share->uniques= 1;

1234

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

4256

1235

}

4257

1236

null_pack_length-=hidden_null_pack_length;

4258

1237

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

4259

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

1238

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

4260

1239

table->distinct= 1;

4261

share->keys= 1;

4262

if (!(key_part_info= (KEY_PART_INFO*)

4263

alloc_root(&table->mem_root,

4264

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

4265

goto err;

4266

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

1240

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

1241

key_part_info= new (table->mem()) KeyPartInfo[keyinfo->key_parts];

1242

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

4267

1243

table->key_info=keyinfo;

4268

1244

keyinfo->key_part=key_part_info;

4269

1245

keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;

4270

1246

keyinfo->key_length=(uint16_t) reclength;

4271

1247

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

4272

1248

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

4273

keyinfo->rec_per_key=0;

1249

keyinfo->rec_per_key= 0;

4274

1250

4275

1251

4276

1252

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

4277

1253

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

4278

1254

when we do not use UNIQUE indexes for blobs.

4279

1255

4280

if (null_pack_length && share->uniques)

1256

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

4281

1257

{

4282

key_part_info->null_bit=0;

1258

key_part_info->null_bit= 0;

4283

1259

key_part_info->offset=hidden_null_pack_length;

4284

1260

key_part_info->length=null_pack_length;

4285

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

1261

table->setVariableWidth();

1262

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

4286

1263

(uint32_t) key_part_info->length,

4287

1264

4288

1265

(unsigned char*) 0,

4289

(uint) 0,

4290

Field::NONE,

4291

NULL,

4292

table->s,

1266

(uint32_t) 0,

1267

NULL,

4293

1268

&my_charset_bin);

4294

1269

if (!key_part_info->field)

4295

1270

goto err;

4296

1271

key_part_info->field->init(table);

4297

key_part_info->key_type=FIELDFLAG_BINARY;

1272

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

4298

1273

key_part_info->type= HA_KEYTYPE_BINARY;

4299

1274

key_part_info++;

4300

1275

}

4301

1276

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

4302

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

1277

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

4303

1278

i < field_count;

4304

1279

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

4305

1280

{

4306

key_part_info->null_bit=0;

1281

key_part_info->null_bit= 0;

4307

1282

key_part_info->field= *reg_field;

4308

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

1283

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

4309

1284

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

4310

/* TODO:

4311

The below method of computing the key format length of the

4312

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

1285

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

1286

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

4313

1287

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

4314

1288

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

4315

1289

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

4319

1293

4320

1294

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

4321

1295

key_part_info->store_length+= HA_KEY_NULL_LENGTH;

4322

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

1296

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

4323

1297

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

4324

1298

key_part_info->store_length+= HA_KEY_BLOB_LENGTH;

4325

1299

4328

1302

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

4329

1303

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

4330

1304

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

4331

0 : FIELDFLAG_BINARY;

1305

0 : 1;

4332

1306

}

4333

1307

}

4334

1308

4335

1309

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

4336

goto err; /* purecov: inspected */

4337

share->db_record_offset= 1;

4338

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

1310

goto err;

1311

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

1312

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

4339

1313

{

4340

1314

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

4341

1315

&param->recinfo, select_options))

4342

1316

goto err;

4343

1317

}

1318

assert(table->in_use);

4344

1319

if (table->open_tmp_table())

4345

1320

goto err;

4346

1321

4350

1325

4351

1326

err:

4352

1327

session->mem_root= mem_root_save;

4353

table->free_tmp_table(session); /* purecov: inspected */

4354

if (temp_pool_slot != MY_BIT_NONE)

4355

bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);

4356

return(NULL); /* purecov: inspected */

1328

table= NULL;

1329

1330

return NULL;

4357

1331

}

4358

1332

4359

1333

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

4360

1334

4361

/**

4362

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

4363

list of field definitions.

4364

4365

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

4366

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

4367

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

4368

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

4369

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

4370

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

4371

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

4372

4373

@param session connection handle

4374

@param field_list list of column definitions

4375

4376

@return

4377

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

4378

4379

4380

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

4381

{

4382

uint32_t field_count= field_list.elements;

4383

uint32_t blob_count= 0;

4384

Field **field;

4385

Create_field *cdef; /* column definition */

4386

uint32_t record_length= 0;

4387

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

4388

uint32_t null_pack_length; /* NULL representation array length */

4389

uint32_t *blob_field;

4390

unsigned char *bitmaps;

4391

Table *table;

4392

TABLE_SHARE *share;

4393

4394

if (!multi_alloc_root(session->mem_root,

4395

&table, sizeof(*table),

4396

&share, sizeof(*share),

4397

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

4398

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

4399

&bitmaps, bitmap_buffer_size(field_count)*2,

4400

NULL))

4401

return 0;

4402

4403

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

4404

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

4405

table->field= field;

4406

table->s= share;

4407

share->blob_field= blob_field;

4408

share->fields= field_count;

4409

share->blob_ptr_size= portable_sizeof_char_ptr;

4410

table->setup_tmp_table_column_bitmaps(bitmaps);

4411

4412

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

4413

List_iterator_fast<Create_field> it(field_list);

4414

while ((cdef= it++))

4415

{

4416

*field= make_field(share, 0, cdef->length,

4417

(unsigned char*) (f_maybe_null(cdef->pack_flag) ? "" : 0),

4418

f_maybe_null(cdef->pack_flag) ? 1 : 0,

4419

cdef->pack_flag, cdef->sql_type, cdef->charset,

4420

cdef->unireg_check,

4421

cdef->interval, cdef->field_name);

4422

if (!*field)

4423

goto error;

4424

(*field)->init(table);

4425

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

4426

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

4427

null_count++;

4428

4429

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

4430

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

4431

4432

field++;

4433

}

4434

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

4435

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

4436

share->blob_fields= blob_count;

4437

4438

null_pack_length= (null_count + 7)/8;

4439

share->reclength= record_length + null_pack_length;

4440

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

4441

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

4442

if (!table->record[0])

4443

goto error;

4444

4445

if (null_pack_length)

4446

{

4447

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

4448

share->null_fields= null_count;

4449

share->null_bytes= null_pack_length;

4450

}

4451

4452

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

4453

{

4454

/* Set up field pointers */

4455

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

4456

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

4457

uint32_t null_bit= 1;

4458

4459

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

4460

{

4461

Field *cur_field= *field;

4462

if ((cur_field->flags & NOT_NULL_FLAG))

4463

cur_field->move_field(field_pos);

4464

else

4465

{

4466

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

4467

null_bit<<= 1;

4468

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

4469

{

4470

++null_pos;

4471

null_bit= 1;

4472

}

4473

}

4474

cur_field->reset();

4475

4476

field_pos+= cur_field->pack_length();

4477

}

4478

}

4479

return table;

4480

error:

4481

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

4482

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

4483

return 0;

4484

}

4485

4486

4487

bool Table::open_tmp_table()

4488

{

4489

int error;

4490

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

4491

HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))

4492

{

4493

file->print_error(error,MYF(0)); /* purecov: inspected */

4494

db_stat=0;

4495

return(1);

4496

}

4497

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

4498

return(0);

4499

}

4500

4501

4502

4503

Create MyISAM temporary table

4504

4505

SYNOPSIS

4506

create_myisam_tmp_table()

4507

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

4508

start_recinfo MyISAM's column descriptions

4509

recinfo INOUT End of MyISAM's column descriptions

4510

options Option bits

4511

4512

DESCRIPTION

4513

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

4514

assumed to have one unique index or constraint.

4515

4516

The passed array or MI_COLUMNDEF structures must have this form:

4517

4518

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

4519

when there are many nullable columns)

4520

2. Table columns

4521

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

4522

4523

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

4524

constraint.

4525

4526

RETURN

4527

false - OK

4528

true - Error

4529

4530

4531

bool Table::create_myisam_tmp_table(KEY *keyinfo,

4532

MI_COLUMNDEF *start_recinfo,

4533

MI_COLUMNDEF **recinfo,

4534

uint64_t options)

4535

{

4536

int error;

4537

MI_KEYDEF keydef;

4538

MI_UNIQUEDEF uniquedef;

4539

TABLE_SHARE *share= s;

4540

4541

if (share->keys)

4542

{ // Get keys for ni_create

4543

bool using_unique_constraint=0;

4544

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

4545

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

4546

if (!seg)

4547

goto err;

4548

4549

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

4550

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

4551

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

4552

share->uniques)

4553

{

4554

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

4555

share->keys= 0;

4556

share->uniques= 1;

4557

using_unique_constraint=1;

4558

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

4559

uniquedef.keysegs=keyinfo->key_parts;

4560

uniquedef.seg=seg;

4561

uniquedef.null_are_equal=1;

4562

4563

/* Create extra column for hash value */

4564

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

4565

(*recinfo)->type= FIELD_CHECK;

4566

(*recinfo)->length=MI_UNIQUE_HASH_LENGTH;

4567

(*recinfo)++;

4568

share->reclength+=MI_UNIQUE_HASH_LENGTH;

4569

}

4570

else

4571

{

4572

/* Create an unique key */

4573

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

4574

keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;

4575

keydef.keysegs= keyinfo->key_parts;

4576

keydef.seg= seg;

4577

}

4578

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

4579

{

4580

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

4581

seg->flag= 0;

4582

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

4583

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

4584

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

4585

if (field->flags & BLOB_FLAG)

4586

{

4587

seg->type=

4588

((keyinfo->key_part[i].key_type & FIELDFLAG_BINARY) ?

4589

HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);

4590

seg->bit_start= (uint8_t)(field->pack_length() - share->blob_ptr_size);

4591

seg->flag= HA_BLOB_PART;

4592

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

4593

}

4594

else

4595

{

4596

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

4597

}

4598

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

4599

{

4600

seg->null_bit= field->null_bit;

4601

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

4602

4603

We are using a GROUP BY on something that contains NULL

4604

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

4605

on INSERT be regarded at the same value

4606

4607

if (!using_unique_constraint)

4608

keydef.flag|= HA_NULL_ARE_EQUAL;

4609

}

4610

}

4611

}

4612

MI_CREATE_INFO create_info;

4613

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

4614

4615

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

4616

OPTION_BIG_TABLES)

4617

create_info.data_file_length= ~(uint64_t) 0;

4618

4619

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

4620

(uint) (*recinfo-start_recinfo),

4621

start_recinfo,

4622

share->uniques, &uniquedef,

4623

&create_info,

4624

HA_CREATE_TMP_TABLE)))

4625

{

4626

file->print_error(error,MYF(0)); /* purecov: inspected */

4627

db_stat=0;

4628

goto err;

4629

}

4630

status_var_increment(in_use->status_var.created_tmp_disk_tables);

4631

share->db_record_offset= 1;

4632

return false;

4633

err:

4634

return true;

4635

}

4636

4637

4638

void Table::free_tmp_table(Session *session)

4639

{

4640

MEM_ROOT own_root= mem_root;

4641

const char *save_proc_info;

4642

4643

save_proc_info=session->get_proc_info();

4644

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

4645

4646

if (file)

4647

{

4648

if (db_stat)

4649

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

4650

else

4651

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

4652

delete file;

4653

}

4654

4655

/* free blobs */

4656

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

4657

(*ptr)->free();

4658

free_io_cache(this);

4659

4660

if (temp_pool_slot != MY_BIT_NONE)

4661

bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);

4662

4663

plugin_unlock(0, s->db_plugin);

4664

4665

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

4666

session->set_proc_info(save_proc_info);

4667

4668

return;

4669

}

4670

4671

/**

4672

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

4673

to this.

4674

4675

4676

bool create_myisam_from_heap(Session *session, Table *table,

4677

MI_COLUMNDEF *start_recinfo,

4678

MI_COLUMNDEF **recinfo,

4679

int error, bool ignore_last_dupp_key_error)

4680

{

4681

Table new_table;

4682

TABLE_SHARE share;

4683

const char *save_proc_info;

4684

int write_err;

4685

4686

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

4687

error != HA_ERR_RECORD_FILE_FULL)

4688

{

4689

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

4690

return(1);

4691

}

4692

new_table= *table;

4693

share= *table->s;

4694

new_table.s= &share;

4695

new_table.s->db_plugin= ha_lock_engine(session, myisam_hton);

4696

if (!(new_table.file= get_new_handler(&share, &new_table.mem_root,

4697

new_table.s->db_type())))

4698

return(1); // End of memory

4699

4700

save_proc_info=session->get_proc_info();

4701

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

4702

4703

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

4704

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

4705

session->options))

4706

goto err2;

4707

if (new_table.open_tmp_table())

4708

goto err1;

4709

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

4710

new_table.file->ha_disable_indexes(HA_KEY_SWITCH_ALL);

4711

table->file->ha_index_or_rnd_end();

4712

table->file->ha_rnd_init(1);

4713

if (table->no_rows)

4714

{

4715

new_table.file->extra(HA_EXTRA_NO_ROWS);

4716

new_table.no_rows=1;

4717

}

4718

4719

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

4720

new_table.file->extra(HA_EXTRA_WRITE_CACHE);

4721

4722

4723

copy all old rows from heap table to MyISAM table

4724

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

4725

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

4726

4727

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

4728

{

4729

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

4730

if (write_err)

4731

goto err;

4732

}

4733

/* copy row that filled HEAP table */

4734

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

4735

{

4736

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

4737

!ignore_last_dupp_key_error)

4738

goto err;

4739

}

4740

4741

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

4742

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

4743

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

4744

delete table->file;

4745

table->file=0;

4746

plugin_unlock(0, table->s->db_plugin);

4747

share.db_plugin= my_plugin_lock(0, &share.db_plugin);

4748

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

4749

*table= new_table;

4750

*table->s= share;

4751

4752

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

4753

table->use_all_columns();

4754

if (save_proc_info)

4755

{

4756

const char *new_proc_info=

4757

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

4758

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

4759

session->set_proc_info(new_proc_info);

4760

}

4761

return(0);

4762

4763

err:

4764

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

4765

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

4766

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

4767

err1:

4768

new_table.file->ha_delete_table(new_table.s->table_name.str);

4769

err2:

4770

delete new_table.file;

4771

session->set_proc_info(save_proc_info);

4772

table->mem_root= new_table.mem_root;

4773

return(1);

4774

}

4775

4776

my_bitmap_map *Table::use_all_columns(MY_BITMAP *bitmap)

4777

{

4778

my_bitmap_map *old= bitmap->bitmap;

4779

bitmap->bitmap= s->all_set.bitmap;

1335

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

1336

boost::dynamic_bitset<>& write_set_arg)

1337

{

1338

read_set= &read_set_arg;

1339

write_set= &write_set_arg;

1340

}

1341

1342

1343

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

1344

{

1345

const boost::dynamic_bitset<> old= in_map;

1346

in_map= getShare()->all_set;

4780

1347

return old;

4781

1348

}

4782

1349

4783

void Table::restore_column_map(my_bitmap_map *old)

1350

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

4784

1351

{

4785

read_set->bitmap= old;

1352

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

1353

{

1354

if (old.test(i))

1355

{

1356

read_set->set(i);

1357

}

1358

else

1359

{

1360

read_set->reset(i);

1361

}

1362

}

4786

1363

}

4787

1364

4788

1365

uint32_t Table::find_shortest_key(const key_map *usable_keys)

4789

1366

{

4790

1367

uint32_t min_length= UINT32_MAX;

4791

1368

uint32_t best= MAX_KEY;

4792

if (!usable_keys->is_clear_all())

1369

if (usable_keys->any())

4793

1370

{

4794

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

1371

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

4795

1372

{

4796

if (usable_keys->is_set(nr))

1373

if (usable_keys->test(nr))

4797

1374

{

4798

1375

if (key_info[nr].key_length < min_length)

4799

1376

{

4818

1395

{

4819

1396

for (; *ptr ; ptr++)

4820

1397

{

4821

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

1398

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

4822

1399

return true;

4823

1400

}

4824

1401

return false;

4825

1402

}

4826

1403

4827

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

4828

4829

bool Table::compare_record()

4830

{

4831

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

4832

return cmp_record(this, record[1]);

1404

/**

1405

True if the table's input and output record buffers are comparable using

1406

compare_records(TABLE*).

1407

1408

bool Table::records_are_comparable()

1409

{

1410

return ((getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) == 0) ||

1411

write_set->is_subset_of(*read_set));

1412

}

1413

1414

/**

1415

Compares the input and outbut record buffers of the table to see if a row

1416

has changed. The algorithm iterates over updated columns and if they are

1417

nullable compares NULL bits in the buffer before comparing actual

1418

data. Special care must be taken to compare only the relevant NULL bits and

1419

mask out all others as they may be undefined. The storage engine will not

1420

and should not touch them.

1421

1422

@param table The table to evaluate.

1423

1424

@return true if row has changed.

1425

@return false otherwise.

1426

1427

bool Table::compare_records()

1428

{

1429

if (getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) != 0)

1430

{

1431

1432

Storage engine may not have read all columns of the record. Fields

1433

(including NULL bits) not in the write_set may not have been read and

1434

can therefore not be compared.

1435

1436

for (Field **ptr= this->field ; *ptr != NULL; ptr++)

1437

{

1438

Field *f= *ptr;

1439

if (write_set->test(f->position()))

1440

{

1441

if (f->real_maybe_null())

1442

{

1443

unsigned char null_byte_index= f->null_ptr - record[0];

1444

1445

if (((record[0][null_byte_index]) & f->null_bit) !=

1446

((record[1][null_byte_index]) & f->null_bit))

1447

return true;

1448

}

1449

if (f->cmp_binary_offset(getShare()->rec_buff_length))

1450

return true;

1451

}

1452

}

1453

return false;

1454

}

1455

1456

1457

The storage engine has read all columns, so it's safe to compare all bits

1458

including those not in the write_set. This is cheaper than the

1459

field-by-field comparison done above.

1460

1461

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

1462

// Fixed-size record: do bitwise comparison of the records

1463

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

1464

4833

1465

/* Compare null bits */

4834

if (memcmp(null_flags,

4835

null_flags + s->rec_buff_length,

4836

s->null_bytes))

4837

return true; // Diff in NULL value

1466

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

1467

return true; /* Diff in NULL value */

1468

4838

1469

/* Compare updated fields */

4839

1470

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

4840

1471

{

4841

if (bitmap_is_set(write_set, (*ptr)->field_index) &&

4842

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

1472

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

1473

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

4843

1474

return true;

4844

1475

}

4845

1476

return false;

4846

1477

}

4847

1478

4848

4849

4850

1479

1480

* Store a record from previous record into next

1481

1482

1483

void Table::storeRecord()

1484

{

1485

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

1486

}

1487

1488

1489

* Store a record as an insert

1490

1491

1492

void Table::storeRecordAsInsert()

1493

{

1494

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

1495

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

1496

}

1497

1498

1499

* Store a record with default values

1500

1501

1502

void Table::storeRecordAsDefault()

1503

{

1504

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

1505

}

1506

1507

1508

* Restore a record from previous record into next

1509

1510

1511

void Table::restoreRecord()

1512

{

1513

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

1514

}

1515

1516

1517

* Restore a record with default values

1518

1519

1520

void Table::restoreRecordAsDefault()

1521

{

1522

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

1523

}

1524

1525

1526

* Empty a record

1527

1528

1529

void Table::emptyRecord()

1530

{

1531

restoreRecordAsDefault();

1532

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

1533

}

1534

1535

Table::Table() :

1536

field(NULL),

1537

cursor(NULL),

1538

next(NULL),

1539

prev(NULL),

1540

read_set(NULL),

1541

write_set(NULL),

1542

tablenr(0),

1543

db_stat(0),

1544

def_read_set(),

1545

def_write_set(),

1546

tmp_set(),

1547

in_use(NULL),

1548

key_info(NULL),

1549

next_number_field(NULL),

1550

found_next_number_field(NULL),

1551

timestamp_field(NULL),

1552

pos_in_table_list(NULL),

1553

group(NULL),

1554

null_flags(NULL),

1555

lock_position(0),

1556

lock_data_start(0),

1557

lock_count(0),

1558

used_fields(0),

1559

status(0),

1560

derived_select_number(0),

1561

current_lock(F_UNLCK),

1562

copy_blobs(false),

1563

maybe_null(false),

1564

null_row(false),

1565

force_index(false),

1566

distinct(false),

1567

const_table(false),

1568

no_rows(false),

1569

key_read(false),

1570

no_keyread(false),

1571

open_placeholder(false),

1572

locked_by_name(false),

1573

no_cache(false),

1574

auto_increment_field_not_null(false),

1575

alias_name_used(false),

1576

query_id(0),

1577

quick_condition_rows(0),

1578

timestamp_field_type(TIMESTAMP_NO_AUTO_SET),

1579

map(0),

1580

quick_rows(),

1581

const_key_parts(),

1582

quick_key_parts(),

1583

quick_n_ranges()

1584

{

1585

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

1586

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

1587

}

4851

1588

4852

1589

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

4853

1590

The different ways to read a record

4854

1591

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

4855

1592

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

4856

1593

4857

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

1594

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

4858

1595

4859

1596

int Table::report_error(int error)

4860

1597

{

4868

1605

print them to the .err log

4869

1606

4870

1607

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

4871

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

4872

error, s->path.str);

4873

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

1608

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

1609

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

1610

print_error(error, MYF(0));

4874

1611

4875

1612

return 1;

4876

1613

}

4877

1614

4878

1615

1616

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

1617

{

1618

used_fields= 0;

1619

const_table= 0;

1620

null_row= 0;

1621

status= STATUS_NO_RECORD;

1622

maybe_null= table_list->outer_join;

1623

TableList *embedding= table_list->getEmbedding();

1624

while (!maybe_null && embedding)

1625

{

1626

maybe_null= embedding->outer_join;

1627

embedding= embedding->getEmbedding();

1628

}

1629

tablenr= table_number;

1630

map= (table_map) 1 << table_number;

1631

force_index= table_list->force_index;

1632

covering_keys= getShare()->keys_for_keyread;

1633

merge_keys.reset();

1634

}

1635

1636

1637

void Table::fill_item_list(List<Item>& items) const

1638

{

1639

1640

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

1641

are fixed in Item_field constructor.

1642

1643

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

1644

items.push_back(new Item_field(*ptr));

1645

}

1646

1647

1648

void Table::filesort_free_buffers(bool full)

1649

{

1650

free(sort.record_pointers);

1651

sort.record_pointers=0;

1652

if (full)

1653

{

1654

free(sort.sort_keys);

1655

sort.sort_keys= 0;

1656

free(sort.buffpek);

1657

sort.buffpek= 0;

1658

sort.buffpek_len= 0;

1659

}

1660

free(sort.addon_buf);

1661

free(sort.addon_field);

1662

sort.addon_buf=0;

1663

sort.addon_field=0;

1664

}

1665

4879

1666

4880

Calculate data for each virtual field marked for write in the

4881

corresponding column map.

4882

4883

SYNOPSIS

4884

update_virtual_fields_marked_for_write()

4885

table The Table object

4886

ignore_stored Indication whether physically stored virtual

4887

fields do not need updating.

4888

This value is false when during INSERT and UPDATE

4889

and true in all other cases.

4890

4891

RETURN

4892

0 - Success

4893

>0 - Error occurred during the generation/calculation of a virtual field value

4894

1667

Is this instance of the table should be reopen or represents a name-lock?

4895

1668

4896

4897

int update_virtual_fields_marked_for_write(Table *table,

4898

bool ignore_stored)

4899

{

4900

Field **vfield_ptr, *vfield;

4901

int error= 0;

4902

if ((not table) or (not table->vfield))

4903

return(0);

4904

4905

/* Iterate over virtual fields in the table */

4906

for (vfield_ptr= table->vfield; *vfield_ptr; vfield_ptr++)

4907

{

4908

vfield= (*vfield_ptr);

4909

assert(vfield->vcol_info && vfield->vcol_info->expr_item);

4910

4911

Only update those fields that are marked in the write_set bitmap

4912

and not _already_ physically stored in the database.

4913

4914

if (bitmap_is_set(table->write_set, vfield->field_index) &&

4915

(not (ignore_stored && vfield->is_stored))

4916

)

4917

{

4918

/* Generate the actual value of the virtual fields */

4919

error= vfield->vcol_info->expr_item->save_in_field(vfield, 0);

4920

}

4921

}

4922

return(0);

4923

}

4924

4925

4926

void setup_table_map(Table *table, TableList *table_list, uint32_t tablenr)

4927

{

4928

table->used_fields= 0;

4929

table->const_table= 0;

4930

table->null_row= 0;

4931

table->status= STATUS_NO_RECORD;

4932

table->maybe_null= table_list->outer_join;

4933

TableList *embedding= table_list->embedding;

4934

while (!table->maybe_null && embedding)

4935

{

4936

table->maybe_null= embedding->outer_join;

4937

embedding= embedding->embedding;

4938

}

4939

table->tablenr= tablenr;

4940

table->map= (table_map) 1 << tablenr;

4941

table->force_index= table_list->force_index;

4942

table->covering_keys= table->s->keys_for_keyread;

4943

table->merge_keys.clear_all();

4944

}

4945

4946

4947

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

4948

** Instansiate templates

4949

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

4950

4951

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

4952

template class List<String>;

4953

template class List_iterator<String>;

4954

#endif

1669

bool Table::needs_reopen_or_name_lock() const

1670

{

1671

return getShare()->getVersion() != g_refresh_version;

1672

}

1673

1674

uint32_t Table::index_flags(uint32_t idx) const

1675

{

1676

return getShare()->getEngine()->index_flags(getShare()->getKeyInfo(idx).algorithm);

1677

}

1678

1679

void Table::print_error(int error, myf errflag) const

1680

{

1681

getShare()->getEngine()->print_error(error, errflag, *this);

1682

}

1683

1684

} /* namespace drizzled */

Older »