~drizzle-trunk/drizzle/development

identifier::Table identifier(table->getSchemaName(), table->getTableName(), table->getInternalTmpTable() ? message::Table::INTERNAL : message::Table::STANDARD);

200

201

message::table::shared_ptr message= plugin::StorageEngine::getTableMessage(*session, identifier, true);

202

203

if (drop_temporary || not plugin::StorageEngine::doesTableExist(*session, identifier))

204

{

205

// Table was not found on disk and table can't be created from engine

206

if (if_exists)

207

{

208

push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

209

ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),

210

table->getTableName());

211

}

212

else

213

{

214

error= 1;

215

}

216

}

217

else

218

{

219

drizzled::error_t local_error;

220

221

/* Generate transaction event ONLY when we successfully drop */

222

if (plugin::StorageEngine::dropTable(*session, identifier, local_error))

223

{

224

if (message) // If we have no definition, we don't know if the table should have been replicated

225

{

226

TransactionServices &transaction_services= TransactionServices::singleton();

227

transaction_services.dropTable(*session, identifier, *message, if_exists);

228

}

229

}

230

else

231

{

232

if (local_error == HA_ERR_NO_SUCH_TABLE and if_exists)

233

{

234

error= 0;

235

session->clear_error();

236

}

237

238

if (local_error == HA_ERR_ROW_IS_REFERENCED)

239

{

240

/* the table is referenced by a foreign key constraint */

241

foreign_key_error= true;

242

}

243

error= local_error;

244

}

245

}

246

247

if (error)

248

{

249

wrong_tables.push_back(table->getTableName());

250

}

251

}

252

253

tables->unlock_table_names();

254

255

} while (0);

256

257

if (wrong_tables.size())

254

session->clear_error();

255

}

256

257

if (error == HA_ERR_ROW_IS_REFERENCED)

258

{

259

/* the table is referenced by a foreign key constraint */

260

foreign_key_error= true;

261

}

262

}

263

264

if (error == 0 || (if_exists && foreign_key_error == false))

265

{

266

ReplicationServices &replication_services= ReplicationServices::singleton();

267

replication_services.dropTable(session, string(db), string(table->table_name), if_exists);

268

}

269

270

if (error)

271

{

272

if (wrong_tables.length())

273

wrong_tables.append(',');

274

wrong_tables.append(String(table->table_name,system_charset_info));

275

}

276

}

277

278

It's safe to unlock LOCK_open: we have an exclusive lock

279

on the table name.

280

281

pthread_mutex_unlock(&LOCK_open);

282

error= 0;

283

if (wrong_tables.length())

258

284

{

259

if (not foreign_key_error)

260

{

261

std::string table_error;

262

263

for (util::string::vector::iterator iter= wrong_tables.begin();

264

iter != wrong_tables.end();

265

iter++)

266

{

267

table_error+= *iter;

268

table_error+= ',';

269

}

270

table_error.resize(table_error.size() -1);

271

285

if (!foreign_key_error)

272

286

my_printf_error(ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), MYF(0),

273

table_error.c_str());

274

}

287

wrong_tables.c_ptr());

275

288

else

276

289

{

277

290

my_message(ER_ROW_IS_REFERENCED, ER(ER_ROW_IS_REFERENCED), MYF(0));

279

292

error= 1;

280

293

}

281

294

295

pthread_mutex_lock(&LOCK_open); /* final bit in rm table lock */

296

err_with_placeholders:

297

unlock_table_names(tables, NULL);

298

pthread_mutex_unlock(&LOCK_open);

282

299

session->no_warnings_for_error= 0;

283

300

284

return error;

301

return(error);

302

}

303

304

305

306

Quickly remove a table.

307

308

SYNOPSIS

309

quick_rm_table()

310

base The plugin::StorageEngine handle.

311

db The database name.

312

table_name The table name.

313

is_tmp If the table is temp.

314

315

RETURN

316

0 OK

317

!= 0 Error

318

319

bool quick_rm_table(Session& session,

320

TableIdentifier &identifier)

321

{

322

return (plugin::StorageEngine::dropTable(session, identifier));

285

323

}

286

324

287

325

297

335

PRIMARY keys are prioritized.

298

336

299

337

300

static int sort_keys(KeyInfo *a, KeyInfo *b)

338

static int sort_keys(KEY *a, KEY *b)

301

339

{

302

340

ulong a_flags= a->flags, b_flags= b->flags;

303

341

349

387

1 Error

350

388

351

389

352

class typelib_set_member

353

{

354

public:

355

string s;

356

const CHARSET_INFO * const cs;

357

358

typelib_set_member(const char* value, unsigned int length,

359

const CHARSET_INFO * const charset)

360

: s(value, length),

361

cs(charset)

362

{}

363

};

364

365

static bool operator==(typelib_set_member const& a, typelib_set_member const& b)

366

{

367

return (my_strnncoll(a.cs,

368

(const unsigned char*)a.s.c_str(), a.s.length(),

369

(const unsigned char*)b.s.c_str(), b.s.length())==0);

370

}

371

372

373

namespace

374

{

375

class typelib_set_member_hasher

376

{

377

boost::hash<string> hasher;

378

public:

379

std::size_t operator()(const typelib_set_member& t) const

380

{

381

return hasher(t.s);

382

}

383

};

384

}

385

386

390

static bool check_duplicates_in_interval(const char *set_or_name,

387

391

const char *name, TYPELIB *typelib,

388

392

const CHARSET_INFO * const cs,

393

397

unsigned int *cur_length= typelib->type_lengths;

394

398

*dup_val_count= 0;

395

399

396

boost::unordered_set<typelib_set_member, typelib_set_member_hasher> interval_set;

397

398

for ( ; tmp.count > 0; cur_value++, cur_length++)

400

for ( ; tmp.count > 1; cur_value++, cur_length++)

399

401

{

400

402

tmp.type_names++;

401

403

tmp.type_lengths++;

402

404

tmp.count--;

403

if (interval_set.find(typelib_set_member(*cur_value, *cur_length, cs)) != interval_set.end())

405

if (find_type2(&tmp, (const char*)*cur_value, *cur_length, cs))

404

406

{

405

407

my_error(ER_DUPLICATED_VALUE_IN_TYPE, MYF(0),

406

408

name,*cur_value,set_or_name);

407

409

return 1;

408

410

}

409

else

410

interval_set.insert(typelib_set_member(*cur_value, *cur_length, cs));

411

}

412

return 0;

413

}

480

481

switch (sql_field->sql_type) {

482

case DRIZZLE_TYPE_BLOB:

483

sql_field->pack_flag= pack_length_to_packflag(sql_field->pack_length - portable_sizeof_char_ptr);

483

484

sql_field->length= 8; // Unireg field length

484

485

(*blob_columns)++;

485

486

break;

486

487

case DRIZZLE_TYPE_VARCHAR:

488

sql_field->pack_flag=0;

489

break;

487

490

case DRIZZLE_TYPE_ENUM:

488

{

489

if (check_duplicates_in_interval("ENUM",

490

sql_field->field_name,

491

sql_field->interval,

492

sql_field->charset,

493

&dup_val_count))

494

{

495

return 1;

496

}

497

}

498

break;

499

500

case DRIZZLE_TYPE_MICROTIME:

491

sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length);

492

if (check_duplicates_in_interval("ENUM",

493

sql_field->field_name,

494

sql_field->interval,

495

sql_field->charset,

496

&dup_val_count))

497

return 1;

498

break;

499

case DRIZZLE_TYPE_DATE: // Rest of string types

500

case DRIZZLE_TYPE_DATETIME:

501

case DRIZZLE_TYPE_NULL:

502

sql_field->pack_flag=f_settype((uint32_t) sql_field->sql_type);

503

break;

504

case DRIZZLE_TYPE_DECIMAL:

505

sql_field->pack_flag= 0;

506

break;

501

507

case DRIZZLE_TYPE_TIMESTAMP:

502

508

/* We should replace old TIMESTAMP fields with their newer analogs */

503

509

if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)

508

514

(*timestamps_with_niladic)++;

509

515

}

510

516

else

511

{

512

517

sql_field->unireg_check= Field::NONE;

513

}

514

518

}

515

519

else if (sql_field->unireg_check != Field::NONE)

516

{

517

520

(*timestamps_with_niladic)++;

518

}

519

521

520

522

(*timestamps)++;

521

522

break;

523

524

case DRIZZLE_TYPE_BOOLEAN:

525

case DRIZZLE_TYPE_DATE: // Rest of string types

526

case DRIZZLE_TYPE_DATETIME:

527

case DRIZZLE_TYPE_DECIMAL:

528

case DRIZZLE_TYPE_DOUBLE:

529

case DRIZZLE_TYPE_LONG:

530

case DRIZZLE_TYPE_LONGLONG:

531

case DRIZZLE_TYPE_NULL:

532

case DRIZZLE_TYPE_TIME:

533

case DRIZZLE_TYPE_UUID:

534

case DRIZZLE_TYPE_VARCHAR:

523

/* fall-through */

524

default:

525

sql_field->pack_flag=(0 |

526

f_settype((uint32_t) sql_field->sql_type));

535

527

break;

536

528

}

537

538

529

return 0;

539

530

}

540

531

541

static int prepare_create_table(Session *session,

542

HA_CREATE_INFO *create_info,

543

message::Table &create_proto,

544

AlterInfo *alter_info,

545

bool tmp_table,

546

uint32_t *db_options,

547

KeyInfo **key_info_buffer,

548

uint32_t *key_count,

549

int select_field_count)

