~drizzle-trunk/drizzle/development

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

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

push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

208

ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),

209

table->getTableName());

210

else

211

error= 1;

212

}

213

else

214

{

215

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

216

217

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

218

{

219

error= 0;

220

session->clear_error();

221

}

222

223

if (error == HA_ERR_ROW_IS_REFERENCED)

224

{

225

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

226

foreign_key_error= true;

227

}

228

}

229

230

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

231

{

232

TransactionServices &transaction_services= TransactionServices::singleton();

233

transaction_services.dropTable(session, string(table->getSchemaName()), string(table->getTableName()), if_exists);

234

}

235

236

if (error)

237

{

238

if (wrong_tables.length())

239

wrong_tables.append(',');

240

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

241

}

242

}

243

244

It's safe to unlock table::Cache::singleton().mutex(): we have an exclusive lock

245

on the table name.

246

247

table::Cache::singleton().mutex().unlock();

260

session->clear_error();

261

}

262

263

if (error == HA_ERR_ROW_IS_REFERENCED)

264

{

265

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

266

foreign_key_error= true;

267

}

268

}

269

270

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

271

{

272

TransactionServices &transaction_services= TransactionServices::singleton();

273

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

274

}

275

276

if (error)

277

{

278

if (wrong_tables.length())

279

wrong_tables.append(',');

280

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

281

}

248

282

}

283

284

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

285

on the table name.

286

287

pthread_mutex_unlock(&LOCK_open);

249

288

error= 0;

250

289

251

290

if (wrong_tables.length())

262

301

error= 1;

263

302

}

264

303

265

table::Cache::singleton().mutex().lock(); /* final bit in rm table lock */

304

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

266

305

267

306

err_with_placeholders:

268

tables->unlock_table_names();

269

table::Cache::singleton().mutex().unlock();

307

unlock_table_names(tables, NULL);

308

pthread_mutex_unlock(&LOCK_open);

270

309

session->no_warnings_for_error= 0;

271

310

272

311

return error;

273

312

}

274

313

314

315

316

Quickly remove a table.

317

318

SYNOPSIS

319

quick_rm_table()

320

base The plugin::StorageEngine handle.

321

db The database name.

322

table_name The table name.

323

is_tmp If the table is temp.

324

325

RETURN

326

0 OK

327

!= 0 Error

328

329

bool quick_rm_table(Session& session,

330

TableIdentifier &identifier)

331

{

332

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

333

}

334

275

335

276

336

Sort keys in the following order:

277

337

- PRIMARY KEY

357

417

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

358

418

}

359

419

420

boost::hash<const typelib_set_member> typelib_set_member_hasher;

360

421

361

namespace

362

{

363

class typelib_set_member_hasher

422

static std::size_t hash_value(const typelib_set_member& t)

364

423

{

365

424

boost::hash<string> hasher;

366

public:

367

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

368

{

369

return hasher(t.s);

370

}

371

};

425

return hasher(t.s);

372

426

}

373

427

374

428

static bool check_duplicates_in_interval(const char *set_or_name,

381

435

unsigned int *cur_length= typelib->type_lengths;

382

436

*dup_val_count= 0;

383

437

384

boost::unordered_set<typelib_set_member, typelib_set_member_hasher> interval_set;

438

boost::unordered_set<typelib_set_member, boost::hash<typelib_set_member> > interval_set;

385

439

386

440

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

387

441

{

606

660

607

661

if (sql_field->sql_type == DRIZZLE_TYPE_ENUM)

608

662

{

609

size_t dummy;

663

uint32_t dummy;

610

664

const CHARSET_INFO * const cs= sql_field->charset;

611

665

TYPELIB *interval= sql_field->interval;

612

666

639

693

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

640

694

cs, &dummy))

641

695

{

642

size_t cnv_errs;

696

uint32_t cnv_errs;

643

697

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

644

698

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

645

699

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

681

735

}

682

736

}

