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

1085

1110

use_packed_rows= 1;

1086

1111

1087

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

1112

share->setRecordLength(reclength);

1088

1113

{

1089

1114

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

1090

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

1091

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

1115

share->rec_buff_length= alloc_length;

1116

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

1117

table->alloc_root(alloc_length*2)))

1092

1118

{

1093

1119

goto err;

1094

1120

}

1095

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

1096

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

1121

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

1122

share->resizeDefaultValues(alloc_length);

1097

1123

}

1098

1124

copy_func[0]= 0; // End marker

1099

1125

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

1100

1126

1101

table->setup_tmp_table_column_bitmaps();

1127

table->setup_tmp_table_column_bitmaps(bitmaps);

1102

1128

1103

1129

recinfo=param->start_recinfo;

1104

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

1105

pos=table->getInsertRecord()+ null_pack_length;

1130

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

1131

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

1106

1132

if (null_pack_length)

1107

1133

{

1108

1134

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

1111

1137

recinfo++;

1112

1138

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

1113

1139

1114

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

1115

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

1116

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

1140

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

1141

share->null_fields= null_count+ hidden_null_count;

1142

share->null_bytes= null_pack_length;

1117

1143

}

1118

1144

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

1119

1145

hidden_field_count=param->hidden_field_count;

1164

1190

ptrdiff_t diff;

1165

1191

Field *orig_field= default_field[i];

1166

1192

/* Get the value from default_values */

1167

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

1193

diff= (ptrdiff_t) (orig_field->table->getDefaultValues() - orig_field->table->record[0]);

1168

1194

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

1169

1195

if (orig_field->is_real_null())

1170

1196

field->set_null();

1173

1199

field->set_notnull();

1174

1200

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

1175

1201

}

1176

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

1202

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

1177

1203

}

1178

1204

1179

1205

if (from_field[i])

1192

1218

recinfo->type=FIELD_NORMAL;

1193

1219

if (!--hidden_field_count)

1194

1220

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

1221

1222

// fix table name in field entry

1223

field->table_name= &table->alias;

1195

1224

}

1196

1225

1197

1226

param->copy_field_end=copy;

1204

1233

}

1205

1234

else

1206

1235

{

1207

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

1236

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

1208

1237

min(session->variables.tmp_table_size,

1209

1238

session->variables.max_heap_table_size) :

1210

1239

session->variables.tmp_table_size) /

1211

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

1240

share->getRecordLength());

1212

1241

}

1213

1242

1214

1243

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

1218

1247

1219

1248

set_if_smaller(max_rows, rows_limit);

1220

1249

1221

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

1250

share->setMaxRows(max_rows);

1222

1251

1223

1252

param->end_write_records= rows_limit;

1224

1253

1228

1257

{

1229

1258

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

1230

1259

param->group_buff=group_buff;

1231

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

1232

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

1260

share->keys=1;

1261

share->uniques= test(using_unique_constraint);

1233

1262

table->key_info=keyinfo;

1234

1263

keyinfo->key_part=key_part_info;

1235

1264

keyinfo->flags=HA_NOSAME;

1238

1267

keyinfo->rec_per_key= 0;

1239

1268

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

1240

1269

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

1241

Order *cur_group= group;

1270

order_st *cur_group= group;

1242

1271

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

1243

1272

{

1244

1273

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

1245

1274

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

1246

1275

key_part_info->null_bit= 0;

1247

1276

key_part_info->field= field;

1248

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

1277

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

1249

1278

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

1250

1279

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

1251

1280

key_part_info->key_type=

1273

1302

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

1274

1303

key_part_info->null_bit=field->null_bit;

1275

1304

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

1276

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

1305

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

1277

1306

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

1278

1307

group_buff++; // Skipp null flag

1279

1308

}

1300

1329

indexes on blobs with arbitrary length. Such indexes cannot be

1301

1330

used for lookups.

1302

1331

1303

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

1332

share->uniques= 1;

1304

1333

}

1305

1334

null_pack_length-=hidden_null_pack_length;

1306

1335

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

1307

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

1336

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

1308

1337

table->distinct= 1;

1309

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

1338

share->keys= 1;

1310

1339