532

static int mysql_prepare_create_table(Session *session,

533

HA_CREATE_INFO *create_info,

534

message::Table &create_proto,

535

AlterInfo *alter_info,

536

bool tmp_table,

537

uint32_t *db_options,

538

KEY **key_info_buffer,

539

uint32_t *key_count,

540

int select_field_count)

550

541

{

551

542

const char *key_name;

552

543

CreateField *sql_field,*dup_field;

553

544

uint field,null_fields,blob_columns,max_key_length;

554

545

ulong record_offset= 0;

555

KeyInfo *key_info;

556

KeyPartInfo *key_part_info;

546

KEY *key_info;

547

KEY_PART_INFO *key_part_info;

557

548

int timestamps= 0, timestamps_with_niladic= 0;

558

int dup_no;

549

int field_no,dup_no;

559

550

int select_field_pos,auto_increment=0;

560

List<CreateField>::iterator it(alter_info->create_list.begin());

561

List<CreateField>::iterator it2(alter_info->create_list.begin());

551

List_iterator<CreateField> it(alter_info->create_list);

552

List_iterator<CreateField> it2(alter_info->create_list);

562

553

uint32_t total_uneven_bit_length= 0;

563

554

564

555

plugin::StorageEngine *engine= plugin::StorageEngine::findByName(create_proto.engine().name());

567

558

null_fields=blob_columns=0;

568

559

max_key_length= engine->max_key_length();

569

560

570

for (int32_t field_no=0; (sql_field=it++) ; field_no++)

561

for (field_no=0; (sql_field=it++) ; field_no++)

571

562

{

572

563

const CHARSET_INFO *save_cs;

573

564

577

568

executing a prepared statement for the second time.

578

569

579

570

sql_field->length= sql_field->char_length;

580

581

571

if (!sql_field->charset)

582

572

sql_field->charset= create_info->default_table_charset;

583

584

573

585

574

table_charset is set in ALTER Table if we want change character set

586

575

for all varchar/char columns.

633

622

634

623

if (sql_field->sql_type == DRIZZLE_TYPE_ENUM)

635

624

{

636

size_t dummy;

625

uint32_t dummy;

637

626

const CHARSET_INFO * const cs= sql_field->charset;

638

627

TYPELIB *interval= sql_field->interval;

639

628

652

641

interval= sql_field->interval= typelib(session->mem_root,

653

642

sql_field->interval_list);

654

643

655

List<String>::iterator int_it(sql_field->interval_list.begin());

644

List_iterator<String> int_it(sql_field->interval_list);

656

645

String conv, *tmp;

657

646

char comma_buf[4];

658

647

int comma_length= cs->cset->wc_mb(cs, ',', (unsigned char*) comma_buf,

666

655

if (String::needs_conversion(tmp->length(), tmp->charset(),

667

656

cs, &dummy))

668

657

{

669

size_t cnv_errs;

658

uint32_t cnv_errs;

670

659

conv.copy(tmp->ptr(), tmp->length(), tmp->charset(), cs, &cnv_errs);

671

interval->type_names[i]= session->mem_root->strmake_root(conv.ptr(), conv.length());

660

interval->type_names[i]= strmake_root(session->mem_root, conv.ptr(),

661

conv.length());

672

662

interval->type_lengths[i]= conv.length();

673

663

}

674

664

678

668

interval->type_lengths[i]= lengthsp;

679

669

((unsigned char *)interval->type_names[i])[lengthsp]= '\0';

680

670

}

681

sql_field->interval_list.clear(); // Don't need interval_list anymore

671

sql_field->interval_list.empty(); // Don't need interval_list anymore

682

672

}

683

673

684

674

/* DRIZZLE_TYPE_ENUM */

701

691

else /* not NULL */

702

692

{

703

693

def->length(cs->cset->lengthsp(cs, def->ptr(), def->length()));

704

if (interval->find_type2(def->ptr(), def->length(), cs) == 0) /* not found */

694

if (find_type2(interval, def->ptr(), def->length(), cs) == 0) /* not found */

705

695

{

706

696

my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);

707

697

return(true);

708

698

}

709

699

}

710

700

}

711

uint32_t new_dummy;

712

calculate_interval_lengths(cs, interval, &field_length, &new_dummy);

701

calculate_interval_lengths(cs, interval, &field_length, &dummy);

713

702

sql_field->length= field_length;

714

703

}

715

704

set_if_smaller(sql_field->length, (uint32_t)MAX_FIELD_WIDTH-1);

777

766

/** @todo Get rid of this MyISAM-specific crap. */

778

767

if (not create_proto.engine().name().compare("MyISAM") &&

779

768

((sql_field->flags & BLOB_FLAG) ||

780

(sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)))

781

{

769

(sql_field->sql_type == DRIZZLE_TYPE_VARCHAR && create_info->row_type != ROW_TYPE_FIXED)))

782

770

(*db_options)|= HA_OPTION_PACK_RECORD;

783

}

784

785

it2= alter_info->create_list.begin();

771

it2.rewind();

786

772

}

787

773

788

774

/* record_offset will be increased with 'length-of-null-bits' later */

789

775

record_offset= 0;

790

776

null_fields+= total_uneven_bit_length;

791

777

792

it= alter_info->create_list.begin();

778

it.rewind();

793

779

while ((sql_field=it++))

794

780

{

795

781

assert(sql_field->charset != 0);

829

815

830

816

/* Create keys */

831

817

832

List<Key>::iterator key_iterator(alter_info->key_list.begin());

833

List<Key>::iterator key_iterator2(alter_info->key_list.begin());

818

List_iterator<Key> key_iterator(alter_info->key_list);

819

List_iterator<Key> key_iterator2(alter_info->key_list);

834

820

uint32_t key_parts=0, fk_key_count=0;

835

821

bool primary_key=0,unique_key=0;

836

822

Key *key, *key2;

848

834

fk_key_count++;

849

835

if (((Foreign_key *)key)->validate(alter_info->create_list))

850

836

return true;

851

852

837

Foreign_key *fk_key= (Foreign_key*) key;

853

854

add_foreign_key_to_table_message(&create_proto,

855

fk_key->name.str,

856

fk_key->columns,

857

fk_key->ref_table,

858

fk_key->ref_columns,

859

fk_key->delete_opt,

860

fk_key->update_opt,

861

fk_key->match_opt);

862

863

838

if (fk_key->ref_columns.elements &&

864

839

fk_key->ref_columns.elements != fk_key->columns.elements)

865

840

{

880

855

}

881

856

if (check_identifier_name(&key->name, ER_TOO_LONG_IDENT))

882

857

return(true);

883

key_iterator2= alter_info->key_list.begin();

858

key_iterator2.rewind ();

884

859

if (key->type != Key::FOREIGN_KEY)

885

860

{

886

861

while ((key2 = key_iterator2++) != key)

894

869

key2->name.str != ignore_key &&

895

870

!foreign_key_prefix(key, key2)))

896

871

{

897

/* @todo issue warning message */

872

/* TODO: issue warning message */

898

873

/* mark that the generated key should be ignored */

899

874

if (!key2->generated ||

900

875

(key->generated && key->columns.elements <

928

903

return(true);

929

904

}

930

905

931

(*key_info_buffer)= key_info= (KeyInfo*) memory::sql_calloc(sizeof(KeyInfo) * (*key_count));

932

key_part_info=(KeyPartInfo*) memory::sql_calloc(sizeof(KeyPartInfo)*key_parts);

906

(*key_info_buffer)= key_info= (KEY*) memory::sql_calloc(sizeof(KEY) * (*key_count));

907

key_part_info=(KEY_PART_INFO*) memory::sql_calloc(sizeof(KEY_PART_INFO)*key_parts);

933

908

if (!*key_info_buffer || ! key_part_info)

934

909

return(true); // Out of memory

935

910

936

key_iterator= alter_info->key_list.begin();

911

key_iterator.rewind();

937

912

key_number=0;

938

913

for (; (key=key_iterator++) ; key_number++)

939

914

{

969

944

key_info->usable_key_parts= key_number;

970

945

key_info->algorithm= key->key_create_info.algorithm;

971

946

947

/* Take block size from key part or table part */

948

949

TODO: Add warning if block size changes. We can't do it here, as

950

this may depend on the size of the key

951

952

key_info->block_size= (key->key_create_info.block_size ?

953

key->key_create_info.block_size :

954

create_proto.options().key_block_size());

955

956

if (key_info->block_size)

957

key_info->flags|= HA_USES_BLOCK_SIZE;

958

972

959

uint32_t tmp_len= system_charset_info->cset->charpos(system_charset_info,

973

960

key->key_create_info.comment.str,

974

961

key->key_create_info.comment.str +

992

979

993

980

message::Table::Field *protofield= NULL;

994

981

995

List<Key_part_spec>::iterator cols(key->columns.begin());

996

List<Key_part_spec>::iterator cols2(key->columns.begin());

982

List_iterator<Key_part_spec> cols(key->columns), cols2(key->columns);

997

983

for (uint32_t column_nr=0 ; (column=cols++) ; column_nr++)

998

984

{

999

985

uint32_t length;

1000

986

Key_part_spec *dup_column;

1001

987

int proto_field_nr= 0;

1002

988

1003

it= alter_info->create_list.begin();

989

it.rewind();

1004

990

field=0;

1005

991

while ((sql_field=it++) && ++proto_field_nr &&

1006

992

my_strcasecmp(system_charset_info,

1007

993

column->field_name.str,

1008

994

sql_field->field_name))

1009

{

1010

995

field++;

1011

}

1012

1013

996

if (!sql_field)

1014

997

{

1015

998

my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);

1016

999

return(true);

1017

1000

}

1018

1019

1001

while ((dup_column= cols2++) != column)

1020

1002

{

1021

1003

if (!my_strcasecmp(system_charset_info,

1027

1009

return(true);

1028

1010

}

1029

1011

}

1030

cols2= key->columns.begin();

1012

cols2.rewind();

1031

1013

1032

1014

if (create_proto.field_size() > 0)

1033

1015

protofield= create_proto.mutable_field(proto_field_nr - 1);

1048

1030

return true;

1049

1031

}

1050

1032

}

1051

1052

1033

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

1053

1034

{

1054

1035

if (key->type == Key::PRIMARY)

1061

1042

{

1062

1043

message::Table::Field::FieldConstraints *constraints;

1063

1044

constraints= protofield->mutable_constraints();

1064

constraints->set_is_notnull(true);

1045

constraints->set_is_nullable(false);

1065

1046

}

1066

1047

1067

1048

}

1075

1056

}

1076

1057

}

1077

1058

}