683

737

}

684

uint32_t new_dummy;

685

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

738

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

686

739

sql_field->length= field_length;

687

740

}

688

741

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

750

803

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

751

804

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

752

805

((sql_field->flags & BLOB_FLAG) ||

753

(sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)))

806

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

754

807

(*db_options)|= HA_OPTION_PACK_RECORD;

755

808

it2.rewind();

756

809

}

818

871

fk_key_count++;

819

872

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

820

873

return true;

821

822

874

Foreign_key *fk_key= (Foreign_key*) key;

823

824

add_foreign_key_to_table_message(&create_proto,

825

fk_key->name.str,

826

fk_key->columns,

827

fk_key->ref_table,

828

fk_key->ref_columns,

829

fk_key->delete_opt,

830

fk_key->update_opt,

831

fk_key->match_opt);

832

833

875

if (fk_key->ref_columns.elements &&

834

876

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

835

877

{

864

906

key2->name.str != ignore_key &&

865

907

!foreign_key_prefix(key, key2)))

866

908

{

867

/* @todo issue warning message */

909

/* TODO: issue warning message */

868

910

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

869

911

if (!key2->generated ||

870

912

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

1265

1307

}

1266

1308

1267

1309

static bool locked_create_event(Session *session,

1268

const TableIdentifier &identifier,

1310

TableIdentifier &identifier,

1269

1311

HA_CREATE_INFO *create_info,

1270

1312

message::Table &table_proto,

1271

1313

AlterInfo *alter_info,

1300

1342

return error;

1301

1343

}

1302

1344

1303

std::string path;

1304

identifier.getSQLPath(path);

1305

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), path.c_str());

1306

1345

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

1307

1346

return error;

1308

1347

}

1309

1348

1320

1359

1321

1360

@todo improve this error condition.

1322

1361

1323

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

1362

if (TableShare::getShare(identifier))

1324

1363

{

1325

std::string path;

1326

identifier.getSQLPath(path);

1327

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), path.c_str());

1328

1364

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

1329

1365

return error;

1330

1366

}

1331

1367

}

1401

1437

1402

1438

1403

1439

bool mysql_create_table_no_lock(Session *session,

1404

const TableIdentifier &identifier,

1440

TableIdentifier &identifier,

1405

1441

HA_CREATE_INFO *create_info,

1406

1442

message::Table &table_proto,

1407

1443

AlterInfo *alter_info,

1423

1459

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

1424

1460

db_options= create_info->table_options;

1425

1461

1462

if (create_info->row_type == ROW_TYPE_DYNAMIC)

1463

db_options|=HA_OPTION_PACK_RECORD;

1464

1426

1465

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

1427

1466

1428

1467

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

1429

1468

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

1430

internal_tmp_table,

1431

&db_options,

1432

&key_info_buffer, &key_count,

1433

select_field_count))

1469

internal_tmp_table,

1470

&db_options,

1471

&key_info_buffer, &key_count,

1472

select_field_count))

1434

1473

{

1435

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

1474

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

1436

1475

error= locked_create_event(session,

1437

1476

identifier,

1438

1477

create_info,

1442

1481

internal_tmp_table,

1443

1482

db_options, key_count,

1444

1483

key_info_buffer);

1484

pthread_mutex_unlock(&LOCK_open);

1445

1485

}

1446

1486

1447

1487

session->set_proc_info("After create");

1453

1493

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

1454

1494

1455

1495

static bool drizzle_create_table(Session *session,

1456

const TableIdentifier &identifier,

1496

TableIdentifier &identifier,

1457

1497

HA_CREATE_INFO *create_info,

1458

1498

message::Table &table_proto,

1459

1499

AlterInfo *alter_info,

1480

1520

}

1481

1521

else

1482

1522

{

1483

std::string path;

1484

identifier.getSQLPath(path);

1485

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), path.c_str());