if (!(key_part_info= (KeyPartInfo*)

1311

1340

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

1312

1341

goto err;

1324

1353

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

1325

1354

when we do not use UNIQUE indexes for blobs.

1326

1355

1327

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

1356

if (null_pack_length && share->uniques)

1328

1357

{

1329

1358

key_part_info->null_bit= 0;

1330

1359

key_part_info->offset=hidden_null_pack_length;

1331

1360

key_part_info->length=null_pack_length;

1332

table->setVariableWidth();

1333

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

1361

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

1334

1362

(uint32_t) key_part_info->length,

1335

1363

1336

1364

(unsigned char*) 0,

1337

1365

(uint32_t) 0,

1338

1366

NULL,

1367

table->getMutableShare(),

1339

1368

&my_charset_bin);

1340

1369

if (!key_part_info->field)

1341

1370

goto err;

1351

1380

{

1352

1381

key_part_info->null_bit= 0;

1353

1382

key_part_info->field= *reg_field;

1354

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

1383

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

1355

1384

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

1356

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

1385

/* TODO:

1386

The below method of computing the key format length of the

1357

1387

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

1358

1388

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

1359

1389

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

1379

1409

1380

1410

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

1381

1411

goto err;

1382

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

1383

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

1412

share->db_record_offset= 1;

1413

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

1384

1414

{

1385

1415

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

1386

1416

&param->recinfo, select_options))

1403

1433

1404

1434

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

1405

1435

1406

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

1407

boost::dynamic_bitset<>& write_set_arg)

1408

{

1409

read_set= &read_set_arg;

1410

write_set= &write_set_arg;

1411

}

1412

1413

1414

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

1415

{

1416

const boost::dynamic_bitset<> old= in_map;

1417

in_map= getShare()->all_set;

1436

/**

1437

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

1438

list of field definitions.

1439

1440

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

1441

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

1442

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

1443

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

1444

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

1445

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

1446

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

1447

1448

@param session connection handle

1449

@param field_list list of column definitions

1450

1451

@return

1452

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

1453

1454

1455

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

1456

{

1457

uint32_t field_count= field_list.elements;

1458

uint32_t blob_count= 0;

1459

Field **field;

1460

CreateField *cdef; /* column definition */

1461

uint32_t record_length= 0;

1462

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

1463

uint32_t null_pack_length; /* NULL representation array length */

1464

unsigned char *bitmaps;

1465

Table *table;

1466

1467

TableShareInstance *share= getTemporaryShare(message::Table::INTERNAL); // This will not go into the tableshare cache, so no key is used.

1468

1469

if (! share->getMemRoot()->multi_alloc_root(0,

1470

&bitmaps, bitmap_buffer_size(field_count)*2,

1471

NULL))

1472

{

1473

return NULL;

1474

}

1475

1476

table= share->getTable();

1477

share->setFields(field_count + 1);

1478

table->setFields(share->getFields(true));

1479

field= share->getFields(true);

1480

share->blob_field.resize(field_count+1);

1481

share->fields= field_count;

1482

share->blob_ptr_size= portable_sizeof_char_ptr;

1483

table->setup_tmp_table_column_bitmaps(bitmaps);

1484

1485

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

1486

1487

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

1488

List_iterator_fast<CreateField> it(field_list);

1489

while ((cdef= it++))

1490

{

1491

*field= share->make_field(NULL,

1492

cdef->length,

1493

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

1494

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

1495

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

1496

cdef->decimals,

1497

cdef->sql_type,

1498

cdef->charset,

1499

cdef->unireg_check,

1500

cdef->interval,

1501

cdef->field_name);

1502

if (!*field)

1503

goto error;

1504

(*field)->init(table);

1505

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

1506

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

1507

null_count++;

1508

1509

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

1510

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

1511

1512

field++;

1513

}

1514

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

1515

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

1516

share->blob_fields= blob_count;

1517

1518

null_pack_length= (null_count + 7)/8;

1519

share->setRecordLength(record_length + null_pack_length);

1520

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

1521

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

1522

if (!table->record[0])

1523

goto error;

1524

1525

if (null_pack_length)

1526

{

1527

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

1528

share->null_fields= null_count;

1529

share->null_bytes= null_pack_length;

1530

}

1531

{

1532

/* Set up field pointers */

1533

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

1534

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

1535

uint32_t null_bit= 1;

1536

1537

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

1538

{

1539

Field *cur_field= *field;

1540

if ((cur_field->flags & NOT_NULL_FLAG))

1541

cur_field->move_field(field_pos);

1542

else

1543

{

1544

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

1545

null_bit<<= 1;

1546

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

1547

{

1548

++null_pos;

1549

null_bit= 1;

1550

}

1551

}

1552

cur_field->reset();

1553

1554

field_pos+= cur_field->pack_length();

1555

}

1556

}

1557

1558

return table;

1559

1560

error:

1561

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

1562

{

1563

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

1564

}

1565

return 0;

1566

}

1567

1568

bool Table::open_tmp_table()

1569

{

1570

int error;

1571

if ((error=cursor->ha_open(this, s->getTableName(),O_RDWR,

1572

HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))

1573

{

1574

print_error(error, MYF(0));

1575

db_stat= 0;

1576

return true;

1577

}

1578

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

1579

return false;

1580

}

1581

1582

1583

1584

Create MyISAM temporary table

1585

1586

SYNOPSIS

1587

create_myisam_tmp_table()

1588

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

1589

start_recinfo MyISAM's column descriptions

1590

recinfo INOUT End of MyISAM's column descriptions

1591

options Option bits

1592

1593

DESCRIPTION

1594

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

1595

assumed to have one unique index or constraint.

1596

1597

The passed array or MI_COLUMNDEF structures must have this form:

1598

1599

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

1600

when there are many nullable columns)

1601

2. Table columns

1602

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

1603

1604

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

1605

constraint.

1606

1607

RETURN

1608

false - OK

1609

true - Error

1610

1611

1612

bool Table::create_myisam_tmp_table(KeyInfo *keyinfo,

1613

MI_COLUMNDEF *start_recinfo,

1614

MI_COLUMNDEF **recinfo,

1615

uint64_t options)

1616

{

1617

int error;

1618

MI_KEYDEF keydef;

1619

MI_UNIQUEDEF uniquedef;

1620

TableShare *share= s;

1621

1622

if (share->sizeKeys())

1623

{ // Get keys for ni_create

1624

bool using_unique_constraint= false;

1625

HA_KEYSEG *seg= (HA_KEYSEG*) this->mem_root.alloc_root(sizeof(*seg) * keyinfo->key_parts);

1626

if (!seg)

1627

goto err;

1628

1629

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

1630

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

1631

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

1632

share->uniques)

1633

{

1634

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

1635

share->keys= 0;

1636

share->uniques= 1;

1637

using_unique_constraint= true;

1638

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

1639

uniquedef.keysegs=keyinfo->key_parts;

1640

uniquedef.seg=seg;

1641

uniquedef.null_are_equal=1;

1642

1643

/* Create extra column for hash value */

1644

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

1645

(*recinfo)->type= FIELD_CHECK;

1646

(*recinfo)->length=MI_UNIQUE_HASH_LENGTH;

1647

(*recinfo)++;

1648

share->setRecordLength(share->getRecordLength() + MI_UNIQUE_HASH_LENGTH);

1649

}

1650

else

1651

{

1652

/* Create an unique key */

1653

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

1654

keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;

1655

keydef.keysegs= keyinfo->key_parts;

1656

keydef.seg= seg;

1657

}

1658

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

1659

{

1660

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

1661

seg->flag= 0;

1662

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

1663

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

1664

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

1665

if (key_field->flags & BLOB_FLAG)

1666

{

1667

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

1668

HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);

1669

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

1670

- share->blob_ptr_size);

1671

seg->flag= HA_BLOB_PART;

1672

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

1673

}

1674

else

1675

{

1676

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

1677

}

1678

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

1679

{

1680

seg->null_bit= key_field->null_bit;

1681

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

1682

1683

We are using a GROUP BY on something that contains NULL

1684

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

1685

on INSERT be regarded at the same value

1686

1687

if (! using_unique_constraint)

1688

keydef.flag|= HA_NULL_ARE_EQUAL;

1689

}

1690

}

1691

}

