~drizzle-trunk/drizzle/development

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

201

202

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

203

{

204

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

205

if (if_exists)

206

push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

207

ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),

208

table->getTableName());

209

else

172

210

error= 1;

173

break;

174

default:

175

// temporary table not found

211

}

212

else

213

{

214

error= plugin::StorageEngine::dropTable(*session, identifier);

215

216

if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE) && if_exists)

217

{

176

218

error= 0;

177

}

178

179

if (drop_temporary == false)

180

{

181

Table *locked_table;

182

abort_locked_tables(session, tmp_identifier);

183

table::Cache::singleton().removeTable(session, tmp_identifier,

184

RTFC_WAIT_OTHER_THREAD_FLAG |

185

RTFC_CHECK_KILLED_FLAG);

186

187

If the table was used in lock tables, remember it so that

188

unlock_table_names can free it

189

190

if ((locked_table= drop_locked_tables(session, tmp_identifier)))

191

table->table= locked_table;

192

193

if (session->getKilled())

194

{

195

error= -1;

196

break;

197

}

198

}

199

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(table->getSchemaName()), string(table->getTableName()), if_exists);

233

}

234

235

if (error)

236

{

237

if (wrong_tables.length())

238

wrong_tables.append(',');

239

wrong_tables.append(String(table->getTableName(), 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

tables->unlock_table_names();

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

1366

1338

1367

1339

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

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

1680

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

1683

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

1719

1684

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

1720

1685

}

1721

1686

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

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

1717

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

1753

1718

locking::broadcast_refresh();

1754

1719

}

1755

1720

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

1798

1762

bool fatal_error=0;

1799

1763

1800

table_identifier.getSQLPath(table_name);

1801

1764

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

1802

1765

table->lock_type= lock_type;

1803

1766

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

1804

1767

{

1813

1776

so it have to be prepared.

1814

1777

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

1815

1778

1816

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

1817

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

1818

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

1779

lex->query_tables= table;

1780

lex->query_tables_last= &table->next_global;

1781

lex->query_tables_own_last= 0;

1819

1782

session->no_warnings_for_error= 0;

1820

1783

1821

1784

session->openTablesLock(table);

1845

1808

{

1846

1809

char buff[FN_REFLEN + DRIZZLE_ERRMSG_SIZE];

1847

1810

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

1811

session->client->store(table_name);

1812

session->client->store(operator_name);

1813

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

1851

1814

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

1815

table_name);

1816

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

1817

transaction_services.autocommitOrRollback(session, false);

1855

1818

session->endTransaction(COMMIT);

1856

1819

session->close_thread_tables();

1857

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

1820

lex->reset_query_tables_list(false);

1858

1821

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

1859

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

1822

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

1860

1823

goto err;

1861

1824

continue;

1862

1825

}

1864

1827

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

1865

1828

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

1866

1829

{

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

1830

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

1831

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

1869

1832

"Waiting to get writelock");

1870

1833

session->abortLock(table->table);

1871

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

1834

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

1872

1835

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

1873

1836

session->exit_cond(old_message);

1874

1837

if (session->getKilled())

1880

1843

1881

1844

send_result:

1882

1845

1883

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

1846

lex->cleanup_after_one_table_open();

1884

1847

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

1885

1848

{

1886

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

1849

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

1887

1850

DRIZZLE_ERROR *err;

1888

1851

while ((err= it++))

1889

1852

{

1890

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

1891

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

1892

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

1853

session->client->store(table_name);

1854

session->client->store(operator_name);

1855

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

1893

1856

warning_level_names[err->level].length);

1894

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

1895

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

1857

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

1858

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

1896

1859

goto err;

1897

1860

}

1898

1861

drizzle_reset_errors(session, true);

1899

1862

}

1900

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

1901

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

1863

session->client->store(table_name);

1864

session->client->store(operator_name);

1902

1865

1903

1866

switch (result_code) {

1904

1867

case HA_ADMIN_NOT_IMPLEMENTED:

1906

1869

char buf[ERRMSGSIZE+20];

1907

1870

uint32_t length=snprintf(buf, ERRMSGSIZE,

1908

1871

ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);

1909

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

1910

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

1872

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

1873

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

1911

1874

}