1078

1079

1059

if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)

1080

1060

{

1081

1061

if (column_nr == 0 || (engine->check_flag(HTON_BIT_AUTO_PART_KEY)))

1085

1065

1086

1066

key_part_info->fieldnr= field;

1087

1067

key_part_info->offset= (uint16_t) sql_field->offset;

1088

key_part_info->key_type= 0;

1068

key_part_info->key_type=sql_field->pack_flag;

1089

1069

length= sql_field->key_length;

1090

1070

1091

1071

if (column->length)

1153

1133

key_part_info->length=(uint16_t) length;

1154

1134

/* Use packed keys for long strings on the first column */

1155

1135

if (!((*db_options) & HA_OPTION_NO_PACK_KEYS) &&

1156

(length >= KEY_DEFAULT_PACK_LENGTH &&

1157

(sql_field->sql_type == DRIZZLE_TYPE_VARCHAR ||

1158

sql_field->sql_type == DRIZZLE_TYPE_BLOB)))

1136

(length >= KEY_DEFAULT_PACK_LENGTH &&

1137

(sql_field->sql_type == DRIZZLE_TYPE_VARCHAR ||

1138

sql_field->sql_type == DRIZZLE_TYPE_BLOB)))

1159

1139

{

1160

1140

if ((column_nr == 0 && sql_field->sql_type == DRIZZLE_TYPE_BLOB) ||

1161

1141

sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)

1162

{

1163

1142

key_info->flags|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;

1164

}

1165

1143

else

1166

{

1167

1144

key_info->flags|= HA_PACK_KEY;

1168

}

1169

1145

}

1170

1146

/* Check if the key segment is partial, set the key flag accordingly */

1171

1147

if (length != sql_field->key_length)

1200

1176

key_info->name=(char*) key_name;

1201

1177

}

1202

1178

}

1203

1204

1179

if (!key_info->name || check_column_name(key_info->name))

1205

1180

{

1206

1181

my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);

1207

1182

return(true);

1208

1183

}

1209

1210

1184

if (!(key_info->flags & HA_NULL_PART_KEY))

1211

{

1212

1185

unique_key=1;

1213

}

1214

1215

1186

key_info->key_length=(uint16_t) key_length;

1216

1217

1187

if (key_length > max_key_length)

1218

1188

{

1219

1189

my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);

1220

1190

return(true);

1221

1191

}

1222

1223

1192

key_info++;

1224

1193

}

1225

1226

1194

if (!unique_key && !primary_key &&

1227

1195

(engine->check_flag(HTON_BIT_REQUIRE_PRIMARY_KEY)))

1228

1196

{

1229

1197

my_message(ER_REQUIRES_PRIMARY_KEY, ER(ER_REQUIRES_PRIMARY_KEY), MYF(0));

1230

1198

return(true);

1231

1199

}

1232

1233

1200

if (auto_increment > 0)

1234

1201

{

1235

1202

my_message(ER_WRONG_AUTO_KEY, ER(ER_WRONG_AUTO_KEY), MYF(0));

1236

1203

return(true);

1237

1204

}

1238

1205

/* Sort keys in optimized order */

1239

internal::my_qsort((unsigned char*) *key_info_buffer, *key_count, sizeof(KeyInfo),

1206

internal::my_qsort((unsigned char*) *key_info_buffer, *key_count, sizeof(KEY),

1240

1207

(qsort_cmp) sort_keys);

1241

1208

1242

1209

/* Check fields. */

1243

it= alter_info->create_list.begin();

1210

it.rewind();

1244

1211

while ((sql_field=it++))

1245

1212

{

1246

1213

Field::utype type= (Field::utype) MTYP_TYPENR(sql_field->unireg_check);

1247

1214

1248

1215

if (session->variables.sql_mode & MODE_NO_ZERO_DATE &&

1249

1216

!sql_field->def &&

1250

(sql_field->sql_type == DRIZZLE_TYPE_TIMESTAMP or sql_field->sql_type == DRIZZLE_TYPE_MICROTIME) &&

1217

sql_field->sql_type == DRIZZLE_TYPE_TIMESTAMP &&

1251

1218

(sql_field->flags & NOT_NULL_FLAG) &&

1252

1219

(type == Field::NONE || type == Field::TIMESTAMP_UN_FIELD))

1253

1220

{

1310

1277

return 0;

1311

1278

}

1312

1279

1313

static bool locked_create_event(Session *session,

1314

const identifier::Table &identifier,

1315

HA_CREATE_INFO *create_info,

1316

message::Table &table_proto,

1317

AlterInfo *alter_info,

1318

bool is_if_not_exists,

1319

bool internal_tmp_table,

1320

uint db_options,

1321

uint key_count,

1322

KeyInfo *key_info_buffer)

1323

{

1324

bool error= true;

1325

1326

{

1327

1328

1329

@note if we are building a temp table we need to check to see if a temp table

1330

already exists, otherwise we just need to find out if a normal table exists (aka it is fine

1331

to create a table under a temporary table.

1332

1333

bool exists=

1334

plugin::StorageEngine::doesTableExist(*session, identifier,

1335

identifier.getType() != message::Table::STANDARD );

1336

1337

if (exists)

1338

{

1339

if (is_if_not_exists)

1340

{

1341

error= false;

1342

push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

1343

ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),

1344

identifier.getTableName().c_str());

1345

create_info->table_existed= 1; // Mark that table existed

1346

return error;

1347

}

1348

1349

my_error(ER_TABLE_EXISTS_ERROR, identifier);

1350

1351

return error;

1352

}

1353

1354

if (identifier.getType() == message::Table::STANDARD) // We have a real table

1355

{

1356

1357

We don't assert here, but check the result, because the table could be

1358

in the table definition cache and in the same time the .frm could be

1359

missing from the disk, in case of manual intervention which deletes

1360

the .frm cursor. The user has to use FLUSH TABLES; to clear the cache.

1361

Then she could create the table. This case is pretty obscure and

1362

therefore we don't introduce a new error message only for it.

1363

1364

1365

@todo improve this error condition.

1366

1367

if (definition::Cache::singleton().find(identifier.getKey()))

1368

{

1369

my_error(ER_TABLE_EXISTS_ERROR, identifier);

1370

1371

return error;

1372

}

1373

}

1374

}

1375

1376

session->set_proc_info("creating table");

1377

create_info->table_existed= 0; // Mark that table is created

1378

1379

create_info->table_options= db_options;

1380

1381

if (not rea_create_table(session, identifier,

1382

table_proto,

1383

create_info, alter_info->create_list,

1384

key_count, key_info_buffer))

1385

{

1386

return error;

1387

}

1388

1389

if (identifier.getType() == message::Table::TEMPORARY)

1390

{

1391

/* Open table and put in temporary table list */

1392

if (not (session->open_temporary_table(identifier)))

1393

{

1394

(void) session->rm_temporary_table(identifier);

1395

return error;

1396

}

1397

}

1398

1399

1400

We keep this behind the lock to make sure ordering is correct for a table.

1401

This is a very unlikely problem where before we would write out to the

1402

trans log, someone would do a delete/create operation.

1403

1404

1405

if (table_proto.type() == message::Table::STANDARD && not internal_tmp_table)

1406

{

1407

TransactionServices &transaction_services= TransactionServices::singleton();

1408

transaction_services.createTable(*session, table_proto);

1409

}

1410

1411

return false;

1412

}

1413

1414

1280

1415

1281

1416

1282

Ignore the name of this function... it locks :(

1418

1284

Create a table

1419

1285

1420

1286

SYNOPSIS

1421

create_table_no_lock()

1287

mysql_create_table_no_lock()

1422

1288

session Thread object

1423

1289

db Database

1424

1290

table_name Table name

1434

1300

1435

1301

Note that this function assumes that caller already have taken

1436

1302

name-lock on table being created or used some other way to ensure

1437

that concurrent operations won't intervene. create_table()

1303

that concurrent operations won't intervene. mysql_create_table()

1438

1304

is a wrapper that can be used for this.

1439

1305

1440

1306

RETURN VALUES

1442

1308

true error

1443

1309

1444

1310

1445

bool create_table_no_lock(Session *session,

1446

const identifier::Table &identifier,

1311

bool mysql_create_table_no_lock(Session *session,

1312

TableIdentifier &identifier,

1447

1313

HA_CREATE_INFO *create_info,

1448

1314

message::Table &table_proto,

1449

1315

AlterInfo *alter_info,

1452

1318

bool is_if_not_exists)

1453

1319

{

1454

1320

uint db_options, key_count;

1455

KeyInfo *key_info_buffer;

1321

KEY *key_info_buffer;

1456

1322

bool error= true;

1323

TableShare share;

1324

bool lex_identified_temp_table=

1325

(table_proto.type() == message::Table::TEMPORARY);

1457

1326

1458

1327

/* Check for duplicate fields and check type of table to create */

1459

1328

if (not alter_info->create_list.elements)

1462

1331

MYF(0));

1463

1332

return true;

1464

1333

}

1465

assert(identifier.getTableName() == table_proto.name());

1334

assert(strcmp(identifier.getTableName(), table_proto.name().c_str())==0);

1466

1335

db_options= create_info->table_options;

1467

1336

1468

set_table_default_charset(create_info, identifier.getSchemaName().c_str());

1469

1470

/* Build a Table object to pass down to the engine, and the do the actual create. */

1471

if (not prepare_create_table(session, create_info, table_proto, alter_info,

1472

internal_tmp_table,

1473

&db_options,

1474

&key_info_buffer, &key_count,

1475

select_field_count))

1476

{

1477

boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* CREATE TABLE (some confussion on naming, double check) */

1478

error= locked_create_event(session,

1479

identifier,

1480

create_info,

1481

table_proto,

1482

alter_info,

1483

is_if_not_exists,

1484

internal_tmp_table,

1485

db_options, key_count,

1486

key_info_buffer);

1487

}

1488

1489

session->set_proc_info("After create");

1490

1491

return(error);

1492

}

1493

1494

/**

1495

@note the following two methods implement create [temporary] table.

1496

1497

static bool drizzle_create_table(Session *session,

1498

const identifier::Table &identifier,

1499

HA_CREATE_INFO *create_info,

1500

message::Table &table_proto,

1501

AlterInfo *alter_info,

1502

bool internal_tmp_table,

1503

uint32_t select_field_count,

1504

bool is_if_not_exists)

1505

{

1506

Table *name_lock= NULL;

1507

bool result;

1508

1509

if (session->lock_table_name_if_not_cached(identifier, &name_lock))

1510

{

1511

result= true;

1512

}

1513

else if (name_lock == NULL)

1337

if (create_info->row_type == ROW_TYPE_DYNAMIC)

1338

db_options|=HA_OPTION_PACK_RECORD;

1339

1340

set_table_default_charset(create_info, identifier.getDBName());

1341

1342

/* Check if table exists */

1343

if (mysql_prepare_create_table(session, create_info, table_proto, alter_info,

1344

internal_tmp_table,

1345

&db_options,

1346

&key_info_buffer, &key_count,

1347

select_field_count))

1348

goto err;

1349

1350

/* Check if table already exists */

1351

if (lex_identified_temp_table &&

1352

session->find_temporary_table(identifier.getDBName(), identifier.getTableName()))

1514

1353

{

1515

1354

if (is_if_not_exists)

1516

1355

{

1356

create_info->table_existed= 1; // Mark that table existed

1517

1357

push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

1518

1358

ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),

1519

identifier.getTableName().c_str());

1520

create_info->table_existed= 1;

1521

result= false;

1522

}