1523

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

1486

1524

result= true;

1487

1525

}

1488

1526

}

1500

1538

1501

1539

if (name_lock)

1502

1540

{

1503

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

1541

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

1504

1542

session->unlink_open_table(name_lock);

1543

pthread_mutex_unlock(&LOCK_open);

1505

1544

}

1506

1545

1507

1546

return(result);

1512

1551

Database locking aware wrapper for mysql_create_table_no_lock(),

1513

1552

1514

1553

bool mysql_create_table(Session *session,

1515

const TableIdentifier &identifier,

1554

TableIdentifier &identifier,

1516

1555

HA_CREATE_INFO *create_info,

1517

1556

message::Table &table_proto,

1518

1557

AlterInfo *alter_info,

1593

1632

1594

1633

SYNOPSIS

1595

1634

mysql_rename_table()

1596

session

1597

1635

base The plugin::StorageEngine handle.

1598

1636

old_db The old database name.

1599

1637

old_name The old table name.

1606

1644

1607

1645

1608

1646

bool

1609

mysql_rename_table(Session &session,

1610

plugin::StorageEngine *base,

1611

const TableIdentifier &from,

1612

const TableIdentifier &to)

1647

mysql_rename_table(plugin::StorageEngine *base,

1648

TableIdentifier &from,

1649

TableIdentifier &to)

1613

1650

{

1651

Session *session= current_session;

1614

1652

int error= 0;

1615

1653

1616

1654

assert(base);

1621

1659

return true;

1622

1660

}

1623

1661

1624

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

1662

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

1625

1663

1626

1664

if (error == HA_ERR_WRONG_COMMAND)

1627

1665

{

1629

1667

}

1630

1668

else if (error)

1631

1669

{

1632

std::string from_path;

1633

std::string to_path;

1634

1635

from.getSQLPath(from_path);

1636

to.getSQLPath(to_path);

1637

1638

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

1639

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

1670

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

1671

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

1640

1672

1641

1673

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

1642

1674

}

1660

1692

the table is closed.

1661

1693

1662

1694

PREREQUISITES

1663

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

1695

Lock on LOCK_open

1664

1696

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

1665

1697

1666

1698

1668

1700

enum ha_extra_function function)

1669

1701

{

1670

1702

1671

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

1703

safe_mutex_assert_owner(&LOCK_open);

1672

1704

1673

1705

table->cursor->extra(function);

1674

1706

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

1675

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

1707

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

1676

1708

1677

1709

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

1678

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

1679

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

1710

remove_table_from_cache(session, table->getMutableShare()->getSchemaName(),

1711

table->getMutableShare()->getTableName(),

1712

RTFC_WAIT_OTHER_THREAD_FLAG);

1680

1713

}

1681

1714

1682

1715

1692

1725

reopen the table.

1693

1726

1694

1727

PREREQUISITES

1695

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

1728

Lock on LOCK_open

1696

1729

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

1697

1730

1698

1731

1703

1736

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

1704

1737

if (lock)

1705

1738

{

1706

unlockTables(lock);

1739

mysql_unlock_tables(this, lock);

1707

1740

lock= NULL; // Start locked threads

1708

1741

}

1709

1742

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

1710

1743

unlink_open_table(table);

1711

1744

1712

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

1713

locking::broadcast_refresh();

1745

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

1746

broadcast_refresh();

1714

1747

}

1715

1748

1716

1749

1754

1787

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

1755

1788

{

1756

1789

char table_name[NAME_LEN*2+2];

1790

char* db = table->db;

1757

1791

bool fatal_error=0;

1758

1792

1759

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

1793

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

1760

1794

table->lock_type= lock_type;

1761

1795

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

1762

1796

{

1769

1803

1770

1804

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

1771

1805

so it have to be prepared.

1772

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

1806

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

1807

using lex->query_tables

1773

1808

1774

1809

lex->query_tables= table;

1775

1810

lex->query_tables_last= &table->next_global;

1820

1855

}

1821

1856

1822

1857

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

1823

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

1858

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

1824

1859

{

1825

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

1826

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

1827

"Waiting to get writelock");

1828

session->abortLock(table->table);

1829

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

1830

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

1860

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

1861

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

1862

"Waiting to get writelock");