1912

1875

break;

1913

1876

1914

1877

case HA_ADMIN_OK:

1915

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

1916

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

1878

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

1879

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

1917

1880

break;

1918

1881

1919

1882

case HA_ADMIN_FAILED:

1920

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

1921

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

1883

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

1884

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

1922

1885

break;

1923

1886

1924

1887

case HA_ADMIN_REJECT:

1925

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

1926

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

1888

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

1889

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

1927

1890

open_for_modify= false;

1928

1891

break;

1929

1892

1930

1893

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

1894

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

1895

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

1933

1896

break;

1934

1897

1935

1898

case HA_ADMIN_CORRUPT:

1936

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

1937

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

1899

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

1900

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

1938

1901

fatal_error=1;

1939

1902

break;

1940

1903

1941

1904

case HA_ADMIN_INVALID:

1942

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

1943

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

1905

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

1906

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

1944

1907

break;

1945

1908

1946

1909

default: // Probably HA_ADMIN_INTERNAL_ERROR

1949

1912

uint32_t length=snprintf(buf, ERRMSGSIZE,

1950

1913

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

1951

1914

result_code);

1952

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

1953

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

1915

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

1916

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

1954

1917

fatal_error=1;

1955

1918

break;

1956

1919

}

1969

1932

}

1970

1933

else

1971

1934

{

1972

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

1973

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

1935

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

1936

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

1974

1937

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

1975

1938

}

1976

1939

}

1977

1940

}

1978

transaction_services.autocommitOrRollback(*session, false);

1941

transaction_services.autocommitOrRollback(session, false);

1979

1942

session->endTransaction(COMMIT);

1980

1943

session->close_thread_tables();

1981

1944

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

1982

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

1945

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

1983

1946

goto err;

1984

1947

}

1985

1948

1987

1950

return(false);

1988

1951

1989

1952

err:

1990

transaction_services.autocommitOrRollback(*session, true);

1953

transaction_services.autocommitOrRollback(session, true);

1991

1954

session->endTransaction(ROLLBACK);

1992

1955

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

1993

1956

if (table)

2001

1964

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

2002

1965

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

2003

1966

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

2004

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

1967

LOCK_open in order to provide minimal atomicity against operations which

2005

1968

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

2006

1969

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

2007

1970

always honor name-locks.

2008

1971

2009

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

1972

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

2010

1973

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

2011

1974

See bug #28614 for more info.

2012

1975

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,

1976

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

1977

TableIdentifier &destination_identifier,

1978

TableIdentifier &src_table,

2017

1979

bool is_engine_set)

2018

1980

{

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

1981

int protoerr= EEXIST;

1982

message::Table new_proto;

1983

message::table::shared_ptr src_proto;

1984

1985

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

1986

src_table,

1987

src_proto);

1988

new_proto.CopyFrom(*src_proto);

2033

1989

2034

1990

if (destination_identifier.isTmp())

2035

1991

{

2036

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

1992

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

2037

1993

}

2038

1994

else

2039

1995

{

2040

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

1996

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

2041

1997

}

2042

1998

2043

1999

if (is_engine_set)

2044

2000

{

2045

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

2001

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

2046

2002

}

2047

2003

2048

2004

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

2005

new_proto.set_name(create_table_proto.name());

2006

new_proto.set_schema(create_table_proto.schema());

2007

new_proto.set_catalog(create_table_proto.catalog());

2052

2008

}

2053

2009

2054

/* Fix names of foreign keys being added */

2055

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

2010

if (protoerr && protoerr != EEXIST)

2056

2011

{

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

}

2012

if (errno == ENOENT)

2013

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

2014

else

2015

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

2016

2017

return false;

2069

2018

}

2070

2019

2071

2020

2072

2021

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

2022

creation, instead create the table directly (for both normal

2023

and temporary tables).

2074

2024

2075

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

2076

destination_identifier,

2077

new_table_message);

2025

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

2026

destination_identifier,

2027

new_proto);

2078

2028

2079

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

2029

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

2080

2030

