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

219

session->clear_error();

220

}

221

222

if (error == HA_ERR_ROW_IS_REFERENCED)

223

{

224

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

225

foreign_key_error= true;

226

}

227

}

228

229

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

230

{

231

TransactionServices &transaction_services= TransactionServices::singleton();

232

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

233

}

234

235

if (error)

236

{

237

if (wrong_tables.length())

238

wrong_tables.append(',');

239

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

240

}

241

}

242

243

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

244

on the table name.

245

246

LOCK_open.unlock();

247

error= 0;

248

249

if (wrong_tables.length())

258

250

{

259

251

if (not foreign_key_error)

260

252

{

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

272

253

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

273

table_error.c_str());

254

wrong_tables.c_ptr());

274

255

}

275

256

else

276

257

{

279

260

error= 1;

280

261

}

281

262

263

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

264

265

err_with_placeholders:

266

unlock_table_names(tables, NULL);

267

LOCK_open.unlock();

282

268

session->no_warnings_for_error= 0;

283

269

284

270

return error;

285

271

}

286

272

273

274

275

Quickly remove a table.

276

277

SYNOPSIS

278

quick_rm_table()

279

base The plugin::StorageEngine handle.

280

db The database name.

281

table_name The table name.

282

is_tmp If the table is temp.

283

284

RETURN

285

0 OK

286

!= 0 Error

287

288

bool quick_rm_table(Session& session,

289

TableIdentifier &identifier)

290

{

291

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

292

}

293

287

294

288

295

Sort keys in the following order:

289

296

- PRIMARY KEY

483

490

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

484

491

(*blob_columns)++;

485

492

break;

486

493

case DRIZZLE_TYPE_VARCHAR:

494

break;

487

495

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:

496

if (check_duplicates_in_interval("ENUM",

497

sql_field->field_name,

498

sql_field->interval,

499

sql_field->charset,

500

&dup_val_count))

501

return 1;

502

break;

503

case DRIZZLE_TYPE_DATE: // Rest of string types

504

case DRIZZLE_TYPE_DATETIME:

505

case DRIZZLE_TYPE_NULL:

506

break;

507

case DRIZZLE_TYPE_DECIMAL:

508

break;

501

509

case DRIZZLE_TYPE_TIMESTAMP:

502

510

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

503

511

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

513

521

}

514

522

}

515

523

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

516

{

517

524

(*timestamps_with_niladic)++;

518

}

519

525

520

526

(*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:

527

/* fall-through */

528

default:

535

529

break;

536

530

}

537

531

538

532

return 0;

539

533

}

540

534

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)

535

static int mysql_prepare_create_table(Session *session,

536

HA_CREATE_INFO *create_info,

537

message::Table &create_proto,

538

AlterInfo *alter_info,

539

bool tmp_table,

540

uint32_t *db_options,

541

KeyInfo **key_info_buffer,

542

uint32_t *key_count,

543

int select_field_count)

550

544

{

551

545

const char *key_name;

552

546

CreateField *sql_field,*dup_field;

555

549

KeyInfo *key_info;

556

550

KeyPartInfo *key_part_info;

557

551

int timestamps= 0, timestamps_with_niladic= 0;

558

int dup_no;

552

int field_no,dup_no;

559

553

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());

554

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

555

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

562

556

uint32_t total_uneven_bit_length= 0;

563

557

564

558

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

567

561

null_fields=blob_columns=0;

568

562

max_key_length= engine->max_key_length();

569

563

570

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

564

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

571

565

{

572

566

const CHARSET_INFO *save_cs;

573

567

577

571

executing a prepared statement for the second time.

578

572

579

573

sql_field->length= sql_field->char_length;

580

581

574

if (!sql_field->charset)

582

575

sql_field->charset= create_info->default_table_charset;

583

584

576

585

577

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

586

578

for all varchar/char columns.

652

644

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

653

645

sql_field->interval_list);

654

646

655

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

647

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

656

648

String conv, *tmp;

657

649

char comma_buf[4];

658

650

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

678

670

