~drizzle-trunk/drizzle/development

printf("index_init %s index %d cols req=%d/%d read_bits=%X write_bits=%X index_bits=%X converage=%d\n", pb_open_tab->ot_table->tab_name->ps_path, (int) idx, pb_open_tab->ot_cols_req, table->read_set->MX_BIT_SIZE(), (int) *table->read_set->bitmap, (int) *table->write_set->bitmap, (int) *ind->mi_col_map.bitmap, (int) (MX_BIT_IS_SUBSET(table->read_set, &ind->mi_col_map) != 0));

3346

3374

XT_DISABLED_TRACE(("search tx=%d val=%d err=%d\n", (int) pb_open_tab->ot_thread->st_xact_data->xd_start_xn_id, (int) XT_GET_DISK_4(key), err));

3347

3375

done:

3348

3376

if (err)

3349

getTable()->status = STATUS_NOT_FOUND;

3377

table->status = STATUS_NOT_FOUND;

3350

3378

else {

3351

3379

pb_open_tab->ot_thread->st_statistics.st_row_select++;

3352

getTable()->status = 0;

3380

table->status = 0;

3353

3381

}

3354

3382

return err;

3355

3383

}

3407

3435

#endif

3408

3436

done:

3409

3437

if (err)

3410

getTable()->status = STATUS_NOT_FOUND;

3438

table->status = STATUS_NOT_FOUND;

3411

3439

else {

3412

3440

pb_open_tab->ot_thread->st_statistics.st_row_select++;

3413

getTable()->status = 0;

3441

table->status = 0;

3414

3442

}

3415

3443

XT_RETURN(err);

3416

3444

}

3461

3489

#endif

3462

3490

done:

3463

3491

if (err)

3464

getTable()->status = STATUS_NOT_FOUND;

3492

table->status = STATUS_NOT_FOUND;

3465

3493

else {

3466

3494

pb_open_tab->ot_thread->st_statistics.st_row_select++;

3467

getTable()->status = 0;

3495

table->status = 0;

3468

3496

}

3469

3497

XT_RETURN(err);

3470

3498

}

3499

3527

#endif

3500

3528

done:

3501

3529

if (err)

3502

getTable()->status = STATUS_NOT_FOUND;

3530

table->status = STATUS_NOT_FOUND;

3503

3531

else {

3504

3532

pb_open_tab->ot_thread->st_statistics.st_row_select++;

3505

getTable()->status = 0;

3533

table->status = 0;

3506

3534

}

3507

3535

XT_RETURN(err);

3508

3536

}

3552

3580

#endif

3553

3581

done:

3554

3582

if (err)

3555

getTable()->status = STATUS_NOT_FOUND;

3583

table->status = STATUS_NOT_FOUND;

3556

3584

else {

3557

3585

pb_open_tab->ot_thread->st_statistics.st_row_select++;

3558

getTable()->status = 0;

3586

table->status = 0;

3559

3587

}

3560

3588

XT_RETURN(err);

3561

3589

}

3598

3626

#endif

3599

3627

done:

3600

3628

if (err)

3601

getTable()->status = STATUS_NOT_FOUND;

3629

table->status = STATUS_NOT_FOUND;

3602

3630

else {

3603

3631

pb_open_tab->ot_thread->st_statistics.st_row_select++;

3604

getTable()->status = 0;

3632

table->status = 0;

3605

3633

}

3606

3634

XT_RETURN(err);

3607

3635

}

3645

3673

3646

3674

/* The number of columns required: */

3647

3675