1523

else

1524

{

1525

my_error(ER_TABLE_EXISTS_ERROR, identifier);

1526

result= true;

1527

}

1528

}

1529

else

1530

{

1531

result= create_table_no_lock(session,

1532

identifier,

1533

create_info,

1534

table_proto,

1535

alter_info,

1536

internal_tmp_table,

1537

select_field_count,

1538

is_if_not_exists);

1539

}

1540

1541

if (name_lock)

1542

{

1543

boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* Lock for removing name_lock during table create */

1544

session->unlink_open_table(name_lock);

1545

}

1546

1547

return(result);

1359

identifier.getTableName());

1360

error= 0;

1361

goto err;

1362

}

1363

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());

1364

goto err;

1365

}

1366

1367

pthread_mutex_lock(&LOCK_open); /* CREATE TABLE (some confussion on naming, double check) */

1368

if (not internal_tmp_table && not lex_identified_temp_table)

1369

{

1370

if (plugin::StorageEngine::doesTableExist(*session,

1371

identifier, false)==EEXIST)

1372

{

1373

if (is_if_not_exists)

1374

{

1375

error= false;

1376

push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

1377

ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),

1378

identifier.getTableName());

1379

create_info->table_existed= 1; // Mark that table existed

1380

}

1381

else

1382

{

1383

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());

1384

}

1385

1386

goto unlock_and_end;

1387

}

1388

1389

We don't assert here, but check the result, because the table could be

1390

in the table definition cache and in the same time the .frm could be

1391

missing from the disk, in case of manual intervention which deletes

1392

the .frm cursor. The user has to use FLUSH TABLES; to clear the cache.

1393

Then she could create the table. This case is pretty obscure and

1394

therefore we don't introduce a new error message only for it.

1395

1396

if (TableShare::getShare(identifier.getDBName(), identifier.getTableName()))

1397

{

1398

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());

1399

goto unlock_and_end;

1400

}

1401

}

1402

1403

1404

Check that table with given name does not already

1405

exist in any storage engine. In such a case it should

1406

be discovered and the error ER_TABLE_EXISTS_ERROR be returned

1407

unless user specified CREATE TABLE IF EXISTS

1408

The LOCK_open mutex has been locked to make sure no

1409

one else is attempting to discover the table. Since

1410

it's not on disk as a frm cursor, no one could be using it!

1411

1412

if (not lex_identified_temp_table)

1413

{

1414

bool exists= plugin::StorageEngine::doesTableExist(*session, identifier, false);

1415

1416

if (exists)

1417

{

1418

if (is_if_not_exists)

1419

{

1420

error= false;

1421

push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

1422

ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),

1423

identifier.getTableName());

1424

create_info->table_existed= 1; // Mark that table existed

1425

goto unlock_and_end;

1426

}

1427

1428

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());

1429

goto unlock_and_end;

1430

}

1431

}

1432

1433

session->set_proc_info("creating table");

1434

create_info->table_existed= 0; // Mark that table is created

1435

1436

create_info->table_options= db_options;

1437

1438

if (rea_create_table(session, identifier,

1439

table_proto,

1440

create_info, alter_info->create_list,

1441

key_count, key_info_buffer))

1442

{

1443

goto unlock_and_end;

1444

}

1445

1446

if (lex_identified_temp_table)

1447

{

1448

/* Open table and put in temporary table list */

1449

if (not (session->open_temporary_table(identifier)))

1450

{

1451

(void) session->rm_temporary_table(identifier);

1452

goto unlock_and_end;

1453

}

1454

}

1455

1456

if (not internal_tmp_table && not lex_identified_temp_table)

1457

{

1458

ReplicationServices &replication_services= ReplicationServices::singleton();

1459

replication_services.createTable(session, table_proto);

1460

}

1461

error= false;

1462

unlock_and_end:

1463

pthread_mutex_unlock(&LOCK_open);

1464

1465

err:

1466

session->set_proc_info("After create");

1467

1468

return(error);

1548

1469

}

1549

1470

1550

1471

1551

1472

1552

Database locking aware wrapper for create_table_no_lock(),

1473

Database locking aware wrapper for mysql_create_table_no_lock(),

1553

1474

1554

bool create_table(Session *session,

1555

const identifier::Table &identifier,

1475

1476

bool mysql_create_table(Session *session,

1477

TableIdentifier &identifier,

1556

1478

HA_CREATE_INFO *create_info,

1557

1479

message::Table &table_proto,

1558

1480

AlterInfo *alter_info,

1560

1482

uint32_t select_field_count,

1561

1483

bool is_if_not_exists)

1562

1484

{

1563

if (identifier.isTmp())

1564

{

1565

return create_table_no_lock(session,

1566

identifier,

1567

create_info,

1568

table_proto,

1569

alter_info,

1570

internal_tmp_table,

1571

select_field_count,

1572

is_if_not_exists);

1573

}

1574

1575

return drizzle_create_table(session,

1576

identifier,

1577

create_info,

1578

table_proto,

1579

alter_info,

1580

internal_tmp_table,

1581

select_field_count,

1582

is_if_not_exists);

1485

Table *name_lock= NULL;

1486

bool result;

1487

bool lex_identified_temp_table=

1488

(table_proto.type() == message::Table::TEMPORARY);

1489

1490

if (not lex_identified_temp_table)

1491

{

1492

if (session->lock_table_name_if_not_cached(identifier.getDBName(),

1493

identifier.getTableName(),

1494

&name_lock))

1495

{

1496

result= true;

1497

goto unlock;

1498

}

1499

if (name_lock == NULL)

1500

{

1501

if (is_if_not_exists)

1502

{

1503

push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

1504

ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),

1505

identifier.getTableName());

1506

create_info->table_existed= 1;

1507

result= false;

1508

}

1509

else

1510

{

1511

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());

1512

result= true;

1513

}

1514

goto unlock;

1515

}

1516

}

1517

1518