interval->type_lengths[i]= lengthsp;

679

671

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

680

672

}

681

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

673

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

682

674

}

683

675

684

676

/* DRIZZLE_TYPE_ENUM */

701

693

else /* not NULL */

702

694

{

703

695

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

704

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

696

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

705

697

{

706

698

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

707

699

return(true);

778

770

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

779

771

((sql_field->flags & BLOB_FLAG) ||

780

772

(sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)))

781

{

782

773

(*db_options)|= HA_OPTION_PACK_RECORD;

783

}

784

785

it2= alter_info->create_list.begin();

774

it2.rewind();

786

775

}

787

776

788

777

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

789

778

record_offset= 0;

790

779

null_fields+= total_uneven_bit_length;

791

780

792

it= alter_info->create_list.begin();

781

it.rewind();

793

782

while ((sql_field=it++))

794

783

{

795

784

assert(sql_field->charset != 0);

829

818

830

819

/* Create keys */

831

820

832

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

833

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

821

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

822

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

834

823

uint32_t key_parts=0, fk_key_count=0;

835

824

bool primary_key=0,unique_key=0;

836

825

Key *key, *key2;

880

869

}

881

870

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

882

871

return(true);

883

key_iterator2= alter_info->key_list.begin();

872

key_iterator2.rewind ();

884

873

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

885

874

{

886

875

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

933

922

if (!*key_info_buffer || ! key_part_info)

934

923

return(true); // Out of memory

935

924

936

key_iterator= alter_info->key_list.begin();

925

key_iterator.rewind();

937

926

key_number=0;

938

927

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

939

928

{

992

981

993

982

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

994

983

995

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

996

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

984

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

997

985

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

998

986

{

999

987

uint32_t length;

1000

988

Key_part_spec *dup_column;

1001

989

int proto_field_nr= 0;

1002

990

1003

it= alter_info->create_list.begin();

991

it.rewind();

1004

992

field=0;

1005

993

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

1006

994

my_strcasecmp(system_charset_info,

1007

995

column->field_name.str,

1008

996

sql_field->field_name))

1009

{

1010

997

field++;

1011

}

1012

1013

998

if (!sql_field)

1014

999

{

1015

1000

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

1016

1001

return(true);

1017

1002

}

1018

1019

1003

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

1020

1004

{

1021

1005

if (!my_strcasecmp(system_charset_info,

1027

1011

return(true);

1028

1012

}

1029

1013

}

1030

cols2= key->columns.begin();

1014

cols2.rewind();

1031

1015

1032

1016

if (create_proto.field_size() > 0)

1033

1017

protofield= create_proto.mutable_field(proto_field_nr - 1);

1048

1032

return true;

1049

1033

}

1050

1034

}

1051

1052

1035

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

1053

1036

{

1054

1037

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

1061

1044

{

1062

1045

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

1063

1046

constraints= protofield->mutable_constraints();

1064

constraints->set_is_notnull(true);

1047

constraints->set_is_nullable(false);

1065

1048

}

1066

1049

1067

1050

}

1075

1058

}

1076

1059

}

1077

1060

}

1078

1079

1061

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

1080

1062

{

1081

1063

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

1200

1182

key_info->name=(char*) key_name;

1201

1183

}

1202

1184

}

1203

1204

1185

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

1205

1186

{

1206

1187

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

1207

1188

return(true);

1208

1189

}

1209

1210

1190

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

1211

{

1212

1191

unique_key=1;

1213

}

1214

1215

1192

key_info->key_length=(uint16_t) key_length;

1216

1217

1193

if (key_length > max_key_length)

1218

1194

{

1219

1195

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

1220

1196

return(true);

1221

1197

}

1222

1223

1198

key_info++;

1224

1199

}

1225

1226

1200

if (!unique_key && !primary_key &&

1227

1201

(engine->check_flag(HTON_BIT_REQUIRE_PRIMARY_KEY)))

1228

1202

{

1229

1203

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

1230

1204

return(true);

1231

1205

}

1232

1233

1206

if (auto_increment > 0)