if (pb_open_tab->ot_is_modify) {

3648

pb_open_tab->ot_cols_req = getTable()->read_set->MX_BIT_SIZE();

3676

pb_open_tab->ot_cols_req = table->read_set->MX_BIT_SIZE();

3649

3677

/* {START-STAT-HACK} previously position of start statement hack,

3650

3678

* previous comment to code below: */

3651

3679

/* Start a statement based transaction as soon

3655

3683

}

3656

3684

else {

3657

3685

//pb_open_tab->ot_cols_req = ha_get_max_bit(table->read_set);

3658

pb_open_tab->ot_cols_req = getTable()->read_set->MX_BIT_SIZE();

3686

pb_open_tab->ot_cols_req = table->read_set->MX_BIT_SIZE();

3659

3687

3660

3688

3661

3689

* in case of queries like SELECT COUNT(*) FROM t

3725

3753

err = HA_ERR_END_OF_FILE;

3726

3754

3727

3755

if (err)

3728

getTable()->status = STATUS_NOT_FOUND;

3756

table->status = STATUS_NOT_FOUND;

3729

3757

else {

3730

3758

pb_open_tab->ot_thread->st_statistics.st_row_select++;

3731

getTable()->status = 0;

3759

table->status = 0;

3732

3760

}

3733

3761

XT_RETURN(err);

3734

3762

}

3800

3828

}

3801

3829

3802

3830

if (err)

3803

getTable()->status = STATUS_NOT_FOUND;

3831

table->status = STATUS_NOT_FOUND;

3804

3832

else {

3805

3833

pb_open_tab->ot_thread->st_statistics.st_row_select++;

3806

getTable()->status = 0;

3834

table->status = 0;

3807

3835

}

3808

3836

XT_RETURN(err);

3809

3837

}

3885

3913

3886

3914

if ((ot = pb_open_tab)) {

3887

3915

if (flag & HA_STATUS_VARIABLE) {

3888

3889

3890

3916

/* {FREE-ROWS-BAD}

3891

3917

* Free row count is not reliable, so ignore it.

3892

3918

* The problem is if tab_row_fnum > tab_row_eof_id - 1 then

3901

3927

* #1 0x0022e1f1 in make_sortkey at filesort.cc:769

3902

3928

* #2 0x0022f1cf in find_all_keys at filesort.cc:619

3903

3929

* #3 0x00230eec in filesort at filesort.cc:243

3904

* #4 0x001b9d89 in update_query at sql_update.cc:415

3930

* #4 0x001b9d89 in mysql_update at sql_update.cc:415

3905

3931

* #5 0x0010db12 in mysql_execute_command at sql_parse.cc:2959

3906

3932

* #6 0x0011480d in mysql_parse at sql_parse.cc:5787

3907

3933

* #7 0x00115afb in dispatch_command at sql_parse.cc:1200

3913

3939

* the actual number of vectors. But it must assume that it has at

3914

3940

* least EXTRA_RECORDS vectors.

3915

3941

3916

#ifdef XT_ROW_COUNT_CORRECTED

3917

if (tab->tab_row_eof_id <= tab->tab_row_fnum ||

3918

(!tab->tab_row_free_id && tab->tab_row_fnum))

3919

xt_tab_check_free_lists(NULL, ot, false, true);

3920

stats.records = (ha_rows) tab->tab_row_eof_id - 1;

3921

if (stats.records >= tab->tab_row_fnum) {

3922

stats.deleted = tab->tab_row_fnum;

3923

stats.records -= stats.deleted;

3924

}

3925

else {

3926

stats.deleted = 0;

3927

stats.records = 2;

3928

}

3929

#else

3930

stats.deleted = /* tab->tab_row_fnum */ 0;

3931

stats.records = (ha_rows) (tab->tab_row_eof_id - 1 /* - stats.deleted */);

3932

#endif

3933

stats.data_file_length = xt_rec_id_to_rec_offset(tab, tab->tab_rec_eof_id);

3934

stats.index_file_length = xt_ind_node_to_offset(tab, tab->tab_ind_eof);

3935

stats.delete_length = tab->tab_rec_fnum * ot->ot_rec_size;

3942

stats.deleted = /* ot->ot_table->tab_row_fnum */ 0;

3943

stats.records = (ha_rows) (ot->ot_table->tab_row_eof_id - 1 /* - stats.deleted */);

3944

stats.data_file_length = xt_rec_id_to_rec_offset(ot->ot_table, ot->ot_table->tab_rec_eof_id);

3945

stats.index_file_length = xt_ind_node_to_offset(ot->ot_table, ot->ot_table->tab_ind_eof);

3946

stats.delete_length = ot->ot_table->tab_rec_fnum * ot->ot_rec_size;

3936

3947

//check_time = info.check_time;

3937

3948

stats.mean_rec_length = (ulong) ot->ot_rec_size;

3938

3949

}