result= mysql_create_table_no_lock(session,

1519

identifier,

1520

create_info,

1521

table_proto,

1522

alter_info,

1523

internal_tmp_table,

1524

select_field_count,

1525

is_if_not_exists);

1526

1527

unlock:

1528

if (name_lock)

1529

{

1530

pthread_mutex_lock(&LOCK_open); /* Lock for removing name_lock during table create */

1531

session->unlink_open_table(name_lock);

1532

pthread_mutex_unlock(&LOCK_open);

1533

}

1534

1535

return(result);

1583

1536

}

1584

1537

1585

1538

1588

1541

**/

1589

1542

1590

1543

static bool

1591

check_if_keyname_exists(const char *name, KeyInfo *start, KeyInfo *end)

1544

check_if_keyname_exists(const char *name, KEY *start, KEY *end)

1592

1545

{

1593

for (KeyInfo *key=start ; key != end ; key++)

1546

for (KEY *key=start ; key != end ; key++)

1594

1547

if (!my_strcasecmp(system_charset_info,name,key->name))

1595

1548

return 1;

1596

1549

return 0;

1598

1551

1599

1552

1600

1553

static char *

1601

make_unique_key_name(const char *field_name,KeyInfo *start,KeyInfo *end)

1554

make_unique_key_name(const char *field_name,KEY *start,KEY *end)

1602

1555

{

1603

1556

char buff[MAX_FIELD_NAME],*buff_end;

1604

1557

1632

1585

Rename a table.

1633

1586

1634

1587

SYNOPSIS

1635

rename_table()

1636

session

1588

mysql_rename_table()

1637

1589

base The plugin::StorageEngine handle.

1638

1590

old_db The old database name.

1639

1591

old_name The old table name.

1640

1592

new_db The new database name.

1641

1593

new_name The new table name.

1594

flags flags for build_table_filename().

1595

FN_FROM_IS_TMP old_name is temporary.

1596

FN_TO_IS_TMP new_name is temporary.

1642

1597

1643

1598

RETURN

1644

1599

false OK

1646

1601

1647

1602

1648

1603

bool

1649

rename_table(Session &session,

1650

plugin::StorageEngine *base,

1651

const identifier::Table &from,

1652

const identifier::Table &to)

1604

mysql_rename_table(plugin::StorageEngine *base, const char *old_db,

1605

const char *old_name, const char *new_db,

1606

const char *new_name, uint32_t flags)

1653

1607

{

1608

Session *session= current_session;

1609

char from[FN_REFLEN], to[FN_REFLEN];

1610

char *from_base= from, *to_base= to;

1654

1611

int error= 0;

1655

1612

1656

1613

assert(base);

1657

1614

1658

if (not plugin::StorageEngine::doesSchemaExist(to))

1615

build_table_filename(from, sizeof(from), old_db, old_name,

1616

flags & FN_FROM_IS_TMP);

1617

build_table_filename(to, sizeof(to), new_db, new_name,

1618

flags & FN_TO_IS_TMP);

1619

1620

if (!(error= base->renameTable(session, from_base, to_base)))

1659

1621

{

1660

my_error(ER_NO_DB_ERROR, MYF(0), to.getSchemaName().c_str());

1661

return true;

1622

if (base->check_flag(HTON_BIT_HAS_DATA_DICTIONARY) == 0

1623

&& rename_table_proto_file(from_base, to_base))

1624

{

1625

error= errno;

1626

base->renameTable(session, to_base, from_base);

1627

}

1662

1628

}

1663

1629

1664

error= base->renameTable(session, from, to);

1665

1666

1630

if (error == HA_ERR_WRONG_COMMAND)

1667

{

1668

1631

my_error(ER_NOT_SUPPORTED_YET, MYF(0), "ALTER Table");

1669

}

1670

1632

else if (error)

1671

{

1672

std::string from_path;

1673

std::string to_path;

1674

1675

from.getSQLPath(from_path);

1676

to.getSQLPath(to_path);

1677

1678

const char *from_identifier= from.isTmp() ? "#sql-temporary" : from_path.c_str();

1679

const char *to_identifier= to.isTmp() ? "#sql-temporary" : to_path.c_str();

1680

1681

my_error(ER_ERROR_ON_RENAME, MYF(0), from_identifier, to_identifier, error);

1682

}

1683

1684

return error ? true : false;

1633

my_error(ER_ERROR_ON_RENAME, MYF(0), from, to, error);

1634

return(error != 0);

1685

1635

}

1686

1636

1687

1637

1700

1650

the table is closed.

1701

1651

1702

1652

PREREQUISITES

1703

Lock on table::Cache::singleton().mutex()

1653

Lock on LOCK_open

1704

1654

Win32 clients must also have a WRITE LOCK on the table !

1705

1655

1706

1656

1708

1658

enum ha_extra_function function)

1709

1659

{

1710

1660

1711

safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());

1661

safe_mutex_assert_owner(&LOCK_open);

1712

1662

1713

1663

table->cursor->extra(function);

1714

1664

/* Mark all tables that are in use as 'old' */

1715

session->abortLock(table); /* end threads waiting on lock */

1665

mysql_lock_abort(session, table); /* end threads waiting on lock */

1716

1666

1717

1667

/* Wait until all there are no other threads that has this table open */

1718

identifier::Table identifier(table->getShare()->getSchemaName(), table->getShare()->getTableName());

1719

table::Cache::singleton().removeTable(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG);

1668

remove_table_from_cache(session, table->s->db.str,

1669

table->s->table_name.str,

1670

RTFC_WAIT_OTHER_THREAD_FLAG);

1720

1671

}

1721

1672

1722

1673

1732

1683

reopen the table.

1733

1684

1734

1685

PREREQUISITES

1735

Lock on table::Cache::singleton().mutex()

1686

Lock on LOCK_open

1736

1687

Win32 clients must also have a WRITE LOCK on the table !

1737

1688

1738

1689

1743

1694

/* Close lock if this is not got with LOCK TABLES */

1744

1695

if (lock)

1745

1696

{

1746

unlockTables(lock);

1697

mysql_unlock_tables(this, lock);

1747

1698

lock= NULL; // Start locked threads

1748

1699

}

1749

1700

/* Close all copies of 'table'. This also frees all LOCK TABLES lock */

1750

1701

unlink_open_table(table);

1751

1702

1752

/* When lock on table::Cache::singleton().mutex() is freed other threads can continue */

1753

locking::broadcast_refresh();

1703

/* When lock on LOCK_open is freed other threads can continue */

1704

broadcast_refresh();

1754

1705

}

1755

1706

1756

1707

1759

1710

true Message should be sent by caller

1760

1711

(admin operation or network communication failed)

1761

1712

1762

static bool admin_table(Session* session, TableList* tables,

1713

static bool mysql_admin_table(Session* session, TableList* tables,

1763

1714

HA_CHECK_OPT* check_opt,

1764

1715

const char *operator_name,

1765

1716

thr_lock_type lock_type,

1768

1719

HA_CHECK_OPT *))

1769

1720

{

1770

1721

TableList *table;

1771

Select_Lex *select= &session->getLex()->select_lex;

1722

Select_Lex *select= &session->lex->select_lex;

1772

1723

List<Item> field_list;

1773

1724

Item *item;

1725

LEX *lex= session->lex;

1774

1726

int result_code= 0;

1775

1727

TransactionServices &transaction_services= TransactionServices::singleton();

1776

1728

const CHARSET_INFO * const cs= system_charset_info;

1777

1729

1778

1730

if (! session->endActiveTransaction())

1779

1731

return 1;

1780

1781

1732

field_list.push_back(item = new Item_empty_string("Table",

1782

1733

NAME_CHAR_LEN * 2,

1783

1734

cs));

1788

1739

item->maybe_null = 1;

1789

1740

field_list.push_back(item = new Item_empty_string("Msg_text", 255, cs));

1790

1741

item->maybe_null = 1;

1791

if (session->getClient()->sendFields(&field_list))

1742

if (session->client->sendFields(&field_list))

1792

1743

return true;

1793

1744

1794

1745

for (table= tables; table; table= table->next_local)

1795

1746

{

1796

identifier::Table table_identifier(table->getSchemaName(), table->getTableName());

1797

std::string table_name;

1747

char table_name[NAME_LEN*2+2];

1748

char* db = table->db;

1798

1749

bool fatal_error=0;

1799

1750

1800

table_identifier.getSQLPath(table_name);

1801

1751

sprintf(table_name,"%s.%s",db,table->table_name);

1802

1752

table->lock_type= lock_type;

1803

1753

/* open only one table from local list of command */

1804

1754

{

1811

1761

1812

1762

Time zone tables and SP tables can be add to lex->query_tables list,

1813

1763

so it have to be prepared.

1814

@todo Investigate if we can put extra tables into argument instead of using lex->query_tables

1764

TODO: Investigate if we can put extra tables into argument instead of

1765

using lex->query_tables

1815

1766

1816

session->getLex()->query_tables= table;

1817

session->getLex()->query_tables_last= &table->next_global;

1818

session->getLex()->query_tables_own_last= 0;

1767

lex->query_tables= table;

1768

lex->query_tables_last= &table->next_global;

1769

lex->query_tables_own_last= 0;

1819

1770

session->no_warnings_for_error= 0;

1820

1771

1821

1772

session->openTablesLock(table);

1845

1796

{

1846

1797

char buff[FN_REFLEN + DRIZZLE_ERRMSG_SIZE];

1847

1798

uint32_t length;

1848

session->getClient()->store(table_name.c_str());

1849

session->getClient()->store(operator_name);

1850

session->getClient()->store(STRING_WITH_LEN("error"));

1799

session->client->store(table_name);

1800

session->client->store(operator_name);

1801

session->client->store(STRING_WITH_LEN("error"));

1851

1802

length= snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY),

1852

table_name.c_str());

1853

session->getClient()->store(buff, length);

1854

transaction_services.autocommitOrRollback(*session, false);

1803

table_name);

1804

session->client->store(buff, length);

1805

transaction_services.ha_autocommit_or_rollback(session, false);

1855

1806

session->endTransaction(COMMIT);

1856

1807

session->close_thread_tables();

1857

session->getLex()->reset_query_tables_list(false);

1808

lex->reset_query_tables_list(false);

1858

1809

table->table=0; // For query cache

1859

if (session->getClient()->flush())

1810

if (session->client->flush())

1860

1811

goto err;

1861

1812

continue;

1862

1813

}