1863

mysql_lock_abort(session,table->table);

1864

remove_table_from_cache(session, table->table->getMutableShare()->getSchemaName(),

1865

table->table->getMutableShare()->getTableName(),

1866

RTFC_WAIT_OTHER_THREAD_FLAG |

1867

RTFC_CHECK_KILLED_FLAG);

1831

1868

session->exit_cond(old_message);

1832

if (session->getKilled())

1869

if (session->killed)

1833

1870

goto err;

1834

1871

open_for_modify= 0;

1835

1872

}

1916

1953

if (table->table)

1917

1954

{

1918

1955

if (fatal_error)

1919

{

1920

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

1921

}

1956

table->table->getMutableShare()->version=0; // Force close of table

1922

1957

else if (open_for_modify)

1923

1958

{

1924

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

1925

{

1959

if (table->table->getShare()->tmp_table)

1926

1960

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

1927

}

1928

1961

else

1929

1962

{

1930

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

1931

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

1932

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

1963

pthread_mutex_lock(&LOCK_open);

1964

remove_table_from_cache(session, table->table->getMutableShare()->getSchemaName(),

1965

table->table->getMutableShare()->getTableName(), RTFC_NO_FLAG);

1966

pthread_mutex_unlock(&LOCK_open);

1933

1967

}

1934

1968

}

1935

1969

}

1953

1987

return(true);

1954

1988

}

1955

1989

1990

1991

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

1992

1993

Since temporary tables are not replicated under row-based

1994

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

1995

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

1996

following decision table:

1997

1998

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

1999

Case Target Source Write to binary log

2000

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

2001

1 normal normal Original statement

2002

2 normal temporary Generated statement

2003

3 temporary normal Nothing

2004

4 temporary temporary Nothing

2005

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

2006

2007

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

2008

bool is_src_table_tmp, bool is_if_not_exists)

2009

{

2010

if (is_src_table_tmp)

2011

{

2012

char buf[2048];

2013

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

2014

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

2015

2016

2017

2018

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

2019

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

2020

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

2021

of this function.

2022

2023

table->table= name_lock;

2024

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

2025

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

2026

{

2027

pthread_mutex_unlock(&LOCK_open);

2028

return false;

2029

}

2030

pthread_mutex_unlock(&LOCK_open);

2031

2032

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

2033

2034

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

2035

write_bin_log(session, query.ptr());

2036

}

2037

else // Case 1

2038

{

2039

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

2040

}

2041

2042

return true;

2043

}

2044

1956

2045

1957

2046

Create a new table by copying from source table

1958

2047

1959

2048

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

1960

2049

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

1961

2050

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

1962

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

2051

LOCK_open in order to provide minimal atomicity against operations which

1963

2052

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

1964

2053

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

1965

2054

always honor name-locks.

1966

2055

1967

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

2056

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

1968

2057

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

1969

2058

See bug #28614 for more info.

1970

2059

1971

2060

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

1972

const TableIdentifier &destination_identifier,

1973

const TableIdentifier &src_table,

2061

TableIdentifier &destination_identifier,

2062

TableIdentifier &src_table,

1974

2063

bool is_engine_set)

1975

2064

{

1976

2065

int protoerr= EEXIST;

1977

2066

message::Table new_proto;

1978

message::table::shared_ptr src_proto;

2067

message::Table src_proto;

1979

2068

1980

2069

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

1981

2070

src_table,

1982

2071

src_proto);

1983

new_proto.CopyFrom(*src_proto);

2072