3939

3950

3940

#if 0 // Commented out, I am pretty sure this will blow up on someone since the global share should be treated as being non-mutable

3941

3951

if (flag & HA_STATUS_CONST) {

3942

3952

ha_rows rec_per_key;

3943

3953

XTIndexPtr ind;

3950

3960

//share->db_options_in_use = info.options;

3951

3961

stats.block_size = XT_INDEX_PAGE_SIZE;

3952

3962

3963

#ifdef DRIZZLED

3953

3964

if (share->getType() == message::Table::STANDARD)

3965

#else

3966

if (share->tmp_table == NO_TMP_TABLE)

3967

#endif

3954

3968

#ifdef DRIZZLED

3955

3969

#define WHICH_MUTEX mutex

3956

3970

#elif MYSQL_VERSION_ID >= 50404

3977

3991

#ifdef MY_PTHREAD_FASTMUTEX

3978

3992

my_pthread_fastmutex_lock(&share->WHICH_MUTEX);

3979

3993

#else

3980

share->lock();

3994

pthread_mutex_lock(&share->WHICH_MUTEX);

3981

3995

#endif

3982

3996

3983

3997

#endif // SAFE_MUTEX

4013

4027

#ifdef MY_PTHREAD_FASTMUTEX

4014

4028

pthread_mutex_unlock(&share->WHICH_MUTEX.mutex);

4015

4029

#else

4016

share->unlock();

4030

pthread_mutex_unlock(&share->WHICH_MUTEX);

4017

4031

#endif

4018

4032

#endif

4019

4033

4030

4044

index_file_name = info.index_file_name;

4031

4045

4032

4046

}

4033

#endif // if(0)

4034

4047

4035

4048

if (flag & HA_STATUS_ERRKEY)

4036

4049

errkey = ot->ot_err_index_no;

4194

4207

4195

4208

* Called from item_sum.cc by Item_func_group_concat::clear(),

4196

4209

* Item_sum_count_distinct::clear(), and Item_func_group_concat::clear().

4197

* Called from sql_delete.cc by delete_query().

4210

* Called from sql_delete.cc by mysql_delete().

4198

4211

* Called from sql_select.cc by JOIN::reinit().

4199

4212

* Called from sql_union.cc by st_select_lex_unit::exec().

4200

4213

4215

4228

* each row because it may be part of a transaction,

4216

4229

* and there may be foreign key actions.

4217

4230

4231

#ifdef DRIZZLED

4218

4232

XT_RETURN (errno = HA_ERR_WRONG_COMMAND);

4233

#else

4234

XT_RETURN (my_errno = HA_ERR_WRONG_COMMAND);

4235

#endif

4219

4236

}

4220

4237

4221

4238

if (!(self = ha_set_current_thread(thd, &err)))

4302

4319

* now agree with the MyISAM strategy.

4303

4320

4304

4321

4322

#ifdef DRIZZLED

4305

4323

int ha_pbxt::analyze(THD *thd)

4324

#else

4325

int ha_pbxt::analyze(THD *thd, HA_CHECK_OPT *XT_UNUSED(check_opt))

4326

#endif

4306

4327