1692

MI_CREATE_INFO create_info;

1693

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

1694

1695

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

1696

OPTION_BIG_TABLES)

1697

create_info.data_file_length= ~(uint64_t) 0;

1698

1699

if ((error=mi_create(share->getTableName(), share->sizeKeys(), &keydef,

1700

(uint32_t) (*recinfo-start_recinfo),

1701

start_recinfo,

1702

share->uniques, &uniquedef,

1703

&create_info,

1704

HA_CREATE_TMP_TABLE)))

1705

{

1706

print_error(error, MYF(0));

1707

db_stat= 0;

1708

goto err;

1709

}

1710

status_var_increment(in_use->status_var.created_tmp_disk_tables);

1711

share->db_record_offset= 1;

1712

return false;

1713

err:

1714

return true;

1715

}

1716

1717

1718

void Table::free_tmp_table(Session *session)

1719

{

1720

memory::Root own_root= mem_root;

1721

const char *save_proc_info;

1722

1723

save_proc_info= session->get_proc_info();

1724

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

1725

1726

// Release latches since this can take a long time

1727

plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);

1728

1729

if (cursor)

1730

{

1731

if (db_stat)

1732

{

1733

cursor->closeMarkForDelete(s->getTableName());

1734

}

1735

1736

TableIdentifier identifier(s->getSchemaName(), s->getTableName(), s->getTableName());

1737

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

1738

1739

delete cursor;

1740

}