1234

1207

{

1235

1208

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

1240

1213

(qsort_cmp) sort_keys);

1241

1214

1242

1215

/* Check fields. */

1243

it= alter_info->create_list.begin();

1216

it.rewind();

1244

1217

while ((sql_field=it++))

1245

1218

{

1246

1219

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

1247

1220

1248

1221

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

1249

1222

!sql_field->def &&

1250

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

1223

sql_field->sql_type == DRIZZLE_TYPE_TIMESTAMP &&

1251

1224

(sql_field->flags & NOT_NULL_FLAG) &&

1252

1225

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

1253

1226

{

1311

1284

}

1312

1285

1313

1286

static bool locked_create_event(Session *session,

1314

const identifier::Table &identifier,

1287

TableIdentifier &identifier,

1315

1288

HA_CREATE_INFO *create_info,

1316

1289

message::Table &table_proto,

1317

1290

AlterInfo *alter_info,

1346

1319

return error;

1347

1320

}

1348

1321

1349

my_error(ER_TABLE_EXISTS_ERROR, identifier);

1350

1322

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());

1351

1323

return error;

1352

1324

}

1353

1325

1364

1336

1365

1337

@todo improve this error condition.

1366

1338

1367

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

1339

if (TableShare::getShare(identifier))

1368

1340

{

1369

my_error(ER_TABLE_EXISTS_ERROR, identifier);

1370

1341

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());

1371

1342

return error;

1372

1343

}

1373

1344

}

1405

1376

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

1406

1377

{

1407

1378

TransactionServices &transaction_services= TransactionServices::singleton();

1408

transaction_services.createTable(*session, table_proto);

1379

transaction_services.createTable(session, table_proto);

1409

1380

}

1410

1381

1411

1382

return false;

1418

1389

Create a table

1419

1390

1420

1391

SYNOPSIS

1421

create_table_no_lock()

1392

mysql_create_table_no_lock()

1422

1393

session Thread object

1423

1394

db Database

1424

1395

table_name Table name

1434

1405

1435

1406

Note that this function assumes that caller already have taken

1436

1407

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

1437

that concurrent operations won't intervene. create_table()

1408

that concurrent operations won't intervene. mysql_create_table()

1438

1409

is a wrapper that can be used for this.

1439

1410

1440

1411

RETURN VALUES

1442

1413

true error

1443

1414

1444

1415

1445