1863

1814

1864

1815

/* Close all instances of the table to allow repair to rename files */

1865

if (lock_type == TL_WRITE && table->table->getShare()->getVersion())

1816

if (lock_type == TL_WRITE && table->table->s->version)

1866

1817

{

1867

table::Cache::singleton().mutex().lock(); /* Lock type is TL_WRITE and we lock to repair the table */

1868

const char *old_message=session->enter_cond(COND_refresh, table::Cache::singleton().mutex(),

1869

"Waiting to get writelock");

1870

session->abortLock(table->table);

1871

identifier::Table identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());

1872

table::Cache::singleton().removeTable(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG | RTFC_CHECK_KILLED_FLAG);

1818

pthread_mutex_lock(&LOCK_open); /* Lock type is TL_WRITE and we lock to repair the table */

1819

const char *old_message=session->enter_cond(&COND_refresh, &LOCK_open,

1820

"Waiting to get writelock");

1821

mysql_lock_abort(session,table->table);

1822

remove_table_from_cache(session, table->table->s->db.str,

1823

table->table->s->table_name.str,

1824

RTFC_WAIT_OTHER_THREAD_FLAG |

1825

RTFC_CHECK_KILLED_FLAG);

1873

1826

session->exit_cond(old_message);

1874

if (session->getKilled())

1827

if (session->killed)

1875

1828

goto err;

1876

1829

open_for_modify= 0;

1877

1830

}

1880

1833

1881

1834

send_result:

1882

1835

1883

session->getLex()->cleanup_after_one_table_open();

1836

lex->cleanup_after_one_table_open();

1884

1837

session->clear_error(); // these errors shouldn't get client

1885

1838

{

1886

List<DRIZZLE_ERROR>::iterator it(session->warn_list.begin());

1839

List_iterator_fast<DRIZZLE_ERROR> it(session->warn_list);

1887

1840

DRIZZLE_ERROR *err;

1888

1841

while ((err= it++))

1889

1842

{

1890

session->getClient()->store(table_name.c_str());

1891

session->getClient()->store(operator_name);

1892

session->getClient()->store(warning_level_names[err->level].str,

1843

session->client->store(table_name);

1844

session->client->store(operator_name);

1845

session->client->store(warning_level_names[err->level].str,

1893

1846

warning_level_names[err->level].length);

1894

session->getClient()->store(err->msg);

1895

if (session->getClient()->flush())

1847

session->client->store(err->msg);

1848

if (session->client->flush())

1896

1849

goto err;

1897

1850

}

1898

1851

drizzle_reset_errors(session, true);

1899

1852

}

1900

session->getClient()->store(table_name.c_str());

1901

session->getClient()->store(operator_name);

1853

session->client->store(table_name);

1854

session->client->store(operator_name);

1902

1855

1903

1856

switch (result_code) {

1904

1857

case HA_ADMIN_NOT_IMPLEMENTED:

1906

1859

char buf[ERRMSGSIZE+20];

1907

1860

uint32_t length=snprintf(buf, ERRMSGSIZE,

1908

1861

ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);

1909

session->getClient()->store(STRING_WITH_LEN("note"));

1910

session->getClient()->store(buf, length);

1862

session->client->store(STRING_WITH_LEN("note"));

1863

session->client->store(buf, length);

1911

1864

}

1912

1865

break;

1913

1866

1914

1867

case HA_ADMIN_OK:

1915

session->getClient()->store(STRING_WITH_LEN("status"));

1916

session->getClient()->store(STRING_WITH_LEN("OK"));

1868

session->client->store(STRING_WITH_LEN("status"));

1869

session->client->store(STRING_WITH_LEN("OK"));

1917

1870

break;

1918

1871

1919

1872

case HA_ADMIN_FAILED:

1920

session->getClient()->store(STRING_WITH_LEN("status"));

1921

session->getClient()->store(STRING_WITH_LEN("Operation failed"));

1873

session->client->store(STRING_WITH_LEN("status"));

1874

session->client->store(STRING_WITH_LEN("Operation failed"));

1922

1875

break;

1923

1876

1924

1877

case HA_ADMIN_REJECT:

1925

session->getClient()->store(STRING_WITH_LEN("status"));

1926

session->getClient()->store(STRING_WITH_LEN("Operation need committed state"));

1878

session->client->store(STRING_WITH_LEN("status"));

1879

session->client->store(STRING_WITH_LEN("Operation need committed state"));

1927

1880

open_for_modify= false;

1928

1881

break;

1929

1882

1930

1883

case HA_ADMIN_ALREADY_DONE:

1931

session->getClient()->store(STRING_WITH_LEN("status"));

1932

session->getClient()->store(STRING_WITH_LEN("Table is already up to date"));

1884

session->client->store(STRING_WITH_LEN("status"));

1885

session->client->store(STRING_WITH_LEN("Table is already up to date"));

1933

1886

break;

1934

1887

1935

1888

case HA_ADMIN_CORRUPT:

1936

session->getClient()->store(STRING_WITH_LEN("error"));

1937

session->getClient()->store(STRING_WITH_LEN("Corrupt"));

1889

session->client->store(STRING_WITH_LEN("error"));

1890

session->client->store(STRING_WITH_LEN("Corrupt"));

1938

1891

fatal_error=1;

1939

1892

break;

1940

1893

1941

1894

case HA_ADMIN_INVALID:

1942

session->getClient()->store(STRING_WITH_LEN("error"));

1943

session->getClient()->store(STRING_WITH_LEN("Invalid argument"));

1895

session->client->store(STRING_WITH_LEN("error"));

1896

session->client->store(STRING_WITH_LEN("Invalid argument"));

1944

1897

break;

1945

1898

1946

1899

default: // Probably HA_ADMIN_INTERNAL_ERROR

1949

1902

uint32_t length=snprintf(buf, ERRMSGSIZE,

1950

1903

_("Unknown - internal error %d during operation"),

1951

1904

result_code);

1952

session->getClient()->store(STRING_WITH_LEN("error"));

1953

session->getClient()->store(buf, length);

1905

session->client->store(STRING_WITH_LEN("error"));

1906

session->client->store(buf, length);

1954

1907

fatal_error=1;

1955

1908

break;

1956

1909

}

1958

1911

if (table->table)

1959

1912

{

1960

1913

if (fatal_error)

1961

{

1962

table->table->getMutableShare()->resetVersion(); // Force close of table

1963

}

1914

table->table->s->version=0; // Force close of table

1964

1915

else if (open_for_modify)

1965

1916

{

1966

if (table->table->getShare()->getType())

1967

{

1917

if (table->table->s->tmp_table)

1968

1918

table->table->cursor->info(HA_STATUS_CONST);

1969

}

1970

1919

else

1971

1920

{

1972

boost::unique_lock<boost::mutex> lock(table::Cache::singleton().mutex());

1973

identifier::Table identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());

1974

table::Cache::singleton().removeTable(session, identifier, RTFC_NO_FLAG);

1921

pthread_mutex_lock(&LOCK_open);

1922

remove_table_from_cache(session, table->table->s->db.str,

1923

table->table->s->table_name.str, RTFC_NO_FLAG);

1924

pthread_mutex_unlock(&LOCK_open);

1975

1925

}

1976

1926

}

1977

1927

}

1978

transaction_services.autocommitOrRollback(*session, false);

1928

transaction_services.ha_autocommit_or_rollback(session, false);

1979

1929

session->endTransaction(COMMIT);

1980

1930

session->close_thread_tables();

1981

1931

table->table=0; // For query cache

1982

if (session->getClient()->flush())

1932

if (session->client->flush())

1983

1933

goto err;

1984

1934

}

1985

1935

1987

1937

return(false);

1988

1938

1989

1939

err:

1990

transaction_services.autocommitOrRollback(*session, true);

1940

transaction_services.ha_autocommit_or_rollback(session, true);

1991

1941

session->endTransaction(ROLLBACK);

1992

1942

session->close_thread_tables(); // Shouldn't be needed

1993

1943

if (table)

1995

1945

return(true);

1996

1946

}

1997

1947

1948

1949

We have to write the query before we unlock the named table.

1950

1951

Since temporary tables are not replicated under row-based

1952

replication, CREATE TABLE ... LIKE ... needs special

1953

treatement. We have four cases to consider, according to the

1954

following decision table:

1955

1956

==== ========= ========= ==============================