{

4307

4328

int err = 0;

4308

4329

XTDatabaseHPtr db;

4347

4368

else

4348

4369

my_xn_id = db->db_xn_to_clean_id;

4349

4370

4350

while ((!db->db_sw_idle || xt_xn_is_before(db->db_xn_to_clean_id, my_xn_id)) && not (thd->getKilled())) {

4371

while ((!db->db_sw_idle || xt_xn_is_before(db->db_xn_to_clean_id, my_xn_id)) && !thd_killed(thd)) {

4351

4372

xt_busy_wait();

4352

4373

4353

4374

4384

4405

XT_RETURN(err);

4385

4406

}

4386

4407

4408

#ifndef DRIZZLED

4409

int ha_pbxt::repair(THD *XT_UNUSED(thd), HA_CHECK_OPT *XT_UNUSED(check_opt))

4410

{

4411

return(HA_ADMIN_TRY_ALTER);

4412

}

4413

4414

4415

* This is mapped to "ALTER TABLE tablename TYPE=PBXT", which rebuilds

4416

* the table in MySQL.

4417

4418

int ha_pbxt::optimize(THD *XT_UNUSED(thd), HA_CHECK_OPT *XT_UNUSED(check_opt))

4419

{

4420

return(HA_ADMIN_TRY_ALTER);

4421

}

4422

#endif

4423

4387

4424

#ifdef DEBUG

4388

4425

extern int pbxt_mysql_trace_on;

4389

4426

#endif

4390

4427

4428

#ifdef DRIZZLED

4391

4429

int ha_pbxt::check(THD* thd)

4430

#else

4431

int ha_pbxt::check(THD* thd, HA_CHECK_OPT* XT_UNUSED(check_opt))

4432

#endif

4392

4433

{

4393

4434

int err = 0;

4394

4435

XTThreadPtr self;

4551

4592

}

4552

4593

4553

4594

if (pb_share->sh_recalc_selectivity) {

4554

#ifdef XT_ROW_COUNT_CORRECTED

4555

/* {CORRECTED-ROW-COUNT} */

4556

if ((pb_share->sh_table->tab_row_eof_id - 1 - pb_share->sh_table->tab_row_fnum) >= 200)

4557

#else

4558

4595

/* {FREE-ROWS-BAD} */

4559

if ((pb_share->sh_table->tab_row_eof_id - 1 /* - pb_share->sh_table->tab_row_fnum */) >= 200)

4560

#endif

4561

{

4596

if ((pb_share->sh_table->tab_row_eof_id - 1 /* - pb_share->sh_table->tab_row_fnum */) >= 200) {

4562

4597

/* [**] */

4563

4598

pb_share->sh_recalc_selectivity = FALSE;

4564

4599

xt_ind_set_index_selectivity(pb_open_tab, self);

4565

#ifdef XT_ROW_COUNT_CORRECTED

4566

/* {CORRECTED-ROW-COUNT} */

4567

pb_share->sh_recalc_selectivity = (pb_share->sh_table->tab_row_eof_id - 1 - pb_share->sh_table->tab_row_fnum) < 150;

4568

#else

4569

4600

/* {FREE-ROWS-BAD} */

4570

4601

pb_share->sh_recalc_selectivity = (pb_share->sh_table->tab_row_eof_id - 1 /* - pb_share->sh_table->tab_row_fnum */) < 150;

4571

#endif

4572

4602

}

4573

4603

}

4574

4604

}

4617

4647

goto complete;

4618

4648

}

4619

4649

cont_(a);

4620

4621

/* Occurs if you do:

4622

* truncate table t1;

4623

* truncate table t1;

4624

4625

if (!pb_open_tab) {

4626

if ((err = reopen())) {

4627

pb_ex_in_use = 0;

4628

goto complete;

4629

}

4630

}

4631

4650

}

4632

4651

else {

4633

4652

pb_ex_in_use = 1;

4958

4977

#ifndef DRIZZLED

4959

4978

case SQLCOM_REPAIR:

4960

4979

case SQLCOM_OPTIMIZE:

4980

self->st_stat_modify = TRUE;

4961

4981

#endif

4962

self->st_stat_modify = TRUE;

4963

4982

break;

4964

4983

}

4965

4984

}

5232

5251

* during create if the table_flag HA_DROP_BEFORE_CREATE was specified for

5233

5252

* the storage engine.

5234

5253

5254

#ifdef DRIZZLED

5235

5255

int PBXTStorageEngine::doDropTable(Session &, const TableIdentifier& ident)

5236

5256

{

5237

5257

const std::string& path = ident.getPath();

5238

5258

const char *table_path = path.c_str();

5259

#else

5260

int ha_pbxt::delete_table(const char *table_path)

5261

{

5262

#endif

5239

5263

THD *thd = current_thd;

5240

5264

int err = 0;

5241

5265

XTThreadPtr self = NULL;

5327

5351

}

5328

5352

#endif

5329

5353

5330

std::string path2(ident.getPath());

5331

path2.append(DEFAULT_FILE_EXTENSION);

5332

(void)internal::my_delete(path2.c_str(), MYF(0));

5354

#ifdef DRIZZLED

5355

std::string path2(ident.getPath());

5356

path2.append(DEFAULT_FILE_EXTENSION);

5357

(void)internal::my_delete(path2.c_str(), MYF(0));

5358

#endif

5333

5359

5334

5360

return err;

5335

5361

}

5376

5402

* This function can be used to move a table from one database to

5377

5403

* another.

5378

5404

5405

#ifdef DRIZZLED

5379

5406

int PBXTStorageEngine::doRenameTable(Session&,

5380

5407

const TableIdentifier& from_ident,

5381

5408

const TableIdentifier& to_ident)

5386

5413

if (strcmp(from, to) == 0)

5387

5414

return 0;

5388

5415

5416

#else

5417

int ha_pbxt::rename_table(const char *from, const char *to)

5418

{

5419

#endif

5389

5420

THD *thd = current_thd;

5390

5421

int err = 0;

5391

5422

XTThreadPtr self;

5462

5493

pbms_completed(NULL, (err == 0));

5463

5494

#endif

5464

5495

5496

#ifdef DRIZZLED

5465

5497

if (err == 0)

5466

5498

plugin::StorageEngine::renameDefinitionFromPath(to_ident, from_ident);

5499

#endif

5467

5500

5468

5501

XT_RETURN(err);

5469

5502

}

5611

5644

try_(a) {

5612

5645

xt_ha_open_database_of_table(self, (XTPathStrPtr) table_path);

5613

5646

5614

for (uint i=0; i<table_arg.getShare()->keys; i++) {

5647

for (uint i=0; i<table_arg.s->keys; i++) {

5615

5648

if (table_arg.key_info[i].key_length > XT_INDEX_MAX_KEY_SIZE)

5616

5649

xt_throw_sulxterr(XT_CONTEXT, XT_ERR_KEY_TOO_LARGE, table_arg.key_info[i].name, (u_long) XT_INDEX_MAX_KEY_SIZE);

5617

5650

}

5628

5661

5629

5662

StorageEngine::writeDefinitionFromPath(ident, proto);

5630

5663

5631

Session::QueryString query_string(thd->getQueryString());

5632

tab_def = xt_ri_create_table(self, true, (XTPathStrPtr) table_path, const_cast<char *>(query_string->c_str()), myxt_create_table_from_table(self, table_arg.getMutableShare()), &source_dic);

5664

tab_def = xt_ri_create_table(self, true, (XTPathStrPtr) table_path, const_cast<char *>(thd->getQueryString().c_str()), myxt_create_table_from_table(self, table_arg.s), &source_dic);

5633

5665

tab_def->checkForeignKeys(self, proto.type() == message::Table::TEMPORARY);

5634

5666

5635

5667

dic.dic_table = tab_def;

5636

dic.dic_my_table = table_arg.getMutableShare();

5668

dic.dic_my_table = table_arg.s;

5637

5669

dic.dic_tab_flags = source_dic.dic_tab_flags;

5638

5670

//if (create_info.storage_media == HA_SM_MEMORY)

5639

5671

// dic.dic_tab_flags |= XT_TF_MEMORY_TABLE;

5700

5732

if (!self->st_database)

5701

5733

xt_ha_open_database_of_table(self, NULL);

5702

5734

5703

assert(!self->st_xact_data); // Check we're not called twice

5704

if (!xt_xn_begin(self)) {

5705

err = xt_ha_pbxt_thread_error_for_mysql(thd, self, /*pb_ignore_dup_key*/false);

