~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

Committer: Padraig O'Sullivan
Date: 2010-10-02 19:49:54 UTC
mto: (1823.1.1 trunk-drizzle)
mto: This revision was merged to the branch mainline in revision 1824.
Revision ID: osullivan.padraig@gmail.com-20101002194954-2sqp7a6szfgdl11l

Removal of all MyBitmap from the code base. Compiles but test failures exist now.

Show diffs side-by-side

added added

removed removed

drizzled/table.cc

334

a tmp_set bitmap to be used by things like filesort.

335

336

337

void Table::setup_tmp_table_column_bitmaps(unsigned char *bitmaps)

337

void Table::setup_tmp_table_column_bitmaps()

338

{

339

uint32_t field_count= s->sizeFields();

340

341

this->def_read_set.init((my_bitmap_map*) bitmaps, field_count);

342

this->tmp_set.init((my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count);

341

this->def_read_set.resize(field_count);

342

this->tmp_set.resize(field_count);

343

344

/* write_set and all_set are copies of read_set */

345

def_write_set= def_read_set;

346

s->all_set= def_read_set;

347

this->getMutableShare()->all_set.setAll();

347

this->getMutableShare()->all_set.set();

348

default_column_bitmaps();

349

}

350

452

bitmap_clear_all(&table->def_read_set);

453

bitmap_clear_all(&table->def_write_set);

454

455

def_read_set.clearAll();

456

def_write_set.clearAll();

457

column_bitmaps_set(&def_read_set, &def_write_set);

455

def_read_set.reset();

456

def_write_set.reset();

457

column_bitmaps_set(def_read_set, def_write_set);

458

}

459

460

491

492

void Table::mark_columns_used_by_index(uint32_t index)

493

{

494

MyBitmap *bitmap= &tmp_set;

494

boost::dynamic_bitset<> *bitmap= &tmp_set;

495

496

(void) cursor->extra(HA_EXTRA_KEYREAD);

497

bitmap->clearAll();

498

mark_columns_used_by_index_no_reset(index, bitmap);

499

column_bitmaps_set(bitmap, bitmap);

497

bitmap->reset();

498

mark_columns_used_by_index_no_reset(index, *bitmap);

499

column_bitmaps_set(*bitmap, *bitmap);

500

return;

501

}

502

528

529

void Table::mark_columns_used_by_index_no_reset(uint32_t index)

530

{

531

mark_columns_used_by_index_no_reset(index, read_set);

532

}

533

534

void Table::mark_columns_used_by_index_no_reset(uint32_t index,

535

MyBitmap *bitmap)

536

{

537

KeyPartInfo *key_part= key_info[index].key_part;

538

KeyPartInfo *key_part_end= (key_part +

539

key_info[index].key_parts);

540

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

541

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

531

mark_columns_used_by_index_no_reset(index, *read_set);

542

532

}

543

533

544

534

818

808

bool using_unique_constraint= false;

819

809

bool use_packed_rows= true;

820

810

bool not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);

821

unsigned char *pos, *group_buff, *bitmaps;

811

unsigned char *pos, *group_buff;

822

812

unsigned char *null_flags;

823

813

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

824

814

CopyField *copy= 0;

882

872

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

883

873

&group_buff, (group && ! using_unique_constraint ?

884

874

param->group_length : 0),

885

&bitmaps, bitmap_buffer_size(field_count)*2,

886

875

NULL))

887

876

{

888

877

return NULL;

1134

1123

copy_func[0]= 0; // End marker

1135

1124

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

1136

1125

1137

table->setup_tmp_table_column_bitmaps(bitmaps);

1126

table->setup_tmp_table_column_bitmaps();

1138

1127

1139

1128

recinfo=param->start_recinfo;

1140

1129

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

1467

1456

uint32_t record_length= 0;

1468

1457

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

1469

1458

uint32_t null_pack_length; /* NULL representation array length */

1470

unsigned char *bitmaps;

1471

1459

Table *table;

1472

1460

1473

1461

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

1474

1475

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

1476

&bitmaps, bitmap_buffer_size(field_count)*2,

1477

NULL))

1478

{

1479

return NULL;

1480

}

1481

1482

1462

table= share->getTable();

1483

1463

share->setFields(field_count + 1);

1484

1464

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

1486

1466

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

1487

1467

share->fields= field_count;

1488

1468

share->blob_ptr_size= portable_sizeof_char_ptr;

1489

table->setup_tmp_table_column_bitmaps(bitmaps);

1469

table->setup_tmp_table_column_bitmaps();

1490

1470

1491

1471

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

1492

1472

1766

1746

{

1767

1747

if (read_set_arg.test(i))

1768

1748

{

1769

read_set->setBit(i);

1749

read_set->set(i);

1770

1750

}

1771

1751

}

1772

1752

/* set the write set */

1774

1754

{

1775

1755

if (write_set_arg.test(i))

1776

1756

{

1777

write_set->setBit(i);

1757

write_set->set(i);

1778

1758

}

1779

1759

}

1780

1760

}

1781

1761

1782

my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)

1762

1763

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

1783

1764

{

1784

my_bitmap_map *old= bitmap->getBitmap();

1785

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

1765

const boost::dynamic_bitset<> old= in_map;

1766

in_map= s->all_set;

1786

1767

return old;

1787

1768

}

1788

1769

1789

void Table::restore_column_map(my_bitmap_map *old)

1770

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

1790

1771

{

1791

read_set->setBitmap(old);

1772

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

1773

{

1774

if (old.test(i))

1775

{

1776

read_set->set(i);

1777

}

1778

else

1779

{

1780

read_set->reset(i);

1781

}

1782

}

1792

1783

}

1793

1784

1794

1785

uint32_t Table::find_shortest_key(const key_map *usable_keys)

1917

1908

write_set(NULL),

1918

1909

tablenr(0),

1919

1910

db_stat(0),

1911

def_read_set(),

1912

def_write_set(),

1913

tmp_set(),

1920

1914

in_use(NULL),

1921

1915

key_info(NULL),

1922

1916

next_number_field(NULL),

1953

1947

map(0),

1954

1948

is_placeholder_created(0)

1955

1949

{

1956

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

1957

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

1958

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

1959

1960

1950

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

1961

1951

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

1962

1952

Older »