1741

1742

/* free blobs */

1743

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

1744

{

1745

(*ptr)->free();

1746

}

1747

free_io_cache();

1748

1749

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

1750

session->set_proc_info(save_proc_info);

1751

}

1752

1753

my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)

1754

{

1755

my_bitmap_map *old= bitmap->getBitmap();

1756

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

1418

1757

return old;

1419

1758

}

1420

1759

1421

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

1760

void Table::restore_column_map(my_bitmap_map *old)

1422

1761

{

1423

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

1424

{

1425

if (old.test(i))

1426

{

1427

read_set->set(i);

1428

}

1429

else

1430

{

1431

read_set->reset(i);

1432

}

1433

}

1762

read_set->setBitmap(old);

1434

1763

}

1435

1764

1436

1765

uint32_t Table::find_shortest_key(const key_map *usable_keys)

1439

1768

uint32_t best= MAX_KEY;

1440

1769

if (usable_keys->any())

1441

1770

{

1442

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

1771

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

1443

1772

{

1444

1773

if (usable_keys->test(nr))

1445

1774

{

1466

1795

{

1467

1796

for (; *ptr ; ptr++)

1468

1797

{

1469

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

1798

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

1470

1799

return true;

1471

1800

}

1472

1801

return false;

1473

1802

}

1474

1803

1475

/**

1476

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

1477

compare_records(TABLE*).

1478

1479

bool Table::records_are_comparable()

1480

{

1481

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

1482

write_set->is_subset_of(*read_set));

1483

}

1484

1485

/**

1486

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

1487

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

1488

nullable compares NULL bits in the buffer before comparing actual

1489

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

1490

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

1491

and should not touch them.

1492

1493

@param table The table to evaluate.

1494

1495

@return true if row has changed.

1496

@return false otherwise.

1497

1498

bool Table::compare_records()

1499

{

1500

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

1501

{

1502

1503

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

1504

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

1505

can therefore not be compared.

1506

1507

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

1508

{

1509

Field *f= *ptr;

1510

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

1511

{

1512

if (f->real_maybe_null())

1513

{

1514

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

1515

1516

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

1517

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

1518

return true;

1519

}

1520

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

1521

return true;

1522

}

1523

}

1524

return false;

1525

}

1526

1527

1528

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

1529

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

1530

field-by-field comparison done above.

1531

1532

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

1533

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

1534

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

1535

1804

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

1805

1806

bool Table::compare_record()

1807

{

1808

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

1809

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

1810

1536

1811

/* Compare null bits */

1537

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

1812

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

1538

1813

return true; /* Diff in NULL value */

1539

1814

1540

1815

/* Compare updated fields */

1541

1816

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

1542

1817

{

1543

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

1544

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

1818

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

1819

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

1545

1820

return true;

1546

1821

}

1547

1822

return false;

1553

1828

1554

1829

void Table::storeRecord()

1555

1830

{

1556

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

1831

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

1557

1832

}

1558

1833

1559

1834

1562

1837

1563

1838

void Table::storeRecordAsInsert()

1564

1839

{

1565

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

1566

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

1840

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

1567

1841

}

1568

1842

1569

1843

1572

1846

1573

1847

void Table::storeRecordAsDefault()

1574

1848

{

1575

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

1849

memcpy(s->getDefaultValues(), record[0], (size_t) s->getRecordLength());

1576

1850

}

1577

1851

1578

1852

1581

1855

1582

1856

void Table::restoreRecord()

1583

1857

{

1584

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

1858

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

1585

1859

}

1586

1860

1587

1861

1590

1864

1591

1865

void Table::restoreRecordAsDefault()

1592

1866

{

1593

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

1867

memcpy(record[0], s->getDefaultValues(), (size_t) s->getRecordLength());

1594

1868

}

1595

1869

1596

1870

1600

1874

void Table::emptyRecord()

1601

1875

{

1602

1876

restoreRecordAsDefault();

1603

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

1877

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

1604

1878

}

1605

1879

1606

1880

Table::Table() :

1881

s(NULL),

1607

1882

field(NULL),

1608

1883

cursor(NULL),

1609

1884

next(NULL),

1612

1887

write_set(NULL),

1613

1888

tablenr(0),

1614

1889

db_stat(0),

1615

def_read_set(),

1616

def_write_set(),

1617

tmp_set(),

1618

1890

in_use(NULL),

1891

insert_values(NULL),

1619

1892

key_info(NULL),

1620

1893

next_number_field(NULL),

1621

1894

found_next_number_field(NULL),

1622

1895

timestamp_field(NULL),

1623

1896

pos_in_table_list(NULL),

1624

1897

group(NULL),

1898

alias(NULL),

1625

1899

null_flags(NULL),

1626

1900

lock_position(0),

1627

1901

lock_data_start(0),

1647

1921

query_id(0),

1648

1922

quick_condition_rows(0),

1649

1923

timestamp_field_type(TIMESTAMP_NO_AUTO_SET),

1650

map(0)

1924

map(0),

1925

is_placeholder_created(0)

1651

1926

{

1927

memset(&def_read_set, 0, sizeof(MyBitmap)); /**< Default read set of columns */

1928

memset(&def_write_set, 0, sizeof(MyBitmap)); /**< Default write set of columns */

1929

memset(&tmp_set, 0, sizeof(MyBitmap)); /* Not sure about this... */

1930

1652

1931

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

1653

1932

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

1654

1933

1666

1945

1667

1946

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

1668

1947

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

1948

1949

memset(&mem_root, 0, sizeof(memory::Root));

1950

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

1669

1951

}

1670

1952

1671

1953

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

1688

1970

1689

1971

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

1690

1972

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

1691

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

1973

error, s->getPath());

1692

1974

print_error(error, MYF(0));

1693

1975

1694

1976

return 1;

1702

1984

null_row= 0;

1703

1985

status= STATUS_NO_RECORD;

1704

1986

maybe_null= table_list->outer_join;

1705

TableList *embedding= table_list->getEmbedding();

1987

TableList *embedding= table_list->embedding;

1706

1988

while (!maybe_null && embedding)

1707

1989

{

1708

1990

maybe_null= embedding->outer_join;

1709

embedding= embedding->getEmbedding();

1991

embedding= embedding->embedding;

1710

1992

}

1711

1993

tablenr= table_number;

1712

1994

map= (table_map) 1 << table_number;

1713

1995

force_index= table_list->force_index;

1714

covering_keys= getShare()->keys_for_keyread;

1996

covering_keys= s->keys_for_keyread;

1715

1997

merge_keys.reset();

1716

1998

}

1717

1999

1731

2013

return false;

1732

2014

}

1733

2015

1734

1735

void Table::filesort_free_buffers(bool full)

1736

{

1737

if (sort.record_pointers)

1738

{

1739

free((unsigned char*) sort.record_pointers);

1740

sort.record_pointers=0;

1741

}

1742

if (full)

1743

{

1744

if (sort.sort_keys )

1745

{

1746

if ((unsigned char*) sort.sort_keys)

1747

free((unsigned char*) sort.sort_keys);

1748

sort.sort_keys= 0;

1749

}

1750

if (sort.buffpek)

1751

{

1752

if ((unsigned char*) sort.buffpek)

1753

free((unsigned char*) sort.buffpek);

1754

sort.buffpek= 0;

1755

sort.buffpek_len= 0;

1756

}

1757

}

1758

1759

if (sort.addon_buf)

1760

{

1761

free((char *) sort.addon_buf);

1762

free((char *) sort.addon_field);

1763

sort.addon_buf=0;

1764

sort.addon_field=0;

1765

}

1766

}

1767

1768

2016

} /* namespace drizzled */

Older »