5735

if (!xt_xn_begin(self)) {

5736

err = xt_ha_pbxt_thread_error_for_mysql(thd, self, /*pb_ignore_dup_key*/false);

5737

//pb_ex_in_use = 0;

5706

5738

}

5707

5739

5708

5740

return err;

5723

5755

return xt_ha_pbxt_thread_error_for_mysql(thd, xt_ha_thd_to_self(thd), false);

5724

5756

}

5725

5757

5726

int PBXTStorageEngine::doCommit(drizzled::Session* thd, bool real_commit)

5758

int PBXTStorageEngine::doCommit(drizzled::Session* thd, bool)

5727

5759

{

5728

5760

int err = 0;

5729

5761

XTThreadPtr self = (XTThreadPtr) *thd->getEngineData(pbxt_hton);

5730

5762

5763

bool real_commit = !session_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN);

5764

5731

5765

XT_PRINT1(self, "PBXTStorageEngine::doCommit(real_commit = %s)\n", real_commit ? "true" : "false");

5732

5766

5733

5767

if (real_commit && self) {

5738

5772

return err;

5739

5773

}

5740

5774

5741

int PBXTStorageEngine::doRollback(drizzled::Session* thd, bool real_commit)

5775

int PBXTStorageEngine::doRollback(drizzled::Session* thd, bool)