1957

Case Target Source Write to binary log

1958

==== ========= ========= ==============================

1959

1 normal normal Original statement

1960

2 normal temporary Generated statement

1961

3 temporary normal Nothing

1962

4 temporary temporary Nothing

1963

==== ========= ========= ==============================

1964

1965

static bool replicateCreateTableLike(Session *session, TableList *table, Table *name_lock,

1966

bool is_src_table_tmp, bool is_if_not_exists)

1967

{

1968

if (is_src_table_tmp)

1969

{

1970

char buf[2048];

1971

String query(buf, sizeof(buf), system_charset_info);

1972

query.length(0); // Have to zero it since constructor doesn't

1973

1974

1975

1976

Here we open the destination table, on which we already have

1977

name-lock. This is needed for store_create_info() to work.

1978

The table will be closed by unlink_open_table() at the end

1979

of this function.

1980

1981

table->table= name_lock;

1982

pthread_mutex_lock(&LOCK_open); /* Open new table we have just acquired */

1983

if (session->reopen_name_locked_table(table, false))

1984

{

1985

pthread_mutex_unlock(&LOCK_open);

1986

return false;

1987

}

1988

pthread_mutex_unlock(&LOCK_open);

1989

1990

int result= store_create_info(table, &query, is_if_not_exists);

1991

1992

assert(result == 0); // store_create_info() always return 0

1993

write_bin_log(session, query.ptr());

1994

}

1995

else // Case 1

1996

{

1997

write_bin_log(session, session->query.c_str());

1998

}

1999

2000

return true;

2001

}

2002

1998

2003

1999

2004

Create a new table by copying from source table

2000

2005

2001

2006

Altough exclusive name-lock on target table protects us from concurrent

2002

2007

DML and DDL operations on it we still want to wrap .FRM creation and call

2003

2008

to plugin::StorageEngine::createTable() in critical section protected by

2004

table::Cache::singleton().mutex() in order to provide minimal atomicity against operations which

2009

LOCK_open in order to provide minimal atomicity against operations which

2005

2010

disregard name-locks, like I_S implementation, for example. This is a

2006

2011

temporary and should not be copied. Instead we should fix our code to

2007

2012

always honor name-locks.

2008

2013

2009

Also some engines (e.g. NDB cluster) require that table::Cache::singleton().mutex() should be held

2014

Also some engines (e.g. NDB cluster) require that LOCK_open should be held

2010

2015

during the call to plugin::StorageEngine::createTable().

2011

2016

See bug #28614 for more info.

2012

2017

2013

static bool create_table_wrapper(Session &session,

2014

const message::Table& create_table_proto,

2015

identifier::Table::const_reference destination_identifier,

2016

identifier::Table::const_reference source_identifier,

2017

bool is_engine_set)

2018

static bool create_table_wrapper(Session &session, message::Table& create_table_proto,

2019

TableIdentifier &destination_identifier,

2020

TableIdentifier &src_table,

2021

bool lex_identified_temp_table, bool is_engine_set)

2018

2022

{

2019

// We require an additional table message because during parsing we used

2020

// a "new" message and it will not have all of the information that the

2021

// source table message would have.

2022

message::Table new_table_message;

2023

2024

message::table::shared_ptr source_table_message= plugin::StorageEngine::getTableMessage(session, source_identifier);

2025

2026

if (not source_table_message)

2027

{

2028

my_error(ER_TABLE_UNKNOWN, source_identifier);

2023

int protoerr= EEXIST;

2024

message::Table new_proto;

2025

message::Table src_proto;

2026

2027

protoerr= plugin::StorageEngine::getTableDefinition(session,

2028

src_table,

2029

&src_proto);

2030

new_proto.CopyFrom(src_proto);

2031

2032

if (lex_identified_temp_table)

2033

{

2034

new_proto.set_type(message::Table::TEMPORARY);

2035

}

2036

else

2037

{

2038

new_proto.set_type(message::Table::STANDARD);

2039

}

2040

2041

if (is_engine_set)

2042

{

2043

message::Table::StorageEngine *protoengine;

2044

2045

protoengine= new_proto.mutable_engine();

2046

protoengine->set_name(create_table_proto.engine().name());

2047

}

2048

2049

if (protoerr && protoerr != EEXIST)

2050

{

2051

if (errno == ENOENT)

2052

my_error(ER_BAD_DB_ERROR,MYF(0), destination_identifier.getSchemaName());

2053

else

2054

my_error(ER_CANT_CREATE_FILE, MYF(0), destination_identifier.getPath(), errno);

2055

2029

2056

return false;

2030

2057

}

2031

2058

2032

new_table_message.CopyFrom(*source_table_message);

2033

2034

if (destination_identifier.isTmp())

2035

{

2036

new_table_message.set_type(message::Table::TEMPORARY);

2037

}

2038

else

2039

{

2040

new_table_message.set_type(message::Table::STANDARD);

2041

}

2042

2043

if (is_engine_set)

2044

{

2045

new_table_message.mutable_engine()->set_name(create_table_proto.engine().name());

2046

}

2047

2048

{ // We now do a selective copy of elements on to the new table.

2049

new_table_message.set_name(create_table_proto.name());

2050

new_table_message.set_schema(create_table_proto.schema());

2051

new_table_message.set_catalog(create_table_proto.catalog());

2052

}

2053

2054

/* Fix names of foreign keys being added */

2055

for (int32_t j= 0; j < new_table_message.fk_constraint_size(); j++)

2056

{

2057

if (new_table_message.fk_constraint(j).has_name())

2058

{

2059

std::string name(new_table_message.name());

2060

char number[20];

2061

2062

name.append("_ibfk_");

2063

snprintf(number, sizeof(number), "%d", j+1);

2064

name.append(number);

2065

2066

message::Table::ForeignKeyConstraint *pfkey= new_table_message.mutable_fk_constraint(j);

2067

pfkey->set_name(name);

2068

}

2069

}

2070

2071

2059

2072

2060

As mysql_truncate don't work on a new table at this stage of

2073

creation, instead create the table directly (for both normal and temporary tables).

2061

creation, instead create the table directly (for both normal

2062

and temporary tables).

2074

2063

2075

bool success= plugin::StorageEngine::createTable(session,

2076

destination_identifier,

2077

new_table_message);

2078

2079

if (success && not destination_identifier.isTmp())

2080

{

2081

TransactionServices &transaction_services= TransactionServices::singleton();

2082

transaction_services.createTable(session, new_table_message);

2083

}

2084

2085

return success;

2064

int err= plugin::StorageEngine::createTable(session,

2065

destination_identifier,

2066

true, new_proto);

2067

2068

return err ? false : true;

2086

2069

}

2087

2070

2088

2071

2089

2072

Create a table identical to the specified table

2090

2073

2091

2074

SYNOPSIS

2092

create_like_table()

2075

mysql_create_like_table()

2093

2076

session Thread object

2094

2077

table Table list element for target table

2095

2078

src_table Table list element for source table

2100

2083

true error

2101

2084

2102

2085

2103

bool create_like_table(Session* session,

2104

identifier::Table::const_reference destination_identifier,

2105

identifier::Table::const_reference source_identifier,

2106

message::Table &create_table_proto,

2107

bool is_if_not_exists,

2108

bool is_engine_set)

2086

bool mysql_create_like_table(Session* session, TableList* table, TableList* src_table,

2087

message::Table& create_table_proto,

2088

bool is_if_not_exists,

2089

bool is_engine_set)

2109

2090

{

2091

Table *name_lock= 0;

2092

char *db= table->db;

2093

char *table_name= table->table_name;

2110

2094

bool res= true;

2111

bool table_exists= false;

2095

uint32_t not_used;

2096

bool lex_identified_temp_table=

2097

(create_table_proto.type() == message::Table::TEMPORARY);

2098

bool was_created;

2099

2100

2101

By opening source table we guarantee that it exists and no concurrent

2102

DDL operation will mess with it. Later we also take an exclusive

2103

name-lock on target table name, which makes copying of .frm cursor,

2104

call to plugin::StorageEngine::createTable() and binlogging atomic

2105

against concurrent DML and DDL operations on target table.

2106

Thus by holding both these "locks" we ensure that our statement is

2107

properly isolated from all concurrent operations which matter.

2108

2109

if (session->open_tables_from_list(&src_table, &not_used))

2110

return true;

2111

2112

TableIdentifier destination_identifier(db, table_name,

2113

lex_identified_temp_table ? TEMP_TABLE : STANDARD_TABLE);

2114

2115

TableIdentifier src_identifier(src_table->table->s->db.str,

2116

src_table->table->s->table_name.str, src_table->table->s->tmp_table);

2117

2118

2112

2119

2113

2120

2114

2121

Check that destination tables does not exist. Note that its name

2115

2122

was already checked when it was added to the table list.

2116

2117

For temporary tables we don't aim to grab locks.

2118

2123

2119

if (destination_identifier.isTmp())

2124

bool table_exists= false;

2125

if (lex_identified_temp_table)

2120

2126

{

2121

if (session->find_temporary_table(destination_identifier))

2127

if (session->find_temporary_table(db, table_name))

2122

2128

{

2123

2129

table_exists= true;

2124

2130

}

2125

else

2126

{

2127

bool was_created= create_table_wrapper(*session,

2128

create_table_proto,

2129

destination_identifier,

2130

source_identifier,

2131

is_engine_set);

2132

if (not was_created) // This is pretty paranoid, but we assume something might not clean up after itself

2133

{

2134

(void) session->rm_temporary_table(destination_identifier, true);

2135

}

2136

else if (not session->open_temporary_table(destination_identifier))

2137

{

2138

// We created, but we can't open... also, a hack.

2139

(void) session->rm_temporary_table(destination_identifier, true);

2140

}

2141

else

2142

{

2143

res= false;

2144

}

2145

}

2146

2131

}

2147

else // Standard table which will require locks.

2132

else

2148

2133

{

2149

Table *name_lock= 0;

2150

2151

if (session->lock_table_name_if_not_cached(destination_identifier, &name_lock))

2134

if (session->lock_table_name_if_not_cached(db, table_name, &name_lock))

2152

2135

{

2153

2136

if (name_lock)

2154

2137

{

2155

boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* unlink open tables for create table like*/

2138

pthread_mutex_lock(&LOCK_open); /* unlink open tables for create table like*/

2156

2139

session->unlink_open_table(name_lock);

2140

pthread_mutex_unlock(&LOCK_open);

2157

2141

}

2158

2142

2159

2143

return res;

2167

2151

{

2168

2152

table_exists= true;

2169

2153

}

2170

else // Otherwise we create the table

2171

{

2172

bool was_created;

2173

{

2174

boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* We lock for CREATE TABLE LIKE to copy table definition */

2175

was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,

2176

source_identifier, is_engine_set);

2177

}

2178

2179

// So we blew the creation of the table, and we scramble to clean up

2180

// anything that might have been created (read... it is a hack)

2181

if (not was_created)

2182

{

2183

plugin::StorageEngine::dropTable(*session, destination_identifier);

2184

}

2185

else

2186

{

2187

res= false;

2188

}

2189

}

2190

2191

if (name_lock)

2192

{

2193

boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* unlink open tables for create table like*/

2194

session->unlink_open_table(name_lock);

2195

}

2196

2154

}

2197

2155

2198

2156

if (table_exists)

2201

2159

{

2202

2160

char warn_buff[DRIZZLE_ERRMSG_SIZE];

2203

2161

snprintf(warn_buff, sizeof(warn_buff),

2204

ER(ER_TABLE_EXISTS_ERROR), destination_identifier.getTableName().c_str());

2162

ER(ER_TABLE_EXISTS_ERROR), table_name);

2205

2163

push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

2206

ER_TABLE_EXISTS_ERROR, warn_buff);

2207

return false;

2208

}