bool create_table_no_lock(Session *session,

1446

const identifier::Table &identifier,

1416

bool mysql_create_table_no_lock(Session *session,

1417

TableIdentifier &identifier,

1447

1418

HA_CREATE_INFO *create_info,

1448

1419

message::Table &table_proto,

1449

1420

AlterInfo *alter_info,

1468

1439

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

1469

1440

1470

1441

/* 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))

1442

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

1443

internal_tmp_table,

1444

&db_options,

1445

&key_info_buffer, &key_count,

1446

select_field_count))

1476

1447

{

1477

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

1448

boost_unique_lock_t lock(LOCK_open); /* CREATE TABLE (some confussion on naming, double check) */

1478

1449

error= locked_create_event(session,

1479

1450

identifier,

1480

1451

create_info,

1495

1466

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

1496

1467

1497

1468

static bool drizzle_create_table(Session *session,

1498

const identifier::Table &identifier,

1469

TableIdentifier &identifier,

1499

1470

HA_CREATE_INFO *create_info,

1500

1471

message::Table &table_proto,

1501

1472

AlterInfo *alter_info,

1522

1493

}

1523

1494

else

1524

1495

{

1525

my_error(ER_TABLE_EXISTS_ERROR, identifier);

1496

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());

1526

1497

result= true;

1527

1498

}

1528

1499

}

1529

1500

else

1530

1501

{

1531

result= create_table_no_lock(session,

1502

result= mysql_create_table_no_lock(session,

1532

1503

identifier,

1533

1504

create_info,

1534

1505

table_proto,

1540

1511

1541

1512

if (name_lock)

1542

1513

{

1543

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

1514

boost_unique_lock_t lock(LOCK_open); /* Lock for removing name_lock during table create */

1544

1515

session->unlink_open_table(name_lock);

1545

1516

}

1546

1517

1549

1520

1550

1521

1551

1522

1552

Database locking aware wrapper for create_table_no_lock(),

1523

Database locking aware wrapper for mysql_create_table_no_lock(),

1553

1524

1554

bool create_table(Session *session,

1555

const identifier::Table &identifier,

1525

bool mysql_create_table(Session *session,

1526

TableIdentifier &identifier,

1556

1527

HA_CREATE_INFO *create_info,

1557

1528

message::Table &table_proto,

1558

1529

AlterInfo *alter_info,

1562

1533

{

1563

1534

if (identifier.isTmp())

1564

1535

{

1565

return create_table_no_lock(session,

1536

return mysql_create_table_no_lock(session,

1566

1537

identifier,

1567

1538

create_info,

1568

1539

table_proto,

1632

1603

Rename a table.

1633

1604

1634

1605

SYNOPSIS

1635

rename_table()

1606

mysql_rename_table()

1636

1607

session

1637

1608

base The plugin::StorageEngine handle.

1638

1609

old_db The old database name.

1646

1617

1647

1618

1648

1619

bool

1649

rename_table(Session &session,

1620

mysql_rename_table(Session &session,

1650

1621

plugin::StorageEngine *base,

1651

const identifier::Table &from,

1652

const identifier::Table &to)

1622

TableIdentifier &from,

1623

TableIdentifier &to)

1653

1624

{

1654

1625

int error= 0;

1655

1626

1669

1640

}

1670

1641

else if (error)

1671

1642

{

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();

1643

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

1644

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

1680

1645

1681

1646

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

1682

1647

}

1700

1665

the table is closed.

1701

1666

1702

1667

PREREQUISITES

1703

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

1668

Lock on LOCK_open

1704

1669

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

1705

1670

1706

1671

1708

1673

enum ha_extra_function function)

1709

1674

{

1710

1675

1711

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

1676

safe_mutex_assert_owner(LOCK_open.native_handle());

1712

1677

1713

1678

table->cursor->extra(function);

1714

1679

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

1715

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

1680

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

1716

1681

1717

1682

/* 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);

1683

TableIdentifier identifier(table->getShare()->getSchemaName(), table->getShare()->getTableName());

1684

remove_table_from_cache(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG);

1720

1685

}

1721

1686

1722

1687

1732

1697

reopen the table.

1733

1698

1734

1699

PREREQUISITES

1735

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

1700

Lock on LOCK_open

1736

1701

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

1737

1702

1738

1703

1743

1708

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

1744

1709

if (lock)

1745

1710

{

1746

unlockTables(lock);

1711

mysql_unlock_tables(this, lock);

1747

1712

lock= NULL; // Start locked threads

1748

1713

}

1749

1714

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

1750

1715

unlink_open_table(table);

1751

1716

1752

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

1753

locking::broadcast_refresh();

1717

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

1718

broadcast_refresh();

1754

1719

}

1755

1720

1756

1721

1759

1724

true Message should be sent by caller

1760

1725

(admin operation or network communication failed)

1761

1726

1762

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

1727

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

1763

1728

HA_CHECK_OPT* check_opt,

1764

1729

const char *operator_name,

1765

1730

thr_lock_type lock_type,

1768

1733

HA_CHECK_OPT *))

1769

1734

{

1770

1735

TableList *table;

1771

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

1736

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

1772

1737

List<Item> field_list;

1773

1738

Item *item;

1739

LEX *lex= session->lex;

1774

1740

int result_code= 0;

1775

1741

TransactionServices &transaction_services= TransactionServices::singleton();

1776

1742

const CHARSET_INFO * const cs= system_charset_info;

1777

1743

1778

1744

if (! session->endActiveTransaction())

1779

1745

return 1;

1780

1781

1746

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

1782

1747

NAME_CHAR_LEN * 2,

1783

1748

cs));

1788

1753

item->maybe_null = 1;

1789

1754

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

1790

1755

item->maybe_null = 1;

1791

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

1756

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

1792

1757

return true;

1793

1758

1794

1759

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

1795

1760

{

1796

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

1797

std::string table_name;

1761

char table_name[NAME_LEN*2+2];

1762

char* db = table->db;

1798

1763

bool fatal_error=0;

1799

1764

1800

table_identifier.getSQLPath(table_name);

1801

1765

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

1802

1766

table->lock_type= lock_type;

1803

1767

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

1804

1768

{

1813

1777

so it have to be prepared.

1814

1778

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

1815

1779

1816

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

1817

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

1818

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

1780

lex->query_tables= table;

1781

lex->query_tables_last= &table->next_global;

1782

lex->query_tables_own_last= 0;

1819

1783

session->no_warnings_for_error= 0;

1820

1784

1821

1785

session->openTablesLock(table);

1845

1809

{

1846

1810

char buff[FN_REFLEN + DRIZZLE_ERRMSG_SIZE];

1847

1811

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"));

1812

session->client->store(table_name);

1813

session->client->store(operator_name);

1814

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

1851

1815

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

1816

table_name);

1817

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

1818

transaction_services.autocommitOrRollback(session, false);

1855

1819

session->endTransaction(COMMIT);

1856

1820

session->close_thread_tables();

1857

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

1821

lex->reset_query_tables_list(false);

1858

1822

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

1859

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

1823

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

1860

1824

goto err;

1861

1825

continue;

1862

1826

}

1864

1828

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

1865

1829

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

1866

1830

{

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(),

1831

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

1832

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

1869

1833

"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);

1834

mysql_lock_abort(session,table->table);

1835

TableIdentifier identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());

1836

remove_table_from_cache(session, identifier,

1837

RTFC_WAIT_OTHER_THREAD_FLAG |

1838

RTFC_CHECK_KILLED_FLAG);

1873

1839

session->exit_cond(old_message);

1874

if (session->getKilled())

1840

if (session->killed)

1875

1841

goto err;

1876

1842

open_for_modify= 0;

1877

1843

}

1880

1846

1881

1847

send_result:

1882

1848

1883

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

1849

lex->cleanup_after_one_table_open();

1884

1850

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

1885

1851

{

1886

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

1852

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

1887

1853

DRIZZLE_ERROR *err;

1888

1854

while ((err= it++))

1889

1855

{

1890

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

1891

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

1892

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

1856

session->client->store(table_name);

1857

session->client->store(operator_name);

1858

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

1893

1859

warning_level_names[err->level].length);

1894

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

1895

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

1860

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

1861

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

1896

1862

goto err;

1897

1863

}

1898

1864

drizzle_reset_errors(session, true);

1899

1865

}

1900

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

1901

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

1866

session->client->store(table_name);

1867

session->client->store(operator_name);

1902

1868

1903

1869

switch (result_code) {

1904

1870

case HA_ADMIN_NOT_IMPLEMENTED:

1906

1872

char buf[ERRMSGSIZE+20];

1907

1873

uint32_t length=snprintf(buf, ERRMSGSIZE,

1908

1874

ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);

1909

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

1910

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

1875

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

1876

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

1911

1877

}

1912

1878

break;

1913

1879

1914

1880

case HA_ADMIN_OK:

1915

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

1916

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

1881

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

1882

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

1917

1883

break;

1918

1884

1919

1885

case HA_ADMIN_FAILED:

1920

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

1921

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

1886

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

1887

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

1922

1888

break;

1923

1889

1924

1890

case HA_ADMIN_REJECT:

1925

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

1926

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

1891

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

1892

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

1927

1893

open_for_modify= false;

1928

1894

break;

1929

1895

1930

1896

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"));

1897

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

1898

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

1933

1899

break;

1934

1900

1935

1901

case HA_ADMIN_CORRUPT:

1936

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

1937

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

1902

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

1903

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

1938

1904

fatal_error=1;

1939

1905

break;

1940

1906

1941

1907

case HA_ADMIN_INVALID:

1942

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

1943

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

1908

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

1909

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

1944

1910

break;

1945

1911

1946

1912

default: // Probably HA_ADMIN_INTERNAL_ERROR

1949

1915

uint32_t length=snprintf(buf, ERRMSGSIZE,

1950

1916

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

1951

1917

result_code);

1952

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

1953

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

1918

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

1919

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

1954

1920

fatal_error=1;

1955

1921

break;

1956

1922

}

1969

1935

}

1970

1936

else

1971

1937

{

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

1938

boost::unique_lock<boost::mutex> lock(LOCK_open);

1939

TableIdentifier identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());

1940

remove_table_from_cache(session, identifier, RTFC_NO_FLAG);

1975

1941

}

1976

1942

}

1977

1943

}

1978

transaction_services.autocommitOrRollback(*session, false);

1944

transaction_services.autocommitOrRollback(session, false);

1979

1945

session->endTransaction(COMMIT);

1980

1946

session->close_thread_tables();

1981

1947

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

1982

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

1948

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

1983

1949

goto err;

1984

1950

}

1985

1951

1987

1953

return(false);

1988

1954

1989

1955

err:

1990

transaction_services.autocommitOrRollback(*session, true);

1956

transaction_services.autocommitOrRollback(session, true);

1991

1957

session->endTransaction(ROLLBACK);

1992

1958

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

1993

1959

if (table)

2001

1967

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

2002

1968

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

2003

1969

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

2004

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

1970

LOCK_open in order to provide minimal atomicity against operations which

2005

1971

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

2006

1972

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

2007

1973

always honor name-locks.

2008

1974

2009

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

1975

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

2010

1976

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

2011

1977

See bug #28614 for more info.

2012

1978

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,

1979

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

1980

TableIdentifier &destination_identifier,

1981

TableIdentifier &src_table,

2017

1982

bool is_engine_set)

2018

1983

{

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

2029

return false;

2030

}

2031

2032

new_table_message.CopyFrom(*source_table_message);

1984

int protoerr= EEXIST;

1985

message::Table new_proto;

1986

message::Table src_proto;

1987

1988

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

1989

src_table,

1990

src_proto);

1991

new_proto.CopyFrom(src_proto);

2033

1992

2034

1993

if (destination_identifier.isTmp())

2035

1994

{

2036

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

1995

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

2037

1996

}

2038

1997

else

2039

1998

{

2040

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

1999

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

2041

2000

}

2042

2001

2043

2002

if (is_engine_set)

2044

2003

{

2045

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

2004

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

2046

2005

}

2047

2006

2048

2007

{ // 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());

2008

new_proto.set_name(create_table_proto.name());

2009

new_proto.set_schema(create_table_proto.schema());

2010

new_proto.set_catalog(create_table_proto.catalog());

2052

2011

}

2053

2012

2054

/* Fix names of foreign keys being added */

2055

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

2013

if (protoerr && protoerr != EEXIST)

2056

2014

{

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

}

2015

if (errno == ENOENT)

2016

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

2017

else

2018

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

2019

2020

return false;

2069

2021

}

2070

2022

2071

2023

2072

2024

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

2025

creation, instead create the table directly (for both normal

2026

and temporary tables).

2074

2027

2075

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

2076

destination_identifier,

2077

new_table_message);

2028

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

2029

destination_identifier,

2030

new_proto);

2078

2031

2079

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

2032

if (err == false && not destination_identifier.isTmp())

2080

2033

{

2081

2034

TransactionServices &transaction_services= TransactionServices::singleton();

2082

transaction_services.createTable(session, new_table_message);

2035

transaction_services.createTable(&session, new_proto);

2083

2036

}

2084

2037

2085

return success;

2038

return err ? false : true;

2086

2039

}

2087

2040

2088

2041

2089

2042

Create a table identical to the specified table

2090

2043

2091

2044

SYNOPSIS

2092

create_like_table()

2045

mysql_create_like_table()

2093

2046

session Thread object

2094

2047

table Table list element for target table

2095

2048

src_table Table list element for source table

2100

2053

true error

2101

2054

2102

2055

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)

2056

bool mysql_create_like_table(Session* session,

2057

TableIdentifier &destination_identifier,

2058

TableList* table, TableList* src_table,

2059

message::Table &create_table_proto,

2060

bool is_if_not_exists,

2061

bool is_engine_set)

2109

2062

{

2063

char *db= table->db;

2064

char *table_name= table->table_name;

2110

2065

bool res= true;

2111

bool table_exists= false;

2066

uint32_t not_used;

2067

2068

2069

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

2070

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

2071

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

2072

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

2073

against concurrent DML and DDL operations on target table.

2074

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

2075

properly isolated from all concurrent operations which matter.

2076

2077

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

2078

return true;

2079

2080

TableIdentifier src_identifier(src_table->table->getShare()->getSchemaName(),

2081

src_table->table->getShare()->getTableName(), src_table->table->getShare()->getType());

2082

2083

2112

2084

2113

2085

2114

2086

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

2116

2088

2117

2089

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

2118

2090

2091

bool table_exists= false;

2119

2092

if (destination_identifier.isTmp())

2120

2093

{

2121

if (session->find_temporary_table(destination_identifier))

2094

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

2122

2095

{

2123

2096

table_exists= true;

2124

2097

}

2125

2098

else

2126

2099

{

2127

bool was_created= create_table_wrapper(*session,

2128

create_table_proto,

2129

destination_identifier,

2130

source_identifier,

2131

is_engine_set);

2100

bool was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,

2101

src_identifier, is_engine_set);

2132

2102

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

2133

2103

{

2134

2104

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

2152

2122

{

2153

2123

if (name_lock)

2154

2124

{

2155

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

2125

boost_unique_lock_t lock(LOCK_open); /* unlink open tables for create table like*/

2156

2126

session->unlink_open_table(name_lock);

2157

2127

}

2158

2128

2171

2141

{

2172

2142

bool was_created;

2173

2143

{

2174

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

2144

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

2175

2145

was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,

2176

source_identifier, is_engine_set);

2146

src_identifier, is_engine_set);

2177

2147

}

2178

2148

2179

2149

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

2180

2150

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

2181

2151

if (not was_created)

2182

2152

{

2183

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

2153

quick_rm_table(*session, destination_identifier);

2184

2154

}

2185

2155

else

2186

2156

{

2190

2160

2191

2161

if (name_lock)

2192

2162

{

2193

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

2163

boost_unique_lock_t lock(LOCK_open); /* unlink open tables for create table like*/

2194

2164

session->unlink_open_table(name_lock);

2195

2165

}

2196

2166

}

2201

2171

{

2202

2172

char warn_buff[DRIZZLE_ERRMSG_SIZE];

2203

2173

snprintf(warn_buff, sizeof(warn_buff),

2204

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

2174

ER(ER_TABLE_EXISTS_ERROR), table_name);

2205

2175

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;

2176

ER_TABLE_EXISTS_ERROR,warn_buff);

2177

res= false;

2178

}

2179

else

2180

{

2181

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

2182

}

2213

2183

}

2214

2184

2215

return res;

2185

return(res);

2216

2186

}

2217

2187

2218

2188

2219

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

2189

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

2220

2190

{

2221

2191

thr_lock_type lock_type = TL_READ_NO_INSERT;

2222

2192

2223

return(admin_table(session, tables, check_opt,

2193

return(mysql_admin_table(session, tables, check_opt,

2224

2194

"analyze", lock_type, true,

2225

2195

&Cursor::ha_analyze));

2226

2196

}

2227

2197

2228

2198

2229

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

2199

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

2230

2200

{

2231

2201

thr_lock_type lock_type = TL_READ_NO_INSERT;

2232

2202

2233

return(admin_table(session, tables, check_opt,

2203

return(mysql_admin_table(session, tables, check_opt,

2234

2204

"check", lock_type,

2235

2205

false,

2236

2206

&Cursor::ha_check));

Older »