{

2081

2031

TransactionServices &transaction_services= TransactionServices::singleton();

2082

transaction_services.createTable(session, new_table_message);

2032

transaction_services.createTable(&session, new_proto);

2083

2033

}

2084

2034

2085

return success;

2035

return err ? false : true;

2086

2036

}

2087

2037

2088

2038

2089

2039

Create a table identical to the specified table

2090

2040

2091

2041

SYNOPSIS

2092

create_like_table()

2042

mysql_create_like_table()

2093

2043

session Thread object

2094

2044

table Table list element for target table

2095

2045

src_table Table list element for source table

2100

2050

true error

2101

2051

2102

2052

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)

2053

bool mysql_create_like_table(Session* session,

2054

TableIdentifier &destination_identifier,

2055

TableList* table, TableList* src_table,

2056

message::Table &create_table_proto,

2057

bool is_if_not_exists,

2058

bool is_engine_set)

2109

2059

{

2110

2060

bool res= true;

2111

bool table_exists= false;

2061

uint32_t not_used;

2062

2063

2064

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

2065

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

2066

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

2067

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

2068

against concurrent DML and DDL operations on target table.

2069

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

2070

properly isolated from all concurrent operations which matter.

2071

2072

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

2073

return true;

2074

2075

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

2076

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

2077

2078

2112

2079

2113

2080

2114

2081

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

2116

2083

2117

2084

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

2118

2085

2086

bool table_exists= false;

2119

2087

if (destination_identifier.isTmp())

2120

2088

{

2121

2089

if (session->find_temporary_table(destination_identifier))

2124

2092

}

2125

2093

else

2126

2094

{

2127

bool was_created= create_table_wrapper(*session,

2128

create_table_proto,

2129

destination_identifier,

2130

source_identifier,

2131

is_engine_set);

2095

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

2096

src_identifier, is_engine_set);

2132

2097

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

2133

2098

{

2134

2099

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

2152

2117

{

2153

2118

if (name_lock)

2154

2119

{

2155

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

2120

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

2156

2121

session->unlink_open_table(name_lock);

2157

2122

}

2158

2123

2171

2136

{

2172

2137

bool was_created;

2173

2138

{

2174

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

2139

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

2175

2140

was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,

2176

source_identifier, is_engine_set);

2141

src_identifier, is_engine_set);

2177

2142

}

2178

2143

2179

2144

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

2180

2145

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

2181

2146

if (not was_created)

2182

2147

{

2183

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

2148

quick_rm_table(*session, destination_identifier);

2184

2149

}

2185

2150

else

2186

2151

{

2190

2155

2191

2156

if (name_lock)

2192

2157

{

2193

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

2158

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

2194

2159

session->unlink_open_table(name_lock);

2195

2160

}

2196

2161

}

2201

2166

{

2202

2167

char warn_buff[DRIZZLE_ERRMSG_SIZE];

2203

2168

snprintf(warn_buff, sizeof(warn_buff),

2204

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

2169

ER(ER_TABLE_EXISTS_ERROR), table->getTableName());

2205

2170

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;

2171

ER_TABLE_EXISTS_ERROR,warn_buff);

2172

res= false;

2173

}

2174

else

2175

{

2176

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table->getTableName());

2177

}

2213

2178

}

2214

2179

2215

return res;

2180

return(res);

2216

2181

}

2217

2182

2218

2183

2219

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

2184

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

2220

2185

{

2221

2186

thr_lock_type lock_type = TL_READ_NO_INSERT;

2222

2187

2223

return(admin_table(session, tables, check_opt,

2188

return(mysql_admin_table(session, tables, check_opt,

2224

2189

"analyze", lock_type, true,

2225

2190

&Cursor::ha_analyze));

2226

2191

}

2227

2192

2228

2193

2229

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

2194

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

2230

2195

{

2231

2196

thr_lock_type lock_type = TL_READ_NO_INSERT;

2232

2197

2233

return(admin_table(session, tables, check_opt,

2198

return(mysql_admin_table(session, tables, check_opt,

2234

2199

"check", lock_type,

2235

2200

false,

2236

2201

&Cursor::ha_check));

Older »