2209

2210

my_error(ER_TABLE_EXISTS_ERROR, destination_identifier);

2211

2212

return true;

2213

}

2214

2215

return res;

2164

ER_TABLE_EXISTS_ERROR,warn_buff);

2165

res= false;

2166

}

2167

else

2168

{

2169

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);

2170

}

2171

}

2172

else // Otherwise we create the table

2173

{

2174

pthread_mutex_lock(&LOCK_open); /* We lock for CREATE TABLE LIKE to copy table definition */

2175

was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,

2176

src_identifier, lex_identified_temp_table, is_engine_set);

2177

pthread_mutex_unlock(&LOCK_open);

2178

2179

// So we blew the creation of the table, and we scramble to clean up

2180

// anything that might have been created (read... it is a hack)

2181

if (not was_created)

2182

{

2183

if (lex_identified_temp_table)

2184

{

2185

(void) session->rm_temporary_table(destination_identifier);

2186

}

2187

else

2188

{

2189

TableIdentifier identifier(db, table_name, STANDARD_TABLE);

2190

quick_rm_table(*session, identifier);

2191

}

2192

}

2193

else if (lex_identified_temp_table && not session->open_temporary_table(destination_identifier))

2194

{

2195

// We created, but we can't open... also, a hack.

2196

(void) session->rm_temporary_table(destination_identifier);

2197

}

2198

else

2199

{

2200

if (not lex_identified_temp_table)

2201

{

2202

bool rc= replicateCreateTableLike(session, table, name_lock, (src_table->table->s->tmp_table), is_if_not_exists);

2203

(void)rc;

2204

}

2205

2206

res= false;

2207

}

2208

}

2209

2210

if (name_lock)

2211

{

2212

pthread_mutex_lock(&LOCK_open); /* unlink open tables for create table like*/

2213

session->unlink_open_table(name_lock);

2214

pthread_mutex_unlock(&LOCK_open);

2215

}

2216

2217

return(res);

2216

2218

}

2217

2219

2218

2220

2219

bool analyze_table(Session* session, TableList* tables, HA_CHECK_OPT* check_opt)

2221

bool mysql_analyze_table(Session* session, TableList* tables, HA_CHECK_OPT* check_opt)

2220

2222

{

2221

2223

thr_lock_type lock_type = TL_READ_NO_INSERT;

2222

2224

2223

return(admin_table(session, tables, check_opt,

2225

return(mysql_admin_table(session, tables, check_opt,

2224

2226

"analyze", lock_type, true,

2225

2227

&Cursor::ha_analyze));

2226

2228

}

2227

2229

2228

2230

2229

bool check_table(Session* session, TableList* tables,HA_CHECK_OPT* check_opt)

2231

bool mysql_check_table(Session* session, TableList* tables,HA_CHECK_OPT* check_opt)

2230

2232

{

2231

2233

thr_lock_type lock_type = TL_READ_NO_INSERT;

2232

2234

2233

return(admin_table(session, tables, check_opt,

2235

return(mysql_admin_table(session, tables, check_opt,

2234

2236

"check", lock_type,

2235

2237

false,

2236

2238

&Cursor::ha_check));

2237

2239

}

2238

2240

2241

2242

bool mysql_checksum_table(Session *session, TableList *tables,

2243

HA_CHECK_OPT *)

2244

{

2245

TableList *table;

2246

List<Item> field_list;

2247

Item *item;

2248

2249

field_list.push_back(item = new Item_empty_string("Table", NAME_LEN*2));

2250

item->maybe_null= 1;

2251

field_list.push_back(item= new Item_int("Checksum", (int64_t) 1,

2252

MY_INT64_NUM_DECIMAL_DIGITS));

2253

item->maybe_null= 1;

2254

if (session->client->sendFields(&field_list))

2255

return true;

2256

2257

/* Open one table after the other to keep lock time as short as possible. */

2258

for (table= tables; table; table= table->next_local)

2259

{

2260

char table_name[NAME_LEN*2+2];

2261

Table *t;

2262

2263

sprintf(table_name,"%s.%s",table->db,table->table_name);

2264

2265

t= table->table= session->openTableLock(table, TL_READ);

2266

session->clear_error(); // these errors shouldn't get client

2267

2268

session->client->store(table_name);

2269

2270

if (!t)

2271

{

2272

/* Table didn't exist */

2273

session->client->store();

2274

session->clear_error();

2275

}

2276

else

2277

{

2278

/**

2279

@note if the engine keeps a checksum then we return the checksum, otherwise we calculate

2280

2281

if (t->cursor->getEngine()->check_flag(HTON_BIT_HAS_CHECKSUM))

2282

{

2283

session->client->store((uint64_t)t->cursor->checksum());

2284

}

2285

else

2286

{

2287

/* calculating table's checksum */

2288

internal::ha_checksum crc= 0;

2289

unsigned char null_mask=256 - (1 << t->s->last_null_bit_pos);

2290

2291

t->use_all_columns();

2292

2293

if (t->cursor->ha_rnd_init(1))

2294

session->client->store();

2295

else

2296

{

2297

for (;;)

2298

{

2299

internal::ha_checksum row_crc= 0;

2300

int error= t->cursor->rnd_next(t->record[0]);

2301

if (unlikely(error))

2302

{

2303

if (error == HA_ERR_RECORD_DELETED)

2304

continue;

2305

break;

2306

}

2307

if (t->s->null_bytes)

2308

{

2309

/* fix undefined null bits */

2310

t->record[0][t->s->null_bytes-1] |= null_mask;

2311

if (!(t->s->db_create_options & HA_OPTION_PACK_RECORD))

2312

t->record[0][0] |= 1;

2313

2314

row_crc= internal::my_checksum(row_crc, t->record[0], t->s->null_bytes);

2315

}

2316

2317

for (uint32_t i= 0; i < t->s->fields; i++ )

2318

{

2319

Field *f= t->field[i];

2320

if ((f->type() == DRIZZLE_TYPE_BLOB) ||

2321

(f->type() == DRIZZLE_TYPE_VARCHAR))

2322

{

2323

String tmp;

2324

f->val_str(&tmp);

2325

row_crc= internal::my_checksum(row_crc, (unsigned char*) tmp.ptr(), tmp.length());

2326

}

2327

else

2328

row_crc= internal::my_checksum(row_crc, f->ptr,

2329

f->pack_length());

2330

}

2331

2332

crc+= row_crc;

2333

}

2334

session->client->store((uint64_t)crc);

2335

t->cursor->ha_rnd_end();

2336

}

2337

}

2338

session->clear_error();

2339

session->close_thread_tables();

2340

table->table=0; // For query cache

2341

}

2342

if (session->client->flush())

2343

goto err;

2344

}

2345

2346

session->my_eof();

2347

return(false);

2348

2349

err:

2350

session->close_thread_tables(); // Shouldn't be needed

2351

if (table)

2352

table->table=0;

2353

return(true);

2354

}

2355

2239

2356

} /* namespace drizzled */

Older »