new_proto.CopyFrom(src_proto);

1984

2073

1985

2074

if (destination_identifier.isTmp())

1986

2075

{

2021

2110

destination_identifier,

2022

2111

new_proto);

2023

2112

2024

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

2025

{

2026

TransactionServices &transaction_services= TransactionServices::singleton();

2027

transaction_services.createTable(&session, new_proto);

2028

}

2029

2030

2113

return err ? false : true;

2031

2114

}

2032

2115

2046

2129

2047

2130

2048

2131

bool mysql_create_like_table(Session* session,

2049

const TableIdentifier &destination_identifier,

2132

TableIdentifier &destination_identifier,

2050

2133

TableList* table, TableList* src_table,

2051

2134

message::Table &create_table_proto,

2052

2135

bool is_if_not_exists,

2053

2136

bool is_engine_set)

2054

2137

{

2138

char *db= table->db;

2139

char *table_name= table->table_name;

2055

2140

bool res= true;

2056

2141

uint32_t not_used;

2057

2142

2067

2152

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

2068

2153

return true;

2069

2154

2070

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

2071

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

2155

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

2156

src_table->table->getMutableShare()->getTableName(), src_table->table->getMutableShare()->tmp_table);

2072

2157

2073

2158

2074

2159

2081

2166

bool table_exists= false;

2082

2167

if (destination_identifier.isTmp())

2083

2168

{

2084

if (session->find_temporary_table(destination_identifier))

2169

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

2085

2170

{

2086

2171

table_exists= true;

2087

2172

}

2088

2173

else

2089

2174

{

2090

2175

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

2091

src_identifier, is_engine_set);

2176

src_identifier, is_engine_set);

2092

2177

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

2093

2178

{

2094

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

2179

(void) session->rm_temporary_table(destination_identifier);

2095

2180

}

2096

2181

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

2097

2182

{

2098

2183

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

2099

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

2184

(void) session->rm_temporary_table(destination_identifier);

2100

2185

}

2101

2186

else

2102

2187

{

2108

2193

{

2109

2194

Table *name_lock= 0;

2110

2195

2111

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

2196

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

2112

2197

{

2113

2198

if (name_lock)

2114

2199

{

2115

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

2200

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

2116

2201

session->unlink_open_table(name_lock);

2202

pthread_mutex_unlock(&LOCK_open);

2117

2203

}

2118

2204

2119

2205

return res;

2129

2215

}

2130

2216

else // Otherwise we create the table

2131

2217

{

2132

bool was_created;

2133

{

2134

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

2135

was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,

2136

src_identifier, is_engine_set);

2137

}

2218

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

2219

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

2220

src_identifier, is_engine_set);

2221

pthread_mutex_unlock(&LOCK_open);

2138

2222

2139

2223

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

2140

2224

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

2141

2225

if (not was_created)

2142

2226

{

2143

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

2227

quick_rm_table(*session, destination_identifier);

2144

2228

}

2145

2229

else

2146

2230

{

2231

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

2232

(void)rc;

2233

2147

2234

res= false;

2148

2235

}

2149

2236

}

2150

2237

2151

2238

if (name_lock)

2152

2239

{

2153

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

2240

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

2154

2241

session->unlink_open_table(name_lock);

2242

pthread_mutex_unlock(&LOCK_open);

2155

2243

}

2156

2244

}

2157

2245

2161

2249

{

2162

2250

char warn_buff[DRIZZLE_ERRMSG_SIZE];

2163

2251

snprintf(warn_buff, sizeof(warn_buff),

2164

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

2252

ER(ER_TABLE_EXISTS_ERROR), table_name);

2165

2253

push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

2166

2254

ER_TABLE_EXISTS_ERROR,warn_buff);

2167

2255

res= false;

2168

2256

}

2169

2257

else

2170

2258

{

2171

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

2259

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

2172

2260

}

2173

2261

}

2174

2262

Older »