5742

5776

{

5743

5777

int err = 0;

5744

5778

XTThreadPtr self = (XTThreadPtr) *thd->getEngineData(pbxt_hton);

5745

5779

5780

bool real_commit = !session_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN);

5781

5746

5782

XT_PRINT1(self, "PBXTStorageEngine::doRollback(real_commit = %s)\n", real_commit ? "true" : "false");

5747

5783

5748

5784

if (real_commit && self) {

5944

5980

5945

5981

fk_info->referenced_table = thd_make_lex_string(thd, 0,

5946

5982

ref_tbl_name, (uint) strlen(ref_tbl_name), 1);

5947

5983

5948

5984

fk_info->referenced_key_name = NULL;

5949

5985

5950

5986

XTIndex *ix = fk->getReferenceIndexPtr();

6016

6052

}

6017

6053

#endif // DRI_IS

6018

6054

6019

#ifndef DRIZZLED

6020

6055

struct st_mysql_sys_var

6021

6056

{

6022

6057

MYSQL_PLUGIN_VAR_HEADER;

6031

6066

#define USE_CONST_SAVE

6032

6067

#endif

6033

6068

#endif

6034

#endif

6035

6069

6036

6070

#ifdef DRIZZLED

6037

6071

#define st_mysql_sys_var drizzled::drizzle_sys_var

6038

6072

#endif

6039

6073

6040

#ifndef DRIZZLED

6041

6074

#ifdef USE_CONST_SAVE

6042

6075

static void pbxt_record_cache_size_func(THD *XT_UNUSED(thd), struct st_mysql_sys_var *var, void *tgt, const void *save)

6043

6076

#else

6063

6096

#endif

6064

6097

}

6065

6098

6099

#ifndef DRIZZLED

6066

6100

struct st_mysql_storage_engine pbxt_storage_engine = {

6067

6101

MYSQL_HANDLERTON_INTERFACE_VERSION

6068

6102

};

6069

6103

static st_mysql_information_schema pbxt_statitics = {

6070

6104

MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION

6071

6105

};

6106

#endif

6072

6107

6073

6108

#if MYSQL_VERSION_ID >= 50118

6074

6109

static MYSQL_SYSVAR_STR(index_cache_size, pbxt_index_cache_size,

6201

6236

NULL

6202

6237

};

6203

6238

#endif

6204

#endif

6205

6239

6206

6240

#ifdef DRIZZLED

6207

6241

DRIZZLE_DECLARE_PLUGIN

6213

6247

"High performance, multi-versioning transactional engine",

6214

6248

PLUGIN_LICENSE_GPL,

6215

6249

pbxt_init, /* Plugin Init */

6216

NULL, /* depends */

6250

pbxt_system_variables, /* system variables */

6217

6251

NULL /* config options */

6218

6252

}

6219

6253

DRIZZLE_DECLARE_PLUGIN_END;

6231

6265

0x0001 /* 0.1 */,

6232

6266

NULL, /* status variables */

6233

6267

#if MYSQL_VERSION_ID >= 50118

6234

pbxt_system_variables, /* depends */

6268

pbxt_system_variables, /* system variables */

6235

6269

#else

6236

6270

NULL,

6237

6271

#endif

6247

6281

pbxt_exit_statistics, /* plugin deinit */

6248

6282

0x0005,

6249

6283

NULL, /* status variables */

6250

NULL, /* depends */

6284

NULL, /* system variables */

6251

6285

NULL /* config options */

6252

6286

}

6253

6287

mysql_declare_plugin_end;

Older »